id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
35,222
|
testmathutil.cpp
|
OpenMW_openmw/apps/components_tests/misc/testmathutil.cpp
|
#include <components/misc/mathutil.hpp>
#include <osg/io_utils>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <iomanip>
#include <limits>
MATCHER_P2(Vec3fEq, other, precision, "")
{
return std::abs(arg.x() - other.x()) < precision && std::abs(arg.y() - other.y()) < precision
&& std::abs(arg.z() - other.z()) < precision;
}
namespace testing
{
template <>
inline testing::Message& Message::operator<<(const osg::Vec3f& value)
{
return (*this) << std::setprecision(std::numeric_limits<float>::max_exponent10) << "osg::Vec3f(" << value.x()
<< ", " << value.y() << ", " << value.z() << ')';
}
template <>
inline testing::Message& Message::operator<<(const osg::Quat& value)
{
return (*this) << std::setprecision(std::numeric_limits<float>::max_exponent10) << "osg::Quat(" << value.x()
<< ", " << value.y() << ", " << value.z() << ", " << value.w() << ')';
}
}
namespace Misc
{
namespace
{
using namespace testing;
struct MiscToEulerAnglesXZQuatTest : TestWithParam<std::pair<osg::Quat, osg::Vec3f>>
{
};
TEST_P(MiscToEulerAnglesXZQuatTest, shouldReturnValueCloseTo)
{
const osg::Vec3f result = toEulerAnglesXZ(GetParam().first);
EXPECT_THAT(result, Vec3fEq(GetParam().second, 1e-6))
<< "toEulerAnglesXZ(" << GetParam().first << ") = " << result;
}
const std::pair<osg::Quat, osg::Vec3f> eulerAnglesXZQuat[] = {
{
osg::Quat(1, 0, 0, 0),
osg::Vec3f(0, 0, osg::PI),
},
{
osg::Quat(0, 1, 0, 0),
osg::Vec3f(0, 0, 0),
},
{
osg::Quat(0, 0, 1, 0),
osg::Vec3f(0, 0, osg::PI),
},
{
osg::Quat(0, 0, 0, 1),
osg::Vec3f(0, 0, 0),
},
{
osg::Quat(-0.5, -0.5, -0.5, -0.5),
osg::Vec3f(-osg::PI_2f, 0, 0),
},
{
osg::Quat(0.5, -0.5, -0.5, -0.5),
osg::Vec3f(0, 0, -osg::PI_2f),
},
{
osg::Quat(0.5, 0.5, -0.5, -0.5),
osg::Vec3f(osg::PI_2f, 0, 0),
},
{
osg::Quat(0.5, 0.5, 0.5, -0.5),
osg::Vec3f(0, 0, osg::PI_2f),
},
{
osg::Quat(0.5, 0.5, 0.5, 0.5),
osg::Vec3f(-osg::PI_2f, 0, 0),
},
{
// normalized osg::Quat(0.1, 0.2, 0.3, 0.4)
osg::Quat(0.18257418583505536, 0.36514837167011072, 0.54772255750516607, 0.73029674334022143),
osg::Vec3f(-0.72972762584686279296875f, 0, -1.10714876651763916015625f),
},
{
osg::Quat(-0.18257418583505536, 0.36514837167011072, 0.54772255750516607, 0.73029674334022143),
osg::Vec3f(-0.13373161852359771728515625f, 0, -1.2277724742889404296875f),
},
{
osg::Quat(0.18257418583505536, -0.36514837167011072, 0.54772255750516607, 0.73029674334022143),
osg::Vec3f(0.13373161852359771728515625f, 0, -1.2277724742889404296875f),
},
{
osg::Quat(0.18257418583505536, 0.36514837167011072, -0.54772255750516607, 0.73029674334022143),
osg::Vec3f(0.13373161852359771728515625f, 0, 1.2277724742889404296875f),
},
{
osg::Quat(0.18257418583505536, 0.36514837167011072, 0.54772255750516607, -0.73029674334022143),
osg::Vec3f(-0.13373161852359771728515625, 0, 1.2277724742889404296875f),
},
{
osg::Quat(0.246736, -0.662657, -0.662667, 0.246739),
osg::Vec3f(-osg::PI_2f, 0, 2.5199801921844482421875f),
},
};
INSTANTIATE_TEST_SUITE_P(FromQuat, MiscToEulerAnglesXZQuatTest, ValuesIn(eulerAnglesXZQuat));
struct MiscToEulerAnglesZYXQuatTest : TestWithParam<std::pair<osg::Quat, osg::Vec3f>>
{
};
TEST_P(MiscToEulerAnglesZYXQuatTest, shouldReturnValueCloseTo)
{
const osg::Vec3f result = toEulerAnglesZYX(GetParam().first);
EXPECT_THAT(result, Vec3fEq(GetParam().second, std::numeric_limits<float>::epsilon()))
<< "toEulerAnglesZYX(" << GetParam().first << ") = " << result;
}
const std::pair<osg::Quat, osg::Vec3f> eulerAnglesZYXQuat[] = {
{
osg::Quat(1, 0, 0, 0),
osg::Vec3f(osg::PI, 0, 0),
},
{
osg::Quat(0, 1, 0, 0),
osg::Vec3f(osg::PI, 0, osg::PI),
},
{
osg::Quat(0, 0, 1, 0),
osg::Vec3f(0, 0, osg::PI),
},
{
osg::Quat(0, 0, 0, 1),
osg::Vec3f(0, 0, 0),
},
{
osg::Quat(-0.5, -0.5, -0.5, -0.5),
osg::Vec3f(0, -osg::PI_2f, -osg::PI_2f),
},
{
osg::Quat(0.5, -0.5, -0.5, -0.5),
osg::Vec3f(osg::PI_2f, 0, -osg::PI_2f),
},
{
osg::Quat(0.5, 0.5, -0.5, -0.5),
osg::Vec3f(0, osg::PI_2f, -osg::PI_2f),
},
{
osg::Quat(0.5, 0.5, 0.5, -0.5),
osg::Vec3f(osg::PI_2f, 0, osg::PI_2f),
},
{
osg::Quat(0.5, 0.5, 0.5, 0.5),
osg::Vec3f(0, -osg::PI_2f, -osg::PI_2f),
},
{
// normalized osg::Quat(0.1, 0.2, 0.3, 0.4)
osg::Quat(0.18257418583505536, 0.36514837167011072, 0.54772255750516607, 0.73029674334022143),
osg::Vec3f(0.1973955929279327392578125f, -0.8232119083404541015625f, -1.37340080738067626953125f),
},
{
osg::Quat(-0.18257418583505536, 0.36514837167011072, 0.54772255750516607, 0.73029674334022143),
osg::Vec3f(0.78539812564849853515625f, -0.339836895465850830078125f, -1.428899288177490234375f),
},
{
osg::Quat(0.18257418583505536, -0.36514837167011072, 0.54772255750516607, 0.73029674334022143),
osg::Vec3f(-0.78539812564849853515625f, 0.339836895465850830078125f, -1.428899288177490234375f),
},
{
osg::Quat(0.18257418583505536, 0.36514837167011072, -0.54772255750516607, 0.73029674334022143),
osg::Vec3f(-0.78539812564849853515625f, -0.339836895465850830078125f, 1.428899288177490234375f),
},
{
osg::Quat(0.18257418583505536, 0.36514837167011072, 0.54772255750516607, -0.73029674334022143),
osg::Vec3f(0.78539812564849853515625f, 0.339836895465850830078125f, 1.428899288177490234375f),
},
{
osg::Quat(0.246736, -0.662657, 0.246739, -0.662667),
osg::Vec3f(0.06586204469203948974609375f, -osg::PI_2f, 0.64701664447784423828125f),
},
};
INSTANTIATE_TEST_SUITE_P(FromQuat, MiscToEulerAnglesZYXQuatTest, ValuesIn(eulerAnglesZYXQuat));
}
}
| 7,399
|
C++
|
.cpp
| 179
| 28.731844
| 117
| 0.504094
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,223
|
compression.cpp
|
OpenMW_openmw/apps/components_tests/misc/compression.cpp
|
#include <components/misc/compression.hpp>
#include <gtest/gtest.h>
#include <algorithm>
#include <cstdlib>
#include <cstring>
namespace
{
using namespace testing;
using namespace Misc;
TEST(MiscCompressionTest, compressShouldAddPrefixWithDataSize)
{
const std::vector<std::byte> data(1234);
const std::vector<std::byte> compressed = compress(data);
int size = 0;
std::memcpy(&size, compressed.data(), sizeof(size));
EXPECT_EQ(size, data.size());
}
TEST(MiscCompressionTest, decompressIsInverseToCompress)
{
const std::vector<std::byte> data(1024);
const std::vector<std::byte> compressed = compress(data);
EXPECT_LT(compressed.size(), data.size());
const std::vector<std::byte> decompressed = decompress(compressed);
EXPECT_EQ(decompressed, data);
}
}
| 870
|
C++
|
.cpp
| 26
| 27.961538
| 75
| 0.680572
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,224
|
progressreporter.cpp
|
OpenMW_openmw/apps/components_tests/misc/progressreporter.cpp
|
#include <components/misc/progressreporter.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <chrono>
namespace
{
using namespace testing;
using namespace Misc;
struct ReportMock
{
MOCK_METHOD(void, call, (std::size_t, std::size_t), ());
};
struct Report
{
StrictMock<ReportMock>* mImpl;
void operator()(std::size_t provided, std::size_t expected) { mImpl->call(provided, expected); }
};
TEST(MiscProgressReporterTest, shouldCallReportWhenPassedInterval)
{
StrictMock<ReportMock> report;
EXPECT_CALL(report, call(13, 42)).WillOnce(Return());
ProgressReporter reporter(std::chrono::steady_clock::duration(0), Report{ &report });
reporter(13, 42);
}
TEST(MiscProgressReporterTest, shouldNotCallReportWhenIntervalIsNotPassed)
{
StrictMock<ReportMock> report;
EXPECT_CALL(report, call(13, 42)).Times(0);
ProgressReporter reporter(std::chrono::seconds(1000), Report{ &report });
reporter(13, 42);
}
}
| 1,062
|
C++
|
.cpp
| 32
| 27.4375
| 104
| 0.675147
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,225
|
test_resourcehelpers.cpp
|
OpenMW_openmw/apps/components_tests/misc/test_resourcehelpers.cpp
|
#include <components/misc/resourcehelpers.hpp>
#include <components/testing/util.hpp>
#include <gtest/gtest.h>
namespace
{
using namespace Misc::ResourceHelpers;
TEST(CorrectSoundPath, wav_files_not_overridden_with_mp3_in_vfs_are_not_corrected)
{
constexpr VFS::Path::NormalizedView path("sound/bar.wav");
std::unique_ptr<VFS::Manager> mVFS = TestingOpenMW::createTestVFS({ { path, nullptr } });
EXPECT_EQ(correctSoundPath(path, *mVFS), "sound/bar.wav");
}
TEST(CorrectSoundPath, wav_files_overridden_with_mp3_in_vfs_are_corrected)
{
constexpr VFS::Path::NormalizedView mp3("sound/foo.mp3");
std::unique_ptr<VFS::Manager> mVFS = TestingOpenMW::createTestVFS({ { mp3, nullptr } });
constexpr VFS::Path::NormalizedView wav("sound/foo.wav");
EXPECT_EQ(correctSoundPath(wav, *mVFS), "sound/foo.mp3");
}
TEST(CorrectSoundPath, corrected_path_does_not_check_existence_in_vfs)
{
std::unique_ptr<VFS::Manager> mVFS = TestingOpenMW::createTestVFS({});
constexpr VFS::Path::NormalizedView path("sound/foo.wav");
EXPECT_EQ(correctSoundPath(path, *mVFS), "sound/foo.mp3");
}
namespace
{
std::string checkChangeExtensionToDds(std::string path)
{
changeExtensionToDds(path);
return path;
}
}
TEST(ChangeExtensionToDds, original_extension_with_same_size_as_dds)
{
EXPECT_EQ(checkChangeExtensionToDds("texture/bar.tga"), "texture/bar.dds");
}
TEST(ChangeExtensionToDds, original_extension_greater_than_dds)
{
EXPECT_EQ(checkChangeExtensionToDds("texture/bar.jpeg"), "texture/bar.dds");
}
TEST(ChangeExtensionToDds, original_extension_smaller_than_dds)
{
EXPECT_EQ(checkChangeExtensionToDds("texture/bar.xx"), "texture/bar.dds");
}
TEST(ChangeExtensionToDds, does_not_change_dds_extension)
{
std::string path = "texture/bar.dds";
EXPECT_FALSE(changeExtensionToDds(path));
}
TEST(ChangeExtensionToDds, does_not_change_when_no_extension)
{
std::string path = "texture/bar";
EXPECT_FALSE(changeExtensionToDds(path));
}
TEST(ChangeExtensionToDds, change_when_there_is_an_extension)
{
std::string path = "texture/bar.jpeg";
EXPECT_TRUE(changeExtensionToDds(path));
}
}
| 2,382
|
C++
|
.cpp
| 61
| 32.557377
| 97
| 0.679654
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,226
|
record.cpp
|
OpenMW_openmw/apps/components_tests/esmloader/record.cpp
|
#include <components/esmloader/record.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <array>
#include <tuple>
namespace
{
using namespace testing;
using namespace EsmLoader;
struct Value
{
int mKey;
int mValue;
};
auto tie(const Value& v)
{
return std::tie(v.mKey, v.mValue);
}
bool operator==(const Value& l, const Value& r)
{
return tie(l) == tie(r);
}
std::ostream& operator<<(std::ostream& s, const Value& v)
{
return s << "Value {" << v.mKey << ", " << v.mValue << "}";
}
Record<Value> present(const Value& v)
{
return Record<Value>(false, v);
}
Record<Value> deleted(const Value& v)
{
return Record<Value>(true, v);
}
struct Params
{
Records<Value> mRecords;
std::vector<Value> mResult;
};
struct EsmLoaderPrepareRecordTest : TestWithParam<Params>
{
};
TEST_P(EsmLoaderPrepareRecordTest, prepareRecords)
{
auto records = GetParam().mRecords;
const auto getKey = [&](const Record<Value>& v) { return v.mValue.mKey; };
EXPECT_THAT(prepareRecords(records, getKey), ElementsAreArray(GetParam().mResult));
}
const std::array params = {
Params{ {}, {} },
Params{ { present(Value{ 1, 1 }) }, { Value{ 1, 1 } } },
Params{ { deleted(Value{ 1, 1 }) }, {} },
Params{ { present(Value{ 1, 1 }), present(Value{ 2, 2 }) }, { Value{ 1, 1 }, Value{ 2, 2 } } },
Params{ { present(Value{ 2, 2 }), present(Value{ 1, 1 }) }, { Value{ 1, 1 }, Value{ 2, 2 } } },
Params{ { present(Value{ 1, 1 }), present(Value{ 1, 2 }) }, { Value{ 1, 2 } } },
Params{ { present(Value{ 1, 2 }), present(Value{ 1, 1 }) }, { Value{ 1, 1 } } },
Params{ { present(Value{ 1, 1 }), deleted(Value{ 1, 2 }) }, {} },
Params{ { deleted(Value{ 1, 1 }), present(Value{ 1, 2 }) }, { Value{ 1, 2 } } },
Params{ { present(Value{ 1, 2 }), deleted(Value{ 1, 1 }) }, {} },
Params{ { deleted(Value{ 1, 2 }), present(Value{ 1, 1 }) }, { Value{ 1, 1 } } },
};
INSTANTIATE_TEST_SUITE_P(Params, EsmLoaderPrepareRecordTest, ValuesIn(params));
}
| 2,230
|
C++
|
.cpp
| 63
| 29.222222
| 103
| 0.553646
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,227
|
esmdata.cpp
|
OpenMW_openmw/apps/components_tests/esmloader/esmdata.cpp
|
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadland.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/variant.hpp>
#include <components/esmloader/esmdata.hpp>
#include <gtest/gtest.h>
#include <array>
#include <functional>
#include <string>
#include <vector>
namespace
{
using namespace testing;
using namespace EsmLoader;
struct Params
{
std::string mRefId;
ESM::RecNameInts mType;
std::string mResult;
std::function<void(EsmData&)> mPushBack;
};
struct EsmLoaderGetModelTest : TestWithParam<Params>
{
};
TEST_P(EsmLoaderGetModelTest, shouldReturnFoundModelName)
{
EsmData data;
GetParam().mPushBack(data);
EXPECT_EQ(EsmLoader::getModel(data, ESM::RefId::stringRefId(GetParam().mRefId), GetParam().mType),
GetParam().mResult);
}
void pushBack(ESM::Activator&& value, EsmData& esmData)
{
esmData.mActivators.push_back(std::move(value));
}
void pushBack(ESM::Container&& value, EsmData& esmData)
{
esmData.mContainers.push_back(std::move(value));
}
void pushBack(ESM::Door&& value, EsmData& esmData)
{
esmData.mDoors.push_back(std::move(value));
}
void pushBack(ESM::Static&& value, EsmData& esmData)
{
esmData.mStatics.push_back(std::move(value));
}
template <class T>
struct PushBack
{
std::string mId;
std::string mModel;
void operator()(EsmData& esmData) const
{
T value;
value.mId = ESM::RefId::stringRefId(mId);
value.mModel = mModel;
pushBack(std::move(value), esmData);
}
};
const std::array params = {
Params{ "acti_ref_id", ESM::REC_ACTI, "acti_model", PushBack<ESM::Activator>{ "acti_ref_id", "acti_model" } },
Params{ "cont_ref_id", ESM::REC_CONT, "cont_model", PushBack<ESM::Container>{ "cont_ref_id", "cont_model" } },
Params{ "door_ref_id", ESM::REC_DOOR, "door_model", PushBack<ESM::Door>{ "door_ref_id", "door_model" } },
Params{
"static_ref_id", ESM::REC_STAT, "static_model", PushBack<ESM::Static>{ "static_ref_id", "static_model" } },
Params{ "acti_ref_id_a", ESM::REC_ACTI, "", PushBack<ESM::Activator>{ "acti_ref_id_z", "acti_model" } },
Params{ "cont_ref_id_a", ESM::REC_CONT, "", PushBack<ESM::Container>{ "cont_ref_id_z", "cont_model" } },
Params{ "door_ref_id_a", ESM::REC_DOOR, "", PushBack<ESM::Door>{ "door_ref_id_z", "door_model" } },
Params{ "static_ref_id_a", ESM::REC_STAT, "", PushBack<ESM::Static>{ "static_ref_id_z", "static_model" } },
Params{ "acti_ref_id_z", ESM::REC_ACTI, "", PushBack<ESM::Activator>{ "acti_ref_id_a", "acti_model" } },
Params{ "cont_ref_id_z", ESM::REC_CONT, "", PushBack<ESM::Container>{ "cont_ref_id_a", "cont_model" } },
Params{ "door_ref_id_z", ESM::REC_DOOR, "", PushBack<ESM::Door>{ "door_ref_id_a", "door_model" } },
Params{ "static_ref_id_z", ESM::REC_STAT, "", PushBack<ESM::Static>{ "static_ref_id_a", "static_model" } },
Params{ "ref_id", ESM::REC_STAT, "", [](EsmData&) {} },
Params{ "ref_id", ESM::REC_BOOK, "", [](EsmData&) {} },
};
INSTANTIATE_TEST_SUITE_P(Params, EsmLoaderGetModelTest, ValuesIn(params));
TEST(EsmLoaderGetGameSettingTest, shouldReturnFoundValue)
{
std::vector<ESM::GameSetting> settings;
ESM::GameSetting setting;
setting.mId = ESM::RefId::stringRefId("setting");
setting.mValue = ESM::Variant(42);
setting.mRecordFlags = 0;
settings.push_back(setting);
EXPECT_EQ(EsmLoader::getGameSetting(settings, "setting"), ESM::Variant(42));
}
TEST(EsmLoaderGetGameSettingTest, shouldThrowExceptionWhenNotFound)
{
const std::vector<ESM::GameSetting> settings;
EXPECT_THROW(EsmLoader::getGameSetting(settings, "setting"), std::runtime_error);
}
}
| 4,175
|
C++
|
.cpp
| 98
| 36.05102
| 119
| 0.63408
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,228
|
load.cpp
|
OpenMW_openmw/apps/components_tests/esmloader/load.cpp
|
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadland.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/readerscache.hpp>
#include <components/esmloader/esmdata.hpp>
#include <components/esmloader/load.hpp>
#include <components/files/collections.hpp>
#include <components/files/multidircollection.hpp>
#include <components/to_utf8/to_utf8.hpp>
#include <gtest/gtest.h>
#ifndef OPENMW_DATA_DIR
#error "OPENMW_DATA_DIR is not defined"
#endif
namespace
{
using namespace testing;
using namespace EsmLoader;
struct EsmLoaderTest : Test
{
const Files::PathContainer mDataDirs{ { std::filesystem::path{ OPENMW_DATA_DIR } } };
const Files::Collections mFileCollections{ mDataDirs };
const std::vector<std::string> mContentFiles{ { "template.omwgame" } };
};
TEST_F(EsmLoaderTest, loadEsmDataShouldSupportOmwgame)
{
Query query;
query.mLoadActivators = true;
query.mLoadCells = true;
query.mLoadContainers = true;
query.mLoadDoors = true;
query.mLoadGameSettings = true;
query.mLoadLands = true;
query.mLoadStatics = true;
ESM::ReadersCache readers;
ToUTF8::Utf8Encoder* const encoder = nullptr;
const EsmData esmData = loadEsmData(query, mContentFiles, mFileCollections, readers, encoder);
EXPECT_EQ(esmData.mActivators.size(), 0);
EXPECT_EQ(esmData.mCells.size(), 1);
EXPECT_EQ(esmData.mContainers.size(), 0);
EXPECT_EQ(esmData.mDoors.size(), 0);
EXPECT_EQ(esmData.mGameSettings.size(), 1521);
EXPECT_EQ(esmData.mLands.size(), 1);
EXPECT_EQ(esmData.mStatics.size(), 2);
}
TEST_F(EsmLoaderTest, shouldIgnoreCellsWhenQueryLoadCellsIsFalse)
{
Query query;
query.mLoadActivators = true;
query.mLoadCells = false;
query.mLoadContainers = true;
query.mLoadDoors = true;
query.mLoadGameSettings = true;
query.mLoadLands = true;
query.mLoadStatics = true;
ESM::ReadersCache readers;
ToUTF8::Utf8Encoder* const encoder = nullptr;
const EsmData esmData = loadEsmData(query, mContentFiles, mFileCollections, readers, encoder);
EXPECT_EQ(esmData.mActivators.size(), 0);
EXPECT_EQ(esmData.mCells.size(), 0);
EXPECT_EQ(esmData.mContainers.size(), 0);
EXPECT_EQ(esmData.mDoors.size(), 0);
EXPECT_EQ(esmData.mGameSettings.size(), 1521);
EXPECT_EQ(esmData.mLands.size(), 1);
EXPECT_EQ(esmData.mStatics.size(), 2);
}
TEST_F(EsmLoaderTest, shouldIgnoreCellsGameSettingsWhenQueryLoadGameSettingsIsFalse)
{
Query query;
query.mLoadActivators = true;
query.mLoadCells = true;
query.mLoadContainers = true;
query.mLoadDoors = true;
query.mLoadGameSettings = false;
query.mLoadLands = true;
query.mLoadStatics = true;
ESM::ReadersCache readers;
ToUTF8::Utf8Encoder* const encoder = nullptr;
const EsmData esmData = loadEsmData(query, mContentFiles, mFileCollections, readers, encoder);
EXPECT_EQ(esmData.mActivators.size(), 0);
EXPECT_EQ(esmData.mCells.size(), 1);
EXPECT_EQ(esmData.mContainers.size(), 0);
EXPECT_EQ(esmData.mDoors.size(), 0);
EXPECT_EQ(esmData.mGameSettings.size(), 0);
EXPECT_EQ(esmData.mLands.size(), 1);
EXPECT_EQ(esmData.mStatics.size(), 2);
}
TEST_F(EsmLoaderTest, shouldIgnoreAllWithDefaultQuery)
{
const Query query;
ESM::ReadersCache readers;
ToUTF8::Utf8Encoder* const encoder = nullptr;
const EsmData esmData = loadEsmData(query, mContentFiles, mFileCollections, readers, encoder);
EXPECT_EQ(esmData.mActivators.size(), 0);
EXPECT_EQ(esmData.mCells.size(), 0);
EXPECT_EQ(esmData.mContainers.size(), 0);
EXPECT_EQ(esmData.mDoors.size(), 0);
EXPECT_EQ(esmData.mGameSettings.size(), 0);
EXPECT_EQ(esmData.mLands.size(), 0);
EXPECT_EQ(esmData.mStatics.size(), 0);
}
TEST_F(EsmLoaderTest, loadEsmDataShouldSkipUnsupportedFormats)
{
Query query;
query.mLoadActivators = true;
query.mLoadCells = true;
query.mLoadContainers = true;
query.mLoadDoors = true;
query.mLoadGameSettings = true;
query.mLoadLands = true;
query.mLoadStatics = true;
const std::vector<std::string> contentFiles{ { "script.omwscripts" } };
ESM::ReadersCache readers;
ToUTF8::Utf8Encoder* const encoder = nullptr;
const EsmData esmData = loadEsmData(query, contentFiles, mFileCollections, readers, encoder);
EXPECT_EQ(esmData.mActivators.size(), 0);
EXPECT_EQ(esmData.mCells.size(), 0);
EXPECT_EQ(esmData.mContainers.size(), 0);
EXPECT_EQ(esmData.mDoors.size(), 0);
EXPECT_EQ(esmData.mGameSettings.size(), 0);
EXPECT_EQ(esmData.mLands.size(), 0);
EXPECT_EQ(esmData.mStatics.size(), 0);
}
}
| 5,240
|
C++
|
.cpp
| 127
| 34.07874
| 102
| 0.675353
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,229
|
testobjectcache.cpp
|
OpenMW_openmw/apps/components_tests/resource/testobjectcache.cpp
|
#include <components/resource/objectcache.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <osg/Object>
namespace Resource
{
namespace
{
using namespace ::testing;
TEST(ResourceGenericObjectCacheTest, getRefFromObjectCacheShouldReturnNullptrByDefault)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
EXPECT_EQ(cache->getRefFromObjectCache(42), nullptr);
}
TEST(ResourceGenericObjectCacheTest, getRefFromObjectCacheOrNoneShouldReturnNulloptByDefault)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(42), std::nullopt);
}
struct Object : osg::Object
{
Object() = default;
Object(const Object& other, const osg::CopyOp& copyOp = osg::CopyOp())
: osg::Object(other, copyOp)
{
}
META_Object(ResourceTest, Object)
};
TEST(ResourceGenericObjectCacheTest, shouldStoreValues)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const int key = 42;
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
EXPECT_EQ(cache->getRefFromObjectCache(key), value);
}
TEST(ResourceGenericObjectCacheTest, shouldStoreNullptrValues)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const int key = 42;
cache->addEntryToObjectCache(key, nullptr);
EXPECT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(nullptr));
}
TEST(ResourceGenericObjectCacheTest, updateShouldExtendLifetimeForItemsWithZeroTimestamp)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const int key = 42;
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value, 0);
value = nullptr;
const double referenceTime = 1000;
const double expiryDelay = 1;
cache->update(referenceTime, expiryDelay);
EXPECT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
}
TEST(ResourceGenericObjectCacheTest, addEntryToObjectCacheShouldReplaceExistingItemByKey)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const int key = 42;
osg::ref_ptr<Object> value1(new Object);
osg::ref_ptr<Object> value2(new Object);
cache->addEntryToObjectCache(key, value1);
ASSERT_EQ(cache->getRefFromObjectCache(key), value1);
cache->addEntryToObjectCache(key, value2);
EXPECT_EQ(cache->getRefFromObjectCache(key), value2);
}
TEST(ResourceGenericObjectCacheTest, addEntryToObjectCacheShouldMarkLifetime)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const double referenceTime = 1;
const double expiryDelay = 2;
const int key = 42;
cache->addEntryToObjectCache(key, nullptr, referenceTime + expiryDelay);
cache->update(referenceTime, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
cache->update(referenceTime + expiryDelay, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
cache->update(referenceTime + 2 * expiryDelay, expiryDelay);
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(key), std::nullopt);
}
TEST(ResourceGenericObjectCacheTest, updateShouldRemoveExpiredItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const double referenceTime = 1;
const double expiryDelay = 1;
const int key = 42;
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
value = nullptr;
cache->update(referenceTime, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
ASSERT_EQ(cache->getStats().mExpired, 0);
cache->update(referenceTime + expiryDelay, expiryDelay);
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(key), std::nullopt);
ASSERT_EQ(cache->getStats().mExpired, 1);
}
TEST(ResourceGenericObjectCacheTest, updateShouldKeepExternallyReferencedItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const double referenceTime = 1;
const double expiryDelay = 1;
const int key = 42;
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
cache->update(referenceTime, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
cache->update(referenceTime + expiryDelay, expiryDelay);
EXPECT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(value));
}
TEST(ResourceGenericObjectCacheTest, updateShouldKeepNotExpiredItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const double referenceTime = 1;
const double expiryDelay = 2;
const int key = 42;
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
value = nullptr;
cache->update(referenceTime + expiryDelay, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
cache->update(referenceTime + expiryDelay / 2, expiryDelay);
EXPECT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
}
TEST(ResourceGenericObjectCacheTest, updateShouldKeepNotExpiredNullptrItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const double referenceTime = 1;
const double expiryDelay = 2;
const int key = 42;
cache->addEntryToObjectCache(key, nullptr);
cache->update(referenceTime + expiryDelay, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
cache->update(referenceTime + expiryDelay / 2, expiryDelay);
EXPECT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
}
TEST(ResourceGenericObjectCacheTest, getRefFromObjectCacheOrNoneShouldNotExtendItemLifetime)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const double referenceTime = 1;
const double expiryDelay = 2;
const int key = 42;
cache->addEntryToObjectCache(key, nullptr);
cache->update(referenceTime, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
cache->update(referenceTime + expiryDelay / 2, expiryDelay);
ASSERT_THAT(cache->getRefFromObjectCacheOrNone(key), Optional(_));
cache->update(referenceTime + expiryDelay, expiryDelay);
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(key), std::nullopt);
}
TEST(ResourceGenericObjectCacheTest, lowerBoundShouldSupportHeterogeneousLookup)
{
osg::ref_ptr<GenericObjectCache<std::string>> cache(new GenericObjectCache<std::string>);
cache->addEntryToObjectCache("a", nullptr);
cache->addEntryToObjectCache("c", nullptr);
EXPECT_THAT(cache->lowerBound(std::string_view("b")), Optional(Pair("c", _)));
}
TEST(ResourceGenericObjectCacheTest, shouldSupportRemovingItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const int key = 42;
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
ASSERT_EQ(cache->getRefFromObjectCache(key), value);
cache->removeFromObjectCache(key);
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(key), std::nullopt);
}
TEST(ResourceGenericObjectCacheTest, clearShouldRemoveAllItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
const int key1 = 42;
const int key2 = 13;
osg::ref_ptr<Object> value1(new Object);
osg::ref_ptr<Object> value2(new Object);
cache->addEntryToObjectCache(key1, value1);
cache->addEntryToObjectCache(key2, value2);
ASSERT_EQ(cache->getRefFromObjectCache(key1), value1);
ASSERT_EQ(cache->getRefFromObjectCache(key2), value2);
cache->clear();
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(key1), std::nullopt);
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(key2), std::nullopt);
}
TEST(ResourceGenericObjectCacheTest, callShouldIterateOverAllItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
osg::ref_ptr<Object> value1(new Object);
osg::ref_ptr<Object> value2(new Object);
osg::ref_ptr<Object> value3(new Object);
cache->addEntryToObjectCache(1, value1);
cache->addEntryToObjectCache(2, value2);
cache->addEntryToObjectCache(3, value3);
std::vector<std::pair<int, osg::Object*>> actual;
cache->call([&](int key, osg::Object* value) { actual.emplace_back(key, value); });
EXPECT_THAT(actual, ElementsAre(Pair(1, value1.get()), Pair(2, value2.get()), Pair(3, value3.get())));
}
TEST(ResourceGenericObjectCacheTest, getStatsShouldReturnNumberOrAddedItems)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
osg::ref_ptr<Object> value1(new Object);
osg::ref_ptr<Object> value2(new Object);
cache->addEntryToObjectCache(13, value1);
cache->addEntryToObjectCache(42, value2);
const CacheStats stats = cache->getStats();
EXPECT_EQ(stats.mSize, 2);
}
TEST(ResourceGenericObjectCacheTest, getStatsShouldReturnNumberOrGetsAndHits)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
{
const CacheStats stats = cache->getStats();
EXPECT_EQ(stats.mGet, 0);
EXPECT_EQ(stats.mHit, 0);
}
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(13, value);
cache->getRefFromObjectCache(13);
cache->getRefFromObjectCache(42);
{
const CacheStats stats = cache->getStats();
EXPECT_EQ(stats.mGet, 2);
EXPECT_EQ(stats.mHit, 1);
}
}
TEST(ResourceGenericObjectCacheTest, lowerBoundShouldReturnFirstNotLessThatGivenKey)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
osg::ref_ptr<Object> value1(new Object);
osg::ref_ptr<Object> value2(new Object);
osg::ref_ptr<Object> value3(new Object);
cache->addEntryToObjectCache(1, value1);
cache->addEntryToObjectCache(2, value2);
cache->addEntryToObjectCache(4, value3);
EXPECT_THAT(cache->lowerBound(3), Optional(Pair(4, value3)));
}
TEST(ResourceGenericObjectCacheTest, lowerBoundShouldReturnNulloptWhenKeyIsGreaterThanAnyOther)
{
osg::ref_ptr<GenericObjectCache<int>> cache(new GenericObjectCache<int>);
osg::ref_ptr<Object> value1(new Object);
osg::ref_ptr<Object> value2(new Object);
osg::ref_ptr<Object> value3(new Object);
cache->addEntryToObjectCache(1, value1);
cache->addEntryToObjectCache(2, value2);
cache->addEntryToObjectCache(3, value3);
EXPECT_EQ(cache->lowerBound(4), std::nullopt);
}
TEST(ResourceGenericObjectCacheTest, addEntryToObjectCacheShouldSupportHeterogeneousLookup)
{
osg::ref_ptr<GenericObjectCache<std::string>> cache(new GenericObjectCache<std::string>);
const std::string key = "key";
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(std::string_view("key"), value);
EXPECT_EQ(cache->getRefFromObjectCache(key), value);
}
TEST(ResourceGenericObjectCacheTest, addEntryToObjectCacheShouldKeyMoving)
{
osg::ref_ptr<GenericObjectCache<std::string>> cache(new GenericObjectCache<std::string>);
std::string key(128, 'a');
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(std::move(key), value);
EXPECT_EQ(key, "");
EXPECT_EQ(cache->getRefFromObjectCache(std::string(128, 'a')), value);
}
TEST(ResourceGenericObjectCacheTest, removeFromObjectCacheShouldSupportHeterogeneousLookup)
{
osg::ref_ptr<GenericObjectCache<std::string>> cache(new GenericObjectCache<std::string>);
const std::string key = "key";
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
ASSERT_EQ(cache->getRefFromObjectCache(key), value);
cache->removeFromObjectCache(std::string_view("key"));
EXPECT_EQ(cache->getRefFromObjectCacheOrNone(key), std::nullopt);
}
TEST(ResourceGenericObjectCacheTest, getRefFromObjectCacheShouldSupportHeterogeneousLookup)
{
osg::ref_ptr<GenericObjectCache<std::string>> cache(new GenericObjectCache<std::string>);
const std::string key = "key";
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
EXPECT_EQ(cache->getRefFromObjectCache(std::string_view("key")), value);
}
TEST(ResourceGenericObjectCacheTest, getRefFromObjectCacheOrNoneShouldSupportHeterogeneousLookup)
{
osg::ref_ptr<GenericObjectCache<std::string>> cache(new GenericObjectCache<std::string>);
const std::string key = "key";
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
EXPECT_THAT(cache->getRefFromObjectCacheOrNone(std::string_view("key")), Optional(value));
}
TEST(ResourceGenericObjectCacheTest, checkInObjectCacheShouldSupportHeterogeneousLookup)
{
osg::ref_ptr<GenericObjectCache<std::string>> cache(new GenericObjectCache<std::string>);
const std::string key = "key";
osg::ref_ptr<Object> value(new Object);
cache->addEntryToObjectCache(key, value);
EXPECT_TRUE(cache->checkInObjectCache(std::string_view("key"), 0));
}
}
}
| 15,388
|
C++
|
.cpp
| 297
| 39.915825
| 114
| 0.640664
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,230
|
shadermanager.cpp
|
OpenMW_openmw/apps/components_tests/settings/shadermanager.cpp
|
#include <components/settings/shadermanager.hpp>
#include <components/testing/util.hpp>
#include <filesystem>
#include <fstream>
#include <gtest/gtest.h>
namespace
{
using namespace testing;
using namespace Settings;
struct ShaderSettingsTest : Test
{
template <typename F>
void withSettingsFile(const std::string& content, F&& f)
{
auto path = TestingOpenMW::outputFilePath(
std::string(UnitTest::GetInstance()->current_test_info()->name()) + ".yaml");
{
std::ofstream stream;
stream.open(path);
stream << content;
stream.close();
}
f(path);
}
};
TEST_F(ShaderSettingsTest, fail_to_fetch_then_set_and_succeed)
{
const std::string content =
R"YAML(
config:
shader:
vec3_uniform: [1.0, 2.0]
)YAML";
withSettingsFile(content, [](const auto& path) {
EXPECT_TRUE(ShaderManager::get().load(path));
EXPECT_FALSE(ShaderManager::get().getValue<osg::Vec3f>("shader", "vec3_uniform").has_value());
EXPECT_TRUE(ShaderManager::get().setValue<osg::Vec3f>("shader", "vec3_uniform", osg::Vec3f(1, 2, 3)));
EXPECT_TRUE(ShaderManager::get().getValue<osg::Vec3f>("shader", "vec3_uniform").has_value());
EXPECT_EQ(ShaderManager::get().getValue<osg::Vec3f>("shader", "vec3_uniform").value(), osg::Vec3f(1, 2, 3));
EXPECT_TRUE(ShaderManager::get().save());
});
}
TEST_F(ShaderSettingsTest, fail_to_load_file_then_fail_to_set_and_get)
{
const std::string content =
R"YAML(
config:
shader:
uniform: 12.0
>Defeated by a sideways carrot
)YAML";
withSettingsFile(content, [](const auto& path) {
EXPECT_FALSE(ShaderManager::get().load(path));
EXPECT_FALSE(ShaderManager::get().setValue("shader", "uniform", 12.0));
EXPECT_FALSE(ShaderManager::get().getValue<float>("shader", "uniform").has_value());
EXPECT_FALSE(ShaderManager::get().save());
});
}
}
| 2,155
|
C++
|
.cpp
| 59
| 28.220339
| 120
| 0.594439
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,231
|
testvalues.cpp
|
OpenMW_openmw/apps/components_tests/settings/testvalues.cpp
|
#include "components/misc/strings/conversion.hpp"
#include "components/settings/parser.hpp"
#include "components/settings/values.hpp"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#ifndef OPENMW_PROJECT_SOURCE_DIR
#define OPENMW_PROJECT_SOURCE_DIR "."
#endif
namespace Settings
{
namespace
{
using namespace testing;
struct SettingsValuesTest : Test
{
const std::filesystem::path mSettingsDefaultPath = std::filesystem::path{ OPENMW_PROJECT_SOURCE_DIR }
/ "files" / Misc::StringUtils::stringToU8String("settings-default.cfg");
SettingsValuesTest()
{
Manager::mDefaultSettings.clear();
Manager::mUserSettings.clear();
Manager::mChangedSettings.clear();
SettingsFileParser parser;
parser.loadSettingsFile(mSettingsDefaultPath, Manager::mDefaultSettings);
}
};
TEST_F(SettingsValuesTest, shouldLoadFromSettingsManager)
{
Index index;
Values values(index);
EXPECT_EQ(values.mCamera.mFieldOfView.get(), 60);
}
TEST_F(SettingsValuesTest, shouldFillIndexOnLoad)
{
Index index;
Values values(index);
EXPECT_EQ(index.get<float>("Camera", "field of view").get(), 60);
}
TEST_F(SettingsValuesTest, constructorShouldThrowExceptionOnMissingSetting)
{
Manager::mDefaultSettings.erase({ "Camera", "field of view" });
Index index;
EXPECT_THROW([&] { Values values(index); }(), std::runtime_error);
}
TEST_F(SettingsValuesTest, constructorShouldSanitize)
{
Manager::mUserSettings[std::make_pair("Camera", "field of view")] = "-1";
Index index;
Values values(index);
EXPECT_EQ(values.mCamera.mFieldOfView.get(), 1);
}
TEST_F(SettingsValuesTest, constructorWithDefaultShouldDoLookup)
{
Manager::mUserSettings[std::make_pair("category", "value")] = "13";
Index index;
SettingValue<int> value{ index, "category", "value", 42 };
EXPECT_EQ(value.get(), 13);
value.reset();
EXPECT_EQ(value.get(), 42);
}
TEST_F(SettingsValuesTest, constructorWithDefaultShouldSanitize)
{
Manager::mUserSettings[std::make_pair("category", "value")] = "2";
Index index;
SettingValue<int> value{ index, "category", "value", -1, Settings::makeClampSanitizerInt(0, 1) };
EXPECT_EQ(value.get(), 1);
value.reset();
EXPECT_EQ(value.get(), 0);
}
TEST_F(SettingsValuesTest, constructorWithDefaultShouldFallbackToDefault)
{
Index index;
const SettingValue<int> value{ index, "category", "value", 42 };
EXPECT_EQ(value.get(), 42);
}
TEST_F(SettingsValuesTest, moveConstructorShouldSetDefaults)
{
Index index;
Values defaultValues(index);
Manager::mUserSettings.emplace(std::make_pair("Camera", "field of view"), "61");
Values values(std::move(defaultValues));
EXPECT_EQ(values.mCamera.mFieldOfView.get(), 61);
values.mCamera.mFieldOfView.reset();
EXPECT_EQ(values.mCamera.mFieldOfView.get(), 60);
}
TEST_F(SettingsValuesTest, moveConstructorShouldSanitize)
{
Index index;
Values defaultValues(index);
Manager::mUserSettings[std::make_pair("Camera", "field of view")] = "-1";
Values values(std::move(defaultValues));
EXPECT_EQ(values.mCamera.mFieldOfView.get(), 1);
}
TEST_F(SettingsValuesTest, moveConstructorShouldThrowOnMissingSetting)
{
Index index;
SettingValue<int> defaultValue{ index, "category", "value", 42 };
EXPECT_THROW([&] { SettingValue<int> value(std::move(defaultValue)); }(), std::runtime_error);
}
TEST_F(SettingsValuesTest, findShouldThrowExceptionOnTypeMismatch)
{
Index index;
Values values(index);
EXPECT_THROW(index.find<int>("Camera", "field of view"), std::invalid_argument);
}
TEST_F(SettingsValuesTest, findShouldReturnNullptrForAbsentSetting)
{
Index index;
Values values(index);
EXPECT_EQ(index.find<int>("foo", "bar"), nullptr);
}
TEST_F(SettingsValuesTest, getShouldThrowExceptionForAbsentSetting)
{
Index index;
Values values(index);
EXPECT_THROW(index.get<int>("foo", "bar").get(), std::invalid_argument);
}
TEST_F(SettingsValuesTest, setShouldChangeManagerUserSettings)
{
Index index;
Values values(index);
values.mCamera.mFieldOfView.set(42);
EXPECT_EQ(Manager::mUserSettings.at({ "Camera", "field of view" }), "42");
EXPECT_THAT(Manager::mChangedSettings, ElementsAre(std::make_pair("Camera", "field of view")));
}
TEST_F(SettingsValuesTest, setShouldNotChangeManagerChangedSettingsForNoChange)
{
Index index;
Values values(index);
values.mCamera.mFieldOfView.set(values.mCamera.mFieldOfView.get());
EXPECT_THAT(Manager::mChangedSettings, ElementsAre());
}
}
}
| 5,548
|
C++
|
.cpp
| 134
| 30.701493
| 113
| 0.602707
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,232
|
parser.cpp
|
OpenMW_openmw/apps/components_tests/settings/parser.cpp
|
#include <components/settings/parser.hpp>
#include <components/testing/util.hpp>
#include <fstream>
#include <gtest/gtest.h>
namespace
{
using namespace testing;
using namespace Settings;
struct SettingsFileParserTest : Test
{
SettingsFileParser mLoader;
SettingsFileParser mSaver;
template <typename F>
void withSettingsFile(const std::string& content, F&& f)
{
auto path = TestingOpenMW::outputFilePath(
std::string(UnitTest::GetInstance()->current_test_info()->name()) + ".cfg");
{
std::ofstream stream(path);
stream << content;
stream.close();
}
f(path);
}
};
TEST_F(SettingsFileParserTest, load_empty_file)
{
const std::string content;
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap());
});
}
TEST_F(SettingsFileParserTest, file_with_single_empty_section)
{
const std::string content = "[Section]\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap());
});
}
TEST_F(SettingsFileParserTest, file_with_single_section_and_key)
{
const std::string content
= "[Section]\n"
"key = value\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), "value" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_single_section_and_key_and_line_comments)
{
const std::string content
= "# foo\n"
"[Section]\n"
"# bar\n"
"key = value\n"
"# baz\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), "value" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_single_section_and_key_file_and_inline_section_comment)
{
const std::string content
= "[Section] # foo\n"
"key = value\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
EXPECT_THROW(mLoader.loadSettingsFile(path, map), std::runtime_error);
});
}
TEST_F(SettingsFileParserTest, file_single_section_and_key_and_inline_key_comment)
{
const std::string content
= "[Section]\n"
"key = value # foo\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), "value # foo" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_single_section_and_key_and_whitespaces)
{
const std::string content
= " [ Section ] \n"
" key = value \n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), "value" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_quoted_string_value)
{
const std::string content
= "[Section]\n"
R"(key = "value")";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), R"("value")" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_quoted_string_value_and_eol)
{
const std::string content
= "[Section]\n"
R"(key = "value"\n)";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), R"("value"\n)" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_empty_value)
{
const std::string content
= "[Section]\n"
"key =\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), "" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_empty_key)
{
const std::string content
= "[Section]\n"
"=\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", ""), "" } }));
});
}
TEST_F(SettingsFileParserTest, file_with_multiple_keys)
{
const std::string content
= "[Section]\n"
"key1 = value1\n"
"key2 = value2\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map,
CategorySettingValueMap({
{ CategorySetting("Section", "key1"), "value1" },
{ CategorySetting("Section", "key2"), "value2" },
}));
});
}
TEST_F(SettingsFileParserTest, file_with_multiple_sections)
{
const std::string content
= "[Section1]\n"
"key1 = value1\n"
"[Section2]\n"
"key2 = value2\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map,
CategorySettingValueMap({
{ CategorySetting("Section1", "key1"), "value1" },
{ CategorySetting("Section2", "key2"), "value2" },
}));
});
}
TEST_F(SettingsFileParserTest, file_with_multiple_sections_and_keys)
{
const std::string content
= "[Section1]\n"
"key1 = value1\n"
"key2 = value2\n"
"[Section2]\n"
"key3 = value3\n"
"key4 = value4\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map,
CategorySettingValueMap({
{ CategorySetting("Section1", "key1"), "value1" },
{ CategorySetting("Section1", "key2"), "value2" },
{ CategorySetting("Section2", "key3"), "value3" },
{ CategorySetting("Section2", "key4"), "value4" },
}));
});
}
TEST_F(SettingsFileParserTest, file_with_repeated_sections)
{
const std::string content
= "[Section]\n"
"key1 = value1\n"
"[Section]\n"
"key2 = value2\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map,
CategorySettingValueMap({
{ CategorySetting("Section", "key1"), "value1" },
{ CategorySetting("Section", "key2"), "value2" },
}));
});
}
TEST_F(SettingsFileParserTest, file_with_repeated_keys)
{
const std::string content
= "[Section]\n"
"key = value\n"
"key = value\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
EXPECT_THROW(mLoader.loadSettingsFile(path, map), std::runtime_error);
});
}
TEST_F(SettingsFileParserTest, file_with_repeated_keys_in_differrent_sections)
{
const std::string content
= "[Section1]\n"
"key = value\n"
"[Section2]\n"
"key = value\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map,
CategorySettingValueMap({
{ CategorySetting("Section1", "key"), "value" },
{ CategorySetting("Section2", "key"), "value" },
}));
});
}
TEST_F(SettingsFileParserTest, file_with_unterminated_section)
{
const std::string content = "[Section";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
EXPECT_THROW(mLoader.loadSettingsFile(path, map), std::runtime_error);
});
}
TEST_F(SettingsFileParserTest, file_with_single_empty_section_name)
{
const std::string content = "[]\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap());
});
}
TEST_F(SettingsFileParserTest, file_with_key_and_without_section)
{
const std::string content = "key = value\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
EXPECT_THROW(mLoader.loadSettingsFile(path, map), std::runtime_error);
});
}
TEST_F(SettingsFileParserTest, file_with_key_in_empty_name_section)
{
const std::string content
= "[]"
"key = value\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
EXPECT_THROW(mLoader.loadSettingsFile(path, map), std::runtime_error);
});
}
TEST_F(SettingsFileParserTest, file_with_unterminated_key)
{
const std::string content
= "[Section]\n"
"key\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
EXPECT_THROW(mLoader.loadSettingsFile(path, map), std::runtime_error);
});
}
TEST_F(SettingsFileParserTest, file_with_empty_lines)
{
const std::string content
= "\n"
"[Section]\n"
"\n"
"key = value\n"
"\n";
withSettingsFile(content, [this](const auto& path) {
CategorySettingValueMap map;
mLoader.loadSettingsFile(path, map);
EXPECT_EQ(map, CategorySettingValueMap({ { CategorySetting("Section", "key"), "value" } }));
});
}
}
| 11,467
|
C++
|
.cpp
| 303
| 27.09571
| 111
| 0.561385
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,233
|
shadermanager.cpp
|
OpenMW_openmw/apps/components_tests/shader/shadermanager.cpp
|
#include <components/files/conversion.hpp>
#include <components/shader/shadermanager.hpp>
#include <components/testing/util.hpp>
#include <fstream>
#include <gtest/gtest.h>
namespace
{
using namespace testing;
using namespace Shader;
struct ShaderManagerTest : Test
{
ShaderManager mManager;
ShaderManager::DefineMap mDefines;
ShaderManagerTest() { mManager.setShaderPath("tests_output"); }
template <class F>
void withShaderFile(const std::string& content, F&& f)
{
withShaderFile("", content, std::forward<F>(f));
}
template <class F>
void withShaderFile(const std::string& suffix, const std::string& content, F&& f)
{
auto subdir = std::filesystem::path("lib")
/ std::filesystem::path(
std::string(UnitTest::GetInstance()->current_test_info()->name()) + suffix + ".vert");
auto path = TestingOpenMW::outputFilePathWithSubDir(subdir);
{
std::ofstream stream(path);
stream << content;
stream.close();
}
f(subdir);
}
};
TEST_F(ShaderManagerTest, get_shader_with_empty_content_should_succeed)
{
const std::string content;
withShaderFile(content, [this](const std::filesystem::path& templateName) {
EXPECT_TRUE(mManager.getShader(Files::pathToUnicodeString(templateName)));
});
}
TEST_F(ShaderManagerTest, get_shader_should_not_change_source_without_template_parameters)
{
const std::string content
= "#version 120\n"
"void main() {}\n";
withShaderFile(content, [&](const std::filesystem::path& templateName) {
const auto shader = mManager.getShader(Files::pathToUnicodeString(templateName), mDefines);
ASSERT_TRUE(shader);
EXPECT_EQ(shader->getShaderSource(), content);
});
}
TEST_F(ShaderManagerTest, get_shader_should_replace_includes_with_content)
{
const std::string content0 = "void foo() {}\n";
withShaderFile("_0", content0, [&](const std::filesystem::path& templateName0) {
const std::string content1 =
"#include \"" + Files::pathToUnicodeString(templateName0) + "\"\n"
"void bar() { foo() }\n";
withShaderFile("_1", content1, [&](const std::filesystem::path& templateName1) {
const std::string content2 =
"#version 120\n"
"#include \"" + Files::pathToUnicodeString(templateName1) + "\"\n"
"void main() { bar() }\n";
withShaderFile(content2, [&](const std::filesystem::path& templateName2) {
const auto shader = mManager.getShader(Files::pathToUnicodeString(templateName2), mDefines);
ASSERT_TRUE(shader);
const std::string expected
= "#version 120\n"
"#line 0 1\n"
"#line 0 2\n"
"void foo() {}\n"
"\n"
"#line 0 0\n"
"\n"
"void bar() { foo() }\n"
"\n"
"#line 1 0\n"
"\n"
"void main() { bar() }\n";
EXPECT_EQ(shader->getShaderSource(), expected);
});
});
});
}
TEST_F(ShaderManagerTest, get_shader_should_replace_defines)
{
const std::string content
= "#version 120\n"
"#define FLAG @flag\n"
"void main() {}\n";
withShaderFile(content, [&](const std::filesystem::path& templateName) {
mDefines["flag"] = "1";
const auto shader = mManager.getShader(Files::pathToUnicodeString(templateName), mDefines);
ASSERT_TRUE(shader);
const std::string expected
= "#version 120\n"
"#define FLAG 1\n"
"void main() {}\n";
EXPECT_EQ(shader->getShaderSource(), expected);
});
}
TEST_F(ShaderManagerTest, get_shader_should_expand_loop)
{
const std::string content
= "#version 120\n"
"@foreach index @list\n"
" varying vec4 foo@index;\n"
"@endforeach\n"
"void main() {}\n";
withShaderFile(content, [&](const std::filesystem::path& templateName) {
mDefines["list"] = "1,2,3";
const auto shader = mManager.getShader(Files::pathToUnicodeString(templateName), mDefines);
ASSERT_TRUE(shader);
const std::string expected
= "#version 120\n"
" varying vec4 foo1;\n"
" varying vec4 foo2;\n"
" varying vec4 foo3;\n"
"\n"
"#line 5\n"
"void main() {}\n";
EXPECT_EQ(shader->getShaderSource(), expected);
});
}
TEST_F(ShaderManagerTest, get_shader_should_replace_loops_with_conditions)
{
const std::string content
= "#version 120\n"
"@foreach index @list\n"
" varying vec4 foo@index;\n"
"@endforeach\n"
"void main()\n"
"{\n"
"#ifdef BAR\n"
"@foreach index @list\n"
" foo@index = vec4(1.0);\n"
"@endforeach\n"
"#elif BAZ\n"
"@foreach index @list\n"
" foo@index = vec4(2.0);\n"
"@endforeach\n"
"#else\n"
"@foreach index @list\n"
" foo@index = vec4(3.0);\n"
"@endforeach\n"
"#endif\n"
"}\n";
withShaderFile(content, [&](const std::filesystem::path& templateName) {
mDefines["list"] = "1,2,3";
const auto shader = mManager.getShader(Files::pathToUnicodeString(templateName), mDefines);
ASSERT_TRUE(shader);
const std::string expected
= "#version 120\n"
" varying vec4 foo1;\n"
" varying vec4 foo2;\n"
" varying vec4 foo3;\n"
"\n"
"#line 5\n"
"void main()\n"
"{\n"
"#ifdef BAR\n"
" foo1 = vec4(1.0);\n"
" foo2 = vec4(1.0);\n"
" foo3 = vec4(1.0);\n"
"\n"
"#line 11\n"
"#elif BAZ\n"
"#line 12\n"
" foo1 = vec4(2.0);\n"
" foo2 = vec4(2.0);\n"
" foo3 = vec4(2.0);\n"
"\n"
"#line 15\n"
"#else\n"
"#line 16\n"
" foo1 = vec4(3.0);\n"
" foo2 = vec4(3.0);\n"
" foo3 = vec4(3.0);\n"
"\n"
"#line 19\n"
"#endif\n"
"#line 20\n"
"}\n";
EXPECT_EQ(shader->getShaderSource(), expected);
});
}
TEST_F(ShaderManagerTest, get_shader_should_fail_on_absent_template_parameters_in_single_line_comments)
{
const std::string content
= "#version 120\n"
"// #define FLAG @flag\n"
"void main() {}\n";
withShaderFile(content, [&](const std::filesystem::path& templateName) {
EXPECT_FALSE(mManager.getShader(Files::pathToUnicodeString(templateName), mDefines));
});
}
TEST_F(ShaderManagerTest, get_shader_should_fail_on_absent_template_parameter_in_multi_line_comments)
{
const std::string content
= "#version 120\n"
"/* #define FLAG @flag */\n"
"void main() {}\n";
withShaderFile(content, [&](const std::filesystem::path& templateName) {
EXPECT_FALSE(mManager.getShader(Files::pathToUnicodeString(templateName), mDefines));
});
}
}
| 8,351
|
C++
|
.cpp
| 208
| 26.552885
| 112
| 0.487495
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,234
|
parsefors.cpp
|
OpenMW_openmw/apps/components_tests/shader/parsefors.cpp
|
#include <components/shader/shadermanager.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <vector>
namespace
{
using namespace testing;
using namespace Shader;
using DefineMap = ShaderManager::DefineMap;
struct ShaderParseForsTest : Test
{
std::string mSource;
const std::string mName = "shader";
};
static bool parseFors(std::string& source, const std::string& templateName)
{
std::vector<std::string> dummy;
return parseDirectives(source, dummy, {}, {}, templateName);
}
TEST_F(ShaderParseForsTest, empty_should_succeed)
{
ASSERT_TRUE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "");
}
TEST_F(ShaderParseForsTest, should_fail_for_single_escape_symbol)
{
mSource = "$";
ASSERT_FALSE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "$");
}
TEST_F(ShaderParseForsTest, should_fail_on_first_found_escaped_not_foreach)
{
mSource = "$foo ";
ASSERT_FALSE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "$foo ");
}
TEST_F(ShaderParseForsTest, should_fail_on_absent_foreach_variable)
{
mSource = "$foreach ";
ASSERT_FALSE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "$foreach ");
}
TEST_F(ShaderParseForsTest, should_fail_on_unmatched_after_variable)
{
mSource = "$foreach foo ";
ASSERT_FALSE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "$foreach foo ");
}
TEST_F(ShaderParseForsTest, should_fail_on_absent_newline_after_foreach_list)
{
mSource = "$foreach foo 1,2,3 ";
ASSERT_FALSE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "$foreach foo 1,2,3 ");
}
TEST_F(ShaderParseForsTest, should_fail_on_absent_endforeach_after_newline)
{
mSource = "$foreach foo 1,2,3\n";
ASSERT_FALSE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "$foreach foo 1,2,3\n");
}
TEST_F(ShaderParseForsTest, should_replace_complete_foreach_by_line_number)
{
mSource = "$foreach foo 1,2,3\n$endforeach";
ASSERT_TRUE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "\n#line 3");
}
TEST_F(ShaderParseForsTest, should_replace_loop_variable)
{
mSource = "$foreach foo 1,2,3\n$foo\n$endforeach";
ASSERT_TRUE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "1\n2\n3\n\n#line 4");
}
TEST_F(ShaderParseForsTest, should_count_line_number_from_existing)
{
mSource = "$foreach foo 1,2,3\n#line 10\n$foo\n$endforeach";
ASSERT_TRUE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "#line 10\n1\n#line 10\n2\n#line 10\n3\n\n#line 12");
}
TEST_F(ShaderParseForsTest, should_not_support_nested_loops)
{
mSource = "$foreach foo 1,2\n$foo\n$foreach bar 1,2\n$bar\n$endforeach\n$endforeach";
ASSERT_FALSE(parseFors(mSource, mName));
EXPECT_EQ(mSource, "1\n1\n2\n$foreach bar 1,2\n1\n\n#line 6\n2\n2\n$foreach bar 1,2\n2\n\n#line 6\n\n#line 7");
}
}
| 3,089
|
C++
|
.cpp
| 85
| 29.788235
| 119
| 0.644913
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,235
|
parselinks.cpp
|
OpenMW_openmw/apps/components_tests/shader/parselinks.cpp
|
#include <components/shader/shadermanager.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <vector>
namespace
{
using namespace testing;
using namespace Shader;
using DefineMap = ShaderManager::DefineMap;
struct ShaderParseLinksTest : Test
{
std::string mSource;
std::vector<std::string> mLinkTargets;
ShaderManager::DefineMap mDefines;
const std::string mName = "my_shader.glsl";
bool parseLinks() { return parseDirectives(mSource, mLinkTargets, mDefines, {}, mName); }
};
TEST_F(ShaderParseLinksTest, empty_should_succeed)
{
ASSERT_TRUE(parseLinks());
EXPECT_EQ(mSource, "");
EXPECT_TRUE(mLinkTargets.empty());
}
TEST_F(ShaderParseLinksTest, should_fail_for_single_escape_symbol)
{
mSource = "$";
ASSERT_FALSE(parseLinks());
EXPECT_EQ(mSource, "$");
EXPECT_TRUE(mLinkTargets.empty());
}
TEST_F(ShaderParseLinksTest, should_fail_on_first_found_escaped_not_valid_directive)
{
mSource = "$foo ";
ASSERT_FALSE(parseLinks());
EXPECT_EQ(mSource, "$foo ");
EXPECT_TRUE(mLinkTargets.empty());
}
TEST_F(ShaderParseLinksTest, should_fail_on_absent_link_target)
{
mSource = "$link ";
ASSERT_FALSE(parseLinks());
EXPECT_EQ(mSource, "$link ");
EXPECT_TRUE(mLinkTargets.empty());
}
TEST_F(ShaderParseLinksTest, should_not_require_newline)
{
mSource = "$link \"foo.glsl\"";
ASSERT_TRUE(parseLinks());
EXPECT_EQ(mSource, "");
ASSERT_EQ(mLinkTargets.size(), 1);
EXPECT_EQ(mLinkTargets[0], "foo.glsl");
}
TEST_F(ShaderParseLinksTest, should_require_quotes)
{
mSource = "$link foo.glsl";
ASSERT_FALSE(parseLinks());
EXPECT_EQ(mSource, "$link foo.glsl");
EXPECT_EQ(mLinkTargets.size(), 0);
}
TEST_F(ShaderParseLinksTest, should_be_replaced_with_empty_line)
{
mSource = "$link \"foo.glsl\"\nbar";
ASSERT_TRUE(parseLinks());
EXPECT_EQ(mSource, "\nbar");
ASSERT_EQ(mLinkTargets.size(), 1);
EXPECT_EQ(mLinkTargets[0], "foo.glsl");
}
TEST_F(ShaderParseLinksTest, should_only_accept_on_true_condition)
{
mSource =
R"glsl(
$link "foo.glsl" if 1
$link "bar.glsl" if 0
)glsl";
ASSERT_TRUE(parseLinks());
EXPECT_EQ(mSource,
R"glsl(
)glsl");
ASSERT_EQ(mLinkTargets.size(), 1);
EXPECT_EQ(mLinkTargets[0], "foo.glsl");
}
}
| 2,578
|
C++
|
.cpp
| 82
| 24.695122
| 97
| 0.620717
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,236
|
parsedefines.cpp
|
OpenMW_openmw/apps/components_tests/shader/parsedefines.cpp
|
#include <components/shader/shadermanager.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
namespace
{
using namespace testing;
using namespace Shader;
using DefineMap = ShaderManager::DefineMap;
struct ShaderParseDefinesTest : Test
{
std::string mSource;
const std::string mName = "shader";
DefineMap mDefines;
DefineMap mGlobalDefines;
};
TEST_F(ShaderParseDefinesTest, empty_should_succeed)
{
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "");
}
TEST_F(ShaderParseDefinesTest, should_fail_for_absent_define)
{
mSource = "@foo\n";
ASSERT_FALSE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "@foo\n");
}
TEST_F(ShaderParseDefinesTest, should_replace_by_existing_define)
{
mDefines["foo"] = "42";
mSource = "@foo\n";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "42\n");
}
TEST_F(ShaderParseDefinesTest, should_replace_by_existing_global_define)
{
mGlobalDefines["foo"] = "42";
mSource = "@foo\n";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "42\n");
}
TEST_F(ShaderParseDefinesTest, should_prefer_define_over_global_define)
{
mDefines["foo"] = "13";
mGlobalDefines["foo"] = "42";
mSource = "@foo\n";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "13\n");
}
namespace SupportedTerminals
{
struct ShaderParseDefinesTest : ::ShaderParseDefinesTest, WithParamInterface<char>
{
};
TEST_P(ShaderParseDefinesTest, support_defines_terminated_by)
{
mDefines["foo"] = "13";
mSource = "@foo" + std::string(1, GetParam());
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "13" + std::string(1, GetParam()));
}
INSTANTIATE_TEST_SUITE_P(
SupportedTerminals, ShaderParseDefinesTest, Values(' ', '\n', '\r', '(', ')', '[', ']', '.', ';', ','));
}
TEST_F(ShaderParseDefinesTest, should_not_support_define_ending_with_source)
{
mDefines["foo"] = "42";
mSource = "@foo";
ASSERT_FALSE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "@foo");
}
TEST_F(ShaderParseDefinesTest, should_replace_all_matched_values)
{
mDefines["foo"] = "42";
mSource = "@foo @foo ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "42 42 ");
}
TEST_F(ShaderParseDefinesTest, should_support_define_with_empty_name)
{
mDefines[""] = "42";
mSource = "@ ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "42 ");
}
TEST_F(ShaderParseDefinesTest, should_replace_all_found_defines)
{
mDefines["foo"] = "42";
mDefines["bar"] = "13";
mDefines["baz"] = "55";
mSource = "@foo @bar ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "42 13 ");
}
TEST_F(ShaderParseDefinesTest, should_fail_on_foreach_without_endforeach)
{
mSource = "@foreach ";
ASSERT_FALSE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach ");
}
TEST_F(ShaderParseDefinesTest, should_fail_on_endforeach_without_foreach)
{
mSource = "@endforeach ";
ASSERT_FALSE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_replace_at_sign_by_dollar_for_foreach_endforeach)
{
mSource = "@foreach @endforeach ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach $endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_succeed_on_unmatched_nested_foreach)
{
mSource = "@foreach @foreach @endforeach ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach $foreach $endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_fail_on_unmatched_nested_endforeach)
{
mSource = "@foreach @endforeach @endforeach ";
ASSERT_FALSE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach $endforeach $endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_support_nested_foreach)
{
mSource = "@foreach @foreach @endforeach @endforeach ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach $foreach $endforeach $endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_support_foreach_variable)
{
mSource = "@foreach foo @foo @endforeach ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach foo $foo $endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_not_replace_foreach_variable_by_define)
{
mDefines["foo"] = "42";
mSource = "@foreach foo @foo @endforeach ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach foo $foo $endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_support_nested_foreach_with_variable)
{
mSource = "@foreach foo @foo @foreach bar @bar @endforeach @endforeach ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "$foreach foo $foo $foreach bar $bar $endforeach $endforeach ");
}
TEST_F(ShaderParseDefinesTest, should_not_support_single_line_comments_for_defines)
{
mDefines["foo"] = "42";
mSource = "@foo // @foo\n";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "42 // 42\n");
}
TEST_F(ShaderParseDefinesTest, should_not_support_multiline_comments_for_defines)
{
mDefines["foo"] = "42";
mSource = "/* @foo */ @foo ";
ASSERT_TRUE(parseDefines(mSource, mDefines, mGlobalDefines, mName));
EXPECT_EQ(mSource, "/* 42 */ 42 ");
}
}
| 6,530
|
C++
|
.cpp
| 163
| 32.760736
| 116
| 0.644006
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,237
|
osgacontroller.cpp
|
OpenMW_openmw/apps/components_tests/sceneutil/osgacontroller.cpp
|
#include <components/sceneutil/osgacontroller.hpp>
#include <gtest/gtest.h>
#include <osgAnimation/Channel>
#include <filesystem>
#include <fstream>
namespace
{
using namespace SceneUtil;
static const std::string ROOT_BONE_NAME = "bip01";
// Creates a merged anim track with a single root channel with two start/end matrix transforms
osg::ref_ptr<Resource::Animation> createMergedAnimationTrack(std::string name, osg::Matrixf startTransform,
osg::Matrixf endTransform, float startTime = 0.0f, float endTime = 1.0f)
{
osg::ref_ptr<Resource::Animation> mergedAnimationTrack = new Resource::Animation;
mergedAnimationTrack->setName(name);
osgAnimation::MatrixKeyframeContainer* cbCntr = new osgAnimation::MatrixKeyframeContainer;
cbCntr->push_back(osgAnimation::MatrixKeyframe(startTime, startTransform));
cbCntr->push_back(osgAnimation::MatrixKeyframe(endTime, endTransform));
osg::ref_ptr<osgAnimation::MatrixLinearChannel> rootChannel = new osgAnimation::MatrixLinearChannel;
rootChannel->setName("transform");
rootChannel->setTargetName(ROOT_BONE_NAME);
rootChannel->getOrCreateSampler()->setKeyframeContainer(cbCntr);
mergedAnimationTrack->addChannel(rootChannel);
return mergedAnimationTrack;
}
TEST(OsgAnimationControllerTest, getTranslationShouldReturnSampledChannelTranslationForBip01)
{
std::vector<EmulatedAnimation> emulatedAnimations;
emulatedAnimations.push_back({ 0.0f, 1.0f, "test1" }); // should sample this
emulatedAnimations.push_back({ 1.1f, 2.0f, "test2" }); // should ignore this
OsgAnimationController controller;
controller.setEmulatedAnimations(emulatedAnimations);
osg::Matrixf startTransform = osg::Matrixf::identity();
osg::Matrixf endTransform = osg::Matrixf::identity();
osg::Matrixf endTransform2 = osg::Matrixf::identity();
endTransform.setTrans(1.0f, 1.0f, 1.0f);
controller.addMergedAnimationTrack(createMergedAnimationTrack("test1", startTransform, endTransform));
endTransform2.setTrans(2.0f, 2.0f, 2.0f);
controller.addMergedAnimationTrack(
createMergedAnimationTrack("test2", endTransform, endTransform2, 0.1f, 0.9f));
// should be halfway between 0,0,0 and 1,1,1
osg::Vec3f translation = controller.getTranslation(0.5f);
EXPECT_EQ(translation, osg::Vec3f(0.5f, 0.5f, 0.5f));
}
TEST(OsgAnimationControllerTest, getTranslationShouldReturnZeroVectorIfNotFound)
{
std::vector<EmulatedAnimation> emulatedAnimations;
emulatedAnimations.push_back({ 0.0f, 1.0f, "test1" });
OsgAnimationController controller;
controller.setEmulatedAnimations(emulatedAnimations);
osg::Matrixf startTransform = osg::Matrixf::identity();
osg::Matrixf endTransform = osg::Matrixf::identity();
endTransform.setTrans(1.0f, 1.0f, 1.0f);
controller.addMergedAnimationTrack(createMergedAnimationTrack("test1", startTransform, endTransform));
// Has no emulated animation at time so will return 0,0,0
osg::Vec3f translation = controller.getTranslation(100.0f);
EXPECT_EQ(translation, osg::Vec3f(0.0f, 0.0f, 0.0f));
}
TEST(OsgAnimationControllerTest, getTranslationShouldReturnZeroVectorIfNoMergedTracks)
{
std::vector<EmulatedAnimation> emulatedAnimations;
emulatedAnimations.push_back({ 0.0f, 1.0f, "test1" });
OsgAnimationController controller;
controller.setEmulatedAnimations(emulatedAnimations);
// Has no merged tracks so will return 0,0,0
osg::Vec3f translation = controller.getTranslation(0.5);
EXPECT_EQ(translation, osg::Vec3f(0.0f, 0.0f, 0.0f));
}
TEST(OsgAnimationControllerTest, getTransformShouldReturnIdentityIfNotFound)
{
std::vector<EmulatedAnimation> emulatedAnimations;
emulatedAnimations.push_back({ 0.0f, 1.0f, "test1" });
OsgAnimationController controller;
controller.setEmulatedAnimations(emulatedAnimations);
osg::Matrixf startTransform = osg::Matrixf::identity();
osg::Matrixf endTransform = osg::Matrixf::identity();
endTransform.setTrans(1.0f, 1.0f, 1.0f);
controller.addMergedAnimationTrack(createMergedAnimationTrack("test1", startTransform, endTransform));
// Has no emulated animation at time so will return identity
EXPECT_EQ(controller.getTransformForNode(100.0f, ROOT_BONE_NAME), osg::Matrixf::identity());
// Has no bone animation at time so will return identity
EXPECT_EQ(controller.getTransformForNode(0.5f, "wrongbone"), osg::Matrixf::identity());
}
TEST(OsgAnimationControllerTest, getTransformShouldReturnSampledAnimMatrixAtTime)
{
std::vector<EmulatedAnimation> emulatedAnimations;
emulatedAnimations.push_back({ 0.0f, 1.0f, "test1" }); // should sample this
emulatedAnimations.push_back({ 1.1f, 2.0f, "test2" }); // should ignore this
OsgAnimationController controller;
controller.setEmulatedAnimations(emulatedAnimations);
osg::Matrixf startTransform = osg::Matrixf::identity();
osg::Matrixf endTransform = osg::Matrixf::identity();
endTransform.setTrans(1.0f, 1.0f, 1.0f);
controller.addMergedAnimationTrack(createMergedAnimationTrack("test1", startTransform, endTransform));
osg::Matrixf endTransform2 = osg::Matrixf::identity();
endTransform2.setTrans(2.0f, 2.0f, 2.0f);
controller.addMergedAnimationTrack(
createMergedAnimationTrack("test2", endTransform, endTransform2, 0.1f, 0.9f));
EXPECT_EQ(controller.getTransformForNode(0.0f, ROOT_BONE_NAME), startTransform); // start of test1
EXPECT_EQ(controller.getTransformForNode(1.0f, ROOT_BONE_NAME), endTransform); // end of test1
EXPECT_EQ(controller.getTransformForNode(1.1f, ROOT_BONE_NAME), endTransform); // start of test2
EXPECT_EQ(controller.getTransformForNode(2.0f, ROOT_BONE_NAME), endTransform2); // end of test2
}
}
| 6,144
|
C++
|
.cpp
| 104
| 51.163462
| 111
| 0.721936
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,238
|
transaction.cpp
|
OpenMW_openmw/apps/components_tests/sqlite3/transaction.cpp
|
#include <components/sqlite3/db.hpp>
#include <components/sqlite3/request.hpp>
#include <components/sqlite3/statement.hpp>
#include <components/sqlite3/transaction.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <limits>
#include <tuple>
#include <vector>
namespace
{
using namespace testing;
using namespace Sqlite3;
struct InsertId
{
static std::string_view text() noexcept { return "INSERT INTO test (id) VALUES (42)"; }
static void bind(sqlite3&, sqlite3_stmt&) {}
};
struct GetIds
{
static std::string_view text() noexcept { return "SELECT id FROM test"; }
static void bind(sqlite3&, sqlite3_stmt&) {}
};
struct Sqlite3TransactionTest : Test
{
const Db mDb = makeDb(":memory:", "CREATE TABLE test ( id INTEGER )");
void insertId() const
{
Statement insertId(*mDb, InsertId{});
EXPECT_EQ(execute(*mDb, insertId), 1);
}
std::vector<std::tuple<int>> getIds() const
{
Statement getIds(*mDb, GetIds{});
std::vector<std::tuple<int>> result;
request(*mDb, getIds, std::back_inserter(result), std::numeric_limits<std::size_t>::max());
return result;
}
};
TEST_F(Sqlite3TransactionTest, shouldRollbackOnDestruction)
{
{
const Transaction transaction(*mDb);
insertId();
}
EXPECT_THAT(getIds(), IsEmpty());
}
TEST_F(Sqlite3TransactionTest, commitShouldCommitTransaction)
{
{
Transaction transaction(*mDb);
insertId();
transaction.commit();
}
EXPECT_THAT(getIds(), ElementsAre(std::tuple(42)));
}
}
| 1,754
|
C++
|
.cpp
| 57
| 23.701754
| 103
| 0.611144
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,239
|
statement.cpp
|
OpenMW_openmw/apps/components_tests/sqlite3/statement.cpp
|
#include <components/sqlite3/db.hpp>
#include <components/sqlite3/statement.hpp>
#include <gtest/gtest.h>
namespace
{
using namespace testing;
using namespace Sqlite3;
struct Query
{
static std::string_view text() noexcept { return "SELECT 1"; }
static void bind(sqlite3&, sqlite3_stmt&) {}
};
TEST(Sqlite3StatementTest, makeStatementShouldCreateStatementWithPreparedQuery)
{
const auto db = makeDb(":memory:", "CREATE TABLE test ( id INTEGER )");
const Statement statement(*db, Query{});
EXPECT_FALSE(statement.mNeedReset);
EXPECT_NE(statement.mHandle, nullptr);
EXPECT_EQ(statement.mQuery.text(), "SELECT 1");
}
}
| 708
|
C++
|
.cpp
| 21
| 28.333333
| 83
| 0.685212
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,240
|
request.cpp
|
OpenMW_openmw/apps/components_tests/sqlite3/request.cpp
|
#include <components/sqlite3/db.hpp>
#include <components/sqlite3/request.hpp>
#include <components/sqlite3/statement.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <limits>
#include <tuple>
#include <vector>
namespace
{
using namespace testing;
using namespace Sqlite3;
template <class T>
struct InsertInt
{
static std::string_view text() noexcept { return "INSERT INTO ints (value) VALUES (:value)"; }
static void bind(sqlite3& db, sqlite3_stmt& statement, T value)
{
bindParameter(db, statement, ":value", value);
}
};
struct InsertReal
{
static std::string_view text() noexcept { return "INSERT INTO reals (value) VALUES (:value)"; }
static void bind(sqlite3& db, sqlite3_stmt& statement, double value)
{
bindParameter(db, statement, ":value", value);
}
};
struct InsertText
{
static std::string_view text() noexcept { return "INSERT INTO texts (value) VALUES (:value)"; }
static void bind(sqlite3& db, sqlite3_stmt& statement, std::string_view value)
{
bindParameter(db, statement, ":value", value);
}
};
struct InsertBlob
{
static std::string_view text() noexcept { return "INSERT INTO blobs (value) VALUES (:value)"; }
static void bind(sqlite3& db, sqlite3_stmt& statement, const std::vector<std::byte>& value)
{
bindParameter(db, statement, ":value", value);
}
};
struct GetAll
{
std::string mQuery;
explicit GetAll(const std::string& table)
: mQuery("SELECT value FROM " + table + " ORDER BY value")
{
}
std::string_view text() noexcept { return mQuery; }
static void bind(sqlite3&, sqlite3_stmt&) {}
};
template <class T>
struct GetExact
{
std::string mQuery;
explicit GetExact(const std::string& table)
: mQuery("SELECT value FROM " + table + " WHERE value = :value")
{
}
std::string_view text() noexcept { return mQuery; }
static void bind(sqlite3& db, sqlite3_stmt& statement, const T& value)
{
bindParameter(db, statement, ":value", value);
}
};
struct GetInt64
{
static std::string_view text() noexcept { return "SELECT value FROM ints WHERE value = :value"; }
static void bind(sqlite3& db, sqlite3_stmt& statement, std::int64_t value)
{
bindParameter(db, statement, ":value", value);
}
};
struct GetNull
{
static std::string_view text() noexcept { return "SELECT NULL"; }
static void bind(sqlite3&, sqlite3_stmt&) {}
};
struct Int
{
int mValue = 0;
Int() = default;
explicit Int(int value)
: mValue(value)
{
}
Int& operator=(int value)
{
mValue = value;
return *this;
}
friend bool operator==(const Int& l, const Int& r) { return l.mValue == r.mValue; }
};
constexpr const char schema[] = R"(
CREATE TABLE ints ( value INTEGER );
CREATE TABLE reals ( value REAL );
CREATE TABLE texts ( value TEXT );
CREATE TABLE blobs ( value BLOB );
)";
struct Sqlite3RequestTest : Test
{
const Db mDb = makeDb(":memory:", schema);
};
TEST_F(Sqlite3RequestTest, executeShouldSupportInt)
{
Statement insert(*mDb, InsertInt<int>{});
EXPECT_EQ(execute(*mDb, insert, 13), 1);
EXPECT_EQ(execute(*mDb, insert, 42), 1);
Statement select(*mDb, GetAll("ints"));
std::vector<std::tuple<int>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max());
EXPECT_THAT(result, ElementsAre(std::tuple(13), std::tuple(42)));
}
TEST_F(Sqlite3RequestTest, executeShouldSupportInt64)
{
Statement insert(*mDb, InsertInt<std::int64_t>{});
const std::int64_t value = 1099511627776;
EXPECT_EQ(execute(*mDb, insert, value), 1);
Statement select(*mDb, GetAll("ints"));
std::vector<std::tuple<std::int64_t>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max());
EXPECT_THAT(result, ElementsAre(std::tuple(value)));
}
TEST_F(Sqlite3RequestTest, executeShouldSupportReal)
{
Statement insert(*mDb, InsertReal{});
EXPECT_EQ(execute(*mDb, insert, 3.14), 1);
Statement select(*mDb, GetAll("reals"));
std::vector<std::tuple<double>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max());
EXPECT_THAT(result, ElementsAre(std::tuple(3.14)));
}
TEST_F(Sqlite3RequestTest, executeShouldSupportText)
{
Statement insert(*mDb, InsertText{});
const std::string text = "foo";
EXPECT_EQ(execute(*mDb, insert, text), 1);
Statement select(*mDb, GetAll("texts"));
std::vector<std::tuple<std::string>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max());
EXPECT_THAT(result, ElementsAre(std::tuple(text)));
}
TEST_F(Sqlite3RequestTest, executeShouldSupportBlob)
{
Statement insert(*mDb, InsertBlob{});
const std::vector<std::byte> blob({ std::byte(42), std::byte(13) });
EXPECT_EQ(execute(*mDb, insert, blob), 1);
Statement select(*mDb, GetAll("blobs"));
std::vector<std::tuple<std::vector<std::byte>>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max());
EXPECT_THAT(result, ElementsAre(std::tuple(blob)));
}
TEST_F(Sqlite3RequestTest, requestShouldSupportInt)
{
Statement insert(*mDb, InsertInt<int>{});
const int value = 42;
EXPECT_EQ(execute(*mDb, insert, value), 1);
Statement select(*mDb, GetExact<int>("ints"));
std::vector<std::tuple<int>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max(), value);
EXPECT_THAT(result, ElementsAre(std::tuple(value)));
}
TEST_F(Sqlite3RequestTest, requestShouldSupportInt64)
{
Statement insert(*mDb, InsertInt<std::int64_t>{});
const std::int64_t value = 1099511627776;
EXPECT_EQ(execute(*mDb, insert, value), 1);
Statement select(*mDb, GetExact<std::int64_t>("ints"));
std::vector<std::tuple<std::int64_t>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max(), value);
EXPECT_THAT(result, ElementsAre(std::tuple(value)));
}
TEST_F(Sqlite3RequestTest, requestShouldSupportReal)
{
Statement insert(*mDb, InsertReal{});
const double value = 3.14;
EXPECT_EQ(execute(*mDb, insert, value), 1);
Statement select(*mDb, GetExact<double>("reals"));
std::vector<std::tuple<double>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max(), value);
EXPECT_THAT(result, ElementsAre(std::tuple(value)));
}
TEST_F(Sqlite3RequestTest, requestShouldSupportText)
{
Statement insert(*mDb, InsertText{});
const std::string text = "foo";
EXPECT_EQ(execute(*mDb, insert, text), 1);
Statement select(*mDb, GetExact<std::string>("texts"));
std::vector<std::tuple<std::string>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max(), text);
EXPECT_THAT(result, ElementsAre(std::tuple(text)));
}
TEST_F(Sqlite3RequestTest, requestShouldSupportBlob)
{
Statement insert(*mDb, InsertBlob{});
const std::vector<std::byte> blob({ std::byte(42), std::byte(13) });
EXPECT_EQ(execute(*mDb, insert, blob), 1);
Statement select(*mDb, GetExact<std::vector<std::byte>>("blobs"));
std::vector<std::tuple<std::vector<std::byte>>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max(), blob);
EXPECT_THAT(result, ElementsAre(std::tuple(blob)));
}
TEST_F(Sqlite3RequestTest, requestResultShouldSupportNull)
{
Statement select(*mDb, GetNull{});
std::vector<std::tuple<void*>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max());
EXPECT_THAT(result, ElementsAre(std::tuple(nullptr)));
}
TEST_F(Sqlite3RequestTest, requestResultShouldSupportConstructibleFromInt)
{
Statement insert(*mDb, InsertInt<int>{});
const int value = 42;
EXPECT_EQ(execute(*mDb, insert, value), 1);
Statement select(*mDb, GetExact<int>("ints"));
std::vector<std::tuple<Int>> result;
request(*mDb, select, std::back_inserter(result), std::numeric_limits<std::size_t>::max(), value);
EXPECT_THAT(result, ElementsAre(std::tuple(Int(value))));
}
TEST_F(Sqlite3RequestTest, requestShouldLimitOutput)
{
Statement insert(*mDb, InsertInt<int>{});
EXPECT_EQ(execute(*mDb, insert, 13), 1);
EXPECT_EQ(execute(*mDb, insert, 42), 1);
Statement select(*mDb, GetAll("ints"));
std::vector<std::tuple<int>> result;
request(*mDb, select, std::back_inserter(result), 1);
EXPECT_THAT(result, ElementsAre(std::tuple(13)));
}
}
| 9,609
|
C++
|
.cpp
| 234
| 33.358974
| 106
| 0.61892
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,241
|
db.cpp
|
OpenMW_openmw/apps/components_tests/sqlite3/db.cpp
|
#include <components/sqlite3/db.hpp>
#include <gtest/gtest.h>
namespace
{
using namespace testing;
using namespace Sqlite3;
TEST(Sqlite3DbTest, makeDbShouldCreateInMemoryDbWithSchema)
{
const auto db = makeDb(":memory:", "CREATE TABLE test ( id INTEGER )");
EXPECT_NE(db, nullptr);
}
}
| 325
|
C++
|
.cpp
| 12
| 22.833333
| 79
| 0.7
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,242
|
binaryreader.cpp
|
OpenMW_openmw/apps/components_tests/serialization/binaryreader.cpp
|
#include "format.hpp"
#include <components/serialization/binaryreader.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <cstdint>
#include <cstring>
#include <vector>
namespace
{
using namespace testing;
using namespace Serialization;
using namespace SerializationTesting;
TEST(DetourNavigatorSerializationBinaryReaderTest, shouldReadArithmeticTypeValue)
{
std::uint32_t value = 42;
std::vector<std::byte> data(sizeof(value));
std::memcpy(data.data(), &value, sizeof(value));
BinaryReader binaryReader(data.data(), data.data() + data.size());
std::uint32_t result = 0;
const TestFormat<Mode::Read> format;
binaryReader(format, result);
EXPECT_EQ(result, 42u);
}
TEST(DetourNavigatorSerializationBinaryReaderTest, shouldReadArithmeticTypeRangeValue)
{
const std::size_t count = 3;
std::vector<std::byte> data(sizeof(std::size_t) + count * sizeof(std::uint32_t));
std::memcpy(data.data(), &count, sizeof(count));
const std::uint32_t value1 = 960900021;
std::memcpy(data.data() + sizeof(count), &value1, sizeof(std::uint32_t));
const std::uint32_t value2 = 1235496234;
std::memcpy(data.data() + sizeof(count) + sizeof(std::uint32_t), &value2, sizeof(std::uint32_t));
const std::uint32_t value3 = 2342038092;
std::memcpy(data.data() + sizeof(count) + 2 * sizeof(std::uint32_t), &value3, sizeof(std::uint32_t));
BinaryReader binaryReader(data.data(), data.data() + data.size());
std::size_t resultCount = 0;
const TestFormat<Mode::Read> format;
binaryReader(format, resultCount);
std::vector<std::uint32_t> result(resultCount);
binaryReader(format, result.data(), result.size());
EXPECT_THAT(result, ElementsAre(value1, value2, value3));
}
TEST(DetourNavigatorSerializationBinaryReaderTest, forNotEnoughDataForArithmeticTypeShouldThrowException)
{
std::vector<std::byte> data(3);
BinaryReader binaryReader(data.data(), data.data() + data.size());
std::uint32_t result = 0;
const TestFormat<Mode::Read> format;
EXPECT_THROW(binaryReader(format, result), std::runtime_error);
}
TEST(DetourNavigatorSerializationBinaryReaderTest, forNotEnoughDataForArithmeticTypeRangeShouldThrowException)
{
std::vector<std::byte> data(7);
BinaryReader binaryReader(data.data(), data.data() + data.size());
std::vector<std::uint32_t> values(2);
const TestFormat<Mode::Read> format;
EXPECT_THROW(binaryReader(format, values.data(), values.size()), std::runtime_error);
}
TEST(DetourNavigatorSerializationBinaryReaderTest, shouldSetPointerToCurrentBufferPosition)
{
std::vector<std::byte> data(8);
BinaryReader binaryReader(data.data(), data.data() + data.size());
const std::byte* ptr = nullptr;
const TestFormat<Mode::Read> format;
binaryReader(format, ptr);
EXPECT_EQ(ptr, data.data());
}
TEST(DetourNavigatorSerializationBinaryReaderTest, shouldNotAdvanceAfterPointer)
{
std::vector<std::byte> data(8);
BinaryReader binaryReader(data.data(), data.data() + data.size());
const std::byte* ptr1 = nullptr;
const std::byte* ptr2 = nullptr;
const TestFormat<Mode::Read> format;
binaryReader(format, ptr1);
binaryReader(format, ptr2);
EXPECT_EQ(ptr1, data.data());
EXPECT_EQ(ptr2, data.data());
}
}
| 3,571
|
C++
|
.cpp
| 80
| 37.5625
| 114
| 0.672795
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,243
|
binarywriter.cpp
|
OpenMW_openmw/apps/components_tests/serialization/binarywriter.cpp
|
#include "format.hpp"
#include <components/serialization/binarywriter.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <array>
#include <cstdint>
#include <vector>
namespace
{
using namespace testing;
using namespace Serialization;
using namespace SerializationTesting;
TEST(DetourNavigatorSerializationBinaryWriterTest, shouldWriteArithmeticTypeValue)
{
std::vector<std::byte> result(4);
BinaryWriter binaryWriter(result.data(), result.data() + result.size());
const TestFormat<Mode::Write> format;
binaryWriter(format, std::uint32_t(42));
EXPECT_THAT(result, ElementsAre(std::byte(42), std::byte(0), std::byte(0), std::byte(0)));
}
TEST(DetourNavigatorSerializationBinaryWriterTest, shouldWriteArithmeticTypeRangeValue)
{
std::vector<std::byte> result(8);
BinaryWriter binaryWriter(result.data(), result.data() + result.size());
std::vector<std::uint32_t> values({ 42, 13 });
const TestFormat<Mode::Write> format;
binaryWriter(format, values.data(), values.size());
constexpr std::array<std::byte, 8> expected{
std::byte(42),
std::byte(0),
std::byte(0),
std::byte(0),
std::byte(13),
std::byte(0),
std::byte(0),
std::byte(0),
};
EXPECT_THAT(result, ElementsAreArray(expected));
}
TEST(DetourNavigatorSerializationBinaryWriterTest, forNotEnoughSpaceForArithmeticTypeShouldThrowException)
{
std::vector<std::byte> result(3);
BinaryWriter binaryWriter(result.data(), result.data() + result.size());
const TestFormat<Mode::Write> format;
EXPECT_THROW(binaryWriter(format, std::uint32_t(42)), std::runtime_error);
}
TEST(DetourNavigatorSerializationBinaryWriterTest, forNotEnoughSpaceForArithmeticTypeRangeShouldThrowException)
{
std::vector<std::byte> result(7);
BinaryWriter binaryWriter(result.data(), result.data() + result.size());
std::vector<std::uint32_t> values({ 42, 13 });
const TestFormat<Mode::Write> format;
EXPECT_THROW(binaryWriter(format, values.data(), values.size()), std::runtime_error);
}
}
| 2,263
|
C++
|
.cpp
| 55
| 33.963636
| 115
| 0.668182
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,244
|
integration.cpp
|
OpenMW_openmw/apps/components_tests/serialization/integration.cpp
|
#include "format.hpp"
#include <components/serialization/binaryreader.hpp>
#include <components/serialization/binarywriter.hpp>
#include <components/serialization/sizeaccumulator.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <vector>
namespace
{
using namespace testing;
using namespace Serialization;
using namespace SerializationTesting;
struct DetourNavigatorSerializationIntegrationTest : Test
{
Composite mComposite;
DetourNavigatorSerializationIntegrationTest()
{
mComposite.mIntVector = { 4, 5, 6 };
mComposite.mEnumVector = { Enum::A, Enum::B, Enum::C };
mComposite.mPodVector = { Pod{ 4, 23.87 }, Pod{ 5, -31.76 }, Pod{ 6, 65.12 } };
mComposite.mPodBuffer = { Pod{ 7, 456.123 }, Pod{ 8, -628.346 } };
mComposite.mPodDataSize = mComposite.mPodBuffer.size();
std::string charData = "serialization";
mComposite.mCharBuffer = { charData.begin(), charData.end() };
mComposite.mCharDataSize = charData.size();
}
};
TEST_F(DetourNavigatorSerializationIntegrationTest, sizeAccumulatorShouldSupportCustomSerializer)
{
SizeAccumulator sizeAccumulator;
TestFormat<Mode::Write>{}(sizeAccumulator, mComposite);
EXPECT_EQ(sizeAccumulator.value(), 143);
}
TEST_F(DetourNavigatorSerializationIntegrationTest, binaryReaderShouldDeserializeDataWrittenByBinaryWriter)
{
std::vector<std::byte> data(143);
TestFormat<Mode::Write>{}(BinaryWriter(data.data(), data.data() + data.size()), mComposite);
Composite result;
TestFormat<Mode::Read>{}(BinaryReader(data.data(), data.data() + data.size()), result);
EXPECT_EQ(result.mIntVector, mComposite.mIntVector);
EXPECT_EQ(result.mEnumVector, mComposite.mEnumVector);
EXPECT_EQ(result.mPodVector, mComposite.mPodVector);
EXPECT_EQ(result.mPodDataSize, mComposite.mPodDataSize);
EXPECT_EQ(result.mPodBuffer, mComposite.mPodBuffer);
EXPECT_EQ(result.mCharDataSize, mComposite.mCharDataSize);
EXPECT_EQ(result.mCharBuffer, mComposite.mCharBuffer);
}
}
| 2,196
|
C++
|
.cpp
| 48
| 38.583333
| 111
| 0.697196
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,245
|
sizeaccumulator.cpp
|
OpenMW_openmw/apps/components_tests/serialization/sizeaccumulator.cpp
|
#include "format.hpp"
#include <components/serialization/sizeaccumulator.hpp>
#include <gtest/gtest.h>
#include <cstddef>
#include <cstdint>
#include <variant>
#include <vector>
namespace
{
using namespace testing;
using namespace Serialization;
using namespace SerializationTesting;
TEST(DetourNavigatorSerializationSizeAccumulatorTest, shouldProvideSizeForArithmeticType)
{
SizeAccumulator sizeAccumulator;
constexpr std::monostate format;
sizeAccumulator(format, std::uint32_t());
EXPECT_EQ(sizeAccumulator.value(), 4);
}
TEST(DetourNavigatorSerializationSizeAccumulatorTest, shouldProvideSizeForArithmeticTypeRange)
{
SizeAccumulator sizeAccumulator;
const std::uint64_t* const data = nullptr;
const std::size_t count = 3;
const std::monostate format;
sizeAccumulator(format, data, count);
EXPECT_EQ(sizeAccumulator.value(), 24);
}
TEST(DetourNavigatorSerializationSizeAccumulatorTest, shouldSupportCustomSerializer)
{
SizeAccumulator sizeAccumulator;
const TestFormat<Mode::Write> format;
sizeAccumulator(format, Pod{});
EXPECT_EQ(sizeAccumulator.value(), 12);
}
}
| 1,237
|
C++
|
.cpp
| 36
| 28.722222
| 98
| 0.734506
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,246
|
includes.cpp
|
OpenMW_openmw/apps/components_tests/esm4/includes.cpp
|
#include <components/esm4/actor.hpp>
#include <components/esm4/common.hpp>
#include <components/esm4/dialogue.hpp>
#include <components/esm4/effect.hpp>
#include <components/esm4/inventory.hpp>
#include <components/esm4/lighting.hpp>
#include <components/esm4/loadachr.hpp>
#include <components/esm4/loadacti.hpp>
#include <components/esm4/loadalch.hpp>
#include <components/esm4/loadaloc.hpp>
#include <components/esm4/loadammo.hpp>
#include <components/esm4/loadanio.hpp>
#include <components/esm4/loadappa.hpp>
#include <components/esm4/loadarma.hpp>
#include <components/esm4/loadarmo.hpp>
#include <components/esm4/loadaspc.hpp>
#include <components/esm4/loadbook.hpp>
#include <components/esm4/loadbptd.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/esm4/loadclas.hpp>
#include <components/esm4/loadclfm.hpp>
#include <components/esm4/loadclot.hpp>
#include <components/esm4/loadcont.hpp>
#include <components/esm4/loadcrea.hpp>
#include <components/esm4/loaddial.hpp>
#include <components/esm4/loaddobj.hpp>
#include <components/esm4/loaddoor.hpp>
#include <components/esm4/loadeyes.hpp>
#include <components/esm4/loadflor.hpp>
#include <components/esm4/loadflst.hpp>
#include <components/esm4/loadfurn.hpp>
#include <components/esm4/loadglob.hpp>
#include <components/esm4/loadgras.hpp>
#include <components/esm4/loadgrup.hpp>
#include <components/esm4/loadhair.hpp>
#include <components/esm4/loadhdpt.hpp>
#include <components/esm4/loadidle.hpp>
#include <components/esm4/loadidlm.hpp>
#include <components/esm4/loadimod.hpp>
#include <components/esm4/loadinfo.hpp>
#include <components/esm4/loadingr.hpp>
#include <components/esm4/loadkeym.hpp>
#include <components/esm4/loadland.hpp>
#include <components/esm4/loadlgtm.hpp>
#include <components/esm4/loadligh.hpp>
#include <components/esm4/loadltex.hpp>
#include <components/esm4/loadlvlc.hpp>
#include <components/esm4/loadlvli.hpp>
#include <components/esm4/loadlvln.hpp>
#include <components/esm4/loadmato.hpp>
#include <components/esm4/loadmisc.hpp>
#include <components/esm4/loadmset.hpp>
#include <components/esm4/loadmstt.hpp>
#include <components/esm4/loadmusc.hpp>
#include <components/esm4/loadnavi.hpp>
#include <components/esm4/loadnavm.hpp>
#include <components/esm4/loadnote.hpp>
#include <components/esm4/loadnpc.hpp>
#include <components/esm4/loadotft.hpp>
#include <components/esm4/loadpack.hpp>
#include <components/esm4/loadpgrd.hpp>
#include <components/esm4/loadpgre.hpp>
#include <components/esm4/loadpwat.hpp>
#include <components/esm4/loadqust.hpp>
#include <components/esm4/loadrace.hpp>
#include <components/esm4/loadrefr.hpp>
#include <components/esm4/loadregn.hpp>
#include <components/esm4/loadroad.hpp>
#include <components/esm4/loadsbsp.hpp>
#include <components/esm4/loadscol.hpp>
#include <components/esm4/loadscpt.hpp>
#include <components/esm4/loadscrl.hpp>
#include <components/esm4/loadsgst.hpp>
#include <components/esm4/loadslgm.hpp>
#include <components/esm4/loadsndr.hpp>
#include <components/esm4/loadsoun.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadtact.hpp>
#include <components/esm4/loadterm.hpp>
#include <components/esm4/loadtes4.hpp>
#include <components/esm4/loadtree.hpp>
#include <components/esm4/loadtxst.hpp>
#include <components/esm4/loadweap.hpp>
#include <components/esm4/loadwrld.hpp>
#include <components/esm4/reader.hpp>
#include <components/esm4/reference.hpp>
#include <components/esm4/script.hpp>
| 3,470
|
C++
|
.cpp
| 87
| 38.885057
| 40
| 0.819982
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,247
|
testrefid.cpp
|
OpenMW_openmw/apps/components_tests/esm/testrefid.cpp
|
#include <components/esm/refid.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/testing/expecterror.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <functional>
#include <map>
#include <string>
MATCHER(IsPrint, "")
{
return std::isprint(arg) != 0;
}
namespace ESM
{
namespace
{
using namespace ::testing;
TEST(ESMRefIdTest, defaultConstructedIsEmpty)
{
const RefId refId;
EXPECT_TRUE(refId.empty());
}
TEST(ESMRefIdTest, stringRefIdIsNotEmpty)
{
const RefId refId = RefId::stringRefId("ref_id");
EXPECT_FALSE(refId.empty());
}
TEST(ESMRefIdTest, formIdRefIdIsNotEmpty)
{
const RefId refId = RefId::formIdRefId({ .mIndex = 42, .mContentFile = 0 });
EXPECT_FALSE(refId.empty());
}
TEST(ESMRefIdTest, FormIdRefIdMustHaveContentFile)
{
EXPECT_TRUE(RefId(FormId()).empty());
EXPECT_ERROR(RefId(FormId{ .mIndex = 1, .mContentFile = -1 }), "RefId can't be a generated FormId");
}
TEST(ESMRefIdTest, defaultConstructedIsEqualToItself)
{
const RefId refId;
EXPECT_EQ(refId, refId);
}
TEST(ESMRefIdTest, defaultConstructedIsEqualToDefaultConstructed)
{
const RefId a;
const RefId b;
EXPECT_EQ(a, b);
}
TEST(ESMRefIdTest, defaultConstructedIsNotEqualToDebugStringRefId)
{
const RefId a;
const RefId b = RefId::stringRefId("b");
EXPECT_NE(a, b);
}
TEST(ESMRefIdTest, defaultConstructedIsNotEqualToFormIdRefId)
{
const RefId a;
const RefId b = RefId::formIdRefId({ .mIndex = 42, .mContentFile = 0 });
EXPECT_NE(a, b);
}
TEST(ESMRefIdTest, defaultConstructedIsNotEqualToDebugStringLiteral)
{
const RefId a;
EXPECT_NE(a, "foo");
}
TEST(ESMRefIdTest, stringRefIdIsEqualToTheSameStringLiteralValue)
{
const RefId refId = RefId::stringRefId("ref_id");
EXPECT_EQ(refId, "ref_id");
}
TEST(ESMRefIdTest, stringRefIdIsCaseInsensitiveEqualToTheSameStringLiteralValue)
{
const RefId refId = RefId::stringRefId("ref_id");
EXPECT_EQ(refId, "REF_ID");
}
TEST(ESMRefIdTest, stringRefIdIsEqualToTheSameStringRefId)
{
const RefId a = RefId::stringRefId("ref_id");
const RefId b = RefId::stringRefId("ref_id");
EXPECT_EQ(a, b);
}
TEST(ESMRefIdTest, stringRefIdIsCaseInsensitiveEqualToTheSameStringRefId)
{
const RefId lower = RefId::stringRefId("ref_id");
const RefId upper = RefId::stringRefId("REF_ID");
EXPECT_EQ(lower, upper);
}
TEST(ESMRefIdTest, equalityIsDefinedForStringRefIdAndRefId)
{
const StringRefId stringRefId("ref_id");
const RefId refId = RefId::stringRefId("REF_ID");
EXPECT_EQ(stringRefId, refId);
}
TEST(ESMRefIdTest, equalityIsDefinedForFormIdAndRefId)
{
const FormId formId{ .mIndex = 42, .mContentFile = 0 };
EXPECT_EQ(formId, RefId(formId));
}
TEST(ESMRefIdTest, stringRefIdIsEqualToItself)
{
const RefId refId = RefId::stringRefId("ref_id");
EXPECT_EQ(refId, refId);
}
TEST(ESMRefIdTest, stringRefIdIsCaseInsensitiveLessByContent)
{
const RefId a = RefId::stringRefId("a");
const RefId b = RefId::stringRefId("B");
EXPECT_LT(a, b);
}
TEST(ESMRefIdTest, stringRefIdDeserializationReturnsEmptyRefIdForNonExistentValues)
{
RefId id = RefId::deserializeText("this stringrefid should not exist");
EXPECT_TRUE(id.empty());
}
TEST(ESMRefIdTest, lessThanIsDefinedForStringRefIdAndRefId)
{
const StringRefId stringRefId("a");
const RefId refId = RefId::stringRefId("B");
EXPECT_LT(stringRefId, refId);
}
TEST(ESMRefIdTest, lessThanIsDefinedForFormRefIdAndRefId)
{
const FormId formId{ .mIndex = 13, .mContentFile = 0 };
const RefId refId = RefId(FormId{ .mIndex = 42, .mContentFile = 0 });
EXPECT_LT(formId, refId);
}
TEST(ESMRefIdTest, stringRefIdHasCaseInsensitiveHash)
{
const RefId lower = RefId::stringRefId("a");
const RefId upper = RefId::stringRefId("A");
const std::hash<RefId> hash;
EXPECT_EQ(hash(lower), hash(upper));
}
TEST(ESMRefIdTest, hasCaseInsensitiveEqualityWithStringView)
{
const RefId a = RefId::stringRefId("a");
const std::string_view b = "A";
EXPECT_EQ(a, b);
}
TEST(ESMRefIdTest, hasCaseInsensitiveLessWithStringView)
{
const RefId a = RefId::stringRefId("a");
const std::string_view b = "B";
EXPECT_LT(a, b);
}
TEST(ESMRefIdTest, hasCaseInsensitiveStrongOrderWithStringView)
{
const RefId a = RefId::stringRefId("a");
const std::string_view b = "B";
const RefId c = RefId::stringRefId("c");
EXPECT_LT(a, b);
EXPECT_LT(b, c);
}
TEST(ESMRefIdTest, stringRefIdHasStrongOrderWithFormId)
{
const RefId stringRefId = RefId::stringRefId("a");
const RefId formIdRefId = RefId::formIdRefId({ .mIndex = 42, .mContentFile = 0 });
EXPECT_TRUE(stringRefId < formIdRefId);
EXPECT_FALSE(formIdRefId < stringRefId);
}
TEST(ESMRefIdTest, formIdRefIdHasStrongOrderWithStringView)
{
const RefId formIdRefId = RefId::formIdRefId({ .mIndex = 42, .mContentFile = 0 });
const std::string_view stringView = "42";
EXPECT_TRUE(stringView < formIdRefId);
EXPECT_FALSE(formIdRefId < stringView);
}
TEST(ESMRefIdTest, canBeUsedAsMapKeyWithLookupByStringView)
{
const std::map<RefId, int, std::less<>> map({ { RefId::stringRefId("a"), 42 } });
EXPECT_EQ(map.count("A"), 1);
}
TEST(ESMRefIdTest, canBeUsedAsLookupKeyForMapWithStringKey)
{
const std::map<std::string, int, std::less<>> map({ { "a", 42 } });
EXPECT_EQ(map.count(RefId::stringRefId("A")), 1);
}
TEST(ESMRefIdTest, emptyRefId)
{
EXPECT_EQ(RefId(), EmptyRefId());
EXPECT_EQ(RefId(), RefId::stringRefId("\0"));
EXPECT_EQ(RefId(), RefId::formIdRefId({ .mIndex = 0, .mContentFile = 0 }));
EXPECT_EQ(RefId(), RefId::formIdRefId({ .mIndex = 0, .mContentFile = -1 }));
}
TEST(ESMRefIdTest, indexRefIdHashDiffersForDistinctValues)
{
const RefId a = RefId::index(static_cast<RecNameInts>(3), 1);
const RefId b = RefId::index(static_cast<RecNameInts>(3), 2);
std::hash<RefId> hash;
EXPECT_NE(hash(a), hash(b));
}
TEST(ESMRefIdTest, indexRefIdHashDiffersForDistinctRecords)
{
const RefId a = RefId::index(static_cast<RecNameInts>(1), 3);
const RefId b = RefId::index(static_cast<RecNameInts>(2), 3);
std::hash<RefId> hash;
EXPECT_NE(hash(a), hash(b));
}
TEST(ESMRefIdTest, esm3ExteriorCellHasLexicographicalOrder)
{
const RefId a = RefId::esm3ExteriorCell(0, 0);
const RefId b = RefId::esm3ExteriorCell(1, 0);
EXPECT_LT(a, b);
EXPECT_TRUE(!(b < a));
}
struct ESMRefIdToStringTest : TestWithParam<std::pair<RefId, std::string>>
{
};
TEST_P(ESMRefIdToStringTest, toString)
{
const RefId& refId = GetParam().first;
const std::string& string = GetParam().second;
EXPECT_EQ(refId.toString(), string);
}
const std::vector<std::pair<RefId, std::string>> toStringParams = {
{ RefId(), std::string() },
{ RefId::stringRefId("foo"), "foo" },
{ RefId::stringRefId(std::string({ 'a', 0, -1, '\n', '\t' })), { 'a', 0, -1, '\n', '\t' } },
{ RefId::formIdRefId({ .mIndex = 42, .mContentFile = 0 }), "0x2a" },
{ RefId::formIdRefId({ .mIndex = 0xffffff, .mContentFile = std::numeric_limits<std::int32_t>::max() }),
"0x7fffffffffffff" },
{ RefId::generated(42), "0x2a" },
{ RefId::generated(std::numeric_limits<std::uint64_t>::max()), "0xffffffffffffffff" },
{ RefId::index(REC_ARMO, 42), "ARMO:0x2a" },
{ RefId::esm3ExteriorCell(-13, 42), "#-13 42" },
{ RefId::esm3ExteriorCell(std::numeric_limits<int>::min(), std::numeric_limits<int>::min()),
"#-2147483648 -2147483648" },
{ RefId::esm3ExteriorCell(std::numeric_limits<int>::max(), std::numeric_limits<int>::max()),
"#2147483647 2147483647" },
};
INSTANTIATE_TEST_SUITE_P(ESMRefIdToString, ESMRefIdToStringTest, ValuesIn(toStringParams));
struct ESMRefIdToDebugStringTest : TestWithParam<std::pair<RefId, std::string>>
{
};
TEST_P(ESMRefIdToDebugStringTest, toDebugString)
{
const RefId& refId = GetParam().first;
const std::string& debugString = GetParam().second;
EXPECT_EQ(refId.toDebugString(), debugString);
}
TEST_P(ESMRefIdToDebugStringTest, toStream)
{
const RefId& refId = GetParam().first;
const std::string& debugString = GetParam().second;
std::ostringstream stream;
stream << refId;
EXPECT_EQ(stream.str(), debugString);
}
const std::vector<std::pair<RefId, std::string>> toDebugStringParams = {
{ RefId(), "Empty{}" },
{ RefId::stringRefId("foo"), "\"foo\"" },
{ RefId::stringRefId("BAR"), "\"BAR\"" },
{ RefId::stringRefId(std::string({ 'a', 0, -1, '\n', '\t' })), "\"a\\x0\\xff\\xa\\x9\"" },
{ RefId::stringRefId("Логово дракона"), "\"Логово дракона\"" },
{ RefId::stringRefId("\xd0\x9b"), "\"Л\"" },
{ RefId::stringRefId("\xff\x9b"), "\"\\xff\\x9b\"" },
{ RefId::stringRefId("\xd0\xd0"), "\"\\xd0\\xd0\"" },
{ RefId::formIdRefId({ .mIndex = 42, .mContentFile = 0 }), "FormId:0x2a" },
{ RefId::formIdRefId({ .mIndex = 0xffffff, .mContentFile = std::numeric_limits<std::int32_t>::max() }),
"FormId:0x7fffffffffffff" },
{ RefId::generated(42), "Generated:0x2a" },
{ RefId::generated(std::numeric_limits<std::uint64_t>::max()), "Generated:0xffffffffffffffff" },
{ RefId::index(REC_ARMO, 42), "Index:ARMO:0x2a" },
{ RefId::index(REC_ARMO, std::numeric_limits<std::uint32_t>::max()), "Index:ARMO:0xffffffff" },
{ RefId::esm3ExteriorCell(-13, 42), "Esm3ExteriorCell:-13:42" },
{ RefId::esm3ExteriorCell(std::numeric_limits<int>::min(), std::numeric_limits<int>::min()),
"Esm3ExteriorCell:-2147483648:-2147483648" },
{ RefId::esm3ExteriorCell(std::numeric_limits<int>::max(), std::numeric_limits<int>::max()),
"Esm3ExteriorCell:2147483647:2147483647" },
};
INSTANTIATE_TEST_SUITE_P(ESMRefIdToDebugString, ESMRefIdToDebugStringTest, ValuesIn(toDebugStringParams));
struct ESMRefIdTextTest : TestWithParam<std::pair<RefId, std::string>>
{
};
TEST_P(ESMRefIdTextTest, serializeTextShouldReturnString)
{
EXPECT_EQ(GetParam().first.serializeText(), GetParam().second);
}
TEST_P(ESMRefIdTextTest, deserializeTextShouldReturnRefId)
{
EXPECT_EQ(RefId::deserializeText(GetParam().second), GetParam().first);
}
const std::vector<std::pair<RefId, std::string>> serializedRefIds = {
{ RefId(), "" },
{ RefId::stringRefId("foo"), "foo" },
{ RefId::stringRefId("BAR"), "bar" },
{ RefId::stringRefId(std::string({ 'a', 0, -1, '\n', '\t' })), { 'a', 0, -1, '\n', '\t' } },
{ RefId::formIdRefId({ .mIndex = 1, .mContentFile = 0 }), "FormId:0x1" },
{ RefId::formIdRefId({ .mIndex = 0x1f, .mContentFile = 0 }), "FormId:0x1f" },
{ RefId::formIdRefId({ .mIndex = 0x1f, .mContentFile = 2 }), "FormId:0x200001f" },
{ RefId::formIdRefId({ .mIndex = 0xffffff, .mContentFile = 0x1abc }), "FormId:0x1abcffffff" },
{ RefId::formIdRefId({ .mIndex = 0xffffff, .mContentFile = std::numeric_limits<std::int32_t>::max() }),
"FormId:0x7fffffffffffff" },
{ RefId::generated(0), "Generated:0x0" },
{ RefId::generated(1), "Generated:0x1" },
{ RefId::generated(0x1f), "Generated:0x1f" },
{ RefId::generated(std::numeric_limits<std::uint64_t>::max()), "Generated:0xffffffffffffffff" },
{ RefId::index(REC_INGR, 0), "Index:INGR:0x0" },
{ RefId::index(REC_INGR, 1), "Index:INGR:0x1" },
{ RefId::index(REC_INGR, 0x1f), "Index:INGR:0x1f" },
{ RefId::index(REC_INGR, std::numeric_limits<std::uint32_t>::max()), "Index:INGR:0xffffffff" },
{ RefId::esm3ExteriorCell(-13, 42), "Esm3ExteriorCell:-13:42" },
{ RefId::esm3ExteriorCell(
std::numeric_limits<std::int32_t>::min(), std::numeric_limits<std::int32_t>::min()),
"Esm3ExteriorCell:-2147483648:-2147483648" },
{ RefId::esm3ExteriorCell(
std::numeric_limits<std::int32_t>::max(), std::numeric_limits<std::int32_t>::max()),
"Esm3ExteriorCell:2147483647:2147483647" },
};
INSTANTIATE_TEST_SUITE_P(ESMRefIdText, ESMRefIdTextTest, ValuesIn(serializedRefIds));
template <class>
[[maybe_unused]] constexpr bool alwaysFalse = false;
template <class T>
struct GenerateRefId
{
static_assert(alwaysFalse<T>,
"There should be specialization for each RefId type. If this assert fails, probably there are no tests "
"for a new RefId type.");
};
template <>
struct GenerateRefId<EmptyRefId>
{
static RefId call() { return RefId(); }
};
template <>
struct GenerateRefId<StringRefId>
{
static RefId call() { return RefId::stringRefId("StringRefId"); }
};
template <>
struct GenerateRefId<FormId>
{
static RefId call() { return FormId{ .mIndex = 42, .mContentFile = 0 }; }
};
template <>
struct GenerateRefId<GeneratedRefId>
{
static RefId call() { return RefId::generated(13); }
};
template <>
struct GenerateRefId<IndexRefId>
{
static RefId call() { return RefId::index(REC_BOOK, 7); }
};
template <>
struct GenerateRefId<ESM3ExteriorCellRefId>
{
static RefId call() { return RefId::esm3ExteriorCell(-12, 7); }
};
template <class T>
struct ESMRefIdTypesTest : Test
{
};
TYPED_TEST_SUITE_P(ESMRefIdTypesTest);
TYPED_TEST_P(ESMRefIdTypesTest, serializeThenDeserializeShouldProduceSameValue)
{
const RefId refId = GenerateRefId<TypeParam>::call();
EXPECT_EQ(RefId::deserialize(refId.serialize()), refId);
}
TYPED_TEST_P(ESMRefIdTypesTest, serializeTextThenDeserializeTextShouldProduceSameValue)
{
const RefId refId = GenerateRefId<TypeParam>::call();
const std::string text = refId.serializeText();
EXPECT_EQ(RefId::deserializeText(text), refId);
}
TYPED_TEST_P(ESMRefIdTypesTest, serializeTextShouldReturnOnlyPrintableCharacters)
{
const RefId refId = GenerateRefId<TypeParam>::call();
EXPECT_THAT(refId.serializeText(), Each(IsPrint()));
}
TYPED_TEST_P(ESMRefIdTypesTest, toStringShouldReturnOnlyPrintableCharacters)
{
const RefId refId = GenerateRefId<TypeParam>::call();
EXPECT_THAT(refId.toString(), Each(IsPrint()));
}
TYPED_TEST_P(ESMRefIdTypesTest, toDebugStringShouldReturnOnlyPrintableCharacters)
{
const RefId refId = GenerateRefId<TypeParam>::call();
EXPECT_THAT(refId.toDebugString(), Each(IsPrint()));
}
TYPED_TEST_P(ESMRefIdTypesTest, shouldBeEqualToItself)
{
const RefId a = GenerateRefId<TypeParam>::call();
const RefId b = GenerateRefId<TypeParam>::call();
EXPECT_EQ(a, b);
}
TYPED_TEST_P(ESMRefIdTypesTest, shouldNotBeNotEqualToItself)
{
const RefId a = GenerateRefId<TypeParam>::call();
const RefId b = GenerateRefId<TypeParam>::call();
EXPECT_FALSE(a != b) << a;
}
TYPED_TEST_P(ESMRefIdTypesTest, shouldBeNotLessThanItself)
{
const RefId a = GenerateRefId<TypeParam>::call();
const RefId b = GenerateRefId<TypeParam>::call();
EXPECT_FALSE(a < b) << a;
}
TYPED_TEST_P(ESMRefIdTypesTest, saveAndLoadShouldNotChange)
{
constexpr NAME fakeRecordId(fourCC("FAKE"));
constexpr NAME subRecordId(fourCC("NAME"));
const RefId expected = GenerateRefId<TypeParam>::call();
auto stream = std::make_unique<std::stringstream>();
{
ESMWriter writer;
writer.setFormatVersion(CurrentSaveGameFormatVersion);
writer.save(*stream);
writer.startRecord(fakeRecordId);
writer.writeHNCRefId(subRecordId, expected);
writer.endRecord(fakeRecordId);
}
ESMReader reader;
reader.open(std::move(stream), "stream");
ASSERT_TRUE(reader.hasMoreRecs());
ASSERT_EQ(reader.getRecName().toInt(), fakeRecordId);
reader.getRecHeader();
const RefId actual = reader.getHNRefId(subRecordId);
EXPECT_EQ(actual, expected);
}
REGISTER_TYPED_TEST_SUITE_P(ESMRefIdTypesTest, serializeThenDeserializeShouldProduceSameValue,
serializeTextThenDeserializeTextShouldProduceSameValue, shouldBeEqualToItself, shouldNotBeNotEqualToItself,
shouldBeNotLessThanItself, serializeTextShouldReturnOnlyPrintableCharacters,
toStringShouldReturnOnlyPrintableCharacters, toDebugStringShouldReturnOnlyPrintableCharacters,
saveAndLoadShouldNotChange);
template <class>
struct RefIdTypes;
template <class... Args>
struct RefIdTypes<std::variant<Args...>>
{
using Type = Types<Args...>;
};
using RefIdTypeParams = typename RefIdTypes<RefId::Value>::Type;
INSTANTIATE_TYPED_TEST_SUITE_P(RefIdTypes, ESMRefIdTypesTest, RefIdTypeParams);
}
}
| 19,640
|
C++
|
.cpp
| 437
| 33.853547
| 120
| 0.585698
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,248
|
test_fixed_string.cpp
|
OpenMW_openmw/apps/components_tests/esm/test_fixed_string.cpp
|
#include "components/esm/defs.hpp"
#include "components/esm/esmcommon.hpp"
#include <gtest/gtest.h>
namespace
{
TEST(EsmFixedString, operator__eq_ne)
{
{
SCOPED_TRACE("asdc == asdc");
constexpr ESM::NAME name("asdc");
char s[4] = { 'a', 's', 'd', 'c' };
std::string ss(s, 4);
EXPECT_TRUE(name == s);
EXPECT_TRUE(name == ss.c_str());
EXPECT_TRUE(name == ss);
}
{
SCOPED_TRACE("asdc == asdcx");
constexpr ESM::NAME name("asdc");
char s[5] = { 'a', 's', 'd', 'c', 'x' };
std::string ss(s, 5);
EXPECT_TRUE(name != s);
EXPECT_TRUE(name != ss.c_str());
EXPECT_TRUE(name != ss);
}
{
SCOPED_TRACE("asdc == asdc[NULL]");
const ESM::NAME name("asdc");
char s[5] = { 'a', 's', 'd', 'c', '\0' };
std::string ss(s, 5);
EXPECT_TRUE(name == s);
EXPECT_TRUE(name == ss.c_str());
EXPECT_TRUE(name == ss);
}
}
TEST(EsmFixedString, operator__eq_ne_const)
{
{
SCOPED_TRACE("asdc == asdc (const)");
constexpr ESM::NAME name("asdc");
const char s[4] = { 'a', 's', 'd', 'c' };
std::string ss(s, 4);
EXPECT_TRUE(name == s);
EXPECT_TRUE(name == ss.c_str());
EXPECT_TRUE(name == ss);
}
{
SCOPED_TRACE("asdc == asdcx (const)");
constexpr ESM::NAME name("asdc");
const char s[5] = { 'a', 's', 'd', 'c', 'x' };
std::string ss(s, 5);
EXPECT_TRUE(name != s);
EXPECT_TRUE(name != ss.c_str());
EXPECT_TRUE(name != ss);
}
{
SCOPED_TRACE("asdc == asdc[NULL] (const)");
constexpr ESM::NAME name("asdc");
const char s[5] = { 'a', 's', 'd', 'c', '\0' };
std::string ss(s, 5);
EXPECT_TRUE(name == s);
EXPECT_TRUE(name == ss.c_str());
EXPECT_TRUE(name == ss);
}
}
TEST(EsmFixedString, empty_strings)
{
{
SCOPED_TRACE("4 bytes");
ESM::NAME empty = ESM::NAME();
EXPECT_TRUE(empty == "");
EXPECT_TRUE(empty == static_cast<uint32_t>(0));
EXPECT_TRUE(empty != "some string");
EXPECT_TRUE(empty != static_cast<uint32_t>(42));
}
{
SCOPED_TRACE("32 bytes");
ESM::NAME32 empty = ESM::NAME32();
EXPECT_TRUE(empty == "");
EXPECT_TRUE(empty != "some string");
}
}
TEST(EsmFixedString, assign_should_zero_untouched_bytes_for_4)
{
ESM::NAME value;
value = static_cast<uint32_t>(0xFFFFFFFFu);
value.assign(std::string(1, 'a'));
EXPECT_EQ(value, static_cast<uint32_t>('a')) << value.toInt();
}
TEST(EsmFixedString, assign_should_only_truncate_for_4)
{
ESM::NAME value;
value.assign(std::string(5, 'a'));
EXPECT_EQ(value, std::string(4, 'a'));
}
TEST(EsmFixedString, assign_should_truncate_and_set_last_element_to_zero)
{
ESM::FixedString<17> value;
value.assign(std::string(20, 'a'));
EXPECT_EQ(value, std::string(16, 'a'));
}
TEST(EsmFixedString, assign_should_truncate_and_set_last_element_to_zero_for_32)
{
ESM::NAME32 value;
value.assign(std::string(33, 'a'));
EXPECT_EQ(value, std::string(31, 'a'));
}
TEST(EsmFixedString, assign_should_truncate_and_set_last_element_to_zero_for_64)
{
ESM::NAME64 value;
value.assign(std::string(65, 'a'));
EXPECT_EQ(value, std::string(63, 'a'));
}
TEST(EsmFixedString, assignment_operator_is_supported_for_uint32)
{
ESM::NAME value;
value = static_cast<uint32_t>(0xFEDCBA98u);
EXPECT_EQ(value, static_cast<uint32_t>(0xFEDCBA98u)) << value.toInt();
}
TEST(EsmFixedString, construction_from_uint32_is_supported)
{
constexpr ESM::NAME value(0xFEDCBA98u);
EXPECT_EQ(value, static_cast<std::uint32_t>(0xFEDCBA98u)) << value.toInt();
}
TEST(EsmFixedString, construction_from_RecNameInts_is_supported)
{
constexpr ESM::NAME value(ESM::RecNameInts::REC_ACTI);
EXPECT_EQ(value, static_cast<std::uint32_t>(ESM::RecNameInts::REC_ACTI)) << value.toInt();
}
TEST(EsmFixedString, equality_operator_for_not_convertible_to_uint32_with_string_literal)
{
const ESM::FixedString<5> value("abcd");
EXPECT_EQ(value, "abcd");
}
TEST(EsmFixedString, equality_operator_for_not_convertible_to_uint32_with_fixed_size_char_array)
{
const ESM::FixedString<5> value("abcd");
const char other[5] = { 'a', 'b', 'c', 'd', '\0' };
EXPECT_EQ(value, other);
}
TEST(EsmFixedString, equality_operator_for_not_convertible_to_uint32_with_const_char_pointer)
{
const ESM::FixedString<5> value("abcd");
const char other[5] = { 'a', 'b', 'c', 'd', '\0' };
EXPECT_EQ(value, static_cast<const char*>(other));
}
TEST(EsmFixedString, equality_operator_for_not_convertible_to_uint32_with_string)
{
const ESM::FixedString<5> value("abcd");
EXPECT_EQ(value, std::string("abcd"));
}
TEST(EsmFixedString, equality_operator_for_not_convertible_to_uint32_with_string_view)
{
const ESM::FixedString<5> value("abcd");
const std::string other("abcd");
EXPECT_EQ(value, std::string_view(other));
}
TEST(EsmFixedString, equality_operator_should_not_get_out_of_bounds)
{
ESM::FixedString<5> value;
const char other[5] = { 'a', 'b', 'c', 'd', 'e' };
std::memcpy(value.mData, other, sizeof(other));
EXPECT_EQ(value, static_cast<const char*>(other));
}
}
| 5,975
|
C++
|
.cpp
| 165
| 27.339394
| 100
| 0.541213
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,249
|
variant.cpp
|
OpenMW_openmw/apps/components_tests/esm/variant.cpp
|
#include <components/esm/fourcc.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/variant.hpp>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <array>
#include <functional>
namespace
{
using namespace testing;
using namespace ESM;
constexpr std::uint32_t fakeRecordId = fourCC("FAKE");
Variant makeVariant(VarType type)
{
Variant v;
v.setType(type);
return v;
}
Variant makeVariant(VarType type, int value)
{
Variant v;
v.setType(type);
v.setInteger(value);
return v;
}
TEST(ESMVariantTest, move_constructed_should_have_data)
{
Variant a(int{ 42 });
const Variant b(std::move(a));
ASSERT_EQ(b.getInteger(), 42);
}
TEST(ESMVariantTest, copy_constructed_is_equal_to_source)
{
const Variant a(int{ 42 });
const Variant b(a);
ASSERT_EQ(a, b);
}
TEST(ESMVariantTest, copy_constructed_does_not_share_data_with_source)
{
const Variant a(int{ 42 });
Variant b(a);
b.setInteger(13);
ASSERT_EQ(a.getInteger(), 42);
ASSERT_EQ(b.getInteger(), 13);
}
TEST(ESMVariantTest, move_assigned_should_have_data)
{
Variant b;
{
Variant a(int{ 42 });
b = std::move(a);
}
ASSERT_EQ(b.getInteger(), 42);
}
TEST(ESMVariantTest, copy_assigned_is_equal_to_source)
{
const Variant a(int{ 42 });
Variant b;
b = a;
ASSERT_EQ(a, b);
}
TEST(ESMVariantTest, not_equal_is_negation_of_equal)
{
const Variant a(int{ 42 });
Variant b;
b = a;
ASSERT_TRUE(!(a != b));
}
TEST(ESMVariantTest, different_types_are_not_equal)
{
ASSERT_NE(Variant(int{ 42 }), Variant(float{ 2.7f }));
}
struct ESMVariantWriteToOStreamTest : TestWithParam<std::tuple<Variant, std::string>>
{
};
TEST_P(ESMVariantWriteToOStreamTest, should_write)
{
const auto [variant, result] = GetParam();
std::ostringstream s;
s << variant;
ASSERT_EQ(s.str(), result);
}
INSTANTIATE_TEST_SUITE_P(VariantAsString, ESMVariantWriteToOStreamTest,
Values(std::make_tuple(Variant(), "variant none"), std::make_tuple(Variant(int{ 42 }), "variant long: 42"),
std::make_tuple(Variant(float{ 2.7f }), "variant float: 2.7"),
std::make_tuple(Variant(std::string("foo")), "variant string: \"foo\""),
std::make_tuple(makeVariant(VT_Unknown), "variant unknown"),
std::make_tuple(makeVariant(VT_Short, 42), "variant short: 42"),
std::make_tuple(makeVariant(VT_Int, 42), "variant int: 42")));
struct ESMVariantGetTypeTest : Test
{
};
TEST(ESMVariantGetTypeTest, default_constructed_should_return_none)
{
ASSERT_EQ(Variant().getType(), VT_None);
}
TEST(ESMVariantGetTypeTest, for_constructed_from_int_should_return_long)
{
ASSERT_EQ(Variant(int{}).getType(), VT_Long);
}
TEST(ESMVariantGetTypeTest, for_constructed_from_float_should_return_float)
{
ASSERT_EQ(Variant(float{}).getType(), VT_Float);
}
TEST(ESMVariantGetTypeTest, for_constructed_from_lvalue_string_should_return_string)
{
const std::string string;
ASSERT_EQ(Variant(string).getType(), VT_String);
}
TEST(ESMVariantGetTypeTest, for_constructed_from_rvalue_string_should_return_string)
{
ASSERT_EQ(Variant(std::string{}).getType(), VT_String);
}
struct ESMVariantGetIntegerTest : Test
{
};
TEST(ESMVariantGetIntegerTest, for_default_constructed_should_throw_exception)
{
ASSERT_THROW(Variant().getInteger(), std::runtime_error);
}
TEST(ESMVariantGetIntegerTest, for_constructed_from_int_should_return_same_value)
{
const Variant variant(int{ 42 });
ASSERT_EQ(variant.getInteger(), 42);
}
TEST(ESMVariantGetIntegerTest, for_constructed_from_float_should_return_casted_to_int)
{
const Variant variant(float{ 2.7 });
ASSERT_EQ(variant.getInteger(), 2);
}
TEST(ESMVariantGetIntegerTest, for_constructed_from_string_should_throw_exception)
{
const Variant variant(std::string("foo"));
ASSERT_THROW(variant.getInteger(), std::runtime_error);
}
TEST(ESMVariantGetFloatTest, for_default_constructed_should_throw_exception)
{
ASSERT_THROW(Variant().getFloat(), std::runtime_error);
}
TEST(ESMVariantGetFloatTest, for_constructed_from_int_should_return_casted_to_float)
{
const Variant variant(int{ 42 });
ASSERT_EQ(variant.getFloat(), 42);
}
TEST(ESMVariantGetFloatTest, for_constructed_from_float_should_return_same_value)
{
const Variant variant(float{ 2.7f });
ASSERT_EQ(variant.getFloat(), 2.7f);
}
TEST(ESMVariantGetFloatTest, for_constructed_from_string_should_throw_exception)
{
const Variant variant(std::string("foo"));
ASSERT_THROW(variant.getFloat(), std::runtime_error);
}
TEST(ESMVariantGetStringTest, for_default_constructed_should_throw_exception)
{
ASSERT_THROW(Variant().getString(), std::bad_variant_access);
}
TEST(ESMVariantGetStringTest, for_constructed_from_int_should_throw_exception)
{
const Variant variant(int{ 42 });
ASSERT_THROW(variant.getString(), std::bad_variant_access);
}
TEST(ESMVariantGetStringTest, for_constructed_from_float_should_throw_exception)
{
const Variant variant(float{ 2.7 });
ASSERT_THROW(variant.getString(), std::bad_variant_access);
}
TEST(ESMVariantGetStringTest, for_constructed_from_string_should_return_same_value)
{
const Variant variant(std::string("foo"));
ASSERT_EQ(variant.getString(), "foo");
}
TEST(ESMVariantSetTypeTest, for_unknown_should_reset_data)
{
Variant variant(int{ 42 });
variant.setType(VT_Unknown);
ASSERT_THROW(variant.getInteger(), std::runtime_error);
}
TEST(ESMVariantSetTypeTest, for_none_should_reset_data)
{
Variant variant(int{ 42 });
variant.setType(VT_None);
ASSERT_THROW(variant.getInteger(), std::runtime_error);
}
TEST(ESMVariantSetTypeTest, for_same_type_should_not_change_value)
{
Variant variant(int{ 42 });
variant.setType(VT_Long);
ASSERT_EQ(variant.getInteger(), 42);
}
TEST(ESMVariantSetTypeTest, for_float_replaced_by_int_should_cast_float_to_int)
{
Variant variant(float{ 2.7f });
variant.setType(VT_Int);
ASSERT_EQ(variant.getInteger(), 2);
}
TEST(ESMVariantSetTypeTest, for_string_replaced_by_int_should_set_default_initialized_data)
{
Variant variant(std::string("foo"));
variant.setType(VT_Int);
ASSERT_EQ(variant.getInteger(), 0);
}
TEST(ESMVariantSetTypeTest, for_default_constructed_replaced_by_float_should_set_default_initialized_value)
{
Variant variant;
variant.setType(VT_Float);
ASSERT_EQ(variant.getInteger(), 0.0f);
}
TEST(ESMVariantSetTypeTest, for_float_replaced_by_short_should_cast_data_to_int)
{
Variant variant(float{ 2.7f });
variant.setType(VT_Short);
ASSERT_EQ(variant.getInteger(), 2);
}
TEST(ESMVariantSetTypeTest, for_float_replaced_by_long_should_cast_data_to_int)
{
Variant variant(float{ 2.7f });
variant.setType(VT_Long);
ASSERT_EQ(variant.getInteger(), 2);
}
TEST(ESMVariantSetTypeTest, for_int_replaced_by_float_should_cast_data_to_float)
{
Variant variant(int{ 42 });
variant.setType(VT_Float);
ASSERT_EQ(variant.getFloat(), 42.0f);
}
TEST(ESMVariantSetTypeTest, for_int_replaced_by_string_should_set_default_initialized_data)
{
Variant variant(int{ 42 });
variant.setType(VT_String);
ASSERT_EQ(variant.getString(), "");
}
TEST(ESMVariantSetIntegerTest, for_default_constructed_should_throw_exception)
{
Variant variant;
ASSERT_THROW(variant.setInteger(42), std::runtime_error);
}
TEST(ESMVariantSetIntegerTest, for_unknown_should_throw_exception)
{
Variant variant;
variant.setType(VT_Unknown);
ASSERT_THROW(variant.setInteger(42), std::runtime_error);
}
TEST(ESMVariantSetIntegerTest, for_default_int_should_change_value)
{
Variant variant(int{ 13 });
variant.setInteger(42);
ASSERT_EQ(variant.getInteger(), 42);
}
TEST(ESMVariantSetIntegerTest, for_int_should_change_value)
{
Variant variant;
variant.setType(VT_Int);
variant.setInteger(42);
ASSERT_EQ(variant.getInteger(), 42);
}
TEST(ESMVariantSetIntegerTest, for_short_should_change_value)
{
Variant variant;
variant.setType(VT_Short);
variant.setInteger(42);
ASSERT_EQ(variant.getInteger(), 42);
}
TEST(ESMVariantSetIntegerTest, for_float_should_change_value)
{
Variant variant(float{ 2.7f });
variant.setInteger(42);
ASSERT_EQ(variant.getFloat(), 42.0f);
}
TEST(ESMVariantSetIntegerTest, for_string_should_throw_exception)
{
Variant variant(std::string{});
ASSERT_THROW(variant.setInteger(42), std::runtime_error);
}
TEST(ESMVariantSetFloatTest, for_default_constructed_should_throw_exception)
{
Variant variant;
ASSERT_THROW(variant.setFloat(2.7f), std::runtime_error);
}
TEST(ESMVariantSetFloatTest, for_unknown_should_throw_exception)
{
Variant variant;
variant.setType(VT_Unknown);
ASSERT_THROW(variant.setFloat(2.7f), std::runtime_error);
}
TEST(ESMVariantSetFloatTest, for_default_int_should_change_value)
{
Variant variant(int{ 13 });
variant.setFloat(2.7f);
ASSERT_EQ(variant.getInteger(), 2);
}
TEST(ESMVariantSetFloatTest, for_int_should_change_value)
{
Variant variant;
variant.setType(VT_Int);
variant.setFloat(2.7f);
ASSERT_EQ(variant.getInteger(), 2);
}
TEST(ESMVariantSetFloatTest, for_short_should_change_value)
{
Variant variant;
variant.setType(VT_Short);
variant.setFloat(2.7f);
ASSERT_EQ(variant.getInteger(), 2);
}
TEST(ESMVariantSetFloatTest, for_float_should_change_value)
{
Variant variant(float{ 2.7f });
variant.setFloat(3.14f);
ASSERT_EQ(variant.getFloat(), 3.14f);
}
TEST(ESMVariantSetFloatTest, for_string_should_throw_exception)
{
Variant variant(std::string{});
ASSERT_THROW(variant.setFloat(2.7f), std::runtime_error);
}
TEST(ESMVariantSetStringTest, for_default_constructed_should_throw_exception)
{
Variant variant;
ASSERT_THROW(variant.setString("foo"), std::bad_variant_access);
}
TEST(ESMVariantSetStringTest, for_unknown_should_throw_exception)
{
Variant variant;
variant.setType(VT_Unknown);
ASSERT_THROW(variant.setString("foo"), std::bad_variant_access);
}
TEST(ESMVariantSetStringTest, for_default_int_should_throw_exception)
{
Variant variant(int{ 13 });
ASSERT_THROW(variant.setString("foo"), std::bad_variant_access);
}
TEST(ESMVariantSetStringTest, for_int_should_throw_exception)
{
Variant variant;
variant.setType(VT_Int);
ASSERT_THROW(variant.setString("foo"), std::bad_variant_access);
}
TEST(ESMVariantSetStringTest, for_short_should_throw_exception)
{
Variant variant;
variant.setType(VT_Short);
ASSERT_THROW(variant.setString("foo"), std::bad_variant_access);
}
TEST(ESMVariantSetStringTest, for_float_should_throw_exception)
{
Variant variant(float{ 2.7f });
ASSERT_THROW(variant.setString("foo"), std::bad_variant_access);
}
TEST(ESMVariantSetStringTest, for_string_should_change_value)
{
Variant variant(std::string("foo"));
variant.setString("bar");
ASSERT_EQ(variant.getString(), "bar");
}
struct WriteToESMTestCase
{
Variant mVariant;
Variant::Format mFormat;
std::size_t mDataSize{};
};
std::string write(const Variant& variant, const Variant::Format format)
{
std::ostringstream out;
ESMWriter writer;
writer.save(out);
writer.startRecord(fakeRecordId);
variant.write(writer, format);
writer.endRecord(fakeRecordId);
writer.close();
return out.str();
}
void read(const Variant::Format format, const std::string& data, Variant& result)
{
ESMReader reader;
reader.open(std::make_unique<std::istringstream>(data), "stream");
ASSERT_TRUE(reader.hasMoreRecs());
ASSERT_EQ(reader.getRecName().toInt(), fakeRecordId);
reader.getRecHeader();
result.read(reader, format);
}
void writeAndRead(const Variant& variant, const Variant::Format format, std::size_t dataSize, Variant& result)
{
const std::string data = write(variant, format);
EXPECT_EQ(data.size(), dataSize);
read(format, data, result);
}
struct ESMVariantToESMTest : TestWithParam<WriteToESMTestCase>
{
};
TEST_P(ESMVariantToESMTest, deserialized_is_equal_to_serialized)
{
const auto param = GetParam();
ESM::Variant result;
writeAndRead(param.mVariant, param.mFormat, param.mDataSize, result);
ASSERT_EQ(param.mVariant, result);
}
const std::array deserializedParams = {
WriteToESMTestCase{ Variant(), Variant::Format_Gmst, 340 },
WriteToESMTestCase{ Variant(int{ 42 }), Variant::Format_Global, 361 },
WriteToESMTestCase{ Variant(float{ 2.7f }), Variant::Format_Global, 361 },
WriteToESMTestCase{ Variant(float{ 2.7f }), Variant::Format_Info, 352 },
WriteToESMTestCase{ Variant(float{ 2.7f }), Variant::Format_Local, 352 },
WriteToESMTestCase{ makeVariant(VT_Short, 42), Variant::Format_Global, 361 },
WriteToESMTestCase{ makeVariant(VT_Short, 42), Variant::Format_Local, 350 },
WriteToESMTestCase{ makeVariant(VT_Int, 42), Variant::Format_Info, 352 },
WriteToESMTestCase{ makeVariant(VT_Int, 42), Variant::Format_Local, 352 },
WriteToESMTestCase{ Variant(float{ 2.7f }), Variant::Format_Gmst, 352 },
WriteToESMTestCase{ Variant(std::string("foo")), Variant::Format_Gmst, 351 },
WriteToESMTestCase{ makeVariant(VT_Int, 42), Variant::Format_Gmst, 352 },
};
INSTANTIATE_TEST_SUITE_P(VariantAndData, ESMVariantToESMTest, ValuesIn(deserializedParams));
struct ESMVariantWriteToESMFailTest : TestWithParam<WriteToESMTestCase>
{
};
TEST_P(ESMVariantWriteToESMFailTest, write_is_not_supported)
{
const auto param = GetParam();
std::ostringstream out;
ESMWriter writer;
writer.save(out);
ASSERT_THROW(param.mVariant.write(writer, param.mFormat), std::runtime_error);
}
INSTANTIATE_TEST_SUITE_P(VariantAndFormat, ESMVariantWriteToESMFailTest,
Values(WriteToESMTestCase{ Variant(), Variant::Format_Global },
WriteToESMTestCase{ Variant(), Variant::Format_Info },
WriteToESMTestCase{ Variant(), Variant::Format_Local },
WriteToESMTestCase{ Variant(int{ 42 }), Variant::Format_Gmst },
WriteToESMTestCase{ Variant(int{ 42 }), Variant::Format_Info },
WriteToESMTestCase{ Variant(int{ 42 }), Variant::Format_Local },
WriteToESMTestCase{ Variant(std::string("foo")), Variant::Format_Global },
WriteToESMTestCase{ Variant(std::string("foo")), Variant::Format_Info },
WriteToESMTestCase{ Variant(std::string("foo")), Variant::Format_Local },
WriteToESMTestCase{ makeVariant(VT_Unknown), Variant::Format_Global },
WriteToESMTestCase{ makeVariant(VT_Int, 42), Variant::Format_Global },
WriteToESMTestCase{ makeVariant(VT_Short, 42), Variant::Format_Gmst },
WriteToESMTestCase{ makeVariant(VT_Short, 42), Variant::Format_Info }));
}
| 16,476
|
C++
|
.cpp
| 440
| 30.252273
| 115
| 0.656871
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,250
|
technique.cpp
|
OpenMW_openmw/apps/components_tests/fx/technique.cpp
|
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <components/files/configurationmanager.hpp>
#include <components/fx/technique.hpp>
#include <components/resource/imagemanager.hpp>
#include <components/settings/settings.hpp>
#include <components/testing/util.hpp>
namespace
{
constexpr VFS::Path::NormalizedView techniquePropertiesPath("shaders/technique_properties.omwfx");
TestingOpenMW::VFSTestFile techniqueProperties(R"(
fragment main {}
vertex main {}
technique {
passes = main;
version = "0.1a";
description = "description";
author = "author";
glsl_version = 330;
glsl_profile = "compatability";
glsl_extensions = GL_EXT_gpu_shader4, GL_ARB_uniform_buffer_object;
flags = disable_sunglare;
hdr = true;
}
)");
constexpr VFS::Path::NormalizedView rendertargetPropertiesPath("shaders/rendertarget_properties.omwfx");
TestingOpenMW::VFSTestFile rendertargetProperties{ R"(
render_target rendertarget {
width_ratio = 0.5;
height_ratio = 0.5;
internal_format = r16f;
source_type = float;
source_format = red;
mipmaps = true;
wrap_s = clamp_to_edge;
wrap_t = repeat;
min_filter = linear;
mag_filter = nearest;
}
fragment downsample2x(target=rendertarget) {
omw_In vec2 omw_TexCoord;
void main()
{
omw_FragColor.r = omw_GetLastShader(omw_TexCoord).r;
}
}
fragment main { }
technique { passes = downsample2x, main; }
)" };
constexpr VFS::Path::NormalizedView uniformPropertiesPath("shaders/uniform_properties.omwfx");
TestingOpenMW::VFSTestFile uniformProperties{ R"(
uniform_vec4 uVec4 {
default = vec4(0,0,0,0);
min = vec4(0,1,0,0);
max = vec4(0,0,1,0);
step = 0.5;
header = "header";
static = true;
description = "description";
}
fragment main { }
technique { passes = main; }
)" };
constexpr VFS::Path::NormalizedView missingSamplerSourcePath("shaders/missing_sampler_source.omwfx");
TestingOpenMW::VFSTestFile missingSamplerSource{ R"(
sampler_1d mysampler1d { }
fragment main { }
technique { passes = main; }
)" };
constexpr VFS::Path::NormalizedView repeatedSharedBlockPath("shaders/repeated_shared_block.omwfx");
TestingOpenMW::VFSTestFile repeatedSharedBlock{ R"(
shared {
float myfloat = 1.0;
}
shared {}
fragment main { }
technique { passes = main; }
)" };
using namespace testing;
using namespace fx;
struct TechniqueTest : Test
{
std::unique_ptr<VFS::Manager> mVFS;
Resource::ImageManager mImageManager;
std::unique_ptr<Technique> mTechnique;
TechniqueTest()
: mVFS(TestingOpenMW::createTestVFS({
{ techniquePropertiesPath, &techniqueProperties },
{ rendertargetPropertiesPath, &rendertargetProperties },
{ uniformPropertiesPath, &uniformProperties },
{ missingSamplerSourcePath, &missingSamplerSource },
{ repeatedSharedBlockPath, &repeatedSharedBlock },
}))
, mImageManager(mVFS.get(), 0)
{
}
void compile(const std::string& name)
{
mTechnique = std::make_unique<Technique>(*mVFS.get(), mImageManager, name, 1, 1, true, true);
mTechnique->compile();
}
};
TEST_F(TechniqueTest, technique_properties)
{
std::unordered_set<std::string> targetExtensions = { "GL_EXT_gpu_shader4", "GL_ARB_uniform_buffer_object" };
compile("technique_properties");
EXPECT_EQ(mTechnique->getVersion(), "0.1a");
EXPECT_EQ(mTechnique->getDescription(), "description");
EXPECT_EQ(mTechnique->getAuthor(), "author");
EXPECT_EQ(mTechnique->getGLSLVersion(), 330);
EXPECT_EQ(mTechnique->getGLSLProfile(), "compatability");
EXPECT_EQ(mTechnique->getGLSLExtensions(), targetExtensions);
EXPECT_EQ(mTechnique->getFlags(), Technique::Flag_Disable_SunGlare);
EXPECT_EQ(mTechnique->getHDR(), true);
EXPECT_EQ(mTechnique->getPasses().size(), 1);
EXPECT_EQ(mTechnique->getPasses().front()->getName(), "main");
}
TEST_F(TechniqueTest, rendertarget_properties)
{
compile("rendertarget_properties");
EXPECT_EQ(mTechnique->getRenderTargetsMap().size(), 1);
const std::string_view name = mTechnique->getRenderTargetsMap().begin()->first;
auto& rt = mTechnique->getRenderTargetsMap().begin()->second;
auto& texture = rt.mTarget;
EXPECT_EQ(name, "rendertarget");
EXPECT_EQ(rt.mMipMap, true);
EXPECT_EQ(rt.mSize.mWidthRatio, 0.5f);
EXPECT_EQ(rt.mSize.mHeightRatio, 0.5f);
EXPECT_EQ(texture->getWrap(osg::Texture::WRAP_S), osg::Texture::CLAMP_TO_EDGE);
EXPECT_EQ(texture->getWrap(osg::Texture::WRAP_T), osg::Texture::REPEAT);
EXPECT_EQ(texture->getFilter(osg::Texture::MIN_FILTER), osg::Texture::LINEAR);
EXPECT_EQ(texture->getFilter(osg::Texture::MAG_FILTER), osg::Texture::NEAREST);
EXPECT_EQ(texture->getSourceType(), static_cast<GLenum>(GL_FLOAT));
EXPECT_EQ(texture->getSourceFormat(), static_cast<GLenum>(GL_RED));
EXPECT_EQ(texture->getInternalFormat(), static_cast<GLint>(GL_R16F));
EXPECT_EQ(mTechnique->getPasses().size(), 2);
EXPECT_EQ(mTechnique->getPasses()[0]->getTarget(), "rendertarget");
}
TEST_F(TechniqueTest, uniform_properties)
{
compile("uniform_properties");
EXPECT_EQ(mTechnique->getUniformMap().size(), 1);
const auto& uniform = mTechnique->getUniformMap().front();
EXPECT_TRUE(uniform->mStatic);
EXPECT_DOUBLE_EQ(uniform->mStep, 0.5);
EXPECT_EQ(uniform->getDefault<osg::Vec4f>(), osg::Vec4f(0, 0, 0, 0));
EXPECT_EQ(uniform->getMin<osg::Vec4f>(), osg::Vec4f(0, 1, 0, 0));
EXPECT_EQ(uniform->getMax<osg::Vec4f>(), osg::Vec4f(0, 0, 1, 0));
EXPECT_EQ(uniform->mHeader, "header");
EXPECT_EQ(uniform->mDescription, "description");
EXPECT_EQ(uniform->mName, "uVec4");
}
TEST_F(TechniqueTest, fail_with_missing_source_for_sampler)
{
internal::CaptureStdout();
compile("missing_sampler_source");
std::string output = internal::GetCapturedStdout();
Log(Debug::Error) << output;
EXPECT_THAT(output, HasSubstr("sampler_1d 'mysampler1d' requires a filename"));
}
TEST_F(TechniqueTest, fail_with_repeated_shared_block)
{
internal::CaptureStdout();
compile("repeated_shared_block");
std::string output = internal::GetCapturedStdout();
Log(Debug::Error) << output;
EXPECT_THAT(output, HasSubstr("repeated 'shared' block"));
}
}
| 6,937
|
C++
|
.cpp
| 169
| 33.402367
| 116
| 0.644883
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,251
|
lexer.cpp
|
OpenMW_openmw/apps/components_tests/fx/lexer.cpp
|
#include <components/fx/lexer.hpp>
#include <gtest/gtest.h>
namespace
{
using namespace testing;
using namespace fx::Lexer;
struct LexerTest : Test
{
};
struct LexerSingleTokenTest : Test
{
template <class Token>
void test()
{
const std::string content = std::string(Token::repr);
Lexer lexer(content);
EXPECT_TRUE(std::holds_alternative<Token>(lexer.next()));
}
};
TEST_F(LexerSingleTokenTest, single_token_shared)
{
test<Shared>();
}
TEST_F(LexerSingleTokenTest, single_token_technique)
{
test<Technique>();
}
TEST_F(LexerSingleTokenTest, single_token_render_target)
{
test<Render_Target>();
}
TEST_F(LexerSingleTokenTest, single_token_vertex)
{
test<Vertex>();
}
TEST_F(LexerSingleTokenTest, single_token_fragment)
{
test<Fragment>();
}
TEST_F(LexerSingleTokenTest, single_token_compute)
{
test<Compute>();
}
TEST_F(LexerSingleTokenTest, single_token_sampler_1d)
{
test<Sampler_1D>();
}
TEST_F(LexerSingleTokenTest, single_token_sampler_2d)
{
test<Sampler_2D>();
}
TEST_F(LexerSingleTokenTest, single_token_sampler_3d)
{
test<Sampler_3D>();
}
TEST_F(LexerSingleTokenTest, single_token_true)
{
test<True>();
}
TEST_F(LexerSingleTokenTest, single_token_false)
{
test<False>();
}
TEST_F(LexerSingleTokenTest, single_token_vec2)
{
test<Vec2>();
}
TEST_F(LexerSingleTokenTest, single_token_vec3)
{
test<Vec3>();
}
TEST_F(LexerSingleTokenTest, single_token_vec4)
{
test<Vec4>();
}
TEST(LexerTest, peek_whitespace_only_content_should_be_eof)
{
Lexer lexer(R"(
)");
EXPECT_TRUE(std::holds_alternative<Eof>(lexer.peek()));
}
TEST(LexerTest, float_with_no_prefixed_digits)
{
Lexer lexer(R"(
0.123;
)");
auto token = lexer.next();
EXPECT_TRUE(std::holds_alternative<Float>(token));
EXPECT_FLOAT_EQ(std::get<Float>(token).value, 0.123f);
}
TEST(LexerTest, float_with_alpha_prefix)
{
Lexer lexer(R"(
abc.123;
)");
EXPECT_TRUE(std::holds_alternative<Literal>(lexer.next()));
auto token = lexer.next();
EXPECT_TRUE(std::holds_alternative<Float>(token));
EXPECT_FLOAT_EQ(std::get<Float>(token).value, 0.123f);
}
TEST(LexerTest, float_with_numeric_prefix)
{
Lexer lexer(R"(
123.123;
)");
auto token = lexer.next();
EXPECT_TRUE(std::holds_alternative<Float>(token));
EXPECT_FLOAT_EQ(std::get<Float>(token).value, 123.123f);
}
TEST(LexerTest, int_should_not_be_float)
{
Lexer lexer(R"(
123
)");
auto token = lexer.next();
EXPECT_TRUE(std::holds_alternative<Integer>(token));
EXPECT_EQ(std::get<Integer>(token).value, 123);
}
TEST(LexerTest, simple_string)
{
Lexer lexer(R"(
"test string"
)");
auto token = lexer.next();
EXPECT_TRUE(std::holds_alternative<String>(token));
std::string parsed = std::string(std::get<String>(token).value);
EXPECT_EQ("test string", parsed);
}
TEST(LexerTest, fail_on_unterminated_double_quotes)
{
Lexer lexer(R"(
"unterminated string'
)");
EXPECT_THROW(lexer.next(), LexerException);
}
TEST(LexerTest, multiline_strings_with_single_quotes)
{
Lexer lexer(R"(
"string that is
on multiple with 'single quotes'
and correctly terminated!"
)");
auto token = lexer.next();
EXPECT_TRUE(std::holds_alternative<String>(token));
}
TEST(LexerTest, fail_on_unterminated_double_quotes_with_multiline_strings)
{
Lexer lexer(R"(
"string that is
on multiple with 'single quotes'
and but is unterminated :(
)");
EXPECT_THROW(lexer.next(), LexerException);
}
TEST(LexerTest, jump_with_single_nested_bracket)
{
const std::string content = R"(
#version 120
void main()
{
return 0;
}})";
const std::string expected = content.substr(0, content.size() - 1);
Lexer lexer(content);
auto block = lexer.jump();
EXPECT_NE(block, std::nullopt);
EXPECT_EQ(expected, std::string(block.value()));
}
TEST(LexerTest, jump_with_single_line_comments_and_mismatching_brackets)
{
const std::string content = R"(
#version 120
void main()
{
// }
return 0;
}})";
const std::string expected = content.substr(0, content.size() - 1);
Lexer lexer(content);
auto block = lexer.jump();
EXPECT_NE(block, std::nullopt);
EXPECT_EQ(expected, std::string(block.value()));
}
TEST(LexerTest, jump_with_multi_line_comments_and_mismatching_brackets)
{
const std::string content = R"(
#version 120
void main()
{
/*
}
*/
return 0;
}})";
const std::string expected = content.substr(0, content.size() - 1);
Lexer lexer(content);
auto block = lexer.jump();
EXPECT_NE(block, std::nullopt);
EXPECT_EQ(expected, std::string(block.value()));
}
TEST(LexerTest, immediate_closed_blocks)
{
Lexer lexer(R"(block{})");
EXPECT_TRUE(std::holds_alternative<Literal>(lexer.next()));
EXPECT_TRUE(std::holds_alternative<Open_bracket>(lexer.next()));
auto block = lexer.jump();
EXPECT_TRUE(block.has_value());
EXPECT_TRUE(block.value().empty());
EXPECT_TRUE(std::holds_alternative<Close_bracket>(lexer.next()));
}
}
| 6,244
|
C++
|
.cpp
| 211
| 21.047393
| 78
| 0.560902
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,252
|
niftest.cpp
|
OpenMW_openmw/apps/niftest/niftest.cpp
|
/// Program to test .nif files both on the FileSystem and in BSA archives.
#include <exception>
#include <filesystem>
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <components/bgsm/file.hpp>
#include <components/files/configurationmanager.hpp>
#include <components/files/constrainedfilestream.hpp>
#include <components/files/conversion.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <components/nif/niffile.hpp>
#include <components/vfs/archive.hpp>
#include <components/vfs/bsaarchive.hpp>
#include <components/vfs/filesystemarchive.hpp>
#include <components/vfs/manager.hpp>
#include <components/vfs/recursivedirectoryiterator.hpp>
#include <boost/program_options.hpp>
// Create local aliases for brevity
namespace bpo = boost::program_options;
enum class FileType
{
BSA,
BA2,
BGEM,
BGSM,
NIF,
KF,
BTO,
BTR,
RDT,
PSA,
Unknown,
};
enum class FileClass
{
Archive,
Material,
NIF,
Unknown,
};
std::pair<FileType, FileClass> classifyFile(const std::filesystem::path& filename)
{
const std::string extension = Misc::StringUtils::lowerCase(Files::pathToUnicodeString(filename.extension()));
if (extension == ".bsa")
return { FileType::BSA, FileClass::Archive };
if (extension == ".ba2")
return { FileType::BA2, FileClass::Archive };
if (extension == ".bgem")
return { FileType::BGEM, FileClass::Material };
if (extension == ".bgsm")
return { FileType::BGSM, FileClass::Material };
if (extension == ".nif")
return { FileType::NIF, FileClass::NIF };
if (extension == ".kf")
return { FileType::KF, FileClass::NIF };
if (extension == ".bto")
return { FileType::BTO, FileClass::NIF };
if (extension == ".btr")
return { FileType::BTR, FileClass::NIF };
if (extension == ".rdt")
return { FileType::RDT, FileClass::NIF };
if (extension == ".psa")
return { FileType::PSA, FileClass::NIF };
return { FileType::Unknown, FileClass::Unknown };
}
std::string getFileTypeName(FileType fileType)
{
switch (fileType)
{
case FileType::BSA:
return "BSA";
case FileType::BA2:
return "BA2";
case FileType::BGEM:
return "BGEM";
case FileType::BGSM:
return "BGSM";
case FileType::NIF:
return "NIF";
case FileType::KF:
return "KF";
case FileType::BTO:
return "BTO";
case FileType::BTR:
return "BTR";
case FileType::RDT:
return "RDT";
case FileType::PSA:
return "PSA";
case FileType::Unknown:
default:
return {};
}
}
bool isBSA(const std::filesystem::path& path)
{
return classifyFile(path).second == FileClass::Archive;
}
std::unique_ptr<VFS::Archive> makeArchive(const std::filesystem::path& path)
{
if (isBSA(path))
return VFS::makeBsaArchive(path);
if (std::filesystem::is_directory(path))
return std::make_unique<VFS::FileSystemArchive>(path);
return nullptr;
}
bool readFile(
const std::filesystem::path& source, const std::filesystem::path& path, const VFS::Manager* vfs, bool quiet)
{
const auto [fileType, fileClass] = classifyFile(path);
if (fileClass != FileClass::NIF && fileClass != FileClass::Material)
return false;
const std::string pathStr = Files::pathToUnicodeString(path);
if (!quiet)
{
std::cout << "Reading " << getFileTypeName(fileType) << " file '" << pathStr << "'";
if (!source.empty())
std::cout << " from '" << Files::pathToUnicodeString(isBSA(source) ? source.filename() : source) << "'";
std::cout << std::endl;
}
const std::filesystem::path fullPath = !source.empty() ? source / path : path;
try
{
switch (fileClass)
{
case FileClass::NIF:
{
Nif::NIFFile file(Files::pathToUnicodeString(fullPath));
Nif::Reader reader(file, nullptr);
if (vfs != nullptr)
reader.parse(vfs->get(pathStr));
else
reader.parse(Files::openConstrainedFileStream(fullPath));
break;
}
case FileClass::Material:
{
if (vfs != nullptr)
Bgsm::parse(vfs->get(pathStr));
else
Bgsm::parse(Files::openConstrainedFileStream(fullPath));
break;
}
default:
break;
}
}
catch (std::exception& e)
{
std::cerr << "Failed to read '" << pathStr << "':" << std::endl << e.what() << std::endl;
}
return true;
}
/// Check all the nif files in a given VFS::Archive
/// \note Can not read a bsa file inside of a bsa file.
void readVFS(std::unique_ptr<VFS::Archive>&& archive, const std::filesystem::path& archivePath, bool quiet)
{
if (archive == nullptr)
return;
if (!quiet)
std::cout << "Reading data source '" << Files::pathToUnicodeString(archivePath) << "'" << std::endl;
VFS::Manager vfs;
vfs.addArchive(std::move(archive));
vfs.buildIndex();
for (const auto& name : vfs.getRecursiveDirectoryIterator())
{
readFile(archivePath, name.value(), &vfs, quiet);
}
if (!archivePath.empty() && !isBSA(archivePath))
{
const Files::Collections fileCollections({ archivePath });
const Files::MultiDirCollection& bsaCol = fileCollections.getCollection(".bsa");
const Files::MultiDirCollection& ba2Col = fileCollections.getCollection(".ba2");
for (const Files::MultiDirCollection& collection : { bsaCol, ba2Col })
{
for (auto& file : collection)
{
try
{
readVFS(VFS::makeBsaArchive(file.second), file.second, quiet);
}
catch (const std::exception& e)
{
std::cerr << "Failed to read archive file '" << Files::pathToUnicodeString(file.second)
<< "': " << e.what() << std::endl;
}
}
}
}
}
bool parseOptions(int argc, char** argv, Files::PathContainer& files, Files::PathContainer& archives,
bool& writeDebugLog, bool& quiet)
{
bpo::options_description desc(
R"(Ensure that OpenMW can use the provided NIF, KF, BTO/BTR, RDT, PSA, BGEM/BGSM and BSA/BA2 files
Usages:
niftest <nif files, kf files, bto/btr files, rdt files, psa files, bgem/bgsm files, BSA/BA2 files, or directories>
Scan the file or directories for NIF errors.
Allowed options)");
auto addOption = desc.add_options();
addOption("help,h", "print help message.");
addOption("write-debug-log,v", "write debug log for unsupported nif files");
addOption("quiet,q", "do not log read archives/files");
addOption("archives", bpo::value<Files::MaybeQuotedPathContainer>(), "path to archive files to provide files");
addOption("input-file", bpo::value<Files::MaybeQuotedPathContainer>(), "input file");
// Default option if none provided
bpo::positional_options_description p;
p.add("input-file", -1);
bpo::variables_map variables;
try
{
bpo::parsed_options valid_opts = bpo::command_line_parser(argc, argv).options(desc).positional(p).run();
bpo::store(valid_opts, variables);
bpo::notify(variables);
if (variables.count("help"))
{
std::cout << desc << std::endl;
return false;
}
writeDebugLog = variables.count("write-debug-log") > 0;
quiet = variables.count("quiet") > 0;
if (variables.count("input-file"))
{
files = asPathContainer(variables["input-file"].as<Files::MaybeQuotedPathContainer>());
if (const auto it = variables.find("archives"); it != variables.end())
archives = asPathContainer(it->second.as<Files::MaybeQuotedPathContainer>());
return true;
}
}
catch (std::exception& e)
{
std::cout << "Error parsing arguments: " << e.what() << "\n\n" << desc << std::endl;
return false;
}
std::cout << "No input files or directories specified!" << std::endl;
std::cout << desc << std::endl;
return false;
}
int main(int argc, char** argv)
{
Files::PathContainer files, sources;
bool writeDebugLog = false;
bool quiet = false;
if (!parseOptions(argc, argv, files, sources, writeDebugLog, quiet))
return 1;
Nif::Reader::setLoadUnsupportedFiles(true);
Nif::Reader::setWriteNifDebugLog(writeDebugLog);
std::unique_ptr<VFS::Manager> vfs;
if (!sources.empty())
{
vfs = std::make_unique<VFS::Manager>();
for (const std::filesystem::path& path : sources)
{
const std::string pathStr = Files::pathToUnicodeString(path);
if (!quiet)
std::cout << "Adding data source '" << pathStr << "'" << std::endl;
try
{
if (auto archive = makeArchive(path))
vfs->addArchive(std::move(archive));
else
std::cerr << "Error: '" << pathStr << "' is not an archive or directory" << std::endl;
}
catch (std::exception& e)
{
std::cerr << "Failed to add data source '" << pathStr << "': " << e.what() << std::endl;
}
}
vfs->buildIndex();
}
for (const auto& path : files)
{
const std::string pathStr = Files::pathToUnicodeString(path);
try
{
const bool isFile = readFile({}, path, vfs.get(), quiet);
if (!isFile)
{
if (auto archive = makeArchive(path))
{
readVFS(std::move(archive), path, quiet);
}
else
{
std::cerr << "Error: '" << pathStr << "' is not a NIF file, material file, archive, or directory"
<< std::endl;
}
}
}
catch (std::exception& e)
{
std::cerr << "Failed to read '" << pathStr << "': " << e.what() << std::endl;
}
}
return 0;
}
| 10,507
|
C++
|
.cpp
| 299
| 27.056856
| 117
| 0.58204
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,253
|
engine.cpp
|
OpenMW_openmw/apps/openmw/engine.cpp
|
#include "engine.hpp"
#include <cerrno>
#include <chrono>
#include <future>
#include <system_error>
#include <osgDB/WriteFile>
#include <osgViewer/ViewerEventHandlers>
#include <SDL.h>
#include <components/debug/debuglog.hpp>
#include <components/debug/gldebug.hpp>
#include <components/misc/rng.hpp>
#include <components/misc/strings/format.hpp>
#include <components/vfs/manager.hpp>
#include <components/vfs/registerarchives.hpp>
#include <components/sdlutil/imagetosurface.hpp>
#include <components/sdlutil/sdlgraphicswindow.hpp>
#include <components/resource/resourcesystem.hpp>
#include <components/resource/scenemanager.hpp>
#include <components/resource/stats.hpp>
#include <components/compiler/extensions0.hpp>
#include <components/stereo/multiview.hpp>
#include <components/stereo/stereomanager.hpp>
#include <components/sceneutil/glextensions.hpp>
#include <components/sceneutil/workqueue.hpp>
#include <components/files/configurationmanager.hpp>
#include <components/version/version.hpp>
#include <components/l10n/manager.hpp>
#include <components/loadinglistener/asynclistener.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/misc/frameratelimiter.hpp>
#include <components/sceneutil/color.hpp>
#include <components/sceneutil/depth.hpp>
#include <components/sceneutil/screencapture.hpp>
#include <components/sceneutil/unrefqueue.hpp>
#include <components/sceneutil/util.hpp>
#include <components/settings/shadermanager.hpp>
#include <components/settings/values.hpp>
#include "mwinput/inputmanagerimp.hpp"
#include "mwgui/windowmanagerimp.hpp"
#include "mwlua/luamanagerimp.hpp"
#include "mwlua/worker.hpp"
#include "mwscript/interpretercontext.hpp"
#include "mwscript/scriptmanagerimp.hpp"
#include "mwsound/constants.hpp"
#include "mwsound/soundmanagerimp.hpp"
#include "mwworld/class.hpp"
#include "mwworld/datetimemanager.hpp"
#include "mwworld/worldimp.hpp"
#include "mwrender/vismask.hpp"
#include "mwclass/classes.hpp"
#include "mwdialogue/dialoguemanagerimp.hpp"
#include "mwdialogue/journalimp.hpp"
#include "mwdialogue/scripttest.hpp"
#include "mwmechanics/mechanicsmanagerimp.hpp"
#include "mwstate/statemanagerimp.hpp"
#include "profile.hpp"
namespace
{
void checkSDLError(int ret)
{
if (ret != 0)
Log(Debug::Error) << "SDL error: " << SDL_GetError();
}
void initStatsHandler(Resource::Profiler& profiler)
{
const osg::Vec4f textColor(1.f, 1.f, 1.f, 1.f);
const osg::Vec4f barColor(1.f, 1.f, 1.f, 1.f);
const float multiplier = 1000;
const bool average = true;
const bool averageInInverseSpace = false;
const float maxValue = 10000;
OMW::forEachUserStatsValue([&](const OMW::UserStats& v) {
profiler.addUserStatsLine(v.mLabel, textColor, barColor, v.mTaken, multiplier, average,
averageInInverseSpace, v.mBegin, v.mEnd, maxValue);
});
// the forEachUserStatsValue loop is "run" at compile time, hence the settings manager is not available.
// Unconditionnally add the async physics stats, and then remove it at runtime if necessary
if (Settings::physics().mAsyncNumThreads == 0)
profiler.removeUserStatsLine(" -Async");
}
struct ScreenCaptureMessageBox
{
void operator()(std::string filePath) const
{
if (filePath.empty())
{
MWBase::Environment::get().getWindowManager()->scheduleMessageBox(
"#{OMWEngine:ScreenshotFailed}", MWGui::ShowInDialogueMode_Never);
return;
}
std::string messageFormat
= MWBase::Environment::get().getL10nManager()->getMessage("OMWEngine", "ScreenshotMade");
std::string message = Misc::StringUtils::format(messageFormat, filePath);
MWBase::Environment::get().getWindowManager()->scheduleMessageBox(
std::move(message), MWGui::ShowInDialogueMode_Never);
}
};
struct IgnoreString
{
void operator()(std::string) const {}
};
class IdentifyOpenGLOperation : public osg::GraphicsOperation
{
public:
IdentifyOpenGLOperation()
: GraphicsOperation("IdentifyOpenGLOperation", false)
{
}
void operator()(osg::GraphicsContext* graphicsContext) override
{
Log(Debug::Info) << "OpenGL Vendor: " << glGetString(GL_VENDOR);
Log(Debug::Info) << "OpenGL Renderer: " << glGetString(GL_RENDERER);
Log(Debug::Info) << "OpenGL Version: " << glGetString(GL_VERSION);
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &mMaxTextureImageUnits);
}
int getMaxTextureImageUnits() const
{
if (mMaxTextureImageUnits == 0)
throw std::logic_error("mMaxTextureImageUnits is not initialized");
return mMaxTextureImageUnits;
}
private:
int mMaxTextureImageUnits = 0;
};
void reportStats(unsigned frameNumber, osgViewer::Viewer& viewer, std::ostream& stream)
{
viewer.getViewerStats()->report(stream, frameNumber);
osgViewer::Viewer::Cameras cameras;
viewer.getCameras(cameras);
for (osg::Camera* camera : cameras)
camera->getStats()->report(stream, frameNumber);
}
}
void OMW::Engine::executeLocalScripts()
{
MWWorld::LocalScripts& localScripts = mWorld->getLocalScripts();
localScripts.startIteration();
std::pair<ESM::RefId, MWWorld::Ptr> script;
while (localScripts.getNext(script))
{
MWScript::InterpreterContext interpreterContext(&script.second.getRefData().getLocals(), script.second);
mScriptManager->run(script.first, interpreterContext);
}
}
bool OMW::Engine::frame(unsigned frameNumber, float frametime)
{
const osg::Timer_t frameStart = mViewer->getStartTick();
const osg::Timer* const timer = osg::Timer::instance();
osg::Stats* const stats = mViewer->getViewerStats();
mEnvironment.setFrameDuration(frametime);
try
{
// update input
{
ScopedProfile<UserStatsType::Input> profile(frameStart, frameNumber, *timer, *stats);
mInputManager->update(frametime, false);
}
// When the window is minimized, pause the game. Currently this *has* to be here to work around a MyGUI bug.
// If we are not currently rendering, then RenderItems will not be reused resulting in a memory leak upon
// changing widget textures (fixed in MyGUI 3.3.2), and destroyed widgets will not be deleted (not fixed yet,
// https://github.com/MyGUI/mygui/issues/21)
{
ScopedProfile<UserStatsType::Sound> profile(frameStart, frameNumber, *timer, *stats);
if (!mWindowManager->isWindowVisible())
{
mSoundManager->pausePlayback();
return false;
}
else
mSoundManager->resumePlayback();
// sound
if (mUseSound)
mSoundManager->update(frametime);
}
{
ScopedProfile<UserStatsType::LuaSyncUpdate> profile(frameStart, frameNumber, *timer, *stats);
// Should be called after input manager update and before any change to the game world.
// It applies to the game world queued changes from the previous frame.
mLuaManager->synchronizedUpdate();
}
// update game state
{
ScopedProfile<UserStatsType::State> profile(frameStart, frameNumber, *timer, *stats);
mStateManager->update(frametime);
}
bool paused = mWorld->getTimeManager()->isPaused();
{
ScopedProfile<UserStatsType::Script> profile(frameStart, frameNumber, *timer, *stats);
if (mStateManager->getState() != MWBase::StateManager::State_NoGame)
{
if (!mWindowManager->containsMode(MWGui::GM_MainMenu) || !paused)
{
if (mWorld->getScriptsEnabled())
{
// local scripts
executeLocalScripts();
// global scripts
mScriptManager->getGlobalScripts().run();
}
mWorld->getWorldScene().markCellAsUnchanged();
}
if (!paused)
{
double hours = (frametime * mWorld->getTimeManager()->getGameTimeScale()) / 3600.0;
mWorld->advanceTime(hours, true);
mWorld->rechargeItems(frametime, true);
}
}
}
// update mechanics
{
ScopedProfile<UserStatsType::Mechanics> profile(frameStart, frameNumber, *timer, *stats);
if (mStateManager->getState() != MWBase::StateManager::State_NoGame)
{
mMechanicsManager->update(frametime, paused);
}
if (mStateManager->getState() == MWBase::StateManager::State_Running)
{
MWWorld::Ptr player = mWorld->getPlayerPtr();
if (!paused && player.getClass().getCreatureStats(player).isDead())
mStateManager->endGame();
}
}
// update physics
{
ScopedProfile<UserStatsType::Physics> profile(frameStart, frameNumber, *timer, *stats);
if (mStateManager->getState() != MWBase::StateManager::State_NoGame)
{
mWorld->updatePhysics(frametime, paused, frameStart, frameNumber, *stats);
}
}
// update world
{
ScopedProfile<UserStatsType::World> profile(frameStart, frameNumber, *timer, *stats);
if (mStateManager->getState() != MWBase::StateManager::State_NoGame)
{
mWorld->update(frametime, paused);
}
}
// update GUI
{
ScopedProfile<UserStatsType::Gui> profile(frameStart, frameNumber, *timer, *stats);
mWindowManager->update(frametime);
}
}
catch (const std::exception& e)
{
Log(Debug::Error) << "Error in frame: " << e.what();
}
const bool reportResource = stats->collectStats("resource");
if (reportResource)
stats->setAttribute(frameNumber, "UnrefQueue", mUnrefQueue->getSize());
mUnrefQueue->flush(*mWorkQueue);
if (reportResource)
{
stats->setAttribute(frameNumber, "FrameNumber", frameNumber);
mResourceSystem->reportStats(frameNumber, stats);
stats->setAttribute(frameNumber, "WorkQueue", mWorkQueue->getNumItems());
stats->setAttribute(frameNumber, "WorkThread", mWorkQueue->getNumActiveThreads());
mMechanicsManager->reportStats(frameNumber, *stats);
mWorld->reportStats(frameNumber, *stats);
mLuaManager->reportStats(frameNumber, *stats);
}
mStereoManager->updateSettings(Settings::camera().mNearClip, Settings::camera().mViewingDistance);
mViewer->eventTraversal();
mViewer->updateTraversal();
// update GUI by world data
{
ScopedProfile<UserStatsType::WindowManager> profile(frameStart, frameNumber, *timer, *stats);
mWorld->updateWindowManager();
}
// if there is a separate Lua thread, it starts the update now
mLuaWorker->allowUpdate(frameStart, frameNumber, *stats);
mViewer->renderingTraversals();
mLuaWorker->finishUpdate(frameStart, frameNumber, *stats);
return true;
}
OMW::Engine::Engine(Files::ConfigurationManager& configurationManager)
: mWindow(nullptr)
, mEncoding(ToUTF8::WINDOWS_1252)
, mScreenCaptureOperation(nullptr)
, mSelectDepthFormatOperation(new SceneUtil::SelectDepthFormatOperation())
, mSelectColorFormatOperation(new SceneUtil::Color::SelectColorFormatOperation())
, mStereoManager(nullptr)
, mSkipMenu(false)
, mUseSound(true)
, mCompileAll(false)
, mCompileAllDialogue(false)
, mWarningsMode(1)
, mScriptConsoleMode(false)
, mActivationDistanceOverride(-1)
, mGrab(true)
, mRandomSeed(0)
, mNewGame(false)
, mCfgMgr(configurationManager)
, mGlMaxTextureImageUnits(0)
{
SDL_SetHint(SDL_HINT_ACCELEROMETER_AS_JOYSTICK, "0"); // We use only gamepads
Uint32 flags
= SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK | SDL_INIT_SENSOR;
if (SDL_WasInit(flags) == 0)
{
SDL_SetMainReady();
if (SDL_Init(flags) != 0)
{
throw std::runtime_error("Could not initialize SDL! " + std::string(SDL_GetError()));
}
}
}
OMW::Engine::~Engine()
{
if (mScreenCaptureOperation != nullptr)
mScreenCaptureOperation->stop();
mMechanicsManager = nullptr;
mDialogueManager = nullptr;
mJournal = nullptr;
mScriptManager = nullptr;
mWindowManager = nullptr;
mWorld = nullptr;
mStereoManager = nullptr;
mSoundManager = nullptr;
mInputManager = nullptr;
mStateManager = nullptr;
mLuaWorker = nullptr;
mLuaManager = nullptr;
mL10nManager = nullptr;
mScriptContext = nullptr;
mUnrefQueue = nullptr;
mWorkQueue = nullptr;
mViewer = nullptr;
mResourceSystem.reset();
mEncoder = nullptr;
if (mWindow)
{
SDL_DestroyWindow(mWindow);
mWindow = nullptr;
}
SDL_Quit();
}
// Set data dir
void OMW::Engine::setDataDirs(const Files::PathContainer& dataDirs)
{
mDataDirs = dataDirs;
mDataDirs.insert(mDataDirs.begin(), mResDir / "vfs");
mFileCollections = Files::Collections(mDataDirs);
}
// Add BSA archive
void OMW::Engine::addArchive(const std::string& archive)
{
mArchives.push_back(archive);
}
// Set resource dir
void OMW::Engine::setResourceDir(const std::filesystem::path& parResDir)
{
mResDir = parResDir;
if (!Version::checkResourcesVersion(mResDir))
Log(Debug::Error) << "Resources dir " << mResDir
<< " doesn't match OpenMW binary, the game may work incorrectly.";
}
// Set start cell name
void OMW::Engine::setCell(const std::string& cellName)
{
mCellName = cellName;
}
void OMW::Engine::addContentFile(const std::string& file)
{
mContentFiles.push_back(file);
}
void OMW::Engine::addGroundcoverFile(const std::string& file)
{
mGroundcoverFiles.emplace_back(file);
}
void OMW::Engine::setSkipMenu(bool skipMenu, bool newGame)
{
mSkipMenu = skipMenu;
mNewGame = newGame;
}
void OMW::Engine::createWindow()
{
const int screen = Settings::video().mScreen;
const int width = Settings::video().mResolutionX;
const int height = Settings::video().mResolutionY;
const Settings::WindowMode windowMode = Settings::video().mWindowMode;
const bool windowBorder = Settings::video().mWindowBorder;
const SDLUtil::VSyncMode vsync = Settings::video().mVsyncMode;
unsigned antialiasing = static_cast<unsigned>(Settings::video().mAntialiasing);
int pos_x = SDL_WINDOWPOS_CENTERED_DISPLAY(screen), pos_y = SDL_WINDOWPOS_CENTERED_DISPLAY(screen);
if (windowMode == Settings::WindowMode::Fullscreen || windowMode == Settings::WindowMode::WindowedFullscreen)
{
pos_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(screen);
pos_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(screen);
}
Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI;
if (windowMode == Settings::WindowMode::Fullscreen)
flags |= SDL_WINDOW_FULLSCREEN;
else if (windowMode == Settings::WindowMode::WindowedFullscreen)
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
// Allows for Windows snapping features to properly work in borderless window
SDL_SetHint("SDL_BORDERLESS_WINDOWED_STYLE", "1");
SDL_SetHint("SDL_BORDERLESS_RESIZABLE_STYLE", "1");
if (!windowBorder)
flags |= SDL_WINDOW_BORDERLESS;
SDL_SetHint(SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, Settings::video().mMinimizeOnFocusLoss ? "1" : "0");
checkSDLError(SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8));
checkSDLError(SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8));
checkSDLError(SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8));
checkSDLError(SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 0));
checkSDLError(SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24));
if (Debug::shouldDebugOpenGL())
checkSDLError(SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG));
if (antialiasing > 0)
{
checkSDLError(SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1));
checkSDLError(SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, antialiasing));
}
osg::ref_ptr<SDLUtil::GraphicsWindowSDL2> graphicsWindow;
while (!graphicsWindow || !graphicsWindow->valid())
{
while (!mWindow)
{
mWindow = SDL_CreateWindow("OpenMW", pos_x, pos_y, width, height, flags);
if (!mWindow)
{
// Try with a lower AA
if (antialiasing > 0)
{
Log(Debug::Warning) << "Warning: " << antialiasing << "x antialiasing not supported, trying "
<< antialiasing / 2;
antialiasing /= 2;
Settings::video().mAntialiasing.set(antialiasing);
checkSDLError(SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, antialiasing));
continue;
}
else
{
std::stringstream error;
error << "Failed to create SDL window: " << SDL_GetError();
throw std::runtime_error(error.str());
}
}
}
// Since we use physical resolution internally, we have to create the window with scaled resolution,
// but we can't get the scale before the window exists, so instead we have to resize aftewards.
int w, h;
SDL_GetWindowSize(mWindow, &w, &h);
int dw, dh;
SDL_GL_GetDrawableSize(mWindow, &dw, &dh);
if (dw != w || dh != h)
{
SDL_SetWindowSize(mWindow, width / (dw / w), height / (dh / h));
}
setWindowIcon();
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
SDL_GetWindowPosition(mWindow, &traits->x, &traits->y);
SDL_GL_GetDrawableSize(mWindow, &traits->width, &traits->height);
traits->windowName = SDL_GetWindowTitle(mWindow);
traits->windowDecoration = !(SDL_GetWindowFlags(mWindow) & SDL_WINDOW_BORDERLESS);
traits->screenNum = SDL_GetWindowDisplayIndex(mWindow);
traits->vsync = 0;
traits->inheritedWindowData = new SDLUtil::GraphicsWindowSDL2::WindowData(mWindow);
graphicsWindow = new SDLUtil::GraphicsWindowSDL2(traits, vsync);
if (!graphicsWindow->valid())
throw std::runtime_error("Failed to create GraphicsContext");
if (traits->samples < antialiasing)
{
Log(Debug::Warning) << "Warning: Framebuffer MSAA level is only " << traits->samples << "x instead of "
<< antialiasing << "x. Trying " << antialiasing / 2 << "x instead.";
graphicsWindow->closeImplementation();
SDL_DestroyWindow(mWindow);
mWindow = nullptr;
antialiasing /= 2;
Settings::video().mAntialiasing.set(antialiasing);
checkSDLError(SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, antialiasing));
continue;
}
if (traits->red < 8)
Log(Debug::Warning) << "Warning: Framebuffer only has a " << traits->red << " bit red channel.";
if (traits->green < 8)
Log(Debug::Warning) << "Warning: Framebuffer only has a " << traits->green << " bit green channel.";
if (traits->blue < 8)
Log(Debug::Warning) << "Warning: Framebuffer only has a " << traits->blue << " bit blue channel.";
if (traits->depth < 24)
Log(Debug::Warning) << "Warning: Framebuffer only has " << traits->depth << " bits of depth precision.";
traits->alpha = 0; // set to 0 to stop ScreenCaptureHandler reading the alpha channel
}
osg::ref_ptr<osg::Camera> camera = mViewer->getCamera();
camera->setGraphicsContext(graphicsWindow);
camera->setViewport(0, 0, graphicsWindow->getTraits()->width, graphicsWindow->getTraits()->height);
osg::ref_ptr<SceneUtil::OperationSequence> realizeOperations = new SceneUtil::OperationSequence(false);
mViewer->setRealizeOperation(realizeOperations);
osg::ref_ptr<IdentifyOpenGLOperation> identifyOp = new IdentifyOpenGLOperation();
realizeOperations->add(identifyOp);
realizeOperations->add(new SceneUtil::GetGLExtensionsOperation());
if (Debug::shouldDebugOpenGL())
realizeOperations->add(new Debug::EnableGLDebugOperation());
realizeOperations->add(mSelectDepthFormatOperation);
realizeOperations->add(mSelectColorFormatOperation);
if (Stereo::getStereo())
{
Stereo::Settings settings;
settings.mMultiview = Settings::stereo().mMultiview;
settings.mAllowDisplayListsForMultiview = Settings::stereo().mAllowDisplayListsForMultiview;
settings.mSharedShadowMaps = Settings::stereo().mSharedShadowMaps;
if (Settings::stereo().mUseCustomView)
{
const osg::Vec3 leftEyeOffset(Settings::stereoView().mLeftEyeOffsetX,
Settings::stereoView().mLeftEyeOffsetY, Settings::stereoView().mLeftEyeOffsetZ);
const osg::Quat leftEyeOrientation(Settings::stereoView().mLeftEyeOrientationX,
Settings::stereoView().mLeftEyeOrientationY, Settings::stereoView().mLeftEyeOrientationZ,
Settings::stereoView().mLeftEyeOrientationW);
const osg::Vec3 rightEyeOffset(Settings::stereoView().mRightEyeOffsetX,
Settings::stereoView().mRightEyeOffsetY, Settings::stereoView().mRightEyeOffsetZ);
const osg::Quat rightEyeOrientation(Settings::stereoView().mRightEyeOrientationX,
Settings::stereoView().mRightEyeOrientationY, Settings::stereoView().mRightEyeOrientationZ,
Settings::stereoView().mRightEyeOrientationW);
settings.mCustomView = Stereo::CustomView{
.mLeft = Stereo::View{
.pose = Stereo::Pose{
.position = leftEyeOffset,
.orientation = leftEyeOrientation,
},
.fov = Stereo::FieldOfView{
.angleLeft = Settings::stereoView().mLeftEyeFovLeft,
.angleRight = Settings::stereoView().mLeftEyeFovRight,
.angleUp = Settings::stereoView().mLeftEyeFovUp,
.angleDown = Settings::stereoView().mLeftEyeFovDown,
},
},
.mRight = Stereo::View{
.pose = Stereo::Pose{
.position = rightEyeOffset,
.orientation = rightEyeOrientation,
},
.fov = Stereo::FieldOfView{
.angleLeft = Settings::stereoView().mRightEyeFovLeft,
.angleRight = Settings::stereoView().mRightEyeFovRight,
.angleUp = Settings::stereoView().mRightEyeFovUp,
.angleDown = Settings::stereoView().mRightEyeFovDown,
},
},
};
}
if (Settings::stereo().mUseCustomEyeResolution)
settings.mEyeResolution
= osg::Vec2i(Settings::stereoView().mEyeResolutionX, Settings::stereoView().mEyeResolutionY);
realizeOperations->add(new Stereo::InitializeStereoOperation(settings));
}
mViewer->realize();
mGlMaxTextureImageUnits = identifyOp->getMaxTextureImageUnits();
mViewer->getEventQueue()->getCurrentEventState()->setWindowRectangle(
0, 0, graphicsWindow->getTraits()->width, graphicsWindow->getTraits()->height);
}
void OMW::Engine::setWindowIcon()
{
std::ifstream windowIconStream;
const auto windowIcon = mResDir / "openmw.png";
windowIconStream.open(windowIcon, std::ios_base::in | std::ios_base::binary);
if (windowIconStream.fail())
Log(Debug::Error) << "Error: Failed to open " << windowIcon;
osgDB::ReaderWriter* reader = osgDB::Registry::instance()->getReaderWriterForExtension("png");
if (!reader)
{
Log(Debug::Error) << "Error: Failed to read window icon, no png readerwriter found";
return;
}
osgDB::ReaderWriter::ReadResult result = reader->readImage(windowIconStream);
if (!result.success())
Log(Debug::Error) << "Error: Failed to read " << windowIcon << ": " << result.message() << " code "
<< result.status();
else
{
osg::ref_ptr<osg::Image> image = result.getImage();
auto surface = SDLUtil::imageToSurface(image, true);
SDL_SetWindowIcon(mWindow, surface.get());
}
}
void OMW::Engine::prepareEngine()
{
mStateManager = std::make_unique<MWState::StateManager>(mCfgMgr.getUserDataPath() / "saves", mContentFiles);
mEnvironment.setStateManager(*mStateManager);
const bool stereoEnabled = Settings::stereo().mStereoEnabled || osg::DisplaySettings::instance().get()->getStereo();
mStereoManager = std::make_unique<Stereo::Manager>(
mViewer, stereoEnabled, Settings::camera().mNearClip, Settings::camera().mViewingDistance);
osg::ref_ptr<osg::Group> rootNode(new osg::Group);
mViewer->setSceneData(rootNode);
createWindow();
mVFS = std::make_unique<VFS::Manager>();
VFS::registerArchives(mVFS.get(), mFileCollections, mArchives, true);
mResourceSystem = std::make_unique<Resource::ResourceSystem>(
mVFS.get(), Settings::cells().mCacheExpiryDelay, &mEncoder.get()->getStatelessEncoder());
mResourceSystem->getSceneManager()->getShaderManager().setMaxTextureUnits(mGlMaxTextureImageUnits);
mResourceSystem->getSceneManager()->setUnRefImageDataAfterApply(
false); // keep to Off for now to allow better state sharing
mResourceSystem->getSceneManager()->setFilterSettings(Settings::general().mTextureMagFilter,
Settings::general().mTextureMinFilter, Settings::general().mTextureMipmap, Settings::general().mAnisotropy);
mEnvironment.setResourceSystem(*mResourceSystem);
mWorkQueue = new SceneUtil::WorkQueue(Settings::cells().mPreloadNumThreads);
mUnrefQueue = std::make_unique<SceneUtil::UnrefQueue>();
mScreenCaptureOperation = new SceneUtil::AsyncScreenCaptureOperation(mWorkQueue,
new SceneUtil::WriteScreenshotToFileOperation(mCfgMgr.getScreenshotPath(),
Settings::general().mScreenshotFormat,
Settings::general().mNotifyOnSavedScreenshot ? std::function<void(std::string)>(ScreenCaptureMessageBox{})
: std::function<void(std::string)>(IgnoreString{})));
mScreenCaptureHandler = new osgViewer::ScreenCaptureHandler(mScreenCaptureOperation);
mViewer->addEventHandler(mScreenCaptureHandler);
mL10nManager = std::make_unique<l10n::Manager>(mVFS.get());
mL10nManager->setPreferredLocales(Settings::general().mPreferredLocales, Settings::general().mGmstOverridesL10n);
mEnvironment.setL10nManager(*mL10nManager);
mLuaManager = std::make_unique<MWLua::LuaManager>(mVFS.get(), mResDir / "lua_libs");
mEnvironment.setLuaManager(*mLuaManager);
// Create input and UI first to set up a bootstrapping environment for
// showing a loading screen and keeping the window responsive while doing so
const auto keybinderUser = mCfgMgr.getUserConfigPath() / "input_v3.xml";
bool keybinderUserExists = std::filesystem::exists(keybinderUser);
if (!keybinderUserExists)
{
const auto input2 = (mCfgMgr.getUserConfigPath() / "input_v2.xml");
if (std::filesystem::exists(input2))
{
keybinderUserExists = std::filesystem::copy_file(input2, keybinderUser);
Log(Debug::Info) << "Loading keybindings file: " << keybinderUser;
}
}
else
Log(Debug::Info) << "Loading keybindings file: " << keybinderUser;
const auto userdefault = mCfgMgr.getUserConfigPath() / "gamecontrollerdb.txt";
const auto localdefault = mCfgMgr.getLocalPath() / "gamecontrollerdb.txt";
const auto globaldefault = mCfgMgr.getGlobalPath() / "gamecontrollerdb.txt";
std::filesystem::path userGameControllerdb;
if (std::filesystem::exists(userdefault))
userGameControllerdb = userdefault;
std::filesystem::path gameControllerdb;
if (std::filesystem::exists(localdefault))
gameControllerdb = localdefault;
else if (std::filesystem::exists(globaldefault))
gameControllerdb = globaldefault;
// else if it doesn't exist, pass in an empty string
// gui needs our shaders path before everything else
mResourceSystem->getSceneManager()->setShaderPath(mResDir / "shaders");
osg::GLExtensions& exts = SceneUtil::getGLExtensions();
bool shadersSupported = exts.glslLanguageVersion >= 1.2f;
#if OSG_VERSION_LESS_THAN(3, 6, 6)
// hack fix for https://github.com/openscenegraph/OpenSceneGraph/issues/1028
if (!osg::isGLExtensionSupported(exts.contextID, "NV_framebuffer_multisample_coverage"))
exts.glRenderbufferStorageMultisampleCoverageNV = nullptr;
#endif
osg::ref_ptr<osg::Group> guiRoot = new osg::Group;
guiRoot->setName("GUI Root");
guiRoot->setNodeMask(MWRender::Mask_GUI);
mStereoManager->disableStereoForNode(guiRoot);
rootNode->addChild(guiRoot);
mWindowManager = std::make_unique<MWGui::WindowManager>(mWindow, mViewer, guiRoot, mResourceSystem.get(),
mWorkQueue.get(), mCfgMgr.getLogPath(), mScriptConsoleMode, mTranslationDataStorage, mEncoding,
Version::getOpenmwVersionDescription(), shadersSupported, mCfgMgr);
mEnvironment.setWindowManager(*mWindowManager);
mInputManager = std::make_unique<MWInput::InputManager>(mWindow, mViewer, mScreenCaptureHandler, keybinderUser,
keybinderUserExists, userGameControllerdb, gameControllerdb, mGrab);
mEnvironment.setInputManager(*mInputManager);
// Create sound system
mSoundManager = std::make_unique<MWSound::SoundManager>(mVFS.get(), mUseSound);
mEnvironment.setSoundManager(*mSoundManager);
// Create the world
mWorld = std::make_unique<MWWorld::World>(
mResourceSystem.get(), mActivationDistanceOverride, mCellName, mCfgMgr.getUserDataPath());
mEnvironment.setWorld(*mWorld);
mEnvironment.setWorldModel(mWorld->getWorldModel());
mEnvironment.setESMStore(mWorld->getStore());
Loading::Listener* listener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
Loading::AsyncListener asyncListener(*listener);
auto dataLoading = std::async(std::launch::async,
[&] { mWorld->loadData(mFileCollections, mContentFiles, mGroundcoverFiles, mEncoder.get(), &asyncListener); });
if (!mSkipMenu)
{
std::string_view logo = Fallback::Map::getString("Movies_Company_Logo");
if (!logo.empty())
mWindowManager->playVideo(logo, true);
}
listener->loadingOn();
{
using namespace std::chrono_literals;
while (dataLoading.wait_for(50ms) != std::future_status::ready)
asyncListener.update();
dataLoading.get();
}
listener->loadingOff();
mWorld->init(mViewer, std::move(rootNode), mWorkQueue.get(), *mUnrefQueue);
mEnvironment.setWorldScene(mWorld->getWorldScene());
mWorld->setupPlayer();
mWorld->setRandomSeed(mRandomSeed);
const MWWorld::Store<ESM::GameSetting>* gmst = &mWorld->getStore().get<ESM::GameSetting>();
mL10nManager->setGmstLoader(
[gmst, misses = std::set<std::string, std::less<>>()](std::string_view gmstName) mutable {
const ESM::GameSetting* res = gmst->search(gmstName);
if (res && res->mValue.getType() == ESM::VT_String)
return res->mValue.getString();
else
{
if (misses.count(gmstName) == 0)
{
misses.emplace(gmstName);
Log(Debug::Error) << "GMST " << gmstName << " not found";
}
return std::string("GMST:") + std::string(gmstName);
}
});
mWindowManager->setStore(mWorld->getStore());
mWindowManager->initUI();
// Load translation data
mTranslationDataStorage.setEncoder(mEncoder.get());
for (auto& mContentFile : mContentFiles)
mTranslationDataStorage.loadTranslationData(mFileCollections, mContentFile);
Compiler::registerExtensions(mExtensions);
// Create script system
mScriptContext = std::make_unique<MWScript::CompilerContext>(MWScript::CompilerContext::Type_Full);
mScriptContext->setExtensions(&mExtensions);
mScriptManager = std::make_unique<MWScript::ScriptManager>(mWorld->getStore(), *mScriptContext, mWarningsMode);
mEnvironment.setScriptManager(*mScriptManager);
// Create game mechanics system
mMechanicsManager = std::make_unique<MWMechanics::MechanicsManager>();
mEnvironment.setMechanicsManager(*mMechanicsManager);
// Create dialog system
mJournal = std::make_unique<MWDialogue::Journal>();
mEnvironment.setJournal(*mJournal);
mDialogueManager = std::make_unique<MWDialogue::DialogueManager>(mExtensions, mTranslationDataStorage);
mEnvironment.setDialogueManager(*mDialogueManager);
// scripts
if (mCompileAll)
{
std::pair<int, int> result = mScriptManager->compileAll();
if (result.first)
Log(Debug::Info) << "compiled " << result.second << " of " << result.first << " scripts ("
<< 100 * static_cast<double>(result.second) / result.first << "%)";
}
if (mCompileAllDialogue)
{
std::pair<int, int> result = MWDialogue::ScriptTest::compileAll(&mExtensions, mWarningsMode);
if (result.first)
Log(Debug::Info) << "compiled " << result.second << " of " << result.first << " dialogue scripts ("
<< 100 * static_cast<double>(result.second) / result.first << "%)";
}
mLuaManager->loadPermanentStorage(mCfgMgr.getUserConfigPath());
mLuaManager->init();
// starts a separate lua thread if "lua num threads" > 0
mLuaWorker = std::make_unique<MWLua::Worker>(*mLuaManager);
}
// Initialise and enter main loop.
void OMW::Engine::go()
{
assert(!mContentFiles.empty());
Log(Debug::Info) << "OSG version: " << osgGetVersion();
SDL_version sdlVersion;
SDL_GetVersion(&sdlVersion);
Log(Debug::Info) << "SDL version: " << (int)sdlVersion.major << "." << (int)sdlVersion.minor << "."
<< (int)sdlVersion.patch;
Misc::Rng::init(mRandomSeed);
Settings::ShaderManager::get().load(mCfgMgr.getUserConfigPath() / "shaders.yaml");
MWClass::registerClasses();
// Create encoder
mEncoder = std::make_unique<ToUTF8::Utf8Encoder>(mEncoding);
// Setup viewer
mViewer = new osgViewer::Viewer;
mViewer->setReleaseContextAtEndOfFrameHint(false);
// Do not try to outsmart the OS thread scheduler (see bug #4785).
mViewer->setUseConfigureAffinity(false);
mEnvironment.setFrameRateLimit(Settings::video().mFramerateLimit);
prepareEngine();
#ifdef _WIN32
const auto* stats_file = _wgetenv(L"OPENMW_OSG_STATS_FILE");
#else
const auto* stats_file = std::getenv("OPENMW_OSG_STATS_FILE");
#endif
std::filesystem::path path;
if (stats_file != nullptr)
path = stats_file;
std::ofstream stats;
if (!path.empty())
{
stats.open(path, std::ios_base::out);
if (stats.is_open())
Log(Debug::Info) << "OSG stats will be written to: " << path;
else
Log(Debug::Warning) << "Failed to open file to write OSG stats \"" << path
<< "\": " << std::generic_category().message(errno);
}
// Setup profiler
osg::ref_ptr<Resource::Profiler> statsHandler = new Resource::Profiler(stats.is_open(), *mVFS);
initStatsHandler(*statsHandler);
mViewer->addEventHandler(statsHandler);
osg::ref_ptr<Resource::StatsHandler> resourcesHandler = new Resource::StatsHandler(stats.is_open(), *mVFS);
mViewer->addEventHandler(resourcesHandler);
if (stats.is_open())
Resource::collectStatistics(*mViewer);
// Start the game
if (!mSaveGameFile.empty())
{
mStateManager->loadGame(mSaveGameFile);
}
else if (!mSkipMenu)
{
// start in main menu
mWindowManager->pushGuiMode(MWGui::GM_MainMenu);
if (mVFS->exists(MWSound::titleMusic))
mSoundManager->streamMusic(MWSound::titleMusic, MWSound::MusicType::Normal);
else
Log(Debug::Warning) << "Title music not found";
std::string_view logo = Fallback::Map::getString("Movies_Morrowind_Logo");
if (!logo.empty())
mWindowManager->playVideo(logo, /*allowSkipping*/ true, /*overrideSounds*/ false);
}
else
{
mStateManager->newGame(!mNewGame);
}
if (!mStartupScript.empty() && mStateManager->getState() == MWState::StateManager::State_Running)
{
mWindowManager->executeInConsole(mStartupScript);
}
// Start the main rendering loop
MWWorld::DateTimeManager& timeManager = *mWorld->getTimeManager();
Misc::FrameRateLimiter frameRateLimiter = Misc::makeFrameRateLimiter(mEnvironment.getFrameRateLimit());
const std::chrono::steady_clock::duration maxSimulationInterval(std::chrono::milliseconds(200));
while (!mViewer->done() && !mStateManager->hasQuitRequest())
{
const double dt = std::chrono::duration_cast<std::chrono::duration<double>>(
std::min(frameRateLimiter.getLastFrameDuration(), maxSimulationInterval))
.count()
* timeManager.getSimulationTimeScale();
mViewer->advance(timeManager.getRenderingSimulationTime());
const unsigned frameNumber = mViewer->getFrameStamp()->getFrameNumber();
if (!frame(frameNumber, dt))
{
std::this_thread::sleep_for(std::chrono::milliseconds(5));
continue;
}
timeManager.updateIsPaused();
if (!timeManager.isPaused())
{
timeManager.setSimulationTime(timeManager.getSimulationTime() + dt);
timeManager.setRenderingSimulationTime(timeManager.getRenderingSimulationTime() + dt);
}
if (stats)
{
// The delay is required because rendering happens in parallel to the main thread and stats from there is
// available with delay.
constexpr unsigned statsReportDelay = 3;
if (frameNumber >= statsReportDelay)
{
// Viewer frame number can be different from frameNumber because of loading screens which render new
// frames inside a simulation frame.
const unsigned currentFrameNumber = mViewer->getFrameStamp()->getFrameNumber();
for (unsigned i = frameNumber; i <= currentFrameNumber; ++i)
reportStats(i - statsReportDelay, *mViewer, stats);
}
}
frameRateLimiter.limit();
}
mLuaWorker->join();
// Save user settings
Settings::Manager::saveUser(mCfgMgr.getUserConfigPath() / "settings.cfg");
Settings::ShaderManager::get().save();
mLuaManager->savePermanentStorage(mCfgMgr.getUserConfigPath());
Log(Debug::Info) << "Quitting peacefully.";
}
void OMW::Engine::setCompileAll(bool all)
{
mCompileAll = all;
}
void OMW::Engine::setCompileAllDialogue(bool all)
{
mCompileAllDialogue = all;
}
void OMW::Engine::setSoundUsage(bool soundUsage)
{
mUseSound = soundUsage;
}
void OMW::Engine::setEncoding(const ToUTF8::FromType& encoding)
{
mEncoding = encoding;
}
void OMW::Engine::setScriptConsoleMode(bool enabled)
{
mScriptConsoleMode = enabled;
}
void OMW::Engine::setStartupScript(const std::filesystem::path& path)
{
mStartupScript = path;
}
void OMW::Engine::setActivationDistanceOverride(int distance)
{
mActivationDistanceOverride = distance;
}
void OMW::Engine::setWarningsMode(int mode)
{
mWarningsMode = mode;
}
void OMW::Engine::setSaveGameFile(const std::filesystem::path& savegame)
{
mSaveGameFile = savegame;
}
void OMW::Engine::setRandomSeed(unsigned int seed)
{
mRandomSeed = seed;
}
| 41,013
|
C++
|
.cpp
| 903
| 37.157254
| 120
| 0.663074
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,254
|
main.cpp
|
OpenMW_openmw/apps/openmw/main.cpp
|
#include <components/debug/debugging.hpp>
#include <components/fallback/fallback.hpp>
#include <components/fallback/validate.hpp>
#include <components/files/configurationmanager.hpp>
#include <components/misc/osgpluginchecker.hpp>
#include <components/misc/rng.hpp>
#include <components/platform/platform.hpp>
#include <components/version/version.hpp>
#include "mwgui/debugwindow.hpp"
#include "engine.hpp"
#include "options.hpp"
#include <boost/program_options/variables_map.hpp>
#if defined(_WIN32)
#include <components/misc/windows.hpp>
// makes __argc and __argv available on windows
#include <cstdlib>
extern "C" __declspec(dllexport) DWORD AmdPowerXpressRequestHighPerformance = 0x00000001;
#endif
#include <filesystem>
#if (defined(__APPLE__) || defined(__linux) || defined(__unix) || defined(__posix))
#include <unistd.h>
#endif
using namespace Fallback;
/**
* \brief Parses application command line and calls \ref Cfg::ConfigurationManager
* to parse configuration files.
*
* Results are directly written to \ref Engine class.
*
* \retval true - Everything goes OK
* \retval false - Error
*/
bool parseOptions(int argc, char** argv, OMW::Engine& engine, Files::ConfigurationManager& cfgMgr)
{
// Create a local alias for brevity
namespace bpo = boost::program_options;
typedef std::vector<std::string> StringsVector;
bpo::options_description desc = OpenMW::makeOptionsDescription();
bpo::variables_map variables;
Files::parseArgs(argc, argv, variables, desc);
bpo::notify(variables);
if (variables.count("help"))
{
Debug::getRawStdout() << desc << std::endl;
return false;
}
if (variables.count("version"))
{
Debug::getRawStdout() << Version::getOpenmwVersionDescription() << std::endl;
return false;
}
cfgMgr.readConfiguration(variables, desc);
Debug::setupLogging(cfgMgr.getLogPath(), "OpenMW");
Log(Debug::Info) << Version::getOpenmwVersionDescription();
Settings::Manager::load(cfgMgr);
MWGui::DebugWindow::startLogRecording();
engine.setGrabMouse(!variables["no-grab"].as<bool>());
// Font encoding settings
std::string encoding(variables["encoding"].as<std::string>());
Log(Debug::Info) << ToUTF8::encodingUsingMessage(encoding);
engine.setEncoding(ToUTF8::calculateEncoding(encoding));
Files::PathContainer dataDirs(asPathContainer(variables["data"].as<Files::MaybeQuotedPathContainer>()));
Files::PathContainer::value_type local(variables["data-local"]
.as<Files::MaybeQuotedPathContainer::value_type>()
.u8string()); // This call to u8string is redundant, but required to
// build on MSVC 14.26 due to implementation bugs.
if (!local.empty())
dataDirs.push_back(local);
cfgMgr.filterOutNonExistingPaths(dataDirs);
engine.setResourceDir(variables["resources"]
.as<Files::MaybeQuotedPath>()
.u8string()); // This call to u8string is redundant, but required to build on MSVC 14.26
// due to implementation bugs.
engine.setDataDirs(dataDirs);
// fallback archives
StringsVector archives = variables["fallback-archive"].as<StringsVector>();
for (StringsVector::const_iterator it = archives.begin(); it != archives.end(); ++it)
{
engine.addArchive(*it);
}
StringsVector content = variables["content"].as<StringsVector>();
if (content.empty())
{
Log(Debug::Error) << "No content file given (esm/esp, nor omwgame/omwaddon). Aborting...";
return false;
}
engine.addContentFile("builtin.omwscripts");
std::set<std::string> contentDedupe{ "builtin.omwscripts" };
for (const auto& contentFile : content)
{
if (!contentDedupe.insert(contentFile).second)
{
Log(Debug::Error) << "Content file specified more than once: " << contentFile << ". Aborting...";
return false;
}
}
for (auto& file : content)
{
engine.addContentFile(file);
}
StringsVector groundcover = variables["groundcover"].as<StringsVector>();
for (auto& file : groundcover)
{
engine.addGroundcoverFile(file);
}
if (variables.count("lua-scripts"))
{
Log(Debug::Warning) << "Lua scripts have been specified via the old lua-scripts option and will not be loaded. "
"Please update them to a version which uses the new omwscripts format.";
}
// startup-settings
engine.setCell(variables["start"].as<std::string>());
engine.setSkipMenu(variables["skip-menu"].as<bool>(), variables["new-game"].as<bool>());
if (!variables["skip-menu"].as<bool>() && variables["new-game"].as<bool>())
Log(Debug::Warning) << "Warning: new-game used without skip-menu -> ignoring it";
// scripts
engine.setCompileAll(variables["script-all"].as<bool>());
engine.setCompileAllDialogue(variables["script-all-dialogue"].as<bool>());
engine.setScriptConsoleMode(variables["script-console"].as<bool>());
engine.setStartupScript(variables["script-run"].as<std::string>());
engine.setWarningsMode(variables["script-warn"].as<int>());
engine.setSaveGameFile(variables["load-savegame"].as<Files::MaybeQuotedPath>().u8string());
// other settings
Fallback::Map::init(variables["fallback"].as<FallbackMap>().mMap);
engine.setSoundUsage(!variables["no-sound"].as<bool>());
engine.setActivationDistanceOverride(variables["activate-dist"].as<int>());
engine.setRandomSeed(variables["random-seed"].as<unsigned int>());
return true;
}
namespace
{
class OSGLogHandler : public osg::NotifyHandler
{
void notify(osg::NotifySeverity severity, const char* msg) override
{
// Copy, because osg logging is not thread safe.
std::string msgCopy(msg);
if (msgCopy.empty())
return;
Debug::Level level;
switch (severity)
{
case osg::ALWAYS:
case osg::FATAL:
level = Debug::Error;
break;
case osg::WARN:
case osg::NOTICE:
level = Debug::Warning;
break;
case osg::INFO:
level = Debug::Info;
break;
case osg::DEBUG_INFO:
case osg::DEBUG_FP:
default:
level = Debug::Debug;
}
std::string_view s(msgCopy);
if (s.size() < 1024)
Log(level) << (s.back() == '\n' ? s.substr(0, s.size() - 1) : s);
else
{
while (!s.empty())
{
size_t lineSize = 1;
while (lineSize < s.size() && s[lineSize - 1] != '\n')
lineSize++;
Log(level) << s.substr(0, s[lineSize - 1] == '\n' ? lineSize - 1 : lineSize);
s = s.substr(lineSize);
}
}
}
};
}
int runApplication(int argc, char* argv[])
{
Platform::init();
#ifdef __APPLE__
setenv("OSG_GL_TEXTURE_STORAGE", "OFF", 0);
#endif
osg::setNotifyHandler(new OSGLogHandler());
Files::ConfigurationManager cfgMgr;
std::unique_ptr<OMW::Engine> engine = std::make_unique<OMW::Engine>(cfgMgr);
if (parseOptions(argc, argv, *engine, cfgMgr))
{
if (!Misc::checkRequiredOSGPluginsArePresent())
return 1;
engine->go();
}
return 0;
}
#ifdef ANDROID
extern "C" int SDL_main(int argc, char** argv)
#else
int main(int argc, char** argv)
#endif
{
return Debug::wrapApplication(&runApplication, argc, argv, "OpenMW");
}
// Platform specific for Windows when there is no console built into the executable.
// Windows will call the WinMain function instead of main in this case, the normal
// main function is then called with the __argc and __argv parameters.
#if defined(_WIN32) && !defined(_CONSOLE)
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{
return main(__argc, __argv);
}
#endif
| 8,417
|
C++
|
.cpp
| 209
| 32.248804
| 120
| 0.62601
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,255
|
android_main.cpp
|
OpenMW_openmw/apps/openmw/android_main.cpp
|
#ifndef stderr
int stderr = 0; // Hack: fix linker error
#endif
#include "SDL_main.h"
#include <SDL_events.h>
#include <SDL_gamecontroller.h>
#include <SDL_mouse.h>
/*******************************************************************************
Functions called by JNI
*******************************************************************************/
#include <jni.h>
/* Called before to initialize JNI bindings */
extern void SDL_Android_Init(JNIEnv* env, jclass cls);
extern int argcData;
extern const char** argvData;
void releaseArgv();
extern "C" int Java_org_libsdl_app_SDLActivity_getMouseX(JNIEnv* env, jclass cls, jobject obj)
{
int ret = 0;
SDL_GetMouseState(&ret, nullptr);
return ret;
}
extern "C" int Java_org_libsdl_app_SDLActivity_getMouseY(JNIEnv* env, jclass cls, jobject obj)
{
int ret = 0;
SDL_GetMouseState(nullptr, &ret);
return ret;
}
extern "C" int Java_org_libsdl_app_SDLActivity_isMouseShown(JNIEnv* env, jclass cls, jobject obj)
{
return SDL_ShowCursor(SDL_QUERY);
}
extern SDL_Window* Android_Window;
extern "C" int SDL_SendMouseMotion(SDL_Window* window, int mouseID, int relative, int x, int y);
extern "C" void Java_org_libsdl_app_SDLActivity_sendRelativeMouseMotion(JNIEnv* env, jclass cls, int x, int y)
{
SDL_SendMouseMotion(Android_Window, 0, 1, x, y);
}
extern "C" int SDL_SendMouseButton(SDL_Window* window, int mouseID, Uint8 state, Uint8 button);
extern "C" void Java_org_libsdl_app_SDLActivity_sendMouseButton(JNIEnv* env, jclass cls, int state, int button)
{
SDL_SendMouseButton(Android_Window, 0, state, button);
}
extern "C" int Java_org_libsdl_app_SDLActivity_nativeInit(JNIEnv* env, jclass cls, jobject obj)
{
setenv("OPENMW_DECOMPRESS_TEXTURES", "1", 1);
// On Android, we use a virtual controller with guid="Virtual"
SDL_GameControllerAddMapping(
"5669727475616c000000000000000000,Virtual,a:b0,b:b1,back:b15,dpdown:h0.4,dpleft:h0.8,dpright:h0.2,dpup:h0.1,"
"guide:b16,leftshoulder:b6,leftstick:b13,lefttrigger:a5,leftx:a0,lefty:a1,rightshoulder:b7,rightstick:b14,"
"righttrigger:a4,rightx:a2,righty:a3,start:b11,x:b3,y:b4");
return 0;
}
| 2,175
|
C++
|
.cpp
| 53
| 38.339623
| 117
| 0.688152
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,256
|
options.cpp
|
OpenMW_openmw/apps/openmw/options.cpp
|
#include "options.hpp"
#include <components/fallback/validate.hpp>
#include <components/files/configurationmanager.hpp>
#include <components/misc/rng.hpp>
namespace
{
namespace bpo = boost::program_options;
typedef std::vector<std::string> StringsVector;
}
namespace OpenMW
{
bpo::options_description makeOptionsDescription()
{
bpo::options_description desc("Syntax: openmw <options>\nAllowed options");
Files::ConfigurationManager::addCommonOptions(desc);
auto addOption = desc.add_options();
addOption("help", "print help message");
addOption("version", "print version information and quit");
addOption("data",
bpo::value<Files::MaybeQuotedPathContainer>()
->default_value(Files::MaybeQuotedPathContainer(), "data")
->multitoken()
->composing(),
"set data directories (later directories have higher priority)");
addOption("data-local", bpo::value<Files::MaybeQuotedPath>()->default_value(Files::MaybeQuotedPath(), ""),
"set local data directory (highest priority)");
addOption("fallback-archive",
bpo::value<StringsVector>()->default_value(StringsVector(), "fallback-archive")->multitoken()->composing(),
"set fallback BSA archives (later archives have higher priority)");
addOption("start", bpo::value<std::string>()->default_value(""), "set initial cell");
addOption("content", bpo::value<StringsVector>()->default_value(StringsVector(), "")->multitoken()->composing(),
"content file(s): esm/esp, or omwgame/omwaddon/omwscripts");
addOption("groundcover",
bpo::value<StringsVector>()->default_value(StringsVector(), "")->multitoken()->composing(),
"groundcover content file(s): esm/esp, or omwgame/omwaddon");
addOption("no-sound", bpo::value<bool>()->implicit_value(true)->default_value(false), "disable all sounds");
addOption("script-all", bpo::value<bool>()->implicit_value(true)->default_value(false),
"compile all scripts (excluding dialogue scripts) at startup");
addOption("script-all-dialogue", bpo::value<bool>()->implicit_value(true)->default_value(false),
"compile all dialogue scripts at startup");
addOption("script-console", bpo::value<bool>()->implicit_value(true)->default_value(false),
"enable console-only script functionality");
addOption("script-run", bpo::value<std::string>()->default_value(""),
"select a file containing a list of console commands that is executed on startup");
addOption("script-warn", bpo::value<int>()->implicit_value(1)->default_value(1),
"handling of warnings when compiling scripts\n"
"\t0 - ignore warning\n"
"\t1 - show warning but consider script as correctly compiled anyway\n"
"\t2 - treat warnings as errors");
addOption("load-savegame", bpo::value<Files::MaybeQuotedPath>()->default_value(Files::MaybeQuotedPath(), ""),
"load a save game file on game startup (specify an absolute filename or a filename relative to the current "
"working directory)");
addOption("skip-menu", bpo::value<bool>()->implicit_value(true)->default_value(false),
"skip main menu on game startup");
addOption("new-game", bpo::value<bool>()->implicit_value(true)->default_value(false),
"run new game sequence (ignored if skip-menu=0)");
addOption("encoding", bpo::value<std::string>()->default_value("win1252"),
"Character encoding used in OpenMW game messages:\n"
"\n\twin1250 - Central and Eastern European such as Polish, Czech, Slovak, Hungarian, Slovene, Bosnian, "
"Croatian, Serbian (Latin script), Romanian and Albanian languages\n"
"\n\twin1251 - Cyrillic alphabet such as Russian, Bulgarian, Serbian Cyrillic and other languages\n"
"\n\twin1252 - Western European (Latin) alphabet, used by default");
addOption("fallback",
bpo::value<Fallback::FallbackMap>()->default_value(Fallback::FallbackMap(), "")->multitoken()->composing(),
"fallback values");
addOption("no-grab", bpo::value<bool>()->implicit_value(true)->default_value(false), "Don't grab mouse cursor");
addOption("export-fonts", bpo::value<bool>()->implicit_value(true)->default_value(false),
"Export Morrowind .fnt fonts to PNG image and XML file in current directory");
addOption("activate-dist", bpo::value<int>()->default_value(-1), "activation distance override");
addOption("random-seed", bpo::value<unsigned int>()->default_value(Misc::Rng::generateDefaultSeed()),
"seed value for random number generator");
return desc;
}
}
| 4,893
|
C++
|
.cpp
| 74
| 56.22973
| 120
| 0.658878
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,257
|
magiceffects.cpp
|
OpenMW_openmw/apps/openmw/mwworld/magiceffects.cpp
|
#include "magiceffects.hpp"
#include "esmstore.hpp"
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadskil.hpp>
#include <components/esm3/loadspel.hpp>
#include <components/esm3/loadweap.hpp>
#include <components/esm3/npcstate.hpp>
#include "../mwbase/environment.hpp"
#include "../mwworld/worldmodel.hpp"
#include "../mwmechanics/magiceffects.hpp"
namespace
{
template <class T>
void getEnchantedItem(const ESM::RefId& id, ESM::RefId& enchantment, std::string& itemName)
{
const T* item = MWBase::Environment::get().getESMStore()->get<T>().search(id);
if (item)
{
enchantment = item->mEnchant;
itemName = item->mName;
}
}
}
namespace MWWorld
{
void convertMagicEffects(ESM::CreatureStats& creatureStats, ESM::InventoryState& inventory, ESM::NpcStats* npcStats)
{
const auto& store = *MWBase::Environment::get().getESMStore();
// Convert corprus to format 10
for (const auto& [id, oldStats] : creatureStats.mSpells.mCorprusSpells)
{
const ESM::Spell* spell = store.get<ESM::Spell>().search(id);
if (!spell)
continue;
ESM::CreatureStats::CorprusStats stats;
stats.mNextWorsening = oldStats.mNextWorsening;
stats.mWorsenings.fill(0);
for (auto& effect : spell->mEffects.mList)
{
if (effect.mData.mEffectID == ESM::MagicEffect::DrainAttribute)
stats.mWorsenings[effect.mData.mAttribute] = oldStats.mWorsenings;
}
creatureStats.mCorprusSpells[id] = stats;
}
// Convert to format 17
for (const auto& [id, oldParams] : creatureStats.mSpells.mSpellParams)
{
const ESM::Spell* spell = store.get<ESM::Spell>().search(id);
if (!spell || spell->mData.mType == ESM::Spell::ST_Spell || spell->mData.mType == ESM::Spell::ST_Power)
continue;
ESM::ActiveSpells::ActiveSpellParams params;
params.mSourceSpellId = id;
params.mDisplayName = spell->mName;
params.mCasterActorId = creatureStats.mActorId;
if (spell->mData.mType == ESM::Spell::ST_Ability)
params.mFlags = ESM::Compatibility::ActiveSpells::Type_Ability_Flags;
else
params.mFlags = ESM::Compatibility::ActiveSpells::Type_Permanent_Flags;
params.mWorsenings = -1;
params.mNextWorsening = ESM::TimeStamp();
for (const auto& enam : spell->mEffects.mList)
{
if (oldParams.mPurgedEffects.find(enam.mIndex) == oldParams.mPurgedEffects.end())
{
ESM::ActiveEffect effect;
effect.mEffectId = enam.mData.mEffectID;
effect.mArg = MWMechanics::EffectKey(enam.mData).mArg;
effect.mDuration = -1;
effect.mTimeLeft = -1;
effect.mEffectIndex = enam.mIndex;
auto rand = oldParams.mEffectRands.find(enam.mIndex);
if (rand != oldParams.mEffectRands.end())
{
float magnitude
= (enam.mData.mMagnMax - enam.mData.mMagnMin) * rand->second + enam.mData.mMagnMin;
effect.mMagnitude = magnitude;
effect.mMinMagnitude = magnitude;
effect.mMaxMagnitude = magnitude;
// Prevent recalculation of resistances and don't reflect or absorb the effect
effect.mFlags = ESM::ActiveEffect::Flag_Ignore_Resistances
| ESM::ActiveEffect::Flag_Ignore_Reflect | ESM::ActiveEffect::Flag_Ignore_SpellAbsorption;
}
else
{
effect.mMagnitude = 0.f;
effect.mMinMagnitude = enam.mData.mMagnMin;
effect.mMaxMagnitude = enam.mData.mMagnMax;
effect.mFlags = ESM::ActiveEffect::Flag_None;
}
params.mEffects.emplace_back(effect);
}
}
creatureStats.mActiveSpells.mSpells.emplace_back(params);
}
std::multimap<ESM::RefId, ESM::RefNum> equippedItems;
for (std::size_t i = 0; i < inventory.mItems.size(); ++i)
{
ESM::ObjectState& item = inventory.mItems[i];
auto slot = inventory.mEquipmentSlots.find(i);
if (slot != inventory.mEquipmentSlots.end())
{
MWBase::Environment::get().getWorldModel()->assignSaveFileRefNum(item.mRef);
equippedItems.emplace(item.mRef.mRefID, item.mRef.mRefNum);
}
}
for (const auto& [id, oldMagnitudes] : inventory.mPermanentMagicEffectMagnitudes)
{
ESM::RefId eId;
std::string name;
switch (store.find(id))
{
case ESM::REC_ARMO:
getEnchantedItem<ESM::Armor>(id, eId, name);
break;
case ESM::REC_CLOT:
getEnchantedItem<ESM::Clothing>(id, eId, name);
break;
case ESM::REC_WEAP:
getEnchantedItem<ESM::Weapon>(id, eId, name);
break;
}
if (eId.empty())
continue;
const ESM::Enchantment* enchantment = store.get<ESM::Enchantment>().search(eId);
if (!enchantment)
continue;
ESM::ActiveSpells::ActiveSpellParams params;
params.mSourceSpellId = id;
params.mDisplayName = std::move(name);
params.mCasterActorId = creatureStats.mActorId;
params.mFlags = ESM::Compatibility::ActiveSpells::Type_Enchantment_Flags;
params.mWorsenings = -1;
params.mNextWorsening = ESM::TimeStamp();
for (const auto& enam : enchantment->mEffects.mList)
{
auto [random, multiplier] = oldMagnitudes[enam.mIndex];
float magnitude = (enam.mData.mMagnMax - enam.mData.mMagnMin) * random + enam.mData.mMagnMin;
magnitude *= multiplier;
if (magnitude <= 0)
continue;
ESM::ActiveEffect effect;
effect.mEffectId = enam.mData.mEffectID;
effect.mMagnitude = magnitude;
effect.mMinMagnitude = magnitude;
effect.mMaxMagnitude = magnitude;
effect.mArg = MWMechanics::EffectKey(enam.mData).mArg;
effect.mDuration = -1;
effect.mTimeLeft = -1;
effect.mEffectIndex = enam.mIndex;
// Prevent recalculation of resistances and don't reflect or absorb the effect
effect.mFlags = ESM::ActiveEffect::Flag_Ignore_Resistances | ESM::ActiveEffect::Flag_Ignore_Reflect
| ESM::ActiveEffect::Flag_Ignore_SpellAbsorption;
params.mEffects.emplace_back(effect);
}
auto [begin, end] = equippedItems.equal_range(id);
for (auto it = begin; it != end; ++it)
{
params.mItem = it->second;
creatureStats.mActiveSpells.mSpells.emplace_back(params);
}
}
for (const auto& spell : creatureStats.mCorprusSpells)
{
auto it
= std::find_if(creatureStats.mActiveSpells.mSpells.begin(), creatureStats.mActiveSpells.mSpells.end(),
[&](const auto& params) { return params.mSourceSpellId == spell.first; });
if (it != creatureStats.mActiveSpells.mSpells.end())
{
it->mNextWorsening = spell.second.mNextWorsening;
int worsenings = 0;
for (const auto& worsening : spell.second.mWorsenings)
worsenings = std::max(worsening, worsenings);
it->mWorsenings = worsenings;
}
}
for (const auto& [key, actorId] : creatureStats.mSummonedCreatureMap)
{
if (actorId < 0)
continue;
for (auto& params : creatureStats.mActiveSpells.mSpells)
{
if (params.mSourceSpellId == key.mSourceId)
{
bool found = false;
for (auto& effect : params.mEffects)
{
if (effect.mEffectId == key.mEffectId && effect.mEffectIndex == key.mEffectIndex)
{
effect.mArg = ESM::RefId::generated(static_cast<uint64_t>(actorId));
effect.mFlags |= ESM::ActiveEffect::Flag_Applied | ESM::ActiveEffect::Flag_Remove;
found = true;
break;
}
}
if (found)
break;
}
}
}
// Reset modifiers that were previously recalculated each frame
for (auto& attribute : creatureStats.mAttributes)
attribute.mMod = 0.f;
for (auto& dynamic : creatureStats.mDynamic)
{
dynamic.mCurrent -= dynamic.mMod - dynamic.mBase;
dynamic.mMod = 0.f;
}
for (auto& setting : creatureStats.mAiSettings)
setting.mMod = 0.f;
if (npcStats)
{
for (auto& skill : npcStats->mSkills)
skill.mMod = 0.f;
}
}
// Versions 17-19 wrote different modifiers to the savegame depending on whether the save had upgraded from a pre-17
// version or not
void convertStats(ESM::CreatureStats& creatureStats)
{
for (auto& dynamic : creatureStats.mDynamic)
dynamic.mMod = 0.f;
for (auto& setting : creatureStats.mAiSettings)
setting.mMod = 0.f;
}
// Versions 17-27 wrote an equipment slot index to mItem
void convertEnchantmentSlots(ESM::CreatureStats& creatureStats, ESM::InventoryState& inventory)
{
for (auto& activeSpell : creatureStats.mActiveSpells.mSpells)
{
if (!activeSpell.mItem.isSet())
continue;
if (activeSpell.mFlags & ESM::ActiveSpells::Flag_Equipment)
{
std::int64_t slotIndex = activeSpell.mItem.mIndex;
auto slot = std::find_if(inventory.mEquipmentSlots.begin(), inventory.mEquipmentSlots.end(),
[=](const auto& entry) { return entry.second == slotIndex; });
if (slot != inventory.mEquipmentSlots.end() && slot->first < inventory.mItems.size())
{
ESM::CellRef& ref = inventory.mItems[slot->first].mRef;
MWBase::Environment::get().getWorldModel()->assignSaveFileRefNum(ref);
activeSpell.mItem = ref.mRefNum;
continue;
}
}
activeSpell.mItem = {};
}
}
}
| 11,374
|
C++
|
.cpp
| 251
| 31.386454
| 120
| 0.552546
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,258
|
inventorystore.cpp
|
OpenMW_openmw/apps/openmw/mwworld/inventorystore.cpp
|
#include "inventorystore.hpp"
#include <algorithm>
#include <iterator>
#include <components/esm3/inventorystate.hpp>
#include "../mwbase/environment.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwmechanics/npcstats.hpp"
#include "../mwmechanics/weapontype.hpp"
#include "class.hpp"
#include "esmstore.hpp"
void MWWorld::InventoryStore::copySlots(const InventoryStore& store)
{
// some const-trickery, required because of a flaw in the handling of MW-references and the
// resulting workarounds
for (std::vector<ContainerStoreIterator>::const_iterator iter(const_cast<InventoryStore&>(store).mSlots.begin());
iter != const_cast<InventoryStore&>(store).mSlots.end(); ++iter)
{
std::size_t distance = std::distance(const_cast<InventoryStore&>(store).begin(), *iter);
ContainerStoreIterator slot = begin();
std::advance(slot, distance);
mSlots.push_back(slot);
}
// some const-trickery, required because of a flaw in the handling of MW-references and the
// resulting workarounds
std::size_t distance = std::distance(
const_cast<InventoryStore&>(store).begin(), const_cast<InventoryStore&>(store).mSelectedEnchantItem);
ContainerStoreIterator slot = begin();
std::advance(slot, distance);
mSelectedEnchantItem = slot;
}
void MWWorld::InventoryStore::initSlots(TSlots& slots_)
{
for (int i = 0; i < Slots; ++i)
slots_.push_back(end());
}
void MWWorld::InventoryStore::storeEquipmentState(
const MWWorld::LiveCellRefBase& ref, size_t index, ESM::InventoryState& inventory) const
{
for (int32_t i = 0; i < MWWorld::InventoryStore::Slots; ++i)
{
if (mSlots[i].getType() != -1 && mSlots[i]->getBase() == &ref)
inventory.mEquipmentSlots[static_cast<uint32_t>(index)] = i;
}
if (mSelectedEnchantItem.getType() != -1 && mSelectedEnchantItem->getBase() == &ref)
inventory.mSelectedEnchantItem = index;
}
void MWWorld::InventoryStore::readEquipmentState(
const MWWorld::ContainerStoreIterator& iter, size_t index, const ESM::InventoryState& inventory)
{
if (index == inventory.mSelectedEnchantItem)
mSelectedEnchantItem = iter;
auto found = inventory.mEquipmentSlots.find(index);
if (found != inventory.mEquipmentSlots.end())
{
if (found->second < 0 || found->second >= MWWorld::InventoryStore::Slots)
throw std::runtime_error("Invalid slot index in inventory state");
// make sure the item can actually be equipped in this slot
int32_t slot = found->second;
std::pair<std::vector<int>, bool> allowedSlots = iter->getClass().getEquipmentSlots(*iter);
if (!allowedSlots.first.size())
return;
if (std::find(allowedSlots.first.begin(), allowedSlots.first.end(), slot) == allowedSlots.first.end())
slot = allowedSlots.first.front();
// unstack if required
if (!allowedSlots.second && iter->getCellRef().getCount() > 1)
{
int count = iter->getCellRef().getCount(false);
MWWorld::ContainerStoreIterator newIter = addNewStack(*iter, count > 0 ? 1 : -1);
iter->getCellRef().setCount(subtractItems(count, 1));
mSlots[slot] = newIter;
}
else
mSlots[slot] = iter;
}
}
MWWorld::InventoryStore::InventoryStore()
: ContainerStore()
, mInventoryListener(nullptr)
, mUpdatesEnabled(true)
, mFirstAutoEquip(true)
, mSelectedEnchantItem(end())
{
initSlots(mSlots);
}
MWWorld::InventoryStore::InventoryStore(const InventoryStore& store)
: ContainerStore(store)
, mInventoryListener(store.mInventoryListener)
, mUpdatesEnabled(store.mUpdatesEnabled)
, mFirstAutoEquip(store.mFirstAutoEquip)
, mSelectedEnchantItem(end())
{
copySlots(store);
}
MWWorld::InventoryStore& MWWorld::InventoryStore::operator=(const InventoryStore& store)
{
if (this == &store)
return *this;
mListener = store.mListener;
mInventoryListener = store.mInventoryListener;
mFirstAutoEquip = store.mFirstAutoEquip;
mRechargingItemsUpToDate = false;
ContainerStore::operator=(store);
mSlots.clear();
copySlots(store);
return *this;
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::add(
const Ptr& itemPtr, int count, bool allowAutoEquip, bool resolve)
{
const MWWorld::ContainerStoreIterator& retVal
= MWWorld::ContainerStore::add(itemPtr, count, allowAutoEquip, resolve);
// Auto-equip items if an armor/clothing item is added, but not for the player nor werewolves
const Ptr& actor = getPtr();
if (allowAutoEquip && actor != MWMechanics::getPlayer() && actor.getClass().isNpc()
&& !actor.getClass().getNpcStats(actor).isWerewolf())
{
auto type = itemPtr.getType();
if (type == ESM::Armor::sRecordId || type == ESM::Clothing::sRecordId)
autoEquip();
}
if (mListener)
mListener->itemAdded(*retVal, count);
return retVal;
}
void MWWorld::InventoryStore::equip(int slot, const ContainerStoreIterator& iterator)
{
if (iterator == end())
throw std::runtime_error("can't equip end() iterator, use unequip function instead");
if (slot < 0 || slot >= static_cast<int>(mSlots.size()))
throw std::runtime_error("slot number out of range");
if (iterator.getContainerStore() != this)
throw std::runtime_error("attempt to equip an item that is not in the inventory");
std::pair<std::vector<int>, bool> slots_;
slots_ = iterator->getClass().getEquipmentSlots(*iterator);
if (std::find(slots_.first.begin(), slots_.first.end(), slot) == slots_.first.end())
throw std::runtime_error("invalid slot");
if (mSlots[slot] != end())
unequipSlot(slot);
// unstack item pointed to by iterator if required
if (iterator != end() && !slots_.second
&& iterator->getCellRef().getCount() > 1) // if slots.second is true, item can stay stacked when equipped
{
unstack(*iterator);
}
mSlots[slot] = iterator;
flagAsModified();
fireEquipmentChangedEvent();
}
void MWWorld::InventoryStore::unequipAll()
{
mUpdatesEnabled = false;
for (int slot = 0; slot < MWWorld::InventoryStore::Slots; ++slot)
unequipSlot(slot);
mUpdatesEnabled = true;
fireEquipmentChangedEvent();
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::getSlot(int slot)
{
return findSlot(slot);
}
MWWorld::ConstContainerStoreIterator MWWorld::InventoryStore::getSlot(int slot) const
{
return findSlot(slot);
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::findSlot(int slot) const
{
if (slot < 0 || slot >= static_cast<int>(mSlots.size()))
throw std::runtime_error("slot number out of range");
if (mSlots[slot] == end())
return mSlots[slot];
// NOTE: mSlots[slot]->getRefData().getCount() can be zero if the item is marked
// for removal by a Lua script, but the removal action is not yet processed.
// The item will be automatically unequiped in the current frame.
return mSlots[slot];
}
void MWWorld::InventoryStore::autoEquipWeapon(TSlots& slots_)
{
const Ptr& actor = getPtr();
if (!actor.getClass().isNpc())
{
// In original game creatures do not autoequip weapon, but we need it for weapon sheathing.
// The only case when the difference is noticable - when this creature sells weapon.
// So just disable weapon autoequipping for creatures which sells weapon.
int services = actor.getClass().getServices(actor);
bool sellsWeapon = services & (ESM::NPC::Weapon | ESM::NPC::MagicItems);
if (sellsWeapon)
return;
}
static const ESM::RefId weaponSkills[] = {
ESM::Skill::LongBlade,
ESM::Skill::Axe,
ESM::Skill::Spear,
ESM::Skill::ShortBlade,
ESM::Skill::Marksman,
ESM::Skill::BluntWeapon,
};
const size_t weaponSkillsLength = sizeof(weaponSkills) / sizeof(weaponSkills[0]);
bool weaponSkillVisited[weaponSkillsLength] = { false };
// give arrows/bolt with max damage by default
int arrowMax = 0;
int boltMax = 0;
ContainerStoreIterator arrow(end());
ContainerStoreIterator bolt(end());
// rate ammo
for (ContainerStoreIterator iter(begin(ContainerStore::Type_Weapon)); iter != end(); ++iter)
{
const ESM::Weapon* esmWeapon = iter->get<ESM::Weapon>()->mBase;
if (esmWeapon->mData.mType == ESM::Weapon::Arrow)
{
if (esmWeapon->mData.mChop[1] >= arrowMax)
{
arrowMax = esmWeapon->mData.mChop[1];
arrow = iter;
}
}
else if (esmWeapon->mData.mType == ESM::Weapon::Bolt)
{
if (esmWeapon->mData.mChop[1] >= boltMax)
{
boltMax = esmWeapon->mData.mChop[1];
bolt = iter;
}
}
}
// rate weapon
for (int i = 0; i < static_cast<int>(weaponSkillsLength); ++i)
{
float max = 0;
int maxWeaponSkill = -1;
for (int j = 0; j < static_cast<int>(weaponSkillsLength); ++j)
{
float skillValue = actor.getClass().getSkill(actor, weaponSkills[j]);
if (skillValue > max && !weaponSkillVisited[j])
{
max = skillValue;
maxWeaponSkill = j;
}
}
if (maxWeaponSkill == -1)
break;
max = 0;
ContainerStoreIterator weapon(end());
for (ContainerStoreIterator iter(begin(ContainerStore::Type_Weapon)); iter != end(); ++iter)
{
const ESM::Weapon* esmWeapon = iter->get<ESM::Weapon>()->mBase;
if (MWMechanics::getWeaponType(esmWeapon->mData.mType)->mWeaponClass == ESM::WeaponType::Ammo)
continue;
if (iter->getClass().getEquipmentSkill(*iter) == weaponSkills[maxWeaponSkill])
{
if (esmWeapon->mData.mChop[1] >= max)
{
max = esmWeapon->mData.mChop[1];
weapon = iter;
}
if (esmWeapon->mData.mSlash[1] >= max)
{
max = esmWeapon->mData.mSlash[1];
weapon = iter;
}
if (esmWeapon->mData.mThrust[1] >= max)
{
max = esmWeapon->mData.mThrust[1];
weapon = iter;
}
}
}
if (weapon != end() && weapon->getClass().canBeEquipped(*weapon, actor).first)
{
// Do not equip ranged weapons, if there is no suitable ammo
bool hasAmmo = true;
const MWWorld::LiveCellRef<ESM::Weapon>* ref = weapon->get<ESM::Weapon>();
int type = ref->mBase->mData.mType;
int ammotype = MWMechanics::getWeaponType(type)->mAmmoType;
if (ammotype == ESM::Weapon::Arrow)
{
if (arrow == end())
hasAmmo = false;
else
slots_[Slot_Ammunition] = arrow;
}
else if (ammotype == ESM::Weapon::Bolt)
{
if (bolt == end())
hasAmmo = false;
else
slots_[Slot_Ammunition] = bolt;
}
if (hasAmmo)
{
std::pair<std::vector<int>, bool> itemsSlots = weapon->getClass().getEquipmentSlots(*weapon);
if (!itemsSlots.first.empty())
{
if (!itemsSlots.second)
{
if (weapon->getCellRef().getCount() > 1)
{
unstack(*weapon);
}
}
int slot = itemsSlots.first.front();
slots_[slot] = weapon;
if (ammotype == ESM::Weapon::None)
slots_[Slot_Ammunition] = end();
}
break;
}
}
weaponSkillVisited[maxWeaponSkill] = true;
}
}
void MWWorld::InventoryStore::autoEquipArmor(TSlots& slots_)
{
// Only NPCs can wear armor for now.
// For creatures we equip only shields.
const Ptr& actor = getPtr();
if (!actor.getClass().isNpc())
{
autoEquipShield(slots_);
return;
}
const MWWorld::Store<ESM::GameSetting>& store = MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
static float fUnarmoredBase1 = store.find("fUnarmoredBase1")->mValue.getFloat();
static float fUnarmoredBase2 = store.find("fUnarmoredBase2")->mValue.getFloat();
float unarmoredSkill = actor.getClass().getSkill(actor, ESM::Skill::Unarmored);
float unarmoredRating = (fUnarmoredBase1 * unarmoredSkill) * (fUnarmoredBase2 * unarmoredSkill);
for (ContainerStoreIterator iter(begin(ContainerStore::Type_Clothing | ContainerStore::Type_Armor)); iter != end();
++iter)
{
Ptr test = *iter;
switch (test.getClass().canBeEquipped(test, actor).first)
{
case 0:
continue;
default:
break;
}
if (iter.getType() == ContainerStore::Type_Armor
&& test.getClass().getEffectiveArmorRating(test, actor) <= std::max(unarmoredRating, 0.f))
{
continue;
}
std::pair<std::vector<int>, bool> itemsSlots = iter->getClass().getEquipmentSlots(*iter);
// checking if current item pointed by iter can be equipped
for (int slot : itemsSlots.first)
{
// if true then it means slot is equipped already
// check if slot may require swapping if current item is more valuable
if (slots_.at(slot) != end())
{
Ptr old = *slots_.at(slot);
if (iter.getType() == ContainerStore::Type_Armor)
{
if (old.getType() == ESM::Armor::sRecordId)
{
if (old.get<ESM::Armor>()->mBase->mData.mType < test.get<ESM::Armor>()->mBase->mData.mType)
continue;
if (old.get<ESM::Armor>()->mBase->mData.mType == test.get<ESM::Armor>()->mBase->mData.mType)
{
if (old.getClass().getEffectiveArmorRating(old, actor)
>= test.getClass().getEffectiveArmorRating(test, actor))
// old armor had better armor rating
continue;
}
}
// suitable armor should replace already equipped clothing
}
else if (iter.getType() == ContainerStore::Type_Clothing)
{
// if left ring is equipped
if (slot == Slot_LeftRing)
{
// if there is a place for right ring dont swap it
if (slots_.at(Slot_RightRing) == end())
{
continue;
}
else // if right ring is equipped too
{
Ptr rightRing = *slots_.at(Slot_RightRing);
// we want to swap cheaper ring only if both are equipped
if (old.getClass().getValue(old) >= rightRing.getClass().getValue(rightRing))
continue;
}
}
if (old.getType() == ESM::Clothing::sRecordId)
{
// check value
if (old.getClass().getValue(old) >= test.getClass().getValue(test))
// old clothing was more valuable
continue;
}
else
// suitable clothing should NOT replace already equipped armor
continue;
}
}
if (!itemsSlots.second) // if itemsSlots.second is true, item can stay stacked when equipped
{
// unstack item pointed to by iterator if required
if (iter->getCellRef().getCount() > 1)
{
unstack(*iter);
}
}
// if we are here it means item can be equipped or swapped
slots_[slot] = iter;
break;
}
}
}
void MWWorld::InventoryStore::autoEquipShield(TSlots& slots_)
{
for (ContainerStoreIterator iter(begin(ContainerStore::Type_Armor)); iter != end(); ++iter)
{
if (iter->get<ESM::Armor>()->mBase->mData.mType != ESM::Armor::Shield)
continue;
if (iter->getClass().canBeEquipped(*iter, getPtr()).first != 1)
continue;
std::pair<std::vector<int>, bool> shieldSlots = iter->getClass().getEquipmentSlots(*iter);
int slot = shieldSlots.first[0];
const ContainerStoreIterator& shield = slots_[slot];
if (shield != end() && shield.getType() == Type_Armor
&& shield->get<ESM::Armor>()->mBase->mData.mType == ESM::Armor::Shield)
{
if (shield->getClass().getItemHealth(*shield) >= iter->getClass().getItemHealth(*iter))
continue;
}
slots_[slot] = iter;
}
}
void MWWorld::InventoryStore::autoEquip()
{
TSlots slots_;
initSlots(slots_);
// Disable model update during auto-equip
mUpdatesEnabled = false;
// Autoequip clothing, armor and weapons.
// Equipping lights is handled in Actors::updateEquippedLight based on environment light.
// Note: creatures ignore equipment armor rating and only equip shields
// Use custom logic for them - select shield based on its health instead of armor rating
autoEquipWeapon(slots_);
autoEquipArmor(slots_);
bool changed = false;
for (std::size_t i = 0; i < slots_.size(); ++i)
{
if (slots_[i] != mSlots[i])
{
changed = true;
break;
}
}
mUpdatesEnabled = true;
if (changed)
{
mSlots.swap(slots_);
fireEquipmentChangedEvent();
flagAsModified();
}
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::getPreferredShield()
{
TSlots slots;
initSlots(slots);
autoEquipArmor(slots);
return slots[Slot_CarriedLeft];
}
bool MWWorld::InventoryStore::stacks(const ConstPtr& ptr1, const ConstPtr& ptr2) const
{
bool canStack = MWWorld::ContainerStore::stacks(ptr1, ptr2);
if (!canStack)
return false;
// don't stack if either item is currently equipped
for (TSlots::const_iterator iter(mSlots.begin()); iter != mSlots.end(); ++iter)
{
if (*iter != end() && (ptr1 == **iter || ptr2 == **iter))
{
bool stackWhenEquipped = (*iter)->getClass().getEquipmentSlots(**iter).second;
if (!stackWhenEquipped)
return false;
}
}
return true;
}
void MWWorld::InventoryStore::setSelectedEnchantItem(const ContainerStoreIterator& iterator)
{
mSelectedEnchantItem = iterator;
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::getSelectedEnchantItem()
{
return mSelectedEnchantItem;
}
int MWWorld::InventoryStore::remove(const Ptr& item, int count, bool equipReplacement, bool resolve)
{
int retCount = ContainerStore::remove(item, count, equipReplacement, resolve);
bool wasEquipped = false;
if (!item.getCellRef().getCount())
{
for (int slot = 0; slot < MWWorld::InventoryStore::Slots; ++slot)
{
if (mSlots[slot] == end())
continue;
if (*mSlots[slot] == item)
{
unequipSlot(slot);
wasEquipped = true;
break;
}
}
}
// If an armor/clothing item is removed, try to find a replacement,
// but not for the player nor werewolves, and not if the RemoveItem script command
// was used (equipReplacement is false)
const Ptr& actor = getPtr();
if (equipReplacement && wasEquipped && (actor != MWMechanics::getPlayer()) && actor.getClass().isNpc()
&& !actor.getClass().getNpcStats(actor).isWerewolf())
{
auto type = item.getType();
if (type == ESM::Armor::sRecordId || type == ESM::Clothing::sRecordId)
autoEquip();
}
if (item.getCellRef().getCount() == 0 && mSelectedEnchantItem != end() && *mSelectedEnchantItem == item)
{
mSelectedEnchantItem = end();
}
if (mListener)
mListener->itemRemoved(item, retCount);
return retCount;
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::unequipSlot(int slot, bool applyUpdates)
{
if (slot < 0 || slot >= static_cast<int>(mSlots.size()))
throw std::runtime_error("slot number out of range");
ContainerStoreIterator it = mSlots[slot];
if (it != end())
{
ContainerStoreIterator retval = it;
// empty this slot
mSlots[slot] = end();
if (it->getCellRef().getCount())
{
retval = restack(*it);
if (getPtr() == MWMechanics::getPlayer())
{
// Unset OnPCEquip Variable on item's script, if it has a script with that variable declared
const ESM::RefId& script = it->getClass().getScript(*it);
if (!script.empty())
(*it).getRefData().getLocals().setVarByInt(script, "onpcequip", 0);
}
if ((mSelectedEnchantItem != end()) && (mSelectedEnchantItem == it))
{
mSelectedEnchantItem = end();
}
}
if (applyUpdates)
{
fireEquipmentChangedEvent();
}
return retval;
}
return it;
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::unequipItem(const MWWorld::Ptr& item)
{
for (int slot = 0; slot < MWWorld::InventoryStore::Slots; ++slot)
{
MWWorld::ContainerStoreIterator equipped = getSlot(slot);
if (equipped != end() && *equipped == item)
return unequipSlot(slot);
}
throw std::runtime_error("attempt to unequip an item that is not currently equipped");
}
MWWorld::ContainerStoreIterator MWWorld::InventoryStore::unequipItemQuantity(const Ptr& item, int count)
{
if (!isEquipped(item))
throw std::runtime_error("attempt to unequip an item that is not currently equipped");
if (count <= 0)
throw std::runtime_error("attempt to unequip nothing (count <= 0)");
if (count > item.getCellRef().getCount())
throw std::runtime_error("attempt to unequip more items than equipped");
if (count == item.getCellRef().getCount())
return unequipItem(item);
// Move items to an existing stack if possible, otherwise split count items out into a new stack.
// Moving counts manually here, since ContainerStore's restack can't target unequipped stacks.
for (MWWorld::ContainerStoreIterator iter(begin()); iter != end(); ++iter)
{
if (stacks(*iter, item) && !isEquipped(*iter))
{
iter->getCellRef().setCount(addItems(iter->getCellRef().getCount(false), count));
item.getCellRef().setCount(subtractItems(item.getCellRef().getCount(false), count));
return iter;
}
}
return unstack(item, item.getCellRef().getCount() - count);
}
MWWorld::InventoryStoreListener* MWWorld::InventoryStore::getInvListener() const
{
return mInventoryListener;
}
void MWWorld::InventoryStore::setInvListener(InventoryStoreListener* listener)
{
mInventoryListener = listener;
}
void MWWorld::InventoryStore::fireEquipmentChangedEvent()
{
if (!mUpdatesEnabled)
return;
if (mInventoryListener)
mInventoryListener->equipmentChanged();
// if player, update inventory window
/*
if (mActor == MWMechanics::getPlayer())
{
MWBase::Environment::get().getWindowManager()->getInventoryWindow()->updateItemView();
}
*/
}
void MWWorld::InventoryStore::clear()
{
mSlots.clear();
initSlots(mSlots);
ContainerStore::clear();
}
bool MWWorld::InventoryStore::isEquipped(const MWWorld::ConstPtr& item)
{
for (int i = 0; i < MWWorld::InventoryStore::Slots; ++i)
{
if (getSlot(i) != end() && *getSlot(i) == item)
return true;
}
return false;
}
bool MWWorld::InventoryStore::isFirstEquip()
{
bool first = mFirstAutoEquip;
mFirstAutoEquip = false;
return first;
}
| 24,969
|
C++
|
.cpp
| 637
| 29.985871
| 119
| 0.596935
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,259
|
datetimemanager.cpp
|
OpenMW_openmw/apps/openmw/mwworld/datetimemanager.cpp
|
#include "datetimemanager.hpp"
#include <components/l10n/manager.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/statemanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "duration.hpp"
#include "globals.hpp"
#include "timestamp.hpp"
namespace
{
static int getDaysPerMonth(int month)
{
switch (month)
{
case 0:
return 31;
case 1:
return 28;
case 2:
return 31;
case 3:
return 30;
case 4:
return 31;
case 5:
return 30;
case 6:
return 31;
case 7:
return 31;
case 8:
return 30;
case 9:
return 31;
case 10:
return 30;
case 11:
return 31;
}
throw std::runtime_error("month out of range");
}
}
namespace MWWorld
{
void DateTimeManager::setup(Globals& globalVariables)
{
mGameHour = globalVariables[Globals::sGameHour].getFloat();
mDaysPassed = globalVariables[Globals::sDaysPassed].getInteger();
mDay = globalVariables[Globals::sDay].getInteger();
mMonth = globalVariables[Globals::sMonth].getInteger();
mYear = globalVariables[Globals::sYear].getInteger();
mGameTimeScale = globalVariables[Globals::sTimeScale].getFloat();
setSimulationTimeScale(1.0);
mPaused = false;
mPausedTags.clear();
}
void DateTimeManager::setHour(double hour)
{
if (hour < 0)
hour = 0;
const Duration duration = Duration::fromHours(hour);
mGameHour = duration.getHours();
if (const int days = duration.getDays(); days > 0)
setDay(days + mDay);
}
void DateTimeManager::setDay(int day)
{
if (day < 1)
day = 1;
int month = mMonth;
while (true)
{
int days = getDaysPerMonth(month);
if (day <= days)
break;
if (month < 11)
{
++month;
}
else
{
month = 0;
mYear++;
}
day -= days;
}
mDay = day;
mMonth = month;
}
TimeStamp DateTimeManager::getTimeStamp() const
{
return TimeStamp(mGameHour, mDaysPassed);
}
void DateTimeManager::setGameTimeScale(float scale)
{
MWBase::Environment::get().getWorld()->setGlobalFloat(MWWorld::Globals::sTimeScale, scale);
}
ESM::EpochTimeStamp DateTimeManager::getEpochTimeStamp() const
{
ESM::EpochTimeStamp timeStamp;
timeStamp.mGameHour = mGameHour;
timeStamp.mDay = mDay;
timeStamp.mMonth = mMonth;
timeStamp.mYear = mYear;
return timeStamp;
}
void DateTimeManager::setMonth(int month)
{
if (month < 0)
month = 0;
int years = month / 12;
month = month % 12;
int days = getDaysPerMonth(month);
if (mDay > days)
mDay = days;
mMonth = month;
if (years > 0)
mYear += years;
}
void DateTimeManager::advanceTime(double hours, Globals& globalVariables)
{
hours += mGameHour;
setHour(hours);
int days = static_cast<int>(hours / 24);
if (days > 0)
mDaysPassed += days;
globalVariables[Globals::sGameHour].setFloat(mGameHour);
globalVariables[Globals::sDaysPassed].setInteger(mDaysPassed);
globalVariables[Globals::sDay].setInteger(mDay);
globalVariables[Globals::sMonth].setInteger(mMonth);
globalVariables[Globals::sYear].setInteger(mYear);
}
static std::vector<std::string> getMonthNames()
{
auto calendarL10n = MWBase::Environment::get().getL10nManager()->getContext("Calendar");
std::string prefix = "month";
std::vector<std::string> months;
int count = 12;
months.reserve(count);
for (int i = 1; i <= count; ++i)
months.push_back(calendarL10n->formatMessage(prefix + std::to_string(i), {}, {}));
return months;
}
std::string_view DateTimeManager::getMonthName(int month) const
{
static std::vector<std::string> months = getMonthNames();
if (month == -1)
month = mMonth;
if (month < 0 || month >= static_cast<int>(months.size()))
return {};
else
return months[month];
}
void DateTimeManager::updateGlobalFloat(GlobalVariableName name, float value)
{
if (name == Globals::sGameHour)
{
setHour(value);
}
else if (name == Globals::sDay)
{
setDay(static_cast<int>(value));
}
else if (name == Globals::sMonth)
{
setMonth(static_cast<int>(value));
}
else if (name == Globals::sYear)
{
mYear = static_cast<int>(value);
}
else if (name == Globals::sTimeScale)
{
mGameTimeScale = value;
}
else if (name == Globals::sDaysPassed)
{
mDaysPassed = static_cast<int>(value);
}
}
void DateTimeManager::updateGlobalInt(GlobalVariableName name, int value)
{
if (name == Globals::sGameHour)
{
setHour(static_cast<float>(value));
}
else if (name == Globals::sDay)
{
setDay(value);
}
else if (name == Globals::sMonth)
{
setMonth(value);
}
else if (name == Globals::sYear)
{
mYear = value;
}
else if (name == Globals::sTimeScale)
{
mGameTimeScale = static_cast<float>(value);
}
else if (name == Globals::sDaysPassed)
{
mDaysPassed = value;
}
}
void DateTimeManager::setSimulationTimeScale(float scale)
{
mSimulationTimeScale = std::max(0.f, scale);
MWBase::Environment::get().getSoundManager()->setSimulationTimeScale(mSimulationTimeScale);
}
void DateTimeManager::unpause(std::string_view tag)
{
auto it = mPausedTags.find(tag);
if (it != mPausedTags.end())
mPausedTags.erase(it);
}
void DateTimeManager::updateIsPaused()
{
auto stateManager = MWBase::Environment::get().getStateManager();
auto wm = MWBase::Environment::get().getWindowManager();
mPaused = !mPausedTags.empty() || wm->isConsoleMode() || wm->isPostProcessorHudVisible()
|| wm->isInteractiveMessageBoxActive() || stateManager->getState() == MWBase::StateManager::State_NoGame;
}
}
| 6,957
|
C++
|
.cpp
| 228
| 21.399123
| 117
| 0.556833
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,260
|
cellpreloader.cpp
|
OpenMW_openmw/apps/openmw/mwworld/cellpreloader.cpp
|
#include "cellpreloader.hpp"
#include <algorithm>
#include <atomic>
#include <limits>
#include <span>
#include <osg/Stats>
#include <components/debug/debuglog.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/loadinglistener/reporter.hpp>
#include <components/misc/constants.hpp>
#include <components/misc/pathhelpers.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <components/misc/strings/lower.hpp>
#include <components/resource/bulletshapemanager.hpp>
#include <components/resource/keyframemanager.hpp>
#include <components/resource/resourcesystem.hpp>
#include <components/resource/scenemanager.hpp>
#include <components/terrain/view.hpp>
#include <components/terrain/world.hpp>
#include <components/vfs/manager.hpp>
#include "../mwrender/landmanager.hpp"
#include "cellstore.hpp"
#include "class.hpp"
namespace MWWorld
{
namespace
{
bool contains(std::span<const PositionCellGrid> positions, const PositionCellGrid& contained, float tolerance)
{
const float squaredTolerance = tolerance * tolerance;
const auto predicate = [&](const PositionCellGrid& v) {
return (contained.mPosition - v.mPosition).length2() < squaredTolerance
&& contained.mCellBounds == v.mCellBounds;
};
return std::ranges::any_of(positions, predicate);
}
bool contains(
std::span<const PositionCellGrid> container, std::span<const PositionCellGrid> contained, float tolerance)
{
const auto predicate = [&](const PositionCellGrid& v) { return contains(container, v, tolerance); };
return std::ranges::all_of(contained, predicate);
}
}
struct ListModelsVisitor
{
bool operator()(const MWWorld::ConstPtr& ptr)
{
ptr.getClass().getModelsToPreload(ptr, mOut);
return true;
}
std::vector<std::string_view>& mOut;
};
/// Worker thread item: preload models in a cell.
class PreloadItem : public SceneUtil::WorkItem
{
public:
/// Constructor to be called from the main thread.
explicit PreloadItem(MWWorld::CellStore* cell, Resource::SceneManager* sceneManager,
Resource::BulletShapeManager* bulletShapeManager, Resource::KeyframeManager* keyframeManager,
Terrain::World* terrain, MWRender::LandManager* landManager, bool preloadInstances)
: mIsExterior(cell->getCell()->isExterior())
, mCellLocation(cell->getCell()->getExteriorCellLocation())
, mCellId(cell->getCell()->getId())
, mSceneManager(sceneManager)
, mBulletShapeManager(bulletShapeManager)
, mKeyframeManager(keyframeManager)
, mTerrain(terrain)
, mLandManager(landManager)
, mPreloadInstances(preloadInstances)
, mAbort(false)
{
mTerrainView = mTerrain->createView();
ListModelsVisitor visitor{ mMeshes };
cell->forEachConst(visitor);
}
void abort() override { mAbort = true; }
/// Preload work to be called from the worker thread.
void doWork() override
{
if (mIsExterior)
{
try
{
mTerrain->cacheCell(mTerrainView.get(), mCellLocation.mX, mCellLocation.mY);
mPreloadedObjects.insert(mLandManager->getLand(mCellLocation));
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to cache terrain for exterior cell " << mCellLocation << ": "
<< e.what();
}
}
VFS::Path::Normalized mesh;
VFS::Path::Normalized kfname;
for (std::string_view path : mMeshes)
{
if (mAbort)
break;
try
{
const VFS::Manager& vfs = *mSceneManager->getVFS();
mesh = Misc::ResourceHelpers::correctMeshPath(path);
mesh = Misc::ResourceHelpers::correctActorModelPath(mesh, &vfs);
if (!vfs.exists(mesh))
continue;
if (Misc::getFileName(mesh).starts_with('x') && Misc::getFileExtension(mesh) == "nif")
{
kfname = mesh;
kfname.changeExtension("kf");
if (vfs.exists(kfname))
mPreloadedObjects.insert(mKeyframeManager->get(kfname));
}
mPreloadedObjects.insert(mSceneManager->getTemplate(mesh));
if (mPreloadInstances)
mPreloadedObjects.insert(mBulletShapeManager->cacheInstance(mesh));
else
mPreloadedObjects.insert(mBulletShapeManager->getShape(mesh));
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to preload mesh \"" << path << "\" from cell " << mCellId << ": "
<< e.what();
}
}
}
private:
bool mIsExterior;
ESM::ExteriorCellLocation mCellLocation;
ESM::RefId mCellId;
std::vector<std::string_view> mMeshes;
Resource::SceneManager* mSceneManager;
Resource::BulletShapeManager* mBulletShapeManager;
Resource::KeyframeManager* mKeyframeManager;
Terrain::World* mTerrain;
MWRender::LandManager* mLandManager;
bool mPreloadInstances;
std::atomic<bool> mAbort;
osg::ref_ptr<Terrain::View> mTerrainView;
// keep a ref to the loaded objects to make sure it stays loaded as long as this cell is in the preloaded state
std::set<osg::ref_ptr<const osg::Object>> mPreloadedObjects;
};
class TerrainPreloadItem : public SceneUtil::WorkItem
{
public:
explicit TerrainPreloadItem(const std::vector<osg::ref_ptr<Terrain::View>>& views, Terrain::World* world,
std::span<const PositionCellGrid> preloadPositions)
: mAbort(false)
, mTerrainViews(views)
, mWorld(world)
, mPreloadPositions(preloadPositions.begin(), preloadPositions.end())
{
}
void doWork() override
{
for (unsigned int i = 0; i < mTerrainViews.size() && i < mPreloadPositions.size() && !mAbort; ++i)
{
mTerrainViews[i]->reset();
mWorld->preload(mTerrainViews[i], mPreloadPositions[i].mPosition, mPreloadPositions[i].mCellBounds,
mAbort, mLoadingReporter);
}
mLoadingReporter.complete();
}
void abort() override { mAbort = true; }
void wait(Loading::Listener& listener) const { mLoadingReporter.wait(listener); }
private:
std::atomic<bool> mAbort;
std::vector<osg::ref_ptr<Terrain::View>> mTerrainViews;
Terrain::World* mWorld;
std::vector<PositionCellGrid> mPreloadPositions;
Loading::Reporter mLoadingReporter;
};
/// Worker thread item: update the resource system's cache, effectively deleting unused entries.
class UpdateCacheItem : public SceneUtil::WorkItem
{
public:
UpdateCacheItem(Resource::ResourceSystem* resourceSystem, double referenceTime)
: mReferenceTime(referenceTime)
, mResourceSystem(resourceSystem)
{
}
void doWork() override { mResourceSystem->updateCache(mReferenceTime); }
private:
double mReferenceTime;
Resource::ResourceSystem* mResourceSystem;
};
CellPreloader::CellPreloader(Resource::ResourceSystem* resourceSystem,
Resource::BulletShapeManager* bulletShapeManager, Terrain::World* terrain, MWRender::LandManager* landManager)
: mResourceSystem(resourceSystem)
, mBulletShapeManager(bulletShapeManager)
, mTerrain(terrain)
, mLandManager(landManager)
, mExpiryDelay(0.0)
, mPreloadInstances(true)
, mLastResourceCacheUpdate(0.0)
, mLoadedTerrainTimestamp(0.0)
{
}
CellPreloader::~CellPreloader()
{
clearAllTasks();
}
void CellPreloader::preload(CellStore& cell, double timestamp)
{
if (!mWorkQueue)
{
Log(Debug::Error) << "Error: can't preload, no work queue set";
return;
}
if (cell.getState() == CellStore::State_Unloaded)
{
Log(Debug::Error) << "Error: can't preload objects for unloaded cell";
return;
}
PreloadMap::iterator found = mPreloadCells.find(&cell);
if (found != mPreloadCells.end())
{
// already preloaded, nothing to do other than updating the timestamp
found->second.mTimeStamp = timestamp;
return;
}
while (mPreloadCells.size() >= mMaxCacheSize)
{
// throw out oldest cell to make room
PreloadMap::iterator oldestCell = mPreloadCells.begin();
double oldestTimestamp = std::numeric_limits<double>::max();
double threshold = 1.0; // seconds
for (PreloadMap::iterator it = mPreloadCells.begin(); it != mPreloadCells.end(); ++it)
{
if (it->second.mTimeStamp < oldestTimestamp)
{
oldestTimestamp = it->second.mTimeStamp;
oldestCell = it;
}
}
if (oldestTimestamp + threshold < timestamp)
{
oldestCell->second.mWorkItem->abort();
mPreloadCells.erase(oldestCell);
++mEvicted;
}
else
return;
}
osg::ref_ptr<PreloadItem> item(new PreloadItem(&cell, mResourceSystem->getSceneManager(), mBulletShapeManager,
mResourceSystem->getKeyframeManager(), mTerrain, mLandManager, mPreloadInstances));
mWorkQueue->addWorkItem(item);
mPreloadCells.emplace(&cell, PreloadEntry(timestamp, item));
++mAdded;
}
void CellPreloader::notifyLoaded(CellStore* cell)
{
PreloadMap::iterator found = mPreloadCells.find(cell);
if (found != mPreloadCells.end())
{
if (found->second.mWorkItem)
{
found->second.mWorkItem->abort();
found->second.mWorkItem = nullptr;
}
mPreloadCells.erase(found);
++mLoaded;
}
}
void CellPreloader::clear()
{
for (PreloadMap::iterator it = mPreloadCells.begin(); it != mPreloadCells.end();)
{
if (it->second.mWorkItem)
{
it->second.mWorkItem->abort();
it->second.mWorkItem = nullptr;
}
mPreloadCells.erase(it++);
}
}
void CellPreloader::updateCache(double timestamp)
{
for (PreloadMap::iterator it = mPreloadCells.begin(); it != mPreloadCells.end();)
{
if (mPreloadCells.size() >= mMinCacheSize && it->second.mTimeStamp < timestamp - mExpiryDelay)
{
if (it->second.mWorkItem)
{
it->second.mWorkItem->abort();
it->second.mWorkItem = nullptr;
}
mPreloadCells.erase(it++);
++mExpired;
}
else
++it;
}
if (timestamp - mLastResourceCacheUpdate > 1.0 && (!mUpdateCacheItem || mUpdateCacheItem->isDone()))
{
// the resource cache is cleared from the worker thread so that we're not holding up the main thread with
// delete operations
mUpdateCacheItem = new UpdateCacheItem(mResourceSystem, timestamp);
mWorkQueue->addWorkItem(mUpdateCacheItem, true);
mLastResourceCacheUpdate = timestamp;
}
if (mTerrainPreloadItem && mTerrainPreloadItem->isDone())
{
mLoadedTerrainPositions = mTerrainPreloadPositions;
mLoadedTerrainTimestamp = timestamp;
}
}
void CellPreloader::setExpiryDelay(double expiryDelay)
{
mExpiryDelay = expiryDelay;
}
void CellPreloader::setPreloadInstances(bool preload)
{
mPreloadInstances = preload;
}
void CellPreloader::setWorkQueue(osg::ref_ptr<SceneUtil::WorkQueue> workQueue)
{
mWorkQueue = workQueue;
}
void CellPreloader::syncTerrainLoad(Loading::Listener& listener)
{
if (mTerrainPreloadItem != nullptr && !mTerrainPreloadItem->isDone())
mTerrainPreloadItem->wait(listener);
}
void CellPreloader::abortTerrainPreloadExcept(const PositionCellGrid* exceptPos)
{
if (exceptPos != nullptr && contains(mTerrainPreloadPositions, *exceptPos, Constants::CellSizeInUnits))
return;
if (mTerrainPreloadItem && !mTerrainPreloadItem->isDone())
{
mTerrainPreloadItem->abort();
mTerrainPreloadItem->waitTillDone();
}
setTerrainPreloadPositions({});
}
void CellPreloader::setTerrainPreloadPositions(std::span<const PositionCellGrid> positions)
{
if (positions.empty())
{
mTerrainPreloadPositions.clear();
mLoadedTerrainPositions.clear();
}
else if (contains(mTerrainPreloadPositions, positions, 128.f))
return;
if (mTerrainPreloadItem && !mTerrainPreloadItem->isDone())
return;
else
{
if (mTerrainViews.size() > positions.size())
mTerrainViews.resize(positions.size());
else if (mTerrainViews.size() < positions.size())
{
for (unsigned int i = mTerrainViews.size(); i < positions.size(); ++i)
mTerrainViews.emplace_back(mTerrain->createView());
}
mTerrainPreloadPositions.assign(positions.begin(), positions.end());
if (!positions.empty())
{
mTerrainPreloadItem = new TerrainPreloadItem(mTerrainViews, mTerrain, positions);
mWorkQueue->addWorkItem(mTerrainPreloadItem);
}
}
}
bool CellPreloader::isTerrainLoaded(const PositionCellGrid& position, double referenceTime) const
{
return mLoadedTerrainTimestamp + mResourceSystem->getSceneManager()->getExpiryDelay() > referenceTime
&& contains(mLoadedTerrainPositions, position, Constants::CellSizeInUnits);
}
void CellPreloader::setTerrain(Terrain::World* terrain)
{
if (terrain != mTerrain)
{
clearAllTasks();
mTerrain = terrain;
}
}
void CellPreloader::clearAllTasks()
{
if (mTerrainPreloadItem)
{
mTerrainPreloadItem->abort();
mTerrainPreloadItem->waitTillDone();
mTerrainPreloadItem = nullptr;
}
if (mUpdateCacheItem)
{
mUpdateCacheItem->waitTillDone();
mUpdateCacheItem = nullptr;
}
for (PreloadMap::iterator it = mPreloadCells.begin(); it != mPreloadCells.end(); ++it)
it->second.mWorkItem->abort();
for (PreloadMap::iterator it = mPreloadCells.begin(); it != mPreloadCells.end(); ++it)
it->second.mWorkItem->waitTillDone();
mPreloadCells.clear();
}
void CellPreloader::reportStats(unsigned int frameNumber, osg::Stats& stats) const
{
stats.setAttribute(frameNumber, "CellPreloader Count", mPreloadCells.size());
stats.setAttribute(frameNumber, "CellPreloader Added", mAdded);
stats.setAttribute(frameNumber, "CellPreloader Evicted", mEvicted);
stats.setAttribute(frameNumber, "CellPreloader Loaded", mLoaded);
stats.setAttribute(frameNumber, "CellPreloader Expired", mExpired);
}
}
| 16,303
|
C++
|
.cpp
| 404
| 29.539604
| 119
| 0.600833
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,261
|
actionopen.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionopen.cpp
|
#include "actionopen.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwmechanics/disease.hpp"
namespace MWWorld
{
ActionOpen::ActionOpen(const MWWorld::Ptr& container)
: Action(false, container)
{
}
void ActionOpen::executeImp(const MWWorld::Ptr& actor)
{
if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
return;
if (actor != MWMechanics::getPlayer())
return;
if (!MWBase::Environment::get().getMechanicsManager()->onOpen(getTarget()))
return;
MWMechanics::diseaseContact(actor, getTarget());
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Container, getTarget());
}
}
| 870
|
C++
|
.cpp
| 24
| 30.416667
| 101
| 0.674224
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,262
|
actionharvest.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionharvest.cpp
|
#include "actionharvest.hpp"
#include <sstream>
#include <MyGUI_LanguageManager.h>
#include <components/misc/strings/format.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "class.hpp"
#include "containerstore.hpp"
namespace MWWorld
{
ActionHarvest::ActionHarvest(const MWWorld::Ptr& container)
: Action(true, container)
{
setSound(ESM::RefId::stringRefId("Item Ingredient Up"));
}
void ActionHarvest::executeImp(const MWWorld::Ptr& actor)
{
if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
return;
MWWorld::Ptr target = getTarget();
MWWorld::ContainerStore& store = target.getClass().getContainerStore(target);
store.resolve();
MWWorld::ContainerStore& actorStore = actor.getClass().getContainerStore(actor);
std::map<std::string, int> takenMap;
for (MWWorld::ContainerStoreIterator it = store.begin(); it != store.end(); ++it)
{
if (!it->getClass().showsInInventory(*it))
continue;
int itemCount = it->getCellRef().getCount();
// Note: it is important to check for crime before move an item from container. Otherwise owner check will
// not work for a last item in the container - empty harvested containers are considered as "allowed to
// use".
MWBase::Environment::get().getMechanicsManager()->itemTaken(actor, *it, target, itemCount);
actorStore.add(*it, itemCount);
store.remove(*it, itemCount);
std::string name{ it->getClass().getName(*it) };
takenMap[name] += itemCount;
}
// Spawn a messagebox (only for items added to player's inventory)
if (actor == MWBase::Environment::get().getWorld()->getPlayerPtr())
{
std::ostringstream stream;
int lineCount = 0;
const static int maxLines = 10;
for (const auto& pair : takenMap)
{
const std::string& itemName = pair.first;
int itemCount = pair.second;
lineCount++;
if (lineCount == maxLines)
stream << "\n...";
else if (lineCount > maxLines)
break;
// The two GMST entries below expand to strings informing the player of what, and how many of it has
// been added to their inventory
std::string msgBox;
if (itemCount == 1)
{
msgBox = MyGUI::LanguageManager::getInstance().replaceTags("\n#{sNotifyMessage60}");
msgBox = Misc::StringUtils::format(msgBox, itemName);
}
else
{
msgBox = MyGUI::LanguageManager::getInstance().replaceTags("\n#{sNotifyMessage61}");
msgBox = Misc::StringUtils::format(msgBox, itemCount, itemName);
}
stream << msgBox;
}
std::string tooltip = stream.str();
// remove the first newline (easier this way)
if (tooltip.size() > 0 && tooltip[0] == '\n')
tooltip.erase(0, 1);
if (tooltip.size() > 0)
MWBase::Environment::get().getWindowManager()->messageBox(tooltip);
}
// Update animation object
MWBase::Environment::get().getWorld()->disable(target);
MWBase::Environment::get().getWorld()->enable(target);
}
}
| 3,674
|
C++
|
.cpp
| 82
| 33.536585
| 118
| 0.580771
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,263
|
actionsoulgem.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionsoulgem.cpp
|
#include "actionsoulgem.hpp"
#include <components/debug/debuglog.hpp>
#include <components/esm3/loadcrea.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwworld/esmstore.hpp"
namespace MWWorld
{
ActionSoulgem::ActionSoulgem(const Ptr& object)
: Action(false, object)
{
}
void ActionSoulgem::executeImp(const Ptr& actor)
{
if (actor != MWMechanics::getPlayer())
return;
if (MWMechanics::isPlayerInCombat())
{ // Ensure we're not in combat
MWBase::Environment::get().getWindowManager()->messageBox("#{sInventoryMessage5}");
return;
}
const auto& target = getTarget();
const ESM::RefId& targetSoul = target.getCellRef().getSoul();
if (targetSoul.empty())
{
MWBase::Environment::get().getWindowManager()->messageBox("#{sNotifyMessage32}");
return;
}
if (!MWBase::Environment::get().getESMStore()->get<ESM::Creature>().search(targetSoul))
{
Log(Debug::Warning) << "Soul '" << targetSoul << "' not found (item: '" << target.getCellRef().getRefId()
<< "')";
return;
}
MWBase::Environment::get().getWindowManager()->showSoulgemDialog(target);
}
}
| 1,390
|
C++
|
.cpp
| 38
| 28.605263
| 117
| 0.60717
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,264
|
actionapply.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionapply.cpp
|
#include "actionapply.hpp"
#include "class.hpp"
namespace MWWorld
{
ActionApply::ActionApply(const Ptr& object, const ESM::RefId& id)
: Action(false, object)
, mId(id)
{
}
void ActionApply::executeImp(const Ptr& actor)
{
actor.getClass().consume(getTarget(), actor);
}
}
| 322
|
C++
|
.cpp
| 14
| 18.357143
| 69
| 0.645902
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,265
|
cellref.cpp
|
OpenMW_openmw/apps/openmw/mwworld/cellref.cpp
|
#include "cellref.hpp"
#include <cassert>
#include <components/debug/debuglog.hpp>
#include <components/esm/refid.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm3/objectstate.hpp>
#include <components/esm4/loadrefr.hpp>
#include "apps/openmw/mwbase/environment.hpp"
#include "apps/openmw/mwbase/world.hpp"
#include "apps/openmw/mwmechanics/spellutil.hpp"
#include "apps/openmw/mwworld/esmstore.hpp"
namespace MWWorld
{
CellRef::CellRef(const ESM::CellRef& ref)
: mCellRef(ESM::ReferenceVariant(ref))
{
}
CellRef::CellRef(const ESM4::Reference& ref)
: mCellRef(ESM::ReferenceVariant(ref))
{
}
CellRef::CellRef(const ESM4::ActorCharacter& ref)
: mCellRef(ESM::ReferenceVariant(ref))
{
}
ESM::RefNum CellRef::getRefNum() const noexcept
{
return std::visit(ESM::VisitOverload{
[&](const ESM4::Reference& ref) -> ESM::RefNum { return ref.mId; },
[&](const ESM4::ActorCharacter& ref) -> ESM::RefNum { return ref.mId; },
[&](const ESM::CellRef& ref) -> ESM::RefNum { return ref.mRefNum; },
},
mCellRef.mVariant);
}
ESM::RefNum CellRef::getOrAssignRefNum(ESM::RefNum& lastAssignedRefNum)
{
ESM::RefNum& refNum = std::visit(ESM::VisitOverload{
[&](ESM4::Reference& ref) -> ESM::RefNum& { return ref.mId; },
[&](ESM4::ActorCharacter& ref) -> ESM::RefNum& { return ref.mId; },
[&](ESM::CellRef& ref) -> ESM::RefNum& { return ref.mRefNum; },
},
mCellRef.mVariant);
if (!refNum.isSet())
{
// Generated RefNums have negative mContentFile
assert(lastAssignedRefNum.mContentFile < 0);
lastAssignedRefNum.mIndex++;
if (lastAssignedRefNum.mIndex == 0) // mIndex overflow, so mContentFile should be changed
{
if (lastAssignedRefNum.mContentFile > std::numeric_limits<int32_t>::min())
lastAssignedRefNum.mContentFile--;
else
Log(Debug::Error) << "RefNum counter overflow in CellRef::getOrAssignRefNum";
}
refNum = lastAssignedRefNum;
mChanged = true;
}
return refNum;
}
void CellRef::setRefNum(ESM::RefNum refNum)
{
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& ref) { ref.mId = refNum; },
[&](ESM4::ActorCharacter& ref) { ref.mId = refNum; },
[&](ESM::CellRef& ref) { ref.mRefNum = refNum; },
},
mCellRef.mVariant);
}
static const std::string emptyString = "";
ESM::Position CellRef::getDoorDest() const
{
return std::visit(
ESM::VisitOverload{
[&](const ESM4::Reference& ref) { return ref.mDoor.destPos; },
[&](const ESM::CellRef& ref) -> ESM::Position { return ref.mDoorDest; },
[&](const ESM4::ActorCharacter&) -> ESM::Position { throw std::logic_error("Not applicable"); },
},
mCellRef.mVariant);
}
ESM::RefId CellRef::getDestCell() const
{
auto esm3Visit = [&](const ESM::CellRef& ref) -> ESM::RefId {
if (!ref.mDestCell.empty())
{
return ESM::RefId::stringRefId(ref.mDestCell);
}
else
{
const auto cellPos = ESM::positionToExteriorCellLocation(ref.mDoorDest.pos[0], ref.mDoorDest.pos[1]);
return ESM::RefId::esm3ExteriorCell(cellPos.mX, cellPos.mY);
}
};
auto esm4Visit = [&](const ESM4::Reference& ref) -> ESM::RefId {
if (ref.mDoor.destDoor.isZeroOrUnset())
return ESM::RefId();
const ESM4::Reference* refDest
= MWBase::Environment::get().getESMStore()->get<ESM4::Reference>().searchStatic(ref.mDoor.destDoor);
if (refDest)
return refDest->mParent;
return ESM::RefId();
};
auto actorDestCell
= [&](const ESM4::ActorCharacter&) -> ESM::RefId { throw std::logic_error("Not applicable"); };
return std::visit(ESM::VisitOverload{ esm3Visit, esm4Visit, actorDestCell }, mCellRef.mVariant);
}
void CellRef::setScale(float scale)
{
if (scale != getScale())
{
mChanged = true;
std::visit([scale](auto&& ref) { ref.mScale = scale; }, mCellRef.mVariant);
}
}
void CellRef::setPosition(const ESM::Position& position)
{
mChanged = true;
std::visit([&position](auto&& ref) { ref.mPos = position; }, mCellRef.mVariant);
}
float CellRef::getEnchantmentCharge() const
{
return std::visit(ESM::VisitOverload{
[&](const ESM4::Reference& /*ref*/) { return 0.f; },
[&](const ESM::CellRef& ref) { return ref.mEnchantmentCharge; },
[&](const ESM4::ActorCharacter&) -> float { throw std::logic_error("Not applicable"); },
},
mCellRef.mVariant);
}
float CellRef::getNormalizedEnchantmentCharge(const ESM::Enchantment& enchantment) const
{
const int maxCharge = MWMechanics::getEnchantmentCharge(enchantment);
if (maxCharge == 0)
{
return 0;
}
else if (getEnchantmentCharge() == -1)
{
return 1;
}
else
{
return getEnchantmentCharge() / static_cast<float>(maxCharge);
}
}
void CellRef::setEnchantmentCharge(float charge)
{
if (charge != getEnchantmentCharge())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mEnchantmentCharge = charge; },
},
mCellRef.mVariant);
}
}
void CellRef::setCharge(int charge)
{
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mChargeInt = charge; },
},
mCellRef.mVariant);
}
void CellRef::applyChargeRemainderToBeSubtracted(float chargeRemainder)
{
auto esm3Visit = [&](ESM::CellRef& cellRef3) {
cellRef3.mChargeIntRemainder -= std::abs(chargeRemainder);
if (cellRef3.mChargeIntRemainder <= -1.0f)
{
float newChargeRemainder = std::modf(cellRef3.mChargeIntRemainder, &cellRef3.mChargeIntRemainder);
cellRef3.mChargeInt += static_cast<int>(cellRef3.mChargeIntRemainder);
cellRef3.mChargeIntRemainder = newChargeRemainder;
if (cellRef3.mChargeInt < 0)
cellRef3.mChargeInt = 0;
}
};
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
esm3Visit,
},
mCellRef.mVariant);
}
void CellRef::setChargeIntRemainder(float chargeRemainder)
{
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mChargeIntRemainder = chargeRemainder; },
},
mCellRef.mVariant);
}
void CellRef::setChargeFloat(float charge)
{
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mChargeFloat = charge; },
},
mCellRef.mVariant);
}
const std::string& CellRef::getGlobalVariable() const
{
return std::visit(ESM::VisitOverload{
[&](const ESM4::Reference& /*ref*/) -> const std::string& { return emptyString; },
[&](const ESM4::ActorCharacter& /*ref*/) -> const std::string& { return emptyString; },
[&](const ESM::CellRef& ref) -> const std::string& { return ref.mGlobalVariable; },
},
mCellRef.mVariant);
}
void CellRef::resetGlobalVariable()
{
if (!getGlobalVariable().empty())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter& /*ref*/) {},
[&](ESM::CellRef& ref) { ref.mGlobalVariable.erase(); },
},
mCellRef.mVariant);
}
}
void CellRef::setFactionRank(int factionRank)
{
if (factionRank != getFactionRank())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::ActorCharacter&) {}, [&](auto&& ref) { ref.mFactionRank = factionRank; } },
mCellRef.mVariant);
}
}
void CellRef::setOwner(const ESM::RefId& owner)
{
if (owner != getOwner())
{
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mOwner = owner; },
},
mCellRef.mVariant);
}
}
void CellRef::setSoul(const ESM::RefId& soul)
{
if (soul != getSoul())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mSoul = soul; },
},
mCellRef.mVariant);
}
}
void CellRef::setFaction(const ESM::RefId& faction)
{
if (faction != getFaction())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mFaction = faction; },
},
mCellRef.mVariant);
}
}
void CellRef::setLockLevel(int lockLevel)
{
if (lockLevel != getLockLevel())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& ref) { ref.mLockLevel = lockLevel; },
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mLockLevel = lockLevel; },
},
mCellRef.mVariant);
}
}
void CellRef::lock(int lockLevel)
{
setLockLevel(lockLevel);
setLocked(true);
}
void CellRef::unlock()
{
setLockLevel(-getLockLevel());
setLocked(false);
}
bool CellRef::isLocked() const
{
struct Visitor
{
bool operator()(const ESM::CellRef& ref) { return ref.mIsLocked; }
bool operator()(const ESM4::Reference& ref) { return ref.mIsLocked; }
bool operator()(const ESM4::ActorCharacter&) { throw std::logic_error("Not applicable"); }
};
return std::visit(Visitor(), mCellRef.mVariant);
}
void CellRef::setLocked(bool locked)
{
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& ref) { ref.mIsLocked = locked; },
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mIsLocked = locked; },
},
mCellRef.mVariant);
}
void CellRef::setTrap(const ESM::RefId& trap)
{
if (trap != getTrap())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mTrap = trap; },
},
mCellRef.mVariant);
}
}
void CellRef::setKey(const ESM::RefId& key)
{
if (key != getKey())
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& /*ref*/) {},
[&](ESM4::ActorCharacter&) {},
[&](ESM::CellRef& ref) { ref.mKey = key; },
},
mCellRef.mVariant);
}
}
void CellRef::setCount(int value)
{
if (value != getCount(false))
{
mChanged = true;
std::visit(ESM::VisitOverload{
[&](ESM4::Reference& ref) { ref.mCount = value; },
[&](ESM4::ActorCharacter& ref) { ref.mCount = value; },
[&](ESM::CellRef& ref) { ref.mCount = value; },
},
mCellRef.mVariant);
if (value == 0)
MWBase::Environment::get().getWorld()->removeRefScript(this);
}
}
void CellRef::writeState(ESM::ObjectState& state) const
{
std::visit(ESM::VisitOverload{
[&](const ESM4::Reference& /*ref*/) {},
[&](const ESM4::ActorCharacter&) {},
[&](const ESM::CellRef& ref) { state.mRef = ref; },
},
mCellRef.mVariant);
}
}
| 14,240
|
C++
|
.cpp
| 366
| 25.814208
| 118
| 0.490351
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,266
|
refdata.cpp
|
OpenMW_openmw/apps/openmw/mwworld/refdata.cpp
|
#include "refdata.hpp"
#include <components/esm3/objectstate.hpp>
#include <components/esm4/loadachr.hpp>
#include <components/esm4/loadrefr.hpp>
#include <components/sceneutil/positionattitudetransform.hpp>
#include "customdata.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
#include "../mwlua/localscripts.hpp"
namespace
{
enum RefDataFlags
{
Flag_SuppressActivate = 1, // If set, activation will be suppressed and redirected to the OnActivate flag, which
// can then be handled by a script.
Flag_OnActivate = 2,
Flag_ActivationBuffered = 4
};
}
namespace MWWorld
{
void RefData::setLuaScripts(std::shared_ptr<MWLua::LocalScripts>&& scripts)
{
mChanged = true;
mLuaScripts = std::move(scripts);
}
void RefData::copy(const RefData& refData)
{
mBaseNode = refData.mBaseNode;
mLocals = refData.mLocals;
mEnabled = refData.mEnabled;
mPosition = refData.mPosition;
mChanged = refData.mChanged;
mDeletedByContentFile = refData.mDeletedByContentFile;
mFlags = refData.mFlags;
mPhysicsPostponed = refData.mPhysicsPostponed;
mAnimationState = refData.mAnimationState;
mCustomData = refData.mCustomData ? refData.mCustomData->clone() : nullptr;
mLuaScripts = refData.mLuaScripts;
}
void RefData::cleanup()
{
mBaseNode = nullptr;
mCustomData = nullptr;
mLuaScripts = nullptr;
}
RefData::RefData()
: mBaseNode(nullptr)
, mCustomData(nullptr)
, mFlags(0)
, mDeletedByContentFile(false)
, mEnabled(true)
, mPhysicsPostponed(false)
, mChanged(false)
{
for (int i = 0; i < 3; ++i)
{
mPosition.pos[i] = 0;
mPosition.rot[i] = 0;
}
}
RefData::RefData(const ESM::CellRef& cellRef)
: mBaseNode(nullptr)
, mPosition(cellRef.mPos)
, mCustomData(nullptr)
, mFlags(0) // Loading from ESM/ESP files -> assume unchanged
, mDeletedByContentFile(false)
, mEnabled(true)
, mPhysicsPostponed(false)
, mChanged(false)
{
}
RefData::RefData(const ESM4::Reference& ref)
: mBaseNode(nullptr)
, mPosition(ref.mPos)
, mCustomData(nullptr)
, mFlags(0)
, mDeletedByContentFile(ref.mFlags & ESM4::Rec_Deleted)
, mEnabled(!(ref.mFlags & ESM4::Rec_Disabled))
, mPhysicsPostponed(false)
, mChanged(false)
{
}
RefData::RefData(const ESM4::ActorCharacter& ref)
: mBaseNode(nullptr)
, mPosition(ref.mPos)
, mCustomData(nullptr)
, mFlags(0)
, mDeletedByContentFile(ref.mFlags & ESM4::Rec_Deleted)
, mEnabled(!(ref.mFlags & ESM4::Rec_Disabled))
, mPhysicsPostponed(false)
, mChanged(false)
{
}
RefData::RefData(const ESM::ObjectState& objectState, bool deletedByContentFile)
: mBaseNode(nullptr)
, mPosition(objectState.mPosition)
, mAnimationState(objectState.mAnimationState)
, mCustomData(nullptr)
, mFlags(objectState.mFlags) // Loading from a savegame -> assume changed
, mDeletedByContentFile(deletedByContentFile)
, mEnabled(objectState.mEnabled != 0)
, mPhysicsPostponed(false)
, mChanged(true)
{
// "Note that the ActivationFlag_UseEnabled is saved to the reference,
// which will result in permanently suppressed activation if the reference script is removed.
// This occurred when removing the animated containers mod, and the fix in MCP is to reset UseEnabled to true on
// loading a game."
mFlags &= (~Flag_SuppressActivate);
}
RefData::RefData(const RefData& refData)
: mBaseNode(nullptr)
, mCustomData(nullptr)
{
try
{
copy(refData);
mFlags &= ~(Flag_SuppressActivate | Flag_OnActivate | Flag_ActivationBuffered);
}
catch (...)
{
cleanup();
throw;
}
}
void RefData::write(ESM::ObjectState& objectState, const ESM::RefId& scriptId) const
{
objectState.mHasLocals = mLocals.write(objectState.mLocals, scriptId);
objectState.mEnabled = mEnabled;
objectState.mPosition = mPosition;
objectState.mFlags = mFlags;
objectState.mAnimationState = mAnimationState;
}
RefData& RefData::operator=(const RefData& refData)
{
try
{
cleanup();
copy(refData);
}
catch (...)
{
cleanup();
throw;
}
return *this;
}
RefData::~RefData()
{
try
{
cleanup();
}
catch (...)
{
}
}
RefData::RefData(RefData&& other) = default;
RefData& RefData::operator=(RefData&& other) = default;
void RefData::setBaseNode(osg::ref_ptr<SceneUtil::PositionAttitudeTransform> base)
{
mBaseNode = std::move(base);
}
SceneUtil::PositionAttitudeTransform* RefData::getBaseNode()
{
return mBaseNode;
}
const SceneUtil::PositionAttitudeTransform* RefData::getBaseNode() const
{
return mBaseNode;
}
void RefData::setLocals(const ESM::Script& script)
{
if (mLocals.configure(script) && !mLocals.isEmpty())
mChanged = true;
}
void RefData::setDeletedByContentFile(bool deleted)
{
mDeletedByContentFile = deleted;
}
bool RefData::isDeletedByContentFile() const
{
return mDeletedByContentFile;
}
MWScript::Locals& RefData::getLocals()
{
return mLocals;
}
bool RefData::isEnabled() const
{
return mEnabled;
}
void RefData::enable()
{
if (!mEnabled)
{
mChanged = true;
mEnabled = true;
}
}
void RefData::disable()
{
if (mEnabled)
{
mChanged = true;
mEnabled = false;
}
}
void RefData::setPosition(const ESM::Position& pos)
{
mChanged = true;
mPosition = pos;
}
const ESM::Position& RefData::getPosition() const
{
return mPosition;
}
void RefData::setCustomData(std::unique_ptr<CustomData>&& value) noexcept
{
mChanged = true; // We do not currently track CustomData, so assume anything with a CustomData is changed
mCustomData = std::move(value);
}
CustomData* RefData::getCustomData()
{
return mCustomData.get();
}
const CustomData* RefData::getCustomData() const
{
return mCustomData.get();
}
bool RefData::hasChanged() const
{
return mChanged || !mAnimationState.empty();
}
bool RefData::activateByScript()
{
bool ret = (mFlags & Flag_ActivationBuffered);
mFlags &= ~(Flag_SuppressActivate | Flag_OnActivate);
return ret;
}
bool RefData::activate()
{
if (mFlags & Flag_SuppressActivate)
{
mFlags |= Flag_OnActivate | Flag_ActivationBuffered;
return false;
}
else
{
return true;
}
}
bool RefData::onActivate()
{
bool ret = mFlags & Flag_OnActivate;
mFlags |= Flag_SuppressActivate;
mFlags &= (~Flag_OnActivate);
return ret;
}
const ESM::AnimationState& RefData::getAnimationState() const
{
return mAnimationState;
}
ESM::AnimationState& RefData::getAnimationState()
{
return mAnimationState;
}
}
| 7,800
|
C++
|
.cpp
| 269
| 21.434944
| 120
| 0.607482
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,267
|
esmstore.cpp
|
OpenMW_openmw/apps/openmw/mwworld/esmstore.cpp
|
#include "esmstore.hpp"
#include <algorithm>
#include <fstream>
#include <tuple>
#include <components/debug/debuglog.hpp>
#include <components/esm/records.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/readerscache.hpp>
#include <components/esm4/common.hpp>
#include <components/esm4/reader.hpp>
#include <components/esm4/readerutils.hpp>
#include <components/esmloader/load.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/lua/configuration.hpp>
#include <components/misc/algorithm.hpp>
#include "../mwmechanics/spelllist.hpp"
namespace
{
struct Ref
{
ESM::RefNum mRefNum;
std::size_t mRefID;
Ref(ESM::RefNum refNum, std::size_t refID)
: mRefNum(refNum)
, mRefID(refID)
{
}
};
constexpr std::size_t deletedRefID = std::numeric_limits<std::size_t>::max();
void readRefs(const ESM::Cell& cell, std::vector<Ref>& refs, std::vector<ESM::RefId>& refIDs,
std::set<ESM::RefId>& keyIDs, ESM::ReadersCache& readers)
{
// TODO: we have many similar copies of this code.
for (size_t i = 0; i < cell.mContextList.size(); i++)
{
const std::size_t index = static_cast<std::size_t>(cell.mContextList[i].index);
const ESM::ReadersCache::BusyItem reader = readers.get(index);
cell.restore(*reader, i);
ESM::CellRef ref;
bool deleted = false;
while (cell.getNextRef(*reader, ref, deleted))
{
if (deleted)
refs.emplace_back(ref.mRefNum, deletedRefID);
else if (std::find(cell.mMovedRefs.begin(), cell.mMovedRefs.end(), ref.mRefNum)
== cell.mMovedRefs.end())
{
if (!ref.mKey.empty())
keyIDs.insert(std::move(ref.mKey));
refs.emplace_back(ref.mRefNum, refIDs.size());
refIDs.push_back(std::move(ref.mRefID));
}
}
}
for (const auto& [value, deleted] : cell.mLeasedRefs)
{
if (deleted)
refs.emplace_back(value.mRefNum, deletedRefID);
else
{
if (!value.mKey.empty())
keyIDs.insert(std::move(value.mKey));
refs.emplace_back(value.mRefNum, refIDs.size());
refIDs.push_back(value.mRefID);
}
}
}
const ESM::RefId& getDefaultClass(const MWWorld::Store<ESM::Class>& classes)
{
auto it = classes.begin();
if (it != classes.end())
return it->mId;
throw std::runtime_error("List of NPC classes is empty!");
}
const ESM::RefId& getDefaultRace(const MWWorld::Store<ESM::Race>& races)
{
auto it = races.begin();
if (it != races.end())
return it->mId;
throw std::runtime_error("List of NPC races is empty!");
}
std::vector<ESM::NPC> getNPCsToReplace(const MWWorld::Store<ESM::Faction>& factions,
const MWWorld::Store<ESM::Class>& classes, const MWWorld::Store<ESM::Race>& races,
const MWWorld::Store<ESM::Script>& scripts, const std::unordered_map<ESM::RefId, ESM::NPC>& npcs)
{
// Cache first class from store - we will use it if current class is not found
const ESM::RefId& defaultCls = getDefaultClass(classes);
// Same for races
const ESM::RefId& defaultRace = getDefaultRace(races);
// Validate NPCs for non-existing class and faction.
// We will replace invalid entries by fixed ones
std::vector<ESM::NPC> npcsToReplace;
for (const auto& npcIter : npcs)
{
ESM::NPC npc = npcIter.second;
bool changed = false;
const ESM::RefId& npcFaction = npc.mFaction;
if (!npcFaction.empty())
{
const ESM::Faction* fact = factions.search(npcFaction);
if (!fact)
{
Log(Debug::Verbose) << "NPC " << npc.mId << " (" << npc.mName << ") has nonexistent faction "
<< npc.mFaction << ", ignoring it.";
npc.mFaction = ESM::RefId();
npc.mNpdt.mRank = 0;
changed = true;
}
}
const ESM::Class* cls = classes.search(npc.mClass);
if (!cls)
{
Log(Debug::Verbose) << "NPC " << npc.mId << " (" << npc.mName << ") has nonexistent class "
<< npc.mClass << ", using " << defaultCls << " class as replacement.";
npc.mClass = defaultCls;
changed = true;
}
const ESM::Race* race = races.search(npc.mRace);
if (!race)
{
Log(Debug::Verbose) << "NPC " << npc.mId << " (" << npc.mName << ") has nonexistent race " << npc.mRace
<< ", using " << defaultRace << " race as replacement.";
npc.mRace = defaultRace;
changed = true;
}
if (!npc.mScript.empty() && !scripts.search(npc.mScript))
{
Log(Debug::Verbose) << "NPC " << npc.mId << " (" << npc.mName << ") has nonexistent script "
<< npc.mScript << ", ignoring it.";
npc.mScript = ESM::RefId();
changed = true;
}
if (changed)
npcsToReplace.push_back(npc);
}
return npcsToReplace;
}
template <class RecordType>
std::vector<RecordType> getSpellsToReplace(
const MWWorld::Store<RecordType>& spells, const MWWorld::Store<ESM::MagicEffect>& magicEffects)
{
std::vector<RecordType> spellsToReplace;
for (RecordType spell : spells)
{
if (spell.mEffects.mList.empty())
continue;
bool changed = false;
auto iter = spell.mEffects.mList.begin();
while (iter != spell.mEffects.mList.end())
{
const ESM::MagicEffect* mgef = magicEffects.search(iter->mData.mEffectID);
if (!mgef)
{
Log(Debug::Verbose) << RecordType::getRecordType() << " " << spell.mId
<< ": dropping invalid effect (index " << iter->mData.mEffectID << ")";
iter = spell.mEffects.mList.erase(iter);
changed = true;
continue;
}
if (!(mgef->mData.mFlags & ESM::MagicEffect::TargetAttribute) && iter->mData.mAttribute != -1)
{
iter->mData.mAttribute = -1;
Log(Debug::Verbose) << RecordType::getRecordType() << " " << spell.mId
<< ": dropping unexpected attribute argument of "
<< ESM::MagicEffect::indexToGmstString(iter->mData.mEffectID) << " effect";
changed = true;
}
if (!(mgef->mData.mFlags & ESM::MagicEffect::TargetSkill) && iter->mData.mSkill != -1)
{
iter->mData.mSkill = -1;
Log(Debug::Verbose) << RecordType::getRecordType() << " " << spell.mId
<< ": dropping unexpected skill argument of "
<< ESM::MagicEffect::indexToGmstString(iter->mData.mEffectID) << " effect";
changed = true;
}
++iter;
}
if (changed)
spellsToReplace.emplace_back(spell);
}
return spellsToReplace;
}
// Custom enchanted items can reference scripts that no longer exist, this doesn't necessarily mean the base item no
// longer exists however. So instead of removing the item altogether, we're only removing the script.
template <class MapT>
void removeMissingScripts(const MWWorld::Store<ESM::Script>& scripts, MapT& items)
{
for (auto& [id, item] : items)
{
if (!item.mScript.empty() && !scripts.search(item.mScript))
{
Log(Debug::Verbose) << MapT::mapped_type::getRecordType() << ' ' << id << " (" << item.mName
<< ") has nonexistent script " << item.mScript << ", ignoring it.";
item.mScript = ESM::RefId();
}
}
}
}
namespace MWWorld
{
using IDMap = std::unordered_map<ESM::RefId, int>;
struct ESMStoreImp
{
ESMStore::StoreTuple mStores;
std::map<ESM::RecNameInts, DynamicStore*> mRecNameToStore;
// Lookup of all IDs. Makes looking up references faster. Just
// maps the id name to the record type.
IDMap mIds;
IDMap mStaticIds;
template <typename T>
static void assignStoreToIndex(ESMStore& stores, Store<T>& store)
{
const std::size_t storeIndex = ESMStore::getTypeIndex<T>();
if (stores.mStores.size() <= storeIndex)
stores.mStores.resize(storeIndex + 1);
assert(&store == &std::get<Store<T>>(stores.mStoreImp->mStores));
stores.mStores[storeIndex] = &store;
if constexpr (std::is_convertible_v<Store<T>*, DynamicStore*>)
{
stores.mDynamicStores.push_back(&store);
constexpr ESM::RecNameInts recName = T::sRecordId;
if constexpr (recName != ESM::REC_INTERNAL_PLAYER)
{
stores.mStoreImp->mRecNameToStore[recName] = &store;
}
}
}
template <typename T>
static bool typedReadRecordESM4(ESM4::Reader& reader, Store<T>& store)
{
auto recordType = static_cast<ESM4::RecordTypes>(reader.hdr().record.typeId);
ESM::RecNameInts esm4RecName = static_cast<ESM::RecNameInts>(ESM::esm4Recname(recordType));
if constexpr (HasRecordId<T>::value)
{
if constexpr (ESM::isESM4Rec(T::sRecordId))
{
if (T::sRecordId == esm4RecName)
{
reader.getRecordData();
T value;
value.load(reader);
store.insertStatic(value);
return true;
}
}
}
return false;
}
static bool readRecord(ESM4::Reader& reader, ESMStore& store)
{
return std::apply(
[&reader](auto&... x) { return (typedReadRecordESM4(reader, x) || ...); }, store.mStoreImp->mStores);
}
};
int ESMStore::find(const ESM::RefId& id) const
{
IDMap::const_iterator it = mStoreImp->mIds.find(id);
if (it == mStoreImp->mIds.end())
{
return 0;
}
return it->second;
}
int ESMStore::findStatic(const ESM::RefId& id) const
{
IDMap::const_iterator it = mStoreImp->mStaticIds.find(id);
if (it == mStoreImp->mStaticIds.end())
{
return 0;
}
return it->second;
}
ESMStore::ESMStore()
{
mStoreImp = std::make_unique<ESMStoreImp>();
std::apply([this](auto&... x) { (ESMStoreImp::assignStoreToIndex(*this, x), ...); }, mStoreImp->mStores);
mDynamicCount = 0;
getWritable<ESM::Pathgrid>().setCells(getWritable<ESM::Cell>());
}
ESMStore::~ESMStore() = default;
void ESMStore::clearDynamic()
{
for (const auto& store : mDynamicStores)
store->clearDynamic();
mStoreImp->mIds = mStoreImp->mStaticIds;
movePlayerRecord();
}
static bool isCacheableRecord(int id)
{
switch (id)
{
case ESM::REC_ACTI:
case ESM::REC_ALCH:
case ESM::REC_APPA:
case ESM::REC_ARMO:
case ESM::REC_BOOK:
case ESM::REC_CLOT:
case ESM::REC_CONT:
case ESM::REC_CREA:
case ESM::REC_DOOR:
case ESM::REC_INGR:
case ESM::REC_LEVC:
case ESM::REC_LEVI:
case ESM::REC_LIGH:
case ESM::REC_LOCK:
case ESM::REC_MISC:
case ESM::REC_NPC_:
case ESM::REC_PROB:
case ESM::REC_REPA:
case ESM::REC_STAT:
case ESM::REC_WEAP:
case ESM::REC_BODY:
case ESM::REC_ACTI4:
case ESM::REC_ALCH4:
case ESM::REC_AMMO4:
case ESM::REC_ARMO4:
case ESM::REC_BOOK4:
case ESM::REC_CONT4:
case ESM::REC_CREA4:
case ESM::REC_DOOR4:
case ESM::REC_FLOR4:
case ESM::REC_FURN4:
case ESM::REC_IMOD4:
case ESM::REC_INGR4:
case ESM::REC_LIGH4:
case ESM::REC_LVLI4:
case ESM::REC_LVLC4:
case ESM::REC_LVLN4:
case ESM::REC_MISC4:
case ESM::REC_MSTT4:
case ESM::REC_NPC_4:
case ESM::REC_SCOL4:
case ESM::REC_STAT4:
case ESM::REC_TERM4:
case ESM::REC_TREE4:
case ESM::REC_WEAP4:
return true;
break;
}
return false;
}
void ESMStore::load(ESM::ESMReader& esm, Loading::Listener* listener, ESM::Dialogue*& dialogue)
{
if (listener != nullptr)
listener->setProgressRange(::EsmLoader::fileProgress);
// Loop through all records
while (esm.hasMoreRecs())
{
ESM::NAME n = esm.getRecName();
esm.getRecHeader();
if (esm.getRecordFlags() & ESM::FLAG_Ignored)
{
esm.skipRecord();
continue;
}
// Look up the record type.
ESM::RecNameInts recName = static_cast<ESM::RecNameInts>(n.toInt());
const auto& it = mStoreImp->mRecNameToStore.find(recName);
if (it == mStoreImp->mRecNameToStore.end())
{
if (recName == ESM::REC_INFO)
{
if (dialogue)
{
dialogue->readInfo(esm);
}
else
{
Log(Debug::Error) << "Error: info record without dialog";
esm.skipRecord();
}
}
else if (n.toInt() == ESM::REC_MGEF)
{
getWritable<ESM::MagicEffect>().load(esm);
}
else if (n.toInt() == ESM::REC_SKIL)
{
getWritable<ESM::Skill>().load(esm);
}
else if (n.toInt() == ESM::REC_FILT || n.toInt() == ESM::REC_DBGP)
{
// ignore project file only records
esm.skipRecord();
}
else if (n.toInt() == ESM::REC_LUAL)
{
ESM::LuaScriptsCfg cfg;
cfg.load(esm);
cfg.adjustRefNums(esm);
mLuaContent.push_back(std::move(cfg));
}
else
{
throw std::runtime_error("Unknown record: " + n.toString());
}
}
else
{
RecordId id = it->second->load(esm);
if (id.mIsDeleted)
{
it->second->eraseStatic(id.mId);
continue;
}
if (n.toInt() == ESM::REC_DIAL)
{
dialogue = const_cast<ESM::Dialogue*>(getWritable<ESM::Dialogue>().find(id.mId));
}
else
{
dialogue = nullptr;
}
}
if (listener != nullptr)
listener->setProgress(::EsmLoader::fileProgress * esm.getFileOffset() / esm.getFileSize());
}
}
void ESMStore::loadESM4(ESM4::Reader& reader)
{
auto visitorRec = [this](ESM4::Reader& reader) { return ESMStoreImp::readRecord(reader, *this); };
ESM4::ReaderUtils::readAll(reader, visitorRec, [](ESM4::Reader&) {});
}
void ESMStore::setIdType(const ESM::RefId& id, ESM::RecNameInts type)
{
mStoreImp->mIds[id] = type;
}
ESM::LuaScriptsCfg ESMStore::getLuaScriptsCfg() const
{
ESM::LuaScriptsCfg cfg;
for (const LuaContent& c : mLuaContent)
{
if (std::holds_alternative<std::filesystem::path>(c))
{
// *.omwscripts are intentionally reloaded every time when `getLuaScriptsCfg` is called.
// It is important for the `reloadlua` console command.
try
{
auto file = std::ifstream(std::get<std::filesystem::path>(c));
std::string fileContent(std::istreambuf_iterator<char>(file), {});
LuaUtil::parseOMWScripts(cfg, fileContent);
}
catch (std::exception& e)
{
Log(Debug::Error) << e.what();
}
}
else
{
const ESM::LuaScriptsCfg& addition = std::get<ESM::LuaScriptsCfg>(c);
cfg.mScripts.insert(cfg.mScripts.end(), addition.mScripts.begin(), addition.mScripts.end());
}
}
return cfg;
}
void ESMStore::setUp()
{
if (mIsSetUpDone)
throw std::logic_error("ESMStore::setUp() is called twice");
mIsSetUpDone = true;
for (const auto& [_, store] : mStoreImp->mRecNameToStore)
store->setUp();
getWritable<ESM::Skill>().setUp(get<ESM::GameSetting>());
getWritable<ESM::MagicEffect>().setUp();
getWritable<ESM::Attribute>().setUp(get<ESM::GameSetting>());
getWritable<ESM4::Land>().updateLandPositions(get<ESM4::Cell>());
getWritable<ESM4::Reference>().preprocessReferences(get<ESM4::Cell>());
getWritable<ESM4::ActorCharacter>().preprocessReferences(get<ESM4::Cell>());
getWritable<ESM4::ActorCreature>().preprocessReferences(get<ESM4::Cell>());
rebuildIdsIndex();
mStoreImp->mStaticIds = mStoreImp->mIds;
}
void ESMStore::rebuildIdsIndex()
{
mStoreImp->mIds.clear();
for (const auto& [recordType, store] : mStoreImp->mRecNameToStore)
{
if (isCacheableRecord(recordType))
{
std::vector<ESM::RefId> identifiers;
store->listIdentifier(identifiers);
for (auto& record : identifiers)
mStoreImp->mIds[record] = recordType;
}
}
}
void ESMStore::validateRecords(ESM::ReadersCache& readers)
{
validate();
countAllCellRefsAndMarkKeys(readers);
}
void ESMStore::countAllCellRefsAndMarkKeys(ESM::ReadersCache& readers)
{
// TODO: We currently need to read entire files here again.
// We should consider consolidating or deferring this reading.
if (!mRefCount.empty())
return;
std::vector<Ref> refs;
std::set<ESM::RefId> keyIDs;
std::vector<ESM::RefId> refIDs;
Store<ESM::Cell> Cells = get<ESM::Cell>();
for (auto it = Cells.intBegin(); it != Cells.intEnd(); ++it)
readRefs(*it, refs, refIDs, keyIDs, readers);
for (auto it = Cells.extBegin(); it != Cells.extEnd(); ++it)
readRefs(*it, refs, refIDs, keyIDs, readers);
const auto lessByRefNum = [](const Ref& l, const Ref& r) { return l.mRefNum < r.mRefNum; };
std::stable_sort(refs.begin(), refs.end(), lessByRefNum);
const auto equalByRefNum = [](const Ref& l, const Ref& r) { return l.mRefNum == r.mRefNum; };
const auto incrementRefCount = [&](const Ref& value) {
if (value.mRefID != deletedRefID)
{
ESM::RefId& refId = refIDs[value.mRefID];
++mRefCount[std::move(refId)];
}
};
Misc::forEachUnique(refs.rbegin(), refs.rend(), equalByRefNum, incrementRefCount);
auto& store = getWritable<ESM::Miscellaneous>().mStatic;
for (const auto& id : keyIDs)
{
auto it = store.find(id);
if (it != store.end())
it->second.mData.mFlags |= ESM::Miscellaneous::Key;
}
}
int ESMStore::getRefCount(const ESM::RefId& id) const
{
auto it = mRefCount.find(id);
if (it == mRefCount.end())
return 0;
return it->second;
}
void ESMStore::validate()
{
auto& npcs = getWritable<ESM::NPC>();
std::vector<ESM::NPC> npcsToReplace = getNPCsToReplace(getWritable<ESM::Faction>(), getWritable<ESM::Class>(),
getWritable<ESM::Race>(), getWritable<ESM::Script>(), npcs.mStatic);
for (const ESM::NPC& npc : npcsToReplace)
{
npcs.eraseStatic(npc.mId);
npcs.insertStatic(npc);
}
removeMissingScripts(getWritable<ESM::Script>(), getWritable<ESM::Creature>().mStatic);
// Validate spell effects and enchantments for invalid arguments
auto& spells = getWritable<ESM::Spell>();
auto& enchantments = getWritable<ESM::Enchantment>();
auto& magicEffects = getWritable<ESM::MagicEffect>();
std::vector<ESM::Spell> spellsToReplace = getSpellsToReplace(spells, magicEffects);
for (const ESM::Spell& spell : spellsToReplace)
{
spells.eraseStatic(spell.mId);
spells.insertStatic(spell);
}
std::vector<ESM::Enchantment> enchantmentsToReplace = getSpellsToReplace(enchantments, magicEffects);
for (const ESM::Enchantment& enchantment : enchantmentsToReplace)
{
enchantments.eraseStatic(enchantment.mId);
enchantments.insertStatic(enchantment);
}
}
void ESMStore::movePlayerRecord()
{
auto& npcs = getWritable<ESM::NPC>();
auto player = npcs.find(ESM::RefId::stringRefId("Player"));
npcs.insert(*player);
}
void ESMStore::validateDynamic()
{
auto& npcs = getWritable<ESM::NPC>();
auto& scripts = getWritable<ESM::Script>();
std::vector<ESM::NPC> npcsToReplace = getNPCsToReplace(getWritable<ESM::Faction>(), getWritable<ESM::Class>(),
getWritable<ESM::Race>(), getWritable<ESM::Script>(), npcs.mDynamic);
for (const ESM::NPC& npc : npcsToReplace)
npcs.insert(npc);
removeMissingScripts(scripts, getWritable<ESM::Armor>().mDynamic);
removeMissingScripts(scripts, getWritable<ESM::Book>().mDynamic);
removeMissingScripts(scripts, getWritable<ESM::Clothing>().mDynamic);
removeMissingScripts(scripts, getWritable<ESM::Creature>().mDynamic);
removeMissingScripts(scripts, getWritable<ESM::Weapon>().mDynamic);
removeMissingObjects(getWritable<ESM::CreatureLevList>());
removeMissingObjects(getWritable<ESM::ItemLevList>());
}
// Leveled lists can be modified by scripts. This removes items that no longer exist (presumably because the
// plugin was removed) from modified lists
template <class T>
void ESMStore::removeMissingObjects(Store<T>& store)
{
for (auto& entry : store.mDynamic)
{
auto first = std::remove_if(entry.second.mList.begin(), entry.second.mList.end(), [&](const auto& item) {
if (!find(item.mId))
{
Log(Debug::Verbose) << "Leveled list " << entry.first << " has nonexistent object " << item.mId
<< ", ignoring it.";
return true;
}
return false;
});
entry.second.mList.erase(first, entry.second.mList.end());
}
}
int ESMStore::countSavedGameRecords() const
{
return 1 // DYNA (dynamic name counter)
+ get<ESM::Potion>().getDynamicSize() + get<ESM::Armor>().getDynamicSize()
+ get<ESM::Book>().getDynamicSize() + get<ESM::Class>().getDynamicSize()
+ get<ESM::Clothing>().getDynamicSize() + get<ESM::Enchantment>().getDynamicSize()
+ get<ESM::NPC>().getDynamicSize() + get<ESM::Spell>().getDynamicSize()
+ get<ESM::Activator>().getDynamicSize() + get<ESM::Miscellaneous>().getDynamicSize()
+ get<ESM::Weapon>().getDynamicSize() + get<ESM::CreatureLevList>().getDynamicSize()
+ get<ESM::ItemLevList>().getDynamicSize() + get<ESM::Creature>().getDynamicSize()
+ get<ESM::Container>().getDynamicSize() + get<ESM::Light>().getDynamicSize();
}
void ESMStore::write(ESM::ESMWriter& writer, Loading::Listener& progress) const
{
writer.startRecord(ESM::REC_DYNA);
writer.startSubRecord("COUN");
writer.writeT(mDynamicCount);
writer.endRecord("COUN");
writer.endRecord(ESM::REC_DYNA);
get<ESM::Potion>().write(writer, progress);
get<ESM::Armor>().write(writer, progress);
get<ESM::Book>().write(writer, progress);
get<ESM::Class>().write(writer, progress);
get<ESM::Clothing>().write(writer, progress);
get<ESM::Enchantment>().write(writer, progress);
get<ESM::NPC>().write(writer, progress);
get<ESM::Miscellaneous>().write(writer, progress);
get<ESM::Activator>().write(writer, progress);
get<ESM::Spell>().write(writer, progress);
get<ESM::Weapon>().write(writer, progress);
get<ESM::CreatureLevList>().write(writer, progress);
get<ESM::ItemLevList>().write(writer, progress);
get<ESM::Creature>().write(writer, progress);
get<ESM::Container>().write(writer, progress);
get<ESM::Light>().write(writer, progress);
}
bool ESMStore::readRecord(ESM::ESMReader& reader, uint32_t type_id)
{
ESM::RecNameInts type = (ESM::RecNameInts)type_id;
switch (type)
{
case ESM::REC_ALCH:
case ESM::REC_MISC:
case ESM::REC_ACTI:
case ESM::REC_ARMO:
case ESM::REC_BOOK:
case ESM::REC_CLAS:
case ESM::REC_CLOT:
case ESM::REC_ENCH:
case ESM::REC_SPEL:
case ESM::REC_WEAP:
case ESM::REC_LEVI:
case ESM::REC_LEVC:
case ESM::REC_LIGH:
mStoreImp->mRecNameToStore[type]->read(reader);
return true;
case ESM::REC_NPC_:
case ESM::REC_CREA:
case ESM::REC_CONT:
mStoreImp->mRecNameToStore[type]->read(reader, true);
return true;
case ESM::REC_DYNA:
reader.getSubNameIs("COUN");
if (reader.getFormatVersion() <= ESM::MaxActiveSpellTypeVersion)
{
uint32_t dynamicCount32 = 0;
reader.getHT(dynamicCount32);
mDynamicCount = dynamicCount32;
}
else
{
reader.getHT(mDynamicCount);
}
return true;
default:
return false;
}
}
void ESMStore::checkPlayer()
{
const ESM::NPC* player = get<ESM::NPC>().find(ESM::RefId::stringRefId("Player"));
if (!get<ESM::Race>().find(player->mRace) || !get<ESM::Class>().find(player->mClass))
throw std::runtime_error("Invalid player record (race or class unavailable");
}
std::pair<std::shared_ptr<MWMechanics::SpellList>, bool> ESMStore::getSpellList(const ESM::RefId& id) const
{
auto result = mSpellListCache.find(id);
std::shared_ptr<MWMechanics::SpellList> ptr;
if (result != mSpellListCache.end())
ptr = result->second.lock();
if (!ptr)
{
int type = find(id);
ptr = std::make_shared<MWMechanics::SpellList>(id, type);
if (result != mSpellListCache.end())
result->second = ptr;
else
mSpellListCache.insert({ id, ptr });
return { ptr, false };
}
return { ptr, true };
}
template <>
const ESM::Cell* ESMStore::insert<ESM::Cell>(const ESM::Cell& cell)
{
return getWritable<ESM::Cell>().insert(cell);
}
template <>
const ESM::NPC* ESMStore::insert<ESM::NPC>(const ESM::NPC& npc)
{
auto& npcs = getWritable<ESM::NPC>();
if (npc.mId == "Player")
{
return npcs.insert(npc);
}
const ESM::RefId id = ESM::RefId::generated(mDynamicCount++);
if (npcs.search(id) != nullptr)
throw std::runtime_error("Try to override existing record: " + id.toDebugString());
ESM::NPC record = npc;
record.mId = id;
ESM::NPC* ptr = npcs.insert(record);
mStoreImp->mIds[ptr->mId] = ESM::REC_NPC_;
return ptr;
}
} // end namespace
| 29,725
|
C++
|
.cpp
| 726
| 28.822314
| 120
| 0.535785
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,268
|
projectilemanager.cpp
|
OpenMW_openmw/apps/openmw/mwworld/projectilemanager.cpp
|
#include "projectilemanager.hpp"
#include <iomanip>
#include <memory>
#include <optional>
#include <sstream>
#include <osg/PositionAttitudeTransform>
#include <components/debug/debuglog.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/projectilestate.hpp>
#include <components/esm/quaternion.hpp>
#include <components/esm/vector3.hpp>
#include <components/misc/constants.hpp>
#include <components/misc/convert.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/resource/resourcesystem.hpp>
#include <components/resource/scenemanager.hpp>
#include <components/sceneutil/controller.hpp>
#include <components/sceneutil/lightmanager.hpp>
#include <components/sceneutil/nodecallback.hpp>
#include <components/sceneutil/visitor.hpp>
#include <components/settings/values.hpp>
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwworld/inventorystore.hpp"
#include "../mwworld/manualref.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwmechanics/combat.hpp"
#include "../mwmechanics/creaturestats.hpp"
#include "../mwmechanics/spellcasting.hpp"
#include "../mwmechanics/weapontype.hpp"
#include "../mwrender/animation.hpp"
#include "../mwrender/renderingmanager.hpp"
#include "../mwrender/util.hpp"
#include "../mwrender/vismask.hpp"
#include "../mwsound/sound.hpp"
#include "../mwphysics/physicssystem.hpp"
#include "../mwphysics/projectile.hpp"
namespace
{
ESM::EffectList getMagicBoltData(std::vector<ESM::RefId>& projectileIDs, std::set<ESM::RefId>& sounds, float& speed,
std::string& texture, std::string& sourceName, const ESM::RefId& id)
{
const MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore();
const ESM::EffectList* effects;
if (const ESM::Spell* spell = esmStore.get<ESM::Spell>().search(id)) // check if it's a spell
{
sourceName = spell->mName;
effects = &spell->mEffects;
}
else // check if it's an enchanted item
{
MWWorld::ManualRef ref(esmStore, id);
MWWorld::Ptr ptr = ref.getPtr();
const ESM::Enchantment* ench = esmStore.get<ESM::Enchantment>().find(ptr.getClass().getEnchantment(ptr));
sourceName = ptr.getClass().getName(ptr);
effects = &ench->mEffects;
}
int count = 0;
speed = 0.0f;
ESM::EffectList projectileEffects;
for (const ESM::IndexedENAMstruct& effect : effects->mList)
{
const ESM::MagicEffect* magicEffect
= MWBase::Environment::get().getESMStore()->get<ESM::MagicEffect>().find(effect.mData.mEffectID);
// Speed of multi-effect projectiles should be the average of the constituent effects,
// based on observation of the original engine.
speed += magicEffect->mData.mSpeed;
count++;
if (effect.mData.mRange != ESM::RT_Target)
continue;
if (magicEffect->mBolt.empty())
projectileIDs.emplace_back(ESM::RefId::stringRefId("VFX_DefaultBolt"));
else
projectileIDs.push_back(magicEffect->mBolt);
if (!magicEffect->mBoltSound.empty())
sounds.emplace(magicEffect->mBoltSound);
else
sounds.emplace(MWBase::Environment::get()
.getESMStore()
->get<ESM::Skill>()
.find(magicEffect->mData.mSchool)
->mSchool->mBoltSound);
projectileEffects.mList.push_back(effect);
}
if (count != 0)
speed /= count;
// the particle texture is only used if there is only one projectile
if (projectileEffects.mList.size() == 1)
{
const ESM::MagicEffect* magicEffect
= MWBase::Environment::get().getESMStore()->get<ESM::MagicEffect>().find(
effects->mList.begin()->mData.mEffectID);
texture = magicEffect->mParticle;
}
if (projectileEffects.mList.size()
> 1) // insert a VFX_Multiple projectile if there are multiple projectile effects
{
const ESM::RefId ID = ESM::RefId::stringRefId("VFX_Multiple" + std::to_string(effects->mList.size()));
std::vector<ESM::RefId>::iterator it;
it = projectileIDs.begin();
it = projectileIDs.insert(it, ID);
}
return projectileEffects;
}
osg::Vec4 getMagicBoltLightDiffuseColor(const ESM::EffectList& effects)
{
// Calculate combined light diffuse color from magical effects
osg::Vec4 lightDiffuseColor;
for (const ESM::IndexedENAMstruct& enam : effects.mList)
{
const ESM::MagicEffect* magicEffect
= MWBase::Environment::get().getESMStore()->get<ESM::MagicEffect>().find(enam.mData.mEffectID);
lightDiffuseColor += magicEffect->getColor();
}
int numberOfEffects = effects.mList.size();
lightDiffuseColor /= numberOfEffects;
return lightDiffuseColor;
}
}
namespace MWWorld
{
ProjectileManager::ProjectileManager(osg::Group* parent, Resource::ResourceSystem* resourceSystem,
MWRender::RenderingManager* rendering, MWPhysics::PhysicsSystem* physics)
: mParent(parent)
, mResourceSystem(resourceSystem)
, mRendering(rendering)
, mPhysics(physics)
, mCleanupTimer(0.0f)
{
}
/// Rotates an osg::PositionAttitudeTransform over time.
class RotateCallback : public SceneUtil::NodeCallback<RotateCallback, osg::PositionAttitudeTransform*>
{
public:
RotateCallback(const osg::Vec3f& axis = osg::Vec3f(0, -1, 0), float rotateSpeed = osg::PI * 2)
: mAxis(axis)
, mRotateSpeed(rotateSpeed)
{
}
void operator()(osg::PositionAttitudeTransform* node, osg::NodeVisitor* nv)
{
double time = nv->getFrameStamp()->getSimulationTime();
osg::Quat orient = osg::Quat(time * mRotateSpeed, mAxis);
node->setAttitude(orient);
traverse(node, nv);
}
private:
osg::Vec3f mAxis;
float mRotateSpeed;
};
void ProjectileManager::createModel(State& state, VFS::Path::NormalizedView model, const osg::Vec3f& pos,
const osg::Quat& orient, bool rotate, bool createLight, osg::Vec4 lightDiffuseColor, const std::string& texture)
{
state.mNode = new osg::PositionAttitudeTransform;
state.mNode->setNodeMask(MWRender::Mask_Effect);
state.mNode->setPosition(pos);
state.mNode->setAttitude(orient);
osg::Group* attachTo = state.mNode;
if (rotate)
{
osg::ref_ptr<osg::PositionAttitudeTransform> rotateNode(new osg::PositionAttitudeTransform);
rotateNode->addUpdateCallback(new RotateCallback());
state.mNode->addChild(rotateNode);
attachTo = rotateNode;
}
osg::ref_ptr<osg::Node> projectile = mResourceSystem->getSceneManager()->getInstance(model, attachTo);
if (state.mIdMagic.size() > 1)
{
for (size_t iter = 1; iter != state.mIdMagic.size(); ++iter)
{
std::ostringstream nodeName;
nodeName << "Dummy" << std::setw(2) << std::setfill('0') << iter;
const ESM::Weapon* weapon
= MWBase::Environment::get().getESMStore()->get<ESM::Weapon>().find(state.mIdMagic.at(iter));
std::string nameToFind = nodeName.str();
SceneUtil::FindByNameVisitor findVisitor(nameToFind);
attachTo->accept(findVisitor);
if (findVisitor.mFoundNode)
mResourceSystem->getSceneManager()->getInstance(
VFS::Path::toNormalized(Misc::ResourceHelpers::correctMeshPath(weapon->mModel)),
findVisitor.mFoundNode);
}
}
if (createLight)
{
osg::ref_ptr<osg::Light> projectileLight(new osg::Light);
projectileLight->setAmbient(osg::Vec4(1.0f, 1.0f, 1.0f, 1.0f));
projectileLight->setDiffuse(lightDiffuseColor);
projectileLight->setSpecular(osg::Vec4(0.0f, 0.0f, 0.0f, 0.0f));
projectileLight->setConstantAttenuation(0.f);
projectileLight->setLinearAttenuation(0.1f);
projectileLight->setQuadraticAttenuation(0.f);
projectileLight->setPosition(osg::Vec4(pos, 1.0));
SceneUtil::LightSource* projectileLightSource = new SceneUtil::LightSource;
projectileLightSource->setNodeMask(MWRender::Mask_Lighting);
projectileLightSource->setRadius(66.f);
state.mNode->addChild(projectileLightSource);
projectileLightSource->setLight(projectileLight);
}
state.mNode->addCullCallback(new SceneUtil::LightListCallback);
mParent->addChild(state.mNode);
state.mEffectAnimationTime = std::make_shared<MWRender::EffectAnimationTime>();
SceneUtil::AssignControllerSourcesVisitor assignVisitor(state.mEffectAnimationTime);
state.mNode->accept(assignVisitor);
MWRender::overrideFirstRootTexture(texture, mResourceSystem, *projectile);
}
void ProjectileManager::update(State& state, float duration)
{
state.mEffectAnimationTime->addTime(duration);
}
void ProjectileManager::launchMagicBolt(
const ESM::RefId& spellId, const Ptr& caster, const osg::Vec3f& fallbackDirection, ESM::RefNum item)
{
osg::Vec3f pos = caster.getRefData().getPosition().asVec3();
if (caster.getClass().isActor())
{
// Note: we ignore the collision box offset, this is required to make some flying creatures work as
// intended.
pos.z() += mPhysics->getRenderingHalfExtents(caster).z() * 2 * Constants::TorsoHeight;
}
if (MWBase::Environment::get().getWorld()->isUnderwater(
caster.getCell(), pos)) // Underwater casting not possible
return;
osg::Quat orient;
if (caster.getClass().isActor())
orient = osg::Quat(caster.getRefData().getPosition().rot[0], osg::Vec3f(-1, 0, 0))
* osg::Quat(caster.getRefData().getPosition().rot[2], osg::Vec3f(0, 0, -1));
else
orient.makeRotate(osg::Vec3f(0, 1, 0), osg::Vec3f(fallbackDirection));
MagicBoltState state;
state.mSpellId = spellId;
state.mCasterHandle = caster;
state.mItem = item;
if (caster.getClass().isActor())
state.mActorId = caster.getClass().getCreatureStats(caster).getActorId();
else
state.mActorId = -1;
std::string texture;
state.mEffects = getMagicBoltData(
state.mIdMagic, state.mSoundIds, state.mSpeed, texture, state.mSourceName, state.mSpellId);
// Non-projectile should have been removed by getMagicBoltData
if (state.mEffects.mList.empty())
return;
if (!caster.getClass().isActor() && fallbackDirection.length2() <= 0)
{
Log(Debug::Warning) << "Unable to launch magic bolt (direction to target is empty)";
return;
}
MWWorld::ManualRef ref(*MWBase::Environment::get().getESMStore(), state.mIdMagic.at(0));
MWWorld::Ptr ptr = ref.getPtr();
osg::Vec4 lightDiffuseColor = getMagicBoltLightDiffuseColor(state.mEffects);
VFS::Path::Normalized model = ptr.getClass().getCorrectedModel(ptr);
createModel(state, model, pos, orient, true, true, lightDiffuseColor, texture);
MWBase::SoundManager* sndMgr = MWBase::Environment::get().getSoundManager();
for (const auto& soundid : state.mSoundIds)
{
MWBase::Sound* sound
= sndMgr->playSound3D(pos, soundid, 1.0f, 1.0f, MWSound::Type::Sfx, MWSound::PlayMode::Loop);
if (sound)
state.mSounds.push_back(sound);
}
// in case there are multiple effects, the model is a dummy without geometry. Use the second effect for physics
// shape
if (state.mIdMagic.size() > 1)
{
model = Misc::ResourceHelpers::correctMeshPath(
MWBase::Environment::get().getESMStore()->get<ESM::Weapon>().find(state.mIdMagic[1])->mModel);
}
state.mProjectileId = mPhysics->addProjectile(caster, pos, model, true);
state.mToDelete = false;
mMagicBolts.push_back(state);
}
void ProjectileManager::launchProjectile(const Ptr& actor, const ConstPtr& projectile, const osg::Vec3f& pos,
const osg::Quat& orient, const Ptr& bow, float speed, float attackStrength)
{
ProjectileState state;
state.mActorId = actor.getClass().getCreatureStats(actor).getActorId();
state.mBowId = bow.getCellRef().getRefId();
state.mVelocity = orient * osg::Vec3f(0, 1, 0) * speed;
state.mIdArrow = projectile.getCellRef().getRefId();
state.mCasterHandle = actor;
state.mAttackStrength = attackStrength;
int type = projectile.get<ESM::Weapon>()->mBase->mData.mType;
state.mThrown = MWMechanics::getWeaponType(type)->mWeaponClass == ESM::WeaponType::Thrown;
MWWorld::ManualRef ref(*MWBase::Environment::get().getESMStore(), projectile.getCellRef().getRefId());
MWWorld::Ptr ptr = ref.getPtr();
const VFS::Path::Normalized model = ptr.getClass().getCorrectedModel(ptr);
createModel(state, model, pos, orient, false, false, osg::Vec4(0, 0, 0, 0));
if (!ptr.getClass().getEnchantment(ptr).empty())
SceneUtil::addEnchantedGlow(state.mNode, mResourceSystem, ptr.getClass().getEnchantmentColor(ptr));
state.mProjectileId = mPhysics->addProjectile(actor, pos, model, false);
state.mToDelete = false;
mProjectiles.push_back(state);
}
void ProjectileManager::updateCasters()
{
for (auto& state : mProjectiles)
mPhysics->setCaster(state.mProjectileId, state.getCaster());
for (auto& state : mMagicBolts)
{
// casters are identified by actor id in the savegame. objects doesn't have one so they can't be identified
// back.
// TODO: should object-type caster be restored from savegame?
if (state.mActorId == -1)
continue;
auto caster = state.getCaster();
if (caster.isEmpty())
{
Log(Debug::Error) << "Couldn't find caster with ID " << state.mActorId;
cleanupMagicBolt(state);
continue;
}
mPhysics->setCaster(state.mProjectileId, caster);
}
}
void ProjectileManager::update(float dt)
{
periodicCleanup(dt);
moveProjectiles(dt);
moveMagicBolts(dt);
}
void ProjectileManager::periodicCleanup(float dt)
{
mCleanupTimer -= dt;
if (mCleanupTimer <= 0.0f)
{
mCleanupTimer = 2.0f;
auto isCleanable = [](const ProjectileManager::State& state) -> bool {
const float farawayThreshold = 72000.0f;
osg::Vec3 playerPos = MWMechanics::getPlayer().getRefData().getPosition().asVec3();
return (state.mNode->getPosition() - playerPos).length2() >= farawayThreshold * farawayThreshold;
};
for (auto& projectileState : mProjectiles)
{
if (isCleanable(projectileState))
cleanupProjectile(projectileState);
}
for (auto& magicBoltState : mMagicBolts)
{
if (isCleanable(magicBoltState))
cleanupMagicBolt(magicBoltState);
}
}
}
void ProjectileManager::moveMagicBolts(float duration)
{
const bool normaliseRaceSpeed = Settings::game().mNormaliseRaceSpeed;
for (auto& magicBoltState : mMagicBolts)
{
if (magicBoltState.mToDelete)
continue;
auto* projectile = mPhysics->getProjectile(magicBoltState.mProjectileId);
if (!projectile->isActive())
continue;
// If the actor caster is gone, the magic bolt needs to be removed from the scene during the next frame.
MWWorld::Ptr caster = magicBoltState.getCaster();
if (!caster.isEmpty() && caster.getClass().isActor())
{
if (caster.getCellRef().getCount() <= 0 || caster.getClass().getCreatureStats(caster).isDead())
{
cleanupMagicBolt(magicBoltState);
continue;
}
}
const auto& store = *MWBase::Environment::get().getESMStore();
osg::Quat orient = magicBoltState.mNode->getAttitude();
static float fTargetSpellMaxSpeed
= store.get<ESM::GameSetting>().find("fTargetSpellMaxSpeed")->mValue.getFloat();
float speed = fTargetSpellMaxSpeed * magicBoltState.mSpeed;
if (!normaliseRaceSpeed && !caster.isEmpty() && caster.getClass().isNpc())
{
const auto npc = caster.get<ESM::NPC>()->mBase;
const auto race = store.get<ESM::Race>().find(npc->mRace);
speed *= npc->isMale() ? race->mData.mMaleWeight : race->mData.mFemaleWeight;
}
osg::Vec3f direction = orient * osg::Vec3f(0, 1, 0);
direction.normalize();
projectile->setVelocity(direction * speed);
update(magicBoltState, duration);
// For AI actors, get combat targets to use in the ray cast. Only those targets will return a positive hit
// result.
std::vector<MWWorld::Ptr> targetActors;
if (!caster.isEmpty() && caster.getClass().isActor() && caster != MWMechanics::getPlayer())
caster.getClass().getCreatureStats(caster).getAiSequence().getCombatTargets(targetActors);
projectile->setValidTargets(targetActors);
}
}
void ProjectileManager::moveProjectiles(float duration)
{
for (auto& projectileState : mProjectiles)
{
if (projectileState.mToDelete)
continue;
auto* projectile = mPhysics->getProjectile(projectileState.mProjectileId);
if (!projectile->isActive())
continue;
// gravity constant - must be way lower than the gravity affecting actors, since we're not
// simulating aerodynamics at all
projectileState.mVelocity
-= osg::Vec3f(0, 0, Constants::GravityConst * Constants::UnitsPerMeter * 0.1f) * duration;
projectile->setVelocity(projectileState.mVelocity);
// rotation does not work well for throwing projectiles - their roll angle will depend on shooting
// direction.
if (!projectileState.mThrown)
{
osg::Quat orient;
orient.makeRotate(osg::Vec3f(0, 1, 0), projectileState.mVelocity);
projectileState.mNode->setAttitude(orient);
}
update(projectileState, duration);
MWWorld::Ptr caster = projectileState.getCaster();
// For AI actors, get combat targets to use in the ray cast. Only those targets will return a positive hit
// result.
std::vector<MWWorld::Ptr> targetActors;
if (!caster.isEmpty() && caster.getClass().isActor() && caster != MWMechanics::getPlayer())
caster.getClass().getCreatureStats(caster).getAiSequence().getCombatTargets(targetActors);
projectile->setValidTargets(targetActors);
}
}
void ProjectileManager::processHits()
{
for (auto& projectileState : mProjectiles)
{
if (projectileState.mToDelete)
continue;
auto* projectile = mPhysics->getProjectile(projectileState.mProjectileId);
const auto pos = projectile->getSimulationPosition();
projectileState.mNode->setPosition(pos);
if (projectile->isActive())
continue;
const auto target = projectile->getTarget();
auto caster = projectileState.getCaster();
assert(target != caster);
if (caster.isEmpty())
caster = target;
// Try to get a Ptr to the bow that was used. It might no longer exist.
MWWorld::ManualRef projectileRef(*MWBase::Environment::get().getESMStore(), projectileState.mIdArrow);
MWWorld::Ptr bow = projectileRef.getPtr();
if (!caster.isEmpty() && projectileState.mIdArrow != projectileState.mBowId)
{
MWWorld::InventoryStore& inv = caster.getClass().getInventoryStore(caster);
MWWorld::ContainerStoreIterator invIt = inv.getSlot(MWWorld::InventoryStore::Slot_CarriedRight);
if (invIt != inv.end() && invIt->getCellRef().getRefId() == projectileState.mBowId)
bow = *invIt;
}
const auto hitPosition = Misc::Convert::toOsg(projectile->getHitPosition());
if (projectile->getHitWater())
mRendering->emitWaterRipple(hitPosition);
MWMechanics::projectileHit(
caster, target, bow, projectileRef.getPtr(), hitPosition, projectileState.mAttackStrength);
projectileState.mToDelete = true;
}
const MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore();
for (auto& magicBoltState : mMagicBolts)
{
if (magicBoltState.mToDelete)
continue;
auto* projectile = mPhysics->getProjectile(magicBoltState.mProjectileId);
const auto pos = projectile->getSimulationPosition();
magicBoltState.mNode->setPosition(pos);
for (const auto& sound : magicBoltState.mSounds)
sound->setPosition(pos);
if (projectile->isActive())
continue;
const auto target = projectile->getTarget();
const auto caster = magicBoltState.getCaster();
assert(target != caster);
MWMechanics::CastSpell cast(caster, target);
cast.mHitPosition = Misc::Convert::toOsg(projectile->getHitPosition());
cast.mId = magicBoltState.mSpellId;
cast.mSourceName = magicBoltState.mSourceName;
cast.mItem = magicBoltState.mItem;
// Grab original effect list so the indices are correct
const ESM::EffectList* effects;
if (const ESM::Spell* spell = esmStore.get<ESM::Spell>().search(magicBoltState.mSpellId))
effects = &spell->mEffects;
else
{
MWWorld::ManualRef ref(esmStore, magicBoltState.mSpellId);
const MWWorld::Ptr& ptr = ref.getPtr();
effects = &esmStore.get<ESM::Enchantment>().find(ptr.getClass().getEnchantment(ptr))->mEffects;
}
cast.inflict(target, *effects, ESM::RT_Target);
magicBoltState.mToDelete = true;
}
for (auto& projectileState : mProjectiles)
{
if (projectileState.mToDelete)
cleanupProjectile(projectileState);
}
for (auto& magicBoltState : mMagicBolts)
{
if (magicBoltState.mToDelete)
cleanupMagicBolt(magicBoltState);
}
mProjectiles.erase(std::remove_if(mProjectiles.begin(), mProjectiles.end(),
[](const State& state) { return state.mToDelete; }),
mProjectiles.end());
mMagicBolts.erase(
std::remove_if(mMagicBolts.begin(), mMagicBolts.end(), [](const State& state) { return state.mToDelete; }),
mMagicBolts.end());
}
void ProjectileManager::cleanupProjectile(ProjectileManager::ProjectileState& state)
{
mParent->removeChild(state.mNode);
mPhysics->removeProjectile(state.mProjectileId);
state.mToDelete = true;
}
void ProjectileManager::cleanupMagicBolt(ProjectileManager::MagicBoltState& state)
{
mParent->removeChild(state.mNode);
mPhysics->removeProjectile(state.mProjectileId);
state.mToDelete = true;
for (size_t soundIter = 0; soundIter != state.mSounds.size(); soundIter++)
{
MWBase::Environment::get().getSoundManager()->stopSound(state.mSounds.at(soundIter));
}
}
void ProjectileManager::clear()
{
for (auto& mProjectile : mProjectiles)
cleanupProjectile(mProjectile);
mProjectiles.clear();
for (auto& mMagicBolt : mMagicBolts)
cleanupMagicBolt(mMagicBolt);
mMagicBolts.clear();
}
void ProjectileManager::write(ESM::ESMWriter& writer, Loading::Listener& progress) const
{
for (std::vector<ProjectileState>::const_iterator it = mProjectiles.begin(); it != mProjectiles.end(); ++it)
{
writer.startRecord(ESM::REC_PROJ);
ESM::ProjectileState state;
state.mId = it->mIdArrow;
state.mPosition = ESM::Vector3(osg::Vec3f(it->mNode->getPosition()));
state.mOrientation = ESM::Quaternion(osg::Quat(it->mNode->getAttitude()));
state.mActorId = it->mActorId;
state.mBowId = it->mBowId;
state.mVelocity = it->mVelocity;
state.mAttackStrength = it->mAttackStrength;
state.save(writer);
writer.endRecord(ESM::REC_PROJ);
}
for (std::vector<MagicBoltState>::const_iterator it = mMagicBolts.begin(); it != mMagicBolts.end(); ++it)
{
writer.startRecord(ESM::REC_MPRJ);
ESM::MagicBoltState state;
state.mId = it->mIdMagic.at(0);
state.mPosition = ESM::Vector3(osg::Vec3f(it->mNode->getPosition()));
state.mOrientation = ESM::Quaternion(osg::Quat(it->mNode->getAttitude()));
state.mActorId = it->mActorId;
state.mItem = it->mItem;
state.mSpellId = it->mSpellId;
state.mSpeed = it->mSpeed;
state.save(writer);
writer.endRecord(ESM::REC_MPRJ);
}
}
bool ProjectileManager::readRecord(ESM::ESMReader& reader, uint32_t type)
{
if (type == ESM::REC_PROJ)
{
ESM::ProjectileState esm;
esm.load(reader);
ProjectileState state;
state.mActorId = esm.mActorId;
state.mBowId = esm.mBowId;
state.mVelocity = esm.mVelocity;
state.mIdArrow = esm.mId;
state.mAttackStrength = esm.mAttackStrength;
state.mToDelete = false;
VFS::Path::Normalized model;
try
{
MWWorld::ManualRef ref(*MWBase::Environment::get().getESMStore(), esm.mId);
MWWorld::Ptr ptr = ref.getPtr();
model = ptr.getClass().getCorrectedModel(ptr);
int weaponType = ptr.get<ESM::Weapon>()->mBase->mData.mType;
state.mThrown = MWMechanics::getWeaponType(weaponType)->mWeaponClass == ESM::WeaponType::Thrown;
state.mProjectileId
= mPhysics->addProjectile(state.getCaster(), osg::Vec3f(esm.mPosition), model, false);
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to add projectile for " << esm.mId
<< " while reading projectile record: " << e.what();
return true;
}
createModel(state, model, osg::Vec3f(esm.mPosition), osg::Quat(esm.mOrientation), false, false,
osg::Vec4(0, 0, 0, 0));
mProjectiles.push_back(state);
return true;
}
if (type == ESM::REC_MPRJ)
{
ESM::MagicBoltState esm;
esm.load(reader);
MagicBoltState state;
state.mIdMagic.push_back(esm.mId);
state.mSpellId = esm.mSpellId;
state.mActorId = esm.mActorId;
state.mToDelete = false;
state.mItem = esm.mItem;
std::string texture;
try
{
state.mEffects = getMagicBoltData(
state.mIdMagic, state.mSoundIds, state.mSpeed, texture, state.mSourceName, state.mSpellId);
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to recreate magic projectile for " << esm.mId << " and spell "
<< state.mSpellId << " while reading projectile record: " << e.what();
return true;
}
state.mSpeed = esm.mSpeed; // speed is derived from non-projectile effects as well as
// projectile effects, so we can't calculate it from the save
// file's effect list, which is already trimmed of non-projectile
// effects. We need to use the stored value.
VFS::Path::Normalized model;
try
{
MWWorld::ManualRef ref(*MWBase::Environment::get().getESMStore(), state.mIdMagic.at(0));
MWWorld::Ptr ptr = ref.getPtr();
model = ptr.getClass().getCorrectedModel(ptr);
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to get model for " << state.mIdMagic.at(0)
<< " while reading projectile record: " << e.what();
return true;
}
osg::Vec4 lightDiffuseColor = getMagicBoltLightDiffuseColor(state.mEffects);
createModel(state, model, osg::Vec3f(esm.mPosition), osg::Quat(esm.mOrientation), true, true,
lightDiffuseColor, texture);
state.mProjectileId = mPhysics->addProjectile(state.getCaster(), osg::Vec3f(esm.mPosition), model, true);
MWBase::SoundManager* sndMgr = MWBase::Environment::get().getSoundManager();
for (const auto& soundid : state.mSoundIds)
{
MWBase::Sound* sound = sndMgr->playSound3D(
esm.mPosition, soundid, 1.0f, 1.0f, MWSound::Type::Sfx, MWSound::PlayMode::Loop);
if (sound)
state.mSounds.push_back(sound);
}
mMagicBolts.push_back(state);
return true;
}
return false;
}
int ProjectileManager::countSavedGameRecords() const
{
return mMagicBolts.size() + mProjectiles.size();
}
MWWorld::Ptr ProjectileManager::State::getCaster()
{
if (!mCasterHandle.isEmpty())
return mCasterHandle;
return MWBase::Environment::get().getWorld()->searchPtrViaActorId(mActorId);
}
}
| 31,705
|
C++
|
.cpp
| 667
| 36.07946
| 120
| 0.608025
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,269
|
actionread.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionread.cpp
|
#include "actionread.hpp"
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loadskil.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwmechanics/npcstats.hpp"
#include "class.hpp"
#include "esmstore.hpp"
namespace MWWorld
{
ActionRead::ActionRead(const MWWorld::Ptr& object)
: Action(false, object)
{
}
void ActionRead::executeImp(const MWWorld::Ptr& actor)
{
const MWWorld::Ptr player = MWMechanics::getPlayer();
if (actor != player && getTarget().getContainerStore() != nullptr)
return;
// Ensure we're not in combat
if (MWMechanics::isPlayerInCombat()
// Reading in combat is still allowed if the scroll/book is not in the player inventory yet
// (since otherwise, there would be no way to pick it up)
&& getTarget().getContainerStore() == &player.getClass().getContainerStore(player))
{
MWBase::Environment::get().getWindowManager()->messageBox("#{sInventoryMessage4}");
return;
}
LiveCellRef<ESM::Book>* ref = getTarget().get<ESM::Book>();
if (ref->mBase->mData.mIsScroll)
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Scroll, getTarget());
else
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Book, getTarget());
MWMechanics::NpcStats& npcStats = player.getClass().getNpcStats(player);
// Skill gain from books
ESM::RefId skill = ESM::Skill::indexToRefId(ref->mBase->mData.mSkillId);
if (!skill.empty() && !npcStats.hasBeenUsed(ref->mBase->mId))
{
MWBase::Environment::get().getLuaManager()->skillLevelUp(player, skill, "book");
npcStats.flagAsUsed(ref->mBase->mId);
}
}
}
| 1,985
|
C++
|
.cpp
| 46
| 35.978261
| 103
| 0.654904
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,270
|
actiondoor.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actiondoor.cpp
|
#include "actiondoor.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
namespace MWWorld
{
ActionDoor::ActionDoor(const MWWorld::Ptr& object)
: Action(false, object)
{
}
void ActionDoor::executeImp(const MWWorld::Ptr& actor)
{
MWBase::Environment::get().getWorld()->activateDoor(getTarget());
}
}
| 363
|
C++
|
.cpp
| 14
| 21.857143
| 73
| 0.679191
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| true
| false
| true
| true
| true
| false
|
35,271
|
actiontake.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actiontake.cpp
|
#include "actiontake.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwgui/inventorywindow.hpp"
#include "class.hpp"
#include "containerstore.hpp"
namespace MWWorld
{
ActionTake::ActionTake(const MWWorld::Ptr& object)
: Action(true, object)
{
}
void ActionTake::executeImp(const Ptr& actor)
{
// When in GUI mode, we should use drag and drop
if (actor == MWBase::Environment::get().getWorld()->getPlayerPtr())
{
MWGui::GuiMode mode = MWBase::Environment::get().getWindowManager()->getMode();
if (mode == MWGui::GM_Inventory || mode == MWGui::GM_Container)
{
MWBase::Environment::get().getWindowManager()->getInventoryWindow()->pickUpObject(getTarget());
return;
}
}
int count = getTarget().getCellRef().getCount();
if (getTarget().getClass().isGold(getTarget()))
count *= getTarget().getClass().getValue(getTarget());
MWBase::Environment::get().getMechanicsManager()->itemTaken(actor, getTarget(), MWWorld::Ptr(), count);
MWWorld::Ptr newitem = *actor.getClass().getContainerStore(actor).add(getTarget(), count);
MWBase::Environment::get().getWorld()->deleteObject(getTarget());
setTarget(newitem);
}
}
| 1,433
|
C++
|
.cpp
| 35
| 33.914286
| 111
| 0.640546
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,272
|
actionequip.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionequip.cpp
|
#include "actionequip.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "class.hpp"
#include "inventorystore.hpp"
namespace MWWorld
{
ActionEquip::ActionEquip(const MWWorld::Ptr& object, bool force)
: Action(false, object)
, mForce(force)
{
}
void ActionEquip::executeImp(const Ptr& actor)
{
MWWorld::Ptr object = getTarget();
MWWorld::InventoryStore& invStore = actor.getClass().getInventoryStore(actor);
if (object.getClass().hasItemHealth(object) && object.getCellRef().getCharge() == 0)
{
if (actor == MWMechanics::getPlayer())
MWBase::Environment::get().getWindowManager()->messageBox("#{sInventoryMessage1}");
return;
}
if (!mForce)
{
auto result = object.getClass().canBeEquipped(object, actor);
// display error message if the player tried to equip something
if (!result.second.empty() && actor == MWMechanics::getPlayer())
MWBase::Environment::get().getWindowManager()->messageBox(result.second);
switch (result.first)
{
case 0:
return;
default:
break;
}
}
// slots that this item can be equipped in
std::pair<std::vector<int>, bool> slots_ = getTarget().getClass().getEquipmentSlots(getTarget());
if (slots_.first.empty())
return;
// retrieve ContainerStoreIterator to the item
MWWorld::ContainerStoreIterator it = invStore.begin();
for (; it != invStore.end(); ++it)
{
if (*it == object)
{
break;
}
}
if (it == invStore.end())
throw std::runtime_error("ActionEquip can't find item " + object.getCellRef().getRefId().toDebugString());
// equip the item in the first free slot
std::vector<int>::const_iterator slot = slots_.first.begin();
for (; slot != slots_.first.end(); ++slot)
{
// if the item is equipped already, nothing to do
if (invStore.getSlot(*slot) == it)
return;
if (invStore.getSlot(*slot) == invStore.end())
{
// slot is not occupied
invStore.equip(*slot, it);
break;
}
}
// all slots are occupied -> cycle
// move all slots one towards begin(), then equip the item in the slot that is now free
if (slot == slots_.first.end())
{
ContainerStoreIterator enchItem = invStore.getSelectedEnchantItem();
bool reEquip = false;
for (slot = slots_.first.begin(); slot != slots_.first.end(); ++slot)
{
invStore.unequipSlot(*slot, false);
if (slot + 1 != slots_.first.end())
{
invStore.equip(*slot, invStore.getSlot(*(slot + 1)));
}
else
{
invStore.equip(*slot, it);
}
// Fix for issue of selected enchated item getting remmoved on cycle
if (invStore.getSlot(*slot) == enchItem)
{
reEquip = true;
}
}
if (reEquip)
{
invStore.setSelectedEnchantItem(enchItem);
}
}
}
}
| 3,582
|
C++
|
.cpp
| 96
| 25.677083
| 118
| 0.526665
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,273
|
scene.cpp
|
OpenMW_openmw/apps/openmw/mwworld/scene.cpp
|
#include "scene.hpp"
#include <atomic>
#include <chrono>
#include <limits>
#include <BulletCollision/CollisionDispatch/btCollisionObject.h>
#include <components/debug/debuglog.hpp>
#include <components/detournavigator/agentbounds.hpp>
#include <components/detournavigator/debug.hpp>
#include <components/detournavigator/heightfieldshape.hpp>
#include <components/detournavigator/navigator.hpp>
#include <components/detournavigator/updateguard.hpp>
#include <components/esm/esmterrain.hpp>
#include <components/esm/records.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/misc/convert.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/resource/resourcesystem.hpp>
#include <components/resource/scenemanager.hpp>
#include <components/sceneutil/positionattitudetransform.hpp>
#include <components/settings/values.hpp>
#include <components/vfs/pathutil.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwrender/landmanager.hpp"
#include "../mwrender/postprocessor.hpp"
#include "../mwrender/renderingmanager.hpp"
#include "../mwphysics/actor.hpp"
#include "../mwphysics/heightfield.hpp"
#include "../mwphysics/object.hpp"
#include "../mwphysics/physicssystem.hpp"
#include "../mwworld/actionteleport.hpp"
#include "cellpreloader.hpp"
#include "cellstore.hpp"
#include "cellvisitors.hpp"
#include "class.hpp"
#include "esmstore.hpp"
#include "localscripts.hpp"
#include "player.hpp"
#include "worldimp.hpp"
namespace
{
using MWWorld::RotationOrder;
osg::Quat makeActorOsgQuat(const ESM::Position& position)
{
return osg::Quat(position.rot[2], osg::Vec3(0, 0, -1));
}
osg::Quat makeInversedOrderObjectOsgQuat(const ESM::Position& position)
{
const float xr = position.rot[0];
const float yr = position.rot[1];
const float zr = position.rot[2];
return osg::Quat(xr, osg::Vec3(-1, 0, 0)) * osg::Quat(yr, osg::Vec3(0, -1, 0))
* osg::Quat(zr, osg::Vec3(0, 0, -1));
}
osg::Quat makeInverseNodeRotation(const MWWorld::Ptr& ptr)
{
const auto& pos = ptr.getRefData().getPosition();
return ptr.getClass().isActor() ? makeActorOsgQuat(pos) : makeInversedOrderObjectOsgQuat(pos);
}
osg::Quat makeDirectNodeRotation(const MWWorld::Ptr& ptr)
{
const auto& pos = ptr.getRefData().getPosition();
return ptr.getClass().isActor() ? makeActorOsgQuat(pos) : Misc::Convert::makeOsgQuat(pos);
}
osg::Quat makeNodeRotation(const MWWorld::Ptr& ptr, RotationOrder order)
{
if (order == RotationOrder::inverse)
return makeInverseNodeRotation(ptr);
return makeDirectNodeRotation(ptr);
}
void setNodeRotation(const MWWorld::Ptr& ptr, MWRender::RenderingManager& rendering, const osg::Quat& rotation)
{
if (ptr.getRefData().getBaseNode())
rendering.rotateObject(ptr, rotation);
}
std::string getModel(const MWWorld::Ptr& ptr)
{
if (Misc::ResourceHelpers::isHiddenMarker(ptr.getCellRef().getRefId()))
return {};
return ptr.getClass().getCorrectedModel(ptr);
}
// Null node meant to distinguish objects that aren't in the scene from paged objects
// TODO: find a more clever way to make paging exclusion more reliable?
static osg::ref_ptr<SceneUtil::PositionAttitudeTransform> pagedNode = new SceneUtil::PositionAttitudeTransform;
void addObject(const MWWorld::Ptr& ptr, const MWWorld::World& world, const std::vector<ESM::RefNum>& pagedRefs,
MWPhysics::PhysicsSystem& physics, MWRender::RenderingManager& rendering)
{
if (ptr.getRefData().getBaseNode() || physics.getActor(ptr))
{
Log(Debug::Warning) << "Warning: Tried to add " << ptr.getCellRef().getRefId() << " to the scene twice";
return;
}
std::string model = getModel(ptr);
const auto rotation = makeDirectNodeRotation(ptr);
ESM::RefNum refnum = ptr.getCellRef().getRefNum();
if (!refnum.hasContentFile() || !std::binary_search(pagedRefs.begin(), pagedRefs.end(), refnum))
ptr.getClass().insertObjectRendering(ptr, model, rendering);
else
ptr.getRefData().setBaseNode(pagedNode);
setNodeRotation(ptr, rendering, rotation);
if (ptr.getClass().useAnim())
MWBase::Environment::get().getMechanicsManager()->add(ptr);
if (ptr.getClass().isActor())
rendering.addWaterRippleEmitter(ptr);
// Restore effect particles
world.applyLoopingParticles(ptr);
if (!model.empty())
ptr.getClass().insertObject(ptr, model, rotation, physics);
MWBase::Environment::get().getLuaManager()->objectAddedToScene(ptr);
}
void addObject(const MWWorld::Ptr& ptr, const MWWorld::World& world, const MWPhysics::PhysicsSystem& physics,
float& lowestPoint, bool isInterior, DetourNavigator::Navigator& navigator,
const DetourNavigator::UpdateGuard* navigatorUpdateGuard = nullptr)
{
if (const auto object = physics.getObject(ptr))
{
// Find the lowest point of this collision object in world space from its AABB if interior
// this point is used to determine the infinite fall cutoff from lowest point in the cell
if (isInterior)
{
btVector3 aabbMin;
btVector3 aabbMax;
const auto transform = object->getTransform();
object->getShapeInstance()->mCollisionShape->getAabb(transform, aabbMin, aabbMax);
lowestPoint = std::min(lowestPoint, static_cast<float>(aabbMin.z()));
}
const DetourNavigator::ObjectTransform objectTransform{ ptr.getRefData().getPosition(),
ptr.getCellRef().getScale() };
if (ptr.getClass().isDoor() && !ptr.getCellRef().getTeleport())
{
btVector3 aabbMin;
btVector3 aabbMax;
object->getShapeInstance()->mCollisionShape->getAabb(btTransform::getIdentity(), aabbMin, aabbMax);
const auto center = (aabbMax + aabbMin) * 0.5f;
const auto distanceFromDoor = world.getMaxActivationDistance() * 0.5f;
const auto toPoint = aabbMax.x() - aabbMin.x() < aabbMax.y() - aabbMin.y()
? btVector3(distanceFromDoor, 0, 0)
: btVector3(0, distanceFromDoor, 0);
const auto transform = object->getTransform();
const btTransform closedDoorTransform(
Misc::Convert::makeBulletQuaternion(ptr.getCellRef().getPosition()), transform.getOrigin());
const auto start = Misc::Convert::toOsg(closedDoorTransform(center + toPoint));
const auto startPoint = physics.castRay(start, start - osg::Vec3f(0, 0, 1000), { ptr }, {},
MWPhysics::CollisionType_World | MWPhysics::CollisionType_HeightMap
| MWPhysics::CollisionType_Water);
const auto connectionStart = startPoint.mHit ? startPoint.mHitPos : start;
const auto end = Misc::Convert::toOsg(closedDoorTransform(center - toPoint));
const auto endPoint = physics.castRay(end, end - osg::Vec3f(0, 0, 1000), { ptr }, {},
MWPhysics::CollisionType_World | MWPhysics::CollisionType_HeightMap
| MWPhysics::CollisionType_Water);
const auto connectionEnd = endPoint.mHit ? endPoint.mHitPos : end;
navigator.addObject(DetourNavigator::ObjectId(object),
DetourNavigator::DoorShapes(
object->getShapeInstance(), objectTransform, connectionStart, connectionEnd),
transform, navigatorUpdateGuard);
}
else if (object->getShapeInstance()->mVisualCollisionType == Resource::VisualCollisionType::None)
{
navigator.addObject(DetourNavigator::ObjectId(object),
DetourNavigator::ObjectShapes(object->getShapeInstance(), objectTransform), object->getTransform(),
navigatorUpdateGuard);
}
}
else if (physics.getActor(ptr))
{
const DetourNavigator::AgentBounds agentBounds = world.getPathfindingAgentBounds(ptr);
if (!navigator.addAgent(agentBounds))
Log(Debug::Warning) << "Agent bounds are not supported by navigator for " << ptr.toString() << ": "
<< agentBounds;
}
}
struct InsertVisitor
{
MWWorld::CellStore& mCell;
Loading::Listener* mLoadingListener;
std::vector<MWWorld::Ptr> mToInsert;
InsertVisitor(MWWorld::CellStore& cell, Loading::Listener* loadingListener);
bool operator()(const MWWorld::Ptr& ptr);
template <class AddObject>
void insert(AddObject&& addObject);
};
InsertVisitor::InsertVisitor(MWWorld::CellStore& cell, Loading::Listener* loadingListener)
: mCell(cell)
, mLoadingListener(loadingListener)
{
}
bool InsertVisitor::operator()(const MWWorld::Ptr& ptr)
{
// do not insert directly as we can't modify the cell from within the visitation
// CreatureLevList::insertObjectRendering may spawn a new creature
mToInsert.push_back(ptr);
return true;
}
template <class AddObject>
void InsertVisitor::insert(AddObject&& addObject)
{
for (MWWorld::Ptr& ptr : mToInsert)
{
if (!ptr.mRef->isDeleted() && ptr.getRefData().isEnabled())
{
try
{
addObject(ptr);
}
catch (const std::exception& e)
{
Log(Debug::Error) << "failed to render '" << ptr.getCellRef().getRefId() << "': " << e.what();
}
}
if (mLoadingListener != nullptr)
mLoadingListener->increaseProgress(1);
}
}
int getCellPositionDistanceToOrigin(const std::pair<int, int>& cellPosition)
{
return std::abs(cellPosition.first) + std::abs(cellPosition.second);
}
bool isCellInCollection(ESM::ExteriorCellLocation cellIndex, MWWorld::Scene::CellStoreCollection& collection)
{
for (auto* cell : collection)
{
assert(cell->getCell()->isExterior());
if (cellIndex == cell->getCell()->getExteriorCellLocation())
return true;
}
return false;
}
bool removeFromSorted(ESM::RefNum refNum, std::vector<ESM::RefNum>& pagedRefs)
{
const auto it = std::lower_bound(pagedRefs.begin(), pagedRefs.end(), refNum);
if (it == pagedRefs.end() || *it != refNum)
return false;
pagedRefs.erase(it);
return true;
}
template <class Function>
void iterateOverCellsAround(int cellX, int cellY, int range, Function&& f)
{
for (int x = cellX - range, lastX = cellX + range; x <= lastX; ++x)
for (int y = cellY - range, lastY = cellY + range; y <= lastY; ++y)
f(x, y);
}
void sortCellsToLoad(int centerX, int centerY, std::vector<std::pair<int, int>>& cells)
{
const auto getDistanceToPlayerCell = [&](const std::pair<int, int>& cellPosition) {
return std::abs(cellPosition.first - centerX) + std::abs(cellPosition.second - centerY);
};
const auto getCellPositionPriority = [&](const std::pair<int, int>& cellPosition) {
return std::make_pair(getDistanceToPlayerCell(cellPosition), getCellPositionDistanceToOrigin(cellPosition));
};
std::sort(cells.begin(), cells.end(), [&](const std::pair<int, int>& lhs, const std::pair<int, int>& rhs) {
return getCellPositionPriority(lhs) < getCellPositionPriority(rhs);
});
}
}
namespace MWWorld
{
void Scene::removeFromPagedRefs(const Ptr& ptr)
{
ESM::RefNum refnum = ptr.getCellRef().getRefNum();
if (refnum.hasContentFile() && removeFromSorted(refnum, mPagedRefs))
{
if (!ptr.getRefData().getBaseNode())
return;
ptr.getClass().insertObjectRendering(ptr, getModel(ptr), mRendering);
setNodeRotation(ptr, mRendering, makeNodeRotation(ptr, RotationOrder::direct));
reloadTerrain();
}
}
bool Scene::isPagedRef(const Ptr& ptr) const
{
return ptr.getRefData().getBaseNode() == pagedNode.get();
}
void Scene::updateObjectRotation(const Ptr& ptr, RotationOrder order)
{
const auto rot = makeNodeRotation(ptr, order);
setNodeRotation(ptr, mRendering, rot);
mPhysics->updateRotation(ptr, rot);
}
void Scene::updateObjectScale(const Ptr& ptr)
{
float scale = ptr.getCellRef().getScale();
osg::Vec3f scaleVec(scale, scale, scale);
ptr.getClass().adjustScale(ptr, scaleVec, true);
mRendering.scaleObject(ptr, scaleVec);
mPhysics->updateScale(ptr);
}
void Scene::update(float duration)
{
if (mChangeCellGridRequest.has_value())
{
changeCellGrid(mChangeCellGridRequest->mPosition, mChangeCellGridRequest->mCellIndex,
mChangeCellGridRequest->mChangeEvent);
mChangeCellGridRequest.reset();
}
mPreloader->updateCache(mRendering.getReferenceTime());
preloadCells(duration);
}
void Scene::unloadCell(CellStore* cell, const DetourNavigator::UpdateGuard* navigatorUpdateGuard)
{
if (mActiveCells.find(cell) == mActiveCells.end())
return;
Log(Debug::Info) << "Unloading cell " << cell->getCell()->getDescription();
ListAndResetObjectsVisitor visitor;
cell->forEach(visitor);
for (const auto& ptr : visitor.mObjects)
{
if (const auto object = mPhysics->getObject(ptr))
{
if (object->getShapeInstance()->mVisualCollisionType == Resource::VisualCollisionType::None)
mNavigator.removeObject(DetourNavigator::ObjectId(object), navigatorUpdateGuard);
mPhysics->remove(ptr);
ptr.mRef->mData.mPhysicsPostponed = false;
}
else if (mPhysics->getActor(ptr))
{
mNavigator.removeAgent(mWorld.getPathfindingAgentBounds(ptr));
mRendering.removeActorPath(ptr);
mPhysics->remove(ptr);
}
MWBase::Environment::get().getLuaManager()->objectRemovedFromScene(ptr);
}
const auto cellX = cell->getCell()->getGridX();
const auto cellY = cell->getCell()->getGridY();
if (cell->getCell()->isExterior())
{
mNavigator.removeHeightfield(osg::Vec2i(cellX, cellY), navigatorUpdateGuard);
mPhysics->removeHeightField(cellX, cellY);
}
if (cell->getCell()->hasWater())
mNavigator.removeWater(osg::Vec2i(cellX, cellY), navigatorUpdateGuard);
ESM::visit(ESM::VisitOverload{
[&](const ESM::Cell& cell) {
if (const auto pathgrid = mWorld.getStore().get<ESM::Pathgrid>().search(cell))
mNavigator.removePathgrid(*pathgrid);
},
[&](const ESM4::Cell& cell) {},
},
*cell->getCell());
MWBase::Environment::get().getMechanicsManager()->drop(cell);
mRendering.removeCell(cell);
MWBase::Environment::get().getWindowManager()->removeCell(cell);
mWorld.getLocalScripts().clearCell(cell);
MWBase::Environment::get().getSoundManager()->stopSound(cell);
mActiveCells.erase(cell);
// Clean up any effects that may have been spawned while unloading all cells
if (mActiveCells.empty())
mRendering.notifyWorldSpaceChanged();
}
void Scene::loadCell(CellStore& cell, Loading::Listener* loadingListener, bool respawn, const osg::Vec3f& position,
const DetourNavigator::UpdateGuard* navigatorUpdateGuard)
{
using DetourNavigator::HeightfieldShape;
assert(mActiveCells.find(&cell) == mActiveCells.end());
mActiveCells.insert(&cell);
Log(Debug::Info) << "Loading cell " << cell.getCell()->getDescription();
const int cellX = cell.getCell()->getGridX();
const int cellY = cell.getCell()->getGridY();
const MWWorld::Cell& cellVariant = *cell.getCell();
ESM::RefId worldspace = cellVariant.getWorldSpace();
ESM::ExteriorCellLocation cellIndex(cellX, cellY, worldspace);
if (cellVariant.isExterior())
{
osg::ref_ptr<const ESMTerrain::LandObject> land = mRendering.getLandManager()->getLand(cellIndex);
const ESM::LandData* data = land ? land->getData(ESM::Land::DATA_VHGT) : nullptr;
const int verts = ESM::getLandSize(worldspace);
const int worldsize = ESM::getCellSize(worldspace);
if (data)
{
mPhysics->addHeightField(data->getHeights().data(), cellX, cellY, worldsize, verts,
data->getMinHeight(), data->getMaxHeight(), land.get());
}
else if (!ESM::isEsm4Ext(worldspace))
{
static const std::vector<float> defaultHeight(verts * verts, ESM::Land::DEFAULT_HEIGHT);
mPhysics->addHeightField(defaultHeight.data(), cellX, cellY, worldsize, verts,
ESM::Land::DEFAULT_HEIGHT, ESM::Land::DEFAULT_HEIGHT, land.get());
}
if (const auto heightField = mPhysics->getHeightField(cellX, cellY))
{
const osg::Vec2i cellPosition(cellX, cellY);
const btVector3& origin = heightField->getCollisionObject()->getWorldTransform().getOrigin();
const osg::Vec3f shift(origin.x(), origin.y(), origin.z());
const HeightfieldShape shape = [&]() -> HeightfieldShape {
if (data == nullptr)
{
return DetourNavigator::HeightfieldPlane{ static_cast<float>(ESM::Land::DEFAULT_HEIGHT) };
}
else
{
DetourNavigator::HeightfieldSurface heights;
heights.mHeights = data->getHeights().data();
heights.mSize = static_cast<std::size_t>(data->getLandSize());
heights.mMinHeight = data->getMinHeight();
heights.mMaxHeight = data->getMaxHeight();
return heights;
}
}();
mNavigator.addHeightfield(cellPosition, worldsize, shape, navigatorUpdateGuard);
}
}
ESM::visit(ESM::VisitOverload{
[&](const ESM::Cell& cell) {
if (const auto pathgrid = mWorld.getStore().get<ESM::Pathgrid>().search(cell))
mNavigator.addPathgrid(cell, *pathgrid);
},
[&](const ESM4::Cell& cell) {},
},
*cell.getCell());
// register local scripts
// do this before insertCell, to make sure we don't add scripts from levelled creature spawning twice
mWorld.getLocalScripts().addCell(&cell);
if (respawn)
cell.respawn();
insertCell(cell, loadingListener, navigatorUpdateGuard);
mRendering.addCell(&cell);
MWBase::Environment::get().getWindowManager()->addCell(&cell);
bool waterEnabled = cellVariant.hasWater() || cell.isExterior();
float waterLevel = cell.getWaterLevel();
mRendering.setWaterEnabled(waterEnabled);
if (waterEnabled)
{
mPhysics->enableWater(waterLevel);
mRendering.setWaterHeight(waterLevel);
if (cellVariant.isExterior())
{
if (const auto heightField = mPhysics->getHeightField(cellX, cellY))
mNavigator.addWater(
osg::Vec2i(cellX, cellY), ESM::Land::REAL_SIZE, waterLevel, navigatorUpdateGuard);
}
else
{
mNavigator.addWater(
osg::Vec2i(cellX, cellY), std::numeric_limits<int>::max(), waterLevel, navigatorUpdateGuard);
}
}
else
mPhysics->disableWater();
if (!cell.isExterior() && !cellVariant.isQuasiExterior())
mRendering.configureAmbient(cellVariant);
mPreloader->notifyLoaded(&cell);
}
void Scene::clear()
{
auto navigatorUpdateGuard = mNavigator.makeUpdateGuard();
for (auto iter = mActiveCells.begin(); iter != mActiveCells.end();)
{
auto* cell = *iter++;
unloadCell(cell, navigatorUpdateGuard.get());
}
navigatorUpdateGuard.reset();
assert(mActiveCells.empty());
mCurrentCell = nullptr;
mLowestPoint = std::numeric_limits<float>::max();
mPreloader->clear();
}
osg::Vec4i Scene::gridCenterToBounds(const osg::Vec2i& centerCell) const
{
return osg::Vec4i(centerCell.x() - mHalfGridSize, centerCell.y() - mHalfGridSize,
centerCell.x() + mHalfGridSize + 1, centerCell.y() + mHalfGridSize + 1);
}
osg::Vec2i Scene::getNewGridCenter(const osg::Vec3f& pos, const osg::Vec2i* currentGridCenter) const
{
ESM::RefId worldspace
= mCurrentCell ? mCurrentCell->getCell()->getWorldSpace() : ESM::Cell::sDefaultWorldspaceId;
if (currentGridCenter)
{
const osg::Vec2f center = ESM::indexToPosition(
ESM::ExteriorCellLocation(currentGridCenter->x(), currentGridCenter->y(), worldspace), true);
float distance = std::max(std::abs(center.x() - pos.x()), std::abs(center.y() - pos.y()));
float cellSize = ESM::getCellSize(worldspace);
const float maxDistance = cellSize / 2 + mCellLoadingThreshold; // 1/2 cell size + threshold
if (distance <= maxDistance)
return *currentGridCenter;
}
ESM::ExteriorCellLocation cellPos = ESM::positionToExteriorCellLocation(pos.x(), pos.y(), worldspace);
return { cellPos.mX, cellPos.mY };
}
void Scene::playerMoved(const osg::Vec3f& pos)
{
if (!mCurrentCell)
return;
// The player is reset when z is 90 units below the lowest reference bound z.
constexpr float lowestPointAdjustment = -90.0f;
if (mCurrentCell->isExterior())
{
osg::Vec2i newCell = getNewGridCenter(pos, &mCurrentGridCenter);
if (newCell != mCurrentGridCenter)
requestChangeCellGrid(pos, newCell);
}
else if (pos.z() < mLowestPoint + lowestPointAdjustment)
{
// Player has fallen into the void, reset to interior marker/coc (#1415)
const std::string_view cellNameId = mCurrentCell->getCell()->getNameId();
MWBase::World* world = MWBase::Environment::get().getWorld();
MWWorld::Ptr playerPtr = world->getPlayerPtr();
// Check that collision is enabled, which is opposite to Vanilla
// this change was decided in MR #4100 as the behaviour is preferable
if (world->isActorCollisionEnabled(playerPtr))
{
ESM::Position newPos;
const ESM::RefId refId = world->findInteriorPosition(cellNameId, newPos);
// Only teleport if that teleport point is > the lowest point, rare edge case
if (!refId.empty() && newPos.pos[2] >= mLowestPoint - lowestPointAdjustment)
{
MWWorld::ActionTeleport(refId, newPos, false).execute(playerPtr);
Log(Debug::Warning) << "Player position has been reset due to falling into the void";
}
}
}
}
void Scene::requestChangeCellGrid(const osg::Vec3f& position, const osg::Vec2i& cell, bool changeEvent)
{
mChangeCellGridRequest = ChangeCellGridRequest{ position,
ESM::ExteriorCellLocation(cell.x(), cell.y(), mCurrentCell->getCell()->getWorldSpace()), changeEvent };
}
void Scene::changeCellGrid(const osg::Vec3f& pos, ESM::ExteriorCellLocation playerCellIndex, bool changeEvent)
{
const int halfGridSize
= isEsm4Ext(playerCellIndex.mWorldspace) ? Constants::ESM4CellGridRadius : Constants::CellGridRadius;
auto navigatorUpdateGuard = mNavigator.makeUpdateGuard();
const int playerCellX = playerCellIndex.mX;
const int playerCellY = playerCellIndex.mY;
for (auto iter = mActiveCells.begin(); iter != mActiveCells.end();)
{
auto* cell = *iter++;
if (cell->getCell()->isExterior() && cell->getCell()->getWorldSpace() == playerCellIndex.mWorldspace)
{
const auto dx = std::abs(playerCellX - cell->getCell()->getGridX());
const auto dy = std::abs(playerCellY - cell->getCell()->getGridY());
if (dx > halfGridSize || dy > halfGridSize)
unloadCell(cell, navigatorUpdateGuard.get());
}
else
unloadCell(cell, navigatorUpdateGuard.get());
}
const DetourNavigator::CellGridBounds cellGridBounds{
.mCenter = osg::Vec2i(playerCellX, playerCellY),
.mHalfSize = halfGridSize,
};
mNavigator.updateBounds(playerCellIndex.mWorldspace, cellGridBounds, pos, navigatorUpdateGuard.get());
mHalfGridSize = halfGridSize;
mCurrentGridCenter = osg::Vec2i(playerCellX, playerCellY);
osg::Vec4i newGrid = gridCenterToBounds(mCurrentGridCenter);
mRendering.setActiveGrid(newGrid);
mRendering.enableTerrain(true, playerCellIndex.mWorldspace);
mPreloader->setTerrain(mRendering.getTerrain());
if (mRendering.pagingUnlockCache())
mPreloader->abortTerrainPreloadExcept(nullptr);
if (!mPreloader->isTerrainLoaded(PositionCellGrid{ pos, newGrid }, mRendering.getReferenceTime()))
preloadTerrain(pos, playerCellIndex.mWorldspace, true);
mPagedRefs.clear();
mRendering.getPagedRefnums(newGrid, mPagedRefs);
addPostponedPhysicsObjects();
std::size_t refsToLoad = 0;
std::vector<std::pair<int, int>> cellsPositionsToLoad;
iterateOverCellsAround(playerCellX, playerCellY, mHalfGridSize, [&](int x, int y) {
const ESM::ExteriorCellLocation location(x, y, playerCellIndex.mWorldspace);
if (isCellInCollection(location, mActiveCells))
return;
refsToLoad += mWorld.getWorldModel().getExterior(location).count();
cellsPositionsToLoad.emplace_back(x, y);
});
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
Loading::ScopedLoad load(loadingListener);
loadingListener->setLabel("#{OMWEngine:LoadingExterior}");
loadingListener->setProgressRange(refsToLoad);
sortCellsToLoad(playerCellX, playerCellY, cellsPositionsToLoad);
for (const auto& [x, y] : cellsPositionsToLoad)
{
ESM::ExteriorCellLocation indexToLoad = { x, y, playerCellIndex.mWorldspace };
if (!isCellInCollection(indexToLoad, mActiveCells))
{
CellStore& cell = mWorld.getWorldModel().getExterior(indexToLoad);
loadCell(cell, loadingListener, changeEvent, pos, navigatorUpdateGuard.get());
}
}
mNavigator.update(pos, navigatorUpdateGuard.get());
navigatorUpdateGuard.reset();
CellStore& current = mWorld.getWorldModel().getExterior(playerCellIndex);
MWBase::Environment::get().getWindowManager()->changeCell(¤t);
if (changeEvent)
mCellChanged = true;
mCellLoaded = true;
}
void Scene::addPostponedPhysicsObjects()
{
for (const auto& cell : mActiveCells)
{
cell->forEach([&](const MWWorld::Ptr& ptr) {
if (ptr.mRef->mData.mPhysicsPostponed)
{
ptr.mRef->mData.mPhysicsPostponed = false;
if (ptr.mRef->mData.isEnabled() && ptr.mRef->mRef.getCount() > 0)
{
std::string model = getModel(ptr);
if (!model.empty())
{
const auto rotation = makeNodeRotation(ptr, RotationOrder::direct);
ptr.getClass().insertObjectPhysics(ptr, model, rotation, *mPhysics);
}
}
}
return true;
});
}
}
void Scene::testExteriorCells()
{
// Note: temporary disable ICO to decrease memory usage
mRendering.getResourceSystem()->getSceneManager()->setIncrementalCompileOperation(nullptr);
mRendering.getResourceSystem()->setExpiryDelay(1.f);
const MWWorld::Store<ESM::Cell>& cells = mWorld.getStore().get<ESM::Cell>();
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
Loading::ScopedLoad load(loadingListener);
loadingListener->setProgressRange(cells.getExtSize());
MWWorld::Store<ESM::Cell>::iterator it = cells.extBegin();
int i = 1;
auto navigatorUpdateGuard = mNavigator.makeUpdateGuard();
for (; it != cells.extEnd(); ++it)
{
loadingListener->setLabel("#{OMWEngine:TestingExteriorCells} (" + std::to_string(i) + "/"
+ std::to_string(cells.getExtSize()) + ")...");
CellStore& cell = mWorld.getWorldModel().getExterior(
ESM::ExteriorCellLocation(it->mData.mX, it->mData.mY, ESM::Cell::sDefaultWorldspaceId));
const osg::Vec3f position
= osg::Vec3f(it->mData.mX + 0.5f, it->mData.mY + 0.5f, 0) * Constants::CellSizeInUnits;
const osg::Vec2i cellPosition(it->mData.mX, it->mData.mY);
const DetourNavigator::CellGridBounds cellGridBounds{
.mCenter = osg::Vec2i(it->mData.mX, it->mData.mY),
.mHalfSize = Constants::CellGridRadius,
};
mNavigator.updateBounds(
ESM::Cell::sDefaultWorldspaceId, cellGridBounds, position, navigatorUpdateGuard.get());
loadCell(cell, nullptr, false, position, navigatorUpdateGuard.get());
mNavigator.update(position, navigatorUpdateGuard.get());
navigatorUpdateGuard.reset();
mNavigator.wait(DetourNavigator::WaitConditionType::requiredTilesPresent, nullptr);
navigatorUpdateGuard = mNavigator.makeUpdateGuard();
auto iter = mActiveCells.begin();
while (iter != mActiveCells.end())
{
if (it->isExterior() && it->mData.mX == (*iter)->getCell()->getGridX()
&& it->mData.mY == (*iter)->getCell()->getGridY())
{
unloadCell(*iter, navigatorUpdateGuard.get());
break;
}
++iter;
}
mRendering.getResourceSystem()->updateCache(mRendering.getReferenceTime());
loadingListener->increaseProgress(1);
i++;
}
mRendering.getResourceSystem()->getSceneManager()->setIncrementalCompileOperation(
mRendering.getIncrementalCompileOperation());
mRendering.getResourceSystem()->setExpiryDelay(Settings::cells().mCacheExpiryDelay);
}
void Scene::testInteriorCells()
{
// Note: temporary disable ICO to decrease memory usage
mRendering.getResourceSystem()->getSceneManager()->setIncrementalCompileOperation(nullptr);
mRendering.getResourceSystem()->setExpiryDelay(1.f);
const MWWorld::Store<ESM::Cell>& cells = mWorld.getStore().get<ESM::Cell>();
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
Loading::ScopedLoad load(loadingListener);
loadingListener->setProgressRange(cells.getIntSize());
int i = 1;
MWWorld::Store<ESM::Cell>::iterator it = cells.intBegin();
auto navigatorUpdateGuard = mNavigator.makeUpdateGuard();
for (; it != cells.intEnd(); ++it)
{
loadingListener->setLabel("#{OMWEngine:TestingInteriorCells} (" + std::to_string(i) + "/"
+ std::to_string(cells.getIntSize()) + ")...");
CellStore& cell = mWorld.getWorldModel().getInterior(it->mName);
ESM::Position position;
mWorld.findInteriorPosition(it->mName, position);
mNavigator.updateBounds(
cell.getCell()->getWorldSpace(), std::nullopt, position.asVec3(), navigatorUpdateGuard.get());
loadCell(cell, nullptr, false, position.asVec3(), navigatorUpdateGuard.get());
mNavigator.update(position.asVec3(), navigatorUpdateGuard.get());
navigatorUpdateGuard.reset();
mNavigator.wait(DetourNavigator::WaitConditionType::requiredTilesPresent, nullptr);
navigatorUpdateGuard = mNavigator.makeUpdateGuard();
auto iter = mActiveCells.begin();
while (iter != mActiveCells.end())
{
assert(!(*iter)->getCell()->isExterior());
if (it->mName == (*iter)->getCell()->getNameId())
{
unloadCell(*iter, navigatorUpdateGuard.get());
break;
}
++iter;
}
mRendering.getResourceSystem()->updateCache(mRendering.getReferenceTime());
loadingListener->increaseProgress(1);
i++;
}
mRendering.getResourceSystem()->getSceneManager()->setIncrementalCompileOperation(
mRendering.getIncrementalCompileOperation());
mRendering.getResourceSystem()->setExpiryDelay(Settings::cells().mCacheExpiryDelay);
}
void Scene::changePlayerCell(CellStore& cell, const ESM::Position& pos, bool adjustPlayerPos)
{
mHalfGridSize = cell.getCell()->isEsm4() ? Constants::ESM4CellGridRadius : Constants::CellGridRadius;
mCurrentCell = &cell;
mRendering.enableTerrain(cell.isExterior(), cell.getCell()->getWorldSpace());
MWWorld::Ptr old = mWorld.getPlayerPtr();
mWorld.getPlayer().setCell(&cell);
MWWorld::Ptr player = mWorld.getPlayerPtr();
mRendering.updatePlayerPtr(player);
// The player is loaded before the scene and by default it is grounded, with the scene fully loaded,
// we validate and correct this. Only run once, during initial cell load.
if (old.mCell == &cell)
mPhysics->traceDown(player, player.getRefData().getPosition().asVec3(), 10.f);
if (adjustPlayerPos)
{
mWorld.moveObject(player, pos.asVec3());
mWorld.rotateObject(player, pos.asRotationVec3());
player.getClass().adjustPosition(player, true);
}
MWBase::Environment::get().getMechanicsManager()->updateCell(old, player);
MWBase::Environment::get().getWindowManager()->watchActor(player);
mPhysics->updatePtr(old, player);
mWorld.adjustSky();
mLastPlayerPos = player.getRefData().getPosition().asVec3();
}
Scene::Scene(MWWorld::World& world, MWRender::RenderingManager& rendering, MWPhysics::PhysicsSystem* physics,
DetourNavigator::Navigator& navigator)
: mCurrentCell(nullptr)
, mCellChanged(false)
, mWorld(world)
, mPhysics(physics)
, mRendering(rendering)
, mNavigator(navigator)
, mCellLoadingThreshold(1024.f)
, mPreloadDistance(Settings::cells().mPreloadDistance)
, mPreloadEnabled(Settings::cells().mPreloadEnabled)
, mPreloadExteriorGrid(Settings::cells().mPreloadExteriorGrid)
, mPreloadDoors(Settings::cells().mPreloadDoors)
, mPreloadFastTravel(Settings::cells().mPreloadFastTravel)
, mPredictionTime(Settings::cells().mPredictionTime)
, mLowestPoint(std::numeric_limits<float>::max())
{
mPreloader = std::make_unique<CellPreloader>(rendering.getResourceSystem(), physics->getShapeManager(),
rendering.getTerrain(), rendering.getLandManager());
mPreloader->setWorkQueue(mRendering.getWorkQueue());
mPreloader->setExpiryDelay(Settings::cells().mPreloadCellExpiryDelay);
mPreloader->setMinCacheSize(Settings::cells().mPreloadCellCacheMin);
mPreloader->setMaxCacheSize(Settings::cells().mPreloadCellCacheMax);
mPreloader->setPreloadInstances(Settings::cells().mPreloadInstances);
}
Scene::~Scene()
{
for (const osg::ref_ptr<SceneUtil::WorkItem>& v : mWorkItems)
v->abort();
for (const osg::ref_ptr<SceneUtil::WorkItem>& v : mWorkItems)
v->waitTillDone();
}
bool Scene::hasCellChanged() const
{
return mCellChanged;
}
const Scene::CellStoreCollection& Scene::getActiveCells() const
{
return mActiveCells;
}
void Scene::changeToInteriorCell(
std::string_view cellName, const ESM::Position& position, bool adjustPlayerPos, bool changeEvent)
{
CellStore& cell = mWorld.getWorldModel().getInterior(cellName);
bool useFading = (mCurrentCell != nullptr);
if (useFading)
MWBase::Environment::get().getWindowManager()->fadeScreenOut(0.5);
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
loadingListener->setLabel("#{OMWEngine:LoadingInterior}");
Loading::ScopedLoad load(loadingListener);
if (mCurrentCell == &cell)
{
mWorld.moveObject(mWorld.getPlayerPtr(), position.asVec3());
mWorld.rotateObject(mWorld.getPlayerPtr(), position.asRotationVec3());
if (adjustPlayerPos)
mWorld.getPlayerPtr().getClass().adjustPosition(mWorld.getPlayerPtr(), true);
MWBase::Environment::get().getWindowManager()->fadeScreenIn(0.5);
return;
}
Log(Debug::Info) << "Changing to interior";
auto navigatorUpdateGuard = mNavigator.makeUpdateGuard();
// unload
for (auto iter = mActiveCells.begin(); iter != mActiveCells.end();)
{
auto* cellToUnload = *iter++;
unloadCell(cellToUnload, navigatorUpdateGuard.get());
}
assert(mActiveCells.empty());
loadingListener->setProgressRange(cell.count());
mNavigator.updateBounds(
cell.getCell()->getWorldSpace(), std::nullopt, position.asVec3(), navigatorUpdateGuard.get());
// Load cell.
mPagedRefs.clear();
loadCell(cell, loadingListener, changeEvent, position.asVec3(), navigatorUpdateGuard.get());
navigatorUpdateGuard.reset();
changePlayerCell(cell, position, adjustPlayerPos);
// adjust fog
mRendering.configureFog(*mCurrentCell->getCell());
// Sky system
mWorld.adjustSky();
if (changeEvent)
mCellChanged = true;
mCellLoaded = true;
if (useFading)
MWBase::Environment::get().getWindowManager()->fadeScreenIn(0.5);
MWBase::Environment::get().getWindowManager()->changeCell(mCurrentCell);
MWBase::Environment::get().getWorld()->getPostProcessor()->setExteriorFlag(cell.getCell()->isQuasiExterior());
}
void Scene::changeToExteriorCell(
const ESM::RefId& extCellId, const ESM::Position& position, bool adjustPlayerPos, bool changeEvent)
{
if (changeEvent)
MWBase::Environment::get().getWindowManager()->fadeScreenOut(0.5);
CellStore& current = mWorld.getWorldModel().getCell(extCellId);
const osg::Vec2i cellIndex(current.getCell()->getGridX(), current.getCell()->getGridY());
changeCellGrid(position.asVec3(),
ESM::ExteriorCellLocation(cellIndex.x(), cellIndex.y(), current.getCell()->getWorldSpace()), changeEvent);
changePlayerCell(current, position, adjustPlayerPos);
if (changeEvent)
MWBase::Environment::get().getWindowManager()->fadeScreenIn(0.5);
MWBase::Environment::get().getWorld()->getPostProcessor()->setExteriorFlag(true);
}
CellStore* Scene::getCurrentCell()
{
return mCurrentCell;
}
void Scene::markCellAsUnchanged()
{
mCellChanged = false;
}
void Scene::insertCell(
CellStore& cell, Loading::Listener* loadingListener, const DetourNavigator::UpdateGuard* navigatorUpdateGuard)
{
const bool isInterior = !cell.isExterior();
InsertVisitor insertVisitor(cell, loadingListener);
cell.forEach(insertVisitor);
insertVisitor.insert(
[&](const MWWorld::Ptr& ptr) { addObject(ptr, mWorld, mPagedRefs, *mPhysics, mRendering); });
insertVisitor.insert([&](const MWWorld::Ptr& ptr) {
addObject(ptr, mWorld, *mPhysics, mLowestPoint, isInterior, mNavigator, navigatorUpdateGuard);
});
}
void Scene::addObjectToScene(const Ptr& ptr)
{
const bool isInterior = mCurrentCell && !mCurrentCell->isExterior();
try
{
addObject(ptr, mWorld, mPagedRefs, *mPhysics, mRendering);
addObject(ptr, mWorld, *mPhysics, mLowestPoint, isInterior, mNavigator);
mWorld.scaleObject(ptr, ptr.getCellRef().getScale());
}
catch (std::exception& e)
{
Log(Debug::Error) << "failed to render '" << ptr.getCellRef().getRefId() << "': " << e.what();
}
}
void Scene::removeObjectFromScene(const Ptr& ptr, bool keepActive)
{
MWBase::Environment::get().getMechanicsManager()->remove(ptr, keepActive);
// You'd expect the sounds attached to the object to be stopped here
// because the object is nowhere to be heard, but in Morrowind, they're not.
// They're still stopped when the cell is unloaded
// or if the player moves away far from the object's position.
// Todd Howard, Who art in Bethesda, hallowed be Thy name.
MWBase::Environment::get().getLuaManager()->objectRemovedFromScene(ptr);
if (const auto object = mPhysics->getObject(ptr))
{
if (object->getShapeInstance()->mVisualCollisionType == Resource::VisualCollisionType::None)
mNavigator.removeObject(DetourNavigator::ObjectId(object), nullptr);
}
else if (mPhysics->getActor(ptr))
{
mNavigator.removeAgent(mWorld.getPathfindingAgentBounds(ptr));
}
mPhysics->remove(ptr);
mRendering.removeObject(ptr);
if (ptr.getClass().isActor())
mRendering.removeWaterRippleEmitter(ptr);
ptr.getRefData().setBaseNode(nullptr);
}
bool Scene::isCellActive(const CellStore& cell)
{
return mActiveCells.contains(&cell);
}
Ptr Scene::searchPtrViaActorId(int actorId)
{
for (CellStoreCollection::const_iterator iter(mActiveCells.begin()); iter != mActiveCells.end(); ++iter)
{
Ptr ptr = (*iter)->searchViaActorId(actorId);
if (!ptr.isEmpty())
return ptr;
}
return Ptr();
}
class PreloadMeshItem : public SceneUtil::WorkItem
{
public:
explicit PreloadMeshItem(VFS::Path::NormalizedView mesh, Resource::SceneManager* sceneManager)
: mMesh(mesh)
, mSceneManager(sceneManager)
{
}
void doWork() override
{
if (mAborted)
return;
try
{
mSceneManager->getTemplate(mMesh);
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to get mesh template \"" << mMesh << "\" to preload: " << e.what();
}
}
void abort() override { mAborted = true; }
private:
VFS::Path::Normalized mMesh;
Resource::SceneManager* mSceneManager;
std::atomic_bool mAborted{ false };
};
void Scene::preload(const std::string& mesh, bool useAnim)
{
const VFS::Path::Normalized meshPath = useAnim
? Misc::ResourceHelpers::correctActorModelPath(
VFS::Path::toNormalized(mesh), mRendering.getResourceSystem()->getVFS())
: VFS::Path::toNormalized(mesh);
if (mRendering.getResourceSystem()->getSceneManager()->checkLoaded(meshPath, mRendering.getReferenceTime()))
return;
osg::ref_ptr<PreloadMeshItem> item(
new PreloadMeshItem(meshPath, mRendering.getResourceSystem()->getSceneManager()));
mRendering.getWorkQueue()->addWorkItem(item);
const auto isDone = [](const osg::ref_ptr<SceneUtil::WorkItem>& v) { return v->isDone(); };
mWorkItems.erase(std::remove_if(mWorkItems.begin(), mWorkItems.end(), isDone), mWorkItems.end());
mWorkItems.emplace_back(std::move(item));
}
void Scene::preloadCells(float dt)
{
if (dt <= 1e-06)
return;
std::vector<PositionCellGrid> exteriorPositions;
const MWWorld::ConstPtr player = mWorld.getPlayerPtr();
osg::Vec3f playerPos = player.getRefData().getPosition().asVec3();
osg::Vec3f moved = playerPos - mLastPlayerPos;
osg::Vec3f predictedPos = playerPos + moved / dt * mPredictionTime;
if (mCurrentCell->isExterior())
exteriorPositions.push_back(PositionCellGrid{
predictedPos, gridCenterToBounds(getNewGridCenter(predictedPos, &mCurrentGridCenter)) });
mLastPlayerPos = playerPos;
if (mPreloadEnabled)
{
if (mPreloadDoors)
preloadTeleportDoorDestinations(playerPos, predictedPos);
if (mPreloadExteriorGrid)
preloadExteriorGrid(playerPos, predictedPos);
if (mPreloadFastTravel)
preloadFastTravelDestinations(playerPos, exteriorPositions);
}
mPreloader->setTerrainPreloadPositions(exteriorPositions);
}
void Scene::preloadTeleportDoorDestinations(const osg::Vec3f& playerPos, const osg::Vec3f& predictedPos)
{
std::vector<MWWorld::ConstPtr> teleportDoors;
for (const MWWorld::CellStore* cellStore : mActiveCells)
{
typedef MWWorld::CellRefList<ESM::Door>::List DoorList;
const DoorList& doors = cellStore->getReadOnlyDoors().mList;
for (auto& door : doors)
{
if (!door.mRef.getTeleport())
{
continue;
}
teleportDoors.emplace_back(&door, cellStore);
}
}
for (const MWWorld::ConstPtr& door : teleportDoors)
{
float sqrDistToPlayer = (playerPos - door.getRefData().getPosition().asVec3()).length2();
sqrDistToPlayer
= std::min(sqrDistToPlayer, (predictedPos - door.getRefData().getPosition().asVec3()).length2());
if (sqrDistToPlayer < mPreloadDistance * mPreloadDistance)
{
try
{
preloadCellWithSurroundings(mWorld.getWorldModel().getCell(door.getCellRef().getDestCell()));
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to schedule preload for door " << door.toString() << ": "
<< e.what();
}
}
}
}
void Scene::preloadExteriorGrid(const osg::Vec3f& playerPos, const osg::Vec3f& predictedPos)
{
if (!mWorld.isCellExterior())
return;
int halfGridSizePlusOne = mHalfGridSize + 1;
int cellX, cellY;
cellX = mCurrentGridCenter.x();
cellY = mCurrentGridCenter.y();
ESM::RefId extWorldspace = mWorld.getCurrentWorldspace();
float cellSize = ESM::getCellSize(extWorldspace);
for (int dx = -halfGridSizePlusOne; dx <= halfGridSizePlusOne; ++dx)
{
for (int dy = -halfGridSizePlusOne; dy <= halfGridSizePlusOne; ++dy)
{
if (dy != halfGridSizePlusOne && dy != -halfGridSizePlusOne && dx != halfGridSizePlusOne
&& dx != -halfGridSizePlusOne)
continue; // only care about the outer (not yet loaded) part of the grid
ESM::ExteriorCellLocation cellIndex(cellX + dx, cellY + dy, extWorldspace);
const osg::Vec2f thisCellCenter = ESM::indexToPosition(cellIndex, true);
float dist = std::max(
std::abs(thisCellCenter.x() - playerPos.x()), std::abs(thisCellCenter.y() - playerPos.y()));
dist = std::min(dist,
std::max(std::abs(thisCellCenter.x() - predictedPos.x()),
std::abs(thisCellCenter.y() - predictedPos.y())));
float loadDist = cellSize / 2 + cellSize - mCellLoadingThreshold + mPreloadDistance;
if (dist < loadDist)
preloadCell(mWorld.getWorldModel().getExterior(cellIndex));
}
}
}
void Scene::preloadCellWithSurroundings(CellStore& cell)
{
if (!cell.isExterior())
{
mPreloader->preload(cell, mRendering.getReferenceTime());
return;
}
const int cellX = cell.getCell()->getGridX();
const int cellY = cell.getCell()->getGridY();
std::vector<std::pair<int, int>> cells;
const std::size_t gridSize = static_cast<std::size_t>(2 * mHalfGridSize + 1);
cells.reserve(gridSize * gridSize);
iterateOverCellsAround(cellX, cellY, mHalfGridSize, [&](int x, int y) { cells.emplace_back(x, y); });
sortCellsToLoad(cellX, cellY, cells);
const std::size_t leftCapacity = mPreloader->getMaxCacheSize() - mPreloader->getCacheSize();
if (cells.size() > leftCapacity)
{
static bool logged = [&] {
Log(Debug::Warning) << "Not enough cell preloader cache capacity to preload exterior cells, consider "
"increasing \"preload cell cache max\" up to "
<< (mPreloader->getCacheSize() + cells.size());
return true;
}();
(void)logged;
cells.resize(leftCapacity);
}
const ESM::RefId worldspace = cell.getCell()->getWorldSpace();
for (const auto& [x, y] : cells)
mPreloader->preload(mWorld.getWorldModel().getExterior(ESM::ExteriorCellLocation(x, y, worldspace)),
mRendering.getReferenceTime());
}
void Scene::preloadCell(CellStore& cell)
{
mPreloader->preload(cell, mRendering.getReferenceTime());
}
void Scene::preloadTerrain(const osg::Vec3f& pos, ESM::RefId worldspace, bool sync)
{
ESM::ExteriorCellLocation cellPos = ESM::positionToExteriorCellLocation(pos.x(), pos.y(), worldspace);
const PositionCellGrid position{ pos, gridCenterToBounds({ cellPos.mX, cellPos.mY }) };
mPreloader->abortTerrainPreloadExcept(&position);
mPreloader->setTerrainPreloadPositions(std::span(&position, 1));
if (!sync)
return;
Loading::Listener* loadingListener = MWBase::Environment::get().getWindowManager()->getLoadingScreen();
Loading::ScopedLoad load(loadingListener);
loadingListener->setLabel("#{OMWEngine:InitializingData}");
mPreloader->syncTerrainLoad(*loadingListener);
}
void Scene::reloadTerrain()
{
mPreloader->setTerrainPreloadPositions({});
}
struct ListFastTravelDestinationsVisitor
{
ListFastTravelDestinationsVisitor(float preloadDist, const osg::Vec3f& playerPos)
: mPreloadDist(preloadDist)
, mPlayerPos(playerPos)
{
}
bool operator()(const MWWorld::Ptr& ptr)
{
if ((ptr.getRefData().getPosition().asVec3() - mPlayerPos).length2() > mPreloadDist * mPreloadDist)
return true;
if (ptr.getClass().isNpc())
{
const std::vector<ESM::Transport::Dest>& transport = ptr.get<ESM::NPC>()->mBase->mTransport.mList;
mList.insert(mList.begin(), transport.begin(), transport.end());
}
else
{
const std::vector<ESM::Transport::Dest>& transport = ptr.get<ESM::Creature>()->mBase->mTransport.mList;
mList.insert(mList.begin(), transport.begin(), transport.end());
}
return true;
}
float mPreloadDist;
osg::Vec3f mPlayerPos;
std::vector<ESM::Transport::Dest> mList;
};
void Scene::preloadFastTravelDestinations(
const osg::Vec3f& playerPos, std::vector<PositionCellGrid>& exteriorPositions)
{
ListFastTravelDestinationsVisitor listVisitor(mPreloadDistance, playerPos);
ESM::RefId extWorldspace = mWorld.getCurrentWorldspace();
for (MWWorld::CellStore* cellStore : mActiveCells)
{
cellStore->forEachType<ESM::NPC>(listVisitor);
cellStore->forEachType<ESM::Creature>(listVisitor);
}
for (ESM::Transport::Dest& dest : listVisitor.mList)
{
if (!dest.mCellName.empty())
preloadCell(mWorld.getWorldModel().getInterior(dest.mCellName));
else
{
osg::Vec3f pos = dest.mPos.asVec3();
const ESM::ExteriorCellLocation cellIndex
= ESM::positionToExteriorCellLocation(pos.x(), pos.y(), extWorldspace);
preloadCellWithSurroundings(mWorld.getWorldModel().getExterior(cellIndex));
exteriorPositions.push_back(PositionCellGrid{ pos, gridCenterToBounds(getNewGridCenter(pos)) });
}
}
}
void Scene::reportStats(unsigned int frameNumber, osg::Stats& stats) const
{
mPreloader->reportStats(frameNumber, stats);
}
}
| 55,237
|
C++
|
.cpp
| 1,146
| 37.246073
| 120
| 0.620946
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,274
|
customdata.cpp
|
OpenMW_openmw/apps/openmw/mwworld/customdata.cpp
|
#include "customdata.hpp"
#include <sstream>
#include <stdexcept>
#include <typeinfo>
namespace MWWorld
{
MWClass::CreatureCustomData& CustomData::asCreatureCustomData()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureCustomData";
throw std::logic_error(error.str());
}
const MWClass::CreatureCustomData& CustomData::asCreatureCustomData() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureCustomData";
throw std::logic_error(error.str());
}
MWClass::NpcCustomData& CustomData::asNpcCustomData()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to NpcCustomData";
throw std::logic_error(error.str());
}
const MWClass::NpcCustomData& CustomData::asNpcCustomData() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to NpcCustomData";
throw std::logic_error(error.str());
}
MWClass::ContainerCustomData& CustomData::asContainerCustomData()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to ContainerCustomData";
throw std::logic_error(error.str());
}
const MWClass::ContainerCustomData& CustomData::asContainerCustomData() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to ContainerCustomData";
throw std::logic_error(error.str());
}
MWClass::DoorCustomData& CustomData::asDoorCustomData()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to DoorCustomData";
throw std::logic_error(error.str());
}
const MWClass::DoorCustomData& CustomData::asDoorCustomData() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to DoorCustomData";
throw std::logic_error(error.str());
}
MWClass::CreatureLevListCustomData& CustomData::asCreatureLevListCustomData()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureLevListCustomData";
throw std::logic_error(error.str());
}
const MWClass::CreatureLevListCustomData& CustomData::asCreatureLevListCustomData() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to CreatureLevListCustomData";
throw std::logic_error(error.str());
}
MWClass::ESM4NpcCustomData& CustomData::asESM4NpcCustomData()
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to ESM4NpcCustomData";
throw std::logic_error(error.str());
}
const MWClass::ESM4NpcCustomData& CustomData::asESM4NpcCustomData() const
{
std::stringstream error;
error << "bad cast " << typeid(this).name() << " to ESM4NpcCustomData";
throw std::logic_error(error.str());
}
}
| 3,050
|
C++
|
.cpp
| 79
| 31.962025
| 93
| 0.640176
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,275
|
groundcoverstore.cpp
|
OpenMW_openmw/apps/openmw/mwworld/groundcoverstore.cpp
|
#include "groundcoverstore.hpp"
#include <components/esm3/loadcell.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/readerscache.hpp>
#include <components/esmloader/esmdata.hpp>
#include <components/esmloader/load.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/misc/strings/lower.hpp>
#include <components/resource/resourcesystem.hpp>
#include "store.hpp"
namespace MWWorld
{
void GroundcoverStore::init(const Store<ESM::Static>& statics, const Files::Collections& fileCollections,
const std::vector<std::string>& groundcoverFiles, ToUTF8::Utf8Encoder* encoder, Loading::Listener* listener)
{
::EsmLoader::Query query;
query.mLoadStatics = true;
query.mLoadCells = true;
ESM::ReadersCache readers;
::EsmLoader::EsmData content
= ::EsmLoader::loadEsmData(query, groundcoverFiles, fileCollections, readers, encoder, listener);
static constexpr std::string_view prefix = "grass/";
for (const ESM::Static& stat : statics)
{
VFS::Path::Normalized model = VFS::Path::toNormalized(stat.mModel);
if (!model.value().starts_with(prefix))
continue;
mMeshCache[stat.mId] = Misc::ResourceHelpers::correctMeshPath(model);
}
for (const ESM::Static& stat : content.mStatics)
{
VFS::Path::Normalized model = VFS::Path::toNormalized(stat.mModel);
if (!model.value().starts_with(prefix))
continue;
mMeshCache[stat.mId] = Misc::ResourceHelpers::correctMeshPath(model);
}
for (ESM::Cell& cell : content.mCells)
{
if (!cell.isExterior())
continue;
auto cellIndex = std::make_pair(cell.getGridX(), cell.getGridY());
mCellContexts[cellIndex] = std::move(cell.mContextList);
}
}
void GroundcoverStore::initCell(ESM::Cell& cell, int cellX, int cellY) const
{
cell.blank();
auto searchCell = mCellContexts.find(std::make_pair(cellX, cellY));
if (searchCell != mCellContexts.end())
cell.mContextList = searchCell->second;
}
}
| 2,211
|
C++
|
.cpp
| 52
| 34.5
| 116
| 0.656279
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,276
|
cell.cpp
|
OpenMW_openmw/apps/openmw/mwworld/cell.cpp
|
#include "cell.hpp"
#include "esmstore.hpp"
#include "../mwbase/environment.hpp"
#include <components/esm3/loadcell.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/esm4/loadwrld.hpp>
#include <components/misc/algorithm.hpp>
#include <stdexcept>
#include <string>
namespace MWWorld
{
namespace
{
std::string getDescription(const ESM4::World& value)
{
if (!value.mEditorId.empty())
return value.mEditorId;
return ESM::RefId(value.mId).serializeText();
}
std::string getCellDescription(const ESM4::Cell& cell, const ESM4::World* world)
{
std::string result;
if (!cell.mEditorId.empty())
result = cell.mEditorId;
else if (world != nullptr && cell.isExterior())
result = getDescription(*world);
else
result = cell.mId.serializeText();
if (cell.isExterior())
result += " (" + std::to_string(cell.mX) + ", " + std::to_string(cell.mY) + ")";
return result;
}
}
Cell::Cell(const ESM4::Cell& cell)
: ESM::CellVariant(cell)
, mIsExterior(!(cell.mCellFlags & ESM4::CELL_Interior))
, mIsQuasiExterior(cell.mCellFlags & ESM4::CELL_QuasiExt)
, mHasWater(cell.mCellFlags & ESM4::CELL_HasWater)
, mNoSleep(false) // No such notion in ESM4
, mGridPos(cell.mX, cell.mY)
, mDisplayname(cell.mFullName)
, mNameID(cell.mEditorId)
, mRegion(ESM::RefId()) // Unimplemented for now
, mId(cell.mId)
, mParent(cell.mParent)
, mWaterHeight(cell.mWaterHeight)
, mMood{
.mAmbiantColor = cell.mLighting.ambient,
.mDirectionalColor = cell.mLighting.directional,
.mFogColor = cell.mLighting.fogColor,
// TODO: use ESM4::Lighting fog parameters
.mFogDensity = 1.f,
}
{
const ESM4::World* world = MWBase::Environment::get().getESMStore()->get<ESM4::World>().search(mParent);
if (isExterior())
{
if (world == nullptr)
throw std::runtime_error(
"Cell " + cell.mId.toDebugString() + " parent world " + mParent.toDebugString() + " is not found");
mWaterHeight = world->mWaterLevel;
}
mDescription = getCellDescription(cell, world);
}
Cell::Cell(const ESM::Cell& cell)
: ESM::CellVariant(cell)
, mIsExterior(!(cell.mData.mFlags & ESM::Cell::Interior))
, mIsQuasiExterior(cell.mData.mFlags & ESM::Cell::QuasiEx)
, mHasWater(cell.mData.mFlags & ESM::Cell::HasWater)
, mNoSleep(cell.mData.mFlags & ESM::Cell::NoSleep)
, mGridPos(cell.getGridX(), cell.getGridY())
, mDisplayname(cell.mName)
, mNameID(cell.mName)
, mRegion(cell.mRegion)
, mId(cell.mId)
, mParent(ESM::Cell::sDefaultWorldspaceId)
, mWaterHeight(cell.mWater)
, mDescription(cell.getDescription())
, mMood{
.mAmbiantColor = cell.mAmbi.mAmbient,
.mDirectionalColor = cell.mAmbi.mSunlight,
.mFogColor = cell.mAmbi.mFog,
.mFogDensity = cell.mAmbi.mFogDensity,
}
{
if (isExterior())
{
mWaterHeight = -1.f;
mHasWater = true;
}
else
mGridPos = {};
}
}
| 3,464
|
C++
|
.cpp
| 94
| 27.553191
| 119
| 0.582192
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,277
|
esmloader.cpp
|
OpenMW_openmw/apps/openmw/mwworld/esmloader.cpp
|
#include "esmloader.hpp"
#include "esmstore.hpp"
#include <fstream>
#include <components/esm/format.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/readerscache.hpp>
#include <components/esm4/reader.hpp>
#include <components/files/conversion.hpp>
#include <components/files/openfile.hpp>
#include <components/misc/strings/lower.hpp>
#include <components/resource/resourcesystem.hpp>
#include "../mwbase/environment.hpp"
namespace MWWorld
{
EsmLoader::EsmLoader(MWWorld::ESMStore& store, ESM::ReadersCache& readers, ToUTF8::Utf8Encoder* encoder,
std::vector<int>& esmVersions)
: mReaders(readers)
, mStore(store)
, mEncoder(encoder)
, mDialogue(nullptr) // A content file containing INFO records without a DIAL record appends them to the
// previous file's dialogue
, mESMVersions(esmVersions)
{
}
void EsmLoader::load(const std::filesystem::path& filepath, int& index, Loading::Listener* listener)
{
auto stream = Files::openBinaryInputFileStream(filepath);
const ESM::Format format = ESM::readFormat(*stream);
stream->seekg(0);
switch (format)
{
case ESM::Format::Tes3:
{
const ESM::ReadersCache::BusyItem reader = mReaders.get(static_cast<std::size_t>(index));
reader->setEncoder(mEncoder);
reader->setIndex(index);
reader->open(filepath);
reader->resolveParentFileIndices(mReaders);
assert(reader->getGameFiles().size() == reader->getParentFileIndices().size());
for (std::size_t i = 0, n = reader->getParentFileIndices().size(); i < n; ++i)
if (i == static_cast<std::size_t>(reader->getIndex()))
throw std::runtime_error("File " + Files::pathToUnicodeString(reader->getName()) + " asks for parent file "
+ reader->getGameFiles()[i].name
+ ", but it is not available or has been loaded in the wrong order. "
"Please run the launcher to fix this issue.");
mESMVersions[index] = reader->getVer();
mStore.load(*reader, listener, mDialogue);
if (!mMasterFileFormat.has_value()
&& (Misc::StringUtils::ciEndsWith(reader->getName().u8string(), u8".esm")
|| Misc::StringUtils::ciEndsWith(reader->getName().u8string(), u8".omwgame")))
mMasterFileFormat = reader->getFormatVersion();
break;
}
case ESM::Format::Tes4:
{
ESM4::Reader reader(std::move(stream), filepath,
MWBase::Environment::get().getResourceSystem()->getVFS(),
mEncoder != nullptr ? &mEncoder->getStatelessEncoder() : nullptr);
reader.setModIndex(index);
reader.updateModIndices(mNameToIndex);
mStore.loadESM4(reader);
break;
}
}
mNameToIndex[Misc::StringUtils::lowerCase(Files::pathToUnicodeString(filepath.filename()))] = index;
}
} /* namespace MWWorld */
| 3,236
|
C++
|
.cpp
| 67
| 36.925373
| 131
| 0.602787
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,278
|
actiontrap.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actiontrap.cpp
|
#include "actiontrap.hpp"
#include "../mwmechanics/spellcasting.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
namespace MWWorld
{
void ActionTrap::executeImp(const Ptr& actor)
{
osg::Vec3f actorPosition(actor.getRefData().getPosition().asVec3());
osg::Vec3f trapPosition(mTrapSource.getRefData().getPosition().asVec3());
float trapRange = MWBase::Environment::get().getWorld()->getMaxActivationDistance();
// Note: can't just detonate the trap at the trapped object's location and use the blast
// radius, because for most trap spells this is 1 foot, much less than the activation distance.
// Using activation distance as the trap range.
if (actor == MWBase::Environment::get().getWorld()->getPlayerPtr()
&& MWBase::Environment::get().getWorld()->getDistanceToFacedObject()
> trapRange) // player activated object outside range of trap
{
MWMechanics::CastSpell cast(mTrapSource, mTrapSource);
cast.mHitPosition = trapPosition;
cast.cast(mSpellId);
}
else // player activated object within range of trap, or NPC activated trap
{
MWMechanics::CastSpell cast(mTrapSource, actor);
cast.mHitPosition = actorPosition;
cast.cast(mSpellId);
}
mTrapSource.getCellRef().setTrap(ESM::RefId());
}
}
| 1,436
|
C++
|
.cpp
| 31
| 38.193548
| 103
| 0.662857
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,279
|
store.cpp
|
OpenMW_openmw/apps/openmw/mwworld/store.cpp
|
#include "store.hpp"
#include <iterator>
#include <sstream>
#include <stdexcept>
#include <components/debug/debuglog.hpp>
#include <components/esm/records.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/fallback/fallback.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/misc/rng.hpp>
#include "../mwworld/cell.hpp"
namespace
{
// TODO: Switch to C++23 to get a working version of std::unordered_map::erase
template <class T, class Id>
bool eraseFromMap(T& map, const Id& value)
{
auto it = map.find(value);
if (it != map.end())
{
map.erase(it);
return true;
}
return false;
}
std::string_view getGMSTString(const MWWorld::Store<ESM::GameSetting>& settings, std::string_view id)
{
const ESM::GameSetting* setting = settings.search(id);
if (setting && setting->mValue.getType() == ESM::VT_String)
return setting->mValue.getString();
return id;
}
float getGMSTFloat(const MWWorld::Store<ESM::GameSetting>& settings, std::string_view id)
{
const ESM::GameSetting* setting = settings.search(id);
if (setting && (setting->mValue.getType() == ESM::VT_Float || setting->mValue.getType() == ESM::VT_Int))
return setting->mValue.getFloat();
return {};
}
}
namespace MWWorld
{
RecordId::RecordId(const ESM::RefId& id, bool isDeleted)
: mId(id)
, mIsDeleted(isDeleted)
{
}
template <typename T>
IndexedStore<T>::IndexedStore()
{
}
template <typename T>
typename IndexedStore<T>::iterator IndexedStore<T>::begin() const
{
return mStatic.begin();
}
template <typename T>
typename IndexedStore<T>::iterator IndexedStore<T>::end() const
{
return mStatic.end();
}
template <typename T>
void IndexedStore<T>::load(ESM::ESMReader& esm)
{
T record;
bool isDeleted = false;
record.load(esm, isDeleted);
auto idx = record.mIndex;
mStatic.insert_or_assign(idx, std::move(record));
}
template <typename T>
int IndexedStore<T>::getSize() const
{
return mStatic.size();
}
template <typename T>
void IndexedStore<T>::setUp()
{
}
template <typename T>
const T* IndexedStore<T>::search(int index) const
{
typename Static::const_iterator it = mStatic.find(index);
if (it != mStatic.end())
return &(it->second);
return nullptr;
}
template <typename T>
const T* IndexedStore<T>::find(int index) const
{
const T* ptr = search(index);
if (ptr == nullptr)
{
std::stringstream msg;
msg << T::getRecordType() << " with index " << index << " not found";
throw std::runtime_error(msg.str());
}
return ptr;
}
// Need to instantiate these before they're used
template class IndexedStore<ESM::MagicEffect>;
template <class T, class Id>
TypedDynamicStore<T, Id>::TypedDynamicStore()
{
}
template <class T, class Id>
TypedDynamicStore<T, Id>::TypedDynamicStore(const TypedDynamicStore<T, Id>& orig)
: mStatic(orig.mStatic)
{
}
template <class T, class Id>
void TypedDynamicStore<T, Id>::clearDynamic()
{
// remove the dynamic part of mShared
assert(mShared.size() >= mStatic.size());
mShared.erase(mShared.begin() + mStatic.size(), mShared.end());
mDynamic.clear();
}
template <class T, class Id>
const T* TypedDynamicStore<T, Id>::search(const Id& id) const
{
typename Dynamic::const_iterator dit = mDynamic.find(id);
if (dit != mDynamic.end())
return &dit->second;
typename Static::const_iterator it = mStatic.find(id);
if (it != mStatic.end())
return &(it->second);
return nullptr;
}
template <class T, class Id>
const T* TypedDynamicStore<T, Id>::searchStatic(const Id& id) const
{
typename Static::const_iterator it = mStatic.find(id);
if (it != mStatic.end())
return &(it->second);
return nullptr;
}
template <class T, class Id>
bool TypedDynamicStore<T, Id>::isDynamic(const Id& id) const
{
typename Dynamic::const_iterator dit = mDynamic.find(id);
return (dit != mDynamic.end());
}
template <class T, class Id>
const T* TypedDynamicStore<T, Id>::searchRandom(const std::string_view prefix, Misc::Rng::Generator& prng) const
{
if constexpr (std::is_same_v<Id, ESM::RefId>)
{
if (prefix.empty())
{
if (!mShared.empty())
return mShared[Misc::Rng::rollDice(mShared.size(), prng)];
}
else if constexpr (!std::is_same_v<decltype(T::mId), ESM::FormId>)
{
std::vector<const T*> results;
std::copy_if(mShared.begin(), mShared.end(), std::back_inserter(results),
[prefix](const T* item) { return item->mId.startsWith(prefix); });
if (!results.empty())
return results[Misc::Rng::rollDice(results.size(), prng)];
}
return nullptr;
}
else
throw std::runtime_error("Store<T>::searchRandom is supported only if Id is ESM::RefId");
}
template <class T, class Id>
const T* TypedDynamicStore<T, Id>::find(const Id& id) const
{
const T* ptr = search(id);
if (ptr == nullptr)
{
std::stringstream msg;
if constexpr (!ESM::isESM4Rec(T::sRecordId))
{
msg << T::getRecordType();
}
else
{
msg << "ESM::REC_" << getRecNameString(T::sRecordId).toStringView();
}
msg << " '" << id << "' not found";
throw std::runtime_error(msg.str());
}
return ptr;
}
template <class T, class Id>
RecordId TypedDynamicStore<T, Id>::load(ESM::ESMReader& esm)
{
if constexpr (!ESM::isESM4Rec(T::sRecordId))
{
T record;
bool isDeleted = false;
record.load(esm, isDeleted);
std::pair<typename Static::iterator, bool> inserted = mStatic.insert_or_assign(record.mId, record);
if (inserted.second)
mShared.push_back(&inserted.first->second);
if constexpr (std::is_same_v<Id, ESM::RefId>)
return RecordId(record.mId, isDeleted);
else
return RecordId();
}
else
{
std::stringstream msg;
msg << "Can not load record of type ESM::REC_" << getRecNameString(T::sRecordId).toStringView()
<< ": ESM::ESMReader can load only ESM3 records.";
throw std::runtime_error(msg.str());
}
}
template <class T, class Id>
void TypedDynamicStore<T, Id>::setUp()
{
}
template <class T, class Id>
typename TypedDynamicStore<T, Id>::iterator TypedDynamicStore<T, Id>::begin() const
{
return mShared.begin();
}
template <class T, class Id>
typename TypedDynamicStore<T, Id>::iterator TypedDynamicStore<T, Id>::end() const
{
return mShared.end();
}
template <class T, class Id>
size_t TypedDynamicStore<T, Id>::getSize() const
{
return mShared.size();
}
template <class T, class Id>
int TypedDynamicStore<T, Id>::getDynamicSize() const
{
return mDynamic.size();
}
template <class T, class Id>
void TypedDynamicStore<T, Id>::listIdentifier(std::vector<Id>& list) const
{
list.reserve(list.size() + getSize());
typename std::vector<T*>::const_iterator it = mShared.begin();
for (; it != mShared.end(); ++it)
{
list.push_back((*it)->mId);
}
}
template <class T, class Id>
T* TypedDynamicStore<T, Id>::insert(const T& item, bool overrideOnly)
{
if (overrideOnly)
{
auto it = mStatic.find(item.mId);
if (it == mStatic.end())
return nullptr;
}
std::pair<typename Dynamic::iterator, bool> result = mDynamic.insert_or_assign(item.mId, item);
T* ptr = &result.first->second;
if (result.second)
mShared.push_back(ptr);
return ptr;
}
template <class T, class Id>
T* TypedDynamicStore<T, Id>::insertStatic(const T& item)
{
std::pair<typename Static::iterator, bool> result = mStatic.insert_or_assign(item.mId, item);
T* ptr = &result.first->second;
if (result.second)
mShared.push_back(ptr);
return ptr;
}
template <class T, class Id>
bool TypedDynamicStore<T, Id>::eraseStatic(const Id& id)
{
typename Static::iterator it = mStatic.find(id);
if (it != mStatic.end())
{
// delete from the static part of mShared
typename std::vector<T*>::iterator sharedIter = mShared.begin();
typename std::vector<T*>::iterator end = sharedIter + mStatic.size();
while (sharedIter != mShared.end() && sharedIter != end)
{
if ((*sharedIter)->mId == id)
{
mShared.erase(sharedIter);
break;
}
++sharedIter;
}
mStatic.erase(it);
}
return true;
}
template <class T, class Id>
bool TypedDynamicStore<T, Id>::erase(const Id& id)
{
if (!eraseFromMap(mDynamic, id))
return false;
// have to reinit the whole shared part
assert(mShared.size() >= mStatic.size());
mShared.erase(mShared.begin() + mStatic.size(), mShared.end());
for (auto it = mDynamic.begin(); it != mDynamic.end(); ++it)
{
mShared.push_back(&it->second);
}
return true;
}
template <class T, class Id>
bool TypedDynamicStore<T, Id>::erase(const T& item)
{
return erase(item.mId);
}
template <class T, class Id>
void TypedDynamicStore<T, Id>::write(ESM::ESMWriter& writer, Loading::Listener& progress) const
{
for (typename Dynamic::const_iterator iter(mDynamic.begin()); iter != mDynamic.end(); ++iter)
{
if constexpr (!ESM::isESM4Rec(T::sRecordId))
{
writer.startRecord(T::sRecordId);
iter->second.save(writer);
writer.endRecord(T::sRecordId);
}
}
}
template <class T, class Id>
RecordId TypedDynamicStore<T, Id>::read(ESM::ESMReader& reader, bool overrideOnly)
{
if constexpr (!ESM::isESM4Rec(T::sRecordId))
{
T record;
bool isDeleted = false;
record.load(reader, isDeleted);
insert(record, overrideOnly);
if constexpr (std::is_same_v<Id, ESM::RefId>)
return RecordId(record.mId, isDeleted);
else
return RecordId();
}
else
{
std::stringstream msg;
msg << "Can not load record of type ESM::REC_" << getRecNameString(T::sRecordId).toStringView()
<< ": ESM::ESMReader can load only ESM3 records.";
throw std::runtime_error(msg.str());
}
}
// LandTexture
//=========================================================================
Store<ESM::LandTexture>::Store() = default;
const std::string* Store<ESM::LandTexture>::search(std::uint32_t index, int plugin) const
{
auto mapping = mMappings.find(PluginIndex{ plugin, index });
if (mapping == mMappings.end())
return nullptr;
auto texture = mStatic.find(mapping->second);
if (texture == mStatic.end())
return nullptr;
return &texture->second;
}
size_t Store<ESM::LandTexture>::getSize() const
{
return mStatic.size();
}
RecordId Store<ESM::LandTexture>::load(ESM::ESMReader& esm)
{
const int plugin = esm.getIndex();
ESM::LandTexture lt;
bool isDeleted = false;
lt.load(esm, isDeleted);
if (!isDeleted)
{
mStatic[lt.mId] = std::move(lt.mTexture);
mMappings.emplace(PluginIndex{ plugin, lt.mIndex }, lt.mId);
}
return RecordId(lt.mId, isDeleted);
}
bool Store<ESM::LandTexture>::eraseStatic(const ESM::RefId& id)
{
mStatic.erase(id);
return true;
}
// Land
//=========================================================================
Store<ESM::Land>::~Store() = default;
size_t Store<ESM::Land>::getSize() const
{
return mStatic.size();
}
Store<ESM::Land>::iterator Store<ESM::Land>::begin() const
{
return iterator(mStatic.begin());
}
Store<ESM::Land>::iterator Store<ESM::Land>::end() const
{
return iterator(mStatic.end());
}
const ESM::Land* Store<ESM::Land>::search(int x, int y) const
{
std::pair<int, int> comp(x, y);
if (auto it = mStatic.find(comp); it != mStatic.end() && it->mX == x && it->mY == y)
return &*it;
return nullptr;
}
const ESM::Land* Store<ESM::Land>::find(int x, int y) const
{
const ESM::Land* ptr = search(x, y);
if (ptr == nullptr)
{
const std::string msg = "Land at (" + std::to_string(x) + ", " + std::to_string(y) + ") not found";
throw std::runtime_error(msg);
}
return ptr;
}
RecordId Store<ESM::Land>::load(ESM::ESMReader& esm)
{
ESM::Land land;
bool isDeleted = false;
land.load(esm, isDeleted);
// Same area defined in multiple plugins? -> last plugin wins
auto it = mStatic.lower_bound(land);
if (it != mStatic.end() && (std::tie(it->mX, it->mY) == std::tie(land.mX, land.mY)))
{
auto nh = mStatic.extract(it);
nh.value() = std::move(land);
mStatic.insert(std::move(nh));
}
else
mStatic.insert(it, std::move(land));
return RecordId(ESM::RefId(), isDeleted);
}
void Store<ESM::Land>::setUp()
{
// The land is static for given game session, there is no need to refresh it every load.
if (mBuilt)
throw std::logic_error("Store<ESM::Land>::setUp() is called twice");
mBuilt = true;
}
// Cell
//=========================================================================
const ESM::Cell* Store<ESM::Cell>::search(const ESM::RefId& cellId) const
{
auto foundCellIt = mCells.find(cellId);
if (foundCellIt != mCells.end())
return &foundCellIt->second;
return nullptr;
}
const ESM::Cell* Store<ESM::Cell>::search(const ESM::Cell& cell) const
{
return search(cell.mId);
}
// this method *must* be called right after esm3.loadCell()
void Store<ESM::Cell>::handleMovedCellRefs(ESM::ESMReader& esm, ESM::Cell* cell)
{
ESM::CellRef ref;
ESM::MovedCellRef cMRef;
bool deleted = false;
bool moved = false;
ESM::ESM_Context ctx = esm.getContext();
// Handling MovedCellRefs, there is no way to do it inside loadcell
// TODO: verify above comment
//
// Get regular moved reference data. Adapted from CellStore::loadRefs. Maybe we can optimize the following
// implementation when the oher implementation works as well.
while (ESM::Cell::getNextRef(esm, ref, deleted, cMRef, moved, ESM::Cell::GetNextRefMode::LoadOnlyMoved))
{
if (!moved)
continue;
ESM::Cell* cellAlt = const_cast<ESM::Cell*>(searchOrCreate(cMRef.mTarget[0], cMRef.mTarget[1]));
// Add data required to make reference appear in the correct cell.
// We should not need to test for duplicates, as this part of the code is pre-cell merge.
cell->mMovedRefs.push_back(cMRef);
// But there may be duplicates here!
ESM::CellRefTracker::iterator iter = std::find_if(
cellAlt->mLeasedRefs.begin(), cellAlt->mLeasedRefs.end(), ESM::CellRefTrackerPredicate(ref.mRefNum));
if (iter == cellAlt->mLeasedRefs.end())
cellAlt->mLeasedRefs.emplace_back(std::move(ref), deleted);
else
*iter = std::make_pair(std::move(ref), deleted);
cMRef.mRefNum.mIndex = 0;
}
esm.restoreContext(ctx);
}
const ESM::Cell* Store<ESM::Cell>::search(std::string_view name) const
{
DynamicInt::const_iterator it = mInt.find(name);
if (it != mInt.end())
{
return it->second;
}
DynamicInt::const_iterator dit = mDynamicInt.find(name);
if (dit != mDynamicInt.end())
{
return dit->second;
}
return nullptr;
}
const ESM::Cell* Store<ESM::Cell>::search(int x, int y) const
{
std::pair<int, int> key(x, y);
DynamicExt::const_iterator it = mExt.find(key);
if (it != mExt.end())
return it->second;
DynamicExt::const_iterator dit = mDynamicExt.find(key);
if (dit != mDynamicExt.end())
return dit->second;
return nullptr;
}
const ESM::Cell* Store<ESM::Cell>::searchStatic(int x, int y) const
{
DynamicExt::const_iterator it = mExt.find(std::make_pair(x, y));
if (it != mExt.end())
return (it->second);
return nullptr;
}
const ESM::Cell* Store<ESM::Cell>::searchOrCreate(int x, int y)
{
std::pair<int, int> key(x, y);
DynamicExt::const_iterator it = mExt.find(key);
if (it != mExt.end())
return (it->second);
DynamicExt::const_iterator dit = mDynamicExt.find(key);
if (dit != mDynamicExt.end())
return dit->second;
ESM::Cell newCell;
newCell.mData.mX = x;
newCell.mData.mY = y;
newCell.mData.mFlags = ESM::Cell::HasWater;
newCell.mAmbi.mAmbient = 0;
newCell.mAmbi.mSunlight = 0;
newCell.mAmbi.mFog = 0;
newCell.mAmbi.mFogDensity = 0;
newCell.updateId();
ESM::Cell* newCellInserted = &mCells.insert(std::make_pair(newCell.mId, newCell)).first->second;
return mExt.insert(std::make_pair(key, newCellInserted)).first->second;
}
const ESM::Cell* Store<ESM::Cell>::find(const ESM::RefId& id) const
{
const ESM::Cell* ptr = search(id);
if (ptr == nullptr)
{
const std::string msg = "Cell " + id.toDebugString() + " not found";
throw std::runtime_error(msg);
}
return ptr;
}
const ESM::Cell* Store<ESM::Cell>::find(std::string_view id) const
{
const ESM::Cell* ptr = search(id);
if (ptr == nullptr)
{
const std::string msg = "Cell '" + std::string(id) + "' not found";
throw std::runtime_error(msg);
}
return ptr;
}
const ESM::Cell* Store<ESM::Cell>::find(int x, int y) const
{
const ESM::Cell* ptr = search(x, y);
if (ptr == nullptr)
{
const std::string msg = "Exterior at (" + std::to_string(x) + ", " + std::to_string(y) + ") not found";
throw std::runtime_error(msg);
}
return ptr;
}
void Store<ESM::Cell>::clearDynamic()
{
for (const auto& [_, cell] : mDynamicExt)
mCells.erase(cell->mId);
mDynamicExt.clear();
for (const auto& [_, cell] : mDynamicInt)
mCells.erase(cell->mId);
mDynamicInt.clear();
setUp();
}
void Store<ESM::Cell>::setUp()
{
mSharedInt.clear();
mSharedInt.reserve(mInt.size());
for (auto& [_, cell] : mInt)
mSharedInt.push_back(cell);
mSharedExt.clear();
mSharedExt.reserve(mExt.size());
for (auto& [_, cell] : mExt)
mSharedExt.push_back(cell);
}
RecordId Store<ESM::Cell>::load(ESM::ESMReader& esm)
{
// Don't automatically assume that a new cell must be spawned. Multiple plugins write to the same cell,
// and we merge all this data into one Cell object. However, we can't simply search for the cell id,
// as many exterior cells do not have a name. Instead, we need to search by (x,y) coordinates - and they
// are not available until both cells have been loaded at least partially!
// All cells have a name record, even nameless exterior cells.
ESM::Cell* emplacedCell = nullptr;
bool isDeleted = false;
bool newCell = false;
{
ESM::Cell cellToLoad;
cellToLoad.loadNameAndData(esm, isDeleted);
auto [it, inserted] = mCells.insert(std::make_pair(cellToLoad.mId, cellToLoad));
emplacedCell = &it->second;
if (!inserted)
{
emplacedCell->mData = cellToLoad.mData;
emplacedCell->mName = cellToLoad.mName;
}
newCell = inserted;
}
ESM::Cell& cell = *emplacedCell;
// Load the (x,y) coordinates of the cell, if it is an exterior cell,
// so we can find the cell we need to merge with
if (cell.mData.mFlags & ESM::Cell::Interior)
{
cell.loadCell(esm, true);
if (newCell)
mInt[cell.mName] = &cell;
}
else
{
cell.loadCell(esm, false);
// handle moved ref (MVRF) subrecords
ESM::MovedCellRefTracker newMovedRefs;
std::swap(newMovedRefs, cell.mMovedRefs);
handleMovedCellRefs(esm, &cell);
std::swap(newMovedRefs, cell.mMovedRefs);
// push the new references on the list of references to manage
cell.postLoad(esm);
if (newCell)
mExt[std::make_pair(cell.mData.mX, cell.mData.mY)] = &cell;
else
{
// merge lists of leased references, use newer data in case of conflict
for (const auto& movedRef : newMovedRefs)
{
// remove reference from current leased ref tracker and add it to new cell
auto itOld = std::find(cell.mMovedRefs.begin(), cell.mMovedRefs.end(), movedRef.mRefNum);
if (itOld != cell.mMovedRefs.end())
{
if (movedRef.mTarget[0] != itOld->mTarget[0] || movedRef.mTarget[1] != itOld->mTarget[1])
{
ESM::Cell* wipecell = const_cast<ESM::Cell*>(search(itOld->mTarget[0], itOld->mTarget[1]));
auto itLease = std::find_if(wipecell->mLeasedRefs.begin(), wipecell->mLeasedRefs.end(),
ESM::CellRefTrackerPredicate(movedRef.mRefNum));
if (itLease != wipecell->mLeasedRefs.end())
wipecell->mLeasedRefs.erase(itLease);
else
Log(Debug::Error) << "Error: can't find " << movedRef.mRefNum.mIndex << " "
<< movedRef.mRefNum.mContentFile << " in leasedRefs";
}
*itOld = movedRef;
}
else
cell.mMovedRefs.push_back(movedRef);
}
// We don't need to merge mLeasedRefs of cell / oldcell. This list is filled when another cell moves a
// reference to this cell, so the list for the new cell should be empty. The list for oldcell,
// however, could have leased refs in it and so should be kept.
}
}
return RecordId(cell.mId, isDeleted);
}
Store<ESM::Cell>::iterator Store<ESM::Cell>::intBegin() const
{
return iterator(mSharedInt.begin());
}
Store<ESM::Cell>::iterator Store<ESM::Cell>::intEnd() const
{
return iterator(mSharedInt.end());
}
Store<ESM::Cell>::iterator Store<ESM::Cell>::extBegin() const
{
return iterator(mSharedExt.begin());
}
Store<ESM::Cell>::iterator Store<ESM::Cell>::extEnd() const
{
return iterator(mSharedExt.end());
}
const ESM::Cell* Store<ESM::Cell>::searchExtByName(std::string_view name) const
{
const ESM::Cell* cell = nullptr;
for (const ESM::Cell* sharedCell : mSharedExt)
{
if (Misc::StringUtils::ciEqual(sharedCell->mName, name))
{
if (cell == nullptr || (sharedCell->mData.mX > cell->mData.mX)
|| (sharedCell->mData.mX == cell->mData.mX && sharedCell->mData.mY > cell->mData.mY))
{
cell = sharedCell;
}
}
}
return cell;
}
const ESM::Cell* Store<ESM::Cell>::searchExtByRegion(const ESM::RefId& id) const
{
const ESM::Cell* cell = nullptr;
for (const ESM::Cell* sharedCell : mSharedExt)
{
if (sharedCell->mRegion == id)
{
if (cell == nullptr || (sharedCell->mData.mX > cell->mData.mX)
|| (sharedCell->mData.mX == cell->mData.mX && sharedCell->mData.mY > cell->mData.mY))
{
cell = sharedCell;
}
}
}
return cell;
}
size_t Store<ESM::Cell>::getSize() const
{
return mSharedInt.size() + mSharedExt.size();
}
size_t Store<ESM::Cell>::getExtSize() const
{
return mSharedExt.size();
}
size_t Store<ESM::Cell>::getIntSize() const
{
return mSharedInt.size();
}
void Store<ESM::Cell>::listIdentifier(std::vector<ESM::RefId>& list) const
{
list.reserve(list.size() + mSharedInt.size());
for (const ESM::Cell* sharedCell : mSharedInt)
{
list.push_back(ESM::RefId::stringRefId(sharedCell->mName));
}
}
ESM::Cell* Store<ESM::Cell>::insert(const ESM::Cell& cell)
{
if (search(cell) != nullptr)
{
const std::string cellType = (cell.isExterior()) ? "exterior" : "interior";
throw std::runtime_error("Failed to create " + cellType + " cell");
}
ESM::Cell* insertedCell = &mCells.emplace(cell.mId, cell).first->second;
if (cell.isExterior())
{
std::pair<int, int> key(cell.getGridX(), cell.getGridY());
// duplicate insertions are avoided by search(ESM::Cell &)
DynamicExt::iterator result = mDynamicExt.emplace(key, insertedCell).first;
mSharedExt.push_back(result->second);
return result->second;
}
else
{
// duplicate insertions are avoided by search(ESM::Cell &)
DynamicInt::iterator result = mDynamicInt.emplace(cell.mName, insertedCell).first;
mSharedInt.push_back(result->second);
return result->second;
}
}
// Pathgrid
//=========================================================================
Store<ESM::Pathgrid>::Store()
: mCells(nullptr)
{
}
void Store<ESM::Pathgrid>::setCells(Store<ESM::Cell>& cells)
{
mCells = &cells;
}
RecordId Store<ESM::Pathgrid>::load(ESM::ESMReader& esm)
{
ESM::Pathgrid pathgrid;
bool isDeleted = false;
pathgrid.load(esm, isDeleted);
// Unfortunately the Pathgrid record model does not specify whether the pathgrid belongs to an interior or
// exterior cell. For interior cells, mCell is the cell name, but for exterior cells it is either the cell name
// or if that doesn't exist, the cell's region name. mX and mY will be (0,0) for interior cells, but there is
// also an exterior cell with the coordinates of (0,0), so that doesn't help. Check whether mCell is an interior
// cell. This isn't perfect, will break if a Region with the same name as an interior cell is created. A proper
// fix should be made for future versions of the file format.
bool interior = pathgrid.mData.mX == 0 && pathgrid.mData.mY == 0
&& mCells->search(pathgrid.mCell.getRefIdString()) != nullptr;
ESM::RefId cell
= interior ? pathgrid.mCell : ESM::RefId::esm3ExteriorCell(pathgrid.mData.mX, pathgrid.mData.mY);
// deal with mods that have empty pathgrid records (Issue #6209)
// we assume that these records are empty on purpose (i.e. to remove old pathgrid on an updated cell)
if (isDeleted || pathgrid.mPoints.empty() || pathgrid.mEdges.empty())
{
mStatic.erase(cell);
return RecordId(ESM::RefId(), isDeleted);
}
// Try to overwrite existing record
auto ret = mStatic.emplace(cell, pathgrid);
if (!ret.second)
ret.first->second = std::move(pathgrid);
return RecordId(ESM::RefId(), isDeleted);
}
size_t Store<ESM::Pathgrid>::getSize() const
{
return mStatic.size();
}
void Store<ESM::Pathgrid>::setUp() {}
const ESM::Pathgrid* Store<ESM::Pathgrid>::search(const ESM::RefId& name) const
{
auto it = mStatic.find(name);
if (it != mStatic.end())
return &(it->second);
return nullptr;
}
const ESM::Pathgrid* Store<ESM::Pathgrid>::find(const ESM::RefId& name) const
{
const ESM::Pathgrid* pathgrid = search(name);
if (pathgrid == nullptr)
throw std::runtime_error("Pathgrid in cell " + name.toDebugString() + " is not found");
return pathgrid;
}
const ESM::Pathgrid* Store<ESM::Pathgrid>::search(const ESM::Cell& cell) const
{
return search(cell.mId);
}
const ESM::Pathgrid* Store<ESM::Pathgrid>::search(const MWWorld::Cell& cellVariant) const
{
return ESM::visit(ESM::VisitOverload{
[&](const ESM::Cell& cell) { return search(cell); },
[&](const ESM4::Cell& cell) -> const ESM::Pathgrid* { return nullptr; },
},
cellVariant);
}
const ESM::Pathgrid* Store<ESM::Pathgrid>::find(const ESM::Cell& cell) const
{
return find(cell.mId);
}
// Skill
//=========================================================================
void Store<ESM::Skill>::setUp(const MWWorld::Store<ESM::GameSetting>& settings)
{
constexpr std::string_view skillValues[ESM::Skill::Length][4] = {
{ "sSkillBlock", "icons\\k\\combat_block.dds", "fWerewolfBlock", {} },
{ "sSkillArmorer", "icons\\k\\combat_armor.dds", "fWerewolfArmorer", {} },
{ "sSkillMediumarmor", "icons\\k\\combat_mediumarmor.dds", "fWerewolfMediumarmor", {} },
{ "sSkillHeavyarmor", "icons\\k\\combat_heavyarmor.dds", "fWerewolfHeavyarmor", {} },
{ "sSkillBluntweapon", "icons\\k\\combat_blunt.dds", "fWerewolfBluntweapon", {} },
{ "sSkillLongblade", "icons\\k\\combat_longblade.dds", "fWerewolfLongblade", {} },
{ "sSkillAxe", "icons\\k\\combat_axe.dds", "fWerewolfAxe", {} },
{ "sSkillSpear", "icons\\k\\combat_spear.dds", "fWerewolfSpear", {} },
{ "sSkillAthletics", "icons\\k\\combat_athletics.dds", "fWerewolfAthletics", {} },
{ "sSkillEnchant", "icons\\k\\magic_enchant.dds", "fWerewolfEnchant", {} },
{ "sSkillDestruction", "icons\\k\\magic_destruction.dds", "fWerewolfDestruction", "destruction" },
{ "sSkillAlteration", "icons\\k\\magic_alteration.dds", "fWerewolfAlteration", "alteration" },
{ "sSkillIllusion", "icons\\k\\magic_illusion.dds", "fWerewolfIllusion", "illusion" },
{ "sSkillConjuration", "icons\\k\\magic_conjuration.dds", "fWerewolfConjuration", "conjuration" },
{ "sSkillMysticism", "icons\\k\\magic_mysticism.dds", "fWerewolfMysticism", "mysticism" },
{ "sSkillRestoration", "icons\\k\\magic_restoration.dds", "fWerewolfRestoration", "restoration" },
{ "sSkillAlchemy", "icons\\k\\magic_alchemy.dds", "fWerewolfAlchemy", {} },
{ "sSkillUnarmored", "icons\\k\\magic_unarmored.dds", "fWerewolfUnarmored", {} },
{ "sSkillSecurity", "icons\\k\\stealth_security.dds", "fWerewolfSecurity", {} },
{ "sSkillSneak", "icons\\k\\stealth_sneak.dds", "fWerewolfSneak", {} },
{ "sSkillAcrobatics", "icons\\k\\stealth_acrobatics.dds", "fWerewolfAcrobatics", {} },
{ "sSkillLightarmor", "icons\\k\\stealth_lightarmor.dds", "fWerewolfLightarmor", {} },
{ "sSkillShortblade", "icons\\k\\stealth_shortblade.dds", "fWerewolfShortblade", {} },
{ "sSkillMarksman", "icons\\k\\stealth_marksman.dds", "fWerewolfMarksman", {} },
// "Mercantile"! >_<
{ "sSkillMercantile", "icons\\k\\stealth_mercantile.dds", "fWerewolfMerchantile", {} },
{ "sSkillSpeechcraft", "icons\\k\\stealth_speechcraft.dds", "fWerewolfSpeechcraft", {} },
{ "sSkillHandtohand", "icons\\k\\stealth_handtohand.dds", "fWerewolfHandtohand", {} },
};
for (ESM::Skill* skill : mShared)
{
int index = ESM::Skill::refIdToIndex(skill->mId);
if (index >= 0)
{
const auto& values = skillValues[index];
skill->mName = getGMSTString(settings, values[0]);
skill->mIcon = values[1];
skill->mWerewolfValue = getGMSTFloat(settings, values[2]);
const auto& school = values[3];
if (!school.empty())
{
if (!skill->mSchool)
skill->mSchool = ESM::MagicSchool{};
const std::string id{ school };
skill->mSchool->mAreaSound = ESM::RefId::stringRefId(id + " area");
skill->mSchool->mBoltSound = ESM::RefId::stringRefId(id + " bolt");
skill->mSchool->mCastSound = ESM::RefId::stringRefId(id + " cast");
skill->mSchool->mFailureSound = ESM::RefId::stringRefId("Spell Failure " + id);
skill->mSchool->mHitSound = ESM::RefId::stringRefId(id + " hit");
const std::string name = "sSchool" + id;
skill->mSchool->mName = getGMSTString(settings, name);
skill->mSchool->mAutoCalcMax = int(getGMSTFloat(settings, "iAutoSpell" + id + "Max"));
}
}
}
}
// Game Settings
//=========================================================================
const ESM::GameSetting* Store<ESM::GameSetting>::search(const ESM::RefId& id) const
{
return TypedDynamicStore::search(id);
}
const ESM::GameSetting* Store<ESM::GameSetting>::find(std::string_view id) const
{
return TypedDynamicStore::find(ESM::RefId::stringRefId(id));
}
const ESM::GameSetting* Store<ESM::GameSetting>::search(std::string_view id) const
{
return TypedDynamicStore::search(ESM::RefId::stringRefId(id));
}
void Store<ESM::GameSetting>::setUp()
{
auto addSetting = [&](const std::string& key, ESM::Variant value) {
auto id = ESM::RefId::stringRefId(key);
ESM::GameSetting setting;
setting.blank();
setting.mId = id;
setting.mValue = std::move(value);
auto [iter, inserted] = mStatic.insert_or_assign(id, std::move(setting));
if (inserted)
mShared.push_back(&iter->second);
};
for (auto& [key, value] : Fallback::Map::getIntFallbackMap())
addSetting(key, ESM::Variant(value));
for (auto& [key, value] : Fallback::Map::getFloatFallbackMap())
addSetting(key, ESM::Variant(value));
for (auto& [key, value] : Fallback::Map::getNonNumericFallbackMap())
addSetting(key, ESM::Variant(value));
TypedDynamicStore<ESM::GameSetting>::setUp();
}
// Magic effect
//=========================================================================
Store<ESM::MagicEffect>::Store() {}
// Attribute
//=========================================================================
void Store<ESM::Attribute>::setUp(const MWWorld::Store<ESM::GameSetting>& settings)
{
insertStatic({ .mId = ESM::Attribute::Strength,
.mName = std::string{ getGMSTString(settings, "sAttributeStrength") },
.mDescription = std::string{ getGMSTString(settings, "sStrDesc") },
.mIcon = "icons\\k\\attribute_strength.dds",
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfStrength") });
insertStatic({ .mId = ESM::Attribute::Intelligence,
.mName = std::string{ getGMSTString(settings, "sAttributeIntelligence") },
.mDescription = std::string{ getGMSTString(settings, "sIntDesc") },
.mIcon = "icons\\k\\attribute_int.dds",
// Oh, Bethesda. It's "Intelligence".
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfIntellegence") });
insertStatic({ .mId = ESM::Attribute::Willpower,
.mName = std::string{ getGMSTString(settings, "sAttributeWillpower") },
.mDescription = std::string{ getGMSTString(settings, "sWilDesc") },
.mIcon = "icons\\k\\attribute_wilpower.dds",
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfWillpower") });
insertStatic({ .mId = ESM::Attribute::Agility,
.mName = std::string{ getGMSTString(settings, "sAttributeAgility") },
.mDescription = std::string{ getGMSTString(settings, "sAgiDesc") },
.mIcon = "icons\\k\\attribute_agility.dds",
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfAgility") });
insertStatic({ .mId = ESM::Attribute::Speed,
.mName = std::string{ getGMSTString(settings, "sAttributeSpeed") },
.mDescription = std::string{ getGMSTString(settings, "sSpdDesc") },
.mIcon = "icons\\k\\attribute_speed.dds",
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfSpeed") });
insertStatic({ .mId = ESM::Attribute::Endurance,
.mName = std::string{ getGMSTString(settings, "sAttributeEndurance") },
.mDescription = std::string{ getGMSTString(settings, "sEndDesc") },
.mIcon = "icons\\k\\attribute_endurance.dds",
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfEndurance") });
insertStatic({ .mId = ESM::Attribute::Personality,
.mName = std::string{ getGMSTString(settings, "sAttributePersonality") },
.mDescription = std::string{ getGMSTString(settings, "sPerDesc") },
.mIcon = "icons\\k\\attribute_personality.dds",
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfPersonality") });
insertStatic({ .mId = ESM::Attribute::Luck,
.mName = std::string{ getGMSTString(settings, "sAttributeLuck") },
.mDescription = std::string{ getGMSTString(settings, "sLucDesc") },
.mIcon = "icons\\k\\attribute_luck.dds",
.mWerewolfValue = getGMSTFloat(settings, "fWerewolfLuck") });
}
// Dialogue
//=========================================================================
Store<ESM::Dialogue>::Store()
: mKeywordSearchModFlag(true)
{
}
void Store<ESM::Dialogue>::setUp()
{
// DialInfos marked as deleted are kept during the loading phase, so that the linked list
// structure is kept intact for inserting further INFOs. Delete them now that loading is done.
for (auto& [_, dial] : mStatic)
dial.setUp();
mShared.clear();
mShared.reserve(mStatic.size());
for (auto& [_, dial] : mStatic)
mShared.push_back(&dial);
// TODO: verify and document this inconsistent behaviour
// TODO: if we require this behaviour, maybe we should move it to the place that requires it
std::sort(mShared.begin(), mShared.end(),
[](const ESM::Dialogue* l, const ESM::Dialogue* r) -> bool { return l->mId < r->mId; });
mKeywordSearchModFlag = true;
}
const ESM::Dialogue* Store<ESM::Dialogue>::search(const ESM::RefId& id) const
{
typename Static::const_iterator it = mStatic.find(id);
if (it != mStatic.end())
return &(it->second);
return nullptr;
}
const ESM::Dialogue* Store<ESM::Dialogue>::find(const ESM::RefId& id) const
{
const ESM::Dialogue* ptr = search(id);
if (ptr == nullptr)
{
std::stringstream msg;
msg << ESM::Dialogue::getRecordType() << " '" << id << "' not found";
throw std::runtime_error(msg.str());
}
return ptr;
}
typename Store<ESM::Dialogue>::iterator Store<ESM::Dialogue>::begin() const
{
return mShared.begin();
}
typename Store<ESM::Dialogue>::iterator Store<ESM::Dialogue>::end() const
{
return mShared.end();
}
size_t Store<ESM::Dialogue>::getSize() const
{
return mShared.size();
}
inline RecordId Store<ESM::Dialogue>::load(ESM::ESMReader& esm)
{
// The original letter case of a dialogue ID is saved, because it's printed
ESM::Dialogue dialogue;
bool isDeleted = false;
dialogue.loadId(esm);
Static::iterator found = mStatic.find(dialogue.mId);
if (found == mStatic.end())
{
dialogue.loadData(esm, isDeleted);
mStatic.emplace(dialogue.mId, dialogue);
}
else
{
found->second.loadData(esm, isDeleted);
dialogue.mId = found->second.mId;
}
mKeywordSearchModFlag = true;
return RecordId(dialogue.mId, isDeleted);
}
bool Store<ESM::Dialogue>::eraseStatic(const ESM::RefId& id)
{
if (eraseFromMap(mStatic, id))
mKeywordSearchModFlag = true;
return true;
}
void Store<ESM::Dialogue>::listIdentifier(std::vector<ESM::RefId>& list) const
{
list.reserve(list.size() + getSize());
for (const auto& dialogue : mShared)
list.push_back(dialogue->mId);
}
const MWDialogue::KeywordSearch<int>& Store<ESM::Dialogue>::getDialogIdKeywordSearch() const
{
if (mKeywordSearchModFlag)
{
mKeywordSearch.clear();
std::vector<std::string> keywordList;
keywordList.reserve(getSize());
for (const auto& it : *this)
keywordList.push_back(Misc::StringUtils::lowerCase(it.mStringId));
sort(keywordList.begin(), keywordList.end());
for (const auto& it : keywordList)
mKeywordSearch.seed(it, 0 /*unused*/);
mKeywordSearchModFlag = false;
}
return mKeywordSearch;
}
// ESM4 Cell
//=========================================================================
const ESM4::Cell* Store<ESM4::Cell>::searchCellName(std::string_view cellName) const
{
const auto foundCell = mCellNameIndex.find(cellName);
if (foundCell == mCellNameIndex.end())
return nullptr;
return foundCell->second;
}
const ESM4::Cell* Store<ESM4::Cell>::searchExterior(ESM::ExteriorCellLocation cellIndex) const
{
const auto foundCell = mExteriors.find(cellIndex);
if (foundCell == mExteriors.end())
return nullptr;
return foundCell->second;
}
ESM4::Cell* Store<ESM4::Cell>::insert(const ESM4::Cell& item, bool overrideOnly)
{
auto cellPtr = TypedDynamicStore<ESM4::Cell>::insert(item, overrideOnly);
insertCell(cellPtr);
return cellPtr;
}
ESM4::Cell* Store<ESM4::Cell>::insertStatic(const ESM4::Cell& item)
{
auto cellPtr = TypedDynamicStore<ESM4::Cell>::insertStatic(item);
insertCell(cellPtr);
return cellPtr;
}
void Store<ESM4::Cell>::insertCell(ESM4::Cell* cellPtr)
{
// Do not index exterior cells with Rec_Persistent flag because they are not real cells.
// References from these cells are merged into normal cells.
if (cellPtr->isExterior() && cellPtr->mFlags & ESM4::Rec_Persistent)
return;
if (!cellPtr->mEditorId.empty())
mCellNameIndex[cellPtr->mEditorId] = cellPtr;
if (cellPtr->isExterior())
mExteriors[ESM::ExteriorCellLocation(cellPtr->mX, cellPtr->mY, cellPtr->mParent)] = cellPtr;
}
void Store<ESM4::Cell>::clearDynamic()
{
for (auto& cellToDeleteIt : mDynamic)
{
ESM4::Cell& cellToDelete = cellToDeleteIt.second;
if (cellToDelete.isExterior())
{
mExteriors.erase({ cellToDelete.mX, cellToDelete.mY, cellToDelete.mParent });
}
if (!cellToDelete.mEditorId.empty())
mCellNameIndex.erase(cellToDelete.mEditorId);
}
MWWorld::TypedDynamicStore<ESM4::Cell>::clearDynamic();
}
// ESM4 Land
//=========================================================================
// Needed to avoid include of ESM4::Land in header
Store<ESM4::Land>::Store() {}
void Store<ESM4::Land>::updateLandPositions(const Store<ESM4::Cell>& cells)
{
for (const auto& [id, value] : mStatic)
{
const ESM4::Cell* cell = cells.find(value.mCell);
mLands[cell->getExteriorCellLocation()] = &value;
}
for (const auto& [id, value] : mDynamic)
{
const ESM4::Cell* cell = cells.find(value.mCell);
mLands[cell->getExteriorCellLocation()] = &value;
}
}
const ESM4::Land* MWWorld::Store<ESM4::Land>::search(ESM::ExteriorCellLocation cellLocation) const
{
auto foundLand = mLands.find(cellLocation);
if (foundLand == mLands.end())
return nullptr;
return foundLand->second;
}
}
template class MWWorld::TypedDynamicStore<ESM::Activator>;
template class MWWorld::TypedDynamicStore<ESM::Apparatus>;
template class MWWorld::TypedDynamicStore<ESM::Armor>;
template class MWWorld::TypedDynamicStore<ESM::Attribute>;
template class MWWorld::TypedDynamicStore<ESM::BirthSign>;
template class MWWorld::TypedDynamicStore<ESM::BodyPart>;
template class MWWorld::TypedDynamicStore<ESM::Book>;
// template class MWWorld::Store<ESM::Cell>;
template class MWWorld::TypedDynamicStore<ESM::Class>;
template class MWWorld::TypedDynamicStore<ESM::Clothing>;
template class MWWorld::TypedDynamicStore<ESM::Container>;
template class MWWorld::TypedDynamicStore<ESM::Creature>;
template class MWWorld::TypedDynamicStore<ESM::CreatureLevList>;
// template class MWWorld::Store<ESM::Dialogue>;
template class MWWorld::TypedDynamicStore<ESM::Door>;
template class MWWorld::TypedDynamicStore<ESM::Enchantment>;
template class MWWorld::TypedDynamicStore<ESM::Faction>;
template class MWWorld::TypedDynamicStore<ESM::GameSetting>;
template class MWWorld::TypedDynamicStore<ESM::Global>;
template class MWWorld::TypedDynamicStore<ESM::Ingredient>;
template class MWWorld::TypedDynamicStore<ESM::ItemLevList>;
// template class MWWorld::Store<ESM::Land>;
// template class MWWorld::Store<ESM::LandTexture>;
template class MWWorld::TypedDynamicStore<ESM::Light>;
template class MWWorld::TypedDynamicStore<ESM::Lockpick>;
// template class MWWorld::Store<ESM::MagicEffect>;
template class MWWorld::TypedDynamicStore<ESM::Miscellaneous>;
template class MWWorld::TypedDynamicStore<ESM::NPC>;
// template class MWWorld::Store<ESM::Pathgrid>;
template class MWWorld::TypedDynamicStore<ESM::Potion>;
template class MWWorld::TypedDynamicStore<ESM::Probe>;
template class MWWorld::TypedDynamicStore<ESM::Race>;
template class MWWorld::TypedDynamicStore<ESM::Region>;
template class MWWorld::TypedDynamicStore<ESM::Repair>;
template class MWWorld::TypedDynamicStore<ESM::Script>;
template class MWWorld::TypedDynamicStore<ESM::Skill>;
template class MWWorld::TypedDynamicStore<ESM::Sound>;
template class MWWorld::TypedDynamicStore<ESM::SoundGenerator>;
template class MWWorld::TypedDynamicStore<ESM::Spell>;
template class MWWorld::TypedDynamicStore<ESM::StartScript>;
template class MWWorld::TypedDynamicStore<ESM::Static>;
template class MWWorld::TypedDynamicStore<ESM::Weapon>;
template class MWWorld::TypedDynamicStore<ESM4::Reference, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::ActorCharacter, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::ActorCreature, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::Activator>;
template class MWWorld::TypedDynamicStore<ESM4::Ammunition>;
template class MWWorld::TypedDynamicStore<ESM4::Armor>;
template class MWWorld::TypedDynamicStore<ESM4::ArmorAddon>;
template class MWWorld::TypedDynamicStore<ESM4::Book>;
template class MWWorld::TypedDynamicStore<ESM4::Cell>;
template class MWWorld::TypedDynamicStore<ESM4::Clothing>;
template class MWWorld::TypedDynamicStore<ESM4::Container>;
template class MWWorld::TypedDynamicStore<ESM4::Creature>;
template class MWWorld::TypedDynamicStore<ESM4::Door>;
template class MWWorld::TypedDynamicStore<ESM4::Flora>;
template class MWWorld::TypedDynamicStore<ESM4::Furniture>;
template class MWWorld::TypedDynamicStore<ESM4::Hair>;
template class MWWorld::TypedDynamicStore<ESM4::HeadPart>;
template class MWWorld::TypedDynamicStore<ESM4::Ingredient>;
template class MWWorld::TypedDynamicStore<ESM4::ItemMod>;
template class MWWorld::TypedDynamicStore<ESM4::Land>;
template class MWWorld::TypedDynamicStore<ESM4::LandTexture>;
template class MWWorld::TypedDynamicStore<ESM4::LevelledCreature>;
template class MWWorld::TypedDynamicStore<ESM4::LevelledItem>;
template class MWWorld::TypedDynamicStore<ESM4::LevelledNpc>;
template class MWWorld::TypedDynamicStore<ESM4::Light>;
template class MWWorld::TypedDynamicStore<ESM4::MiscItem>;
template class MWWorld::TypedDynamicStore<ESM4::MovableStatic>;
template class MWWorld::TypedDynamicStore<ESM4::Npc>;
template class MWWorld::TypedDynamicStore<ESM4::Outfit>;
template class MWWorld::TypedDynamicStore<ESM4::Potion>;
template class MWWorld::TypedDynamicStore<ESM4::Race>;
template class MWWorld::TypedDynamicStore<ESM4::Static>;
template class MWWorld::TypedDynamicStore<ESM4::StaticCollection>;
template class MWWorld::TypedDynamicStore<ESM4::Terminal>;
template class MWWorld::TypedDynamicStore<ESM4::Tree>;
template class MWWorld::TypedDynamicStore<ESM4::Weapon>;
template class MWWorld::TypedDynamicStore<ESM4::World>;
| 51,403
|
C++
|
.cpp
| 1,226
| 32.921697
| 120
| 0.592175
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,280
|
globals.cpp
|
OpenMW_openmw/apps/openmw/mwworld/globals.cpp
|
#include "globals.hpp"
#include <stdexcept>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include "esmstore.hpp"
namespace MWWorld
{
Globals::Collection::const_iterator Globals::find(std::string_view name) const
{
Collection::const_iterator iter = mVariables.find(name);
if (iter == mVariables.end())
throw std::runtime_error("unknown global variable: " + std::string{ name });
return iter;
}
Globals::Collection::iterator Globals::find(std::string_view name)
{
Collection::iterator iter = mVariables.find(name);
if (iter == mVariables.end())
throw std::runtime_error("unknown global variable: " + std::string{ name });
return iter;
}
void Globals::fill(const MWWorld::ESMStore& store)
{
mVariables.clear();
const MWWorld::Store<ESM::Global>& globals = store.get<ESM::Global>();
for (const ESM::Global& esmGlobal : globals)
{
mVariables.emplace(esmGlobal.mId, esmGlobal);
}
}
const ESM::Variant& Globals::operator[](GlobalVariableName name) const
{
return find(name.getValue())->second.mValue;
}
ESM::Variant& Globals::operator[](GlobalVariableName name)
{
return find(name.getValue())->second.mValue;
}
char Globals::getType(GlobalVariableName name) const
{
Collection::const_iterator iter = mVariables.find(name.getValue());
if (iter == mVariables.end())
return ' ';
switch (iter->second.mValue.getType())
{
case ESM::VT_Short:
return 's';
case ESM::VT_Long:
return 'l';
case ESM::VT_Float:
return 'f';
default:
return ' ';
}
}
int Globals::countSavedGameRecords() const
{
return mVariables.size();
}
void Globals::write(ESM::ESMWriter& writer, Loading::Listener& progress) const
{
for (const auto& variable : mVariables)
{
writer.startRecord(ESM::REC_GLOB);
variable.second.save(writer);
writer.endRecord(ESM::REC_GLOB);
}
}
bool Globals::readRecord(ESM::ESMReader& reader, uint32_t type)
{
if (type == ESM::REC_GLOB)
{
ESM::Global global;
bool isDeleted = false;
// This readRecord() method is used when reading a saved game.
// Deleted globals can't appear there, so isDeleted will be ignored here.
global.load(reader, isDeleted);
if (const auto iter = mVariables.find(global.mId); iter != mVariables.end())
iter->second = std::move(global);
return true;
}
return false;
}
}
| 2,854
|
C++
|
.cpp
| 84
| 25.392857
| 88
| 0.59235
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,281
|
actionalchemy.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionalchemy.cpp
|
#include "actionalchemy.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
namespace MWWorld
{
ActionAlchemy::ActionAlchemy(bool force)
: Action(false)
, mForce(force)
{
}
void ActionAlchemy::executeImp(const Ptr& actor)
{
if (actor != MWMechanics::getPlayer())
return;
if (!mForce && MWMechanics::isPlayerInCombat())
{ // Ensure we're not in combat
MWBase::Environment::get().getWindowManager()->messageBox("#{sInventoryMessage3}");
return;
}
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Alchemy);
}
}
| 719
|
C++
|
.cpp
| 23
| 24.956522
| 95
| 0.64058
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,282
|
timestamp.cpp
|
OpenMW_openmw/apps/openmw/mwworld/timestamp.cpp
|
#include "timestamp.hpp"
#include <cmath>
#include <stdexcept>
#include <string>
#include <components/esm3/timestamp.hpp>
#include "duration.hpp"
namespace MWWorld
{
TimeStamp::TimeStamp(float hour, int day)
: mHour(hour)
, mDay(day)
{
if (hour < 0 || hour >= 24)
throw std::runtime_error("invalid time stamp hour: " + std::to_string(hour));
}
float TimeStamp::getHour() const
{
return mHour;
}
int TimeStamp::getDay() const
{
return mDay;
}
TimeStamp& TimeStamp::operator+=(double hours)
{
if (hours < 0)
throw std::runtime_error("can't move time stamp backwards in time");
const Duration duration = Duration::fromHours(mHour + hours);
mHour = duration.getHours();
mDay += duration.getDays();
return *this;
}
bool operator==(const TimeStamp& left, const TimeStamp& right)
{
return left.getHour() == right.getHour() && left.getDay() == right.getDay();
}
bool operator!=(const TimeStamp& left, const TimeStamp& right)
{
return !(left == right);
}
bool operator<(const TimeStamp& left, const TimeStamp& right)
{
if (left.getDay() < right.getDay())
return true;
if (left.getDay() > right.getDay())
return false;
return left.getHour() < right.getHour();
}
bool operator<=(const TimeStamp& left, const TimeStamp& right)
{
return left < right || left == right;
}
bool operator>(const TimeStamp& left, const TimeStamp& right)
{
return !(left <= right);
}
bool operator>=(const TimeStamp& left, const TimeStamp& right)
{
return !(left < right);
}
TimeStamp operator+(const TimeStamp& stamp, double hours)
{
return TimeStamp(stamp) += hours;
}
TimeStamp operator+(double hours, const TimeStamp& stamp)
{
return TimeStamp(stamp) += hours;
}
double operator-(const TimeStamp& left, const TimeStamp& right)
{
if (left < right)
return -(right - left);
int days = left.getDay() - right.getDay();
double hours = 0;
if (left.getHour() < right.getHour())
{
hours = 24 - right.getHour() + left.getHour();
--days;
}
else
{
hours = left.getHour() - right.getHour();
}
return hours + 24 * days;
}
ESM::TimeStamp TimeStamp::toEsm() const
{
ESM::TimeStamp ret;
ret.mDay = mDay;
ret.mHour = mHour;
return ret;
}
TimeStamp::TimeStamp(const ESM::TimeStamp& esm)
{
mDay = esm.mDay;
mHour = esm.mHour;
}
}
| 2,769
|
C++
|
.cpp
| 98
| 21.22449
| 89
| 0.577912
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,283
|
localscripts.cpp
|
OpenMW_openmw/apps/openmw/mwworld/localscripts.cpp
|
#include "localscripts.hpp"
#include <components/debug/debuglog.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadscpt.hpp>
#include "cellstore.hpp"
#include "class.hpp"
#include "containerstore.hpp"
#include "esmstore.hpp"
namespace
{
struct AddScriptsVisitor
{
AddScriptsVisitor(MWWorld::LocalScripts& scripts)
: mScripts(scripts)
{
}
MWWorld::LocalScripts& mScripts;
bool operator()(const MWWorld::Ptr& ptr)
{
if (ptr.mRef->isDeleted())
return true;
const ESM::RefId& script = ptr.getClass().getScript(ptr);
if (!script.empty())
mScripts.add(script, ptr);
return true;
}
};
struct AddContainerItemScriptsVisitor
{
AddContainerItemScriptsVisitor(MWWorld::LocalScripts& scripts)
: mScripts(scripts)
{
}
MWWorld::LocalScripts& mScripts;
bool operator()(const MWWorld::Ptr& containerPtr)
{
// Ignore containers without generated content
if (containerPtr.getType() == ESM::Container::sRecordId
&& containerPtr.getRefData().getCustomData() == nullptr)
return true;
MWWorld::ContainerStore& container = containerPtr.getClass().getContainerStore(containerPtr);
for (const auto& ptr : container)
{
const ESM::RefId& script = ptr.getClass().getScript(ptr);
if (!script.empty())
{
MWWorld::Ptr item = ptr;
item.mCell = containerPtr.getCell();
mScripts.add(script, item);
}
}
return true;
}
};
}
MWWorld::LocalScripts::LocalScripts(const MWWorld::ESMStore& store)
: mStore(store)
{
mIter = mScripts.end();
}
void MWWorld::LocalScripts::startIteration()
{
mIter = mScripts.begin();
}
bool MWWorld::LocalScripts::getNext(std::pair<ESM::RefId, Ptr>& script)
{
if (mIter != mScripts.end())
{
auto iter = mIter++;
script = *iter;
return true;
}
return false;
}
void MWWorld::LocalScripts::add(const ESM::RefId& scriptName, const Ptr& ptr)
{
if (const ESM::Script* script = mStore.get<ESM::Script>().search(scriptName))
{
try
{
ptr.getRefData().setLocals(*script);
for (auto iter = mScripts.begin(); iter != mScripts.end(); ++iter)
if (iter->second == ptr)
{
Log(Debug::Warning) << "Error: tried to add local script twice for " << ptr.getCellRef().getRefId();
remove(ptr);
break;
}
mScripts.emplace_back(scriptName, ptr);
}
catch (const std::exception& exception)
{
Log(Debug::Error) << "failed to add local script " << scriptName
<< " because an exception has been thrown: " << exception.what();
}
}
else
Log(Debug::Warning) << "failed to add local script " << scriptName << " because the script does not exist.";
}
void MWWorld::LocalScripts::addCell(CellStore* cell)
{
AddScriptsVisitor addScriptsVisitor(*this);
cell->forEach(addScriptsVisitor);
AddContainerItemScriptsVisitor addContainerItemScriptsVisitor(*this);
cell->forEachType<ESM::NPC>(addContainerItemScriptsVisitor);
cell->forEachType<ESM::Creature>(addContainerItemScriptsVisitor);
cell->forEachType<ESM::Container>(addContainerItemScriptsVisitor);
}
void MWWorld::LocalScripts::clear()
{
mScripts.clear();
}
void MWWorld::LocalScripts::clearCell(CellStore* cell)
{
auto iter = mScripts.begin();
while (iter != mScripts.end())
{
if (iter->second.mCell == cell)
{
if (iter == mIter)
++mIter;
mScripts.erase(iter++);
}
else
++iter;
}
}
void MWWorld::LocalScripts::remove(const MWWorld::CellRef* ref)
{
for (auto iter = mScripts.begin(); iter != mScripts.end(); ++iter)
if (&(iter->second.getCellRef()) == ref)
{
if (iter == mIter)
++mIter;
mScripts.erase(iter);
break;
}
}
void MWWorld::LocalScripts::remove(const Ptr& ptr)
{
for (auto iter = mScripts.begin(); iter != mScripts.end(); ++iter)
if (iter->second == ptr)
{
if (iter == mIter)
++mIter;
mScripts.erase(iter);
break;
}
}
bool MWWorld::LocalScripts::isRunning(const ESM::RefId& scriptName, const Ptr& ptr) const
{
return std::ranges::find(mScripts, std::pair(scriptName, ptr)) != mScripts.end();
}
| 4,920
|
C++
|
.cpp
| 155
| 23.574194
| 120
| 0.586993
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,284
|
actiontalk.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actiontalk.cpp
|
#include "actiontalk.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
namespace MWWorld
{
ActionTalk::ActionTalk(const Ptr& actor)
: Action(false, actor)
{
}
void ActionTalk::executeImp(const Ptr& actor)
{
if (actor == MWMechanics::getPlayer())
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Dialogue, getTarget());
}
}
| 470
|
C++
|
.cpp
| 16
| 24.875
| 104
| 0.68
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,286
|
cellstore.cpp
|
OpenMW_openmw/apps/openmw/mwworld/cellstore.cpp
|
#include "cellstore.hpp"
#include "magiceffects.hpp"
#include <algorithm>
#include <fstream>
#include <components/debug/debuglog.hpp>
#include <components/esm/format.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/cellstate.hpp>
#include <components/esm3/containerstate.hpp>
#include <components/esm3/creaturelevliststate.hpp>
#include <components/esm3/creaturestate.hpp>
#include <components/esm3/doorstate.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/fogstate.hpp>
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadappa.hpp>
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadbody.hpp>
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadlevlist.hpp>
#include <components/esm3/loadligh.hpp>
#include <components/esm3/loadlock.hpp>
#include <components/esm3/loadmisc.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadprob.hpp>
#include <components/esm3/loadrepa.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/loadweap.hpp>
#include <components/esm3/npcstate.hpp>
#include <components/esm3/objectstate.hpp>
#include <components/esm3/readerscache.hpp>
#include <components/esm4/loadachr.hpp>
#include <components/esm4/loadacti.hpp>
#include <components/esm4/loadalch.hpp>
#include <components/esm4/loadammo.hpp>
#include <components/esm4/loadarmo.hpp>
#include <components/esm4/loadbook.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/esm4/loadclot.hpp>
#include <components/esm4/loadcont.hpp>
#include <components/esm4/loadcrea.hpp>
#include <components/esm4/loaddoor.hpp>
#include <components/esm4/loadflor.hpp>
#include <components/esm4/loadfurn.hpp>
#include <components/esm4/loadimod.hpp>
#include <components/esm4/loadingr.hpp>
#include <components/esm4/loadligh.hpp>
#include <components/esm4/loadmisc.hpp>
#include <components/esm4/loadmstt.hpp>
#include <components/esm4/loadnpc.hpp>
#include <components/esm4/loadrefr.hpp>
#include <components/esm4/loadscol.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadterm.hpp>
#include <components/esm4/loadtree.hpp>
#include <components/esm4/loadweap.hpp>
#include <components/esm4/readerutils.hpp>
#include <components/files/openfile.hpp>
#include <components/misc/tuplehelpers.hpp>
#include <components/resource/resourcesystem.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwmechanics/creaturestats.hpp"
#include "../mwmechanics/recharge.hpp"
#include "../mwmechanics/spellutil.hpp"
#include "class.hpp"
#include "containerstore.hpp"
#include "esmstore.hpp"
#include "inventorystore.hpp"
#include "ptr.hpp"
#include "worldmodel.hpp"
namespace
{
template <typename Record>
struct RecordToState
{
using StateType = ESM::ObjectState;
};
template <>
struct RecordToState<ESM::NPC>
{
using StateType = ESM::NpcState;
};
template <>
struct RecordToState<ESM::Creature>
{
using StateType = ESM::CreatureState;
};
template <>
struct RecordToState<ESM::Door>
{
using StateType = ESM::DoorState;
};
template <>
struct RecordToState<ESM::Container>
{
using StateType = ESM::ContainerState;
};
template <>
struct RecordToState<ESM::CreatureLevList>
{
using StateType = ESM::CreatureLevListState;
};
template <typename T>
MWWorld::Ptr searchInContainerList(MWWorld::CellRefList<T>& containerList, const ESM::RefId& id)
{
for (auto iter(containerList.mList.begin()); iter != containerList.mList.end(); ++iter)
{
MWWorld::Ptr container(&*iter, nullptr);
if (container.getRefData().getCustomData() == nullptr)
continue;
MWWorld::Ptr ptr = container.getClass().getContainerStore(container).search(id);
if (!ptr.isEmpty())
return ptr;
}
return MWWorld::Ptr();
}
template <typename T>
MWWorld::Ptr searchViaActorId(MWWorld::CellRefList<T>& actorList, int actorId, MWWorld::CellStore* cell,
const std::map<MWWorld::LiveCellRefBase*, MWWorld::CellStore*>& toIgnore)
{
for (typename MWWorld::CellRefList<T>::List::iterator iter(actorList.mList.begin());
iter != actorList.mList.end(); ++iter)
{
MWWorld::Ptr actor(&*iter, cell);
if (toIgnore.find(&*iter) != toIgnore.end())
continue;
if (actor.getClass().getCreatureStats(actor).matchesActorId(actorId) && actor.getCellRef().getCount() > 0)
return actor;
}
return MWWorld::Ptr();
}
template <typename T>
void writeReferenceCollection(ESM::ESMWriter& writer, const MWWorld::CellRefList<T>& collection)
{
// references
for (const MWWorld::LiveCellRef<T>& liveCellRef : collection.mList)
{
if (ESM::isESM4Rec(T::sRecordId))
{
// TODO: Implement loading/saving of REFR4 and ACHR4 with ESM3 reader/writer.
continue;
}
if (!liveCellRef.mData.hasChanged() && !liveCellRef.mRef.hasChanged() && liveCellRef.mRef.hasContentFile())
{
// Reference that came from a content file and has not been changed -> ignore
continue;
}
if (liveCellRef.mRef.getCount() == 0 && !liveCellRef.mRef.hasContentFile())
{
// Deleted reference that did not come from a content file -> ignore
continue;
}
using StateType = typename RecordToState<T>::StateType;
StateType state;
liveCellRef.save(state);
// recordId currently unused
writer.writeHNT("OBJE", collection.mList.front().mBase->sRecordId);
state.save(writer);
}
}
template <class RecordType, class T>
void fixRestockingImpl(const T* base, RecordType& state)
{
// Workaround for old saves not containing negative quantities
for (const auto& baseItem : base->mInventory.mList)
{
if (baseItem.mCount < 0)
{
for (auto& item : state.mInventory.mItems)
{
if (item.mRef.mCount > 0 && baseItem.mItem == item.mRef.mRefID)
item.mRef.mCount = -item.mRef.mCount;
}
}
}
}
template <class RecordType, class T>
void fixRestocking(const T* base, RecordType& state)
{
}
template <>
void fixRestocking<>(const ESM::Creature* base, ESM::CreatureState& state)
{
fixRestockingImpl(base, state);
}
template <>
void fixRestocking<>(const ESM::NPC* base, ESM::NpcState& state)
{
fixRestockingImpl(base, state);
}
template <>
void fixRestocking<>(const ESM::Container* base, ESM::ContainerState& state)
{
fixRestockingImpl(base, state);
}
template <typename T>
void readReferenceCollection(ESM::ESMReader& reader, MWWorld::CellRefList<T>& collection, const ESM::CellRef& cref,
const MWWorld::ESMStore& esmStore, MWWorld::CellStore* cellstore)
{
using StateType = typename RecordToState<T>::StateType;
StateType state;
state.mRef = cref;
state.load(reader);
// If the reference came from a content file, make sure this content file is loaded
if (!reader.applyContentFileMapping(state.mRef.mRefNum))
return; // content file has been removed -> skip
if (!MWWorld::LiveCellRef<T>::checkState(state))
return; // not valid anymore with current content files -> skip
const T* record = esmStore.get<T>().search(state.mRef.mRefID);
if (!record)
return;
if (state.mVersion <= ESM::MaxOldRestockingFormatVersion)
fixRestocking(record, state);
if (state.mVersion <= ESM::MaxClearModifiersFormatVersion)
{
if constexpr (std::is_same_v<T, ESM::Creature>)
MWWorld::convertMagicEffects(state.mCreatureStats, state.mInventory);
else if constexpr (std::is_same_v<T, ESM::NPC>)
MWWorld::convertMagicEffects(state.mCreatureStats, state.mInventory, &state.mNpcStats);
}
else if (state.mVersion <= ESM::MaxOldCreatureStatsFormatVersion)
{
if constexpr (std::is_same_v<T, ESM::Creature> || std::is_same_v<T, ESM::NPC>)
{
MWWorld::convertStats(state.mCreatureStats);
MWWorld::convertEnchantmentSlots(state.mCreatureStats, state.mInventory);
}
}
else if (state.mVersion <= ESM::MaxActiveSpellSlotIndexFormatVersion)
{
if constexpr (std::is_same_v<T, ESM::Creature> || std::is_same_v<T, ESM::NPC>)
MWWorld::convertEnchantmentSlots(state.mCreatureStats, state.mInventory);
}
if (state.mRef.mRefNum.hasContentFile())
{
for (typename MWWorld::CellRefList<T>::List::iterator iter(collection.mList.begin());
iter != collection.mList.end(); ++iter)
if (iter->mRef.getRefNum() == state.mRef.mRefNum && iter->mRef.getRefId() == state.mRef.mRefID)
{
// overwrite existing reference
float oldscale = iter->mRef.getScale();
iter->load(state);
const ESM::Position& oldpos = iter->mRef.getPosition();
const ESM::Position& newpos = iter->mData.getPosition();
const MWWorld::Ptr ptr(&*iter, cellstore);
if ((oldscale != iter->mRef.getScale() || oldpos.asVec3() != newpos.asVec3()
|| oldpos.rot[0] != newpos.rot[0] || oldpos.rot[1] != newpos.rot[1]
|| oldpos.rot[2] != newpos.rot[2])
&& !ptr.getClass().isActor())
MWBase::Environment::get().getWorld()->moveObject(ptr, newpos.asVec3());
if (!iter->mData.isEnabled())
{
iter->mData.enable();
MWBase::Environment::get().getWorld()->disable(ptr);
}
MWBase::Environment::get().getWorldModel()->registerPtr(ptr);
return;
}
// Note: we preserve RefNum when picking up or dropping an item. This includes non-carriable lights 'picked
// up' through Lua. So if this RefNum is not found in this cell in content files, it doesn't mean that the
// instance is invalid. But non-storable item are always stored in saves together with their original cell.
// If a non-storable item references a content file, but is not found in this content file,
// we should drop it. Likewise if this stack is empty.
if (!MWWorld::ContainerStore::isStorableType<T>() || !state.mRef.mCount)
{
if (state.mRef.mCount)
Log(Debug::Warning) << "Warning: Dropping reference to " << state.mRef.mRefID
<< " (invalid content file link)";
return;
}
}
// new reference
MWWorld::LiveCellRef<T> ref(ESM::makeBlankCellRef(), record);
ref.load(state);
collection.mList.push_back(std::move(ref));
MWWorld::LiveCellRefBase* base = &collection.mList.back();
MWBase::Environment::get().getWorldModel()->registerPtr(MWWorld::Ptr(base, cellstore));
}
// this function allows us to link a CellRefList<T> to the associated recNameInt, and apply a function
template <typename RecordType, typename Callable>
static void recNameSwitcher(MWWorld::CellRefList<RecordType>& store, ESM::RecNameInts recnNameInt, Callable&& f)
{
if (RecordType::sRecordId == recnNameInt)
{
f(store);
}
}
// helper function for forEachInternal
template <class Visitor, class List>
bool forEachImp(Visitor& visitor, List& list, MWWorld::CellStore* cellStore)
{
for (typename List::List::iterator iter(list.mList.begin()); iter != list.mList.end(); ++iter)
{
if (!MWWorld::CellStore::isAccessible(iter->mData, iter->mRef))
continue;
if (!visitor(MWWorld::Ptr(&*iter, cellStore)))
return false;
}
return true;
}
}
namespace MWWorld
{
namespace
{
template <class T>
bool isEnabled(const T& ref, const ESMStore& store)
{
if (ref.mEsp.parent.isZeroOrUnset())
return true;
// Disable objects that are linked to an initially disabled parent.
// Actually when we will start working on Oblivion/Skyrim scripting we will need to:
// - use the current state of the parent instead of initial state of the parent
// - every time when the parent is enabled/disabled we should also enable/disable
// all objects that are linked to it.
// But for now we assume that the parent remains in its initial state.
if (const ESM4::Reference* parentRef = store.get<ESM4::Reference>().searchStatic(ref.mEsp.parent))
{
const bool parentDisabled = parentRef->mFlags & ESM4::Rec_Disabled;
const bool inversed = ref.mEsp.flags & ESM4::EnableParent::Flag_Inversed;
if (parentDisabled != inversed)
return false;
return isEnabled(*parentRef, store);
}
return true;
}
}
struct CellStoreImp
{
CellStoreTuple mRefLists;
template <typename T>
static void assignStoreToIndex(CellStore& stores, CellRefList<T>& refList)
{
const std::size_t storeIndex = CellStore::getTypeIndex<T>();
if (stores.mCellRefLists.size() <= storeIndex)
stores.mCellRefLists.resize(storeIndex + 1);
assert(&refList == &std::get<CellRefList<T>>(stores.mCellStoreImp->mRefLists));
stores.mCellRefLists[storeIndex] = &refList;
}
// listing only objects owned by this cell. Internal use only, you probably want to use forEach() so that moved
// objects are accounted for.
template <class Visitor>
static bool forEachInternal(Visitor& visitor, MWWorld::CellStore& cellStore)
{
bool returnValue = true;
Misc::tupleForEach(cellStore.mCellStoreImp->mRefLists, [&visitor, &returnValue, &cellStore](auto& store) {
returnValue = returnValue && forEachImp(visitor, store, &cellStore);
});
return returnValue;
}
};
template <typename X>
void CellRefList<X>::load(ESM::CellRef& ref, bool deleted, const MWWorld::ESMStore& esmStore)
{
const MWWorld::Store<X>& store = esmStore.get<X>();
if (const X* ptr = store.search(ref.mRefID))
{
typename std::list<LiveRef>::iterator iter = std::find(mList.begin(), mList.end(), ref.mRefNum);
LiveRef liveCellRef(ref, ptr);
if (deleted)
liveCellRef.mData.setDeletedByContentFile(true);
if (iter != mList.end())
*iter = std::move(liveCellRef);
else
mList.push_back(std::move(liveCellRef));
}
else
{
Log(Debug::Warning) << "Warning: could not resolve cell reference " << ref.mRefID
<< " (dropping reference)";
}
}
static constexpr bool isESM4ActorRec(unsigned int rec)
{
return rec == ESM::REC_NPC_4 || rec == ESM::REC_CREA4;
}
template <typename X, typename R>
static void loadImpl(const R& ref, const MWWorld::ESMStore& esmStore, auto& list)
{
const MWWorld::Store<X>& store = esmStore.get<X>();
const X* ptr = store.search(ref.mBaseObj);
if (!ptr)
{
Log(Debug::Warning) << "Warning: could not resolve cell reference " << ref.mId << " (dropping reference)";
return;
}
LiveCellRef<X> liveCellRef(ref, ptr);
if (!isEnabled(ref, esmStore))
liveCellRef.mData.disable();
list.push_back(std::move(liveCellRef));
}
template <typename X>
void CellRefList<X>::load(const ESM4::Reference& ref, const MWWorld::ESMStore& esmStore)
{
if constexpr (ESM::isESM4Rec(X::sRecordId) && !isESM4ActorRec(X::sRecordId))
loadImpl<X>(ref, esmStore, mList);
}
template <typename X>
void CellRefList<X>::load(const ESM4::ActorCharacter& ref, const MWWorld::ESMStore& esmStore)
{
if constexpr (isESM4ActorRec(X::sRecordId))
loadImpl<X>(ref, esmStore, mList);
}
template <typename X>
bool operator==(const LiveCellRef<X>& ref, int pRefnum)
{
return (ref.mRef.mRefnum == pRefnum);
}
Ptr CellStore::getCurrentPtr(LiveCellRefBase* ref)
{
MovedRefTracker::iterator found = mMovedToAnotherCell.find(ref);
if (found != mMovedToAnotherCell.end())
return Ptr(ref, found->second);
return Ptr(ref, this);
}
void CellStore::moveFrom(const Ptr& object, CellStore* from)
{
if (mState != State_Loaded)
load();
mHasState = true;
MovedRefTracker::iterator found = mMovedToAnotherCell.find(object.getBase());
if (found != mMovedToAnotherCell.end())
{
// A cell we had previously moved an object to is returning it to us.
assert(found->second == from);
mMovedToAnotherCell.erase(found);
}
else
{
mMovedHere.insert(std::make_pair(object.getBase(), from));
}
requestMergedRefsUpdate();
}
MWWorld::Ptr CellStore::moveTo(const Ptr& object, CellStore* cellToMoveTo)
{
if (cellToMoveTo == this)
throw std::runtime_error("moveTo: object is already in this cell");
// We assume that *this is in State_Loaded since we could hardly have reference to a live object otherwise.
if (mState != State_Loaded)
throw std::runtime_error(
"moveTo: can't move object from a non-loaded cell (how did you get this object anyway?)");
MWBase::Environment::get().getWorldModel()->registerPtr(MWWorld::Ptr(object.getBase(), cellToMoveTo));
MovedRefTracker::iterator found = mMovedHere.find(object.getBase());
if (found != mMovedHere.end())
{
// Special case - object didn't originate in this cell
// Move it back to its original cell first
CellStore* originalCell = found->second;
assert(originalCell != this);
originalCell->moveFrom(object, this);
mMovedHere.erase(found);
// Now that object is back to its rightful owner, we can move it
if (cellToMoveTo != originalCell)
{
originalCell->moveTo(object, cellToMoveTo);
}
requestMergedRefsUpdate();
return MWWorld::Ptr(object.getBase(), cellToMoveTo);
}
cellToMoveTo->moveFrom(object, this);
mMovedToAnotherCell.insert(std::make_pair(object.getBase(), cellToMoveTo));
requestMergedRefsUpdate();
return MWWorld::Ptr(object.getBase(), cellToMoveTo);
}
struct MergeVisitor
{
MergeVisitor(std::vector<LiveCellRefBase*>& mergeTo,
const std::map<LiveCellRefBase*, MWWorld::CellStore*>& movedHere,
const std::map<LiveCellRefBase*, MWWorld::CellStore*>& movedToAnotherCell)
: mMergeTo(mergeTo)
, mMovedHere(movedHere)
, mMovedToAnotherCell(movedToAnotherCell)
{
}
bool operator()(const MWWorld::Ptr& ptr)
{
if (mMovedToAnotherCell.find(ptr.getBase()) != mMovedToAnotherCell.end())
return true;
mMergeTo.push_back(ptr.getBase());
return true;
}
void merge()
{
for (const auto& [base, _] : mMovedHere)
mMergeTo.push_back(base);
}
private:
std::vector<LiveCellRefBase*>& mMergeTo;
const std::map<LiveCellRefBase*, MWWorld::CellStore*>& mMovedHere;
const std::map<LiveCellRefBase*, MWWorld::CellStore*>& mMovedToAnotherCell;
};
void CellStore::requestMergedRefsUpdate()
{
mRechargingItemsUpToDate = false;
mMergedRefsNeedsUpdate = true;
}
void CellStore::updateMergedRefs() const
{
mMergedRefs.clear();
MergeVisitor visitor(mMergedRefs, mMovedHere, mMovedToAnotherCell);
CellStoreImp::forEachInternal(visitor, const_cast<CellStore&>(*this));
visitor.merge();
mMergedRefsNeedsUpdate = false;
}
bool CellStore::movedHere(const MWWorld::Ptr& ptr) const
{
if (ptr.isEmpty())
return false;
if (mMovedHere.find(ptr.getBase()) != mMovedHere.end())
return true;
return false;
}
CellStore::CellStore(MWWorld::Cell&& cell, const MWWorld::ESMStore& esmStore, ESM::ReadersCache& readers)
: mStore(esmStore)
, mReaders(readers)
, mCellVariant(std::move(cell))
, mState(State_Unloaded)
, mHasState(false)
, mLastRespawn(0, 0)
, mCellStoreImp(std::make_unique<CellStoreImp>())
, mRechargingItemsUpToDate(false)
{
std::apply([this](auto&... x) { (CellStoreImp::assignStoreToIndex(*this, x), ...); }, mCellStoreImp->mRefLists);
mWaterLevel = mCellVariant.getWaterHeight();
}
CellStore::~CellStore() = default;
const MWWorld::Cell* CellStore::getCell() const
{
return &mCellVariant;
}
CellStore::State CellStore::getState() const
{
return mState;
}
const std::vector<ESM::RefId>& CellStore::getPreloadedIds() const
{
return mIds;
}
bool CellStore::hasState() const
{
return mHasState;
}
bool CellStore::hasId(const ESM::RefId& id) const
{
if (mState == State_Unloaded)
return false;
if (mState == State_Preloaded)
return std::binary_search(mIds.begin(), mIds.end(), id);
return searchConst(id).isEmpty();
}
template <typename PtrType>
struct SearchVisitor
{
PtrType mFound;
const ESM::RefId& mIdToFind;
SearchVisitor(const ESM::RefId& id)
: mIdToFind(id)
{
}
bool operator()(const PtrType& ptr)
{
if (ptr.getCellRef().getRefId() == mIdToFind)
{
mFound = ptr;
return false;
}
return true;
}
};
Ptr CellStore::search(const ESM::RefId& id)
{
SearchVisitor<MWWorld::Ptr> searchVisitor(id);
forEach(searchVisitor);
return searchVisitor.mFound;
}
ConstPtr CellStore::searchConst(const ESM::RefId& id) const
{
SearchVisitor<MWWorld::ConstPtr> searchVisitor(id);
forEachConst(searchVisitor);
return searchVisitor.mFound;
}
Ptr CellStore::searchViaActorId(int id)
{
if (Ptr ptr = ::searchViaActorId(get<ESM::NPC>(), id, this, mMovedToAnotherCell); !ptr.isEmpty())
return ptr;
if (Ptr ptr = ::searchViaActorId(get<ESM::Creature>(), id, this, mMovedToAnotherCell); !ptr.isEmpty())
return ptr;
for (const auto& [base, _] : mMovedHere)
{
MWWorld::Ptr actor(base, this);
if (!actor.getClass().isActor())
continue;
if (actor.getClass().getCreatureStats(actor).matchesActorId(id) && actor.getCellRef().getCount() > 0)
return actor;
}
return Ptr();
}
class RefNumSearchVisitor
{
ESM::RefNum mRefNum;
public:
RefNumSearchVisitor(ESM::RefNum refNum)
: mRefNum(refNum)
{
}
Ptr mFound;
bool operator()(const Ptr& ptr)
{
if (ptr.getCellRef().getRefNum() == mRefNum)
{
mFound = ptr;
return false;
}
return true;
}
};
float CellStore::getWaterLevel() const
{
if (isExterior())
return getCell()->getWaterHeight();
return mWaterLevel;
}
void CellStore::setWaterLevel(float level)
{
mWaterLevel = level;
mHasState = true;
}
std::size_t CellStore::count() const
{
if (mMergedRefsNeedsUpdate)
updateMergedRefs();
return mMergedRefs.size();
}
void CellStore::load()
{
if (mState != State_Loaded)
{
if (mState == State_Preloaded)
mIds.clear();
loadRefs();
mState = State_Loaded;
}
}
void CellStore::preload()
{
if (mState == State_Unloaded)
{
listRefs();
mState = State_Preloaded;
}
}
void CellStore::listRefs(const ESM::Cell& cell)
{
if (cell.mContextList.empty())
return; // this is a dynamically generated cell -> skipping.
// Load references from all plugins that do something with this cell.
for (size_t i = 0; i < cell.mContextList.size(); i++)
{
try
{
// Reopen the ESM reader and seek to the right position.
const std::size_t index = static_cast<std::size_t>(cell.mContextList[i].index);
const ESM::ReadersCache::BusyItem reader = mReaders.get(index);
cell.restore(*reader, i);
ESM::CellRef ref;
// Get each reference in turn
ESM::MovedCellRef cMRef;
bool deleted = false;
bool moved = false;
while (ESM::Cell::getNextRef(
*reader, ref, deleted, cMRef, moved, ESM::Cell::GetNextRefMode::LoadOnlyNotMoved))
{
if (deleted || moved)
continue;
// Don't list reference if it was moved to a different cell.
ESM::MovedCellRefTracker::const_iterator iter
= std::find(cell.mMovedRefs.begin(), cell.mMovedRefs.end(), ref.mRefNum);
if (iter != cell.mMovedRefs.end())
{
continue;
}
mIds.push_back(std::move(ref.mRefID));
}
}
catch (std::exception& e)
{
Log(Debug::Error) << "An error occurred listing references for cell " << getCell()->getDescription()
<< ": " << e.what();
}
}
// List moved references, from separately tracked list.
for (const auto& [ref, deleted] : cell.mLeasedRefs)
{
if (!deleted)
mIds.push_back(ref.mRefID);
}
}
template <typename ReferenceInvocable>
static void visitCell4References(
const ESM4::Cell& cell, const ESMStore& esmStore, ESM::ReadersCache& readers, ReferenceInvocable&& invocable)
{
for (const ESM4::Reference* ref : esmStore.get<ESM4::Reference>().getByCell(cell.mId))
invocable(*ref);
}
template <typename ReferenceInvocable>
static void visitCell4ActorReferences(
const ESM4::Cell& cell, const ESMStore& esmStore, ESM::ReadersCache& readers, ReferenceInvocable&& invocable)
{
for (const ESM4::ActorCharacter* ref : esmStore.get<ESM4::ActorCharacter>().getByCell(cell.mId))
invocable(*ref);
for (const ESM4::ActorCharacter* ref : esmStore.get<ESM4::ActorCreature>().getByCell(cell.mId))
invocable(*ref);
}
void CellStore::listRefs(const ESM4::Cell& cell)
{
visitCell4References(cell, mStore, mReaders, [&](const ESM4::Reference& ref) { mIds.push_back(ref.mBaseObj); });
visitCell4ActorReferences(
cell, mStore, mReaders, [&](const ESM4::ActorCharacter& ref) { mIds.push_back(ref.mBaseObj); });
}
void CellStore::listRefs()
{
ESM::visit([&](auto&& cell) { listRefs(cell); }, mCellVariant);
std::sort(mIds.begin(), mIds.end());
}
void CellStore::loadRefs(const ESM::Cell& cell, std::map<ESM::RefNum, ESM::RefId>& refNumToID)
{
if (cell.mContextList.empty())
return; // this is a dynamically generated cell -> skipping.
// Load references from all plugins that do something with this cell.
for (size_t i = 0; i < cell.mContextList.size(); i++)
{
try
{
// Reopen the ESM reader and seek to the right position.
const std::size_t index = static_cast<std::size_t>(cell.mContextList[i].index);
const ESM::ReadersCache::BusyItem reader = mReaders.get(index);
cell.restore(*reader, i);
ESM::CellRef ref;
// Get each reference in turn
ESM::MovedCellRef cMRef;
bool deleted = false;
bool moved = false;
while (ESM::Cell::getNextRef(
*reader, ref, deleted, cMRef, moved, ESM::Cell::GetNextRefMode::LoadOnlyNotMoved))
{
if (moved)
continue;
// Don't load reference if it was moved to a different cell.
ESM::MovedCellRefTracker::const_iterator iter
= std::find(cell.mMovedRefs.begin(), cell.mMovedRefs.end(), ref.mRefNum);
if (iter != cell.mMovedRefs.end())
{
continue;
}
loadRef(ref, deleted, refNumToID);
}
}
catch (std::exception& e)
{
Log(Debug::Error) << "An error occurred loading references for cell " << getCell()->getDescription()
<< ": " << e.what();
}
}
// Load moved references, from separately tracked list.
for (const auto& leasedRef : cell.mLeasedRefs)
{
ESM::CellRef& ref = const_cast<ESM::CellRef&>(leasedRef.first);
bool deleted = leasedRef.second;
loadRef(ref, deleted, refNumToID);
}
}
void CellStore::loadRefs(const ESM4::Cell& cell, std::map<ESM::RefNum, ESM::RefId>& refNumToID)
{
visitCell4References(cell, mStore, mReaders, [&](const ESM4::Reference& ref) { loadRef(ref); });
visitCell4ActorReferences(cell, mStore, mReaders, [&](const ESM4::ActorCharacter& ref) { loadRef(ref); });
}
void CellStore::loadRefs()
{
std::map<ESM::RefNum, ESM::RefId> refNumToID; // used to detect refID modifications
ESM::visit([&](auto&& cell) { loadRefs(cell, refNumToID); }, mCellVariant);
requestMergedRefsUpdate();
}
bool CellStore::isExterior() const
{
return mCellVariant.isExterior();
}
bool CellStore::isQuasiExterior() const
{
return mCellVariant.isQuasiExterior();
}
Ptr CellStore::searchInContainer(const ESM::RefId& id)
{
bool oldState = mHasState;
mHasState = true;
if (Ptr ptr = searchInContainerList(get<ESM::Container>(), id); !ptr.isEmpty())
return ptr;
if (Ptr ptr = searchInContainerList(get<ESM::Creature>(), id); !ptr.isEmpty())
return ptr;
if (Ptr ptr = searchInContainerList(get<ESM::NPC>(), id); !ptr.isEmpty())
return ptr;
mHasState = oldState;
return Ptr();
}
void CellStore::loadRef(const ESM4::Reference& ref)
{
const MWWorld::ESMStore& store = mStore;
ESM::RecNameInts foundType = static_cast<ESM::RecNameInts>(store.find(ref.mBaseObj));
Misc::tupleForEach(this->mCellStoreImp->mRefLists, [&ref, &store, foundType](auto& x) {
recNameSwitcher(x, foundType, [&ref, &store](auto& storeIn) { storeIn.load(ref, store); });
});
}
void CellStore::loadRef(const ESM4::ActorCharacter& ref)
{
const MWWorld::ESMStore& store = mStore;
ESM::RecNameInts foundType = static_cast<ESM::RecNameInts>(store.find(ref.mBaseObj));
Misc::tupleForEach(this->mCellStoreImp->mRefLists, [&ref, &store, foundType](auto& x) {
recNameSwitcher(x, foundType, [&ref, &store](auto& storeIn) { storeIn.load(ref, store); });
});
}
void CellStore::loadRef(ESM::CellRef& ref, bool deleted, std::map<ESM::RefNum, ESM::RefId>& refNumToID)
{
const MWWorld::ESMStore& store = mStore;
auto it = refNumToID.find(ref.mRefNum);
if (it != refNumToID.end())
{
if (it->second != ref.mRefID)
{
// refID was modified, make sure we don't end up with duplicated refs
ESM::RecNameInts foundType = static_cast<ESM::RecNameInts>(store.find(it->second));
if (foundType != 0)
{
Misc::tupleForEach(this->mCellStoreImp->mRefLists, [&ref, foundType](auto& x) {
recNameSwitcher(x, foundType, [&ref](auto& storeIn) { storeIn.remove(ref.mRefNum); });
});
}
}
}
ESM::RecNameInts foundType = static_cast<ESM::RecNameInts>(store.find(ref.mRefID));
bool handledType = false;
if (foundType != 0)
{
Misc::tupleForEach(
this->mCellStoreImp->mRefLists, [&ref, &deleted, &store, foundType, &handledType](auto& x) {
recNameSwitcher(x, foundType, [&ref, &deleted, &store, &handledType](auto& storeIn) {
handledType = true;
storeIn.load(ref, deleted, store);
});
});
}
else
{
Log(Debug::Error) << "Cell reference " << ref.mRefID << " is not found!";
return;
}
if (!handledType)
{
Log(Debug::Error) << "Error: Ignoring reference " << ref.mRefID << " of unhandled type";
return;
}
refNumToID[ref.mRefNum] = ref.mRefID;
}
void CellStore::loadState(const ESM::CellState& state)
{
mHasState = true;
if (!mCellVariant.isExterior() && mCellVariant.hasWater())
mWaterLevel = state.mWaterLevel;
mLastRespawn = MWWorld::TimeStamp(state.mLastRespawn);
}
void CellStore::saveState(ESM::CellState& state) const
{
state.mId = mCellVariant.getId();
if (!mCellVariant.isExterior() && mCellVariant.hasWater())
state.mWaterLevel = mWaterLevel;
state.mIsInterior = !mCellVariant.isExterior();
state.mHasFogOfWar = (mFogState.get() ? 1 : 0);
state.mLastRespawn = mLastRespawn.toEsm();
}
void CellStore::writeFog(ESM::ESMWriter& writer) const
{
if (mFogState.get())
{
mFogState->save(writer, !mCellVariant.isExterior());
}
}
void CellStore::readFog(ESM::ESMReader& reader)
{
mFogState = std::make_unique<ESM::FogState>();
mFogState->load(reader);
}
void CellStore::writeReferences(ESM::ESMWriter& writer) const
{
Misc::tupleForEach(this->mCellStoreImp->mRefLists,
[&writer](auto& cellRefList) { writeReferenceCollection(writer, cellRefList); });
for (const auto& [base, store] : mMovedToAnotherCell)
{
ESM::RefNum refNum = base->mRef.getRefNum();
if (base->isDeleted() && !refNum.hasContentFile())
continue; // filtered out in writeReferenceCollection
ESM::RefId movedTo = store->getCell()->getId();
writer.writeFormId(refNum, true, "MVRF");
writer.writeCellId(movedTo);
}
}
void CellStore::readReferences(ESM::ESMReader& reader, GetCellStoreCallback* callback)
{
mHasState = true;
while (reader.isNextSub("OBJE"))
{
unsigned int unused;
reader.getHT(unused);
// load the RefID first so we know what type of object it is
ESM::CellRef cref;
cref.loadId(reader, true);
int type = mStore.find(cref.mRefID);
if (type == 0)
{
Log(Debug::Warning) << "Dropping reference to " << cref.mRefID << " (object no longer exists)";
// Skip until the next OBJE or MVRF
while (reader.hasMoreSubs() && !reader.peekNextSub("OBJE") && !reader.peekNextSub("MVRF"))
{
reader.getSubName();
reader.skipHSub();
}
continue;
}
if (type != 0)
{
bool foundCorrespondingStore = false;
Misc::tupleForEach(
this->mCellStoreImp->mRefLists, [&reader, this, &cref, &foundCorrespondingStore, type](auto&& x) {
recNameSwitcher(x, static_cast<ESM::RecNameInts>(type),
[&reader, this, &cref, &foundCorrespondingStore](auto& store) {
foundCorrespondingStore = true;
readReferenceCollection(reader, store, cref, mStore, this);
});
});
if (!foundCorrespondingStore)
throw std::runtime_error("unknown type in cell reference section");
}
}
while (reader.isNextSub("MVRF"))
{
reader.cacheSubName();
ESM::RefNum refnum = reader.getFormId(true, "MVRF");
ESM::RefId movedToId = reader.getCellId();
if (!reader.applyContentFileMapping(refnum))
{
Log(Debug::Warning) << "Warning: Dropping moved ref tag for " << refnum.mIndex
<< " (content file no longer exists)";
continue;
}
// Search for the reference. It might no longer exist if its content file was changed.
Ptr movedRef = MWBase::Environment::get().getWorldModel()->getPtr(refnum);
if (movedRef.isEmpty())
{
Log(Debug::Warning) << "Warning: Dropping moved ref tag for " << refnum.mIndex
<< " (moved object no longer exists)";
continue;
}
CellStore* otherCell = callback->getCellStore(movedToId);
if (otherCell == nullptr)
{
Log(Debug::Warning) << "Warning: Dropping moved ref tag for " << movedRef.getCellRef().getRefId()
<< " (target cell " << movedToId
<< " no longer exists). Reference moved back to its original location.";
// Note by dropping tag the object will automatically re-appear in its original cell, though
// potentially at inapproriate coordinates. Restore original coordinates:
movedRef.getRefData().setPosition(movedRef.getCellRef().getPosition());
continue;
}
if (otherCell == this)
{
// Should never happen unless someone's tampering with files.
Log(Debug::Warning) << "Found invalid moved ref, ignoring";
continue;
}
moveTo(movedRef, otherCell);
}
requestMergedRefsUpdate();
}
void CellStore::setFog(std::unique_ptr<ESM::FogState>&& fog)
{
mFogState = std::move(fog);
}
ESM::FogState* CellStore::getFog() const
{
return mFogState.get();
}
static void clearCorpse(const MWWorld::Ptr& ptr, const ESMStore& store)
{
const MWMechanics::CreatureStats& creatureStats = ptr.getClass().getCreatureStats(ptr);
static const float fCorpseClearDelay
= store.get<ESM::GameSetting>().find("fCorpseClearDelay")->mValue.getFloat();
if (creatureStats.isDead() && creatureStats.isDeathAnimationFinished() && !ptr.getClass().isPersistent(ptr)
&& creatureStats.getTimeOfDeath() + fCorpseClearDelay
<= MWBase::Environment::get().getWorld()->getTimeStamp())
{
MWBase::Environment::get().getWorld()->deleteObject(ptr);
}
}
void CellStore::rest(double hours)
{
if (mState == State_Loaded)
{
for (MWWorld::LiveCellRef<ESM::Creature>& creature : get<ESM::Creature>().mList)
{
Ptr ptr = getCurrentPtr(&creature);
if (!ptr.isEmpty() && ptr.getCellRef().getCount() > 0)
{
MWBase::Environment::get().getMechanicsManager()->restoreDynamicStats(ptr, hours, true);
}
}
for (MWWorld::LiveCellRef<ESM::NPC>& npc : get<ESM::NPC>().mList)
{
Ptr ptr = getCurrentPtr(&npc);
if (!ptr.isEmpty() && ptr.getCellRef().getCount() > 0)
{
MWBase::Environment::get().getMechanicsManager()->restoreDynamicStats(ptr, hours, true);
}
}
}
}
void CellStore::recharge(float duration)
{
if (duration <= 0)
return;
if (mState == State_Loaded)
{
for (MWWorld::LiveCellRef<ESM::Creature>& creature : get<ESM::Creature>().mList)
{
Ptr ptr = getCurrentPtr(&creature);
if (!ptr.isEmpty() && ptr.getCellRef().getCount() > 0)
{
ptr.getClass().getContainerStore(ptr).rechargeItems(duration);
}
}
for (MWWorld::LiveCellRef<ESM::NPC>& npc : get<ESM::NPC>().mList)
{
Ptr ptr = getCurrentPtr(&npc);
if (!ptr.isEmpty() && ptr.getCellRef().getCount() > 0)
{
ptr.getClass().getContainerStore(ptr).rechargeItems(duration);
}
}
for (MWWorld::LiveCellRef<ESM::Container>& container : get<ESM::Container>().mList)
{
Ptr ptr = getCurrentPtr(&container);
if (!ptr.isEmpty() && ptr.getRefData().getCustomData() != nullptr && ptr.getCellRef().getCount() > 0
&& ptr.getClass().getContainerStore(ptr).isResolved())
{
ptr.getClass().getContainerStore(ptr).rechargeItems(duration);
}
}
rechargeItems(duration);
}
}
void CellStore::respawn()
{
if (mState == State_Loaded)
{
static const int iMonthsToRespawn
= mStore.get<ESM::GameSetting>().find("iMonthsToRespawn")->mValue.getInteger();
if (MWBase::Environment::get().getWorld()->getTimeStamp() - mLastRespawn > 24 * 30 * iMonthsToRespawn)
{
mLastRespawn = MWBase::Environment::get().getWorld()->getTimeStamp();
for (CellRefList<ESM::Container>::List::iterator it(get<ESM::Container>().mList.begin());
it != get<ESM::Container>().mList.end(); ++it)
{
Ptr ptr = getCurrentPtr(&*it);
ptr.getClass().respawn(ptr);
}
}
for (CellRefList<ESM::Creature>::List::iterator it(get<ESM::Creature>().mList.begin());
it != get<ESM::Creature>().mList.end(); ++it)
{
Ptr ptr = getCurrentPtr(&*it);
clearCorpse(ptr, mStore);
ptr.getClass().respawn(ptr);
}
for (CellRefList<ESM::NPC>::List::iterator it(get<ESM::NPC>().mList.begin());
it != get<ESM::NPC>().mList.end(); ++it)
{
Ptr ptr = getCurrentPtr(&*it);
clearCorpse(ptr, mStore);
ptr.getClass().respawn(ptr);
}
forEachType<ESM::CreatureLevList>([](Ptr ptr) {
// no need to clearCorpse, handled as part of get<ESM::Creature>()
if (!ptr.mRef->isDeleted())
ptr.getClass().respawn(ptr);
return true;
});
}
}
void MWWorld::CellStore::rechargeItems(float duration)
{
if (!mRechargingItemsUpToDate)
{
updateRechargingItems();
mRechargingItemsUpToDate = true;
}
for (const auto& [item, charge] : mRechargingItems)
{
MWMechanics::rechargeItem(item, charge, duration);
}
}
void MWWorld::CellStore::updateRechargingItems()
{
mRechargingItems.clear();
const auto update = [this](auto& list) {
for (auto& item : list)
{
Ptr ptr = getCurrentPtr(&item);
if (!ptr.isEmpty() && ptr.getCellRef().getCount() > 0)
{
checkItem(ptr);
}
}
};
update(get<ESM::Weapon>().mList);
update(get<ESM::Armor>().mList);
update(get<ESM::Clothing>().mList);
update(get<ESM::Book>().mList);
}
void MWWorld::CellStore::checkItem(const Ptr& ptr)
{
const ESM::RefId& enchantmentId = ptr.getClass().getEnchantment(ptr);
if (enchantmentId.empty())
return;
const ESM::Enchantment* enchantment = mStore.get<ESM::Enchantment>().search(enchantmentId);
if (!enchantment)
{
Log(Debug::Warning) << "Warning: Can't find enchantment " << enchantmentId << " on item "
<< ptr.getCellRef().getRefId();
return;
}
if (enchantment->mData.mType == ESM::Enchantment::WhenUsed
|| enchantment->mData.mType == ESM::Enchantment::WhenStrikes)
mRechargingItems.emplace_back(
ptr.getBase(), static_cast<float>(MWMechanics::getEnchantmentCharge(*enchantment)));
}
Ptr MWWorld::CellStore::getMovedActor(int actorId) const
{
for (const auto& [cellRef, cell] : mMovedToAnotherCell)
{
if (cellRef->mClass->isActor() && cellRef->mData.getCustomData())
{
Ptr actor(cellRef, cell);
if (actor.getClass().getCreatureStats(actor).getActorId() == actorId)
return actor;
}
}
return {};
}
Ptr CellStore::getPtr(ESM::RefId id)
{
if (mState == CellStore::State_Unloaded)
preload();
if (mState == CellStore::State_Preloaded)
{
if (!std::binary_search(mIds.begin(), mIds.end(), id))
return Ptr();
load();
}
Ptr ptr = search(id);
if (!ptr.isEmpty() && isAccessible(ptr.getRefData(), ptr.getCellRef()))
return ptr;
return Ptr();
}
}
| 48,171
|
C++
|
.cpp
| 1,180
| 30.215254
| 120
| 0.581173
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,287
|
manualref.cpp
|
OpenMW_openmw/apps/openmw/mwworld/manualref.cpp
|
#include "manualref.hpp"
#include <components/esm/records.hpp>
#include <components/esm4/loadstat.hpp>
#include "esmstore.hpp"
namespace
{
template <typename T>
void create(const MWWorld::Store<T>& list, const ESM::RefId& name, std::any& refValue, MWWorld::Ptr& ptrValue)
{
const T* base = list.find(name);
ESM::CellRef cellRef;
cellRef.blank();
cellRef.mRefID = name;
refValue = MWWorld::LiveCellRef<T>(cellRef, base);
ptrValue = MWWorld::Ptr(&std::any_cast<MWWorld::LiveCellRef<T>&>(refValue), nullptr);
}
template <typename T>
void create(
const MWWorld::Store<T>& list, const MWWorld::Ptr& templatePtr, std::any& refValue, MWWorld::Ptr& ptrValue)
{
refValue = *static_cast<MWWorld::LiveCellRef<T>*>(templatePtr.getBase());
ptrValue = MWWorld::Ptr(&std::any_cast<MWWorld::LiveCellRef<T>&>(refValue), nullptr);
}
template <typename F>
void visitRefStore(const MWWorld::ESMStore& store, ESM::RefId name, F func)
{
switch (store.find(name))
{
case ESM::REC_ACTI:
return func(store.get<ESM::Activator>());
case ESM::REC_ALCH:
return func(store.get<ESM::Potion>());
case ESM::REC_APPA:
return func(store.get<ESM::Apparatus>());
case ESM::REC_ARMO:
return func(store.get<ESM::Armor>());
case ESM::REC_BOOK:
return func(store.get<ESM::Book>());
case ESM::REC_CLOT:
return func(store.get<ESM::Clothing>());
case ESM::REC_CONT:
return func(store.get<ESM::Container>());
case ESM::REC_CREA:
return func(store.get<ESM::Creature>());
case ESM::REC_DOOR:
return func(store.get<ESM::Door>());
case ESM::REC_INGR:
return func(store.get<ESM::Ingredient>());
case ESM::REC_LEVC:
return func(store.get<ESM::CreatureLevList>());
case ESM::REC_LEVI:
return func(store.get<ESM::ItemLevList>());
case ESM::REC_LIGH:
return func(store.get<ESM::Light>());
case ESM::REC_LOCK:
return func(store.get<ESM::Lockpick>());
case ESM::REC_MISC:
return func(store.get<ESM::Miscellaneous>());
case ESM::REC_NPC_:
return func(store.get<ESM::NPC>());
case ESM::REC_PROB:
return func(store.get<ESM::Probe>());
case ESM::REC_REPA:
return func(store.get<ESM::Repair>());
case ESM::REC_STAT:
return func(store.get<ESM::Static>());
case ESM::REC_WEAP:
return func(store.get<ESM::Weapon>());
case ESM::REC_BODY:
return func(store.get<ESM::BodyPart>());
case ESM::REC_STAT4:
return func(store.get<ESM4::Static>());
case ESM::REC_TERM4:
return func(store.get<ESM4::Terminal>());
case 0:
throw std::logic_error(
"failed to create manual cell ref for " + name.toDebugString() + " (unknown ID)");
default:
throw std::logic_error(
"failed to create manual cell ref for " + name.toDebugString() + " (unknown type)");
}
}
}
MWWorld::ManualRef::ManualRef(const MWWorld::ESMStore& store, const ESM::RefId& name, const int count)
{
auto cb = [&](const auto& store) { create(store, name, mRef, mPtr); };
visitRefStore(store, name, cb);
mPtr.getCellRef().setCount(count);
}
MWWorld::ManualRef::ManualRef(const ESMStore& store, const Ptr& template_, const int count)
{
auto cb = [&](const auto& store) { create(store, template_, mRef, mPtr); };
visitRefStore(store, template_.getCellRef().getRefId(), cb);
mPtr.getCellRef().setCount(count);
mPtr.getCellRef().unsetRefNum();
mPtr.getRefData().setLuaScripts(nullptr);
}
| 4,093
|
C++
|
.cpp
| 97
| 31.628866
| 115
| 0.567269
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,288
|
actionteleport.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionteleport.cpp
|
#include "actionteleport.hpp"
#include <components/esm3/loadcell.hpp>
#include <components/esm3/loadmgef.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwmechanics/creaturestats.hpp"
#include "../mwworld/cellstore.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/worldmodel.hpp"
#include "player.hpp"
namespace MWWorld
{
ActionTeleport::ActionTeleport(ESM::RefId cellId, const ESM::Position& position, bool teleportFollowers)
: Action(true)
, mCellId(cellId)
, mPosition(position)
, mTeleportFollowers(teleportFollowers)
{
}
void ActionTeleport::executeImp(const Ptr& actor)
{
if (mTeleportFollowers)
{
// Find any NPCs that are following the actor and teleport them with him
std::set<MWWorld::Ptr> followers;
bool toExterior = MWBase::Environment::get().getWorldModel()->getCell(mCellId).isExterior();
getFollowers(actor, followers, toExterior, true);
for (std::set<MWWorld::Ptr>::iterator it = followers.begin(); it != followers.end(); ++it)
teleport(*it);
}
teleport(actor);
}
void ActionTeleport::teleport(const Ptr& actor)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
MWWorld::WorldModel* worldModel = MWBase::Environment::get().getWorldModel();
auto& stats = actor.getClass().getCreatureStats(actor);
stats.land(actor == world->getPlayerPtr());
stats.setTeleported(true);
Ptr teleported;
if (actor == world->getPlayerPtr())
{
world->getPlayer().setTeleported(true);
world->changeToCell(mCellId, mPosition, true);
teleported = world->getPlayerPtr();
}
else
{
if (actor.getClass().getCreatureStats(actor).getAiSequence().isInCombat(world->getPlayerPtr()))
{
actor.getClass().getCreatureStats(actor).getAiSequence().stopCombat();
return;
}
else
teleported = world->moveObject(actor, &worldModel->getCell(mCellId), mPosition.asVec3(), true, true);
}
if (!world->isWaterWalkingCastableOnTarget(teleported) && MWMechanics::hasWaterWalking(teleported))
teleported.getClass()
.getCreatureStats(teleported)
.getActiveSpells()
.purgeEffect(actor, ESM::MagicEffect::WaterWalking);
MWBase::Environment::get().getLuaManager()->objectTeleported(teleported);
}
void ActionTeleport::getFollowers(
const MWWorld::Ptr& actor, std::set<MWWorld::Ptr>& out, bool toExterior, bool includeHostiles)
{
std::set<MWWorld::Ptr> followers;
MWBase::Environment::get().getMechanicsManager()->getActorsFollowing(actor, followers);
for (std::set<MWWorld::Ptr>::iterator it = followers.begin(); it != followers.end(); ++it)
{
MWWorld::Ptr follower = *it;
const ESM::RefId& script = follower.getClass().getScript(follower);
if (!includeHostiles && follower.getClass().getCreatureStats(follower).getAiSequence().isInCombat(actor))
continue;
if (!toExterior && !script.empty()
&& follower.getRefData().getLocals().getIntVar(script, "stayoutside") == 1
&& follower.getCell()->getCell()->isExterior())
continue;
if ((follower.getRefData().getPosition().asVec3() - actor.getRefData().getPosition().asVec3()).length2()
> 800 * 800)
continue;
out.emplace(follower);
}
}
}
| 3,851
|
C++
|
.cpp
| 88
| 34.477273
| 117
| 0.627472
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,289
|
weather.cpp
|
OpenMW_openmw/apps/openmw/mwworld/weather.cpp
|
#include "weather.hpp"
#include <components/settings/values.hpp>
#include <components/misc/rng.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm3/weatherstate.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwsound/sound.hpp"
#include "../mwrender/renderingmanager.hpp"
#include "../mwrender/sky.hpp"
#include "cellstore.hpp"
#include "esmstore.hpp"
#include "player.hpp"
#include <algorithm>
#include <cmath>
namespace MWWorld
{
namespace
{
static const int invalidWeatherID = -1;
// linear interpolate between x and y based on factor.
float lerp(float x, float y, float factor)
{
return x * (1 - factor) + y * factor;
}
// linear interpolate between x and y based on factor.
osg::Vec4f lerp(const osg::Vec4f& x, const osg::Vec4f& y, float factor)
{
return x * (1 - factor) + y * factor;
}
osg::Vec3f calculateStormDirection(const std::string& particleEffect)
{
osg::Vec3f stormDirection = MWWorld::Weather::defaultDirection();
if (particleEffect == Settings::models().mWeatherashcloud.get()
|| particleEffect == Settings::models().mWeatherblightcloud.get())
{
osg::Vec3f playerPos = MWMechanics::getPlayer().getRefData().getPosition().asVec3();
playerPos.z() = 0;
osg::Vec3f redMountainPos = osg::Vec3f(25000.f, 70000.f, 0.f);
stormDirection = (playerPos - redMountainPos);
stormDirection.normalize();
}
return stormDirection;
}
}
template <typename T>
T TimeOfDayInterpolator<T>::getValue(
const float gameHour, const TimeOfDaySettings& timeSettings, const std::string& prefix) const
{
WeatherSetting setting = timeSettings.getSetting(prefix);
float preSunriseTime = setting.mPreSunriseTime;
float postSunriseTime = setting.mPostSunriseTime;
float preSunsetTime = setting.mPreSunsetTime;
float postSunsetTime = setting.mPostSunsetTime;
// night
if (gameHour < timeSettings.mNightEnd - preSunriseTime || gameHour > timeSettings.mNightStart + postSunsetTime)
return mNightValue;
// sunrise
else if (gameHour >= timeSettings.mNightEnd - preSunriseTime
&& gameHour <= timeSettings.mDayStart + postSunriseTime)
{
float duration = timeSettings.mDayStart + postSunriseTime - timeSettings.mNightEnd + preSunriseTime;
float middle = timeSettings.mNightEnd - preSunriseTime + duration / 2.f;
if (gameHour <= middle)
{
// fade in
float advance = middle - gameHour;
float factor = 0.f;
if (duration > 0)
factor = advance / duration * 2;
return lerp(mSunriseValue, mNightValue, factor);
}
else
{
// fade out
float advance = gameHour - middle;
float factor = 1.f;
if (duration > 0)
factor = advance / duration * 2;
return lerp(mSunriseValue, mDayValue, factor);
}
}
// day
else if (gameHour > timeSettings.mDayStart + postSunriseTime && gameHour < timeSettings.mDayEnd - preSunsetTime)
return mDayValue;
// sunset
else if (gameHour >= timeSettings.mDayEnd - preSunsetTime
&& gameHour <= timeSettings.mNightStart + postSunsetTime)
{
float duration = timeSettings.mNightStart + postSunsetTime - timeSettings.mDayEnd + preSunsetTime;
float middle = timeSettings.mDayEnd - preSunsetTime + duration / 2.f;
if (gameHour <= middle)
{
// fade in
float advance = middle - gameHour;
float factor = 0.f;
if (duration > 0)
factor = advance / duration * 2;
return lerp(mSunsetValue, mDayValue, factor);
}
else
{
// fade out
float advance = gameHour - middle;
float factor = 1.f;
if (duration > 0)
factor = advance / duration * 2;
return lerp(mSunsetValue, mNightValue, factor);
}
}
// shut up compiler
return T();
}
template class MWWorld::TimeOfDayInterpolator<float>;
template class MWWorld::TimeOfDayInterpolator<osg::Vec4f>;
osg::Vec3f Weather::defaultDirection()
{
static const osg::Vec3f direction = osg::Vec3f(0.f, 1.f, 0.f);
return direction;
}
Weather::Weather(const std::string& name, float stormWindSpeed, float rainSpeed, float dlFactor, float dlOffset,
const std::string& particleEffect)
: mCloudTexture(Fallback::Map::getString("Weather_" + name + "_Cloud_Texture"))
, mSkyColor(Fallback::Map::getColour("Weather_" + name + "_Sky_Sunrise_Color"),
Fallback::Map::getColour("Weather_" + name + "_Sky_Day_Color"),
Fallback::Map::getColour("Weather_" + name + "_Sky_Sunset_Color"),
Fallback::Map::getColour("Weather_" + name + "_Sky_Night_Color"))
, mFogColor(Fallback::Map::getColour("Weather_" + name + "_Fog_Sunrise_Color"),
Fallback::Map::getColour("Weather_" + name + "_Fog_Day_Color"),
Fallback::Map::getColour("Weather_" + name + "_Fog_Sunset_Color"),
Fallback::Map::getColour("Weather_" + name + "_Fog_Night_Color"))
, mAmbientColor(Fallback::Map::getColour("Weather_" + name + "_Ambient_Sunrise_Color"),
Fallback::Map::getColour("Weather_" + name + "_Ambient_Day_Color"),
Fallback::Map::getColour("Weather_" + name + "_Ambient_Sunset_Color"),
Fallback::Map::getColour("Weather_" + name + "_Ambient_Night_Color"))
, mSunColor(Fallback::Map::getColour("Weather_" + name + "_Sun_Sunrise_Color"),
Fallback::Map::getColour("Weather_" + name + "_Sun_Day_Color"),
Fallback::Map::getColour("Weather_" + name + "_Sun_Sunset_Color"),
Fallback::Map::getColour("Weather_" + name + "_Sun_Night_Color"))
, mLandFogDepth(Fallback::Map::getFloat("Weather_" + name + "_Land_Fog_Day_Depth"),
Fallback::Map::getFloat("Weather_" + name + "_Land_Fog_Day_Depth"),
Fallback::Map::getFloat("Weather_" + name + "_Land_Fog_Day_Depth"),
Fallback::Map::getFloat("Weather_" + name + "_Land_Fog_Night_Depth"))
, mSunDiscSunsetColor(Fallback::Map::getColour("Weather_" + name + "_Sun_Disc_Sunset_Color"))
, mWindSpeed(Fallback::Map::getFloat("Weather_" + name + "_Wind_Speed"))
, mCloudSpeed(Fallback::Map::getFloat("Weather_" + name + "_Cloud_Speed"))
, mGlareView(Fallback::Map::getFloat("Weather_" + name + "_Glare_View"))
, mIsStorm(mWindSpeed > stormWindSpeed)
, mRainSpeed(rainSpeed)
, mRainEntranceSpeed(Fallback::Map::getFloat("Weather_" + name + "_Rain_Entrance_Speed"))
, mRainMaxRaindrops(Fallback::Map::getFloat("Weather_" + name + "_Max_Raindrops"))
, mRainDiameter(Fallback::Map::getFloat("Weather_" + name + "_Rain_Diameter"))
, mRainThreshold(Fallback::Map::getFloat("Weather_" + name + "_Rain_Threshold"))
, mRainMinHeight(Fallback::Map::getFloat("Weather_" + name + "_Rain_Height_Min"))
, mRainMaxHeight(Fallback::Map::getFloat("Weather_" + name + "_Rain_Height_Max"))
, mParticleEffect(particleEffect)
, mRainEffect(Fallback::Map::getBool("Weather_" + name + "_Using_Precip") ? "meshes\\raindrop.nif" : "")
, mStormDirection(Weather::defaultDirection())
, mCloudsMaximumPercent(Fallback::Map::getFloat("Weather_" + name + "_Clouds_Maximum_Percent"))
, mTransitionDelta(Fallback::Map::getFloat("Weather_" + name + "_Transition_Delta"))
, mThunderFrequency(Fallback::Map::getFloat("Weather_" + name + "_Thunder_Frequency"))
, mThunderThreshold(Fallback::Map::getFloat("Weather_" + name + "_Thunder_Threshold"))
, mFlashDecrement(Fallback::Map::getFloat("Weather_" + name + "_Flash_Decrement"))
, mFlashBrightness(0.0f)
{
mDL.FogFactor = dlFactor;
mDL.FogOffset = dlOffset;
mThunderSoundID[0]
= ESM::RefId::stringRefId(Fallback::Map::getString("Weather_" + name + "_Thunder_Sound_ID_0"));
mThunderSoundID[1]
= ESM::RefId::stringRefId(Fallback::Map::getString("Weather_" + name + "_Thunder_Sound_ID_1"));
mThunderSoundID[2]
= ESM::RefId::stringRefId(Fallback::Map::getString("Weather_" + name + "_Thunder_Sound_ID_2"));
mThunderSoundID[3]
= ESM::RefId::stringRefId(Fallback::Map::getString("Weather_" + name + "_Thunder_Sound_ID_3"));
if (!mRainEffect.empty()) // NOTE: in vanilla, the weathers with rain seem to be hardcoded; changing
// Using_Precip has no effect
{
mRainLoopSoundID
= ESM::RefId::stringRefId(Fallback::Map::getString("Weather_" + name + "_Rain_Loop_Sound_ID"));
if (mRainLoopSoundID.empty()) // default to "rain" if not set
mRainLoopSoundID = ESM::RefId::stringRefId("rain");
else if (mRainLoopSoundID == "None")
mRainLoopSoundID = ESM::RefId();
}
mAmbientLoopSoundID
= ESM::RefId::stringRefId(Fallback::Map::getString("Weather_" + name + "_Ambient_Loop_Sound_ID"));
if (mAmbientLoopSoundID == "None")
mAmbientLoopSoundID = ESM::RefId();
}
float Weather::transitionDelta() const
{
// Transition Delta describes how quickly transitioning to the weather in question will take, in Hz. Note that
// the measurement is in real time, not in-game time.
return mTransitionDelta;
}
float Weather::cloudBlendFactor(const float transitionRatio) const
{
// Clouds Maximum Percent affects how quickly the sky transitions from one sky texture to the next.
return transitionRatio / mCloudsMaximumPercent;
}
float Weather::calculateThunder(const float transitionRatio, const float elapsedSeconds, const bool isPaused)
{
// When paused, the flash brightness remains the same and no new strikes can occur.
if (!isPaused)
{
// Morrowind doesn't appear to do any calculations unless the transition ratio is higher than the Thunder
// Threshold.
if (transitionRatio >= mThunderThreshold && mThunderFrequency > 0.0f)
{
flashDecrement(elapsedSeconds);
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
if (Misc::Rng::rollProbability(prng) <= thunderChance(transitionRatio, elapsedSeconds))
{
lightningAndThunder();
}
}
else
{
mFlashBrightness = 0.0f;
}
}
return mFlashBrightness;
}
inline void Weather::flashDecrement(const float elapsedSeconds)
{
// The Flash Decrement is measured in whole units per second. This means that if the flash brightness was
// currently 1.0, then it should take approximately 0.25 seconds to decay to 0.0 (the minimum).
float decrement = mFlashDecrement * elapsedSeconds;
mFlashBrightness = decrement > mFlashBrightness ? 0.0f : mFlashBrightness - decrement;
}
inline float Weather::thunderChance(const float transitionRatio, const float elapsedSeconds) const
{
// This formula is reversed from the observation that with Thunder Frequency set to 1, there are roughly 10
// strikes per minute. It doesn't appear to be tied to in game time as Timescale doesn't affect it. Various
// values of Thunder Frequency seem to change the average number of strikes in a linear fashion.. During a
// transition, it appears to scaled based on how far past it is past the Thunder Threshold.
float scaleFactor = (transitionRatio - mThunderThreshold) / (1.0f - mThunderThreshold);
return ((mThunderFrequency * 10.0f) / 60.0f) * elapsedSeconds * scaleFactor;
}
inline void Weather::lightningAndThunder(void)
{
// Morrowind seems to vary the intensity of the brightness based on which of the four sound IDs it selects.
// They appear to go from 0 (brightest, closest) to 3 (faintest, farthest). The value of 0.25 per distance
// was derived by setting the Flash Decrement to 0.1 and measuring how long each value took to decay to 0.
// TODO: Determine the distribution of each distance to see if it's evenly weighted.
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
unsigned int distance = Misc::Rng::rollDice(4, prng);
// Flash brightness appears additive, since if multiple strikes occur, it takes longer for it to decay to 0.
mFlashBrightness += 1 - (distance * 0.25f);
MWBase::Environment::get().getSoundManager()->playSound(mThunderSoundID[distance], 1.0, 1.0);
}
RegionWeather::RegionWeather(const ESM::Region& region)
: mWeather(invalidWeatherID)
, mChances(region.mData.mProbabilities.begin(), region.mData.mProbabilities.end())
{
}
RegionWeather::RegionWeather(const ESM::RegionWeatherState& state)
: mWeather(state.mWeather)
, mChances(state.mChances)
{
}
RegionWeather::operator ESM::RegionWeatherState() const
{
ESM::RegionWeatherState state = { mWeather, mChances };
return state;
}
void RegionWeather::setChances(const std::vector<uint8_t>& chances)
{
mChances = chances;
// Regional weather no longer supports the current type, select a new weather pattern.
if ((static_cast<size_t>(mWeather) >= mChances.size()) || (mChances[mWeather] == 0))
{
chooseNewWeather();
}
}
void RegionWeather::setWeather(int weatherID)
{
mWeather = weatherID;
}
int RegionWeather::getWeather()
{
// If the region weather was already set (by ChangeWeather, or by a previous call) then just return that value.
// Note that the region weather will be expired periodically when the weather update timer expires.
if (mWeather == invalidWeatherID)
{
chooseNewWeather();
}
return mWeather;
}
void RegionWeather::chooseNewWeather()
{
// All probabilities must add to 100 (responsibility of the user).
// If chances A and B has values 30 and 70 then by generating 100 numbers 1..100, 30% will be lesser or equal 30
// and 70% will be greater than 30 (in theory).
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
unsigned int chance = static_cast<unsigned int>(Misc::Rng::rollDice(100, prng) + 1); // 1..100
unsigned int sum = 0;
for (size_t i = 0; i < mChances.size(); ++i)
{
sum += mChances[i];
if (chance <= sum)
{
mWeather = static_cast<int>(i);
return;
}
}
// if we hit this path then the chances don't add to 100, choose a default weather instead
mWeather = 0;
}
MoonModel::MoonModel(const std::string& name)
: mFadeInStart(Fallback::Map::getFloat("Moons_" + name + "_Fade_In_Start"))
, mFadeInFinish(Fallback::Map::getFloat("Moons_" + name + "_Fade_In_Finish"))
, mFadeOutStart(Fallback::Map::getFloat("Moons_" + name + "_Fade_Out_Start"))
, mFadeOutFinish(Fallback::Map::getFloat("Moons_" + name + "_Fade_Out_Finish"))
, mAxisOffset(Fallback::Map::getFloat("Moons_" + name + "_Axis_Offset"))
, mSpeed(Fallback::Map::getFloat("Moons_" + name + "_Speed"))
, mDailyIncrement(Fallback::Map::getFloat("Moons_" + name + "_Daily_Increment"))
, mFadeStartAngle(Fallback::Map::getFloat("Moons_" + name + "_Fade_Start_Angle"))
, mFadeEndAngle(Fallback::Map::getFloat("Moons_" + name + "_Fade_End_Angle"))
, mMoonShadowEarlyFadeAngle(Fallback::Map::getFloat("Moons_" + name + "_Moon_Shadow_Early_Fade_Angle"))
{
// Morrowind appears to have a minimum speed in order to avoid situations where the moon couldn't conceivably
// complete a rotation in a single 24 hour period. The value of 180/23 was deduced from reverse engineering.
mSpeed = std::min(mSpeed, 180.0f / 23.0f);
}
MWRender::MoonState MoonModel::calculateState(const TimeStamp& gameTime) const
{
float rotationFromHorizon = angle(gameTime);
MWRender::MoonState state = { rotationFromHorizon,
mAxisOffset, // Reverse engineered from Morrowind's scene graph rotation matrices.
phase(gameTime), shadowBlend(rotationFromHorizon),
earlyMoonShadowAlpha(rotationFromHorizon) * hourlyAlpha(gameTime.getHour()) };
return state;
}
inline float MoonModel::angle(const TimeStamp& gameTime) const
{
// Morrowind's moons start travel on one side of the horizon (let's call it H-rise) and travel 180 degrees to
// the opposite horizon (let's call it H-set). Upon reaching H-set, they reset to H-rise until the next moon
// rise.
// When calculating the angle of the moon, several cases have to be taken into account:
// 1. Moon rises and then sets in one day.
// 2. Moon sets and doesn't rise in one day (occurs when the moon rise hour is >= 24).
// 3. Moon sets and then rises in one day.
float moonRiseHourToday = moonRiseHour(gameTime.getDay());
float moonRiseAngleToday = 0;
if (gameTime.getHour() < moonRiseHourToday)
{
float moonRiseHourYesterday = moonRiseHour(gameTime.getDay() - 1);
if (moonRiseHourYesterday < 24)
{
float moonRiseAngleYesterday = rotation(24 - moonRiseHourYesterday);
if (moonRiseAngleYesterday < 180)
{
// The moon rose but did not set yesterday, so accumulate yesterday's angle with how much we've
// travelled today.
moonRiseAngleToday = rotation(gameTime.getHour()) + moonRiseAngleYesterday;
}
}
}
else
{
moonRiseAngleToday = rotation(gameTime.getHour() - moonRiseHourToday);
}
if (moonRiseAngleToday >= 180)
{
// The moon set today, reset the angle to the horizon.
moonRiseAngleToday = 0;
}
return moonRiseAngleToday;
}
inline float MoonModel::moonRiseHour(unsigned int daysPassed) const
{
// This arises from the start date of 16 Last Seed, 427
// TODO: Find an alternate formula that doesn't rely on this day being fixed.
static const unsigned int startDay = 16;
// This odd formula arises from the fact that on 16 Last Seed, 17 increments have occurred, meaning
// that upon starting a new game, it must only calculate the moon phase as far back as 1 Last Seed.
// Note that we don't modulo after adding the latest daily increment because other calculations need to
// know if doing so would cause the moon rise to be postponed until the next day (which happens when
// the moon rise hour is >= 24 in Morrowind).
return mDailyIncrement + std::fmod((daysPassed - 1 + startDay) * mDailyIncrement, 24.0f);
}
inline float MoonModel::rotation(float hours) const
{
// 15 degrees per hour was reverse engineered from the rotation matrices of the Morrowind scene graph.
// Note that this correlates to 360 / 24, which is a full rotation every 24 hours, so speed is a measure
// of whole rotations that could be completed in a day.
return 15.0f * mSpeed * hours;
}
MWRender::MoonState::Phase MoonModel::phase(const TimeStamp& gameTime) const
{
// Morrowind starts with a full moon on 16 Last Seed and then begins to wane 17 Last Seed, working on 3 day
// phase cycle.
// If the moon didn't rise yet today, use yesterday's moon phase.
if (gameTime.getHour() < moonRiseHour(gameTime.getDay()))
return static_cast<MWRender::MoonState::Phase>((gameTime.getDay() / 3) % 8);
else
return static_cast<MWRender::MoonState::Phase>(((gameTime.getDay() + 1) / 3) % 8);
}
inline float MoonModel::shadowBlend(float angle) const
{
// The Fade End Angle and Fade Start Angle describe a region where the moon transitions from a solid disk
// that is roughly the color of the sky, to a textured surface.
// Depending on the current angle, the following values describe the ratio between the textured moon
// and the solid disk:
// 1. From Fade End Angle 1 to Fade Start Angle 1 (during moon rise): 0..1
// 2. From Fade Start Angle 1 to Fade Start Angle 2 (between moon rise and moon set): 1 (textured)
// 3. From Fade Start Angle 2 to Fade End Angle 2 (during moon set): 1..0
// 4. From Fade End Angle 2 to Fade End Angle 1 (between moon set and moon rise): 0 (solid disk)
float fadeAngle = mFadeStartAngle - mFadeEndAngle;
float fadeEndAngle2 = 180.0f - mFadeEndAngle;
float fadeStartAngle2 = 180.0f - mFadeStartAngle;
if ((angle >= mFadeEndAngle) && (angle < mFadeStartAngle))
return (angle - mFadeEndAngle) / fadeAngle;
else if ((angle >= mFadeStartAngle) && (angle < fadeStartAngle2))
return 1.0f;
else if ((angle >= fadeStartAngle2) && (angle < fadeEndAngle2))
return (fadeEndAngle2 - angle) / fadeAngle;
else
return 0.0f;
}
inline float MoonModel::hourlyAlpha(float gameHour) const
{
// The Fade Out Start / Finish and Fade In Start / Finish describe the hours at which the moon
// appears and disappears.
// Depending on the current hour, the following values describe how transparent the moon is.
// 1. From Fade Out Start to Fade Out Finish: 1..0
// 2. From Fade Out Finish to Fade In Start: 0 (transparent)
// 3. From Fade In Start to Fade In Finish: 0..1
// 4. From Fade In Finish to Fade Out Start: 1 (solid)
if ((gameHour >= mFadeOutStart) && (gameHour < mFadeOutFinish))
return (mFadeOutFinish - gameHour) / (mFadeOutFinish - mFadeOutStart);
else if ((gameHour >= mFadeOutFinish) && (gameHour < mFadeInStart))
return 0.0f;
else if ((gameHour >= mFadeInStart) && (gameHour < mFadeInFinish))
return (gameHour - mFadeInStart) / (mFadeInFinish - mFadeInStart);
else
return 1.0f;
}
inline float MoonModel::earlyMoonShadowAlpha(float angle) const
{
// The Moon Shadow Early Fade Angle describes an arc relative to Fade End Angle.
// Depending on the current angle, the following values describe how transparent the moon is.
// 1. From Moon Shadow Early Fade Angle 1 to Fade End Angle 1 (during moon rise): 0..1
// 2. From Fade End Angle 1 to Fade End Angle 2 (between moon rise and moon set): 1 (solid)
// 3. From Fade End Angle 2 to Moon Shadow Early Fade Angle 2 (during moon set): 1..0
// 4. From Moon Shadow Early Fade Angle 2 to Moon Shadow Early Fade Angle 1: 0 (transparent)
float moonShadowEarlyFadeAngle1 = mFadeEndAngle - mMoonShadowEarlyFadeAngle;
float fadeEndAngle2 = 180.0f - mFadeEndAngle;
float moonShadowEarlyFadeAngle2 = fadeEndAngle2 + mMoonShadowEarlyFadeAngle;
if ((angle >= moonShadowEarlyFadeAngle1) && (angle < mFadeEndAngle))
return (angle - moonShadowEarlyFadeAngle1) / mMoonShadowEarlyFadeAngle;
else if ((angle >= mFadeEndAngle) && (angle < fadeEndAngle2))
return 1.0f;
else if ((angle >= fadeEndAngle2) && (angle < moonShadowEarlyFadeAngle2))
return (moonShadowEarlyFadeAngle2 - angle) / mMoonShadowEarlyFadeAngle;
else
return 0.0f;
}
WeatherManager::WeatherManager(MWRender::RenderingManager& rendering, MWWorld::ESMStore& store)
: mStore(store)
, mRendering(rendering)
, mSunriseTime(Fallback::Map::getFloat("Weather_Sunrise_Time"))
, mSunsetTime(Fallback::Map::getFloat("Weather_Sunset_Time"))
, mSunriseDuration(Fallback::Map::getFloat("Weather_Sunrise_Duration"))
, mSunsetDuration(Fallback::Map::getFloat("Weather_Sunset_Duration"))
, mSunPreSunsetTime(Fallback::Map::getFloat("Weather_Sun_Pre-Sunset_Time"))
, mNightFade(0, 0, 0, 1)
, mHoursBetweenWeatherChanges(Fallback::Map::getFloat("Weather_Hours_Between_Weather_Changes"))
, mRainSpeed(Fallback::Map::getFloat("Weather_Precip_Gravity"))
, mUnderwaterFog(Fallback::Map::getFloat("Water_UnderwaterSunriseFog"),
Fallback::Map::getFloat("Water_UnderwaterDayFog"), Fallback::Map::getFloat("Water_UnderwaterSunsetFog"),
Fallback::Map::getFloat("Water_UnderwaterNightFog"))
, mWeatherSettings()
, mMasser("Masser")
, mSecunda("Secunda")
, mWindSpeed(0.f)
, mCurrentWindSpeed(0.f)
, mNextWindSpeed(0.f)
, mIsStorm(false)
, mPrecipitation(false)
, mStormDirection(Weather::defaultDirection())
, mCurrentRegion()
, mTimePassed(0)
, mFastForward(false)
, mWeatherUpdateTime(mHoursBetweenWeatherChanges)
, mTransitionFactor(0)
, mNightDayMode(Default)
, mCurrentWeather(0)
, mNextWeather(0)
, mQueuedWeather(0)
, mRegions()
, mResult()
{
mTimeSettings.mNightStart = mSunsetTime + mSunsetDuration;
mTimeSettings.mNightEnd = mSunriseTime;
mTimeSettings.mDayStart = mSunriseTime + mSunriseDuration;
mTimeSettings.mDayEnd = mSunsetTime;
mTimeSettings.addSetting("Sky");
mTimeSettings.addSetting("Ambient");
mTimeSettings.addSetting("Fog");
mTimeSettings.addSetting("Sun");
// Morrowind handles stars settings differently for other ones
mTimeSettings.mStarsPostSunsetStart = Fallback::Map::getFloat("Weather_Stars_Post-Sunset_Start");
mTimeSettings.mStarsPreSunriseFinish = Fallback::Map::getFloat("Weather_Stars_Pre-Sunrise_Finish");
mTimeSettings.mStarsFadingDuration = Fallback::Map::getFloat("Weather_Stars_Fading_Duration");
WeatherSetting starSetting = { mTimeSettings.mStarsPreSunriseFinish,
mTimeSettings.mStarsFadingDuration - mTimeSettings.mStarsPreSunriseFinish,
mTimeSettings.mStarsPostSunsetStart,
mTimeSettings.mStarsFadingDuration - mTimeSettings.mStarsPostSunsetStart };
mTimeSettings.mSunriseTransitions["Stars"] = starSetting;
mWeatherSettings.reserve(10);
// These distant land fog factor and offset values are the defaults MGE XE provides. Should be
// provided by settings somewhere?
addWeather("Clear", 1.0f, 0.0f); // 0
addWeather("Cloudy", 0.9f, 0.0f); // 1
addWeather("Foggy", 0.2f, 30.0f); // 2
addWeather("Overcast", 0.7f, 0.0f); // 3
addWeather("Rain", 0.5f, 10.0f); // 4
addWeather("Thunderstorm", 0.5f, 20.0f); // 5
addWeather("Ashstorm", 0.2f, 50.0f, Settings::models().mWeatherashcloud.get()); // 6
addWeather("Blight", 0.2f, 60.0f, Settings::models().mWeatherblightcloud.get()); // 7
addWeather("Snow", 0.5f, 40.0f, Settings::models().mWeathersnow.get()); // 8
addWeather("Blizzard", 0.16f, 70.0f, Settings::models().mWeatherblizzard.get()); // 9
Store<ESM::Region>::iterator it = store.get<ESM::Region>().begin();
for (; it != store.get<ESM::Region>().end(); ++it)
{
mRegions.insert(std::make_pair(it->mId, RegionWeather(*it)));
}
forceWeather(0);
}
WeatherManager::~WeatherManager()
{
stopSounds();
}
void WeatherManager::changeWeather(const ESM::RefId& regionID, const unsigned int weatherID)
{
// In Morrowind, this seems to have the following behavior, when applied to the current region:
// - When there is no transition in progress, start transitioning to the new weather.
// - If there is a transition in progress, queue up the transition and process it when the current one
// completes.
// - If there is a transition in progress, and a queued transition, overwrite the queued transition.
// - If multiple calls to ChangeWeather are made while paused (console up), only the last call will be used,
// meaning that if there was no transition in progress, only the last ChangeWeather will be processed.
// If the region isn't current, Morrowind will store the new weather for the region in question.
if (weatherID < mWeatherSettings.size())
{
auto it = mRegions.find(regionID);
if (it != mRegions.end())
{
it->second.setWeather(weatherID);
regionalWeatherChanged(it->first, it->second);
}
}
}
void WeatherManager::modRegion(const ESM::RefId& regionID, const std::vector<uint8_t>& chances)
{
// Sets the region's probability for various weather patterns. Note that this appears to be saved permanently.
// In Morrowind, this seems to have the following behavior when applied to the current region:
// - If the region supports the current weather, no change in current weather occurs.
// - If the region no longer supports the current weather, and there is no transition in progress, begin to
// transition to a new supported weather type.
// - If the region no longer supports the current weather, and there is a transition in progress, queue a
// transition to a new supported weather type.
auto it = mRegions.find(regionID);
if (it != mRegions.end())
{
it->second.setChances(chances);
regionalWeatherChanged(it->first, it->second);
}
}
void WeatherManager::playerTeleported(const ESM::RefId& playerRegion, bool isExterior)
{
// If the player teleports to an outdoors cell in a new region (for instance, by travelling), the weather needs
// to be changed immediately, and any transitions for the previous region discarded.
{
auto it = mRegions.find(playerRegion);
if (it != mRegions.end() && playerRegion != mCurrentRegion)
{
mCurrentRegion = playerRegion;
forceWeather(it->second.getWeather());
}
}
}
float WeatherManager::calculateWindSpeed(int weatherId, float currentSpeed)
{
float targetSpeed = std::min(8.0f * mWeatherSettings[weatherId].mWindSpeed, 70.f);
if (currentSpeed == 0.f)
currentSpeed = targetSpeed;
float multiplier = mWeatherSettings[weatherId].mRainEffect.empty() ? 1.f : 0.5f;
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
float updatedSpeed = (Misc::Rng::rollClosedProbability(prng) - 0.5f) * multiplier * targetSpeed + currentSpeed;
if (updatedSpeed > 0.5f * targetSpeed && updatedSpeed < 2.f * targetSpeed)
currentSpeed = updatedSpeed;
return currentSpeed;
}
void WeatherManager::update(float duration, bool paused, const TimeStamp& time, bool isExterior)
{
MWWorld::ConstPtr player = MWMechanics::getPlayer();
if (!paused || mFastForward)
{
// Add new transitions when either the player's current external region changes.
if (updateWeatherTime() || updateWeatherRegion(player.getCell()->getCell()->getRegion()))
{
auto it = mRegions.find(mCurrentRegion);
if (it != mRegions.end())
{
addWeatherTransition(it->second.getWeather());
}
}
updateWeatherTransitions(duration);
}
bool isDay = time.getHour() >= mSunriseTime && time.getHour() <= mTimeSettings.mNightStart;
if (isExterior && !isDay)
mNightDayMode = ExteriorNight;
else if (!isExterior && isDay && mWeatherSettings[mCurrentWeather].mGlareView >= 0.5f)
mNightDayMode = InteriorDay;
else
mNightDayMode = Default;
if (!isExterior)
{
mRendering.setSkyEnabled(false);
stopSounds();
mWindSpeed = 0.f;
mCurrentWindSpeed = 0.f;
mNextWindSpeed = 0.f;
return;
}
calculateWeatherResult(time.getHour(), duration, paused);
if (!paused)
{
mWindSpeed = mResult.mWindSpeed;
mCurrentWindSpeed = mResult.mCurrentWindSpeed;
mNextWindSpeed = mResult.mNextWindSpeed;
}
mIsStorm = mResult.mIsStorm;
// For some reason Ash Storm is not considered as a precipitation weather in game
mPrecipitation = !(mResult.mParticleEffect.empty() && mResult.mRainEffect.empty())
&& mResult.mParticleEffect != Settings::models().mWeatherashcloud.get();
mStormDirection = calculateStormDirection(mResult.mParticleEffect);
mRendering.getSkyManager()->setStormParticleDirection(mStormDirection);
// disable sun during night
if (time.getHour() >= mTimeSettings.mNightStart || time.getHour() <= mSunriseTime)
mRendering.getSkyManager()->sunDisable();
else
mRendering.getSkyManager()->sunEnable();
// Update the sun direction. Run it east to west at a fixed angle from overhead.
// The sun's speed at day and night may differ, since mSunriseTime and mNightStart
// mark when the sun is level with the horizon.
{
// Shift times into a 24-hour window beginning at mSunriseTime...
float adjustedHour = time.getHour();
float adjustedNightStart = mTimeSettings.mNightStart;
if (time.getHour() < mSunriseTime)
adjustedHour += 24.f;
if (mTimeSettings.mNightStart < mSunriseTime)
adjustedNightStart += 24.f;
const bool is_night = adjustedHour >= adjustedNightStart;
const float dayDuration = adjustedNightStart - mSunriseTime;
const float nightDuration = 24.f - dayDuration;
float orbit;
if (!is_night)
{
float t = (adjustedHour - mSunriseTime) / dayDuration;
orbit = 1.f - 2.f * t;
}
else
{
float t = (adjustedHour - adjustedNightStart) / nightDuration;
orbit = 2.f * t - 1.f;
}
// Hardcoded constant from Morrowind
const osg::Vec3f sunDir(-400.f * orbit, 75.f, -100.f);
mRendering.setSunDirection(sunDir);
mRendering.setNight(is_night);
}
float underwaterFog = mUnderwaterFog.getValue(time.getHour(), mTimeSettings, "Fog");
float peakHour = mSunriseTime + (mTimeSettings.mNightStart - mSunriseTime) / 2;
float glareFade = 1.f;
if (time.getHour() < mSunriseTime || time.getHour() > mTimeSettings.mNightStart)
glareFade = 0.f;
else if (time.getHour() < peakHour)
glareFade = 1.f - (peakHour - time.getHour()) / (peakHour - mSunriseTime);
else
glareFade = 1.f - (time.getHour() - peakHour) / (mTimeSettings.mNightStart - peakHour);
mRendering.getSkyManager()->setGlareTimeOfDayFade(glareFade);
mRendering.getSkyManager()->setMasserState(mMasser.calculateState(time));
mRendering.getSkyManager()->setSecundaState(mSecunda.calculateState(time));
mRendering.configureFog(
mResult.mFogDepth, underwaterFog, mResult.mDLFogFactor, mResult.mDLFogOffset / 100.0f, mResult.mFogColor);
mRendering.setAmbientColour(mResult.mAmbientColor);
mRendering.setSunColour(mResult.mSunColor, mResult.mSunColor, mResult.mGlareView * glareFade);
mRendering.getSkyManager()->setWeather(mResult);
// Play sounds
if (mPlayingAmbientSoundID != mResult.mAmbientLoopSoundID)
{
if (mAmbientSound)
{
MWBase::Environment::get().getSoundManager()->stopSound(mAmbientSound);
mAmbientSound = nullptr;
}
if (!mResult.mAmbientLoopSoundID.empty())
mAmbientSound = MWBase::Environment::get().getSoundManager()->playSound(mResult.mAmbientLoopSoundID,
mResult.mAmbientSoundVolume, 1.0, MWSound::Type::Sfx, MWSound::PlayMode::Loop);
mPlayingAmbientSoundID = mResult.mAmbientLoopSoundID;
}
else if (mAmbientSound)
mAmbientSound->setVolume(mResult.mAmbientSoundVolume);
if (mPlayingRainSoundID != mResult.mRainLoopSoundID)
{
if (mRainSound)
{
MWBase::Environment::get().getSoundManager()->stopSound(mRainSound);
mRainSound = nullptr;
}
if (!mResult.mRainLoopSoundID.empty())
mRainSound = MWBase::Environment::get().getSoundManager()->playSound(mResult.mRainLoopSoundID,
mResult.mAmbientSoundVolume, 1.0, MWSound::Type::Sfx, MWSound::PlayMode::Loop);
mPlayingRainSoundID = mResult.mRainLoopSoundID;
}
else if (mRainSound)
mRainSound->setVolume(mResult.mAmbientSoundVolume);
}
void WeatherManager::stopSounds()
{
MWBase::SoundManager* sndMgr = MWBase::Environment::get().getSoundManager();
if (mAmbientSound)
{
sndMgr->stopSound(mAmbientSound);
mAmbientSound = nullptr;
}
mPlayingAmbientSoundID = ESM::RefId();
if (mRainSound)
{
sndMgr->stopSound(mRainSound);
mRainSound = nullptr;
}
mPlayingRainSoundID = ESM::RefId();
for (ESM::RefId soundId : mWeatherSettings[mCurrentWeather].mThunderSoundID)
if (!soundId.empty() && sndMgr->getSoundPlaying(MWWorld::ConstPtr(), soundId))
sndMgr->stopSound3D(MWWorld::ConstPtr(), soundId);
if (inTransition())
for (ESM::RefId soundId : mWeatherSettings[mNextWeather].mThunderSoundID)
if (!soundId.empty() && sndMgr->getSoundPlaying(MWWorld::ConstPtr(), soundId))
sndMgr->stopSound3D(MWWorld::ConstPtr(), soundId);
}
float WeatherManager::getWindSpeed() const
{
return mWindSpeed;
}
bool WeatherManager::isInStorm() const
{
return mIsStorm;
}
osg::Vec3f WeatherManager::getStormDirection() const
{
return mStormDirection;
}
void WeatherManager::advanceTime(double hours, bool incremental)
{
// In Morrowind, when the player sleeps/waits, serves jail time, travels, or trains, all weather transitions are
// immediately applied, regardless of whatever transition time might have been remaining.
mTimePassed += hours;
mFastForward = !incremental ? true : mFastForward;
}
NightDayMode WeatherManager::getNightDayMode() const
{
return mNightDayMode;
}
bool WeatherManager::useTorches(float hour) const
{
bool isDark = hour < mSunriseTime || hour > mTimeSettings.mNightStart;
return isDark && !mPrecipitation;
}
float WeatherManager::getSunPercentage(float hour) const
{
if (hour <= mTimeSettings.mNightEnd || hour >= mTimeSettings.mNightStart)
return 0.f;
else if (hour <= mTimeSettings.mDayStart)
return (hour - mTimeSettings.mNightEnd) / mSunriseDuration;
else if (hour > mTimeSettings.mDayEnd)
return 1.f - ((hour - mTimeSettings.mDayEnd) / mSunsetDuration);
return 1.f;
}
float WeatherManager::getSunVisibility() const
{
if (inTransition() && mTransitionFactor < mWeatherSettings[mNextWeather].mCloudsMaximumPercent)
{
float t = mTransitionFactor / mWeatherSettings[mNextWeather].mCloudsMaximumPercent;
return (1.f - t) * mWeatherSettings[mCurrentWeather].mGlareView
+ t * mWeatherSettings[mNextWeather].mGlareView;
}
return mWeatherSettings[mCurrentWeather].mGlareView;
}
void WeatherManager::write(ESM::ESMWriter& writer, Loading::Listener& progress)
{
ESM::WeatherState state;
state.mCurrentRegion = mCurrentRegion;
state.mTimePassed = mTimePassed;
state.mFastForward = mFastForward;
state.mWeatherUpdateTime = mWeatherUpdateTime;
state.mTransitionFactor = mTransitionFactor;
state.mCurrentWeather = mCurrentWeather;
state.mNextWeather = mNextWeather;
state.mQueuedWeather = mQueuedWeather;
auto it = mRegions.begin();
for (; it != mRegions.end(); ++it)
{
state.mRegions.insert(std::make_pair(it->first, it->second));
}
writer.startRecord(ESM::REC_WTHR);
state.save(writer);
writer.endRecord(ESM::REC_WTHR);
}
bool WeatherManager::readRecord(ESM::ESMReader& reader, uint32_t type)
{
if (ESM::REC_WTHR == type)
{
ESM::WeatherState state;
state.load(reader);
std::swap(mCurrentRegion, state.mCurrentRegion);
mTimePassed = state.mTimePassed;
mFastForward = state.mFastForward;
mWeatherUpdateTime = state.mWeatherUpdateTime;
mTransitionFactor = state.mTransitionFactor;
mCurrentWeather = state.mCurrentWeather;
mNextWeather = state.mNextWeather;
mQueuedWeather = state.mQueuedWeather;
mRegions.clear();
importRegions();
for (auto it = state.mRegions.begin(); it != state.mRegions.end(); ++it)
{
auto found = mRegions.find(it->first);
if (found != mRegions.end())
{
found->second = RegionWeather(it->second);
}
}
return true;
}
return false;
}
void WeatherManager::clear()
{
stopSounds();
mCurrentRegion = ESM::RefId();
mTimePassed = 0.0f;
mWeatherUpdateTime = 0.0f;
forceWeather(0);
mRegions.clear();
importRegions();
}
inline void WeatherManager::addWeather(
const std::string& name, float dlFactor, float dlOffset, const std::string& particleEffect)
{
static const float fStromWindSpeed = mStore.get<ESM::GameSetting>().find("fStromWindSpeed")->mValue.getFloat();
Weather weather(name, fStromWindSpeed, mRainSpeed, dlFactor, dlOffset, particleEffect);
mWeatherSettings.push_back(weather);
}
inline void WeatherManager::importRegions()
{
for (const ESM::Region& region : mStore.get<ESM::Region>())
{
mRegions.insert(std::make_pair(region.mId, RegionWeather(region)));
}
}
inline void WeatherManager::regionalWeatherChanged(const ESM::RefId& regionID, RegionWeather& region)
{
// If the region is current, then add a weather transition for it.
MWWorld::ConstPtr player = MWMechanics::getPlayer();
if (player.isInCell())
{
if (regionID == mCurrentRegion)
{
addWeatherTransition(region.getWeather());
}
}
}
inline bool WeatherManager::updateWeatherTime()
{
mWeatherUpdateTime -= mTimePassed;
mTimePassed = 0.0f;
if (mWeatherUpdateTime <= 0.0f)
{
// Expire all regional weather, so that any call to getWeather() will return a new weather ID.
auto it = mRegions.begin();
for (; it != mRegions.end(); ++it)
{
it->second.setWeather(invalidWeatherID);
}
mWeatherUpdateTime += mHoursBetweenWeatherChanges;
return true;
}
return false;
}
inline bool WeatherManager::updateWeatherRegion(const ESM::RefId& playerRegion)
{
if (!playerRegion.empty() && playerRegion != mCurrentRegion)
{
mCurrentRegion = playerRegion;
return true;
}
return false;
}
inline void WeatherManager::updateWeatherTransitions(const float elapsedRealSeconds)
{
// When a player chooses to train, wait, or serves jail time, any transitions will be fast forwarded to the last
// weather type set, regardless of the remaining transition time.
if (!mFastForward && inTransition())
{
const float delta = mWeatherSettings[mNextWeather].transitionDelta();
mTransitionFactor -= elapsedRealSeconds * delta;
if (mTransitionFactor <= 0.0f)
{
mCurrentWeather = mNextWeather;
mNextWeather = mQueuedWeather;
mQueuedWeather = invalidWeatherID;
// We may have begun processing the queued transition, so we need to apply the remaining time towards
// it.
if (inTransition())
{
const float newDelta = mWeatherSettings[mNextWeather].transitionDelta();
const float remainingSeconds = -(mTransitionFactor / delta);
mTransitionFactor = 1.0f - (remainingSeconds * newDelta);
}
else
{
mTransitionFactor = 0.0f;
}
}
}
else
{
if (mQueuedWeather != invalidWeatherID)
{
mCurrentWeather = mQueuedWeather;
}
else if (mNextWeather != invalidWeatherID)
{
mCurrentWeather = mNextWeather;
}
mNextWeather = invalidWeatherID;
mQueuedWeather = invalidWeatherID;
mFastForward = false;
}
}
inline void WeatherManager::forceWeather(const int weatherID)
{
mTransitionFactor = 0.0f;
mCurrentWeather = weatherID;
mNextWeather = invalidWeatherID;
mQueuedWeather = invalidWeatherID;
}
inline bool WeatherManager::inTransition() const
{
return mNextWeather != invalidWeatherID;
}
inline void WeatherManager::addWeatherTransition(const int weatherID)
{
// In order to work like ChangeWeather expects, this method begins transitioning to the new weather immediately
// if no transition is in progress, otherwise it queues it to be transitioned.
assert(weatherID >= 0 && static_cast<size_t>(weatherID) < mWeatherSettings.size());
if (!inTransition() && (weatherID != mCurrentWeather))
{
mNextWeather = weatherID;
mTransitionFactor = 1.0f;
}
else if (inTransition() && (weatherID != mNextWeather))
{
mQueuedWeather = weatherID;
}
}
inline void WeatherManager::calculateWeatherResult(
const float gameHour, const float elapsedSeconds, const bool isPaused)
{
float flash = 0.0f;
if (!inTransition())
{
calculateResult(mCurrentWeather, gameHour);
flash = mWeatherSettings[mCurrentWeather].calculateThunder(1.0f, elapsedSeconds, isPaused);
}
else
{
calculateTransitionResult(1 - mTransitionFactor, gameHour);
float currentFlash
= mWeatherSettings[mCurrentWeather].calculateThunder(mTransitionFactor, elapsedSeconds, isPaused);
float nextFlash
= mWeatherSettings[mNextWeather].calculateThunder(1 - mTransitionFactor, elapsedSeconds, isPaused);
flash = currentFlash + nextFlash;
}
osg::Vec4f flashColor(flash, flash, flash, 0.0f);
mResult.mFogColor += flashColor;
mResult.mAmbientColor += flashColor;
mResult.mSunColor += flashColor;
}
inline void WeatherManager::calculateResult(const int weatherID, const float gameHour)
{
const Weather& current = mWeatherSettings[weatherID];
mResult.mCloudTexture = current.mCloudTexture;
mResult.mCloudBlendFactor = 0;
mResult.mNextWindSpeed = 0;
mResult.mWindSpeed = mResult.mCurrentWindSpeed = calculateWindSpeed(weatherID, mWindSpeed);
mResult.mBaseWindSpeed = mWeatherSettings[weatherID].mWindSpeed;
mResult.mCloudSpeed = current.mCloudSpeed;
mResult.mGlareView = current.mGlareView;
mResult.mAmbientLoopSoundID = current.mAmbientLoopSoundID;
mResult.mRainLoopSoundID = current.mRainLoopSoundID;
mResult.mAmbientSoundVolume = 1.f;
mResult.mPrecipitationAlpha = 1.f;
mResult.mIsStorm = current.mIsStorm;
mResult.mRainSpeed = current.mRainSpeed;
mResult.mRainEntranceSpeed = current.mRainEntranceSpeed;
mResult.mRainDiameter = current.mRainDiameter;
mResult.mRainMinHeight = current.mRainMinHeight;
mResult.mRainMaxHeight = current.mRainMaxHeight;
mResult.mRainMaxRaindrops = current.mRainMaxRaindrops;
mResult.mParticleEffect = current.mParticleEffect;
mResult.mRainEffect = current.mRainEffect;
mResult.mNight = (gameHour < mSunriseTime
|| gameHour
> mTimeSettings.mNightStart + mTimeSettings.mStarsPostSunsetStart - mTimeSettings.mStarsFadingDuration);
mResult.mFogDepth = current.mLandFogDepth.getValue(gameHour, mTimeSettings, "Fog");
mResult.mFogColor = current.mFogColor.getValue(gameHour, mTimeSettings, "Fog");
mResult.mAmbientColor = current.mAmbientColor.getValue(gameHour, mTimeSettings, "Ambient");
mResult.mSunColor = current.mSunColor.getValue(gameHour, mTimeSettings, "Sun");
mResult.mSkyColor = current.mSkyColor.getValue(gameHour, mTimeSettings, "Sky");
mResult.mNightFade = mNightFade.getValue(gameHour, mTimeSettings, "Stars");
mResult.mDLFogFactor = current.mDL.FogFactor;
mResult.mDLFogOffset = current.mDL.FogOffset;
WeatherSetting setting = mTimeSettings.getSetting("Sun");
float preSunsetTime = setting.mPreSunsetTime;
if (gameHour >= mTimeSettings.mDayEnd - preSunsetTime)
{
float factor = 1.f;
if (preSunsetTime > 0)
factor = (gameHour - (mTimeSettings.mDayEnd - preSunsetTime)) / preSunsetTime;
factor = std::min(1.f, factor);
mResult.mSunDiscColor = lerp(osg::Vec4f(1, 1, 1, 1), current.mSunDiscSunsetColor, factor);
// The SunDiscSunsetColor in the INI isn't exactly the resulting color on screen, most likely because
// MW applied the color to the ambient term as well. After the ambient and emissive terms are added
// together, the fixed pipeline would then clamp the total lighting to (1,1,1). A noticeable change in color
// tone can be observed when only one of the color components gets clamped. Unfortunately that means we
// can't use the INI color as is, have to replicate the above nonsense.
mResult.mSunDiscColor
= mResult.mSunDiscColor + osg::componentMultiply(mResult.mSunDiscColor, mResult.mAmbientColor);
for (int i = 0; i < 3; ++i)
mResult.mSunDiscColor[i] = std::min(1.f, mResult.mSunDiscColor[i]);
}
else
mResult.mSunDiscColor = osg::Vec4f(1, 1, 1, 1);
if (gameHour >= mTimeSettings.mDayEnd)
{
// sunset
float fade = std::min(
1.f, (gameHour - mTimeSettings.mDayEnd) / (mTimeSettings.mNightStart - mTimeSettings.mDayEnd));
fade = fade * fade;
mResult.mSunDiscColor.a() = 1.f - fade;
}
else if (gameHour >= mTimeSettings.mNightEnd && gameHour <= mTimeSettings.mNightEnd + mSunriseDuration / 2.f)
{
// sunrise
mResult.mSunDiscColor.a() = gameHour - mTimeSettings.mNightEnd;
}
else
mResult.mSunDiscColor.a() = 1;
mResult.mStormDirection = calculateStormDirection(mResult.mParticleEffect);
}
inline void WeatherManager::calculateTransitionResult(const float factor, const float gameHour)
{
calculateResult(mCurrentWeather, gameHour);
const MWRender::WeatherResult current = mResult;
calculateResult(mNextWeather, gameHour);
const MWRender::WeatherResult other = mResult;
mResult.mStormDirection = current.mStormDirection;
mResult.mNextStormDirection = other.mStormDirection;
mResult.mCloudTexture = current.mCloudTexture;
mResult.mNextCloudTexture = other.mCloudTexture;
mResult.mCloudBlendFactor = mWeatherSettings[mNextWeather].cloudBlendFactor(factor);
mResult.mFogColor = lerp(current.mFogColor, other.mFogColor, factor);
mResult.mSunColor = lerp(current.mSunColor, other.mSunColor, factor);
mResult.mSkyColor = lerp(current.mSkyColor, other.mSkyColor, factor);
mResult.mAmbientColor = lerp(current.mAmbientColor, other.mAmbientColor, factor);
mResult.mSunDiscColor = lerp(current.mSunDiscColor, other.mSunDiscColor, factor);
mResult.mFogDepth = lerp(current.mFogDepth, other.mFogDepth, factor);
mResult.mDLFogFactor = lerp(current.mDLFogFactor, other.mDLFogFactor, factor);
mResult.mDLFogOffset = lerp(current.mDLFogOffset, other.mDLFogOffset, factor);
mResult.mCurrentWindSpeed = calculateWindSpeed(mCurrentWeather, mCurrentWindSpeed);
mResult.mNextWindSpeed = calculateWindSpeed(mNextWeather, mNextWindSpeed);
mResult.mBaseWindSpeed = lerp(current.mBaseWindSpeed, other.mBaseWindSpeed, factor);
mResult.mWindSpeed = lerp(mResult.mCurrentWindSpeed, mResult.mNextWindSpeed, factor);
mResult.mCloudSpeed = lerp(current.mCloudSpeed, other.mCloudSpeed, factor);
mResult.mGlareView = lerp(current.mGlareView, other.mGlareView, factor);
mResult.mNightFade = lerp(current.mNightFade, other.mNightFade, factor);
mResult.mNight = current.mNight;
float threshold = mWeatherSettings[mNextWeather].mRainThreshold;
if (threshold <= 0.f)
threshold = 0.5f;
if (factor < threshold)
{
mResult.mIsStorm = current.mIsStorm;
mResult.mParticleEffect = current.mParticleEffect;
mResult.mRainEffect = current.mRainEffect;
mResult.mRainSpeed = current.mRainSpeed;
mResult.mRainEntranceSpeed = current.mRainEntranceSpeed;
mResult.mAmbientSoundVolume = 1.f - factor / threshold;
mResult.mPrecipitationAlpha = mResult.mAmbientSoundVolume;
mResult.mAmbientLoopSoundID = current.mAmbientLoopSoundID;
mResult.mRainLoopSoundID = current.mRainLoopSoundID;
mResult.mRainDiameter = current.mRainDiameter;
mResult.mRainMinHeight = current.mRainMinHeight;
mResult.mRainMaxHeight = current.mRainMaxHeight;
mResult.mRainMaxRaindrops = current.mRainMaxRaindrops;
}
else
{
mResult.mIsStorm = other.mIsStorm;
mResult.mParticleEffect = other.mParticleEffect;
mResult.mRainEffect = other.mRainEffect;
mResult.mRainSpeed = other.mRainSpeed;
mResult.mRainEntranceSpeed = other.mRainEntranceSpeed;
mResult.mAmbientSoundVolume = (factor - threshold) / (1 - threshold);
mResult.mPrecipitationAlpha = mResult.mAmbientSoundVolume;
mResult.mAmbientLoopSoundID = other.mAmbientLoopSoundID;
mResult.mRainLoopSoundID = other.mRainLoopSoundID;
mResult.mRainDiameter = other.mRainDiameter;
mResult.mRainMinHeight = other.mRainMinHeight;
mResult.mRainMaxHeight = other.mRainMaxHeight;
mResult.mRainMaxRaindrops = other.mRainMaxRaindrops;
}
}
}
| 57,186
|
C++
|
.cpp
| 1,136
| 40.134683
| 120
| 0.639295
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,290
|
ptr.cpp
|
OpenMW_openmw/apps/openmw/mwworld/ptr.cpp
|
#include "ptr.hpp"
#include "apps/openmw/mwbase/environment.hpp"
#include "worldmodel.hpp"
namespace MWWorld
{
SafePtr::SafePtr(const Ptr& ptr)
: mId(ptr.getCellRef().getRefNum())
, mPtr(ptr)
, mLastUpdate(MWBase::Environment::get().getWorldModel()->getPtrRegistryRevision())
{
}
std::string SafePtr::toString() const
{
update();
if (mPtr.isEmpty())
return "object" + mId.toString() + " (not found)";
else
return mPtr.toString();
}
void SafePtr::update() const
{
const WorldModel& worldModel = *MWBase::Environment::get().getWorldModel();
if (mLastUpdate != worldModel.getPtrRegistryRevision())
{
mPtr = worldModel.getPtr(mId);
mLastUpdate = worldModel.getPtrRegistryRevision();
}
}
}
| 854
|
C++
|
.cpp
| 29
| 22.62069
| 91
| 0.610976
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,291
|
action.cpp
|
OpenMW_openmw/apps/openmw/mwworld/action.cpp
|
#include "action.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
const MWWorld::Ptr& MWWorld::Action::getTarget() const
{
return mTarget;
}
void MWWorld::Action::setTarget(const MWWorld::Ptr& target)
{
mTarget = target;
}
MWWorld::Action::Action(bool keepSound, const Ptr& target)
: mKeepSound(keepSound)
, mSoundOffset(0)
, mTarget(target)
{
}
MWWorld::Action::~Action() {}
void MWWorld::Action::execute(const Ptr& actor, bool noSound)
{
if (!mSoundId.empty() && !noSound)
{
MWSound::PlayMode envType = MWSound::PlayMode::Normal;
// Action sounds should not have a distortion in GUI mode
// example: take an item or drink a potion underwater
if (actor == MWMechanics::getPlayer() && MWBase::Environment::get().getWindowManager()->isGuiMode())
{
envType = MWSound::PlayMode::NoEnv;
}
if (mKeepSound && actor == MWMechanics::getPlayer())
MWBase::Environment::get().getSoundManager()->playSound(
mSoundId, 1.0, 1.0, MWSound::Type::Sfx, envType, mSoundOffset);
else
{
bool local = mTarget.isEmpty() || !mTarget.isInCell(); // no usable target
if (mKeepSound)
MWBase::Environment::get().getSoundManager()->playSound3D(
(local ? actor : mTarget).getRefData().getPosition().asVec3(), mSoundId, 1.0, 1.0,
MWSound::Type::Sfx, envType, mSoundOffset);
else
MWBase::Environment::get().getSoundManager()->playSound3D(
local ? actor : mTarget, mSoundId, 1.0, 1.0, MWSound::Type::Sfx, envType, mSoundOffset);
}
}
executeImp(actor);
}
void MWWorld::Action::setSound(const ESM::RefId& id)
{
mSoundId = id;
}
void MWWorld::Action::setSoundOffset(float offset)
{
mSoundOffset = offset;
}
| 1,986
|
C++
|
.cpp
| 56
| 29.017857
| 108
| 0.635889
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,292
|
worldmodel.cpp
|
OpenMW_openmw/apps/openmw/mwworld/worldmodel.cpp
|
#include "worldmodel.hpp"
#include <algorithm>
#include <cassert>
#include <optional>
#include <stdexcept>
#include <components/debug/debuglog.hpp>
#include <components/esm/defs.hpp>
#include <components/esm3/cellid.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/cellstate.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm4/loadwrld.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/settings/values.hpp>
#include "cellstore.hpp"
#include "esmstore.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
namespace MWWorld
{
namespace
{
const ESM::RefId draftCellId = ESM::RefId::index(ESM::REC_CSTA, 0);
template <class T>
CellStore& emplaceCellStore(ESM::RefId id, const T& cell, ESMStore& store, ESM::ReadersCache& readers,
std::unordered_map<ESM::RefId, CellStore>& cells)
{
const auto [it, inserted] = cells.emplace(
std::piecewise_construct, std::forward_as_tuple(id), std::forward_as_tuple(Cell(cell), store, readers));
assert(inserted);
return it->second;
}
CellStore* emplaceInteriorCellStore(std::string_view name, ESMStore& store, ESM::ReadersCache& readers,
std::unordered_map<ESM::RefId, CellStore>& cells)
{
if (const ESM::Cell* cell = store.get<ESM::Cell>().search(name))
return &emplaceCellStore(cell->mId, *cell, store, readers, cells);
if (const ESM4::Cell* cell = store.get<ESM4::Cell>().searchCellName(name);
cell != nullptr && !cell->isExterior())
{
return &emplaceCellStore(cell->mId, *cell, store, readers, cells);
}
return nullptr;
}
const ESM::Cell* createEsmCell(ESM::ExteriorCellLocation location, ESMStore& store)
{
ESM::Cell record = {};
record.mData.mFlags = ESM::Cell::HasWater;
record.mData.mX = location.mX;
record.mData.mY = location.mY;
record.updateId();
return store.insert(record);
}
const ESM4::Cell* createEsm4Cell(ESM::ExteriorCellLocation location, ESMStore& store)
{
ESM4::Cell record = {};
record.mParent = location.mWorldspace;
record.mX = location.mX;
record.mY = location.mY;
return store.insert(record);
}
std::tuple<Cell, bool> createExteriorCell(ESM::ExteriorCellLocation location, ESMStore& store)
{
if (ESM::isEsm4Ext(location.mWorldspace))
{
if (store.get<ESM4::World>().search(location.mWorldspace) == nullptr)
throw std::runtime_error(
"Exterior ESM4 world is not found: " + location.mWorldspace.toDebugString());
const ESM4::Cell* cell = store.get<ESM4::Cell>().searchExterior(location);
bool created = cell == nullptr;
if (created)
cell = createEsm4Cell(location, store);
assert(cell != nullptr);
return { MWWorld::Cell(*cell), created };
}
const ESM::Cell* cell = store.get<ESM::Cell>().search(location.mX, location.mY);
bool created = cell == nullptr;
if (created)
cell = createEsmCell(location, store);
assert(cell != nullptr);
return { Cell(*cell), created };
}
std::optional<Cell> createCell(ESM::RefId id, const ESMStore& store)
{
if (const ESM4::Cell* cell = store.get<ESM4::Cell>().search(id))
return Cell(*cell);
if (const ESM::Cell* cell = store.get<ESM::Cell>().search(id))
return Cell(*cell);
return std::nullopt;
}
CellStore* getOrCreateExterior(const ESM::ExteriorCellLocation& location,
std::map<ESM::ExteriorCellLocation, MWWorld::CellStore*>& exteriors, ESMStore& store,
ESM::ReadersCache& readers, std::unordered_map<ESM::RefId, CellStore>& cells, bool triggerEvent)
{
if (const auto it = exteriors.find(location); it != exteriors.end())
{
assert(it->second != nullptr);
return it->second;
}
auto [cell, created] = createExteriorCell(location, store);
const ESM::RefId id = cell.getId();
CellStore* const cellStore = &emplaceCellStore(id, std::move(cell), store, readers, cells);
exteriors.emplace(location, cellStore);
if (created && triggerEvent)
MWBase::Environment::get().getLuaManager()->exteriorCreated(*cellStore);
return cellStore;
}
}
}
MWWorld::CellStore& MWWorld::WorldModel::getOrInsertCellStore(const ESM::Cell& cell)
{
const auto it = mCells.find(cell.mId);
if (it != mCells.end())
return it->second;
return insertCellStore(cell);
}
MWWorld::CellStore& MWWorld::WorldModel::insertCellStore(const ESM::Cell& cell)
{
CellStore& cellStore = emplaceCellStore(cell.mId, cell, mStore, mReaders, mCells);
if (cell.mData.mFlags & ESM::Cell::Interior)
mInteriors.emplace(cell.mName, &cellStore);
else
mExteriors.emplace(
ESM::ExteriorCellLocation(cell.getGridX(), cell.getGridY(), ESM::Cell::sDefaultWorldspaceId), &cellStore);
return cellStore;
}
void MWWorld::WorldModel::clear()
{
mPtrRegistry.clear();
mInteriors.clear();
mExteriors.clear();
mCells.clear();
std::fill(mIdCache.begin(), mIdCache.end(), std::make_pair(ESM::RefId(), (MWWorld::CellStore*)nullptr));
mIdCacheIndex = 0;
}
MWWorld::Ptr MWWorld::WorldModel::getPtrAndCache(const ESM::RefId& name, CellStore& cellStore)
{
Ptr ptr = cellStore.getPtr(name);
if (!ptr.isEmpty() && ptr.isInCell())
{
mIdCache[mIdCacheIndex].first = name;
mIdCache[mIdCacheIndex].second = &cellStore;
if (++mIdCacheIndex >= mIdCache.size())
mIdCacheIndex = 0;
}
return ptr;
}
void MWWorld::WorldModel::writeCell(ESM::ESMWriter& writer, CellStore& cell) const
{
if (cell.getState() != CellStore::State_Loaded)
cell.load();
ESM::CellState cellState;
cell.saveState(cellState);
writer.startRecord(ESM::REC_CSTA);
writer.writeCellId(cellState.mId);
cellState.save(writer);
cell.writeFog(writer);
cell.writeReferences(writer);
writer.endRecord(ESM::REC_CSTA);
}
MWWorld::WorldModel::WorldModel(MWWorld::ESMStore& store, ESM::ReadersCache& readers)
: mStore(store)
, mReaders(readers)
, mIdCache(Settings::cells().mPointersCacheSize, { ESM::RefId(), nullptr })
{
mDraftCell.mId = draftCellId;
}
namespace MWWorld
{
CellStore& WorldModel::getExterior(ESM::ExteriorCellLocation location, bool forceLoad) const
{
CellStore* cellStore = getOrCreateExterior(location, mExteriors, mStore, mReaders, mCells, true);
if (forceLoad && cellStore->getState() != CellStore::State_Loaded)
cellStore->load();
return *cellStore;
}
CellStore* WorldModel::findInterior(std::string_view name, bool forceLoad) const
{
const auto it = mInteriors.find(name);
CellStore* cellStore = nullptr;
if (it == mInteriors.end())
{
cellStore = emplaceInteriorCellStore(name, mStore, mReaders, mCells);
if (cellStore == nullptr)
return cellStore;
mInteriors.emplace(name, cellStore);
}
else
{
assert(it->second != nullptr);
cellStore = it->second;
}
if (forceLoad && cellStore->getState() != CellStore::State_Loaded)
cellStore->load();
return cellStore;
}
CellStore& WorldModel::getInterior(std::string_view name, bool forceLoad) const
{
CellStore* const cellStore = findInterior(name, forceLoad);
if (cellStore == nullptr)
throw std::runtime_error("Interior cell is not found: '" + std::string(name) + "'");
return *cellStore;
}
CellStore* WorldModel::findCell(ESM::RefId id, bool forceLoad) const
{
auto it = mCells.find(id);
if (it != mCells.end())
{
CellStore& cellStore = it->second;
if (forceLoad && cellStore.getState() != CellStore::State_Loaded)
cellStore.load();
return &cellStore;
}
if (id == draftCellId)
{
CellStore& cellStore = emplaceCellStore(id, Cell(mDraftCell), mStore, mReaders, mCells);
cellStore.load();
return &cellStore;
}
if (const auto* exteriorId = id.getIf<ESM::ESM3ExteriorCellRefId>())
return &getExterior(
ESM::ExteriorCellLocation(exteriorId->getX(), exteriorId->getY(), ESM::Cell::sDefaultWorldspaceId),
forceLoad);
std::optional<Cell> cell = createCell(id, mStore);
if (!cell.has_value())
return nullptr;
CellStore& cellStore = emplaceCellStore(id, std::move(*cell), mStore, mReaders, mCells);
if (cellStore.isExterior())
mExteriors.emplace(ESM::ExteriorCellLocation(cellStore.getCell()->getGridX(),
cellStore.getCell()->getGridY(), cellStore.getCell()->getWorldSpace()),
&cellStore);
else
mInteriors.emplace(cellStore.getCell()->getNameId(), &cellStore);
if (forceLoad && cellStore.getState() != CellStore::State_Loaded)
cellStore.load();
return &cellStore;
}
CellStore& WorldModel::getCell(ESM::RefId id, bool forceLoad) const
{
CellStore* const result = findCell(id, forceLoad);
if (result == nullptr)
throw std::runtime_error("Cell does not exist: " + id.toDebugString());
return *result;
}
CellStore& WorldModel::getDraftCell() const
{
return getCell(draftCellId);
}
CellStore* WorldModel::findCell(std::string_view name, bool forceLoad) const
{
if (CellStore* const cellStore = findInterior(name, forceLoad))
return cellStore;
// try named exteriors
const ESM::Cell* cell = mStore.get<ESM::Cell>().searchExtByName(name);
if (cell == nullptr)
{
// treat "Wilderness" like an empty string
static const std::string& defaultName
= mStore.get<ESM::GameSetting>().find("sDefaultCellname")->mValue.getString();
if (Misc::StringUtils::ciEqual(name, defaultName))
cell = mStore.get<ESM::Cell>().searchExtByName({});
}
if (cell == nullptr)
{
// now check for regions
const Store<ESM::Region>& regions = mStore.get<ESM::Region>();
const auto region = std::find_if(regions.begin(), regions.end(),
[&](const ESM::Region& v) { return Misc::StringUtils::ciEqual(name, v.mName); });
if (region != regions.end())
cell = mStore.get<ESM::Cell>().searchExtByRegion(region->mId);
}
if (cell != nullptr)
return &getExterior(
ESM::ExteriorCellLocation(cell->getGridX(), cell->getGridY(), ESM::Cell::sDefaultWorldspaceId),
forceLoad);
if (const ESM4::Cell* cell4 = mStore.get<ESM4::Cell>().searchCellName(name);
cell4 != nullptr && cell4->isExterior())
{
return &getExterior(cell4->getExteriorCellLocation(), forceLoad);
}
return nullptr;
}
CellStore& WorldModel::getCell(std::string_view name, bool forceLoad) const
{
CellStore* const result = findCell(name, forceLoad);
if (result == nullptr)
throw std::runtime_error(std::string("Can't find cell with name ") + std::string(name));
return *result;
}
void WorldModel::registerPtr(const Ptr& ptr)
{
if (ptr.mRef == nullptr)
throw std::logic_error("Ptr with nullptr mRef is not allowed to be registered");
mPtrRegistry.insert(ptr);
ptr.mRef->mWorldModel = this;
}
void WorldModel::deregisterLiveCellRef(LiveCellRefBase& ref) noexcept
{
mPtrRegistry.remove(ref);
ref.mWorldModel = nullptr;
}
}
MWWorld::Ptr MWWorld::WorldModel::getPtrByRefId(const ESM::RefId& name)
{
for (const auto& [cachedId, cellStore] : mIdCache)
{
if (cachedId != name || cellStore == nullptr)
continue;
Ptr ptr = cellStore->getPtr(name);
if (!ptr.isEmpty())
return ptr;
}
// Then check cells that are already listed
// Search in reverse, this is a workaround for an ambiguous chargen_plank reference in the vanilla game.
// there is one at -22,16 and one at -2,-9, the latter should be used.
for (auto iter = mExteriors.rbegin(); iter != mExteriors.rend(); ++iter)
{
Ptr ptr = getPtrAndCache(name, *iter->second);
if (!ptr.isEmpty())
return ptr;
}
for (auto iter = mInteriors.begin(); iter != mInteriors.end(); ++iter)
{
Ptr ptr = getPtrAndCache(name, *iter->second);
if (!ptr.isEmpty())
return ptr;
}
// Now try the other cells
const MWWorld::Store<ESM::Cell>& cells = mStore.get<ESM::Cell>();
for (auto iter = cells.extBegin(); iter != cells.extEnd(); ++iter)
{
if (mCells.contains(iter->mId))
continue;
Ptr ptr = getPtrAndCache(name, insertCellStore(*iter));
if (!ptr.isEmpty())
return ptr;
}
for (auto iter = cells.intBegin(); iter != cells.intEnd(); ++iter)
{
if (mCells.contains(iter->mId))
continue;
Ptr ptr = getPtrAndCache(name, insertCellStore(*iter));
if (!ptr.isEmpty())
return ptr;
}
// giving up
return Ptr();
}
void MWWorld::WorldModel::getExteriorPtrs(const ESM::RefId& name, std::vector<MWWorld::Ptr>& out)
{
const MWWorld::Store<ESM::Cell>& cells = mStore.get<ESM::Cell>();
for (MWWorld::Store<ESM::Cell>::iterator iter = cells.extBegin(); iter != cells.extEnd(); ++iter)
{
CellStore& cellStore = getOrInsertCellStore(*iter);
Ptr ptr = getPtrAndCache(name, cellStore);
if (!ptr.isEmpty())
out.push_back(ptr);
}
}
std::vector<MWWorld::Ptr> MWWorld::WorldModel::getAll(const ESM::RefId& id)
{
std::vector<Ptr> result;
for (auto& [cellId, cellStore] : mCells)
{
if (cellStore.getState() == CellStore::State_Unloaded)
cellStore.preload();
if (cellStore.getState() == CellStore::State_Preloaded)
{
if (!cellStore.hasId(id))
continue;
cellStore.load();
}
cellStore.forEach([&](const Ptr& ptr) {
if (ptr.getCellRef().getRefId() == id)
result.push_back(ptr);
return true;
});
}
return result;
}
int MWWorld::WorldModel::countSavedGameRecords() const
{
return std::count_if(mCells.begin(), mCells.end(), [](const auto& v) { return v.second.hasState(); });
}
void MWWorld::WorldModel::write(ESM::ESMWriter& writer, Loading::Listener& progress) const
{
for (auto& [id, cellStore] : mCells)
if (cellStore.hasState())
{
writeCell(writer, cellStore);
progress.increaseProgress();
}
}
struct MWWorld::WorldModel::GetCellStoreCallback : public CellStore::GetCellStoreCallback
{
public:
GetCellStoreCallback(WorldModel& worldModel)
: mWorldModel(worldModel)
{
}
WorldModel& mWorldModel;
CellStore* getCellStore(const ESM::RefId& cellId) override
{
if (const auto* exteriorId = cellId.getIf<ESM::ESM3ExteriorCellRefId>())
{
ESM::ExteriorCellLocation location(exteriorId->getX(), exteriorId->getY(), ESM::Cell::sDefaultWorldspaceId);
return getOrCreateExterior(
location, mWorldModel.mExteriors, mWorldModel.mStore, mWorldModel.mReaders, mWorldModel.mCells, false);
}
return mWorldModel.findCell(cellId);
}
};
bool MWWorld::WorldModel::readRecord(ESM::ESMReader& reader, uint32_t type)
{
if (type == ESM::REC_CSTA)
{
ESM::CellState state;
state.mId = reader.getCellId();
GetCellStoreCallback callback(*this);
CellStore* const cellStore = callback.getCellStore(state.mId);
if (cellStore == nullptr)
{
Log(Debug::Warning) << "Dropping state for cell " << state.mId << " (cell no longer exists)";
reader.skipRecord();
return true;
}
state.load(reader);
cellStore->loadState(state);
if (state.mHasFogOfWar)
cellStore->readFog(reader);
if (cellStore->getState() != CellStore::State_Loaded)
cellStore->load();
cellStore->readReferences(reader, &callback);
return true;
}
return false;
}
| 17,325
|
C++
|
.cpp
| 439
| 30.842825
| 120
| 0.613759
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,293
|
player.cpp
|
OpenMW_openmw/apps/openmw/mwworld/player.cpp
|
#include "player.hpp"
#include <stdexcept>
#include <components/debug/debuglog.hpp>
#include <components/esm/defs.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadbsgn.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/player.hpp>
#include <components/fallback/fallback.hpp>
#include "../mwworld/esmstore.hpp"
#include "../mwworld/inventorystore.hpp"
#include "../mwworld/magiceffects.hpp"
#include "../mwworld/worldmodel.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwmechanics/movement.hpp"
#include "../mwmechanics/npcstats.hpp"
#include "../mwmechanics/spellutil.hpp"
#include "../mwrender/camera.hpp"
#include "../mwrender/renderingmanager.hpp"
#include "cellstore.hpp"
#include "class.hpp"
#include "ptr.hpp"
namespace MWWorld
{
namespace
{
ESM::CellRef makePlayerCellRef()
{
ESM::CellRef result;
result.blank();
result.mRefID = ESM::RefId::stringRefId("Player");
return result;
}
}
Player::Player(const ESM::NPC* player)
: mPlayer(makePlayerCellRef(), player)
, mCellStore(nullptr)
, mLastKnownExteriorPosition(0, 0, 0)
, mMarkedPosition(ESM::Position())
, mMarkedCell(nullptr)
, mTeleported(false)
, mCurrentCrimeId(-1)
, mPaidCrimeId(-1)
, mJumping(false)
{
ESM::Position playerPos = mPlayer.mData.getPosition();
playerPos.pos[0] = playerPos.pos[1] = playerPos.pos[2] = 0;
mPlayer.mData.setPosition(playerPos);
}
void Player::saveStats()
{
MWMechanics::NpcStats& stats = getPlayer().getClass().getNpcStats(getPlayer());
for (size_t i = 0; i < mSaveSkills.size(); ++i)
mSaveSkills[i] = stats.getSkill(ESM::Skill::indexToRefId(i)).getModified();
for (size_t i = 0; i < mSaveAttributes.size(); ++i)
mSaveAttributes[i] = stats.getAttribute(ESM::Attribute::indexToRefId(i)).getModified();
}
void Player::restoreStats()
{
const auto& store = MWBase::Environment::get().getESMStore();
const MWWorld::Store<ESM::GameSetting>& gmst = store->get<ESM::GameSetting>();
MWMechanics::CreatureStats& creatureStats = getPlayer().getClass().getCreatureStats(getPlayer());
MWMechanics::NpcStats& npcStats = getPlayer().getClass().getNpcStats(getPlayer());
MWMechanics::DynamicStat<float> health = creatureStats.getDynamic(0);
creatureStats.setHealth(health.getBase() / gmst.find("fWereWolfHealth")->mValue.getFloat());
for (size_t i = 0; i < mSaveSkills.size(); ++i)
{
auto& skill = npcStats.getSkill(ESM::Skill::indexToRefId(i));
skill.restore(skill.getDamage());
skill.setModifier(mSaveSkills[i] - skill.getBase());
}
for (size_t i = 0; i < mSaveAttributes.size(); ++i)
{
auto id = ESM::Attribute::indexToRefId(i);
auto attribute = npcStats.getAttribute(id);
attribute.restore(attribute.getDamage());
attribute.setModifier(mSaveAttributes[i] - attribute.getBase());
npcStats.setAttribute(id, attribute);
}
}
void Player::setWerewolfStats()
{
const auto& store = MWBase::Environment::get().getESMStore();
const MWWorld::Store<ESM::GameSetting>& gmst = store->get<ESM::GameSetting>();
MWMechanics::CreatureStats& creatureStats = getPlayer().getClass().getCreatureStats(getPlayer());
MWMechanics::NpcStats& npcStats = getPlayer().getClass().getNpcStats(getPlayer());
MWMechanics::DynamicStat<float> health = creatureStats.getDynamic(0);
creatureStats.setHealth(health.getBase() * gmst.find("fWereWolfHealth")->mValue.getFloat());
for (const auto& attribute : store->get<ESM::Attribute>())
{
MWMechanics::AttributeValue value = npcStats.getAttribute(attribute.mId);
value.setModifier(attribute.mWerewolfValue - value.getModified());
npcStats.setAttribute(attribute.mId, value);
}
for (const auto& skill : store->get<ESM::Skill>())
{
// Acrobatics is set separately for some reason.
if (skill.mId == ESM::Skill::Acrobatics)
continue;
MWMechanics::SkillValue& value = npcStats.getSkill(skill.mId);
value.setModifier(skill.mWerewolfValue - value.getModified());
}
}
void Player::set(const ESM::NPC* player)
{
mPlayer.mBase = player;
}
void Player::setCell(MWWorld::CellStore* cellStore)
{
mCellStore = cellStore;
}
MWWorld::Ptr Player::getPlayer()
{
MWWorld::Ptr ptr(&mPlayer, mCellStore);
return ptr;
}
MWWorld::ConstPtr Player::getConstPlayer() const
{
MWWorld::ConstPtr ptr(&mPlayer, mCellStore);
return ptr;
}
void Player::setBirthSign(const ESM::RefId& sign)
{
mSign = sign;
}
const ESM::RefId& Player::getBirthSign() const
{
return mSign;
}
void Player::setDrawState(MWMechanics::DrawState state)
{
MWWorld::Ptr ptr = getPlayer();
ptr.getClass().getNpcStats(ptr).setDrawState(state);
}
void Player::yaw(float yaw)
{
MWWorld::Ptr ptr = getPlayer();
ptr.getClass().getMovementSettings(ptr).mRotation[2] += yaw;
}
void Player::pitch(float pitch)
{
MWWorld::Ptr ptr = getPlayer();
ptr.getClass().getMovementSettings(ptr).mRotation[0] += pitch;
}
void Player::roll(float roll)
{
MWWorld::Ptr ptr = getPlayer();
ptr.getClass().getMovementSettings(ptr).mRotation[1] += roll;
}
MWMechanics::DrawState Player::getDrawState()
{
MWWorld::Ptr ptr = getPlayer();
return ptr.getClass().getNpcStats(ptr).getDrawState();
}
void Player::activate()
{
if (MWBase::Environment::get().getWindowManager()->isGuiMode())
return;
MWWorld::Ptr player = getPlayer();
const MWMechanics::NpcStats& playerStats = player.getClass().getNpcStats(player);
if (playerStats.isParalyzed() || playerStats.getKnockedDown() || playerStats.isDead())
return;
MWWorld::Ptr toActivate = MWBase::Environment::get().getWorld()->getFacedObject();
if (toActivate.isEmpty())
return;
if (!toActivate.getClass().hasToolTip(toActivate))
return;
MWBase::Environment::get().getLuaManager()->objectActivated(toActivate, player);
}
bool Player::wasTeleported() const
{
return mTeleported;
}
void Player::setTeleported(bool teleported)
{
mTeleported = teleported;
}
void Player::setJumping(bool jumping)
{
mJumping = jumping;
}
bool Player::getJumping() const
{
return mJumping;
}
bool Player::isInCombat()
{
return MWBase::Environment::get().getMechanicsManager()->getActorsFighting(getPlayer()).size() != 0;
}
bool Player::enemiesNearby()
{
return MWBase::Environment::get().getMechanicsManager()->getEnemiesNearby(getPlayer()).size() != 0;
}
void Player::markPosition(CellStore* markedCell, const ESM::Position& markedPosition)
{
mMarkedCell = markedCell;
mMarkedPosition = markedPosition;
}
void Player::getMarkedPosition(CellStore*& markedCell, ESM::Position& markedPosition) const
{
markedCell = mMarkedCell;
if (mMarkedCell)
markedPosition = mMarkedPosition;
}
void Player::clear()
{
ESM::CellRef cellRef;
cellRef.blank();
cellRef.mRefID = ESM::RefId::stringRefId("Player");
cellRef.mRefNum = mPlayer.mRef.getRefNum();
mPlayer = LiveCellRef<ESM::NPC>(cellRef, mPlayer.mBase);
mCellStore = nullptr;
mSign = ESM::RefId();
mMarkedCell = nullptr;
mTeleported = false;
mJumping = false;
mCurrentCrimeId = -1;
mPaidCrimeId = -1;
mPreviousItems.clear();
mLastKnownExteriorPosition = osg::Vec3f(0, 0, 0);
mSaveSkills.fill(0.f);
mSaveAttributes.fill(0.f);
mMarkedPosition.pos[0] = 0;
mMarkedPosition.pos[1] = 0;
mMarkedPosition.pos[2] = 0;
mMarkedPosition.rot[0] = 0;
mMarkedPosition.rot[1] = 0;
mMarkedPosition.rot[2] = 0;
}
void Player::write(ESM::ESMWriter& writer, Loading::Listener& progress) const
{
ESM::Player player;
mPlayer.save(player.mObject);
player.mCellId = mCellStore->getCell()->getId();
player.mCurrentCrimeId = mCurrentCrimeId;
player.mPaidCrimeId = mPaidCrimeId;
player.mBirthsign = mSign;
player.mLastKnownExteriorPosition[0] = mLastKnownExteriorPosition.x();
player.mLastKnownExteriorPosition[1] = mLastKnownExteriorPosition.y();
player.mLastKnownExteriorPosition[2] = mLastKnownExteriorPosition.z();
if (mMarkedCell)
{
player.mHasMark = true;
player.mMarkedPosition = mMarkedPosition;
player.mMarkedCell = mMarkedCell->getCell()->getId();
}
else
player.mHasMark = false;
for (size_t i = 0; i < mSaveAttributes.size(); ++i)
player.mSaveAttributes[i] = mSaveAttributes[i];
for (size_t i = 0; i < mSaveSkills.size(); ++i)
player.mSaveSkills[i] = mSaveSkills[i];
player.mPreviousItems = mPreviousItems;
writer.startRecord(ESM::REC_PLAY);
player.save(writer);
writer.endRecord(ESM::REC_PLAY);
}
bool Player::readRecord(ESM::ESMReader& reader, uint32_t type)
{
if (type == ESM::REC_PLAY)
{
ESM::Player player;
player.load(reader);
if (!mPlayer.checkState(player.mObject))
{
// this is the one object we can not silently drop.
throw std::runtime_error("invalid player state record (object state)");
}
if (reader.getFormatVersion() <= ESM::MaxClearModifiersFormatVersion)
convertMagicEffects(
player.mObject.mCreatureStats, player.mObject.mInventory, &player.mObject.mNpcStats);
else if (reader.getFormatVersion() <= ESM::MaxOldCreatureStatsFormatVersion)
{
convertStats(player.mObject.mCreatureStats);
convertEnchantmentSlots(player.mObject.mCreatureStats, player.mObject.mInventory);
}
else if (reader.getFormatVersion() <= ESM::MaxActiveSpellSlotIndexFormatVersion)
convertEnchantmentSlots(player.mObject.mCreatureStats, player.mObject.mInventory);
if (!player.mObject.mEnabled)
{
Log(Debug::Warning) << "Warning: Savegame attempted to disable the player.";
player.mObject.mEnabled = true;
}
MWBase::Environment::get().getWorldModel()->deregisterLiveCellRef(mPlayer);
mPlayer.load(player.mObject);
for (size_t i = 0; i < mSaveAttributes.size(); ++i)
mSaveAttributes[i] = player.mSaveAttributes[i];
for (size_t i = 0; i < mSaveSkills.size(); ++i)
mSaveSkills[i] = player.mSaveSkills[i];
if (player.mObject.mNpcStats.mIsWerewolf)
{
if (reader.getFormatVersion() <= ESM::MaxOldSkillsAndAttributesFormatVersion)
{
setWerewolfStats();
if (player.mSetWerewolfAcrobatics)
MWBase::Environment::get().getMechanicsManager()->applyWerewolfAcrobatics(getPlayer());
}
}
getPlayer().getClass().getCreatureStats(getPlayer()).getAiSequence().clear();
MWBase::World& world = *MWBase::Environment::get().getWorld();
mCellStore = MWBase::Environment::get().getWorldModel()->findCell(player.mCellId);
if (mCellStore == nullptr)
Log(Debug::Warning) << "Player cell " << player.mCellId << " no longer exists";
if (!player.mBirthsign.empty())
{
const ESM::BirthSign* sign = world.getStore().get<ESM::BirthSign>().search(player.mBirthsign);
if (!sign)
throw std::runtime_error("invalid player state record (birthsign does not exist)");
}
mCurrentCrimeId = player.mCurrentCrimeId;
mPaidCrimeId = player.mPaidCrimeId;
mSign = player.mBirthsign;
mLastKnownExteriorPosition.x() = player.mLastKnownExteriorPosition[0];
mLastKnownExteriorPosition.y() = player.mLastKnownExteriorPosition[1];
mLastKnownExteriorPosition.z() = player.mLastKnownExteriorPosition[2];
if (player.mHasMark)
{
if (!world.getStore().get<ESM::Cell>().search(player.mMarkedCell))
player.mHasMark = false; // drop mark silently
}
if (player.mHasMark)
{
mMarkedPosition = player.mMarkedPosition;
mMarkedCell = &MWBase::Environment::get().getWorldModel()->getCell(player.mMarkedCell);
}
else
{
mMarkedCell = nullptr;
}
mTeleported = false;
mPreviousItems = player.mPreviousItems;
return true;
}
return false;
}
int Player::getNewCrimeId()
{
return ++mCurrentCrimeId;
}
void Player::recordCrimeId()
{
mPaidCrimeId = mCurrentCrimeId;
}
int Player::getCrimeId() const
{
return mPaidCrimeId;
}
void Player::setPreviousItem(const ESM::RefId& boundItemId, const ESM::RefId& previousItemId)
{
mPreviousItems[boundItemId] = previousItemId;
}
ESM::RefId Player::getPreviousItem(const ESM::RefId& boundItemId)
{
return mPreviousItems[boundItemId];
}
void Player::erasePreviousItem(const ESM::RefId& boundItemId)
{
mPreviousItems.erase(boundItemId);
}
void Player::setSelectedSpell(const ESM::RefId& spellId)
{
Ptr player = getPlayer();
InventoryStore& store = player.getClass().getInventoryStore(player);
store.setSelectedEnchantItem(store.end());
int castChance = int(MWMechanics::getSpellSuccessChance(spellId, player));
MWBase::Environment::get().getWindowManager()->setSelectedSpell(spellId, castChance);
MWBase::Environment::get().getWindowManager()->updateSpellWindow();
}
void Player::update()
{
auto player = getPlayer();
const auto world = MWBase::Environment::get().getWorld();
const auto rendering = world->getRenderingManager();
auto& store = world->getStore();
auto& playerClass = player.getClass();
const auto windowMgr = MWBase::Environment::get().getWindowManager();
if (player.getCell()->isExterior())
{
ESM::Position pos = player.getRefData().getPosition();
setLastKnownExteriorPosition(pos.asVec3());
}
bool isWerewolf = playerClass.getNpcStats(player).isWerewolf();
bool isFirstPerson = world->isFirstPerson();
if (isWerewolf && isFirstPerson)
{
float werewolfFov = Fallback::Map::getFloat("General_Werewolf_FOV");
if (werewolfFov != 0)
rendering->overrideFieldOfView(werewolfFov);
windowMgr->setWerewolfOverlay(true);
}
else
{
rendering->resetFieldOfView();
windowMgr->setWerewolfOverlay(false);
}
// Sink the camera while sneaking
bool sneaking = playerClass.getCreatureStats(player).getStance(MWMechanics::CreatureStats::Stance_Sneak);
bool swimming = world->isSwimming(player);
bool flying = world->isFlying(player);
static const float i1stPersonSneakDelta
= store.get<ESM::GameSetting>().find("i1stPersonSneakDelta")->mValue.getFloat();
if (sneaking && !swimming && !flying)
rendering->getCamera()->setSneakOffset(i1stPersonSneakDelta);
else
rendering->getCamera()->setSneakOffset(0.f);
int blind = 0;
const auto& magicEffects = playerClass.getCreatureStats(player).getMagicEffects();
if (!world->getGodModeState())
blind = static_cast<int>(magicEffects.getOrDefault(ESM::MagicEffect::Blind).getModifier());
windowMgr->setBlindness(std::clamp(blind, 0, 100));
int nightEye = static_cast<int>(magicEffects.getOrDefault(ESM::MagicEffect::NightEye).getMagnitude());
rendering->setNightEyeFactor(std::min(1.f, (nightEye / 100.f)));
}
}
| 17,152
|
C++
|
.cpp
| 419
| 31.894988
| 113
| 0.628484
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,294
|
livecellref.cpp
|
OpenMW_openmw/apps/openmw/mwworld/livecellref.cpp
|
#include "livecellref.hpp"
#include <sstream>
#include <components/debug/debuglog.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadscpt.hpp>
#include <components/esm3/objectstate.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "class.hpp"
#include "esmstore.hpp"
#include "ptr.hpp"
#include "worldmodel.hpp"
namespace MWWorld
{
LiveCellRefBase::LiveCellRefBase(unsigned int type, const ESM::CellRef& cref)
: mClass(&Class::get(type))
, mRef(cref)
, mData(cref)
{
}
LiveCellRefBase::LiveCellRefBase(unsigned int type, const ESM4::Reference& cref)
: mClass(&Class::get(type))
, mRef(cref)
, mData(cref)
{
}
LiveCellRefBase::LiveCellRefBase(unsigned int type, const ESM4::ActorCharacter& cref)
: mClass(&Class::get(type))
, mRef(cref)
, mData(cref)
{
}
LiveCellRefBase::LiveCellRefBase(LiveCellRefBase&& other) noexcept
: mClass(other.mClass)
, mRef(std::move(other.mRef))
, mData(std::move(other.mData))
, mWorldModel(std::exchange(other.mWorldModel, nullptr))
{
}
LiveCellRefBase::~LiveCellRefBase()
{
if (mWorldModel != nullptr)
mWorldModel->deregisterLiveCellRef(*this);
}
LiveCellRefBase& LiveCellRefBase::operator=(LiveCellRefBase&& other) noexcept
{
mClass = other.mClass;
mRef = std::move(other.mRef);
mData = std::move(other.mData);
mWorldModel = std::exchange(other.mWorldModel, nullptr);
return *this;
}
void LiveCellRefBase::loadImp(const ESM::ObjectState& state)
{
mRef = CellRef(state.mRef);
mData = RefData(state, mData.isDeletedByContentFile());
Ptr ptr(this);
if (state.mHasLocals)
{
const ESM::RefId& scriptId = mClass->getScript(ptr);
// Make sure we still have a script. It could have been coming from a content file that is no longer active.
if (!scriptId.empty())
{
if (const ESM::Script* script
= MWBase::Environment::get().getESMStore()->get<ESM::Script>().search(scriptId))
{
try
{
mData.setLocals(*script);
mData.getLocals().read(state.mLocals, scriptId);
}
catch (const std::exception& exception)
{
Log(Debug::Error) << "Error: failed to load state for local script " << scriptId
<< " because an exception has been thrown: " << exception.what();
}
}
}
}
mClass->readAdditionalState(ptr, state);
if (!mRef.getSoul().empty()
&& !MWBase::Environment::get().getESMStore()->get<ESM::Creature>().search(mRef.getSoul()))
{
Log(Debug::Warning) << "Soul '" << mRef.getSoul() << "' not found, removing the soul from soul gem";
mRef.setSoul(ESM::RefId());
}
MWBase::Environment::get().getLuaManager()->loadLocalScripts(ptr, state.mLuaScripts);
}
void LiveCellRefBase::saveImp(ESM::ObjectState& state) const
{
mRef.writeState(state);
ConstPtr ptr(this);
mData.write(state, mClass->getScript(ptr));
MWBase::Environment::get().getLuaManager()->saveLocalScripts(
Ptr(const_cast<LiveCellRefBase*>(this)), state.mLuaScripts);
mClass->writeAdditionalState(ptr, state);
}
bool LiveCellRefBase::checkStateImp(const ESM::ObjectState& state)
{
return true;
}
unsigned int LiveCellRefBase::getType() const
{
return mClass->getType();
}
bool LiveCellRefBase::isDeleted() const
{
return mData.isDeletedByContentFile() || mRef.getCount(false) == 0;
}
std::string makeDynamicCastErrorMessage(const LiveCellRefBase* value, std::string_view recordType)
{
std::stringstream message;
message << "Bad LiveCellRef cast to " << recordType << " from ";
if (value != nullptr)
message << value->getTypeDescription();
else
message << "an empty object";
return message.str();
}
}
| 4,391
|
C++
|
.cpp
| 120
| 27.583333
| 120
| 0.597785
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,295
|
actionrepair.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actionrepair.cpp
|
#include "actionrepair.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
namespace MWWorld
{
ActionRepair::ActionRepair(const Ptr& item, bool force)
: Action(false, item)
, mForce(force)
{
}
void ActionRepair::executeImp(const Ptr& actor)
{
if (actor != MWMechanics::getPlayer())
return;
if (!mForce && MWMechanics::isPlayerInCombat())
{
MWBase::Environment::get().getWindowManager()->messageBox("#{sInventoryMessage2}");
return;
}
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Repair, getTarget());
}
}
| 719
|
C++
|
.cpp
| 23
| 25
| 98
| 0.638205
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,296
|
class.cpp
|
OpenMW_openmw/apps/openmw/mwworld/class.cpp
|
#include "class.hpp"
#include <stdexcept>
#include <components/esm/defs.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadsoun.hpp>
#include <components/misc/resourcehelpers.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/esmstore.hpp"
#include "actiontake.hpp"
#include "containerstore.hpp"
#include "failedaction.hpp"
#include "inventorystore.hpp"
#include "nullaction.hpp"
#include "ptr.hpp"
#include "worldmodel.hpp"
#include "../mwgui/tooltips.hpp"
#include "../mwmechanics/npcstats.hpp"
namespace MWWorld
{
std::map<unsigned, Class*>& Class::getClasses()
{
static std::map<unsigned, Class*> values;
return values;
}
void Class::insertObjectRendering(
const Ptr& ptr, const std::string& mesh, MWRender::RenderingInterface& renderingInterface) const
{
}
void Class::insertObject(
const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{
}
void Class::insertObjectPhysics(
const Ptr& ptr, const std::string& mesh, const osg::Quat& rotation, MWPhysics::PhysicsSystem& physics) const
{
}
bool Class::consume(const MWWorld::Ptr& consumable, const MWWorld::Ptr& actor) const
{
return false;
}
void Class::skillUsageSucceeded(const MWWorld::Ptr& ptr, ESM::RefId skill, int usageType, float extraFactor) const
{
throw std::runtime_error("class does not represent an actor");
}
bool Class::canSell(const MWWorld::ConstPtr& item, int npcServices) const
{
return false;
}
int Class::getServices(const ConstPtr& actor) const
{
throw std::runtime_error("class does not have services");
}
MWMechanics::CreatureStats& Class::getCreatureStats(const Ptr& ptr) const
{
throw std::runtime_error("class does not have creature stats");
}
MWMechanics::NpcStats& Class::getNpcStats(const Ptr& ptr) const
{
throw std::runtime_error("class does not have NPC stats");
}
bool Class::hasItemHealth(const ConstPtr& ptr) const
{
return false;
}
int Class::getItemHealth(const ConstPtr& ptr) const
{
if (ptr.getCellRef().getCharge() == -1)
return getItemMaxHealth(ptr);
else
return ptr.getCellRef().getCharge();
}
float Class::getItemNormalizedHealth(const ConstPtr& ptr) const
{
if (getItemMaxHealth(ptr) == 0)
{
return 0.f;
}
else
{
return getItemHealth(ptr) / static_cast<float>(getItemMaxHealth(ptr));
}
}
int Class::getItemMaxHealth(const ConstPtr& ptr) const
{
throw std::runtime_error("class does not have item health");
}
bool Class::evaluateHit(const Ptr& ptr, Ptr& victim, osg::Vec3f& hitPosition) const
{
throw std::runtime_error("class cannot hit");
}
void Class::hit(const Ptr& ptr, float attackStrength, int type, const Ptr& victim, const osg::Vec3f& hitPosition,
bool success) const
{
throw std::runtime_error("class cannot hit");
}
void Class::onHit(const Ptr& ptr, float damage, bool ishealth, const Ptr& object, const Ptr& attacker,
const osg::Vec3f& hitPosition, bool successful, const MWMechanics::DamageSourceType sourceType) const
{
throw std::runtime_error("class cannot be hit");
}
std::unique_ptr<Action> Class::activate(const Ptr& ptr, const Ptr& actor) const
{
return std::make_unique<NullAction>();
}
std::unique_ptr<Action> Class::use(const Ptr& ptr, bool force) const
{
return std::make_unique<NullAction>();
}
ContainerStore& Class::getContainerStore(const Ptr& ptr) const
{
throw std::runtime_error("class does not have a container store");
}
InventoryStore& Class::getInventoryStore(const Ptr& ptr) const
{
throw std::runtime_error("class does not have an inventory store");
}
bool Class::hasInventoryStore(const ConstPtr& ptr) const
{
return false;
}
bool Class::canLock(const ConstPtr& ptr) const
{
return false;
}
void Class::setRemainingUsageTime(const Ptr& ptr, float duration) const
{
throw std::runtime_error("class does not support time-based uses");
}
float Class::getRemainingUsageTime(const ConstPtr& ptr) const
{
return -1;
}
ESM::RefId Class::getScript(const ConstPtr& ptr) const
{
return ESM::RefId();
}
float Class::getMaxSpeed(const Ptr& ptr) const
{
return 0;
}
float Class::getCurrentSpeed(const Ptr& ptr) const
{
return 0;
}
float Class::getJump(const Ptr& ptr) const
{
return 0;
}
int Class::getEnchantmentPoints(const MWWorld::ConstPtr& ptr) const
{
throw std::runtime_error("class does not support enchanting");
}
MWMechanics::Movement& Class::getMovementSettings(const Ptr& ptr) const
{
throw std::runtime_error("movement settings not supported by class");
}
osg::Vec3f Class::getRotationVector(const Ptr& ptr) const
{
return osg::Vec3f(0, 0, 0);
}
std::pair<std::vector<int>, bool> Class::getEquipmentSlots(const ConstPtr& ptr) const
{
return std::make_pair(std::vector<int>(), false);
}
ESM::RefId Class::getEquipmentSkill(const ConstPtr& ptr) const
{
return {};
}
int Class::getValue(const ConstPtr& ptr) const
{
throw std::logic_error("value not supported by this class");
}
float Class::getCapacity(const MWWorld::Ptr& ptr) const
{
throw std::runtime_error("capacity not supported by this class");
}
float Class::getWeight(const ConstPtr& ptr) const
{
throw std::runtime_error("weight not supported by this class");
}
float Class::getEncumbrance(const MWWorld::Ptr& ptr) const
{
throw std::runtime_error("encumbrance not supported by class");
}
bool Class::isEssential(const MWWorld::ConstPtr& ptr) const
{
return false;
}
float Class::getArmorRating(const MWWorld::Ptr& ptr) const
{
throw std::runtime_error("Class does not support armor rating");
}
const Class& Class::get(unsigned int key)
{
const auto& classes = getClasses();
auto iter = classes.find(key);
if (iter == classes.end())
throw std::logic_error("Class::get(): unknown class key: " + std::to_string(key));
return *iter->second;
}
bool Class::isPersistent(const ConstPtr& ptr) const
{
throw std::runtime_error("class does not support persistence");
}
void Class::registerClass(Class& instance)
{
getClasses().emplace(instance.getType(), &instance);
}
const ESM::RefId& Class::getUpSoundId(const ConstPtr& ptr) const
{
throw std::runtime_error("class does not have an up sound");
}
const ESM::RefId& Class::getDownSoundId(const ConstPtr& ptr) const
{
throw std::runtime_error("class does not have an down sound");
}
ESM::RefId Class::getSoundIdFromSndGen(const Ptr& ptr, std::string_view type) const
{
throw std::runtime_error("class does not support soundgen look up");
}
const std::string& Class::getInventoryIcon(const MWWorld::ConstPtr& ptr) const
{
throw std::runtime_error("class does not have any inventory icon");
}
MWGui::ToolTipInfo Class::getToolTipInfo(const ConstPtr& ptr, int count) const
{
throw std::runtime_error("class does not have a tool tip");
}
bool Class::showsInInventory(const ConstPtr& ptr) const
{
// NOTE: Don't show WerewolfRobe objects in the inventory, or allow them to be taken.
// Vanilla likely uses a hack like this since there's no other way to prevent it from
// being shown or taken.
return (ptr.getCellRef().getRefId() != "werewolfrobe");
}
bool Class::hasToolTip(const ConstPtr& ptr) const
{
return true;
}
ESM::RefId Class::getEnchantment(const ConstPtr& ptr) const
{
return ESM::RefId();
}
void Class::adjustScale(const MWWorld::ConstPtr& ptr, osg::Vec3f& scale, bool rendering) const {}
std::string_view Class::getModel(const MWWorld::ConstPtr& ptr) const
{
return {};
}
std::string Class::getCorrectedModel(const MWWorld::ConstPtr& ptr) const
{
std::string_view model = getModel(ptr);
if (!model.empty())
return Misc::ResourceHelpers::correctMeshPath(model);
return {};
}
bool Class::useAnim() const
{
return false;
}
void Class::getModelsToPreload(const ConstPtr& ptr, std::vector<std::string_view>& models) const
{
std::string_view model = getModel(ptr);
if (!model.empty())
models.push_back(model);
}
const ESM::RefId& Class::applyEnchantment(
const MWWorld::ConstPtr& ptr, const ESM::RefId& enchId, int enchCharge, const std::string& newName) const
{
throw std::runtime_error("class can't be enchanted");
}
std::pair<int, std::string_view> Class::canBeEquipped(const MWWorld::ConstPtr& ptr, const MWWorld::Ptr& npc) const
{
return { 1, {} };
}
void Class::adjustPosition(const MWWorld::Ptr& ptr, bool force) const {}
std::unique_ptr<Action> Class::defaultItemActivate(const Ptr& ptr, const Ptr& actor) const
{
if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
return std::make_unique<NullAction>();
if (actor.getClass().isNpc() && actor.getClass().getNpcStats(actor).isWerewolf())
{
const MWWorld::ESMStore& store = *MWBase::Environment::get().getESMStore();
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
const ESM::Sound* sound = store.get<ESM::Sound>().searchRandom("WolfItem", prng);
std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>("#{sWerewolfRefusal}");
if (sound)
action->setSound(sound->mId);
return action;
}
std::unique_ptr<MWWorld::Action> action = std::make_unique<ActionTake>(ptr);
action->setSound(getUpSoundId(ptr));
return action;
}
MWWorld::Ptr Class::copyToCellImpl(const ConstPtr& ptr, CellStore& cell) const
{
throw std::runtime_error("unable to copy class to cell");
}
MWWorld::Ptr Class::copyToCell(const ConstPtr& ptr, CellStore& cell, int count) const
{
Ptr newPtr = copyToCellImpl(ptr, cell);
newPtr.getCellRef().unsetRefNum(); // This RefNum is only valid within the original cell of the reference
newPtr.getCellRef().setCount(count);
newPtr.getRefData().setLuaScripts(nullptr);
MWBase::Environment::get().getWorldModel()->registerPtr(newPtr);
return newPtr;
}
MWWorld::Ptr Class::moveToCell(const Ptr& ptr, CellStore& cell) const
{
Ptr newPtr = copyToCellImpl(ptr, cell);
ptr.getRefData().setLuaScripts(nullptr);
MWBase::Environment::get().getWorldModel()->registerPtr(newPtr);
return newPtr;
}
Ptr Class::moveToCell(const Ptr& ptr, CellStore& cell, const ESM::Position& pos) const
{
Ptr newPtr = moveToCell(ptr, cell);
newPtr.getRefData().setPosition(pos);
newPtr.getCellRef().setPosition(pos);
return newPtr;
}
MWWorld::Ptr Class::copyToCell(const ConstPtr& ptr, CellStore& cell, const ESM::Position& pos, int count) const
{
Ptr newPtr = copyToCell(ptr, cell, count);
newPtr.getRefData().setPosition(pos);
newPtr.getCellRef().setPosition(pos);
return newPtr;
}
bool Class::isBipedal(const ConstPtr& ptr) const
{
return false;
}
bool Class::canFly(const ConstPtr& ptr) const
{
return false;
}
bool Class::canSwim(const ConstPtr& ptr) const
{
return false;
}
bool Class::canWalk(const ConstPtr& ptr) const
{
return false;
}
bool Class::isPureWaterCreature(const ConstPtr& ptr) const
{
return canSwim(ptr) && !isBipedal(ptr) && !canFly(ptr) && !canWalk(ptr);
}
bool Class::isPureFlyingCreature(const ConstPtr& ptr) const
{
return canFly(ptr) && !isBipedal(ptr) && !canSwim(ptr) && !canWalk(ptr);
}
bool Class::isPureLandCreature(const Ptr& ptr) const
{
return canWalk(ptr) && !isBipedal(ptr) && !canFly(ptr) && !canSwim(ptr);
}
bool Class::isMobile(const MWWorld::Ptr& ptr) const
{
return canSwim(ptr) || canWalk(ptr) || canFly(ptr);
}
float Class::getSkill(const MWWorld::Ptr& ptr, ESM::RefId id) const
{
throw std::runtime_error("class does not support skills");
}
int Class::getBloodTexture(const MWWorld::ConstPtr& ptr) const
{
throw std::runtime_error("class does not support gore");
}
void Class::readAdditionalState(const MWWorld::Ptr& ptr, const ESM::ObjectState& state) const {}
void Class::writeAdditionalState(const MWWorld::ConstPtr& ptr, ESM::ObjectState& state) const {}
int Class::getBaseGold(const MWWorld::ConstPtr& ptr) const
{
throw std::runtime_error("class does not support base gold");
}
bool Class::isClass(const MWWorld::ConstPtr& ptr, std::string_view className) const
{
return false;
}
MWWorld::DoorState Class::getDoorState(const MWWorld::ConstPtr& ptr) const
{
throw std::runtime_error("this is not a door");
}
void Class::setDoorState(const MWWorld::Ptr& ptr, MWWorld::DoorState state) const
{
throw std::runtime_error("this is not a door");
}
float Class::getNormalizedEncumbrance(const Ptr& ptr) const
{
float capacity = getCapacity(ptr);
float encumbrance = getEncumbrance(ptr);
if (encumbrance == 0)
return 0.f;
if (capacity == 0)
return 1.f;
return encumbrance / capacity;
}
ESM::RefId Class::getSound(const MWWorld::ConstPtr&) const
{
return ESM::RefId();
}
int Class::getBaseFightRating(const ConstPtr& ptr) const
{
throw std::runtime_error("class does not support fight rating");
}
ESM::RefId Class::getPrimaryFaction(const MWWorld::ConstPtr& ptr) const
{
return ESM::RefId();
}
int Class::getPrimaryFactionRank(const MWWorld::ConstPtr& ptr) const
{
return -1;
}
float Class::getEffectiveArmorRating(const ConstPtr& armor, const Ptr& actor) const
{
throw std::runtime_error("class does not support armor ratings");
}
osg::Vec4f Class::getEnchantmentColor(const MWWorld::ConstPtr& item) const
{
osg::Vec4f result(1, 1, 1, 1);
const ESM::RefId& enchantmentName = item.getClass().getEnchantment(item);
if (enchantmentName.empty())
return result;
const ESM::Enchantment* enchantment
= MWBase::Environment::get().getESMStore()->get<ESM::Enchantment>().search(enchantmentName);
if (!enchantment || enchantment->mEffects.mList.empty())
return result;
const ESM::MagicEffect* magicEffect = MWBase::Environment::get().getESMStore()->get<ESM::MagicEffect>().search(
enchantment->mEffects.mList.front().mData.mEffectID);
if (!magicEffect)
return result;
result.x() = magicEffect->mData.mRed / 255.f;
result.y() = magicEffect->mData.mGreen / 255.f;
result.z() = magicEffect->mData.mBlue / 255.f;
return result;
}
void Class::setBaseAISetting(const ESM::RefId&, MWMechanics::AiSetting setting, int value) const
{
throw std::runtime_error("class does not have creature stats");
}
void Class::modifyBaseInventory(const ESM::RefId& actorId, const ESM::RefId& itemId, int amount) const
{
throw std::runtime_error("class does not have an inventory store");
}
float Class::getWalkSpeed(const Ptr& /*ptr*/) const
{
return 0;
}
float Class::getRunSpeed(const Ptr& /*ptr*/) const
{
return 0;
}
float Class::getSwimSpeed(const Ptr& /*ptr*/) const
{
return 0;
}
}
| 16,637
|
C++
|
.cpp
| 458
| 29.650655
| 119
| 0.651668
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,297
|
failedaction.cpp
|
OpenMW_openmw/apps/openmw/mwworld/failedaction.cpp
|
#include "failedaction.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
namespace MWWorld
{
FailedAction::FailedAction(std::string_view msg, const Ptr& target)
: Action(false, target)
, mMessage(msg)
{
}
void FailedAction::executeImp(const Ptr& actor)
{
if (actor == MWMechanics::getPlayer() && !mMessage.empty())
MWBase::Environment::get().getWindowManager()->messageBox(mMessage);
}
}
| 523
|
C++
|
.cpp
| 17
| 26
| 80
| 0.675299
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,298
|
actioneat.cpp
|
OpenMW_openmw/apps/openmw/mwworld/actioneat.cpp
|
#include "actioneat.hpp"
#include <components/esm3/loadskil.hpp>
#include "../mwmechanics/actorutil.hpp"
#include "class.hpp"
namespace MWWorld
{
void ActionEat::executeImp(const Ptr& actor)
{
if (actor.getClass().consume(getTarget(), actor) && actor == MWMechanics::getPlayer())
actor.getClass().skillUsageSucceeded(actor, ESM::Skill::Alchemy, ESM::Skill::Alchemy_UseIngredient);
}
ActionEat::ActionEat(const MWWorld::Ptr& object)
: Action(false, object)
{
}
}
| 519
|
C++
|
.cpp
| 16
| 27.875
| 112
| 0.692771
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,299
|
worldimp.cpp
|
OpenMW_openmw/apps/openmw/mwworld/worldimp.cpp
|
#include "worldimp.hpp"
#include <charconv>
#include <vector>
#include <osg/ComputeBoundsVisitor>
#include <osg/Group>
#include <osg/Timer>
#include <MyGUI_TextIterator.h>
#include <LinearMath/btAabbUtil2.h>
#include <components/debug/debuglog.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadlevlist.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/esm4/loaddoor.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadwrld.hpp>
#include <components/misc/constants.hpp>
#include <components/misc/convert.hpp>
#include <components/misc/mathutil.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/misc/rng.hpp>
#include <components/files/collections.hpp>
#include <components/resource/bulletshape.hpp>
#include <components/resource/resourcesystem.hpp>
#include <components/sceneutil/lightmanager.hpp>
#include <components/sceneutil/positionattitudetransform.hpp>
#include <components/sceneutil/workqueue.hpp>
#include <components/detournavigator/agentbounds.hpp>
#include <components/detournavigator/debug.hpp>
#include <components/detournavigator/navigator.hpp>
#include <components/detournavigator/settings.hpp>
#include <components/detournavigator/stats.hpp>
#include <components/detournavigator/updateguard.hpp>
#include <components/files/conversion.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/settings/values.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/scriptmanager.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/statemanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwmechanics/actorutil.hpp"
#include "../mwmechanics/aiavoiddoor.hpp" //Used to tell actors to avoid doors
#include "../mwmechanics/combat.hpp"
#include "../mwmechanics/creaturestats.hpp"
#include "../mwmechanics/levelledlist.hpp"
#include "../mwmechanics/npcstats.hpp"
#include "../mwmechanics/spellcasting.hpp"
#include "../mwmechanics/spellutil.hpp"
#include "../mwmechanics/summoning.hpp"
#include "../mwrender/animation.hpp"
#include "../mwrender/camera.hpp"
#include "../mwrender/npcanimation.hpp"
#include "../mwrender/postprocessor.hpp"
#include "../mwrender/renderingmanager.hpp"
#include "../mwrender/vismask.hpp"
#include "../mwscript/globalscripts.hpp"
#include "../mwclass/door.hpp"
#include "../mwphysics/actor.hpp"
#include "../mwphysics/collisiontype.hpp"
#include "../mwphysics/object.hpp"
#include "../mwphysics/physicssystem.hpp"
#include "../mwsound/constants.hpp"
#include "actionteleport.hpp"
#include "cellstore.hpp"
#include "containerstore.hpp"
#include "datetimemanager.hpp"
#include "inventorystore.hpp"
#include "manualref.hpp"
#include "player.hpp"
#include "projectilemanager.hpp"
#include "weather.hpp"
#include "contentloader.hpp"
#include "esmloader.hpp"
namespace MWWorld
{
namespace
{
std::vector<std::pair<std::string_view, ESM::Variant>> generateDefaultGameSettings()
{
return {
// Companion (tribunal)
{ "sCompanionShare", ESM::Variant("Companion Share") },
{ "sCompanionWarningMessage", ESM::Variant("Warning message") },
{ "sCompanionWarningButtonOne", ESM::Variant("Button 1") },
{ "sCompanionWarningButtonTwo", ESM::Variant("Button 2") },
{ "sProfitValue", ESM::Variant("Profit Value") },
{ "sTeleportDisabled", ESM::Variant("Teleport disabled") },
{ "sLevitateDisabled", ESM::Variant("Levitate disabled") },
// Missing in unpatched MW 1.0
{ "sDifficulty", ESM::Variant("Difficulty") },
{ "fDifficultyMult", ESM::Variant(5.f) },
{ "sAuto_Run", ESM::Variant("Auto Run") },
{ "sServiceRefusal", ESM::Variant("Service Refusal") },
{ "sNeedOneSkill", ESM::Variant("Need one skill") },
{ "sNeedTwoSkills", ESM::Variant("Need two skills") },
{ "sEasy", ESM::Variant("Easy") },
{ "sHard", ESM::Variant("Hard") },
{ "sDeleteNote", ESM::Variant("Delete Note") },
{ "sEditNote", ESM::Variant("Edit Note") },
{ "sAdmireSuccess", ESM::Variant("Admire Success") },
{ "sAdmireFail", ESM::Variant("Admire Fail") },
{ "sIntimidateSuccess", ESM::Variant("Intimidate Success") },
{ "sIntimidateFail", ESM::Variant("Intimidate Fail") },
{ "sTauntSuccess", ESM::Variant("Taunt Success") },
{ "sTauntFail", ESM::Variant("Taunt Fail") },
{ "sBribeSuccess", ESM::Variant("Bribe Success") },
{ "sBribeFail", ESM::Variant("Bribe Fail") },
{ "fNPCHealthBarTime", ESM::Variant(5.f) },
{ "fNPCHealthBarFade", ESM::Variant(1.f) },
{ "fFleeDistance", ESM::Variant(3000.f) },
{ "sMaxSale", ESM::Variant("Max Sale") },
{ "sAnd", ESM::Variant("and") },
// Werewolf (BM)
{ "fWereWolfRunMult", ESM::Variant(1.3f) },
{ "fWereWolfSilverWeaponDamageMult", ESM::Variant(2.f) },
{ "iWerewolfFightMod", ESM::Variant(100) },
{ "iWereWolfFleeMod", ESM::Variant(100) },
{ "iWereWolfLevelToAttack", ESM::Variant(20) },
{ "iWereWolfBounty", ESM::Variant(1000) },
{ "fCombatDistanceWerewolfMod", ESM::Variant(0.3f) },
};
}
std::vector<std::pair<GlobalVariableName, ESM::Variant>> generateDefaultGlobals()
{
return {
// vanilla Morrowind does not define dayspassed.
{ Globals::sDaysPassed, ESM::Variant(1) }, // but the addons start counting at 1 :(
{ Globals::sWerewolfClawMult, ESM::Variant(25.f) },
{ Globals::sPCKnownWerewolf, ESM::Variant(0) },
// following should exist in all versions of MW, but not necessarily in TCs
{ Globals::sGameHour, ESM::Variant(0) },
{ Globals::sTimeScale, ESM::Variant(30.f) },
{ Globals::sDay, ESM::Variant(1) },
{ Globals::sYear, ESM::Variant(1) },
{ Globals::sPCRace, ESM::Variant(0) },
{ Globals::sPCHasCrimeGold, ESM::Variant(0) },
{ Globals::sCrimeGoldDiscount, ESM::Variant(0) },
{ Globals::sCrimeGoldTurnIn, ESM::Variant(0) },
{ Globals::sPCHasTurnIn, ESM::Variant(0) },
};
}
std::vector<std::pair<std::string_view, std::string_view>> generateDefaultStatics()
{
return {
// Total conversions from SureAI lack marker records
{ "divinemarker", "marker_divine.nif" },
{ "doormarker", "marker_arrow.nif" },
{ "northmarker", "marker_north.nif" },
{ "templemarker", "marker_temple.nif" },
{ "travelmarker", "marker_travel.nif" },
};
}
std::vector<std::pair<std::string_view, std::string_view>> generateDefaultDoors()
{
return { { "prisonmarker", "marker_prison.nif" } };
}
}
struct GameContentLoader : public ContentLoader
{
void addLoader(std::string&& extension, ContentLoader& loader)
{
mLoaders.emplace(std::move(extension), &loader);
}
void load(const std::filesystem::path& filepath, int& index, Loading::Listener* listener) override
{
const auto it
= mLoaders.find(Misc::StringUtils::lowerCase(Files::pathToUnicodeString(filepath.extension())));
if (it != mLoaders.end())
{
const auto filename = filepath.filename();
Log(Debug::Info) << "Loading content file " << filename;
if (listener != nullptr)
listener->setLabel(MyGUI::TextIterator::toTagsString(Files::pathToUnicodeString(filename)));
it->second->load(filepath, index, listener);
}
else
{
std::string msg("Cannot load file: ");
msg += Files::pathToUnicodeString(filepath);
throw std::runtime_error(msg.c_str());
}
}
private:
std::map<std::string, ContentLoader*> mLoaders;
};
struct OMWScriptsLoader : public ContentLoader
{
ESMStore& mStore;
OMWScriptsLoader(ESMStore& store)
: mStore(store)
{
}
void load(const std::filesystem::path& filepath, int& /*index*/, Loading::Listener* /*listener*/) override
{
mStore.addOMWScripts(filepath);
}
};
void World::adjustSky()
{
if (mSky && (isCellExterior() || isCellQuasiExterior()))
{
mRendering->setSkyEnabled(true);
}
else
mRendering->setSkyEnabled(false);
}
World::World(Resource::ResourceSystem* resourceSystem, int activationDistanceOverride, const std::string& startCell,
const std::filesystem::path& userDataPath)
: mResourceSystem(resourceSystem)
, mLocalScripts(mStore)
, mWorldModel(mStore, mReaders)
, mTimeManager(std::make_unique<DateTimeManager>())
, mSky(true)
, mGodMode(false)
, mScriptsEnabled(true)
, mDiscardMovements(true)
, mUserDataPath(userDataPath)
, mActivationDistanceOverride(activationDistanceOverride)
, mStartCell(startCell)
, mSwimHeightScale(0.f)
, mDistanceToFacedObject(-1.f)
, mTeleportEnabled(true)
, mLevitationEnabled(true)
, mGoToJail(false)
, mDaysInPrison(0)
, mPlayerTraveling(false)
, mPlayerInJail(false)
, mSpellPreloadTimer(0.f)
{
}
void World::loadData(const Files::Collections& fileCollections, const std::vector<std::string>& contentFiles,
const std::vector<std::string>& groundcoverFiles, ToUTF8::Utf8Encoder* encoder, Loading::Listener* listener)
{
mContentFiles = contentFiles;
mESMVersions.resize(mContentFiles.size(), -1);
loadContentFiles(fileCollections, contentFiles, encoder, listener);
loadGroundcoverFiles(fileCollections, groundcoverFiles, encoder, listener);
fillGlobalVariables();
mStore.setUp();
mStore.validateRecords(mReaders);
mStore.movePlayerRecord();
mSwimHeightScale = mStore.get<ESM::GameSetting>().find("fSwimHeightScale")->mValue.getFloat();
}
void World::init(osgViewer::Viewer* viewer, osg::ref_ptr<osg::Group> rootNode, SceneUtil::WorkQueue* workQueue,
SceneUtil::UnrefQueue& unrefQueue)
{
mPhysics = std::make_unique<MWPhysics::PhysicsSystem>(mResourceSystem, rootNode);
if (Settings::navigator().mEnable)
{
auto navigatorSettings = DetourNavigator::makeSettingsFromSettingsManager();
navigatorSettings.mRecast.mSwimHeightScale = mSwimHeightScale;
mNavigator = DetourNavigator::makeNavigator(navigatorSettings, mUserDataPath);
}
else
{
mNavigator = DetourNavigator::makeNavigatorStub();
}
mRendering = std::make_unique<MWRender::RenderingManager>(
viewer, rootNode, mResourceSystem, workQueue, *mNavigator, mGroundcoverStore, unrefQueue);
mProjectileManager = std::make_unique<ProjectileManager>(
mRendering->getLightRoot()->asGroup(), mResourceSystem, mRendering.get(), mPhysics.get());
mRendering->preloadCommonAssets();
mWeatherManager = std::make_unique<MWWorld::WeatherManager>(*mRendering, mStore);
mWorldScene = std::make_unique<Scene>(*this, *mRendering.get(), mPhysics.get(), *mNavigator);
}
void World::fillGlobalVariables()
{
mGlobalVariables.fill(mStore);
mTimeManager->setup(mGlobalVariables);
}
void World::startNewGame(bool bypass)
{
mGoToJail = false;
mLevitationEnabled = true;
mTeleportEnabled = true;
mGodMode = false;
mScriptsEnabled = true;
mSky = true;
// Rebuild player
setupPlayer();
renderPlayer();
mRendering->getCamera()->reset();
// we don't want old weather to persist on a new game
// Note that if reset later, the initial ChangeWeather that the chargen script calls will be lost.
mWeatherManager.reset();
mWeatherManager = std::make_unique<MWWorld::WeatherManager>(*mRendering.get(), mStore);
if (!bypass)
{
// set new game mark
mGlobalVariables[Globals::sCharGenState].setInteger(1);
}
else
mGlobalVariables[Globals::sCharGenState].setInteger(-1);
MWBase::Environment::get().getLuaManager()->newGameStarted();
if (bypass && !mStartCell.empty())
{
ESM::Position pos;
ESM::RefId cellId = findExteriorPosition(mStartCell, pos);
if (!cellId.empty())
{
changeToCell(cellId, pos, true);
adjustPosition(getPlayerPtr(), false);
}
else
{
findInteriorPosition(mStartCell, pos);
changeToInteriorCell(mStartCell, pos, true);
}
}
else
{
for (int i = 0; i < 5; ++i)
MWBase::Environment::get().getScriptManager()->getGlobalScripts().run();
if (!getPlayerPtr().isInCell())
{
ESM::Position pos;
const int cellSize = Constants::CellSizeInUnits;
pos.pos[0] = cellSize / 2;
pos.pos[1] = cellSize / 2;
pos.pos[2] = 0;
pos.rot[0] = 0;
pos.rot[1] = 0;
pos.rot[2] = 0;
ESM::ExteriorCellLocation exteriorCellPos = ESM::positionToExteriorCellLocation(pos.pos[0], pos.pos[1]);
ESM::RefId cellId = ESM::RefId::esm3ExteriorCell(exteriorCellPos.mX, exteriorCellPos.mY);
mWorldScene->changeToExteriorCell(cellId, pos, true);
}
}
if (!bypass)
{
std::string_view video = Fallback::Map::getString("Movies_New_Game");
if (!video.empty())
{
// Make sure that we do not continue to play a Title music after a new game video.
MWBase::Environment::get().getSoundManager()->stopMusic();
MWBase::Environment::get().getWindowManager()->playVideo(video, true);
}
}
// enable collision
if (!mPhysics->toggleCollisionMode())
mPhysics->toggleCollisionMode();
MWBase::Environment::get().getWindowManager()->updatePlayer();
mTimeManager->setup(mGlobalVariables);
// Initial seed.
mPrng.seed(mRandomSeed);
}
void World::clear()
{
mWeatherManager->clear();
mRendering->clear();
mProjectileManager->clear();
mLocalScripts.clear();
mWorldScene->clear();
mWorldModel.clear();
mStore.clearDynamic();
if (mPlayer)
{
mPlayer->clear();
mPlayer->set(mStore.get<ESM::NPC>().find(ESM::RefId::stringRefId("Player")));
}
mDoorStates.clear();
mGoToJail = false;
mTeleportEnabled = true;
mLevitationEnabled = true;
mPlayerTraveling = false;
mPlayerInJail = false;
mIdsRebuilt = false;
fillGlobalVariables();
}
int World::countSavedGameRecords() const
{
return mWorldModel.countSavedGameRecords() + mStore.countSavedGameRecords()
+ mGlobalVariables.countSavedGameRecords() + mProjectileManager->countSavedGameRecords()
+ 1 // player record
+ 1 // weather record
+ 1 // actorId counter
+ 1 // levitation/teleport enabled state
+ 1 // camera
+ 1; // random state.
}
int World::countSavedGameCells() const
{
return mWorldModel.countSavedGameRecords();
}
void World::write(ESM::ESMWriter& writer, Loading::Listener& progress) const
{
writer.startRecord(ESM::REC_RAND);
writer.writeHNOString("RAND", Misc::Rng::serialize(mPrng));
writer.endRecord(ESM::REC_RAND);
// Active cells could have a dirty fog of war, sync it to the CellStore first
for (CellStore* cellstore : mWorldScene->getActiveCells())
{
MWBase::Environment::get().getWindowManager()->writeFog(cellstore);
}
MWMechanics::CreatureStats::writeActorIdCounter(writer);
mStore.write(writer, progress); // dynamic Store must be written (and read) before Cells, so that
// references to custom made records will be recognized
mWorldModel.write(writer, progress); // the player's cell needs to be loaded before the player
mPlayer->write(writer, progress);
mGlobalVariables.write(writer, progress);
mWeatherManager->write(writer, progress);
mProjectileManager->write(writer, progress);
writer.startRecord(ESM::REC_ENAB);
writer.writeHNT("TELE", mTeleportEnabled);
writer.writeHNT("LEVT", mLevitationEnabled);
writer.endRecord(ESM::REC_ENAB);
writer.startRecord(ESM::REC_CAM_);
writer.writeHNT("FIRS", isFirstPerson());
writer.endRecord(ESM::REC_CAM_);
}
void World::readRecord(ESM::ESMReader& reader, uint32_t type)
{
switch (type)
{
case ESM::REC_ACTC:
MWMechanics::CreatureStats::readActorIdCounter(reader);
return;
case ESM::REC_ENAB:
reader.getHNT(mTeleportEnabled, "TELE");
reader.getHNT(mLevitationEnabled, "LEVT");
return;
case ESM::REC_RAND:
{
auto data = reader.getHNOString("RAND");
Misc::Rng::deserialize(data, mPrng);
}
break;
case ESM::REC_PLAY:
if (reader.getFormatVersion() <= ESM::MaxPlayerBeforeCellDataFormatVersion && !mIdsRebuilt)
{
mStore.rebuildIdsIndex();
mIdsRebuilt = true;
}
mStore.checkPlayer();
mPlayer->readRecord(reader, type);
if (getPlayerPtr().isInCell())
{
if (getPlayerPtr().getCell()->isExterior())
mWorldScene->preloadTerrain(getPlayerPtr().getRefData().getPosition().asVec3(),
getPlayerPtr().getCell()->getCell()->getWorldSpace());
mWorldScene->preloadCellWithSurroundings(*getPlayerPtr().getCell());
}
break;
case ESM::REC_CSTA:
// We need to rebuild the ESMStore index in order to be able to lookup dynamic records while loading the
// WorldModel and, afterwards, the player.
if (!mIdsRebuilt)
{
mStore.rebuildIdsIndex();
mIdsRebuilt = true;
}
mWorldModel.readRecord(reader, type);
break;
default:
if (!mStore.readRecord(reader, type) && !mGlobalVariables.readRecord(reader, type)
&& !mWeatherManager->readRecord(reader, type) && !mProjectileManager->readRecord(reader, type))
{
throw std::runtime_error("unknown record in saved game");
}
break;
}
}
void World::ensureNeededRecords()
{
for (const auto& [id, value] : generateDefaultGameSettings())
{
if (mStore.get<ESM::GameSetting>().search(id) == nullptr)
{
ESM::GameSetting record;
record.mId = ESM::RefId::stringRefId(id);
record.mValue = value;
record.mRecordFlags = 0;
mStore.insertStatic(record);
}
}
for (const auto& [name, value] : generateDefaultGlobals())
{
if (mStore.get<ESM::Global>().search(ESM::RefId::stringRefId(name.getValue())) == nullptr)
{
ESM::Global record;
record.mId = ESM::RefId::stringRefId(name.getValue());
record.mValue = value;
record.mRecordFlags = 0;
mStore.insertStatic(record);
}
}
for (const auto& [id, model] : generateDefaultStatics())
{
if (mStore.get<ESM::Static>().search(ESM::RefId::stringRefId(id)) == nullptr)
{
ESM::Static record;
record.mId = ESM::RefId::stringRefId(id);
record.mModel = model;
record.mRecordFlags = 0;
mStore.insertStatic(record);
}
}
for (const auto& [id, model] : generateDefaultDoors())
{
if (mStore.get<ESM::Door>().search(ESM::RefId::stringRefId(id)) == nullptr)
{
ESM::Door record;
record.mId = ESM::RefId::stringRefId(id);
record.mModel = model;
record.mRecordFlags = 0;
mStore.insertStatic(record);
}
}
}
World::~World()
{
// Must be cleared before mRendering is destroyed
if (mProjectileManager)
mProjectileManager->clear();
if (Settings::navigator().mWaitForAllJobsOnExit)
{
Log(Debug::Verbose) << "Waiting for all navmesh jobs to be done...";
mNavigator->wait(DetourNavigator::WaitConditionType::allJobsDone, nullptr);
}
}
void World::setRandomSeed(uint32_t seed)
{
mRandomSeed = seed;
}
void World::useDeathCamera()
{
mRendering->getCamera()->setMode(MWRender::Camera::Mode::ThirdPerson);
}
MWWorld::Player& World::getPlayer()
{
return *mPlayer;
}
const std::vector<int>& World::getESMVersions() const
{
return mESMVersions;
}
LocalScripts& World::getLocalScripts()
{
return mLocalScripts;
}
void World::setGlobalInt(GlobalVariableName name, int value)
{
mTimeManager->updateGlobalInt(name, value);
mGlobalVariables[name].setInteger(value);
}
void World::setGlobalFloat(GlobalVariableName name, float value)
{
mTimeManager->updateGlobalFloat(name, value);
mGlobalVariables[name].setFloat(value);
}
int World::getGlobalInt(GlobalVariableName name) const
{
return mGlobalVariables[name].getInteger();
}
float World::getGlobalFloat(GlobalVariableName name) const
{
return mGlobalVariables[name].getFloat();
}
char World::getGlobalVariableType(GlobalVariableName name) const
{
return mGlobalVariables.getType(name);
}
std::string_view World::getCellName(const MWWorld::CellStore* cell) const
{
if (!cell)
cell = mWorldScene->getCurrentCell();
return getCellName(*cell->getCell());
}
std::string_view World::getCellName(const MWWorld::Cell& cell) const
{
if (!cell.isExterior() || !cell.getDisplayName().empty())
return cell.getDisplayName();
if (!cell.getRegion().empty())
{
std::string_view regionName
= ESM::visit(ESM::VisitOverload{
[&](const ESM::Cell& cellIn) -> std::string_view {
if (const ESM::Region* region = mStore.get<ESM::Region>().search(cell.getRegion()))
return !region->mName.empty() ? region->mName : region->mId.getRefIdString();
return {};
},
[&](const ESM4::Cell& cellIn) -> std::string_view { return {}; },
},
cell);
if (!regionName.empty())
return regionName;
}
if (!cell.getWorldSpace().empty() && ESM::isEsm4Ext(cell.getWorldSpace()))
{
if (const ESM4::World* worldspace = mStore.get<ESM4::World>().search(cell.getWorldSpace()))
if (!worldspace->mFullName.empty())
return worldspace->mFullName;
}
return mStore.get<ESM::GameSetting>().find("sDefaultCellname")->mValue.getString();
}
void World::removeRefScript(const MWWorld::CellRef* ref)
{
mLocalScripts.remove(ref);
}
Ptr World::searchPtr(const ESM::RefId& name, bool activeOnly, bool searchInContainers)
{
Ptr ret;
// the player is always in an active cell.
if (name == "Player")
{
return mPlayer->getPlayer();
}
for (CellStore* cellstore : mWorldScene->getActiveCells())
{
// TODO: caching still doesn't work efficiently here (only works for the one CellStore that the reference is
// in)
Ptr ptr = cellstore->getPtr(name);
if (!ptr.isEmpty())
return ptr;
}
if (!activeOnly)
{
ret = mWorldModel.getPtrByRefId(name);
if (!ret.isEmpty())
return ret;
}
if (searchInContainers)
{
for (CellStore* cellstore : mWorldScene->getActiveCells())
{
Ptr ptr = cellstore->searchInContainer(name);
if (!ptr.isEmpty())
return ptr;
}
}
Ptr ptr = mPlayer->getPlayer().getClass().getContainerStore(mPlayer->getPlayer()).search(name);
return ptr;
}
Ptr World::getPtr(const ESM::RefId& name, bool activeOnly)
{
Ptr ret = searchPtr(name, activeOnly);
if (!ret.isEmpty())
return ret;
std::string error = "Failed to find an instance of object " + name.toDebugString();
if (activeOnly)
error += " in active cells";
throw std::runtime_error(error);
}
Ptr World::searchPtrViaActorId(int actorId)
{
// The player is not registered in any CellStore so must be checked manually
if (actorId == getPlayerPtr().getClass().getCreatureStats(getPlayerPtr()).getActorId())
return getPlayerPtr();
// Now search cells
return mWorldScene->searchPtrViaActorId(actorId);
}
struct FindContainerVisitor
{
ConstPtr mContainedPtr;
Ptr mResult;
FindContainerVisitor(const ConstPtr& containedPtr)
: mContainedPtr(containedPtr)
{
}
bool operator()(const Ptr& ptr)
{
if (mContainedPtr.getContainerStore() == &ptr.getClass().getContainerStore(ptr))
{
mResult = ptr;
return false;
}
return true;
}
};
Ptr World::findContainer(const ConstPtr& ptr)
{
if (ptr.isInCell())
return Ptr();
Ptr player = getPlayerPtr();
if (ptr.getContainerStore() == &player.getClass().getContainerStore(player))
return player;
for (CellStore* cellstore : mWorldScene->getActiveCells())
{
FindContainerVisitor visitor(ptr);
cellstore->forEachType<ESM::Container>(visitor);
if (visitor.mResult.isEmpty())
cellstore->forEachType<ESM::Creature>(visitor);
if (visitor.mResult.isEmpty())
cellstore->forEachType<ESM::NPC>(visitor);
if (!visitor.mResult.isEmpty())
return visitor.mResult;
}
return Ptr();
}
void World::addContainerScripts(const Ptr& reference, CellStore* cell)
{
if (reference.getType() == ESM::Container::sRecordId || reference.getType() == ESM::NPC::sRecordId
|| reference.getType() == ESM::Creature::sRecordId)
{
MWWorld::ContainerStore& container = reference.getClass().getContainerStore(reference);
for (MWWorld::ContainerStoreIterator it = container.begin(); it != container.end(); ++it)
{
const auto& script = it->getClass().getScript(*it);
if (!script.empty())
{
MWWorld::Ptr item = *it;
item.mCell = cell;
mLocalScripts.add(script, item);
}
}
}
}
void World::enable(const Ptr& reference)
{
if (!reference.isInCell())
return;
if (!reference.getRefData().isEnabled())
{
reference.getRefData().enable();
if (mWorldScene->getActiveCells().find(reference.getCell()) != mWorldScene->getActiveCells().end()
&& reference.getCellRef().getCount())
mWorldScene->addObjectToScene(reference);
if (reference.getCellRef().getRefNum().hasContentFile())
{
int type = mStore.find(reference.getCellRef().getRefId());
if (mRendering->pagingEnableObject(type, reference, true))
mWorldScene->reloadTerrain();
}
}
}
void World::removeContainerScripts(const Ptr& reference)
{
if (reference.getType() == ESM::Container::sRecordId || reference.getType() == ESM::NPC::sRecordId
|| reference.getType() == ESM::Creature::sRecordId)
{
MWWorld::ContainerStore& container = reference.getClass().getContainerStore(reference);
for (MWWorld::ContainerStoreIterator it = container.begin(); it != container.end(); ++it)
{
const ESM::RefId& script = it->getClass().getScript(*it);
if (!script.empty())
{
MWWorld::Ptr item = *it;
mLocalScripts.remove(item);
}
}
}
}
void World::disable(const Ptr& reference)
{
if (!reference.getRefData().isEnabled())
return;
// disable is a no-op for items in containers
if (!reference.isInCell())
return;
if (reference == getPlayerPtr())
throw std::runtime_error("can not disable player object");
reference.getRefData().disable();
if (reference.getCellRef().getRefNum().hasContentFile())
{
int type = mStore.find(reference.getCellRef().getRefId());
if (mRendering->pagingEnableObject(type, reference, false))
mWorldScene->reloadTerrain();
}
if (mWorldScene->getActiveCells().find(reference.getCell()) != mWorldScene->getActiveCells().end()
&& reference.getCellRef().getCount())
{
mWorldScene->removeObjectFromScene(reference);
mWorldScene->addPostponedPhysicsObjects();
}
}
void World::advanceTime(double hours, bool incremental)
{
if (!incremental)
{
// When we fast-forward time, we should recharge magic items
// in all loaded cells, using game world time
float duration = hours * 3600;
const float timeScaleFactor = mTimeManager->getGameTimeScale();
if (timeScaleFactor != 0.0f)
duration /= timeScaleFactor;
rechargeItems(duration, false);
}
mWeatherManager->advanceTime(hours, incremental);
mTimeManager->advanceTime(hours, mGlobalVariables);
if (!incremental)
{
mRendering->notifyWorldSpaceChanged();
mProjectileManager->clear();
mDiscardMovements = true;
}
}
TimeStamp World::getTimeStamp() const
{
return mTimeManager->getTimeStamp();
}
bool World::toggleSky()
{
mSky = !mSky;
mRendering->setSkyEnabled(mSky);
return mSky;
}
int World::getMasserPhase() const
{
return mRendering->skyGetMasserPhase();
}
int World::getSecundaPhase() const
{
return mRendering->skyGetSecundaPhase();
}
void World::setMoonColour(bool red)
{
mRendering->skySetMoonColour(red);
}
void World::changeToInteriorCell(
const std::string_view cellName, const ESM::Position& position, bool adjustPlayerPos, bool changeEvent)
{
mPhysics->clearQueuedMovement();
mDiscardMovements = true;
if (changeEvent && mCurrentWorldSpace != cellName)
{
// changed worldspace
mProjectileManager->clear();
mRendering->notifyWorldSpaceChanged();
mCurrentWorldSpace = cellName;
}
removeContainerScripts(getPlayerPtr());
mWorldScene->changeToInteriorCell(cellName, position, adjustPlayerPos, changeEvent);
addContainerScripts(getPlayerPtr(), getPlayerPtr().getCell());
}
void World::changeToCell(
const ESM::RefId& cellId, const ESM::Position& position, bool adjustPlayerPos, bool changeEvent)
{
const MWWorld::Cell* destinationCell = getWorldModel().getCell(cellId).getCell();
bool exteriorCell = destinationCell->isExterior();
mPhysics->clearQueuedMovement();
mDiscardMovements = true;
if (changeEvent && mCurrentWorldSpace != destinationCell->getNameId())
{
// changed worldspace
mProjectileManager->clear();
mRendering->notifyWorldSpaceChanged();
mCurrentWorldSpace = destinationCell->getNameId();
}
removeContainerScripts(getPlayerPtr());
if (exteriorCell)
mWorldScene->changeToExteriorCell(cellId, position, adjustPlayerPos, changeEvent);
else
mWorldScene->changeToInteriorCell(destinationCell->getNameId(), position, adjustPlayerPos, changeEvent);
addContainerScripts(getPlayerPtr(), getPlayerPtr().getCell());
}
float World::getMaxActivationDistance() const
{
if (mActivationDistanceOverride >= 0)
return static_cast<float>(mActivationDistanceOverride);
static const int iMaxActivateDist
= mStore.get<ESM::GameSetting>().find("iMaxActivateDist")->mValue.getInteger();
return static_cast<float>(iMaxActivateDist);
}
MWWorld::Ptr World::getFacedObject()
{
MWWorld::Ptr facedObject;
if (MWBase::Environment::get().getStateManager()->getState() == MWBase::StateManager::State_NoGame)
return facedObject;
if (MWBase::Environment::get().getWindowManager()->isGuiMode()
&& MWBase::Environment::get().getWindowManager()->isConsoleMode())
facedObject = getFacedObject(getMaxActivationDistance() * 50, false);
else
{
float activationDistance = getActivationDistancePlusTelekinesis();
facedObject = getFacedObject(activationDistance, true);
if (!facedObject.isEmpty() && !facedObject.getClass().allowTelekinesis(facedObject)
&& mDistanceToFacedObject > getMaxActivationDistance()
&& !MWBase::Environment::get().getWindowManager()->isGuiMode())
return nullptr;
}
return facedObject;
}
float World::getDistanceToFacedObject()
{
return mDistanceToFacedObject;
}
osg::Matrixf World::getActorHeadTransform(const MWWorld::ConstPtr& actor) const
{
const MWRender::Animation* anim = mRendering->getAnimation(actor);
if (anim)
{
const osg::Node* node = anim->getNode("Head");
if (!node)
node = anim->getNode("Bip01 Head");
if (node)
{
osg::NodePathList nodepaths = node->getParentalNodePaths();
if (!nodepaths.empty())
return osg::computeLocalToWorld(nodepaths[0]);
}
}
return osg::Matrixf::translate(actor.getRefData().getPosition().asVec3());
}
void World::deleteObject(const Ptr& ptr)
{
if (!ptr.mRef->isDeleted() && ptr.getContainerStore() == nullptr)
{
if (ptr == getPlayerPtr())
throw std::runtime_error("can not delete player object");
ptr.getCellRef().setCount(0);
if (ptr.isInCell()
&& mWorldScene->getActiveCells().find(ptr.getCell()) != mWorldScene->getActiveCells().end()
&& ptr.getRefData().isEnabled())
{
mWorldScene->removeObjectFromScene(ptr);
mLocalScripts.remove(ptr);
removeContainerScripts(ptr);
}
}
}
void World::undeleteObject(const Ptr& ptr)
{
if (!ptr.getCellRef().hasContentFile())
return;
if (ptr.mRef->isDeleted())
{
ptr.getCellRef().setCount(1);
if (mWorldScene->getActiveCells().find(ptr.getCell()) != mWorldScene->getActiveCells().end()
&& ptr.getRefData().isEnabled())
{
mWorldScene->addObjectToScene(ptr);
const auto& script = ptr.getClass().getScript(ptr);
if (!script.empty())
mLocalScripts.add(script, ptr);
addContainerScripts(ptr, ptr.getCell());
}
}
}
MWWorld::Ptr World::moveObject(
const Ptr& ptr, CellStore* newCell, const osg::Vec3f& position, bool movePhysics, bool keepActive)
{
ESM::Position pos = ptr.getRefData().getPosition();
std::memcpy(pos.pos, &position, sizeof(osg::Vec3f));
ptr.getRefData().setPosition(pos);
CellStore* currCell = ptr.isInCell()
? ptr.getCell()
: nullptr; // currCell == nullptr should only happen for player, during initial startup
bool isPlayer = ptr == mPlayer->getPlayer();
bool haveToMove = isPlayer || (currCell && mWorldScene->isCellActive(*currCell));
MWWorld::Ptr newPtr = ptr;
if (!isPlayer && !currCell)
throw std::runtime_error("Can not move actor " + ptr.getCellRef().getRefId().toDebugString()
+ " to another cell: current cell is nullptr");
if (!newCell)
throw std::runtime_error("Can not move actor " + ptr.getCellRef().getRefId().toDebugString()
+ " to another cell: new cell is nullptr");
if (currCell != newCell)
{
removeContainerScripts(ptr);
if (isPlayer)
{
if (!newCell->isExterior())
{
changeToInteriorCell(newCell->getCell()->getNameId(), pos, false);
removeContainerScripts(getPlayerPtr());
}
else
{
if (mWorldScene->isCellActive(*newCell))
mWorldScene->changePlayerCell(*newCell, pos, false);
else
mWorldScene->changeToExteriorCell(newCell->getCell()->getId(), pos, false);
}
addContainerScripts(getPlayerPtr(), newCell);
newPtr = getPlayerPtr();
}
else
{
bool currCellActive = mWorldScene->isCellActive(*currCell);
bool newCellActive = mWorldScene->isCellActive(*newCell);
if (!currCellActive && newCellActive)
{
newPtr = currCell->moveTo(ptr, newCell);
if (newPtr.getRefData().isEnabled())
mWorldScene->addObjectToScene(newPtr);
const auto& script = newPtr.getClass().getScript(newPtr);
if (!script.empty())
{
mLocalScripts.add(script, newPtr);
}
addContainerScripts(newPtr, newCell);
}
else if (!newCellActive && currCellActive)
{
mWorldScene->removeObjectFromScene(ptr, keepActive);
mLocalScripts.remove(ptr);
removeContainerScripts(ptr);
haveToMove = false;
newPtr = currCell->moveTo(ptr, newCell);
newPtr.getRefData().setBaseNode(nullptr);
}
else if (!currCellActive && !newCellActive)
newPtr = currCell->moveTo(ptr, newCell);
else // both cells active
{
newPtr = currCell->moveTo(ptr, newCell);
mRendering->updatePtr(ptr, newPtr);
MWBase::Environment::get().getSoundManager()->updatePtr(ptr, newPtr);
mPhysics->updatePtr(ptr, newPtr);
MWBase::MechanicsManager* mechMgr = MWBase::Environment::get().getMechanicsManager();
mechMgr->updateCell(ptr, newPtr);
const auto& script = ptr.getClass().getScript(ptr);
if (!script.empty())
{
mLocalScripts.remove(ptr);
removeContainerScripts(ptr);
mLocalScripts.add(script, newPtr);
addContainerScripts(newPtr, newCell);
}
}
}
MWBase::Environment::get().getWindowManager()->updateConsoleObjectPtr(ptr, newPtr);
MWBase::Environment::get().getScriptManager()->getGlobalScripts().updatePtrs(ptr, newPtr);
}
if (haveToMove && newPtr.getRefData().getBaseNode())
{
mRendering->moveObject(newPtr, position);
if (movePhysics)
{
mPhysics->updatePosition(newPtr);
if (const MWPhysics::Object* object = mPhysics->getObject(newPtr))
updateNavigatorObject(*object);
}
}
if (isPlayer)
mWorldScene->playerMoved(position);
else
{
mRendering->pagingBlacklistObject(mStore.find(ptr.getCellRef().getRefId()), ptr);
mWorldScene->removeFromPagedRefs(newPtr);
}
return newPtr;
}
MWWorld::Ptr World::moveObject(const Ptr& ptr, const osg::Vec3f& position, bool movePhysics, bool moveToActive)
{
CellStore* cell = ptr.getCell();
ESM::RefId worldspaceId
= cell->isExterior() ? cell->getCell()->getWorldSpace() : ESM::Cell::sDefaultWorldspaceId;
const ESM::ExteriorCellLocation index
= ESM::positionToExteriorCellLocation(position.x(), position.y(), worldspaceId);
CellStore* newCell = cell->isExterior() ? &mWorldModel.getExterior(index) : nullptr;
bool isCellActive = getPlayerPtr().isInCell() && getPlayerPtr().getCell()->isExterior()
&& (newCell && mWorldScene->isCellActive(*newCell));
if (cell->isExterior() || (moveToActive && isCellActive && ptr.getClass().isActor()))
cell = newCell;
return moveObject(ptr, cell, position, movePhysics);
}
MWWorld::Ptr World::moveObjectBy(const Ptr& ptr, const osg::Vec3f& vec, bool moveToActive)
{
auto* actor = mPhysics->getActor(ptr);
osg::Vec3f newpos = ptr.getRefData().getPosition().asVec3() + vec;
if (actor)
actor->adjustPosition(vec);
if (ptr.getClass().isActor())
return moveObject(ptr, newpos, false, moveToActive && ptr != getPlayerPtr());
return moveObject(ptr, newpos);
}
void World::scaleObject(const Ptr& ptr, float scale, bool force)
{
if (!force && scale == ptr.getCellRef().getScale())
return;
if (mPhysics->getActor(ptr))
mNavigator->removeAgent(getPathfindingAgentBounds(ptr));
ptr.getCellRef().setScale(scale);
mRendering->pagingBlacklistObject(mStore.find(ptr.getCellRef().getRefId()), ptr);
mWorldScene->removeFromPagedRefs(ptr);
if (ptr.getRefData().getBaseNode() != nullptr)
mWorldScene->updateObjectScale(ptr);
if (mPhysics->getActor(ptr))
{
const DetourNavigator::AgentBounds agentBounds = getPathfindingAgentBounds(ptr);
if (!mNavigator->addAgent(agentBounds))
Log(Debug::Warning) << "Scaled agent bounds are not supported by navigator: " << agentBounds;
}
else if (const auto object = mPhysics->getObject(ptr))
updateNavigatorObject(*object);
}
void World::rotateObject(const Ptr& ptr, const osg::Vec3f& rot, MWBase::RotationFlags flags)
{
ESM::Position pos = ptr.getRefData().getPosition();
float* objRot = pos.rot;
if (flags & MWBase::RotationFlag_adjust)
{
objRot[0] += rot.x();
objRot[1] += rot.y();
objRot[2] += rot.z();
}
else
{
objRot[0] = rot.x();
objRot[1] = rot.y();
objRot[2] = rot.z();
}
if (ptr.getClass().isActor())
{
/* HACK? Actors shouldn't really be rotating around X (or Y), but
* currently it's done so for rotating the camera, which needs
* clamping.
*/
objRot[0] = std::clamp<float>(objRot[0], -osg::PI_2, osg::PI_2);
objRot[1] = Misc::normalizeAngle(objRot[1]);
objRot[2] = Misc::normalizeAngle(objRot[2]);
}
ptr.getRefData().setPosition(pos);
mRendering->pagingBlacklistObject(mStore.find(ptr.getCellRef().getRefId()), ptr);
mWorldScene->removeFromPagedRefs(ptr);
if (ptr.getRefData().getBaseNode() != nullptr)
{
const auto order
= flags & MWBase::RotationFlag_inverseOrder ? RotationOrder::inverse : RotationOrder::direct;
mWorldScene->updateObjectRotation(ptr, order);
if (const auto object = mPhysics->getObject(ptr))
updateNavigatorObject(*object);
}
}
void World::adjustPosition(const Ptr& ptr, bool force)
{
if (ptr.isEmpty())
{
Log(Debug::Warning) << "Unable to adjust position for empty object";
return;
}
osg::Vec3f pos(ptr.getRefData().getPosition().asVec3());
if (!ptr.getRefData().getBaseNode())
{
// will be adjusted when Ptr's cell becomes active
return;
}
if (!ptr.isInCell())
{
Log(Debug::Warning) << "Unable to adjust position for object '" << ptr.getCellRef().getRefId()
<< "' - it has no cell";
return;
}
const float terrainHeight = ptr.getCell()->isExterior()
? getTerrainHeightAt(pos, ptr.getCell()->getCell()->getWorldSpace())
: -std::numeric_limits<float>::max();
pos.z() = std::max(pos.z(), terrainHeight)
+ 20; // place slightly above terrain. will snap down to ground with code below
// We still should trace down dead persistent actors - they do not use the "swimdeath" animation.
bool swims = ptr.getClass().isActor() && isSwimming(ptr)
&& !(ptr.getClass().isPersistent(ptr) && ptr.getClass().getCreatureStats(ptr).isDeathAnimationFinished());
if (force || !ptr.getClass().isActor() || (!isFlying(ptr) && !swims && isActorCollisionEnabled(ptr)))
{
osg::Vec3f traced
= mPhysics->traceDown(ptr, pos, ESM::getCellSize(ptr.getCell()->getCell()->getWorldSpace()));
pos.z() = std::min(pos.z(), traced.z());
}
moveObject(ptr, ptr.getCell(), pos);
}
void World::fixPosition()
{
const MWWorld::Ptr actor = getPlayerPtr();
const float distance = 128.f;
ESM::Position esmPos = actor.getRefData().getPosition();
osg::Quat orientation(esmPos.rot[2], osg::Vec3f(0, 0, -1));
osg::Vec3f pos(esmPos.asVec3());
int direction = 0;
int fallbackDirections[4] = { direction, (direction + 3) % 4, (direction + 2) % 4, (direction + 1) % 4 };
osg::Vec3f targetPos = pos;
for (int i = 0; i < 4; ++i)
{
direction = fallbackDirections[i];
if (direction == 0)
targetPos = pos + (orientation * osg::Vec3f(0, 1, 0)) * distance;
else if (direction == 1)
targetPos = pos - (orientation * osg::Vec3f(0, 1, 0)) * distance;
else if (direction == 2)
targetPos = pos - (orientation * osg::Vec3f(1, 0, 0)) * distance;
else if (direction == 3)
targetPos = pos + (orientation * osg::Vec3f(1, 0, 0)) * distance;
// destination is free
if (!mPhysics->castRay(pos, targetPos, MWPhysics::CollisionType_World | MWPhysics::CollisionType_Door).mHit)
break;
}
targetPos.z() += distance / 2.f; // move up a bit to get out from geometry, will snap down later
osg::Vec3f traced
= mPhysics->traceDown(actor, targetPos, ESM::getCellSize(actor.getCell()->getCell()->getWorldSpace()));
if (traced != pos)
{
esmPos.pos[0] = traced.x();
esmPos.pos[1] = traced.y();
esmPos.pos[2] = traced.z();
ESM::RefId cell = actor.getCell()->getCell()->getId();
MWWorld::ActionTeleport(cell, esmPos, false).execute(actor);
}
}
void World::rotateWorldObject(const Ptr& ptr, const osg::Quat& rotate)
{
if (ptr.getRefData().getBaseNode() != nullptr)
{
mRendering->pagingBlacklistObject(mStore.find(ptr.getCellRef().getRefId()), ptr);
mWorldScene->removeFromPagedRefs(ptr);
mRendering->rotateObject(ptr, rotate);
mPhysics->updateRotation(ptr, rotate);
if (const auto object = mPhysics->getObject(ptr))
updateNavigatorObject(*object);
}
}
MWWorld::Ptr World::placeObject(const MWWorld::ConstPtr& ptr, MWWorld::CellStore* cell, const ESM::Position& pos)
{
return copyObjectToCell(ptr, cell, pos, ptr.getCellRef().getCount(), false);
}
MWWorld::Ptr World::safePlaceObject(const ConstPtr& ptr, const ConstPtr& referenceObject,
MWWorld::CellStore* referenceCell, int direction, float distance)
{
ESM::Position ipos = referenceObject.getRefData().getPosition();
osg::Vec3f pos(ipos.asVec3());
osg::Quat orientation(ipos.rot[2], osg::Vec3f(0, 0, -1));
int fallbackDirections[4] = { direction, (direction + 3) % 4, (direction + 2) % 4, (direction + 1) % 4 };
osg::Vec3f spawnPoint = pos;
for (int i = 0; i < 4; ++i)
{
direction = fallbackDirections[i];
if (direction == 0)
spawnPoint = pos + (orientation * osg::Vec3f(0, 1, 0)) * distance;
else if (direction == 1)
spawnPoint = pos - (orientation * osg::Vec3f(0, 1, 0)) * distance;
else if (direction == 2)
spawnPoint = pos - (orientation * osg::Vec3f(1, 0, 0)) * distance;
else if (direction == 3)
spawnPoint = pos + (orientation * osg::Vec3f(1, 0, 0)) * distance;
if (!ptr.getClass().isActor())
break;
// check if spawn point is safe, fall back to another direction if not
spawnPoint.z() += 30; // move up a little to account for slopes, will snap down later
if (!mPhysics
->castRay(spawnPoint, osg::Vec3f(pos.x(), pos.y(), pos.z() + 20),
MWPhysics::CollisionType_World | MWPhysics::CollisionType_Door)
.mHit)
{
// safe
break;
}
}
ipos.pos[0] = spawnPoint.x();
ipos.pos[1] = spawnPoint.y();
ipos.pos[2] = spawnPoint.z();
if (referenceObject.getClass().isActor())
{
ipos.rot[0] = 0;
ipos.rot[1] = 0;
}
MWWorld::Ptr placed = copyObjectToCell(ptr, referenceCell, ipos, ptr.getCellRef().getCount(), false);
adjustPosition(placed, true); // snap to ground
return placed;
}
void World::queueMovement(const Ptr& ptr, const osg::Vec3f& velocity)
{
mPhysics->queueObjectMovement(ptr, velocity);
}
void World::updateAnimatedCollisionShape(const Ptr& ptr)
{
mPhysics->updateAnimatedCollisionShape(ptr);
}
void World::doPhysics(float duration, osg::Timer_t frameStart, unsigned int frameNumber, osg::Stats& stats)
{
processDoors(duration);
mProjectileManager->update(duration);
mPhysics->stepSimulation(duration, mDiscardMovements, frameStart, frameNumber, stats);
mProjectileManager->processHits();
mDiscardMovements = false;
mPhysics->moveActors();
}
void World::updateNavigator()
{
auto navigatorUpdateGuard = mNavigator->makeUpdateGuard();
mPhysics->forEachAnimatedObject([&](const auto& pair) {
const auto [object, changed] = pair;
if (changed)
updateNavigatorObject(*object, navigatorUpdateGuard.get());
});
for (const auto& door : mDoorStates)
if (const auto object = mPhysics->getObject(door.first))
updateNavigatorObject(*object, navigatorUpdateGuard.get());
mNavigator->update(getPlayerPtr().getRefData().getPosition().asVec3(), navigatorUpdateGuard.get());
}
void World::updateNavigatorObject(
const MWPhysics::Object& object, const DetourNavigator::UpdateGuard* navigatorUpdateGuard)
{
if (object.getShapeInstance()->mVisualCollisionType != Resource::VisualCollisionType::None)
return;
const MWWorld::Ptr ptr = object.getPtr();
const DetourNavigator::ObjectShapes shapes(object.getShapeInstance(),
DetourNavigator::ObjectTransform{ ptr.getRefData().getPosition(), ptr.getCellRef().getScale() });
mNavigator->updateObject(
DetourNavigator::ObjectId(&object), shapes, object.getTransform(), navigatorUpdateGuard);
}
const MWPhysics::RayCastingInterface* World::getRayCasting() const
{
return mPhysics.get();
}
bool World::rotateDoor(const Ptr door, MWWorld::DoorState state, float duration)
{
const ESM::Position& objPos = door.getRefData().getPosition();
auto oldRot = objPos.asRotationVec3();
auto newRot = oldRot;
float minRot = door.getCellRef().getPosition().rot[2];
float maxRot = minRot + osg::DegreesToRadians(90.f);
float diff = duration * osg::DegreesToRadians(90.f) * (state == MWWorld::DoorState::Opening ? 1 : -1);
float targetRot = std::clamp(oldRot.z() + diff, minRot, maxRot);
newRot.z() = targetRot;
rotateObject(door, newRot, MWBase::RotationFlag_none);
bool reached = (targetRot == maxRot && state != MWWorld::DoorState::Idle) || targetRot == minRot;
/// \todo should use convexSweepTest here
bool collisionWithActor = false;
for (auto& [ptr, point, normal] :
mPhysics->getCollisionsPoints(door, MWPhysics::CollisionType_Door, MWPhysics::CollisionType_Actor))
{
if (ptr.getClass().isActor())
{
auto localPoint = objPos.asVec3() - point;
osg::Vec3f direction = osg::Quat(diff, osg::Vec3f(0, 0, 1)) * localPoint - localPoint;
direction.normalize();
mPhysics->reportCollision(Misc::Convert::toBullet(point), Misc::Convert::toBullet(normal));
if (direction * normal < 0) // door is turning away from actor
continue;
collisionWithActor = true;
// Collided with actor, ask actor to try to avoid door
if (ptr != getPlayerPtr())
{
MWMechanics::AiSequence& seq = ptr.getClass().getCreatureStats(ptr).getAiSequence();
if (seq.getTypeId() != MWMechanics::AiPackageTypeId::AvoidDoor) // Only add it once
seq.stack(MWMechanics::AiAvoidDoor(door), ptr);
}
// we need to undo the rotation
reached = false;
}
}
// Cancel door closing sound if collision with actor is detected
if (collisionWithActor)
{
const ESM::Door* ref = door.get<ESM::Door>()->mBase;
if (state == MWWorld::DoorState::Opening)
{
const ESM::RefId& openSound = ref->mOpenSound;
if (!openSound.empty()
&& MWBase::Environment::get().getSoundManager()->getSoundPlaying(door, openSound))
MWBase::Environment::get().getSoundManager()->stopSound3D(door, openSound);
}
else if (state == MWWorld::DoorState::Closing)
{
const ESM::RefId& closeSound = ref->mCloseSound;
if (!closeSound.empty()
&& MWBase::Environment::get().getSoundManager()->getSoundPlaying(door, closeSound))
MWBase::Environment::get().getSoundManager()->stopSound3D(door, closeSound);
}
rotateObject(door, oldRot, MWBase::RotationFlag_none);
}
return reached;
}
void World::processDoors(float duration)
{
auto it = mDoorStates.begin();
while (it != mDoorStates.end())
{
if (!mWorldScene->isCellActive(*it->first.getCell()) || !it->first.getRefData().getBaseNode())
{
// The door is no longer in an active cell, or it was disabled.
// Erase from mDoorStates, since we no longer need to move it.
// Once we load the door's cell again (or re-enable the door), Door::insertObject will reinsert to
// mDoorStates.
mDoorStates.erase(it++);
}
else
{
bool reached = rotateDoor(it->first, it->second, duration);
if (reached)
{
// Mark as non-moving
it->first.getClass().setDoorState(it->first, MWWorld::DoorState::Idle);
mDoorStates.erase(it++);
}
else
++it;
}
}
}
void World::setActorCollisionMode(const MWWorld::Ptr& ptr, bool internal, bool external)
{
MWPhysics::Actor* physicActor = mPhysics->getActor(ptr);
if (physicActor && physicActor->getCollisionMode() != internal)
{
physicActor->enableCollisionMode(internal);
physicActor->enableCollisionBody(external);
}
}
bool World::isActorCollisionEnabled(const MWWorld::Ptr& ptr)
{
MWPhysics::Actor* physicActor = mPhysics->getActor(ptr);
return physicActor && physicActor->getCollisionMode();
}
bool World::toggleCollisionMode()
{
if (mPhysics->toggleCollisionMode())
{
adjustPosition(getPlayerPtr(), true);
return true;
}
return false;
}
bool World::toggleRenderMode(MWRender::RenderMode mode)
{
switch (mode)
{
case MWRender::Render_CollisionDebug:
return mPhysics->toggleDebugRendering();
default:
return mRendering->toggleRenderMode(mode);
}
}
void World::update(float duration, bool paused)
{
if (mGoToJail && !paused)
goToJail();
// Reset "traveling" flag - there was a frame to detect traveling.
mPlayerTraveling = false;
// The same thing for "in jail" flag: reset it if:
// 1. Player was in jail
// 2. Jailing window was closed
if (mPlayerInJail && !mGoToJail && !MWBase::Environment::get().getWindowManager()->containsMode(MWGui::GM_Jail))
mPlayerInJail = false;
updateWeather(duration, paused);
updateNavigator();
mPlayer->update();
mPhysics->debugDraw();
mWorldScene->update(duration);
mRendering->update(duration, paused);
updateSoundListener();
mSpellPreloadTimer -= duration;
if (mSpellPreloadTimer <= 0.f)
{
mSpellPreloadTimer = 0.1f;
preloadSpells();
}
if (mWorldScene->hasCellLoaded())
{
mNavigator->wait(DetourNavigator::WaitConditionType::requiredTilesPresent,
MWBase::Environment::get().getWindowManager()->getLoadingScreen());
mWorldScene->resetCellLoaded();
}
}
void World::updatePhysics(
float duration, bool paused, osg::Timer_t frameStart, unsigned int frameNumber, osg::Stats& stats)
{
if (!paused)
{
doPhysics(duration, frameStart, frameNumber, stats);
}
else
{
// zero the async stats if we are paused
stats.setAttribute(frameNumber, "physicsworker_time_begin", 0);
stats.setAttribute(frameNumber, "physicsworker_time_taken", 0);
stats.setAttribute(frameNumber, "physicsworker_time_end", 0);
}
}
void World::preloadSpells()
{
const ESM::RefId& selectedSpell = MWBase::Environment::get().getWindowManager()->getSelectedSpell();
if (!selectedSpell.empty())
{
const ESM::Spell* spell = mStore.get<ESM::Spell>().search(selectedSpell);
if (spell)
preloadEffects(&spell->mEffects);
}
const MWWorld::Ptr& selectedEnchantItem
= MWBase::Environment::get().getWindowManager()->getSelectedEnchantItem();
if (!selectedEnchantItem.isEmpty())
{
const ESM::RefId& enchantId = selectedEnchantItem.getClass().getEnchantment(selectedEnchantItem);
if (!enchantId.empty())
{
const ESM::Enchantment* ench = mStore.get<ESM::Enchantment>().search(enchantId);
if (ench)
preloadEffects(&ench->mEffects);
}
}
const MWWorld::Ptr& selectedWeapon = MWBase::Environment::get().getWindowManager()->getSelectedWeapon();
if (!selectedWeapon.isEmpty())
{
const ESM::RefId& enchantId = selectedWeapon.getClass().getEnchantment(selectedWeapon);
if (!enchantId.empty())
{
const ESM::Enchantment* ench = mStore.get<ESM::Enchantment>().search(enchantId);
if (ench && ench->mData.mType == ESM::Enchantment::WhenStrikes)
preloadEffects(&ench->mEffects);
}
}
}
void World::updateSoundListener()
{
const MWRender::Camera* camera = mRendering->getCamera();
const auto& player = getPlayerPtr();
const ESM::Position& refpos = player.getRefData().getPosition();
osg::Vec3f listenerPos, up, forward;
osg::Quat listenerOrient;
if (isFirstPerson() || Settings::sound().mCameraListener)
listenerPos = camera->getPosition();
else
listenerPos = refpos.asVec3() + osg::Vec3f(0, 0, 1.85f * mPhysics->getHalfExtents(player).z());
if (isFirstPerson() || Settings::sound().mCameraListener)
listenerOrient = camera->getOrient();
else
listenerOrient = osg::Quat(refpos.rot[1], osg::Vec3f(0, -1, 0))
* osg::Quat(refpos.rot[0], osg::Vec3f(-1, 0, 0)) * osg::Quat(refpos.rot[2], osg::Vec3f(0, 0, -1));
forward = listenerOrient * osg::Vec3f(0, 1, 0);
up = listenerOrient * osg::Vec3f(0, 0, 1);
bool underwater = isUnderwater(player.getCell(), camera->getPosition());
MWBase::Environment::get().getSoundManager()->setListenerPosDir(listenerPos, forward, up, underwater);
}
void World::updateWindowManager()
{
try
{
// inform the GUI about focused object
MWWorld::Ptr object = getFacedObject();
// retrieve object dimensions so we know where to place the floating label
if (!object.isEmpty())
{
osg::BoundingBox bb = mPhysics->getBoundingBox(object);
if (!bb.valid() && object.getRefData().getBaseNode())
{
osg::ComputeBoundsVisitor computeBoundsVisitor;
computeBoundsVisitor.setTraversalMask(~(MWRender::Mask_ParticleSystem | MWRender::Mask_Effect));
object.getRefData().getBaseNode()->accept(computeBoundsVisitor);
bb = computeBoundsVisitor.getBoundingBox();
}
osg::Vec4f screenBounds = mRendering->getScreenBounds(bb);
MWBase::Environment::get().getWindowManager()->setFocusObjectScreenCoords(
screenBounds.x(), screenBounds.y(), screenBounds.z(), screenBounds.w());
}
MWBase::Environment::get().getWindowManager()->setFocusObject(object);
}
catch (std::exception& e)
{
Log(Debug::Error) << "Error updating window manager: " << e.what();
}
}
MWWorld::Ptr World::getFacedObject(float maxDistance, bool ignorePlayer)
{
const float camDist = mRendering->getCamera()->getCameraDistance();
maxDistance += camDist;
MWWorld::Ptr facedObject;
MWRender::RenderingManager::RayResult rayToObject;
if (MWBase::Environment::get().getWindowManager()->isGuiMode())
{
float x, y;
MWBase::Environment::get().getWindowManager()->getMousePosition(x, y);
rayToObject = mRendering->castCameraToViewportRay(x, y, maxDistance, ignorePlayer);
}
else
rayToObject = mRendering->castCameraToViewportRay(0.5f, 0.5f, maxDistance, ignorePlayer);
facedObject = rayToObject.mHitObject;
if (facedObject.isEmpty() && rayToObject.mHitRefnum.isSet())
facedObject = MWBase::Environment::get().getWorldModel()->getPtr(rayToObject.mHitRefnum);
if (rayToObject.mHit)
mDistanceToFacedObject = (rayToObject.mRatio * maxDistance) - camDist;
else
mDistanceToFacedObject = -1;
return facedObject;
}
bool World::castRenderingRay(MWPhysics::RayCastingResult& res, const osg::Vec3f& from, const osg::Vec3f& to,
bool ignorePlayer, bool ignoreActors, std::span<const MWWorld::Ptr> ignoreList)
{
MWRender::RenderingManager::RayResult rayRes
= mRendering->castRay(from, to, ignorePlayer, ignoreActors, ignoreList);
res.mHit = rayRes.mHit;
res.mHitPos = rayRes.mHitPointWorld;
res.mHitNormal = rayRes.mHitNormalWorld;
res.mHitObject = rayRes.mHitObject;
if (res.mHitObject.isEmpty() && rayRes.mHitRefnum.isSet())
res.mHitObject = MWBase::Environment::get().getWorldModel()->getPtr(rayRes.mHitRefnum);
return res.mHit;
}
bool World::isCellExterior() const
{
const CellStore* currentCell = mWorldScene->getCurrentCell();
if (currentCell)
{
return currentCell->getCell()->isExterior();
}
return false;
}
bool World::isCellQuasiExterior() const
{
const CellStore* currentCell = mWorldScene->getCurrentCell();
if (currentCell)
{
return currentCell->getCell()->isQuasiExterior();
}
return false;
}
ESM::RefId World::getCurrentWorldspace() const
{
const CellStore* cellStore = mWorldScene->getCurrentCell();
if (cellStore)
return cellStore->getCell()->getWorldSpace();
return ESM::Cell::sDefaultWorldspaceId;
}
int World::getCurrentWeather() const
{
return mWeatherManager->getWeatherID();
}
int World::getNextWeather() const
{
return mWeatherManager->getNextWeatherID();
}
float World::getWeatherTransition() const
{
return mWeatherManager->getTransitionFactor();
}
unsigned int World::getNightDayMode() const
{
return mWeatherManager->getNightDayMode();
}
void World::changeWeather(const ESM::RefId& region, const unsigned int id)
{
mWeatherManager->changeWeather(region, id);
}
void World::modRegion(const ESM::RefId& regionid, const std::vector<uint8_t>& chances)
{
mWeatherManager->modRegion(regionid, chances);
}
struct GetDoorMarkerVisitor
{
std::vector<World::DoorMarker>& mOut;
bool operator()(const MWWorld::Ptr& ptr)
{
MWWorld::LiveCellRef<ESM::Door>& ref = *static_cast<MWWorld::LiveCellRef<ESM::Door>*>(ptr.getBase());
if (!ref.mData.isEnabled() || ref.isDeleted())
return true;
if (ref.mRef.getTeleport())
{
World::DoorMarker newMarker;
newMarker.name = MWClass::Door::getDestination(ref);
newMarker.dest = ref.mRef.getDestCell();
ESM::Position pos = ref.mData.getPosition();
newMarker.x = pos.pos[0];
newMarker.y = pos.pos[1];
mOut.push_back(newMarker);
}
return true;
}
};
void World::getDoorMarkers(CellStore& cell, std::vector<World::DoorMarker>& out)
{
GetDoorMarkerVisitor visitor{ out };
cell.forEachType<ESM::Door>(visitor);
}
void World::setWaterHeight(const float height)
{
mPhysics->setWaterHeight(height);
mRendering->setWaterHeight(height);
}
bool World::toggleWater()
{
return mRendering->toggleRenderMode(MWRender::Render_Water);
}
bool World::toggleWorld()
{
return mRendering->toggleRenderMode(MWRender::Render_Scene);
}
bool World::toggleBorders()
{
return mRendering->toggleBorders();
}
void World::PCDropped(const Ptr& item)
{
const auto& script = item.getClass().getScript(item);
// Set OnPCDrop Variable on item's script, if it has a script with that variable declared
if (!script.empty())
item.getRefData().getLocals().setVarByInt(script, "onpcdrop", 1);
}
MWWorld::Ptr World::placeObject(const MWWorld::Ptr& object, float cursorX, float cursorY, int amount, bool copy)
{
const float maxDist = 200.f;
MWRender::RenderingManager::RayResult result
= mRendering->castCameraToViewportRay(cursorX, cursorY, maxDist, true, true);
CellStore* cell = getPlayerPtr().getCell();
ESM::Position pos = getPlayerPtr().getRefData().getPosition();
if (result.mHit)
{
pos.pos[0] = result.mHitPointWorld.x();
pos.pos[1] = result.mHitPointWorld.y();
pos.pos[2] = result.mHitPointWorld.z();
}
// We want only the Z part of the player's rotation
pos.rot[0] = 0;
pos.rot[1] = 0;
// copy the object and set its count
Ptr dropped
= copy ? copyObjectToCell(object, cell, pos, amount, true) : moveObjectToCell(object, cell, pos, true);
// only the player place items in the world, so no need to check actor
PCDropped(dropped);
return dropped;
}
bool World::canPlaceObject(float cursorX, float cursorY)
{
const float maxDist = 200.f;
MWRender::RenderingManager::RayResult result
= mRendering->castCameraToViewportRay(cursorX, cursorY, maxDist, true, true);
if (result.mHit)
{
// check if the wanted position is on a flat surface, and not e.g. against a vertical wall
if (std::acos((result.mHitNormalWorld / result.mHitNormalWorld.length()) * osg::Vec3f(0, 0, 1))
>= osg::DegreesToRadians(30.f))
return false;
return true;
}
else
return false;
}
Ptr World::copyObjectToCell(const ConstPtr& object, CellStore* cell, ESM::Position pos, int count, bool adjustPos)
{
if (!cell)
throw std::runtime_error("copyObjectToCell(): cannot copy object to null cell");
if (cell->isExterior())
{
const ESM::ExteriorCellLocation index
= ESM::positionToExteriorCellLocation(pos.pos[0], pos.pos[1], cell->getCell()->getWorldSpace());
cell = &mWorldModel.getExterior(index);
}
MWWorld::Ptr dropped = object.getClass().copyToCell(object, *cell, pos, count);
initObjectInCell(dropped, *cell, adjustPos);
return dropped;
}
Ptr World::moveObjectToCell(const Ptr& object, CellStore* cell, ESM::Position pos, bool adjustPos)
{
if (!cell)
throw std::runtime_error("moveObjectToCell(): cannot move object to null cell");
if (cell->isExterior())
{
const ESM::ExteriorCellLocation index
= ESM::positionToExteriorCellLocation(pos.pos[0], pos.pos[1], cell->getCell()->getWorldSpace());
cell = &mWorldModel.getExterior(index);
}
MWWorld::Ptr dropped = object.getClass().moveToCell(object, *cell, pos);
initObjectInCell(dropped, *cell, adjustPos);
return dropped;
}
void World::initObjectInCell(const Ptr& object, CellStore& cell, bool adjustPos)
{
if (mWorldScene->isCellActive(cell))
{
if (object.getRefData().isEnabled())
{
mWorldScene->addObjectToScene(object);
}
const auto& script = object.getClass().getScript(object);
if (!script.empty())
{
mLocalScripts.add(script, object);
}
addContainerScripts(object, &cell);
}
if (!object.getClass().isActor() && adjustPos && object.getRefData().getBaseNode())
{
// Adjust position so the location we wanted ends up in the middle of the object bounding box
osg::ComputeBoundsVisitor computeBounds;
computeBounds.setTraversalMask(~MWRender::Mask_ParticleSystem);
object.getRefData().getBaseNode()->accept(computeBounds);
osg::BoundingBox bounds = computeBounds.getBoundingBox();
if (bounds.valid())
{
ESM::Position pos = object.getRefData().getPosition();
bounds.set(bounds._min - pos.asVec3(), bounds._max - pos.asVec3());
osg::Vec3f adjust(
(bounds.xMin() + bounds.xMax()) / 2, (bounds.yMin() + bounds.yMax()) / 2, bounds.zMin());
pos.pos[0] -= adjust.x();
pos.pos[1] -= adjust.y();
pos.pos[2] -= adjust.z();
moveObject(object, pos.asVec3());
}
}
}
MWWorld::Ptr World::dropObjectOnGround(const Ptr& actor, const Ptr& object, int amount, bool copy)
{
MWWorld::CellStore* cell = actor.getCell();
ESM::Position pos = actor.getRefData().getPosition();
// We want only the Z part of the actor's rotation
pos.rot[0] = 0;
pos.rot[1] = 0;
osg::Vec3f orig = pos.asVec3();
orig.z() += 20;
osg::Vec3f dir(0, 0, -1);
float len = 1000000.0;
MWRender::RenderingManager::RayResult result = mRendering->castRay(orig, orig + dir * len, true, true);
if (result.mHit)
pos.pos[2] = result.mHitPointWorld.z();
// copy the object and set its count
Ptr dropped
= copy ? copyObjectToCell(object, cell, pos, amount, true) : moveObjectToCell(object, cell, pos, true);
if (actor == mPlayer->getPlayer()) // Only call if dropped by player
PCDropped(dropped);
return dropped;
}
void World::processChangedSettings(const Settings::CategorySettingVector& settings)
{
mRendering->processChangedSettings(settings);
}
bool World::isFlying(const MWWorld::Ptr& ptr) const
{
if (!ptr.getClass().isActor())
return false;
const MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
if (stats.isDead())
return false;
const bool isPlayer = ptr == getPlayerConstPtr();
if (!(isPlayer && mGodMode)
&& stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Paralyze).getModifier() > 0)
return false;
if (ptr.getClass().canFly(ptr))
return true;
if (stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Levitate).getMagnitude() > 0
&& isLevitationEnabled())
return true;
const MWPhysics::Actor* actor = mPhysics->getActor(ptr);
if (!actor)
return true;
return false;
}
bool World::isSlowFalling(const MWWorld::Ptr& ptr) const
{
if (!ptr.getClass().isActor())
return false;
const MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
if (stats.getMagicEffects().getOrDefault(ESM::MagicEffect::SlowFall).getMagnitude() > 0)
return true;
return false;
}
bool World::isSubmerged(const MWWorld::ConstPtr& object) const
{
return isUnderwater(object, 1.0f / mSwimHeightScale);
}
bool World::isSwimming(const MWWorld::ConstPtr& object) const
{
return isUnderwater(object, mSwimHeightScale);
}
bool World::isWading(const MWWorld::ConstPtr& object) const
{
const float kneeDeep = 0.25f;
return isUnderwater(object, kneeDeep);
}
bool World::isUnderwater(const MWWorld::ConstPtr& object, const float heightRatio) const
{
osg::Vec3f pos(object.getRefData().getPosition().asVec3());
pos.z() += heightRatio * 2 * mPhysics->getRenderingHalfExtents(object).z();
const CellStore* currCell = object.isInCell()
? object.getCell()
: nullptr; // currCell == nullptr should only happen for player, during initial startup
return isUnderwater(currCell, pos);
}
bool World::isUnderwater(const MWWorld::CellStore* cell, const osg::Vec3f& pos) const
{
if (!cell)
return false;
if (!(cell->getCell()->hasWater()))
{
return false;
}
return pos.z() < cell->getWaterLevel();
}
bool World::isWaterWalkingCastableOnTarget(const MWWorld::ConstPtr& target) const
{
const MWWorld::CellStore* cell = target.getCell();
if (!cell->getCell()->hasWater())
return true;
float waterlevel = cell->getWaterLevel();
// SwimHeightScale affects the upper z position an actor can swim to
// while in water. Based on observation from the original engine,
// the upper z position you get with a +1 SwimHeightScale is the depth
// limit for being able to cast water walking on an underwater target.
if (isUnderwater(target, mSwimHeightScale + 1)
|| (isUnderwater(cell, target.getRefData().getPosition().asVec3())
&& !mPhysics->canMoveToWaterSurface(target, waterlevel)))
return false; // not castable if too deep or if not enough room to move actor to surface
else
return true;
}
bool World::isOnGround(const MWWorld::Ptr& ptr) const
{
return mPhysics->isOnGround(ptr);
}
void World::togglePOV(bool force)
{
mRendering->getCamera()->toggleViewMode(force);
}
bool World::isFirstPerson() const
{
return mRendering->getCamera()->getMode() == MWRender::Camera::Mode::FirstPerson;
}
bool World::isPreviewModeEnabled() const
{
return mRendering->getCamera()->getMode() == MWRender::Camera::Mode::Preview;
}
bool World::toggleVanityMode(bool enable)
{
return mRendering->getCamera()->toggleVanityMode(enable);
}
void World::disableDeferredPreviewRotation()
{
mRendering->getCamera()->disableDeferredPreviewRotation();
}
void World::applyDeferredPreviewRotationToPlayer(float dt)
{
mRendering->getCamera()->applyDeferredPreviewRotationToPlayer(dt);
}
MWRender::Camera* World::getCamera()
{
return mRendering->getCamera();
}
bool World::vanityRotateCamera(const float* rot)
{
auto* camera = mRendering->getCamera();
if (!camera->isVanityOrPreviewModeEnabled())
return false;
camera->setPitch(camera->getPitch() + rot[0]);
camera->setYaw(camera->getYaw() + rot[2]);
return true;
}
void World::saveLoaded()
{
mStore.rebuildIdsIndex();
mStore.validateDynamic();
mTimeManager->setup(mGlobalVariables);
}
void World::setupPlayer()
{
const ESM::NPC* player = mStore.get<ESM::NPC>().find(ESM::RefId::stringRefId("Player"));
if (!mPlayer)
mPlayer = std::make_unique<MWWorld::Player>(player);
else
{
// Remove the old CharacterController
MWBase::Environment::get().getMechanicsManager()->remove(getPlayerPtr(), true);
mNavigator->removeAgent(getPathfindingAgentBounds(getPlayerConstPtr()));
mPhysics->remove(getPlayerPtr());
mRendering->removePlayer(getPlayerPtr());
MWBase::Environment::get().getLuaManager()->objectRemovedFromScene(getPlayerPtr());
mPlayer->set(player);
}
Ptr ptr = mPlayer->getPlayer();
mRendering->setupPlayer(ptr);
MWBase::Environment::get().getLuaManager()->setupPlayer(ptr);
}
void World::renderPlayer()
{
MWBase::Environment::get().getMechanicsManager()->remove(getPlayerPtr(), true);
MWWorld::Ptr player = getPlayerPtr();
mRendering->renderPlayer(player);
MWRender::NpcAnimation* anim = static_cast<MWRender::NpcAnimation*>(mRendering->getAnimation(player));
player.getClass().getInventoryStore(player).setInvListener(anim);
player.getClass().getInventoryStore(player).setContListener(anim);
scaleObject(player, player.getCellRef().getScale(), true); // apply race height
rotateObject(player, osg::Vec3f(), MWBase::RotationFlag_inverseOrder | MWBase::RotationFlag_adjust);
MWBase::Environment::get().getMechanicsManager()->add(getPlayerPtr());
MWBase::Environment::get().getWindowManager()->watchActor(getPlayerPtr());
mPhysics->remove(getPlayerPtr());
mPhysics->addActor(
getPlayerPtr(), VFS::Path::toNormalized(getPlayerPtr().getClass().getCorrectedModel(getPlayerPtr())));
applyLoopingParticles(player);
const DetourNavigator::AgentBounds agentBounds = getPathfindingAgentBounds(getPlayerConstPtr());
if (!mNavigator->addAgent(agentBounds))
Log(Debug::Warning) << "Player agent bounds are not supported by navigator: " << agentBounds;
}
World::RestPermitted World::canRest() const
{
CellStore* currentCell = mWorldScene->getCurrentCell();
Ptr player = mPlayer->getPlayer();
RefData& refdata = player.getRefData();
osg::Vec3f playerPos(refdata.getPosition().asVec3());
const MWPhysics::Actor* actor = mPhysics->getActor(player);
if (!actor)
throw std::runtime_error("can't find player");
if (mPlayer->enemiesNearby())
return Rest_EnemiesAreNearby;
if (isUnderwater(currentCell, playerPos) || isWalkingOnWater(player))
return Rest_PlayerIsUnderwater;
float fallHeight = player.getClass().getCreatureStats(player).getFallHeight();
float epsilon = 1e-4;
if ((actor->getCollisionMode() && (!mPhysics->isOnSolidGround(player) || fallHeight >= epsilon))
|| isFlying(player))
return Rest_PlayerIsInAir;
if (currentCell->getCell()->noSleep() || player.getClass().getNpcStats(player).isWerewolf())
return Rest_OnlyWaiting;
return Rest_Allowed;
}
MWRender::Animation* World::getAnimation(const MWWorld::Ptr& ptr)
{
auto* animation = mRendering->getAnimation(ptr);
if (!animation)
{
mWorldScene->removeFromPagedRefs(ptr);
animation = mRendering->getAnimation(ptr);
if (animation)
mRendering->pagingBlacklistObject(mStore.find(ptr.getCellRef().getRefId()), ptr);
}
return animation;
}
const MWRender::Animation* World::getAnimation(const MWWorld::ConstPtr& ptr) const
{
return mRendering->getAnimation(ptr);
}
void World::screenshot(osg::Image* image, int w, int h)
{
mRendering->screenshot(image, w, h);
}
void World::activateDoor(const MWWorld::Ptr& door)
{
auto state = door.getClass().getDoorState(door);
switch (state)
{
case MWWorld::DoorState::Idle:
if (door.getRefData().getPosition().rot[2] == door.getCellRef().getPosition().rot[2])
state = MWWorld::DoorState::Opening; // if closed, then open
else
state = MWWorld::DoorState::Closing; // if open, then close
break;
case MWWorld::DoorState::Closing:
state = MWWorld::DoorState::Opening; // if closing, then open
break;
case MWWorld::DoorState::Opening:
default:
state = MWWorld::DoorState::Closing; // if opening, then close
break;
}
door.getClass().setDoorState(door, state);
mDoorStates[door] = state;
}
void World::activateDoor(const Ptr& door, MWWorld::DoorState state)
{
door.getClass().setDoorState(door, state);
mDoorStates[door] = state;
if (state == MWWorld::DoorState::Idle)
{
mDoorStates.erase(door);
rotateDoor(door, state, 1);
}
}
bool World::getPlayerStandingOn(const MWWorld::ConstPtr& object)
{
MWWorld::Ptr player = getPlayerPtr();
return mPhysics->isActorStandingOn(player, object);
}
bool World::getActorStandingOn(const MWWorld::ConstPtr& object)
{
std::vector<MWWorld::Ptr> actors;
mPhysics->getActorsStandingOn(object, actors);
return !actors.empty();
}
void World::getActorsStandingOn(const MWWorld::ConstPtr& object, std::vector<MWWorld::Ptr>& actors)
{
mPhysics->getActorsStandingOn(object, actors);
}
bool World::getPlayerCollidingWith(const MWWorld::ConstPtr& object)
{
return mPhysics->isObjectCollidingWith(object, MWPhysics::ScriptedCollisionType_Player);
}
bool World::getActorCollidingWith(const MWWorld::ConstPtr& object)
{
return mPhysics->isObjectCollidingWith(object, MWPhysics::ScriptedCollisionType_Actor);
}
void World::hurtStandingActors(const ConstPtr& object, float healthPerSecond)
{
if (MWBase::Environment::get().getWindowManager()->isGuiMode())
return;
std::vector<MWWorld::Ptr> actors;
mPhysics->getActorsStandingOn(object, actors);
for (const Ptr& actor : actors)
{
MWMechanics::CreatureStats& stats = actor.getClass().getCreatureStats(actor);
if (stats.isDead())
continue;
mPhysics->markAsNonSolid(object);
if (actor == getPlayerPtr() && mGodMode)
continue;
MWMechanics::DynamicStat<float> health = stats.getHealth();
health.setCurrent(health.getCurrent() - healthPerSecond * MWBase::Environment::get().getFrameDuration());
stats.setHealth(health);
if (healthPerSecond > 0.0f)
{
if (actor == getPlayerPtr())
MWBase::Environment::get().getWindowManager()->activateHitOverlay(false);
auto healthDamage = ESM::RefId::stringRefId("Health Damage");
if (!MWBase::Environment::get().getSoundManager()->getSoundPlaying(actor, healthDamage))
MWBase::Environment::get().getSoundManager()->playSound3D(actor, healthDamage, 1.0f, 1.0f);
}
}
}
void World::hurtCollidingActors(const ConstPtr& object, float healthPerSecond)
{
if (MWBase::Environment::get().getWindowManager()->isGuiMode())
return;
std::vector<Ptr> actors;
mPhysics->getActorsCollidingWith(object, actors);
for (const Ptr& actor : actors)
{
MWMechanics::CreatureStats& stats = actor.getClass().getCreatureStats(actor);
if (stats.isDead())
continue;
mPhysics->markAsNonSolid(object);
if (actor == getPlayerPtr() && mGodMode)
continue;
MWMechanics::DynamicStat<float> health = stats.getHealth();
health.setCurrent(health.getCurrent() - healthPerSecond * MWBase::Environment::get().getFrameDuration());
stats.setHealth(health);
if (healthPerSecond > 0.0f)
{
if (actor == getPlayerPtr())
MWBase::Environment::get().getWindowManager()->activateHitOverlay(false);
auto healthDamage = ESM::RefId::stringRefId("Health Damage");
if (!MWBase::Environment::get().getSoundManager()->getSoundPlaying(actor, healthDamage))
MWBase::Environment::get().getSoundManager()->playSound3D(actor, healthDamage, 1.0f, 1.0f);
}
}
}
float World::getWindSpeed()
{
if (isCellExterior() || isCellQuasiExterior())
return mWeatherManager->getWindSpeed();
else
return 0.f;
}
bool World::isInStorm() const
{
if (isCellExterior() || isCellQuasiExterior())
return mWeatherManager->isInStorm();
else
return false;
}
osg::Vec3f World::getStormDirection() const
{
if (isCellExterior() || isCellQuasiExterior())
return mWeatherManager->getStormDirection();
else
return osg::Vec3f(0, 1, 0);
}
struct GetContainersOwnedByVisitor
{
GetContainersOwnedByVisitor(const MWWorld::ConstPtr& owner, std::vector<MWWorld::Ptr>& out)
: mOwner(owner)
, mOut(out)
{
}
MWWorld::ConstPtr mOwner;
std::vector<MWWorld::Ptr>& mOut;
bool operator()(const MWWorld::Ptr& ptr)
{
if (ptr.mRef->isDeleted())
return true;
// vanilla Morrowind does not allow to sell items from containers with zero capacity
if (ptr.getClass().getCapacity(ptr) <= 0.f)
return true;
if (ptr.getCellRef().getOwner() == mOwner.getCellRef().getRefId())
mOut.push_back(ptr);
return true;
}
};
void World::getContainersOwnedBy(const MWWorld::ConstPtr& owner, std::vector<MWWorld::Ptr>& out)
{
for (CellStore* cellstore : mWorldScene->getActiveCells())
{
GetContainersOwnedByVisitor visitor(owner, out);
cellstore->forEachType<ESM::Container>(visitor);
}
}
void World::getItemsOwnedBy(const MWWorld::ConstPtr& npc, std::vector<MWWorld::Ptr>& out)
{
for (CellStore* cellstore : mWorldScene->getActiveCells())
{
cellstore->forEach([&](const auto& ptr) {
if (ptr.getRefData().getBaseNode() && ptr.getCellRef().getOwner() == npc.getCellRef().getRefId())
out.push_back(ptr);
return true;
});
}
}
bool World::getLOS(const MWWorld::ConstPtr& actor, const MWWorld::ConstPtr& targetActor)
{
if (!targetActor.getRefData().isEnabled() || !actor.getRefData().isEnabled())
return false; // cannot get LOS unless both NPC's are enabled
if (!targetActor.getRefData().getBaseNode() || !actor.getRefData().getBaseNode())
return false; // not in active cell
return mPhysics->getLineOfSight(actor, targetActor);
}
float World::getDistToNearestRayHit(const osg::Vec3f& from, const osg::Vec3f& dir, float maxDist, bool includeWater)
{
osg::Vec3f to(dir);
to.normalize();
to = from + (to * maxDist);
int collisionTypes
= MWPhysics::CollisionType_World | MWPhysics::CollisionType_HeightMap | MWPhysics::CollisionType_Door;
if (includeWater)
{
collisionTypes |= MWPhysics::CollisionType_Water;
}
MWPhysics::RayCastingResult result
= mPhysics->castRay(from, to, { MWWorld::Ptr() }, std::vector<MWWorld::Ptr>(), collisionTypes);
if (!result.mHit)
return maxDist;
else
return (result.mHitPos - from).length();
}
void World::enableActorCollision(const MWWorld::Ptr& actor, bool enable)
{
MWPhysics::Actor* physicActor = mPhysics->getActor(actor);
if (physicActor)
physicActor->enableCollisionBody(enable);
}
static std::optional<ESM::Position> searchMarkerPosition(const CellStore& cellStore, std::string_view editorId)
{
for (const MWWorld::LiveCellRef<ESM4::Static>& stat4 : cellStore.getReadOnlyEsm4Statics().mList)
{
if (Misc::StringUtils::lowerCase(stat4.mBase->mEditorId) == editorId)
return stat4.mRef.getPosition();
}
return std::nullopt;
}
static std::optional<ESM::Position> searchDoorDestInCell(const CellStore& cellStore)
{
ESM::RefId cellId = cellStore.getCell()->getId();
std::vector<const MWWorld::CellRef*> sortedDoors;
for (const MWWorld::LiveCellRef<ESM::Door>& door : cellStore.getReadOnlyDoors().mList)
{
if (!door.mRef.getTeleport())
continue;
sortedDoors.push_back(&door.mRef);
}
for (const MWWorld::LiveCellRef<ESM4::Door>& door : cellStore.getReadOnlyEsm4Doors().mList)
{
if (!door.mRef.getTeleport())
continue;
sortedDoors.push_back(&door.mRef);
}
// Sort teleporting doors alphabetically, first by ID, then by destination cell to make search consistent
std::sort(sortedDoors.begin(), sortedDoors.end(), [](const MWWorld::CellRef* lhs, const MWWorld::CellRef* rhs) {
if (lhs->getRefId() != rhs->getRefId())
return lhs->getRefId() < rhs->getRefId();
return lhs->getDestCell() < rhs->getDestCell();
});
WorldModel* worldModel = MWBase::Environment::get().getWorldModel();
for (const MWWorld::CellRef* door : sortedDoors)
{
const MWWorld::CellStore& source = worldModel->getCell(door->getDestCell());
// Find door leading to our current teleport door
// and use its destination to position inside cell.
// \note Using _any_ door pointed to the cell,
// not the one pointed to current door.
for (const MWWorld::LiveCellRef<ESM::Door>& destDoor : source.getReadOnlyDoors().mList)
{
if (cellId == destDoor.mRef.getDestCell())
{
ESM::Position doorDest = destDoor.mRef.getDoorDest();
doorDest.rot[0] = doorDest.rot[1] = doorDest.rot[2] = 0;
return doorDest;
}
}
for (const MWWorld::LiveCellRef<ESM4::Door>& destDoor : source.getReadOnlyEsm4Doors().mList)
{
if (cellId == destDoor.mRef.getDestCell())
return destDoor.mRef.getDoorDest();
}
}
return std::nullopt;
}
ESM::RefId World::findInteriorPosition(std::string_view name, ESM::Position& pos)
{
pos.rot[0] = pos.rot[1] = pos.rot[2] = 0;
pos.pos[0] = pos.pos[1] = pos.pos[2] = 0;
const MWWorld::CellStore* cellStore = mWorldModel.findInterior(name);
if (!cellStore)
return ESM::RefId();
ESM::RefId cellId = cellStore->getCell()->getId();
if (std::optional<ESM::Position> destPos = searchMarkerPosition(*cellStore, "cocmarkerheading"))
{
pos = *destPos;
return cellId;
}
if (std::optional<ESM::Position> destPos = searchDoorDestInCell(*cellStore))
{
pos = *destPos;
return cellId;
}
if (std::optional<ESM::Position> destPos = searchMarkerPosition(*cellStore, "xmarkerheading"))
{
pos = *destPos;
return cellId;
}
// Fall back to the first static location.
const MWWorld::CellRefList<ESM4::Static>::List& statics4 = cellStore->getReadOnlyEsm4Statics().mList;
if (!statics4.empty())
{
pos = statics4.begin()->mRef.getPosition();
pos.rot[0] = pos.rot[1] = pos.rot[2] = 0;
return cellId;
}
const MWWorld::CellRefList<ESM::Static>::List& statics = cellStore->getReadOnlyStatics().mList;
if (!statics.empty())
{
pos = statics.begin()->mRef.getPosition();
pos.rot[0] = pos.rot[1] = pos.rot[2] = 0;
return cellId;
}
return ESM::RefId();
}
ESM::RefId World::findExteriorPosition(std::string_view nameId, ESM::Position& pos)
{
pos.rot[0] = pos.rot[1] = pos.rot[2] = 0;
const MWWorld::CellStore* cellStore = mWorldModel.findCell(nameId);
if (cellStore != nullptr && !cellStore->isExterior())
return ESM::RefId();
if (!cellStore)
{
size_t comma = nameId.find(',');
if (comma != std::string::npos)
{
int x, y;
std::from_chars_result xResult = std::from_chars(nameId.data(), nameId.data() + comma, x);
std::from_chars_result yResult
= std::from_chars(nameId.data() + comma + 1, nameId.data() + nameId.size(), y);
if (xResult.ec == std::errc::result_out_of_range || yResult.ec == std::errc::result_out_of_range)
throw std::runtime_error("Cell coordinates out of range.");
else if (xResult.ec == std::errc{} && yResult.ec == std::errc{})
cellStore
= &mWorldModel.getExterior(ESM::ExteriorCellLocation(x, y, ESM::Cell::sDefaultWorldspaceId));
// ignore std::errc::invalid_argument, as this means that name probably refers to a interior cell
// instead of comma separated coordinates
}
}
if (!cellStore)
return ESM::RefId();
const MWWorld::Cell* ext = cellStore->getCell();
if (std::optional<ESM::Position> destPos = searchMarkerPosition(*cellStore, "cocmarkerheading"))
{
pos = *destPos;
return ext->getId();
}
if (std::optional<ESM::Position> destPos = searchMarkerPosition(*cellStore, "xmarkerheading"))
{
pos = *destPos;
return ext->getId();
}
int x = ext->getGridX();
int y = ext->getGridY();
const osg::Vec2f posFromIndex = indexToPosition(ESM::ExteriorCellLocation(x, y, ext->getWorldSpace()), true);
pos.pos[0] = posFromIndex.x();
pos.pos[1] = posFromIndex.y();
// Note: Z pos will be adjusted by adjustPosition later
pos.pos[2] = 0;
return ext->getId();
}
void World::enableTeleporting(bool enable)
{
mTeleportEnabled = enable;
}
bool World::isTeleportingEnabled() const
{
return mTeleportEnabled;
}
void World::enableLevitation(bool enable)
{
mLevitationEnabled = enable;
}
bool World::isLevitationEnabled() const
{
return mLevitationEnabled;
}
void World::reattachPlayerCamera()
{
mRendering->rebuildPtr(getPlayerPtr());
}
bool World::getGodModeState() const
{
return mGodMode;
}
bool World::toggleGodMode()
{
mGodMode = !mGodMode;
return mGodMode;
}
bool World::toggleScripts()
{
mScriptsEnabled = !mScriptsEnabled;
return mScriptsEnabled;
}
bool World::getScriptsEnabled() const
{
return mScriptsEnabled;
}
void World::loadContentFiles(const Files::Collections& fileCollections, const std::vector<std::string>& content,
ToUTF8::Utf8Encoder* encoder, Loading::Listener* listener)
{
GameContentLoader gameContentLoader;
EsmLoader esmLoader(mStore, mReaders, encoder, mESMVersions);
gameContentLoader.addLoader(".esm", esmLoader);
gameContentLoader.addLoader(".esp", esmLoader);
gameContentLoader.addLoader(".omwgame", esmLoader);
gameContentLoader.addLoader(".omwaddon", esmLoader);
gameContentLoader.addLoader(".project", esmLoader);
OMWScriptsLoader omwScriptsLoader(mStore);
gameContentLoader.addLoader(".omwscripts", omwScriptsLoader);
int idx = 0;
for (const std::string& file : content)
{
const auto filename = Files::pathFromUnicodeString(file);
const Files::MultiDirCollection& col
= fileCollections.getCollection(Files::pathToUnicodeString(filename.extension()));
if (col.doesExist(file))
{
gameContentLoader.load(col.getPath(file), idx, listener);
}
else
{
std::string message = "Failed loading " + file + ": the content file does not exist";
throw std::runtime_error(message);
}
idx++;
}
if (const auto v = esmLoader.getMasterFileFormat(); v.has_value() && *v == 0)
ensureNeededRecords(); // Insert records that may not be present in all versions of master files.
}
void World::loadGroundcoverFiles(const Files::Collections& fileCollections,
const std::vector<std::string>& groundcoverFiles, ToUTF8::Utf8Encoder* encoder, Loading::Listener* listener)
{
if (!Settings::groundcover().mEnabled)
return;
Log(Debug::Info) << "Loading groundcover:";
mGroundcoverStore.init(mStore.get<ESM::Static>(), fileCollections, groundcoverFiles, encoder, listener);
}
MWWorld::SpellCastState World::startSpellCast(const Ptr& actor)
{
MWMechanics::CreatureStats& stats = actor.getClass().getCreatureStats(actor);
std::string_view message;
MWWorld::SpellCastState result = MWWorld::SpellCastState::Success;
bool isPlayer = (actor == getPlayerPtr());
const ESM::RefId& selectedSpell = stats.getSpells().getSelectedSpell();
if (!selectedSpell.empty())
{
const ESM::Spell* spell = mStore.get<ESM::Spell>().find(selectedSpell);
int spellCost = MWMechanics::calcSpellCost(*spell);
// Check mana
bool godmode = (isPlayer && mGodMode);
MWMechanics::DynamicStat<float> magicka = stats.getMagicka();
if (spellCost > 0 && magicka.getCurrent() < spellCost && !godmode)
{
message = "#{sMagicInsufficientSP}";
result = MWWorld::SpellCastState::InsufficientMagicka;
}
// If this is a power, check if it was already used in the last 24h
if (result == MWWorld::SpellCastState::Success && spell->mData.mType == ESM::Spell::ST_Power
&& !stats.getSpells().canUsePower(spell))
{
message = "#{sPowerAlreadyUsed}";
result = MWWorld::SpellCastState::PowerAlreadyUsed;
}
if (result == MWWorld::SpellCastState::Success && !godmode)
{
// Reduce mana
magicka.setCurrent(magicka.getCurrent() - spellCost);
stats.setMagicka(magicka);
// Reduce fatigue (note that in the vanilla game, both GMSTs are 0, and there's no fatigue loss)
static const float fFatigueSpellBase
= mStore.get<ESM::GameSetting>().find("fFatigueSpellBase")->mValue.getFloat();
static const float fFatigueSpellMult
= mStore.get<ESM::GameSetting>().find("fFatigueSpellMult")->mValue.getFloat();
MWMechanics::DynamicStat<float> fatigue = stats.getFatigue();
const float normalizedEncumbrance = actor.getClass().getNormalizedEncumbrance(actor);
float fatigueLoss = spellCost * (fFatigueSpellBase + normalizedEncumbrance * fFatigueSpellMult);
fatigue.setCurrent(fatigue.getCurrent() - fatigueLoss);
stats.setFatigue(fatigue);
}
}
if (isPlayer && result != MWWorld::SpellCastState::Success)
MWBase::Environment::get().getWindowManager()->messageBox(message);
return result;
}
void World::castSpell(const Ptr& actor, bool scriptedSpell)
{
MWMechanics::CreatureStats& stats = actor.getClass().getCreatureStats(actor);
const bool casterIsPlayer = actor == MWMechanics::getPlayer();
MWWorld::Ptr target;
// For scripted spells we should not use hit contact
if (scriptedSpell)
{
if (!casterIsPlayer)
{
for (const auto& package : stats.getAiSequence())
{
if (package->getTypeId() == MWMechanics::AiPackageTypeId::Cast)
{
target = package->getTarget();
break;
}
}
}
}
else
{
if (casterIsPlayer)
target = getFacedObject();
if (target.isEmpty() || !target.getClass().hasToolTip(target))
{
// For actor targets, we want to use melee hit contact.
// This is to give a slight tolerance for errors, especially with creatures like the Skeleton that would
// be very hard to aim at otherwise.
// For object targets, we want the detailed shapes (rendering raycast).
// If we used the bounding boxes for static objects, then we would not be able to target e.g.
// objects lying on a shelf.
const float fCombatDistance = mStore.get<ESM::GameSetting>().find("fCombatDistance")->mValue.getFloat();
target = MWMechanics::getHitContact(actor, fCombatDistance).first;
if (target.isEmpty())
{
// Get the target using the facing direction from Head node
const osg::Vec3f origin = getActorHeadTransform(actor).getTrans();
const osg::Quat orient = osg::Quat(actor.getRefData().getPosition().rot[0], osg::Vec3f(-1, 0, 0))
* osg::Quat(actor.getRefData().getPosition().rot[2], osg::Vec3f(0, 0, -1));
const osg::Vec3f direction = orient * osg::Vec3f(0, 1, 0);
const osg::Vec3f dest = origin + direction * getMaxActivationDistance();
const MWRender::RenderingManager::RayResult result = mRendering->castRay(origin, dest, true, true);
if (result.mHit)
target = result.mHitObject;
}
}
}
osg::Vec3f hitPosition = actor.getRefData().getPosition().asVec3();
if (!target.isEmpty())
{
// Touch explosion placement doesn't depend on where the target was "touched".
// In Morrowind, it's at 0.7 of the actor's AABB height for actors
// or at 0.7 of the player's height for non-actors if the player is the caster
// This is probably meant to prevent the explosion from being too far above on large objects
// but it often puts the explosions way above small objects, so we'll deviate here
// and use the object's bounds when reasonable (it's $CURRENT_YEAR, we can afford that)
// Note collision object origin is intentionally not used
hitPosition = target.getRefData().getPosition().asVec3();
constexpr float explosionHeight = 0.7f;
float targetHeight = getHalfExtents(target).z() * 2.f;
if (!target.getClass().isActor() && casterIsPlayer)
{
const float playerHeight = getHalfExtents(actor).z() * 2.f;
targetHeight = std::min(targetHeight, playerHeight);
}
hitPosition.z() += targetHeight * explosionHeight;
}
const ESM::RefId& selectedSpell = stats.getSpells().getSelectedSpell();
MWMechanics::CastSpell cast(actor, target, false, scriptedSpell);
cast.mHitPosition = hitPosition;
if (!selectedSpell.empty())
{
const ESM::Spell* spell = mStore.get<ESM::Spell>().find(selectedSpell);
cast.cast(spell);
}
else if (actor.getClass().hasInventoryStore(actor))
{
MWWorld::InventoryStore& inv = actor.getClass().getInventoryStore(actor);
if (inv.getSelectedEnchantItem() != inv.end())
{
const auto& itemPtr = *inv.getSelectedEnchantItem();
cast.cast(itemPtr);
}
}
}
void World::launchProjectile(MWWorld::Ptr& actor, MWWorld::Ptr& projectile, const osg::Vec3f& worldPos,
const osg::Quat& orient, MWWorld::Ptr& bow, float speed, float attackStrength)
{
// An initial position of projectile can be outside shooter's collision box, so any object between shooter and
// launch position will be ignored. To avoid this issue, we should check for impact immediately before launch
// the projectile. So we cast a 1-yard-length ray from shooter to launch position and check if there are
// collisions in this area.
// TODO: as a better solutuon we should handle projectiles during physics update, not during world update.
const osg::Vec3f sourcePos = worldPos + orient * osg::Vec3f(0, -1, 0) * 64.f;
// Early out if the launch position is underwater
bool underwater = isUnderwater(MWMechanics::getPlayer().getCell(), worldPos);
if (underwater)
{
MWMechanics::projectileHit(actor, Ptr(), bow, projectile, worldPos, attackStrength);
mRendering->emitWaterRipple(worldPos);
return;
}
// For AI actors, get combat targets to use in the ray cast. Only those targets will return a positive hit
// result.
std::vector<MWWorld::Ptr> targetActors;
if (!actor.isEmpty() && actor.getClass().isActor() && actor != MWMechanics::getPlayer())
actor.getClass().getCreatureStats(actor).getAiSequence().getCombatTargets(targetActors);
// Check for impact, if yes, handle hit, if not, launch projectile
MWPhysics::RayCastingResult result = mPhysics->castRay(
sourcePos, worldPos, { actor }, targetActors, 0xff, MWPhysics::CollisionType_Projectile);
if (result.mHit)
MWMechanics::projectileHit(actor, result.mHitObject, bow, projectile, result.mHitPos, attackStrength);
else
mProjectileManager->launchProjectile(actor, projectile, worldPos, orient, bow, speed, attackStrength);
}
void World::launchMagicBolt(
const ESM::RefId& spellId, const MWWorld::Ptr& caster, const osg::Vec3f& fallbackDirection, ESM::RefNum item)
{
mProjectileManager->launchMagicBolt(spellId, caster, fallbackDirection, item);
}
void World::updateProjectilesCasters()
{
mProjectileManager->updateCasters();
}
void World::applyLoopingParticles(const MWWorld::Ptr& ptr) const
{
const MWWorld::Class& cls = ptr.getClass();
if (cls.isActor())
{
std::set<int> playing;
for (const auto& params : cls.getCreatureStats(ptr).getActiveSpells())
{
for (const auto& effect : params.getEffects())
{
if (playing.insert(effect.mEffectId).second)
{
const auto magicEffect = mStore.get<ESM::MagicEffect>().find(effect.mEffectId);
if (magicEffect->mData.mFlags & ESM::MagicEffect::ContinuousVfx)
MWMechanics::playEffects(ptr, *magicEffect, false);
}
}
}
}
}
const std::vector<std::string>& World::getContentFiles() const
{
return mContentFiles;
}
void World::breakInvisibility(const Ptr& actor)
{
actor.getClass().getCreatureStats(actor).getActiveSpells().purgeEffect(actor, ESM::MagicEffect::Invisibility);
// Normally updated once per frame, but here it is kinda important to do it right away.
MWBase::Environment::get().getMechanicsManager()->updateMagicEffects(actor);
}
bool World::useTorches() const
{
// If we are in exterior, check the weather manager.
// In interiors there are no precipitations and sun, so check the ambient
// Looks like pseudo-exteriors considered as interiors in this case
MWWorld::CellStore* cell = mPlayer->getPlayer().getCell();
if (cell->isExterior())
{
float hour = getTimeStamp().getHour();
return mWeatherManager->useTorches(hour);
}
else
{
const MWWorld::Cell& cellVariant = *cell->getCell();
uint32_t ambient = cellVariant.getMood().mAmbiantColor;
int ambientTotal = (ambient & 0xff) + ((ambient >> 8) & 0xff) + ((ambient >> 16) & 0xff);
return !cell->getCell()->noSleep() && ambientTotal <= 201;
}
}
float World::getSunVisibility() const
{
return mWeatherManager->getSunVisibility();
}
float World::getSunPercentage() const
{
return mWeatherManager->getSunPercentage(getTimeStamp().getHour());
}
bool World::findInteriorPositionInWorldSpace(const MWWorld::CellStore* cell, osg::Vec3f& result)
{
if (cell->isExterior())
return false;
// Search for a 'nearest' exterior, counting each cell between the starting
// cell and the exterior as a distance of 1. Will fail for isolated interiors.
std::set<ESM::RefId> checkedCells;
std::set<ESM::RefId> currentCells;
std::set<ESM::RefId> nextCells;
nextCells.insert(cell->getCell()->getId());
while (!nextCells.empty())
{
currentCells = nextCells;
nextCells.clear();
for (const auto& currentCell : currentCells)
{
MWWorld::CellStore& next = mWorldModel.getCell(currentCell);
// Check if any door in the cell leads to an exterior directly
for (const MWWorld::LiveCellRef<ESM::Door>& ref : next.getReadOnlyDoors().mList)
{
if (!ref.mRef.getTeleport())
continue;
if (ref.mRef.getDestCell().is<ESM::ESM3ExteriorCellRefId>())
{
ESM::Position pos = ref.mRef.getDoorDest();
result = pos.asVec3();
return true;
}
else
{
ESM::RefId dest = ref.mRef.getDestCell();
if (!checkedCells.count(dest) && !currentCells.count(dest))
nextCells.insert(dest);
}
}
checkedCells.insert(currentCell);
}
}
// No luck :(
return false;
}
MWWorld::ConstPtr World::getClosestMarker(const MWWorld::ConstPtr& ptr, const ESM::RefId& id)
{
if (ptr.getCell()->isExterior())
{
return getClosestMarkerFromExteriorPosition(mPlayer->getLastKnownExteriorPosition(), id);
}
// Search for a 'nearest' marker, counting each cell between the starting
// cell and the exterior as a distance of 1. If an exterior is found, jump
// to the nearest exterior marker, without further interior searching.
std::set<ESM::RefId> checkedCells;
std::set<ESM::RefId> currentCells;
std::set<ESM::RefId> nextCells;
MWWorld::ConstPtr closestMarker;
nextCells.insert(ptr.getCell()->getCell()->getId());
while (!nextCells.empty())
{
currentCells.clear();
std::swap(currentCells, nextCells);
for (const auto& cell : currentCells)
{
MWWorld::CellStore& next = mWorldModel.getCell(cell);
checkedCells.insert(cell);
closestMarker = next.searchConst(id);
if (!closestMarker.isEmpty())
{
return closestMarker;
}
// Check if any door in the cell leads to an exterior directly
for (const MWWorld::LiveCellRef<ESM::Door>& ref : next.getReadOnlyDoors().mList)
{
if (!ref.mRef.getTeleport())
continue;
if (ref.mRef.getDestCell().is<ESM::ESM3ExteriorCellRefId>())
{
osg::Vec3f worldPos = ref.mRef.getDoorDest().asVec3();
return getClosestMarkerFromExteriorPosition(worldPos, id);
}
else
{
const auto& dest = ref.mRef.getDestCell();
if (!checkedCells.contains(dest) && !currentCells.contains(dest))
nextCells.insert(dest);
}
}
}
}
return MWWorld::Ptr();
}
MWWorld::ConstPtr World::getClosestMarkerFromExteriorPosition(const osg::Vec3f& worldPos, const ESM::RefId& id)
{
const ESM::ExteriorCellLocation posIndex = ESM::positionToExteriorCellLocation(worldPos.x(), worldPos.y());
// Potential optimization: don't scan the entire world for markers and actually do the Todd spiral
std::vector<Ptr> markers;
mWorldModel.getExteriorPtrs(id, markers);
struct MarkerInfo
{
Ptr mPtr;
int mColumn, mRow; // Local coordinates in the valid marker grid
};
std::vector<MarkerInfo> validMarkers;
validMarkers.reserve(markers.size());
// The idea is to collect all markers that belong to the smallest possible square grid around worldPos
// They are grouped with their position on that grid's edge where the origin is the SW corner
int minGridSize = std::numeric_limits<int>::max();
for (const Ptr& marker : markers)
{
const osg::Vec3f markerPos = marker.getRefData().getPosition().asVec3();
const ESM::ExteriorCellLocation index = ESM::positionToExteriorCellLocation(markerPos.x(), markerPos.y());
const int deltaX = index.mX - posIndex.mX;
const int deltaY = index.mY - posIndex.mY;
const int gridSize = std::max(std::abs(deltaX), std::abs(deltaY)) * 2;
if (gridSize == 0)
return marker;
if (gridSize <= minGridSize)
{
if (gridSize < minGridSize)
{
validMarkers.clear();
minGridSize = gridSize;
}
validMarkers.push_back({ marker, gridSize / 2 + deltaX, gridSize / 2 + deltaY });
}
}
ConstPtr closestMarker;
if (validMarkers.empty())
return closestMarker;
if (validMarkers.size() == 1)
return validMarkers[0].mPtr;
// All the markers are on the edge of the grid
// Break ties by picking the earliest marker on SW -> SE -> NE -> NW -> SW path
int earliestDistance = std::numeric_limits<int>::max();
for (const MarkerInfo& marker : validMarkers)
{
int distance = 0;
if (marker.mRow == 0) // South edge (plus SW and SE corners)
distance = marker.mColumn;
else if (marker.mColumn == minGridSize) // East edge and NE corner
distance = minGridSize + marker.mRow;
else if (marker.mRow == minGridSize) // North edge and NW corner
distance = minGridSize * 3 - marker.mColumn;
else // West edge
distance = minGridSize * 4 - marker.mRow;
if (distance < earliestDistance)
{
closestMarker = marker.mPtr;
earliestDistance = distance;
}
}
return closestMarker;
}
void World::rest(double hours)
{
mWorldModel.forEachLoadedCellStore([hours](CellStore& store) { store.rest(hours); });
}
void World::rechargeItems(double duration, bool activeOnly)
{
MWWorld::Ptr player = getPlayerPtr();
player.getClass().getInventoryStore(player).rechargeItems(duration);
if (activeOnly)
{
for (auto& cell : mWorldScene->getActiveCells())
{
cell->recharge(duration);
}
}
else
mWorldModel.forEachLoadedCellStore([duration](CellStore& store) { store.recharge(duration); });
}
void World::teleportToClosestMarker(const MWWorld::Ptr& ptr, const ESM::RefId& id)
{
MWWorld::ConstPtr closestMarker = getClosestMarker(ptr, id);
if (closestMarker.isEmpty())
{
Log(Debug::Warning) << "Failed to teleport: no closest marker found";
return;
}
ESM::RefId cellId = closestMarker.mCell->getCell()->getId();
MWWorld::ActionTeleport action(cellId, closestMarker.getRefData().getPosition(), false);
action.execute(ptr);
}
void World::updateWeather(float duration, bool paused)
{
bool isExterior = isCellExterior() || isCellQuasiExterior();
if (mPlayer->wasTeleported())
{
mPlayer->setTeleported(false);
const ESM::RefId& playerRegion = getPlayerPtr().getCell()->getCell()->getRegion();
mWeatherManager->playerTeleported(playerRegion, isExterior);
}
const TimeStamp time = getTimeStamp();
mWeatherManager->update(duration, paused, time, isExterior);
}
struct AddDetectedReferenceVisitor
{
std::vector<Ptr>& mOut;
Ptr mDetector;
float mSquaredDist;
World::DetectionType mType;
const MWWorld::ESMStore& mStore;
bool operator()(const MWWorld::Ptr& ptr)
{
if ((ptr.getRefData().getPosition().asVec3() - mDetector.getRefData().getPosition().asVec3()).length2()
>= mSquaredDist)
return true;
if (!ptr.getRefData().isEnabled() || ptr.mRef->isDeleted())
return true;
// Consider references inside containers as well (except if we are looking for a Creature, they cannot be in
// containers)
bool isContainer = ptr.getClass().getType() == ESM::Container::sRecordId;
if (mType != World::Detect_Creature && (ptr.getClass().isActor() || isContainer))
{
// but ignore containers without resolved content
if (isContainer && ptr.getRefData().getCustomData() == nullptr)
{
for (const auto& containerItem : ptr.get<ESM::Container>()->mBase->mInventory.mList)
{
if (containerItem.mCount)
{
try
{
ManualRef ref(mStore, containerItem.mItem, containerItem.mCount);
if (needToAdd(ref.getPtr(), mDetector))
{
mOut.push_back(ptr);
return true;
}
}
catch (const std::exception& e)
{
Log(Debug::Warning)
<< "Failed to process container item " << containerItem.mItem << ": " << e.what();
}
}
}
return true;
}
MWWorld::ContainerStore& store = ptr.getClass().getContainerStore(ptr);
{
for (MWWorld::ContainerStoreIterator it = store.begin(); it != store.end(); ++it)
{
if (needToAdd(*it, mDetector))
{
mOut.push_back(ptr);
return true;
}
}
}
}
if (needToAdd(ptr, mDetector))
mOut.push_back(ptr);
return true;
}
bool needToAdd(const MWWorld::Ptr& ptr, const MWWorld::Ptr& detector)
{
if (mType == World::Detect_Creature)
{
// If in werewolf form, this detects only NPCs, otherwise only creatures
if (detector.getClass().isNpc() && detector.getClass().getNpcStats(detector).isWerewolf())
{
if (ptr.getClass().getType() != ESM::NPC::sRecordId)
return false;
}
else if (ptr.getClass().getType() != ESM::Creature::sRecordId)
return false;
if (ptr.getClass().getCreatureStats(ptr).isDead())
return false;
}
if (mType == World::Detect_Key && !ptr.getClass().isKey(ptr))
return false;
if (mType == World::Detect_Enchantment && ptr.getClass().getEnchantment(ptr).empty())
return false;
return true;
}
};
void World::listDetectedReferences(const Ptr& ptr, std::vector<Ptr>& out, DetectionType type)
{
const MWMechanics::MagicEffects& effects = ptr.getClass().getCreatureStats(ptr).getMagicEffects();
float dist = 0;
if (type == World::Detect_Creature)
dist = effects.getOrDefault(ESM::MagicEffect::DetectAnimal).getMagnitude();
else if (type == World::Detect_Key)
dist = effects.getOrDefault(ESM::MagicEffect::DetectKey).getMagnitude();
else if (type == World::Detect_Enchantment)
dist = effects.getOrDefault(ESM::MagicEffect::DetectEnchantment).getMagnitude();
if (!dist)
return;
dist = feetToGameUnits(dist);
AddDetectedReferenceVisitor visitor{ out, ptr, dist * dist, type, mStore };
for (CellStore* cellStore : mWorldScene->getActiveCells())
{
cellStore->forEach(visitor);
}
}
float World::feetToGameUnits(float feet)
{
// Original engine rounds size upward
static const int unitsPerFoot = ceil(Constants::UnitsPerFoot);
return feet * unitsPerFoot;
}
float World::getActivationDistancePlusTelekinesis()
{
float telekinesisRangeBonus = mPlayer->getPlayer()
.getClass()
.getCreatureStats(mPlayer->getPlayer())
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Telekinesis)
.getMagnitude();
telekinesisRangeBonus = feetToGameUnits(telekinesisRangeBonus);
float activationDistance = getMaxActivationDistance() + telekinesisRangeBonus;
return activationDistance;
}
MWWorld::Ptr World::getPlayerPtr()
{
return mPlayer->getPlayer();
}
MWWorld::ConstPtr World::getPlayerConstPtr() const
{
return mPlayer->getConstPlayer();
}
void World::updateDialogueGlobals()
{
MWWorld::Ptr player = getPlayerPtr();
int bounty = player.getClass().getNpcStats(player).getBounty();
int playerGold = player.getClass().getContainerStore(player).count(ContainerStore::sGoldId);
static float fCrimeGoldDiscountMult
= mStore.get<ESM::GameSetting>().find("fCrimeGoldDiscountMult")->mValue.getFloat();
static float fCrimeGoldTurnInMult
= mStore.get<ESM::GameSetting>().find("fCrimeGoldTurnInMult")->mValue.getFloat();
int discount = static_cast<int>(bounty * fCrimeGoldDiscountMult);
int turnIn = static_cast<int>(bounty * fCrimeGoldTurnInMult);
if (bounty > 0)
{
discount = std::max(1, discount);
turnIn = std::max(1, turnIn);
}
mGlobalVariables[Globals::sPCHasCrimeGold].setInteger((bounty <= playerGold) ? 1 : 0);
mGlobalVariables[Globals::sPCHasGoldDiscount].setInteger((discount <= playerGold) ? 1 : 0);
mGlobalVariables[Globals::sCrimeGoldDiscount].setInteger(discount);
mGlobalVariables[Globals::sCrimeGoldTurnIn].setInteger(turnIn);
mGlobalVariables[Globals::sPCHasTurnIn].setInteger((turnIn <= playerGold) ? 1 : 0);
}
void World::confiscateStolenItems(const Ptr& ptr)
{
MWWorld::ConstPtr prisonMarker = getClosestMarker(ptr, ESM::RefId::stringRefId("prisonmarker"));
if (prisonMarker.isEmpty())
{
Log(Debug::Warning) << "Failed to confiscate items: no closest prison marker found.";
return;
}
ESM::RefId prisonName = prisonMarker.getCellRef().getDestCell();
if (prisonName.empty())
{
Log(Debug::Warning) << "Failed to confiscate items: prison marker not linked to prison interior";
return;
}
MWWorld::CellStore& prison = mWorldModel.getCell(prisonName);
MWWorld::Ptr closestChest = prison.search(ESM::RefId::stringRefId("stolen_goods"));
if (!closestChest.isEmpty()) // Found a close chest
{
MWBase::Environment::get().getMechanicsManager()->confiscateStolenItems(ptr, closestChest);
}
else
Log(Debug::Warning) << "Failed to confiscate items: no stolen_goods container found";
}
void World::goToJail()
{
const MWWorld::Ptr player = getPlayerPtr();
if (!mGoToJail)
{
// Reset bounty and forget the crime now, but don't change cell yet (the player should be able to read the
// dialog text first)
mGoToJail = true;
mPlayerInJail = true;
int bounty = player.getClass().getNpcStats(player).getBounty();
player.getClass().getNpcStats(player).setBounty(0);
mPlayer->recordCrimeId();
confiscateStolenItems(player);
static int iDaysinPrisonMod = mStore.get<ESM::GameSetting>().find("iDaysinPrisonMod")->mValue.getInteger();
mDaysInPrison = std::max(1, bounty / iDaysinPrisonMod);
return;
}
else
{
if (MWBase::Environment::get().getMechanicsManager()->isAttackPreparing(player))
{
player.getClass().getCreatureStats(player).setAttackingOrSpell(false);
}
mPlayer->setDrawState(MWMechanics::DrawState::Nothing);
mGoToJail = false;
MWBase::Environment::get().getWindowManager()->removeGuiMode(MWGui::GM_Dialogue);
MWBase::Environment::get().getWindowManager()->goToJail(mDaysInPrison);
}
}
bool World::isPlayerInJail() const
{
return mPlayerInJail;
}
void World::setPlayerTraveling(bool traveling)
{
mPlayerTraveling = traveling;
}
bool World::isPlayerTraveling() const
{
return mPlayerTraveling;
}
float World::getTerrainHeightAt(const osg::Vec3f& worldPos, ESM::RefId worldspace) const
{
return mRendering->getTerrainHeightAt(worldPos, worldspace);
}
osg::Vec3f World::getHalfExtents(const ConstPtr& object, bool rendering) const
{
if (!object.getClass().isActor())
return mRendering->getHalfExtents(object);
// Handle actors separately because of bodyparts
if (rendering)
return mPhysics->getRenderingHalfExtents(object);
else
return mPhysics->getHalfExtents(object);
}
std::filesystem::path World::exportSceneGraph(const Ptr& ptr)
{
auto file = mUserDataPath / "openmw.osgt";
if (!ptr.isEmpty())
{
mRendering->pagingBlacklistObject(mStore.find(ptr.getCellRef().getRefId()), ptr);
mWorldScene->removeFromPagedRefs(ptr);
}
mRendering->exportSceneGraph(ptr, file, "Ascii");
return file;
}
void World::spawnRandomCreature(const ESM::RefId& creatureList)
{
const ESM::CreatureLevList* list = mStore.get<ESM::CreatureLevList>().find(creatureList);
static int iNumberCreatures = mStore.get<ESM::GameSetting>().find("iNumberCreatures")->mValue.getInteger();
int numCreatures = 1 + Misc::Rng::rollDice(iNumberCreatures, mPrng); // [1, iNumberCreatures]
for (int i = 0; i < numCreatures; ++i)
{
const ESM::RefId& selectedCreature = MWMechanics::getLevelledItem(list, true, mPrng);
if (selectedCreature.empty())
continue;
MWWorld::ManualRef ref(mStore, selectedCreature, 1);
safePlaceObject(ref.getPtr(), getPlayerPtr(), getPlayerPtr().getCell(), 0, 220.f);
}
}
void World::spawnBloodEffect(const Ptr& ptr, const osg::Vec3f& worldPosition)
{
if (ptr == getPlayerPtr() && Settings::gui().mHitFader)
return;
std::string_view texture
= Fallback::Map::getString("Blood_Texture_" + std::to_string(ptr.getClass().getBloodTexture(ptr)));
if (texture.empty())
texture = Fallback::Map::getString("Blood_Texture_0");
VFS::Path::Normalized model(Misc::ResourceHelpers::correctMeshPath(std::string{
Fallback::Map::getString("Blood_Model_" + std::to_string(Misc::Rng::rollDice(3))) } /*[0, 2]*/));
mRendering->spawnEffect(model, texture, worldPosition, 1.0f, false);
}
void World::spawnEffect(VFS::Path::NormalizedView model, const std::string& textureOverride,
const osg::Vec3f& worldPos, float scale, bool isMagicVFX)
{
mRendering->spawnEffect(model, textureOverride, worldPos, scale, isMagicVFX);
}
struct ResetActorsVisitor
{
World& mWorld;
bool operator()(const Ptr& ptr)
{
if (ptr.getClass().isActor() && ptr.getCellRef().hasContentFile())
{
if (ptr.getCell()->movedHere(ptr))
return true;
const ESM::Position& origPos = ptr.getCellRef().getPosition();
mWorld.moveObject(ptr, origPos.asVec3());
mWorld.rotateObject(ptr, origPos.asRotationVec3());
ptr.getClass().adjustPosition(ptr, true);
}
return true;
}
};
void World::resetActors()
{
for (CellStore* cellstore : mWorldScene->getActiveCells())
{
ResetActorsVisitor visitor{ *this };
cellstore->forEach(visitor);
}
}
bool World::isWalkingOnWater(const ConstPtr& actor) const
{
const MWPhysics::Actor* physicActor = mPhysics->getActor(actor);
if (physicActor && physicActor->isWalkingOnWater())
return true;
return false;
}
osg::Vec3f World::aimToTarget(const ConstPtr& actor, const ConstPtr& target, bool isRangedCombat)
{
osg::Vec3f weaponPos = actor.getRefData().getPosition().asVec3();
float heightRatio = isRangedCombat ? 2.f * Constants::TorsoHeight : 1.f;
weaponPos.z() += mPhysics->getHalfExtents(actor).z() * heightRatio;
osg::Vec3f targetPos = mPhysics->getCollisionObjectPosition(target);
return (targetPos - weaponPos);
}
namespace
{
void preload(MWWorld::Scene* scene, const ESMStore& store, const ESM::RefId& obj)
{
if (obj.empty())
return;
try
{
MWWorld::ManualRef ref(store, obj);
std::string model = ref.getPtr().getClass().getCorrectedModel(ref.getPtr());
if (!model.empty())
scene->preload(model, ref.getPtr().getClass().useAnim());
}
catch (const std::exception& e)
{
Log(Debug::Warning) << "Failed to preload scene object " << obj << ": " << e.what();
}
}
}
void World::preloadEffects(const ESM::EffectList* effectList)
{
for (const ESM::IndexedENAMstruct& effectInfo : effectList->mList)
{
const ESM::MagicEffect* effect = mStore.get<ESM::MagicEffect>().find(effectInfo.mData.mEffectID);
if (MWMechanics::isSummoningEffect(effectInfo.mData.mEffectID))
{
preload(mWorldScene.get(), mStore, ESM::RefId::stringRefId("VFX_Summon_Start"));
preload(mWorldScene.get(), mStore, MWMechanics::getSummonedCreature(effectInfo.mData.mEffectID));
}
preload(mWorldScene.get(), mStore, effect->mCasting);
preload(mWorldScene.get(), mStore, effect->mHit);
if (effectInfo.mData.mArea > 0)
preload(mWorldScene.get(), mStore, effect->mArea);
if (effectInfo.mData.mRange == ESM::RT_Target)
preload(mWorldScene.get(), mStore, effect->mBolt);
}
}
DetourNavigator::Navigator* World::getNavigator() const
{
return mNavigator.get();
}
void World::updateActorPath(const MWWorld::ConstPtr& actor, const std::deque<osg::Vec3f>& path,
const DetourNavigator::AgentBounds& agentBounds, const osg::Vec3f& start, const osg::Vec3f& end) const
{
mRendering->updateActorPath(actor, path, agentBounds, start, end);
}
void World::removeActorPath(const MWWorld::ConstPtr& actor) const
{
mRendering->removeActorPath(actor);
}
void World::setNavMeshNumberToRender(const std::size_t value)
{
mRendering->setNavMeshNumber(value);
}
DetourNavigator::AgentBounds World::getPathfindingAgentBounds(const MWWorld::ConstPtr& actor) const
{
const MWPhysics::Actor* physicsActor = mPhysics->getActor(actor);
if (physicsActor == nullptr || !actor.isInCell() || actor.getCell()->isExterior())
return DetourNavigator::AgentBounds{ Settings::game().mActorCollisionShapeType,
Settings::game().mDefaultActorPathfindHalfExtents };
else
return DetourNavigator::AgentBounds{ physicsActor->getCollisionShapeType(),
physicsActor->getHalfExtents() };
}
bool World::hasCollisionWithDoor(
const MWWorld::ConstPtr& door, const osg::Vec3f& position, const osg::Vec3f& destination) const
{
const auto object = mPhysics->getObject(door);
if (!object)
return false;
btVector3 aabbMin;
btVector3 aabbMax;
object->getShapeInstance()->mCollisionShape->getAabb(btTransform::getIdentity(), aabbMin, aabbMax);
const auto toLocal = object->getTransform().inverse();
const auto localFrom = toLocal(Misc::Convert::toBullet(position));
const auto localTo = toLocal(Misc::Convert::toBullet(destination));
btScalar hitDistance = 1;
btVector3 hitNormal;
return btRayAabb(localFrom, localTo, aabbMin, aabbMax, hitDistance, hitNormal);
}
bool World::isAreaOccupiedByOtherActor(const osg::Vec3f& position, const float radius,
std::span<const MWWorld::ConstPtr> ignore, std::vector<MWWorld::Ptr>* occupyingActors) const
{
return mPhysics->isAreaOccupiedByOtherActor(position, radius, ignore, occupyingActors);
}
void World::reportStats(unsigned int frameNumber, osg::Stats& stats) const
{
DetourNavigator::reportStats(mNavigator->getStats(), frameNumber, stats);
mPhysics->reportStats(frameNumber, stats);
mWorldScene->reportStats(frameNumber, stats);
}
std::vector<MWWorld::Ptr> World::getAll(const ESM::RefId& id)
{
return mWorldModel.getAll(id);
}
Misc::Rng::Generator& World::getPrng()
{
return mPrng;
}
MWRender::PostProcessor* World::getPostProcessor()
{
return mRendering->getPostProcessor();
}
void World::setActorActive(const MWWorld::Ptr& ptr, bool value)
{
if (MWPhysics::Actor* const actor = mPhysics->getActor(ptr))
actor->setActive(value);
}
}
| 143,123
|
C++
|
.cpp
| 3,281
| 32.61719
| 120
| 0.593758
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,300
|
pickpocket.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/pickpocket.cpp
|
#include "pickpocket.hpp"
#include <components/misc/rng.hpp>
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
#include "npcstats.hpp"
namespace MWMechanics
{
Pickpocket::Pickpocket(const MWWorld::Ptr& thief, const MWWorld::Ptr& victim)
: mThief(thief)
, mVictim(victim)
{
}
float Pickpocket::getChanceModifier(const MWWorld::Ptr& ptr, float add)
{
NpcStats& stats = ptr.getClass().getNpcStats(ptr);
float agility = stats.getAttribute(ESM::Attribute::Agility).getModified();
float luck = stats.getAttribute(ESM::Attribute::Luck).getModified();
float sneak = static_cast<float>(ptr.getClass().getSkill(ptr, ESM::Skill::Sneak));
return (add + 0.2f * agility + 0.1f * luck + sneak) * stats.getFatigueTerm();
}
bool Pickpocket::getDetected(float valueTerm)
{
float x = getChanceModifier(mThief);
float y = getChanceModifier(mVictim, valueTerm);
float t = 2 * x - y;
float pcSneak = static_cast<float>(mThief.getClass().getSkill(mThief, ESM::Skill::Sneak));
int iPickMinChance = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("iPickMinChance")
->mValue.getInteger();
int iPickMaxChance = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("iPickMaxChance")
->mValue.getInteger();
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
int roll = Misc::Rng::roll0to99(prng);
if (t < pcSneak / iPickMinChance)
{
return (roll > int(pcSneak / iPickMinChance));
}
else
{
t = std::min(float(iPickMaxChance), t);
return (roll > int(t));
}
}
bool Pickpocket::pick(const MWWorld::Ptr& item, int count)
{
float stackValue = static_cast<float>(item.getClass().getValue(item) * count);
float fPickPocketMod = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fPickPocketMod")
->mValue.getFloat();
float valueTerm = 10 * fPickPocketMod * stackValue;
return getDetected(valueTerm);
}
bool Pickpocket::finish()
{
return getDetected(0.f);
}
}
| 2,713
|
C++
|
.cpp
| 66
| 29.151515
| 98
| 0.549392
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,301
|
objects.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/objects.cpp
|
#include "objects.hpp"
#include <components/debug/debuglog.hpp>
#include <components/esm3/loadcont.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "character.hpp"
namespace MWMechanics
{
void Objects::addObject(const MWWorld::Ptr& ptr)
{
removeObject(ptr);
MWRender::Animation* anim = MWBase::Environment::get().getWorld()->getAnimation(ptr);
if (anim == nullptr)
return;
const auto it = mObjects.emplace(mObjects.end(), ptr, anim);
mIndex.emplace(ptr.mRef, it);
}
void Objects::removeObject(const MWWorld::Ptr& ptr)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
{
mObjects.erase(iter->second);
mIndex.erase(iter);
}
}
void Objects::updateObject(const MWWorld::Ptr& old, const MWWorld::Ptr& ptr)
{
const auto iter = mIndex.find(old.mRef);
if (iter != mIndex.end())
iter->second->updatePtr(ptr);
}
void Objects::dropObjects(const MWWorld::CellStore* cellStore)
{
for (auto iter = mObjects.begin(); iter != mObjects.end();)
{
if (iter->getPtr().getCell() == cellStore)
{
mIndex.erase(iter->getPtr().mRef);
iter = mObjects.erase(iter);
}
else
++iter;
}
}
void Objects::update(float duration, bool paused)
{
if (!paused)
{
for (CharacterController& object : mObjects)
object.update(duration);
}
else
{
// We still should play container opening animation in the Container GUI mode.
MWGui::GuiMode mode = MWBase::Environment::get().getWindowManager()->getMode();
if (mode != MWGui::GM_Container)
return;
for (CharacterController& object : mObjects)
{
if (object.getPtr().getType() != ESM::Container::sRecordId)
continue;
if (object.isAnimPlaying("containeropen"))
{
object.update(duration);
MWBase::Environment::get().getWorld()->updateAnimatedCollisionShape(object.getPtr());
}
}
}
}
bool Objects::onOpen(const MWWorld::Ptr& ptr)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
return iter->second->onOpen();
return true;
}
void Objects::onClose(const MWWorld::Ptr& ptr)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->onClose();
}
bool Objects::playAnimationGroup(
const MWWorld::Ptr& ptr, std::string_view groupName, int mode, uint32_t number, bool scripted)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
{
return iter->second->playGroup(groupName, mode, number, scripted);
}
else
{
Log(Debug::Warning) << "Warning: Objects::playAnimationGroup: Unable to find "
<< ptr.getCellRef().getRefId();
return false;
}
}
bool Objects::playAnimationGroupLua(const MWWorld::Ptr& ptr, std::string_view groupName, uint32_t loops,
float speed, std::string_view startKey, std::string_view stopKey, bool forceLoop)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
return iter->second->playGroupLua(groupName, speed, startKey, stopKey, loops, forceLoop);
return false;
}
void Objects::enableLuaAnimations(const MWWorld::Ptr& ptr, bool enable)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->enableLuaAnimations(enable);
}
void Objects::skipAnimation(const MWWorld::Ptr& ptr)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->skipAnim();
}
void Objects::persistAnimationStates()
{
for (CharacterController& object : mObjects)
object.persistAnimationState();
}
void Objects::clearAnimationQueue(const MWWorld::Ptr& ptr, bool clearScripted)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->clearAnimQueue(clearScripted);
}
void Objects::getObjectsInRange(const osg::Vec3f& position, float radius, std::vector<MWWorld::Ptr>& out) const
{
for (const CharacterController& object : mObjects)
if ((position - object.getPtr().getRefData().getPosition().asVec3()).length2() <= radius * radius)
out.push_back(object.getPtr());
}
}
| 4,912
|
C++
|
.cpp
| 137
| 26.715328
| 115
| 0.583333
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,302
|
summoning.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/summoning.cpp
|
#include "summoning.hpp"
#include <components/debug/debuglog.hpp>
#include <components/esm/refid.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/misc/resourcehelpers.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwworld/manualref.hpp"
#include "../mwrender/animation.hpp"
#include "aifollow.hpp"
#include "creaturestats.hpp"
namespace MWMechanics
{
bool isSummoningEffect(int effectId)
{
return ((effectId >= ESM::MagicEffect::SummonScamp && effectId <= ESM::MagicEffect::SummonStormAtronach)
|| (effectId == ESM::MagicEffect::SummonCenturionSphere)
|| (effectId >= ESM::MagicEffect::SummonFabricant && effectId <= ESM::MagicEffect::SummonCreature05));
}
static const std::map<int, ESM::RefId>& getSummonMap()
{
static std::map<int, ESM::RefId> summonMap;
if (summonMap.size() > 0)
return summonMap;
const std::map<int, std::string_view> summonMapToGameSetting{
{ ESM::MagicEffect::SummonAncestralGhost, "sMagicAncestralGhostID" },
{ ESM::MagicEffect::SummonBonelord, "sMagicBonelordID" },
{ ESM::MagicEffect::SummonBonewalker, "sMagicLeastBonewalkerID" },
{ ESM::MagicEffect::SummonCenturionSphere, "sMagicCenturionSphereID" },
{ ESM::MagicEffect::SummonClannfear, "sMagicClannfearID" },
{ ESM::MagicEffect::SummonDaedroth, "sMagicDaedrothID" },
{ ESM::MagicEffect::SummonDremora, "sMagicDremoraID" },
{ ESM::MagicEffect::SummonFabricant, "sMagicFabricantID" },
{ ESM::MagicEffect::SummonFlameAtronach, "sMagicFlameAtronachID" },
{ ESM::MagicEffect::SummonFrostAtronach, "sMagicFrostAtronachID" },
{ ESM::MagicEffect::SummonGoldenSaint, "sMagicGoldenSaintID" },
{ ESM::MagicEffect::SummonGreaterBonewalker, "sMagicGreaterBonewalkerID" },
{ ESM::MagicEffect::SummonHunger, "sMagicHungerID" },
{ ESM::MagicEffect::SummonScamp, "sMagicScampID" },
{ ESM::MagicEffect::SummonSkeletalMinion, "sMagicSkeletalMinionID" },
{ ESM::MagicEffect::SummonStormAtronach, "sMagicStormAtronachID" },
{ ESM::MagicEffect::SummonWingedTwilight, "sMagicWingedTwilightID" },
{ ESM::MagicEffect::SummonWolf, "sMagicCreature01ID" },
{ ESM::MagicEffect::SummonBear, "sMagicCreature02ID" },
{ ESM::MagicEffect::SummonBonewolf, "sMagicCreature03ID" },
{ ESM::MagicEffect::SummonCreature04, "sMagicCreature04ID" },
{ ESM::MagicEffect::SummonCreature05, "sMagicCreature05ID" },
};
for (const auto& it : summonMapToGameSetting)
{
summonMap[it.first] = ESM::RefId::stringRefId(
MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>().find(it.second)->mValue.getString());
}
return summonMap;
}
ESM::RefId getSummonedCreature(int effectId)
{
const auto& summonMap = getSummonMap();
auto it = summonMap.find(effectId);
if (it != summonMap.end())
{
return it->second;
}
return ESM::RefId();
}
int summonCreature(int effectId, const MWWorld::Ptr& summoner)
{
const ESM::RefId& creatureID = getSummonedCreature(effectId);
int creatureActorId = -1;
if (!creatureID.empty())
{
try
{
auto world = MWBase::Environment::get().getWorld();
MWWorld::ManualRef ref(world->getStore(), creatureID, 1);
MWWorld::Ptr placed = world->safePlaceObject(ref.getPtr(), summoner, summoner.getCell(), 0, 120.f);
MWMechanics::CreatureStats& summonedCreatureStats = placed.getClass().getCreatureStats(placed);
// Make the summoned creature follow its master and help in fights
AiFollow package(summoner);
summonedCreatureStats.getAiSequence().stack(package, placed);
creatureActorId = summonedCreatureStats.getActorId();
MWRender::Animation* anim = world->getAnimation(placed);
if (anim)
{
const ESM::Static* fx
= world->getStore().get<ESM::Static>().search(ESM::RefId::stringRefId("VFX_Summon_Start"));
if (fx)
anim->addEffect(Misc::ResourceHelpers::correctMeshPath(fx->mModel), "", false);
}
}
catch (std::exception& e)
{
Log(Debug::Error) << "Failed to spawn summoned creature: " << e.what();
// still insert into creatureMap so we don't try to spawn again every frame, that would spam the warning
// log
}
summoner.getClass().getCreatureStats(summoner).getSummonedCreatureMap().emplace(effectId, creatureActorId);
}
return creatureActorId;
}
void updateSummons(const MWWorld::Ptr& summoner, bool cleanup)
{
MWMechanics::CreatureStats& creatureStats = summoner.getClass().getCreatureStats(summoner);
auto& creatureMap = creatureStats.getSummonedCreatureMap();
std::vector<int> graveyard = creatureStats.getSummonedCreatureGraveyard();
creatureStats.getSummonedCreatureGraveyard().clear();
for (const int creature : graveyard)
MWBase::Environment::get().getMechanicsManager()->cleanupSummonedCreature(summoner, creature);
if (!cleanup)
return;
for (auto it = creatureMap.begin(); it != creatureMap.end();)
{
if (it->second == -1)
{
// Keep the spell effect active if we failed to spawn anything
it++;
continue;
}
MWWorld::Ptr ptr = MWBase::Environment::get().getWorld()->searchPtrViaActorId(it->second);
if (!ptr.isEmpty() && ptr.getClass().getCreatureStats(ptr).isDead()
&& ptr.getClass().getCreatureStats(ptr).isDeathAnimationFinished())
{
// Purge the magic effect so a new creature can be summoned if desired
auto summon = *it;
creatureMap.erase(it++);
purgeSummonEffect(summoner, summon);
}
else
++it;
}
}
void purgeSummonEffect(const MWWorld::Ptr& summoner, const std::pair<int, int>& summon)
{
auto& creatureStats = summoner.getClass().getCreatureStats(summoner);
creatureStats.getActiveSpells().purge(
[summon](const auto& spell, const auto& effect) {
return effect.mEffectId == summon.first && effect.getActorId() == summon.second;
},
summoner);
MWBase::Environment::get().getMechanicsManager()->cleanupSummonedCreature(summoner, summon.second);
}
}
| 7,147
|
C++
|
.cpp
| 146
| 38.171233
| 120
| 0.622474
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,303
|
magiceffects.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/magiceffects.cpp
|
#include "magiceffects.hpp"
#include <cmath>
#include <stdexcept>
#include <components/esm/attr.hpp>
#include <components/esm3/effectlist.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadskil.hpp>
#include <components/esm3/magiceffects.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwworld/esmstore.hpp"
namespace
{
// Round value to prevent precision issues
void truncate(float& value)
{
value = static_cast<int>(value * 1024.f) / 1024.f;
}
}
namespace MWMechanics
{
EffectKey::EffectKey()
: mId(0)
{
}
EffectKey::EffectKey(const ESM::ENAMstruct& effect)
{
mId = effect.mEffectID;
mArg = ESM::Skill::indexToRefId(effect.mSkill);
ESM::RefId attribute = ESM::Attribute::indexToRefId(effect.mAttribute);
if (!attribute.empty())
{
if (!mArg.empty())
throw std::runtime_error("magic effect can't have both a skill and an attribute argument");
mArg = attribute;
}
}
std::string EffectKey::toString() const
{
const auto& store = MWBase::Environment::get().getESMStore();
const ESM::MagicEffect* magicEffect = store->get<ESM::MagicEffect>().find(mId);
return getMagicEffectString(
*magicEffect, store->get<ESM::Attribute>().search(mArg), store->get<ESM::Skill>().search(mArg));
}
bool operator<(const EffectKey& left, const EffectKey& right)
{
if (left.mId < right.mId)
return true;
if (left.mId > right.mId)
return false;
return left.mArg < right.mArg;
}
bool operator==(const EffectKey& left, const EffectKey& right)
{
return left.mId == right.mId && left.mArg == right.mArg;
}
float EffectParam::getMagnitude() const
{
return mBase + mModifier;
}
void EffectParam::modifyBase(int diff)
{
mBase += diff;
}
int EffectParam::getBase() const
{
return mBase;
}
void EffectParam::setBase(int base)
{
mBase = base;
}
void EffectParam::setModifier(float mod)
{
mModifier = mod;
}
float EffectParam::getModifier() const
{
return mModifier;
}
EffectParam::EffectParam()
: mModifier(0)
, mBase(0)
{
}
EffectParam& EffectParam::operator+=(const EffectParam& param)
{
mModifier += param.mModifier;
mBase += param.mBase;
truncate(mModifier);
return *this;
}
EffectParam& EffectParam::operator-=(const EffectParam& param)
{
mModifier -= param.mModifier;
mBase -= param.mBase;
truncate(mModifier);
return *this;
}
void MagicEffects::remove(const EffectKey& key)
{
mCollection.erase(key);
}
void MagicEffects::add(const EffectKey& key, const EffectParam& param)
{
Collection::iterator iter = mCollection.find(key);
if (iter == mCollection.end())
{
mCollection.insert(std::make_pair(key, param));
}
else
{
iter->second += param;
}
}
void MagicEffects::modifyBase(const EffectKey& key, int diff)
{
mCollection[key].modifyBase(diff);
}
void MagicEffects::setModifiers(const MagicEffects& effects)
{
for (Collection::iterator it = mCollection.begin(); it != mCollection.end(); ++it)
{
it->second.setModifier(effects.getOrDefault(it->first).getModifier());
}
for (Collection::const_iterator it = effects.begin(); it != effects.end(); ++it)
{
mCollection[it->first].setModifier(it->second.getModifier());
}
}
EffectParam MagicEffects::getOrDefault(const EffectKey& key) const
{
return get(key).value_or(EffectParam());
}
std::optional<EffectParam> MagicEffects::get(const EffectKey& key) const
{
Collection::const_iterator iter = mCollection.find(key);
if (iter != mCollection.end())
{
return iter->second;
}
return std::nullopt;
}
MagicEffects MagicEffects::diff(const MagicEffects& prev, const MagicEffects& now)
{
MagicEffects result;
// adding/changing
for (Collection::const_iterator iter(now.begin()); iter != now.end(); ++iter)
{
Collection::const_iterator other = prev.mCollection.find(iter->first);
if (other == prev.end())
{
// adding
result.add(iter->first, iter->second);
}
else
{
// changing
result.add(iter->first, iter->second - other->second);
}
}
// removing
for (Collection::const_iterator iter(prev.begin()); iter != prev.end(); ++iter)
{
Collection::const_iterator other = now.mCollection.find(iter->first);
if (other == now.end())
{
result.add(iter->first, EffectParam() - iter->second);
}
}
return result;
}
void MagicEffects::writeState(ESM::MagicEffects& state) const
{
for (const auto& [key, params] : mCollection)
{
if (params.getBase() != 0 || params.getModifier() != 0.f)
{
// Don't worry about mArg, never used by magic effect script instructions
state.mEffects[key.mId] = { params.getBase(), params.getModifier() };
}
}
}
void MagicEffects::readState(const ESM::MagicEffects& state)
{
for (const auto& [key, params] : state.mEffects)
{
mCollection[EffectKey(key)].setBase(params.first);
mCollection[EffectKey(key)].setModifier(params.second);
}
}
std::string getMagicEffectString(
const ESM::MagicEffect& effect, const ESM::Attribute* attribute, const ESM::Skill* skill)
{
const bool targetsSkill = effect.mData.mFlags & ESM::MagicEffect::TargetSkill && skill;
const bool targetsAttribute = effect.mData.mFlags & ESM::MagicEffect::TargetAttribute && attribute;
std::string spellLine;
auto windowManager = MWBase::Environment::get().getWindowManager();
if (targetsSkill || targetsAttribute)
{
switch (effect.mIndex)
{
case ESM::MagicEffect::AbsorbAttribute:
case ESM::MagicEffect::AbsorbSkill:
spellLine = windowManager->getGameSettingString("sAbsorb", {});
break;
case ESM::MagicEffect::DamageAttribute:
case ESM::MagicEffect::DamageSkill:
spellLine = windowManager->getGameSettingString("sDamage", {});
break;
case ESM::MagicEffect::DrainAttribute:
case ESM::MagicEffect::DrainSkill:
spellLine = windowManager->getGameSettingString("sDrain", {});
break;
case ESM::MagicEffect::FortifyAttribute:
case ESM::MagicEffect::FortifySkill:
spellLine = windowManager->getGameSettingString("sFortify", {});
break;
case ESM::MagicEffect::RestoreAttribute:
case ESM::MagicEffect::RestoreSkill:
spellLine = windowManager->getGameSettingString("sRestore", {});
break;
}
}
if (spellLine.empty())
{
auto& effectIDStr = ESM::MagicEffect::indexToGmstString(effect.mIndex);
spellLine = windowManager->getGameSettingString(effectIDStr, {});
}
if (targetsSkill)
{
spellLine += ' ';
spellLine += skill->mName;
}
else if (targetsAttribute)
{
spellLine += ' ';
spellLine += attribute->mName;
}
return spellLine;
}
}
| 8,115
|
C++
|
.cpp
| 242
| 24.495868
| 108
| 0.582397
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,304
|
aiactivate.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/aiactivate.cpp
|
#include "aiactivate.hpp"
#include <components/esm3/aisequence.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "creaturestats.hpp"
#include "movement.hpp"
#include "steering.hpp"
namespace MWMechanics
{
AiActivate::AiActivate(const ESM::RefId& objectId, bool repeat)
: TypedAiPackage<AiActivate>(repeat)
, mObjectId(objectId)
{
}
bool AiActivate::execute(
const MWWorld::Ptr& actor, CharacterController& characterController, AiState& state, float duration)
{
const MWWorld::Ptr target
= MWBase::Environment::get().getWorld()->searchPtr(mObjectId, false); // The target to follow
actor.getClass().getCreatureStats(actor).setDrawState(DrawState::Nothing);
// Stop if the target doesn't exist
// Really we should be checking whether the target is currently registered with the MechanicsManager
if (target == MWWorld::Ptr() || !target.getCellRef().getCount() || !target.getRefData().isEnabled())
return true;
// Turn to target and move to it directly, without pathfinding.
const osg::Vec3f targetDir
= target.getRefData().getPosition().asVec3() - actor.getRefData().getPosition().asVec3();
zTurn(actor, std::atan2(targetDir.x(), targetDir.y()), 0.f);
actor.getClass().getMovementSettings(actor).mPosition[1] = 1;
actor.getClass().getMovementSettings(actor).mPosition[0] = 0;
if (MWBase::Environment::get().getWorld()->getMaxActivationDistance() >= targetDir.length())
{
// Note: we intentionally do not cancel package after activation here for backward compatibility with
// original engine.
MWBase::Environment::get().getLuaManager()->objectActivated(target, actor);
}
return false;
}
void AiActivate::writeState(ESM::AiSequence::AiSequence& sequence) const
{
auto activate = std::make_unique<ESM::AiSequence::AiActivate>();
activate->mTargetId = mObjectId;
activate->mRepeat = getRepeat();
ESM::AiSequence::AiPackageContainer package;
package.mType = ESM::AiSequence::Ai_Activate;
package.mPackage = std::move(activate);
sequence.mPackages.push_back(std::move(package));
}
AiActivate::AiActivate(const ESM::AiSequence::AiActivate* activate)
: AiActivate(activate->mTargetId, activate->mRepeat)
{
}
}
| 2,534
|
C++
|
.cpp
| 55
| 39
| 113
| 0.679919
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,305
|
npcstats.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/npcstats.cpp
|
#include "npcstats.hpp"
#include <cassert>
#include <iomanip>
#include <sstream>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/npcstats.hpp>
#include <components/misc/strings/format.hpp>
#include <MyGUI_TextIterator.h>
#include "../mwworld/esmstore.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
MWMechanics::NpcStats::NpcStats()
: mDisposition(0)
, mCrimeDispositionModifier(0)
, mReputation(0)
, mCrimeId(-1)
, mBounty(0)
, mWerewolfKills(0)
, mLevelProgress(0)
, mTimeToStartDrowning(-1.0) // set breath to special value, it will be replaced during actor update
, mIsWerewolf(false)
{
mSpecIncreases.resize(3, 0);
for (const ESM::Skill& skill : MWBase::Environment::get().getESMStore()->get<ESM::Skill>())
mSkills.emplace(skill.mId, SkillValue{});
}
int MWMechanics::NpcStats::getBaseDisposition() const
{
return mDisposition;
}
void MWMechanics::NpcStats::setBaseDisposition(int disposition)
{
mDisposition = disposition;
}
int MWMechanics::NpcStats::getCrimeDispositionModifier() const
{
return mCrimeDispositionModifier;
}
void MWMechanics::NpcStats::setCrimeDispositionModifier(int value)
{
mCrimeDispositionModifier = value;
}
void MWMechanics::NpcStats::modCrimeDispositionModifier(int value)
{
mCrimeDispositionModifier += value;
}
const MWMechanics::SkillValue& MWMechanics::NpcStats::getSkill(ESM::RefId id) const
{
auto it = mSkills.find(id);
if (it == mSkills.end())
throw std::runtime_error("skill not found");
return it->second;
}
MWMechanics::SkillValue& MWMechanics::NpcStats::getSkill(ESM::RefId id)
{
auto it = mSkills.find(id);
if (it == mSkills.end())
throw std::runtime_error("skill not found");
return it->second;
}
void MWMechanics::NpcStats::setSkill(ESM::RefId id, const MWMechanics::SkillValue& value)
{
auto it = mSkills.find(id);
if (it == mSkills.end())
throw std::runtime_error("skill not found");
it->second = value;
}
const std::map<ESM::RefId, int>& MWMechanics::NpcStats::getFactionRanks() const
{
return mFactionRank;
}
int MWMechanics::NpcStats::getFactionRank(const ESM::RefId& faction) const
{
auto it = mFactionRank.find(faction);
if (it != mFactionRank.end())
return it->second;
return -1;
}
void MWMechanics::NpcStats::joinFaction(const ESM::RefId& faction)
{
auto it = mFactionRank.find(faction);
if (it == mFactionRank.end())
mFactionRank[faction] = 0;
}
void MWMechanics::NpcStats::setFactionRank(const ESM::RefId& faction, int newRank)
{
auto it = mFactionRank.find(faction);
if (it != mFactionRank.end())
{
const ESM::Faction* factionPtr = MWBase::Environment::get().getESMStore()->get<ESM::Faction>().find(faction);
if (newRank < 0)
{
mFactionRank.erase(it);
mExpelled.erase(faction);
}
else if (newRank < static_cast<int>(factionPtr->mData.mRankData.size()))
do
it->second = newRank;
// Does the new rank exist?
while (newRank > 0 && factionPtr->mRanks[newRank--].empty());
}
}
bool MWMechanics::NpcStats::getExpelled(const ESM::RefId& factionID) const
{
return mExpelled.find(factionID) != mExpelled.end();
}
void MWMechanics::NpcStats::expell(const ESM::RefId& factionID, bool printMessage)
{
if (mExpelled.find(factionID) == mExpelled.end())
{
mExpelled.insert(factionID);
if (!printMessage)
return;
std::string message = "#{sExpelledMessage}";
message += MWBase::Environment::get().getESMStore()->get<ESM::Faction>().find(factionID)->mName;
MWBase::Environment::get().getWindowManager()->messageBox(message);
}
}
void MWMechanics::NpcStats::clearExpelled(const ESM::RefId& factionID)
{
mExpelled.erase(factionID);
}
bool MWMechanics::NpcStats::isInFaction(const ESM::RefId& faction) const
{
return (mFactionRank.find(faction) != mFactionRank.end());
}
int MWMechanics::NpcStats::getFactionReputation(const ESM::RefId& faction) const
{
auto iter = mFactionReputation.find(faction);
if (iter == mFactionReputation.end())
return 0;
return iter->second;
}
void MWMechanics::NpcStats::setFactionReputation(const ESM::RefId& faction, int value)
{
mFactionReputation[faction] = value;
}
float MWMechanics::NpcStats::getSkillProgressRequirement(ESM::RefId id, const ESM::Class& class_) const
{
float progressRequirement = 1.f + getSkill(id).getBase();
const MWWorld::Store<ESM::GameSetting>& gmst = MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
const ESM::Skill* skill = MWBase::Environment::get().getESMStore()->get<ESM::Skill>().find(id);
float typeFactor = gmst.find("fMiscSkillBonus")->mValue.getFloat();
int index = ESM::Skill::refIdToIndex(skill->mId);
for (const auto& skills : class_.mData.mSkills)
{
if (skills[0] == index)
{
typeFactor = gmst.find("fMinorSkillBonus")->mValue.getFloat();
break;
}
else if (skills[1] == index)
{
typeFactor = gmst.find("fMajorSkillBonus")->mValue.getFloat();
break;
}
}
progressRequirement *= typeFactor;
if (typeFactor <= 0)
throw std::runtime_error("invalid skill type factor");
float specialisationFactor = 1;
if (skill->mData.mSpecialization == class_.mData.mSpecialization)
{
specialisationFactor = gmst.find("fSpecialSkillBonus")->mValue.getFloat();
if (specialisationFactor <= 0)
throw std::runtime_error("invalid skill specialisation factor");
}
progressRequirement *= specialisationFactor;
return progressRequirement;
}
int MWMechanics::NpcStats::getLevelProgress() const
{
return mLevelProgress;
}
void MWMechanics::NpcStats::setLevelProgress(int progress)
{
mLevelProgress = progress;
}
void MWMechanics::NpcStats::levelUp()
{
const MWWorld::Store<ESM::GameSetting>& gmst = MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
mLevelProgress -= gmst.find("iLevelUpTotal")->mValue.getInteger();
mLevelProgress = std::max(0, mLevelProgress); // might be necessary when levelup was invoked via console
mSkillIncreases.clear();
const float endurance = getAttribute(ESM::Attribute::Endurance).getBase();
// "When you gain a level, in addition to increasing three primary attributes, your Health
// will automatically increase by 10% of your Endurance attribute. If you increased Endurance this level,
// the Health increase is calculated from the increased Endurance"
// Note: we should add bonus Health points to current level too.
float healthGain = endurance * gmst.find("fLevelUpHealthEndMult")->mValue.getFloat();
MWMechanics::DynamicStat<float> health(getHealth());
health.setBase(getHealth().getBase() + healthGain);
health.setCurrent(std::max(1.f, getHealth().getCurrent() + healthGain));
setHealth(health);
setLevel(getLevel() + 1);
}
void MWMechanics::NpcStats::updateHealth()
{
const float endurance = getAttribute(ESM::Attribute::Endurance).getBase();
const float strength = getAttribute(ESM::Attribute::Strength).getBase();
setHealth(floor(0.5f * (strength + endurance)));
}
int MWMechanics::NpcStats::getLevelupAttributeMultiplier(ESM::Attribute::AttributeID attribute) const
{
auto it = mSkillIncreases.find(attribute);
if (it == mSkillIncreases.end() || it->second == 0)
return 1;
int num = std::min(10, it->second);
// iLevelUp01Mult - iLevelUp10Mult
std::stringstream gmst;
gmst << "iLevelUp" << std::setfill('0') << std::setw(2) << num << "Mult";
return MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>().find(gmst.str())->mValue.getInteger();
}
int MWMechanics::NpcStats::getSkillIncreasesForAttribute(ESM::Attribute::AttributeID attribute) const
{
auto it = mSkillIncreases.find(attribute);
if (it == mSkillIncreases.end())
return 0;
return it->second;
}
void MWMechanics::NpcStats::setSkillIncreasesForAttribute(ESM::Attribute::AttributeID attribute, int increases)
{
if (increases == 0)
mSkillIncreases.erase(attribute);
else
mSkillIncreases[attribute] = increases;
}
int MWMechanics::NpcStats::getSkillIncreasesForSpecialization(ESM::Class::Specialization spec) const
{
return mSpecIncreases[spec];
}
void MWMechanics::NpcStats::setSkillIncreasesForSpecialization(ESM::Class::Specialization spec, int increases)
{
assert(spec >= 0 && spec < 3);
mSpecIncreases[spec] = increases;
}
void MWMechanics::NpcStats::flagAsUsed(const ESM::RefId& id)
{
mUsedIds.insert(id);
}
bool MWMechanics::NpcStats::hasBeenUsed(const ESM::RefId& id) const
{
return mUsedIds.find(id) != mUsedIds.end();
}
int MWMechanics::NpcStats::getBounty() const
{
return mBounty;
}
void MWMechanics::NpcStats::setBounty(int bounty)
{
mBounty = bounty;
}
int MWMechanics::NpcStats::getReputation() const
{
return mReputation;
}
void MWMechanics::NpcStats::setReputation(int reputation)
{
// Reputation is capped in original engine
mReputation = std::clamp(reputation, 0, 255);
}
int MWMechanics::NpcStats::getCrimeId() const
{
return mCrimeId;
}
void MWMechanics::NpcStats::setCrimeId(int id)
{
mCrimeId = id;
}
bool MWMechanics::NpcStats::hasSkillsForRank(const ESM::RefId& factionId, int rank) const
{
const ESM::Faction& faction = *MWBase::Environment::get().getESMStore()->get<ESM::Faction>().find(factionId);
const ESM::RankData& rankData = faction.mData.mRankData.at(rank);
std::vector<int> skills;
for (int index : faction.mData.mSkills)
{
ESM::RefId id = ESM::Skill::indexToRefId(index);
if (!id.empty())
skills.push_back(static_cast<int>(getSkill(id).getBase()));
}
if (skills.empty())
return true;
std::sort(skills.begin(), skills.end());
std::vector<int>::const_reverse_iterator iter = skills.rbegin();
if (*iter < rankData.mPrimarySkill)
return false;
if (skills.size() < 2)
return true;
iter++;
if (*iter < rankData.mFavouredSkill)
return false;
if (skills.size() < 3)
return true;
iter++;
if (*iter < rankData.mFavouredSkill)
return false;
return true;
}
bool MWMechanics::NpcStats::isWerewolf() const
{
return mIsWerewolf;
}
void MWMechanics::NpcStats::setWerewolf(bool set)
{
if (mIsWerewolf == set)
return;
if (set != false)
{
mWerewolfKills = 0;
}
mIsWerewolf = set;
}
int MWMechanics::NpcStats::getWerewolfKills() const
{
return mWerewolfKills;
}
void MWMechanics::NpcStats::addWerewolfKill()
{
++mWerewolfKills;
}
float MWMechanics::NpcStats::getTimeToStartDrowning() const
{
return mTimeToStartDrowning;
}
void MWMechanics::NpcStats::setTimeToStartDrowning(float time)
{
mTimeToStartDrowning = time;
}
void MWMechanics::NpcStats::writeState(ESM::CreatureStats& state) const
{
CreatureStats::writeState(state);
}
void MWMechanics::NpcStats::writeState(ESM::NpcStats& state) const
{
for (std::map<ESM::RefId, int>::const_iterator iter(mFactionRank.begin()); iter != mFactionRank.end(); ++iter)
state.mFactions[iter->first].mRank = iter->second;
state.mDisposition = mDisposition;
state.mCrimeDispositionModifier = mCrimeDispositionModifier;
for (const auto& [id, value] : mSkills)
{
// TODO extend format
auto index = ESM::Skill::refIdToIndex(id);
assert(index >= 0);
value.writeState(state.mSkills[static_cast<size_t>(index)]);
}
state.mIsWerewolf = mIsWerewolf;
state.mCrimeId = mCrimeId;
state.mBounty = mBounty;
for (auto iter(mExpelled.begin()); iter != mExpelled.end(); ++iter)
state.mFactions[*iter].mExpelled = true;
for (auto iter(mFactionReputation.begin()); iter != mFactionReputation.end(); ++iter)
state.mFactions[iter->first].mReputation = iter->second;
state.mReputation = mReputation;
state.mWerewolfKills = mWerewolfKills;
state.mLevelProgress = mLevelProgress;
state.mSkillIncrease.fill(0);
for (const auto& [key, value] : mSkillIncreases)
{
// TODO extend format
auto index = ESM::Attribute::refIdToIndex(key);
assert(index >= 0);
state.mSkillIncrease[static_cast<size_t>(index)] = value;
}
for (size_t i = 0; i < state.mSpecIncreases.size(); ++i)
state.mSpecIncreases[i] = mSpecIncreases[i];
std::copy(mUsedIds.begin(), mUsedIds.end(), std::back_inserter(state.mUsedIds));
state.mTimeToStartDrowning = mTimeToStartDrowning;
}
void MWMechanics::NpcStats::readState(const ESM::CreatureStats& state)
{
CreatureStats::readState(state);
}
void MWMechanics::NpcStats::readState(const ESM::NpcStats& state)
{
const MWWorld::ESMStore& store = *MWBase::Environment::get().getESMStore();
for (auto iter(state.mFactions.begin()); iter != state.mFactions.end(); ++iter)
if (store.get<ESM::Faction>().search(iter->first))
{
if (iter->second.mExpelled)
mExpelled.insert(iter->first);
if (iter->second.mRank >= 0)
mFactionRank[iter->first] = iter->second.mRank;
if (iter->second.mReputation)
mFactionReputation[iter->first] = iter->second.mReputation;
}
mDisposition = state.mDisposition;
mCrimeDispositionModifier = state.mCrimeDispositionModifier;
for (size_t i = 0; i < state.mSkills.size(); ++i)
{
// TODO extend format
ESM::RefId id = ESM::Skill::indexToRefId(i);
assert(!id.empty());
mSkills[id].readState(state.mSkills[i]);
}
mIsWerewolf = state.mIsWerewolf;
mCrimeId = state.mCrimeId;
mBounty = state.mBounty;
mReputation = state.mReputation;
mWerewolfKills = state.mWerewolfKills;
mLevelProgress = state.mLevelProgress;
for (size_t i = 0; i < state.mSkillIncrease.size(); ++i)
mSkillIncreases[ESM::Attribute::indexToRefId(i)] = state.mSkillIncrease[i];
for (size_t i = 0; i < state.mSpecIncreases.size(); ++i)
mSpecIncreases[i] = state.mSpecIncreases[i];
for (auto iter(state.mUsedIds.begin()); iter != state.mUsedIds.end(); ++iter)
if (store.find(*iter))
mUsedIds.insert(*iter);
mTimeToStartDrowning = state.mTimeToStartDrowning;
}
| 14,682
|
C++
|
.cpp
| 411
| 30.953771
| 117
| 0.696371
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,306
|
mechanicsmanagerimp.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/mechanicsmanagerimp.cpp
|
#include "mechanicsmanagerimp.hpp"
#include <cassert>
#include <osg/Stats>
#include <components/misc/rng.hpp>
#include <components/esm/records.hpp>
#include <components/esm/refid.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/stolenitems.hpp>
#include <components/sceneutil/positionattitudetransform.hpp>
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwworld/globals.hpp"
#include "../mwworld/inventorystore.hpp"
#include "../mwworld/player.hpp"
#include "../mwworld/ptr.hpp"
#include "../mwbase/dialoguemanager.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/statemanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwsound/constants.hpp"
#include "actor.hpp"
#include "actors.hpp"
#include "actorutil.hpp"
#include "aicombat.hpp"
#include "aipursue.hpp"
#include "autocalcspell.hpp"
#include "combat.hpp"
#include "npcstats.hpp"
#include "spellutil.hpp"
namespace
{
float getFightDispositionBias(float disposition)
{
static const float fFightDispMult = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fFightDispMult")
->mValue.getFloat();
return ((50.f - disposition) * fFightDispMult);
}
void getPersuasionRatings(
const MWMechanics::NpcStats& stats, float& rating1, float& rating2, float& rating3, bool player)
{
const MWWorld::Store<ESM::GameSetting>& gmst
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
float persTerm = stats.getAttribute(ESM::Attribute::Personality).getModified()
/ gmst.find("fPersonalityMod")->mValue.getFloat();
float luckTerm
= stats.getAttribute(ESM::Attribute::Luck).getModified() / gmst.find("fLuckMod")->mValue.getFloat();
float repTerm = stats.getReputation() * gmst.find("fReputationMod")->mValue.getFloat();
float fatigueTerm = stats.getFatigueTerm();
float levelTerm = stats.getLevel() * gmst.find("fLevelMod")->mValue.getFloat();
rating1 = (repTerm + luckTerm + persTerm + stats.getSkill(ESM::Skill::Speechcraft).getModified()) * fatigueTerm;
if (player)
{
rating2 = rating1 + levelTerm;
rating3 = (stats.getSkill(ESM::Skill::Mercantile).getModified() + luckTerm + persTerm) * fatigueTerm;
}
else
{
rating2
= (levelTerm + repTerm + luckTerm + persTerm + stats.getSkill(ESM::Skill::Speechcraft).getModified())
* fatigueTerm;
rating3
= (stats.getSkill(ESM::Skill::Mercantile).getModified() + repTerm + luckTerm + persTerm) * fatigueTerm;
}
}
bool isOwned(const MWWorld::Ptr& ptr, const MWWorld::Ptr& target, MWWorld::Ptr& victim)
{
const MWWorld::CellRef& cellref = target.getCellRef();
const ESM::RefId& owner = cellref.getOwner();
bool isOwned = !owner.empty() && owner != ESM::RefId::stringRefId("Player");
const ESM::RefId& faction = cellref.getFaction();
bool isFactionOwned = false;
if (!faction.empty() && ptr.getClass().isNpc())
{
const std::map<ESM::RefId, int>& factions = ptr.getClass().getNpcStats(ptr).getFactionRanks();
auto found = factions.find(faction);
if (found == factions.end() || found->second < cellref.getFactionRank())
isFactionOwned = true;
}
const std::string& globalVariable = cellref.getGlobalVariable();
if (!globalVariable.empty() && MWBase::Environment::get().getWorld()->getGlobalInt(globalVariable))
{
isOwned = false;
isFactionOwned = false;
}
if (!cellref.getOwner().empty())
victim = MWBase::Environment::get().getWorld()->searchPtr(cellref.getOwner(), true, false);
return isOwned || isFactionOwned;
}
}
namespace MWMechanics
{
void MechanicsManager::buildPlayer()
{
MWWorld::Ptr ptr = getPlayer();
MWMechanics::CreatureStats& creatureStats = ptr.getClass().getCreatureStats(ptr);
MWMechanics::NpcStats& npcStats = ptr.getClass().getNpcStats(ptr);
npcStats.recalculateMagicka();
const ESM::NPC* player = ptr.get<ESM::NPC>()->mBase;
// reset
creatureStats.setLevel(player->mNpdt.mLevel);
creatureStats.getSpells().clear(true);
creatureStats.getActiveSpells().clear(ptr);
for (size_t i = 0; i < player->mNpdt.mSkills.size(); ++i)
npcStats.getSkill(ESM::Skill::indexToRefId(i)).setBase(player->mNpdt.mSkills[i]);
for (size_t i = 0; i < player->mNpdt.mAttributes.size(); ++i)
npcStats.setAttribute(ESM::Attribute::indexToRefId(i), player->mNpdt.mSkills[i]);
const MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore();
// race
if (mRaceSelected)
{
const ESM::Race* race = esmStore.get<ESM::Race>().find(player->mRace);
bool male = (player->mFlags & ESM::NPC::Female) == 0;
for (const ESM::Attribute& attribute : esmStore.get<ESM::Attribute>())
creatureStats.setAttribute(attribute.mId, race->mData.getAttribute(attribute.mId, male));
for (const ESM::Skill& skill : esmStore.get<ESM::Skill>())
{
int bonus = 0;
int index = ESM::Skill::refIdToIndex(skill.mId);
auto bonusIt = std::find_if(race->mData.mBonus.begin(), race->mData.mBonus.end(),
[&](const auto& bonus) { return bonus.mSkill == index; });
if (bonusIt != race->mData.mBonus.end())
bonus = bonusIt->mBonus;
npcStats.getSkill(skill.mId).setBase(5 + bonus);
}
for (const ESM::RefId& power : race->mPowers.mList)
{
creatureStats.getSpells().add(power);
}
}
// birthsign
const ESM::RefId& signId = MWBase::Environment::get().getWorld()->getPlayer().getBirthSign();
if (!signId.empty())
{
const ESM::BirthSign* sign = esmStore.get<ESM::BirthSign>().find(signId);
for (const ESM::RefId& power : sign->mPowers.mList)
{
creatureStats.getSpells().add(power);
}
}
// class
if (mClassSelected)
{
const ESM::Class* class_ = esmStore.get<ESM::Class>().find(player->mClass);
for (int attribute : class_->mData.mAttribute)
{
ESM::RefId id = ESM::Attribute::indexToRefId(attribute);
if (!id.empty())
creatureStats.setAttribute(id, creatureStats.getAttribute(id).getBase() + 10);
}
for (int i = 0; i < 2; ++i)
{
int bonus = i == 0 ? 10 : 25;
for (const auto& skills : class_->mData.mSkills)
{
ESM::RefId id = ESM::Skill::indexToRefId(skills[i]);
if (!id.empty())
npcStats.getSkill(id).setBase(npcStats.getSkill(id).getBase() + bonus);
}
}
for (const ESM::Skill& skill : esmStore.get<ESM::Skill>())
{
if (skill.mData.mSpecialization == class_->mData.mSpecialization)
npcStats.getSkill(skill.mId).setBase(npcStats.getSkill(skill.mId).getBase() + 5);
}
}
// F_PCStart spells
const ESM::Race* race = nullptr;
if (mRaceSelected)
race = esmStore.get<ESM::Race>().find(player->mRace);
npcStats.updateHealth();
std::vector<ESM::RefId> selectedSpells
= autoCalcPlayerSpells(npcStats.getSkills(), npcStats.getAttributes(), race);
for (const ESM::RefId& spell : selectedSpells)
creatureStats.getSpells().add(spell);
// forced update and current value adjustments
mActors.updateActor(ptr, 0);
for (int i = 0; i < 3; ++i)
{
DynamicStat<float> stat = creatureStats.getDynamic(i);
stat.setCurrent(stat.getModified());
creatureStats.setDynamic(i, stat);
}
// auto-equip again. we need this for when the race is changed to a beast race and shoes are no longer
// equippable
MWWorld::InventoryStore& invStore = ptr.getClass().getInventoryStore(ptr);
for (int i = 0; i < MWWorld::InventoryStore::Slots; ++i)
invStore.unequipAll();
invStore.autoEquip();
}
MechanicsManager::MechanicsManager()
: mUpdatePlayer(true)
, mClassSelected(false)
, mRaceSelected(false)
, mAI(true)
{
// buildPlayer no longer here, needs to be done explicitly after all subsystems are up and running
}
void MechanicsManager::add(const MWWorld::Ptr& ptr)
{
if (ptr.getClass().isActor())
mActors.addActor(ptr);
else
mObjects.addObject(ptr);
}
void MechanicsManager::castSpell(const MWWorld::Ptr& ptr, const ESM::RefId& spellId, bool scriptedSpell)
{
if (ptr.getClass().isActor())
mActors.castSpell(ptr, spellId, scriptedSpell);
}
void MechanicsManager::remove(const MWWorld::Ptr& ptr, bool keepActive)
{
if (ptr == MWBase::Environment::get().getWindowManager()->getWatchedActor())
MWBase::Environment::get().getWindowManager()->watchActor(MWWorld::Ptr());
mActors.removeActor(ptr, keepActive);
mObjects.removeObject(ptr);
}
void MechanicsManager::updateCell(const MWWorld::Ptr& old, const MWWorld::Ptr& ptr)
{
if (old == MWBase::Environment::get().getWindowManager()->getWatchedActor())
MWBase::Environment::get().getWindowManager()->watchActor(ptr);
if (ptr.getClass().isActor())
mActors.updateActor(old, ptr);
else
mObjects.updateObject(old, ptr);
}
void MechanicsManager::drop(const MWWorld::CellStore* cellStore)
{
mActors.dropActors(cellStore, getPlayer());
mObjects.dropObjects(cellStore);
}
void MechanicsManager::update(float duration, bool paused)
{
// Note: we should do it here since game mechanics and world updates use these values
MWWorld::Ptr ptr = getPlayer();
MWBase::WindowManager* winMgr = MWBase::Environment::get().getWindowManager();
MWWorld::InventoryStore& inv = ptr.getClass().getInventoryStore(ptr);
MWWorld::ContainerStoreIterator weapon = inv.getSlot(MWWorld::InventoryStore::Slot_CarriedRight);
// Update the selected spell icon
MWWorld::ContainerStoreIterator enchantItem = inv.getSelectedEnchantItem();
if (enchantItem != inv.end())
winMgr->setSelectedEnchantItem(*enchantItem);
else
{
const ESM::RefId& spell = winMgr->getSelectedSpell();
if (!spell.empty())
winMgr->setSelectedSpell(spell, int(MWMechanics::getSpellSuccessChance(spell, ptr)));
else
winMgr->unsetSelectedSpell();
}
// Update the equipped weapon icon
if (weapon == inv.end())
winMgr->unsetSelectedWeapon();
else
winMgr->setSelectedWeapon(*weapon);
if (mUpdatePlayer)
{
mUpdatePlayer = false;
// HACK? The player has been changed, so a new Animation object may
// have been made for them. Make sure they're properly updated.
mActors.removeActor(ptr, true);
mActors.addActor(ptr, true);
}
mActors.update(duration, paused);
mObjects.update(duration, paused);
}
void MechanicsManager::processChangedSettings(const Settings::CategorySettingVector& changed)
{
for (Settings::CategorySettingVector::const_iterator it = changed.begin(); it != changed.end(); ++it)
{
if (it->first == "Game" && it->second == "actors processing range")
{
int state = MWBase::Environment::get().getStateManager()->getState();
if (state != MWBase::StateManager::State_Running)
continue;
// Update mechanics for new processing range immediately
update(0.f, false);
}
}
}
void MechanicsManager::notifyDied(const MWWorld::Ptr& actor)
{
mActors.notifyDied(actor);
}
bool MechanicsManager::isActorDetected(const MWWorld::Ptr& actor, const MWWorld::Ptr& observer)
{
return mActors.isActorDetected(actor, observer);
}
bool MechanicsManager::isAttackPreparing(const MWWorld::Ptr& ptr)
{
return mActors.isAttackPreparing(ptr);
}
bool MechanicsManager::isRunning(const MWWorld::Ptr& ptr)
{
return mActors.isRunning(ptr);
}
bool MechanicsManager::isSneaking(const MWWorld::Ptr& ptr)
{
CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
MWBase::World* world = MWBase::Environment::get().getWorld();
bool animActive = mActors.isSneaking(ptr);
bool stanceOn = stats.getStance(MWMechanics::CreatureStats::Stance_Sneak);
bool inair = !world->isOnGround(ptr) && !world->isSwimming(ptr) && !world->isFlying(ptr);
return stanceOn && (animActive || inair);
}
void MechanicsManager::rest(double hours, bool sleep)
{
if (sleep)
MWBase::Environment::get().getWorld()->rest(hours);
mActors.rest(hours, sleep);
}
void MechanicsManager::restoreDynamicStats(const MWWorld::Ptr& actor, double hours, bool sleep)
{
mActors.restoreDynamicStats(actor, hours, sleep);
}
int MechanicsManager::getHoursToRest() const
{
return mActors.getHoursToRest(getPlayer());
}
void MechanicsManager::setPlayerName(const std::string& name)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
ESM::NPC player = *world->getPlayerPtr().get<ESM::NPC>()->mBase;
player.mName = name;
world->getStore().insert(player);
mUpdatePlayer = true;
}
void MechanicsManager::setPlayerRace(
const ESM::RefId& race, bool male, const ESM::RefId& head, const ESM::RefId& hair)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
ESM::NPC player = *world->getPlayerPtr().get<ESM::NPC>()->mBase;
if (player.mRace != race || player.mHead != head || player.mHair != hair || player.isMale() != male)
{
player.mRace = race;
player.mHead = head;
player.mHair = hair;
player.setIsMale(male);
world->getStore().insert(player);
world->renderPlayer();
}
mRaceSelected = true;
buildPlayer();
mUpdatePlayer = true;
}
void MechanicsManager::setPlayerBirthsign(const ESM::RefId& id)
{
MWBase::Environment::get().getWorld()->getPlayer().setBirthSign(id);
buildPlayer();
mUpdatePlayer = true;
}
void MechanicsManager::setPlayerClass(const ESM::RefId& id)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
ESM::NPC player = *world->getPlayerPtr().get<ESM::NPC>()->mBase;
player.mClass = id;
world->getStore().insert(player);
mClassSelected = true;
buildPlayer();
mUpdatePlayer = true;
}
void MechanicsManager::setPlayerClass(const ESM::Class& cls)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
const ESM::Class* ptr = world->getStore().insert(cls);
ESM::NPC player = *world->getPlayerPtr().get<ESM::NPC>()->mBase;
player.mClass = ptr->mId;
world->getStore().insert(player);
mClassSelected = true;
buildPlayer();
mUpdatePlayer = true;
}
int MechanicsManager::getDerivedDisposition(const MWWorld::Ptr& ptr, bool clamp)
{
const MWMechanics::NpcStats& npcStats = ptr.getClass().getNpcStats(ptr);
float x = static_cast<float>(npcStats.getBaseDisposition() + npcStats.getCrimeDispositionModifier());
MWWorld::LiveCellRef<ESM::NPC>* npc = ptr.get<ESM::NPC>();
MWWorld::Ptr playerPtr = getPlayer();
MWWorld::LiveCellRef<ESM::NPC>* player = playerPtr.get<ESM::NPC>();
const MWMechanics::NpcStats& playerStats = playerPtr.getClass().getNpcStats(playerPtr);
const MWWorld::Store<ESM::GameSetting>& gmst
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
static const float fDispRaceMod = gmst.find("fDispRaceMod")->mValue.getFloat();
if (npc->mBase->mRace == player->mBase->mRace)
x += fDispRaceMod;
static const float fDispPersonalityMult = gmst.find("fDispPersonalityMult")->mValue.getFloat();
static const float fDispPersonalityBase = gmst.find("fDispPersonalityBase")->mValue.getFloat();
x += fDispPersonalityMult
* (playerStats.getAttribute(ESM::Attribute::Personality).getModified() - fDispPersonalityBase);
float reaction = 0;
int rank = 0;
const ESM::RefId& npcFaction = ptr.getClass().getPrimaryFaction(ptr);
if (playerStats.getFactionRanks().find(npcFaction) != playerStats.getFactionRanks().end())
{
if (!playerStats.getExpelled(npcFaction))
{
// faction reaction towards itself. yes, that exists
reaction = static_cast<float>(
MWBase::Environment::get().getDialogueManager()->getFactionReaction(npcFaction, npcFaction));
rank = playerStats.getFactionRanks().find(npcFaction)->second;
}
}
else if (!npcFaction.empty())
{
auto playerFactionIt = playerStats.getFactionRanks().begin();
for (; playerFactionIt != playerStats.getFactionRanks().end(); ++playerFactionIt)
{
const ESM::RefId& itFaction = playerFactionIt->first;
// Ignore the faction, if a player was expelled from it.
if (playerStats.getExpelled(itFaction))
continue;
int itReaction
= MWBase::Environment::get().getDialogueManager()->getFactionReaction(npcFaction, itFaction);
if (playerFactionIt == playerStats.getFactionRanks().begin() || itReaction < reaction)
{
reaction = static_cast<float>(itReaction);
rank = playerFactionIt->second;
}
}
}
else
{
reaction = 0;
rank = 0;
}
static const float fDispFactionRankMult = gmst.find("fDispFactionRankMult")->mValue.getFloat();
static const float fDispFactionRankBase = gmst.find("fDispFactionRankBase")->mValue.getFloat();
static const float fDispFactionMod = gmst.find("fDispFactionMod")->mValue.getFloat();
x += (fDispFactionRankMult * rank + fDispFactionRankBase) * fDispFactionMod * reaction;
static const float fDispCrimeMod = gmst.find("fDispCrimeMod")->mValue.getFloat();
static const float fDispDiseaseMod = gmst.find("fDispDiseaseMod")->mValue.getFloat();
x -= fDispCrimeMod * playerStats.getBounty();
if (playerStats.hasCommonDisease() || playerStats.hasBlightDisease())
x += fDispDiseaseMod;
static const float fDispWeaponDrawn = gmst.find("fDispWeaponDrawn")->mValue.getFloat();
if (playerStats.getDrawState() == MWMechanics::DrawState::Weapon)
x += fDispWeaponDrawn;
x += ptr.getClass()
.getCreatureStats(ptr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Charm)
.getMagnitude();
if (clamp)
return std::clamp<int>(x, 0, 100); //, normally clamped to [0..100] when used
return static_cast<int>(x);
}
int MechanicsManager::getBarterOffer(const MWWorld::Ptr& ptr, int basePrice, bool buying)
{
// Make sure zero base price items/services can't be bought/sold for 1 gold
// and return the intended base price for creature merchants
if (basePrice == 0 || ptr.getType() == ESM::Creature::sRecordId)
return basePrice;
const MWMechanics::NpcStats& sellerStats = ptr.getClass().getNpcStats(ptr);
MWWorld::Ptr playerPtr = getPlayer();
const MWMechanics::NpcStats& playerStats = playerPtr.getClass().getNpcStats(playerPtr);
// I suppose the temporary disposition change (second param to getDerivedDisposition()) _has_ to be considered
// here, otherwise one would get different prices when exiting and re-entering the dialogue window...
int clampedDisposition = getDerivedDisposition(ptr);
float a = std::min(playerPtr.getClass().getSkill(playerPtr, ESM::Skill::Mercantile), 100.f);
float b = std::min(0.1f * playerStats.getAttribute(ESM::Attribute::Luck).getModified(), 10.f);
float c = std::min(0.2f * playerStats.getAttribute(ESM::Attribute::Personality).getModified(), 10.f);
float d = std::min(ptr.getClass().getSkill(ptr, ESM::Skill::Mercantile), 100.f);
float e = std::min(0.1f * sellerStats.getAttribute(ESM::Attribute::Luck).getModified(), 10.f);
float f = std::min(0.2f * sellerStats.getAttribute(ESM::Attribute::Personality).getModified(), 10.f);
float pcTerm = (clampedDisposition - 50 + a + b + c) * playerStats.getFatigueTerm();
float npcTerm = (d + e + f) * sellerStats.getFatigueTerm();
float buyTerm = 0.01f * (100 - 0.5f * (pcTerm - npcTerm));
float sellTerm = 0.01f * (50 - 0.5f * (npcTerm - pcTerm));
int offerPrice = int(basePrice * (buying ? buyTerm : sellTerm));
return std::max(1, offerPrice);
}
int MechanicsManager::countDeaths(const ESM::RefId& id) const
{
return mActors.countDeaths(id);
}
void MechanicsManager::getPersuasionDispositionChange(
const MWWorld::Ptr& npc, PersuasionType type, bool& success, int& tempChange, int& permChange)
{
const MWWorld::Store<ESM::GameSetting>& gmst
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
MWMechanics::NpcStats& npcStats = npc.getClass().getNpcStats(npc);
MWWorld::Ptr playerPtr = getPlayer();
const MWMechanics::NpcStats& playerStats = playerPtr.getClass().getNpcStats(playerPtr);
float npcRating1, npcRating2, npcRating3;
getPersuasionRatings(npcStats, npcRating1, npcRating2, npcRating3, false);
float playerRating1, playerRating2, playerRating3;
getPersuasionRatings(playerStats, playerRating1, playerRating2, playerRating3, true);
const int currentDisposition = getDerivedDisposition(npc);
float d = 1 - 0.02f * abs(currentDisposition - 50);
float target1 = d * (playerRating1 - npcRating1 + 50);
float target2 = d * (playerRating2 - npcRating2 + 50);
float bribeMod;
if (type == PT_Bribe10)
bribeMod = gmst.find("fBribe10Mod")->mValue.getFloat();
else if (type == PT_Bribe100)
bribeMod = gmst.find("fBribe100Mod")->mValue.getFloat();
else
bribeMod = gmst.find("fBribe1000Mod")->mValue.getFloat();
float target3 = d * (playerRating3 - npcRating3 + 50) + bribeMod;
const float iPerMinChance = gmst.find("iPerMinChance")->mValue.getFloat();
const float iPerMinChange = gmst.find("iPerMinChange")->mValue.getFloat();
const float fPerDieRollMult = gmst.find("fPerDieRollMult")->mValue.getFloat();
const float fPerTempMult = gmst.find("fPerTempMult")->mValue.getFloat();
float x = 0;
float y = 0;
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
int roll = Misc::Rng::roll0to99(prng);
if (type == PT_Admire)
{
target1 = std::max(iPerMinChance, target1);
success = (roll <= target1);
float c = floor(fPerDieRollMult * (target1 - roll));
x = success ? std::max(iPerMinChange, c) : c;
}
else if (type == PT_Intimidate)
{
target2 = std::max(iPerMinChance, target2);
success = (roll <= target2);
float r;
if (roll != target2)
r = floor(target2 - roll);
else
r = 1;
if (roll <= target2)
{
float s = floor(r * fPerDieRollMult * fPerTempMult);
const int flee = npcStats.getAiSetting(MWMechanics::AiSetting::Flee).getBase();
const int fight = npcStats.getAiSetting(MWMechanics::AiSetting::Fight).getBase();
npcStats.setAiSetting(
MWMechanics::AiSetting::Flee, std::clamp(flee + int(std::max(iPerMinChange, s)), 0, 100));
npcStats.setAiSetting(
MWMechanics::AiSetting::Fight, std::clamp(fight + int(std::min(-iPerMinChange, -s)), 0, 100));
}
float c = -std::abs(floor(r * fPerDieRollMult));
if (success)
{
if (std::abs(c) < iPerMinChange)
{
// Deviating from Morrowind here: it doesn't increase disposition on marginal wins,
// which seems to be a bug (MCP fixes it too).
// Original logic: x = 0, y = -iPerMinChange
x = iPerMinChange;
y = x; // This goes unused.
}
else
{
x = -floor(c * fPerTempMult);
y = c;
}
}
else
{
x = floor(c * fPerTempMult);
y = c;
}
}
else if (type == PT_Taunt)
{
target1 = std::max(iPerMinChance, target1);
success = (roll <= target1);
float c = std::abs(floor(target1 - roll));
if (success)
{
float s = c * fPerDieRollMult * fPerTempMult;
const int flee = npcStats.getAiSetting(AiSetting::Flee).getBase();
const int fight = npcStats.getAiSetting(AiSetting::Fight).getBase();
npcStats.setAiSetting(
AiSetting::Flee, std::clamp(flee + std::min(-int(iPerMinChange), int(-s)), 0, 100));
npcStats.setAiSetting(
AiSetting::Fight, std::clamp(fight + std::max(int(iPerMinChange), int(s)), 0, 100));
}
x = floor(-c * fPerDieRollMult);
if (success && std::abs(x) < iPerMinChange)
x = -iPerMinChange;
}
else // Bribe
{
target3 = std::max(iPerMinChance, target3);
success = (roll <= target3);
float c = floor((target3 - roll) * fPerDieRollMult);
x = success ? std::max(iPerMinChange, c) : c;
}
if (type == PT_Intimidate)
{
tempChange = int(x);
if (currentDisposition + tempChange > 100)
tempChange = 100 - currentDisposition;
else if (currentDisposition + tempChange < 0)
tempChange = -currentDisposition;
permChange = success ? -int(tempChange / fPerTempMult) : int(y);
}
else
{
tempChange = int(x * fPerTempMult);
if (currentDisposition + tempChange > 100)
tempChange = 100 - currentDisposition;
else if (currentDisposition + tempChange < 0)
tempChange = -currentDisposition;
permChange = int(tempChange / fPerTempMult);
}
}
void MechanicsManager::forceStateUpdate(const MWWorld::Ptr& ptr)
{
if (ptr.getClass().isActor())
mActors.forceStateUpdate(ptr);
}
bool MechanicsManager::playAnimationGroup(
const MWWorld::Ptr& ptr, std::string_view groupName, int mode, uint32_t number, bool scripted)
{
if (ptr.getClass().isActor())
return mActors.playAnimationGroup(ptr, groupName, mode, number, scripted);
else
return mObjects.playAnimationGroup(ptr, groupName, mode, number, scripted);
}
bool MechanicsManager::playAnimationGroupLua(const MWWorld::Ptr& ptr, std::string_view groupName, uint32_t loops,
float speed, std::string_view startKey, std::string_view stopKey, bool forceLoop)
{
if (ptr.getClass().isActor())
return mActors.playAnimationGroupLua(ptr, groupName, loops, speed, startKey, stopKey, forceLoop);
else
return mObjects.playAnimationGroupLua(ptr, groupName, loops, speed, startKey, stopKey, forceLoop);
}
void MechanicsManager::enableLuaAnimations(const MWWorld::Ptr& ptr, bool enable)
{
if (ptr.getClass().isActor())
mActors.enableLuaAnimations(ptr, enable);
else
mObjects.enableLuaAnimations(ptr, enable);
}
void MechanicsManager::skipAnimation(const MWWorld::Ptr& ptr)
{
if (ptr.getClass().isActor())
mActors.skipAnimation(ptr);
else
mObjects.skipAnimation(ptr);
}
bool MechanicsManager::checkAnimationPlaying(const MWWorld::Ptr& ptr, const std::string& groupName)
{
if (ptr.getClass().isActor())
return mActors.checkAnimationPlaying(ptr, groupName);
else
return false;
}
bool MechanicsManager::checkScriptedAnimationPlaying(const MWWorld::Ptr& ptr) const
{
if (ptr.getClass().isActor())
return mActors.checkScriptedAnimationPlaying(ptr);
return false;
}
bool MechanicsManager::onOpen(const MWWorld::Ptr& ptr)
{
if (ptr.getClass().isActor())
return true;
else
return mObjects.onOpen(ptr);
}
void MechanicsManager::onClose(const MWWorld::Ptr& ptr)
{
if (!ptr.getClass().isActor())
mObjects.onClose(ptr);
}
void MechanicsManager::persistAnimationStates()
{
mActors.persistAnimationStates();
mObjects.persistAnimationStates();
}
void MechanicsManager::clearAnimationQueue(const MWWorld::Ptr& ptr, bool clearScripted)
{
if (ptr.getClass().isActor())
mActors.clearAnimationQueue(ptr, clearScripted);
else
mObjects.clearAnimationQueue(ptr, clearScripted);
}
void MechanicsManager::updateMagicEffects(const MWWorld::Ptr& ptr)
{
mActors.updateMagicEffects(ptr);
}
bool MechanicsManager::toggleAI()
{
mAI = !mAI;
return mAI;
}
bool MechanicsManager::isAIActive()
{
return mAI;
}
void MechanicsManager::playerLoaded()
{
mUpdatePlayer = true;
mClassSelected = true;
mRaceSelected = true;
mAI = true;
}
namespace
{
std::set<ESM::RefId> makeBoundItemIdCache()
{
std::set<ESM::RefId> boundItemIDCache;
// Build a list of known bound item ID's
const MWWorld::Store<ESM::GameSetting>& gameSettings
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
for (const ESM::GameSetting& currentSetting : gameSettings)
{
// Don't bother checking this GMST if it's not a sMagicBound* one.
if (!currentSetting.mId.startsWith("smagicbound"))
continue;
// All sMagicBound* GMST's should be of type string
std::string currentGMSTValue = currentSetting.mValue.getString();
Misc::StringUtils::lowerCaseInPlace(currentGMSTValue);
boundItemIDCache.insert(ESM::RefId::stringRefId(currentGMSTValue));
}
return boundItemIDCache;
}
}
bool MechanicsManager::isBoundItem(const MWWorld::Ptr& item)
{
static const std::set<ESM::RefId> boundItemIdCache = makeBoundItemIdCache();
return boundItemIdCache.find(item.getCellRef().getRefId()) != boundItemIdCache.end();
}
bool MechanicsManager::isAllowedToUse(const MWWorld::Ptr& ptr, const MWWorld::Ptr& target, MWWorld::Ptr& victim)
{
if (target.isEmpty())
return true;
const MWWorld::CellRef& cellref = target.getCellRef();
// there is no harm to use unlocked doors
if (target.getClass().isDoor() && !cellref.isLocked() && cellref.getTrap().empty())
{
return true;
}
if (!target.getClass().hasToolTip(target))
return true;
// TODO: implement a better check to check if target is owned bed
if (target.getClass().isActivator() && !target.getClass().getScript(target).startsWith("Bed"))
return true;
if (target.getClass().isNpc())
{
if (target.getClass().getCreatureStats(target).isDead())
return true;
if (target.getClass().getCreatureStats(target).getAiSequence().isInCombat())
return true;
// check if a player tries to pickpocket a target NPC
if (target.getClass().getCreatureStats(target).getKnockedDown() || isSneaking(ptr))
return false;
return true;
}
if (isOwned(ptr, target, victim))
return false;
// A special case for evidence chest - we should not allow to take items even if it is technically permitted
return !(cellref.getRefId() == "stolen_goods");
}
bool MechanicsManager::sleepInBed(const MWWorld::Ptr& ptr, const MWWorld::Ptr& bed)
{
if (ptr.getClass().getNpcStats(ptr).isWerewolf())
{
MWBase::Environment::get().getWindowManager()->messageBox("#{sWerewolfRefusal}");
return true;
}
if (MWBase::Environment::get().getWorld()->getPlayer().enemiesNearby())
{
MWBase::Environment::get().getWindowManager()->messageBox("#{sNotifyMessage2}");
return true;
}
MWWorld::Ptr victim;
if (isAllowedToUse(ptr, bed, victim))
return false;
if (commitCrime(ptr, victim, OT_SleepingInOwnedBed, bed.getCellRef().getFaction()))
{
MWBase::Environment::get().getWindowManager()->messageBox("#{sNotifyMessage64}");
return true;
}
else
return false;
}
void MechanicsManager::unlockAttempted(const MWWorld::Ptr& ptr, const MWWorld::Ptr& item)
{
MWWorld::Ptr victim;
if (isOwned(ptr, item, victim))
{
// Note that attempting to unlock something that has ever been locked is a crime even if it's already
// unlocked. Likewise, it's illegal to unlock something that has a trap but isn't otherwise locked.
const auto& cellref = item.getCellRef();
if (cellref.getLockLevel() || cellref.isLocked() || !cellref.getTrap().empty())
commitCrime(ptr, victim, OT_Trespassing, item.getCellRef().getFaction());
}
}
std::vector<std::pair<ESM::RefId, int>> MechanicsManager::getStolenItemOwners(const ESM::RefId& itemid)
{
std::vector<std::pair<ESM::RefId, int>> result;
StolenItemsMap::const_iterator it = mStolenItems.find(itemid);
if (it == mStolenItems.end())
return result;
else
{
const OwnerMap& owners = it->second;
for (OwnerMap::const_iterator ownerIt = owners.begin(); ownerIt != owners.end(); ++ownerIt)
result.emplace_back(ownerIt->first.first, ownerIt->second);
return result;
}
}
bool MechanicsManager::isItemStolenFrom(const ESM::RefId& itemid, const MWWorld::Ptr& ptr)
{
StolenItemsMap::const_iterator it = mStolenItems.find(itemid);
if (it == mStolenItems.end())
return false;
const OwnerMap& owners = it->second;
const ESM::RefId& ownerid = ptr.getCellRef().getRefId();
OwnerMap::const_iterator ownerFound = owners.find(std::make_pair(ownerid, false));
if (ownerFound != owners.end())
return true;
const ESM::RefId& factionid = ptr.getClass().getPrimaryFaction(ptr);
if (!factionid.empty())
{
OwnerMap::const_iterator factionOwnerFound = owners.find(std::make_pair(factionid, true));
return factionOwnerFound != owners.end();
}
return false;
}
void MechanicsManager::confiscateStolenItemToOwner(
const MWWorld::Ptr& player, const MWWorld::Ptr& item, const MWWorld::Ptr& victim, int count)
{
if (player != getPlayer())
return;
const ESM::RefId& itemId = item.getCellRef().getRefId();
StolenItemsMap::iterator stolenIt = mStolenItems.find(itemId);
if (stolenIt == mStolenItems.end())
return;
Owner owner;
owner.first = victim.getCellRef().getRefId();
owner.second = false;
const ESM::RefId& victimFaction = victim.getClass().getPrimaryFaction(victim);
if (!victimFaction.empty() && item.getCellRef().getFaction() == victimFaction) // Is the item faction-owned?
{
owner.first = victimFaction;
owner.second = true;
}
// decrease count of stolen items
int toRemove = std::min(count, mStolenItems[itemId][owner]);
mStolenItems[itemId][owner] -= toRemove;
if (mStolenItems[itemId][owner] == 0)
{
// erase owner from stolen items owners
OwnerMap& owners = stolenIt->second;
OwnerMap::iterator ownersIt = owners.find(owner);
if (ownersIt != owners.end())
owners.erase(ownersIt);
}
MWWorld::ContainerStore& store = player.getClass().getContainerStore(player);
// move items from player to owner and report about theft
victim.getClass().getContainerStore(victim).add(item, toRemove);
store.remove(item, toRemove);
commitCrime(
player, victim, OT_Theft, item.getCellRef().getFaction(), item.getClass().getValue(item) * toRemove);
}
void MechanicsManager::confiscateStolenItems(const MWWorld::Ptr& player, const MWWorld::Ptr& targetContainer)
{
MWWorld::ContainerStore& store = player.getClass().getContainerStore(player);
MWWorld::ContainerStore& containerStore = targetContainer.getClass().getContainerStore(targetContainer);
for (MWWorld::ContainerStoreIterator it = store.begin(); it != store.end(); ++it)
{
StolenItemsMap::iterator stolenIt = mStolenItems.find(it->getCellRef().getRefId());
if (stolenIt == mStolenItems.end())
continue;
OwnerMap& owners = stolenIt->second;
int itemCount = it->getCellRef().getCount();
for (OwnerMap::iterator ownerIt = owners.begin(); ownerIt != owners.end();)
{
int toRemove = std::min(itemCount, ownerIt->second);
itemCount -= toRemove;
ownerIt->second -= toRemove;
if (ownerIt->second == 0)
owners.erase(ownerIt++);
else
++ownerIt;
}
int toMove = it->getCellRef().getCount() - itemCount;
containerStore.add(*it, toMove);
store.remove(*it, toMove);
}
// TODO: unhardcode the locklevel
targetContainer.getCellRef().lock(50);
}
void MechanicsManager::itemTaken(
const MWWorld::Ptr& ptr, const MWWorld::Ptr& item, const MWWorld::Ptr& container, int count, bool alarm)
{
if (ptr != getPlayer())
return;
MWWorld::Ptr victim;
bool isAllowed = true;
const MWWorld::CellRef* ownerCellRef = &item.getCellRef();
if (!container.isEmpty())
{
// Inherit the owner of the container
ownerCellRef = &container.getCellRef();
isAllowed = isAllowedToUse(ptr, container, victim);
}
else
{
isAllowed = isAllowedToUse(ptr, item, victim);
}
if (isAllowed)
return;
Owner owner;
owner.second = false;
if (!container.isEmpty() && container.getClass().isActor())
{
// "container" is an actor inventory, so just take actor's ID
owner.first = ownerCellRef->getRefId();
}
else
{
owner.first = ownerCellRef->getOwner();
if (owner.first.empty())
{
owner.first = ownerCellRef->getFaction();
owner.second = true;
}
}
const bool isGold = item.getClass().isGold(item);
if (!isGold)
{
if (victim.isEmpty()
|| (victim.getClass().isActor() && victim.getCellRef().getCount() > 0
&& !victim.getClass().getCreatureStats(victim).isDead()))
mStolenItems[item.getCellRef().getRefId()][owner] += count;
}
if (alarm)
{
int value = count;
if (!isGold)
value *= item.getClass().getValue(item);
commitCrime(ptr, victim, OT_Theft, ownerCellRef->getFaction(), value);
}
}
bool MechanicsManager::commitCrime(const MWWorld::Ptr& player, const MWWorld::Ptr& victim, OffenseType type,
const ESM::RefId& factionId, int arg, bool victimAware)
{
// NOTE: victim may be empty
// Only player can commit crime
if (player != getPlayer())
return false;
if (type == OT_Assault)
victimAware = true;
// Find all the actors within the alarm radius
std::vector<MWWorld::Ptr> neighbors;
osg::Vec3f from(player.getRefData().getPosition().asVec3());
const MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore();
float radius = esmStore.get<ESM::GameSetting>().find("fAlarmRadius")->mValue.getFloat();
mActors.getObjectsInRange(from, radius, neighbors);
// victim should be considered even beyond alarm radius
if (!victim.isEmpty() && (from - victim.getRefData().getPosition().asVec3()).length2() > radius * radius)
neighbors.push_back(victim);
// get the player's followers / allies (works recursively) that will not report crimes
std::set<MWWorld::Ptr> playerFollowers;
getActorsSidingWith(player, playerFollowers);
// Did anyone see it?
bool crimeSeen = false;
for (const MWWorld::Ptr& neighbor : neighbors)
{
if (!canReportCrime(neighbor, victim, playerFollowers))
continue;
if ((neighbor == victim && victimAware)
// Murder crime can be reported even if no one saw it (hearing is enough, I guess).
// TODO: Add mod support for stealth executions!
|| (type == OT_Murder && neighbor != victim)
|| (MWBase::Environment::get().getWorld()->getLOS(player, neighbor)
&& awarenessCheck(player, neighbor)))
{
// NPC will complain about theft even if he will do nothing about it
if (type == OT_Theft || type == OT_Pickpocket)
MWBase::Environment::get().getDialogueManager()->say(neighbor, ESM::RefId::stringRefId("thief"));
crimeSeen = true;
}
}
if (crimeSeen)
reportCrime(player, victim, type, factionId, arg);
else if (type == OT_Assault && !victim.isEmpty())
{
bool reported = false;
if (victim.getClass().isClass(victim, "guard")
&& !victim.getClass().getCreatureStats(victim).getAiSequence().hasPackage(AiPackageTypeId::Pursue))
reported = reportCrime(player, victim, type, ESM::RefId(), arg);
// TODO: combat should be started with an "unaware" flag, which makes the victim flee?
if (!reported)
startCombat(victim, player, &playerFollowers);
}
return crimeSeen;
}
bool MechanicsManager::canReportCrime(
const MWWorld::Ptr& actor, const MWWorld::Ptr& victim, std::set<MWWorld::Ptr>& playerFollowers)
{
if (actor == getPlayer() || !actor.getClass().isNpc() || actor.getClass().getCreatureStats(actor).isDead())
return false;
if (actor.getClass().getCreatureStats(actor).getAiSequence().isInCombat(victim))
return false;
// Unconsious actor can not report about crime and should not become hostile
if (actor.getClass().getCreatureStats(actor).getKnockedDown())
return false;
// Player's followers should not attack player, or try to arrest him
if (actor.getClass().getCreatureStats(actor).getAiSequence().hasPackage(AiPackageTypeId::Follow))
{
if (playerFollowers.find(actor) != playerFollowers.end())
return false;
}
return true;
}
bool MechanicsManager::reportCrime(
const MWWorld::Ptr& player, const MWWorld::Ptr& victim, OffenseType type, const ESM::RefId& factionId, int arg)
{
const MWWorld::Store<ESM::GameSetting>& store
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
if (type == OT_Murder && !victim.isEmpty())
victim.getClass().getCreatureStats(victim).notifyMurder();
// Bounty and disposition penalty for each type of crime
float disp = 0.f, dispVictim = 0.f;
if (type == OT_Trespassing || type == OT_SleepingInOwnedBed)
{
arg = store.find("iCrimeTresspass")->mValue.getInteger();
disp = dispVictim = store.find("iDispTresspass")->mValue.getFloat();
}
else if (type == OT_Pickpocket)
{
arg = store.find("iCrimePickPocket")->mValue.getInteger();
disp = dispVictim = store.find("fDispPickPocketMod")->mValue.getFloat();
}
else if (type == OT_Assault)
{
arg = store.find("iCrimeAttack")->mValue.getInteger();
disp = store.find("iDispAttackMod")->mValue.getFloat();
dispVictim = store.find("fDispAttacking")->mValue.getFloat();
}
else if (type == OT_Murder)
{
arg = store.find("iCrimeKilling")->mValue.getInteger();
disp = dispVictim = store.find("iDispKilling")->mValue.getFloat();
}
else if (type == OT_Theft)
{
disp = dispVictim = store.find("fDispStealing")->mValue.getFloat() * arg;
arg = static_cast<int>(arg * store.find("fCrimeStealing")->mValue.getFloat());
arg = std::max(1, arg); // Minimum bounty of 1, in case items with zero value are stolen
}
// Make surrounding actors within alarm distance respond to the crime
std::vector<MWWorld::Ptr> neighbors;
const MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore();
osg::Vec3f from(player.getRefData().getPosition().asVec3());
float radius = esmStore.get<ESM::GameSetting>().find("fAlarmRadius")->mValue.getFloat();
mActors.getObjectsInRange(from, radius, neighbors);
// victim should be considered even beyond alarm radius
if (!victim.isEmpty() && (from - victim.getRefData().getPosition().asVec3()).length2() > radius * radius)
neighbors.push_back(victim);
int id = MWBase::Environment::get().getWorld()->getPlayer().getNewCrimeId();
// What amount of provocation did this crime generate?
// Controls whether witnesses will engage combat with the criminal.
int fight = 0, fightVictim = 0;
if (type == OT_Trespassing || type == OT_SleepingInOwnedBed)
fight = fightVictim = esmStore.get<ESM::GameSetting>().find("iFightTrespass")->mValue.getInteger();
else if (type == OT_Pickpocket)
{
fight = esmStore.get<ESM::GameSetting>().find("iFightPickpocket")->mValue.getInteger();
fightVictim = esmStore.get<ESM::GameSetting>().find("iFightPickpocket")->mValue.getInteger()
* 4; // *4 according to research wiki
}
else if (type == OT_Assault)
{
fight = esmStore.get<ESM::GameSetting>().find("iFightAttacking")->mValue.getInteger();
fightVictim = esmStore.get<ESM::GameSetting>().find("iFightAttack")->mValue.getInteger();
}
else if (type == OT_Murder)
fight = fightVictim = esmStore.get<ESM::GameSetting>().find("iFightKilling")->mValue.getInteger();
else if (type == OT_Theft)
fight = fightVictim = esmStore.get<ESM::GameSetting>().find("fFightStealing")->mValue.getInteger();
bool reported = false;
std::set<MWWorld::Ptr> playerFollowers;
getActorsSidingWith(player, playerFollowers);
// Tell everyone (including the original reporter) in alarm range
for (const MWWorld::Ptr& actor : neighbors)
{
if (!canReportCrime(actor, victim, playerFollowers))
continue;
// Will the witness report the crime?
if (actor.getClass().getCreatureStats(actor).getAiSetting(AiSetting::Alarm).getBase() >= 100)
{
reported = true;
if (type == OT_Trespassing)
MWBase::Environment::get().getDialogueManager()->say(actor, ESM::RefId::stringRefId("intruder"));
}
}
for (const MWWorld::Ptr& actor : neighbors)
{
if (!canReportCrime(actor, victim, playerFollowers))
continue;
NpcStats& observerStats = actor.getClass().getNpcStats(actor);
int alarm = observerStats.getAiSetting(AiSetting::Alarm).getBase();
float alarmTerm = 0.01f * alarm;
bool isActorVictim = actor == victim;
float dispTerm = isActorVictim ? dispVictim : disp;
bool isActorGuard = actor.getClass().isClass(actor, "guard");
int currentDisposition = getDerivedDisposition(actor);
bool isPermanent = false;
bool applyOnlyIfHostile = false;
int dispositionModifier = 0;
// Murdering and trespassing seem to do not affect disposition
if (type == OT_Theft)
{
dispositionModifier = static_cast<int>(dispTerm * alarmTerm);
}
else if (type == OT_Pickpocket)
{
if (alarm >= 100 && isActorGuard)
dispositionModifier = static_cast<int>(dispTerm);
else if (isActorVictim && isActorGuard)
{
isPermanent = true;
dispositionModifier = static_cast<int>(dispTerm * alarmTerm);
}
else if (isActorVictim)
{
isPermanent = true;
dispositionModifier = static_cast<int>(dispTerm);
}
}
else if (type == OT_Assault)
{
if (isActorVictim && !isActorGuard)
{
isPermanent = true;
dispositionModifier = static_cast<int>(dispTerm);
}
else if (alarm >= 100)
dispositionModifier = static_cast<int>(dispTerm);
else if (isActorVictim && isActorGuard)
{
isPermanent = true;
dispositionModifier = static_cast<int>(dispTerm * alarmTerm);
}
else
{
applyOnlyIfHostile = true;
dispositionModifier = static_cast<int>(dispTerm * alarmTerm);
}
}
bool setCrimeId = false;
if (isPermanent && dispositionModifier != 0 && !applyOnlyIfHostile)
{
setCrimeId = true;
dispositionModifier = std::clamp(dispositionModifier, -currentDisposition, 100 - currentDisposition);
int baseDisposition = observerStats.getBaseDisposition();
observerStats.setBaseDisposition(baseDisposition + dispositionModifier);
}
else if (dispositionModifier != 0 && !applyOnlyIfHostile)
{
setCrimeId = true;
dispositionModifier = std::clamp(dispositionModifier, -currentDisposition, 100 - currentDisposition);
observerStats.modCrimeDispositionModifier(dispositionModifier);
}
if (isActorGuard && alarm >= 100)
{
// Mark as Alarmed for dialogue
observerStats.setAlarmed(true);
setCrimeId = true;
if (!observerStats.getAiSequence().isInPursuit())
{
observerStats.getAiSequence().stack(AiPursue(player), actor);
}
}
else
{
// If Alarm is 0, treat it like 100 to calculate a Fight modifier for a victim of pickpocketing.
// Observers which do not try to arrest player do not care about pickpocketing at all.
if (type == OT_Pickpocket && isActorVictim && alarmTerm == 0.0)
alarmTerm = 1.0;
else if (type == OT_Pickpocket && !isActorVictim)
alarmTerm = 0.0;
float fightTerm = static_cast<float>(isActorVictim ? fightVictim : fight);
fightTerm += getFightDispositionBias(dispTerm);
fightTerm += getFightDistanceBias(actor, player);
fightTerm *= alarmTerm;
const int observerFightRating = observerStats.getAiSetting(AiSetting::Fight).getBase();
if (observerFightRating + fightTerm > 100)
fightTerm = static_cast<float>(100 - observerFightRating);
fightTerm = std::max(0.f, fightTerm);
if (observerFightRating + fightTerm >= 100)
{
if (dispositionModifier != 0 && applyOnlyIfHostile)
{
dispositionModifier
= std::clamp(dispositionModifier, -currentDisposition, 100 - currentDisposition);
observerStats.modCrimeDispositionModifier(dispositionModifier);
}
startCombat(actor, player, &playerFollowers);
// Apply aggression value to the base Fight rating, so that the actor can continue fighting
// after a Calm spell wears off
observerStats.setAiSetting(AiSetting::Fight, observerFightRating + static_cast<int>(fightTerm));
setCrimeId = true;
// Mark as Alarmed for dialogue
observerStats.setAlarmed(true);
}
}
// Set the crime ID, which we will use to calm down participants
// once the bounty has been paid and restore their disposition to player character.
if (setCrimeId)
observerStats.setCrimeId(id);
}
if (reported)
{
player.getClass().getNpcStats(player).setBounty(
std::max(0, player.getClass().getNpcStats(player).getBounty() + arg));
// If committing a crime against a faction member, expell from the faction
if (!victim.isEmpty() && victim.getClass().isNpc())
{
const ESM::RefId& factionID = victim.getClass().getPrimaryFaction(victim);
const std::map<ESM::RefId, int>& playerRanks = player.getClass().getNpcStats(player).getFactionRanks();
if (playerRanks.find(factionID) != playerRanks.end())
{
player.getClass().getNpcStats(player).expell(factionID, true);
}
}
else if (!factionId.empty())
{
const std::map<ESM::RefId, int>& playerRanks = player.getClass().getNpcStats(player).getFactionRanks();
if (playerRanks.find(factionId) != playerRanks.end())
{
player.getClass().getNpcStats(player).expell(factionId, true);
}
}
if (type == OT_Assault && !victim.isEmpty()
&& !victim.getClass().getCreatureStats(victim).getAiSequence().isInCombat(player)
&& victim.getClass().isNpc())
{
// Attacker is in combat with us, but we are not in combat with the attacker yet. Time to fight back.
// Note: accidental or collateral damage attacks are ignored.
if (!victim.getClass().getCreatureStats(victim).getAiSequence().isInPursuit())
startCombat(victim, player, &playerFollowers);
// Set the crime ID, which we will use to calm down participants
// once the bounty has been paid.
victim.getClass().getNpcStats(victim).setCrimeId(id);
}
}
return reported;
}
bool MechanicsManager::actorAttacked(const MWWorld::Ptr& target, const MWWorld::Ptr& attacker)
{
const MWWorld::Ptr& player = getPlayer();
if (target == player || !attacker.getClass().isActor())
return false;
if (canCommitCrimeAgainst(target, attacker))
commitCrime(attacker, target, MWBase::MechanicsManager::OT_Assault);
MWMechanics::CreatureStats& statsTarget = target.getClass().getCreatureStats(target);
AiSequence& seq = statsTarget.getAiSequence();
if (!attacker.isEmpty()
&& (attacker.getClass().getCreatureStats(attacker).getAiSequence().isInCombat(target) || attacker == player)
&& !seq.isInCombat(attacker))
{
// Attacker is in combat with us, but we are not in combat with the attacker yet. Time to fight back.
// Note: accidental or collateral damage attacks are ignored.
if (!target.getClass().getCreatureStats(target).getAiSequence().isInPursuit())
{
// If an actor has OnPCHitMe declared in his script, his Fight = 0 and the attacker is player,
// he will attack the player only if we will force him (e.g. via StartCombat console command)
bool peaceful = false;
const ESM::RefId& script = target.getClass().getScript(target);
if (!script.empty() && target.getRefData().getLocals().hasVar(script, "onpchitme")
&& attacker == player)
{
const int fight
= target.getClass().getCreatureStats(target).getAiSetting(AiSetting::Fight).getModified();
peaceful = (fight == 0);
}
if (!peaceful)
{
SidingCache cachedAllies{ mActors, false };
const std::set<MWWorld::Ptr>& attackerAllies = cachedAllies.getActorsSidingWith(attacker);
startCombat(target, attacker, &attackerAllies);
// Force friendly actors into combat to prevent infighting between followers
for (const auto& follower : cachedAllies.getActorsSidingWith(target))
{
if (follower != attacker && follower != player)
startCombat(follower, attacker, &attackerAllies);
}
}
}
}
return true;
}
bool MechanicsManager::canCommitCrimeAgainst(const MWWorld::Ptr& target, const MWWorld::Ptr& attacker)
{
const MWWorld::Class& cls = target.getClass();
const MWMechanics::CreatureStats& stats = cls.getCreatureStats(target);
const MWMechanics::AiSequence& seq = stats.getAiSequence();
return cls.isNpc() && !attacker.isEmpty() && !seq.isInCombat(attacker) && !isAggressive(target, attacker)
&& !seq.isEngagedWithActor() && !stats.getAiSequence().isInPursuit()
&& !cls.getNpcStats(target).isWerewolf()
&& stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Vampirism).getMagnitude() <= 0;
}
void MechanicsManager::actorKilled(const MWWorld::Ptr& victim, const MWWorld::Ptr& attacker)
{
if (attacker.isEmpty() || victim.isEmpty())
return;
if (victim == attacker)
return; // known to happen
if (!victim.getClass().isNpc())
return; // TODO: implement animal rights
const MWMechanics::NpcStats& victimStats = victim.getClass().getNpcStats(victim);
const MWWorld::Ptr& player = getPlayer();
bool canCommit = attacker == player && canCommitCrimeAgainst(victim, attacker);
// For now we report only about crimes of player and player's followers
if (attacker != player)
{
std::set<MWWorld::Ptr> playerFollowers;
getActorsSidingWith(player, playerFollowers);
if (playerFollowers.find(attacker) == playerFollowers.end())
return;
}
if (!canCommit && victimStats.getCrimeId() == -1)
return;
// Simple check for who attacked first: if the player attacked first, a crimeId should be set
// Doesn't handle possible edge case where no one reported the assault, but in such a case,
// for bystanders it is not possible to tell who attacked first, anyway.
commitCrime(player, victim, MWBase::MechanicsManager::OT_Murder);
}
bool MechanicsManager::awarenessCheck(const MWWorld::Ptr& ptr, const MWWorld::Ptr& observer)
{
if (observer.getClass().getCreatureStats(observer).isDead() || !observer.getRefData().isEnabled())
return false;
const MWWorld::Store<ESM::GameSetting>& store
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
float sneakTerm = 0;
if (isSneaking(ptr))
{
static float fSneakSkillMult = store.find("fSneakSkillMult")->mValue.getFloat();
static float fSneakBootMult = store.find("fSneakBootMult")->mValue.getFloat();
float sneak = static_cast<float>(ptr.getClass().getSkill(ptr, ESM::Skill::Sneak));
float agility = stats.getAttribute(ESM::Attribute::Agility).getModified();
float luck = stats.getAttribute(ESM::Attribute::Luck).getModified();
float bootWeight = 0;
if (ptr.getClass().isNpc() && MWBase::Environment::get().getWorld()->isOnGround(ptr))
{
const MWWorld::InventoryStore& inv = ptr.getClass().getInventoryStore(ptr);
MWWorld::ConstContainerStoreIterator it = inv.getSlot(MWWorld::InventoryStore::Slot_Boots);
if (it != inv.end())
bootWeight = it->getClass().getWeight(*it);
}
sneakTerm = fSneakSkillMult * sneak + 0.2f * agility + 0.1f * luck + bootWeight * fSneakBootMult;
}
static float fSneakDistBase = store.find("fSneakDistanceBase")->mValue.getFloat();
static float fSneakDistMult = store.find("fSneakDistanceMultiplier")->mValue.getFloat();
osg::Vec3f pos1(ptr.getRefData().getPosition().asVec3());
osg::Vec3f pos2(observer.getRefData().getPosition().asVec3());
float distTerm = fSneakDistBase + fSneakDistMult * (pos1 - pos2).length();
float chameleon = stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Chameleon).getMagnitude();
float invisibility = stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Invisibility).getMagnitude();
float x = sneakTerm * distTerm * stats.getFatigueTerm() + chameleon;
if (invisibility > 0.f)
x += 100.f;
CreatureStats& observerStats = observer.getClass().getCreatureStats(observer);
float obsAgility = observerStats.getAttribute(ESM::Attribute::Agility).getModified();
float obsLuck = observerStats.getAttribute(ESM::Attribute::Luck).getModified();
float obsBlind = observerStats.getMagicEffects().getOrDefault(ESM::MagicEffect::Blind).getMagnitude();
float obsSneak = observer.getClass().getSkill(observer, ESM::Skill::Sneak);
float obsTerm = obsSneak + 0.2f * obsAgility + 0.1f * obsLuck - obsBlind;
// is ptr behind the observer?
static float fSneakNoViewMult = store.find("fSneakNoViewMult")->mValue.getFloat();
static float fSneakViewMult = store.find("fSneakViewMult")->mValue.getFloat();
float y = 0;
osg::Vec3f vec = pos1 - pos2;
if (observer.getRefData().getBaseNode())
{
osg::Vec3f observerDir = (observer.getRefData().getBaseNode()->getAttitude() * osg::Vec3f(0, 1, 0));
float angleRadians = std::acos(observerDir * vec / (observerDir.length() * vec.length()));
if (angleRadians > osg::DegreesToRadians(90.f))
y = obsTerm * observerStats.getFatigueTerm() * fSneakNoViewMult;
else
y = obsTerm * observerStats.getFatigueTerm() * fSneakViewMult;
}
float target = x - y;
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
return (Misc::Rng::roll0to99(prng) >= target);
}
void MechanicsManager::startCombat(
const MWWorld::Ptr& ptr, const MWWorld::Ptr& target, const std::set<MWWorld::Ptr>* targetAllies)
{
CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
// Don't add duplicate packages nor add packages to dead actors.
if (stats.isDead() || stats.getAiSequence().isInCombat(target))
return;
// The target is somehow the same as the actor. Early-out.
if (ptr == target)
{
// We don't care about dialogue filters since the target is invalid.
// We still want to play the combat taunt.
MWBase::Environment::get().getDialogueManager()->say(ptr, ESM::RefId::stringRefId("attack"));
if (!stats.getAiSequence().isInCombat())
stats.resetFriendlyHits();
return;
}
const bool inCombat = stats.getAiSequence().isInCombat();
bool shout = !inCombat;
if (inCombat)
{
const auto isInCombatWithOneOf = [&](const auto& allies) {
for (const MWWorld::Ptr& ally : allies)
{
if (stats.getAiSequence().isInCombat(ally))
return true;
}
return false;
};
if (targetAllies)
shout = !isInCombatWithOneOf(*targetAllies);
else
{
shout = stats.getAiSequence().isInCombat(target);
if (!shout)
{
std::set<MWWorld::Ptr> sidingActors;
getActorsSidingWith(target, sidingActors);
shout = !isInCombatWithOneOf(sidingActors);
}
}
}
stats.getAiSequence().stack(MWMechanics::AiCombat(target), ptr);
if (target == getPlayer())
{
// if guard starts combat with player, guards pursuing player should do the same
if (ptr.getClass().isClass(ptr, "Guard"))
{
stats.setHitAttemptActorId(
target.getClass()
.getCreatureStats(target)
.getActorId()); // Stops guard from ending combat if player is unreachable
for (const Actor& actor : mActors)
{
if (actor.getPtr().getClass().isClass(actor.getPtr(), "Guard"))
{
MWMechanics::AiSequence& aiSeq
= actor.getPtr().getClass().getCreatureStats(actor.getPtr()).getAiSequence();
if (aiSeq.getTypeId() == MWMechanics::AiPackageTypeId::Pursue)
{
aiSeq.stopPursuit();
aiSeq.stack(MWMechanics::AiCombat(target), ptr);
actor.getPtr()
.getClass()
.getCreatureStats(actor.getPtr())
.setHitAttemptActorId(
target.getClass()
.getCreatureStats(target)
.getActorId()); // Stops guard from ending combat if player is unreachable
}
}
}
}
}
// Must be done after the target is set up, so that CreatureTargetted dialogue filter works properly
if (shout)
MWBase::Environment::get().getDialogueManager()->say(ptr, ESM::RefId::stringRefId("attack"));
}
void MechanicsManager::stopCombat(const MWWorld::Ptr& actor)
{
mActors.stopCombat(actor);
}
void MechanicsManager::getObjectsInRange(
const osg::Vec3f& position, float radius, std::vector<MWWorld::Ptr>& objects)
{
mActors.getObjectsInRange(position, radius, objects);
mObjects.getObjectsInRange(position, radius, objects);
}
void MechanicsManager::getActorsInRange(
const osg::Vec3f& position, float radius, std::vector<MWWorld::Ptr>& objects)
{
mActors.getObjectsInRange(position, radius, objects);
}
bool MechanicsManager::isAnyActorInRange(const osg::Vec3f& position, float radius)
{
return mActors.isAnyObjectInRange(position, radius);
}
std::vector<MWWorld::Ptr> MechanicsManager::getActorsSidingWith(const MWWorld::Ptr& actor)
{
return mActors.getActorsSidingWith(actor);
}
std::vector<MWWorld::Ptr> MechanicsManager::getActorsFollowing(const MWWorld::Ptr& actor)
{
return mActors.getActorsFollowing(actor);
}
std::vector<int> MechanicsManager::getActorsFollowingIndices(const MWWorld::Ptr& actor)
{
return mActors.getActorsFollowingIndices(actor);
}
std::map<int, MWWorld::Ptr> MechanicsManager::getActorsFollowingByIndex(const MWWorld::Ptr& actor)
{
return mActors.getActorsFollowingByIndex(actor);
}
std::vector<MWWorld::Ptr> MechanicsManager::getActorsFighting(const MWWorld::Ptr& actor)
{
return mActors.getActorsFighting(actor);
}
std::vector<MWWorld::Ptr> MechanicsManager::getEnemiesNearby(const MWWorld::Ptr& actor)
{
return mActors.getEnemiesNearby(actor);
}
void MechanicsManager::getActorsFollowing(const MWWorld::Ptr& actor, std::set<MWWorld::Ptr>& out)
{
mActors.getActorsFollowing(actor, out);
}
void MechanicsManager::getActorsSidingWith(const MWWorld::Ptr& actor, std::set<MWWorld::Ptr>& out)
{
mActors.getActorsSidingWith(actor, out);
}
int MechanicsManager::countSavedGameRecords() const
{
return 1 // Death counter
+ 1; // Stolen items
}
void MechanicsManager::write(ESM::ESMWriter& writer, Loading::Listener& listener) const
{
mActors.write(writer, listener);
ESM::StolenItems items;
items.mStolenItems = mStolenItems;
writer.startRecord(ESM::REC_STLN);
items.write(writer);
writer.endRecord(ESM::REC_STLN);
}
void MechanicsManager::readRecord(ESM::ESMReader& reader, uint32_t type)
{
if (type == ESM::REC_STLN)
{
ESM::StolenItems items;
items.load(reader);
mStolenItems = items.mStolenItems;
}
else
mActors.readRecord(reader, type);
}
void MechanicsManager::clear()
{
mActors.clear();
mStolenItems.clear();
mClassSelected = false;
mRaceSelected = false;
}
bool MechanicsManager::isAggressive(const MWWorld::Ptr& ptr, const MWWorld::Ptr& target)
{
// Don't become aggressive if a calm effect is active, since it would cause combat to cycle on/off as
// combat is activated here and then canceled by the calm effect
if ((ptr.getClass().isNpc()
&& ptr.getClass()
.getCreatureStats(ptr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::CalmHumanoid)
.getMagnitude()
> 0)
|| (!ptr.getClass().isNpc()
&& ptr.getClass()
.getCreatureStats(ptr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::CalmCreature)
.getMagnitude()
> 0))
return false;
int disposition = 50;
if (ptr.getClass().isNpc())
disposition = getDerivedDisposition(ptr);
int fight = ptr.getClass().getCreatureStats(ptr).getAiSetting(AiSetting::Fight).getModified()
+ static_cast<int>(
getFightDistanceBias(ptr, target) + getFightDispositionBias(static_cast<float>(disposition)));
if (ptr.getClass().isNpc() && target.getClass().isNpc())
{
if (target.getClass().getNpcStats(target).isWerewolf()
|| (target == getPlayer()
&& MWBase::Environment::get().getWorld()->getGlobalInt(MWWorld::Globals::sPCKnownWerewolf)))
{
const ESM::GameSetting* iWerewolfFightMod
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>().find("iWerewolfFightMod");
fight += iWerewolfFightMod->mValue.getInteger();
}
}
return (fight >= 100);
}
void MechanicsManager::resurrect(const MWWorld::Ptr& ptr)
{
CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
if (stats.isDead())
{
stats.resurrect();
mActors.resurrect(ptr);
}
}
bool MechanicsManager::isCastingSpell(const MWWorld::Ptr& ptr) const
{
return mActors.isCastingSpell(ptr);
}
bool MechanicsManager::isReadyToBlock(const MWWorld::Ptr& ptr) const
{
return mActors.isReadyToBlock(ptr);
}
bool MechanicsManager::isAttackingOrSpell(const MWWorld::Ptr& ptr) const
{
return mActors.isAttackingOrSpell(ptr);
}
void MechanicsManager::setWerewolf(const MWWorld::Ptr& actor, bool werewolf)
{
MWMechanics::NpcStats& npcStats = actor.getClass().getNpcStats(actor);
// The actor does not have to change state
if (npcStats.isWerewolf() == werewolf)
return;
MWWorld::Player* player = &MWBase::Environment::get().getWorld()->getPlayer();
// Werewolfs can not cast spells, so we need to unset the prepared spell if there is one.
if (npcStats.getDrawState() == MWMechanics::DrawState::Spell)
npcStats.setDrawState(MWMechanics::DrawState::Nothing);
npcStats.setWerewolf(werewolf);
MWWorld::InventoryStore& inv = actor.getClass().getInventoryStore(actor);
if (werewolf)
{
inv.unequipAll();
inv.equip(MWWorld::InventoryStore::Slot_Robe,
inv.ContainerStore::add(ESM::RefId::stringRefId("werewolfrobe"), 1));
}
else
{
inv.unequipSlot(MWWorld::InventoryStore::Slot_Robe);
inv.ContainerStore::remove(ESM::RefId::stringRefId("werewolfrobe"), 1);
}
if (actor == player->getPlayer())
{
MWBase::Environment::get().getWorld()->reattachPlayerCamera();
// Update the GUI only when called on the player
MWBase::WindowManager* windowManager = MWBase::Environment::get().getWindowManager();
// Transforming removes all temporary effects
actor.getClass().getCreatureStats(actor).getActiveSpells().purge(
[](const auto& params) { return params.hasFlag(ESM::ActiveSpells::Flag_Temporary); }, actor);
mActors.updateActor(actor, 0.f);
if (werewolf)
{
player->saveStats();
player->setWerewolfStats();
windowManager->forceHide(MWGui::GW_Inventory);
windowManager->forceHide(MWGui::GW_Magic);
}
else
{
player->restoreStats();
windowManager->unsetForceHide(MWGui::GW_Inventory);
windowManager->unsetForceHide(MWGui::GW_Magic);
}
windowManager->setWerewolfOverlay(werewolf);
// Witnesses of the player's transformation will make them a globally known werewolf
std::vector<MWWorld::Ptr> neighbors;
const MWWorld::Store<ESM::GameSetting>& gmst
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
getActorsInRange(
actor.getRefData().getPosition().asVec3(), gmst.find("fAlarmRadius")->mValue.getFloat(), neighbors);
bool detected = false, reported = false;
for (const MWWorld::Ptr& neighbor : neighbors)
{
if (neighbor == actor || !neighbor.getClass().isNpc())
continue;
if (MWBase::Environment::get().getWorld()->getLOS(neighbor, actor) && awarenessCheck(actor, neighbor))
{
detected = true;
if (neighbor.getClass()
.getCreatureStats(neighbor)
.getAiSetting(MWMechanics::AiSetting::Alarm)
.getModified()
> 0)
{
reported = true;
break;
}
}
}
if (detected)
{
windowManager->messageBox("#{sWerewolfAlarmMessage}");
MWBase::Environment::get().getWorld()->setGlobalInt(MWWorld::Globals::sPCKnownWerewolf, 1);
if (reported)
{
npcStats.setBounty(
std::max(0, npcStats.getBounty() + gmst.find("iWereWolfBounty")->mValue.getInteger()));
}
}
}
}
void MechanicsManager::applyWerewolfAcrobatics(const MWWorld::Ptr& actor)
{
const ESM::Skill* acrobatics
= MWBase::Environment::get().getESMStore()->get<ESM::Skill>().find(ESM::Skill::Acrobatics);
MWMechanics::NpcStats& stats = actor.getClass().getNpcStats(actor);
auto& skill = stats.getSkill(acrobatics->mId);
skill.setModifier(acrobatics->mWerewolfValue - skill.getModified());
}
void MechanicsManager::cleanupSummonedCreature(const MWWorld::Ptr& caster, int creatureActorId)
{
mActors.cleanupSummonedCreature(caster.getClass().getCreatureStats(caster), creatureActorId);
}
void MechanicsManager::reportStats(unsigned int frameNumber, osg::Stats& stats) const
{
stats.setAttribute(frameNumber, "Mechanics Actors", mActors.size());
stats.setAttribute(frameNumber, "Mechanics Objects", mObjects.size());
}
int MechanicsManager::getGreetingTimer(const MWWorld::Ptr& ptr) const
{
return mActors.getGreetingTimer(ptr);
}
float MechanicsManager::getAngleToPlayer(const MWWorld::Ptr& ptr) const
{
return mActors.getAngleToPlayer(ptr);
}
GreetingState MechanicsManager::getGreetingState(const MWWorld::Ptr& ptr) const
{
return mActors.getGreetingState(ptr);
}
bool MechanicsManager::isTurningToPlayer(const MWWorld::Ptr& ptr) const
{
return mActors.isTurningToPlayer(ptr);
}
}
| 81,145
|
C++
|
.cpp
| 1,722
| 35.616144
| 120
| 0.598134
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,307
|
aicast.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/aicast.cpp
|
#include "aicast.hpp"
#include <components/misc/constants.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "aicombataction.hpp"
#include "character.hpp"
#include "steering.hpp"
namespace MWMechanics
{
namespace
{
float getInitialDistance(const ESM::RefId& spellId)
{
ActionSpell action = ActionSpell(spellId);
bool isRanged;
return action.getCombatRange(isRanged);
}
}
}
MWMechanics::AiCast::AiCast(const ESM::RefId& targetId, const ESM::RefId& spellId, bool scriptedSpell)
: mTargetId(targetId)
, mSpellId(spellId)
, mCasting(false)
, mScripted(scriptedSpell)
, mDistance(getInitialDistance(spellId))
{
}
bool MWMechanics::AiCast::execute(const MWWorld::Ptr& actor, MWMechanics::CharacterController& characterController,
MWMechanics::AiState& state, float duration)
{
MWWorld::Ptr target;
if (actor.getCellRef().getRefId() == mTargetId)
{
// If the target has the same ID as caster, consider that actor casts spell with Self range.
target = actor;
}
else
{
target = getTarget();
if (target.isEmpty())
return true;
if (!mScripted
&& !pathTo(actor, target.getRefData().getPosition().asVec3(), duration,
characterController.getSupportedMovementDirections(), mDistance))
{
return false;
}
}
osg::Vec3f targetPos = target.getRefData().getPosition().asVec3();
// If the target of an on-target spell is an actor that is not the caster
// the target position must be adjusted so that it's not casted at the actor's feet.
if (target != actor && target.getClass().isActor())
{
osg::Vec3f halfExtents = MWBase::Environment::get().getWorld()->getHalfExtents(target);
targetPos.z() += halfExtents.z() * 2 * Constants::TorsoHeight;
}
osg::Vec3f actorPos = actor.getRefData().getPosition().asVec3();
osg::Vec3f halfExtents = MWBase::Environment::get().getWorld()->getHalfExtents(actor);
actorPos.z() += halfExtents.z() * 2 * Constants::TorsoHeight;
osg::Vec3f dir = targetPos - actorPos;
bool turned = smoothTurn(actor, getZAngleToDir(dir), 2, osg::DegreesToRadians(3.f));
turned &= smoothTurn(actor, getXAngleToDir(dir), 0, osg::DegreesToRadians(3.f));
if (!turned)
return false;
// Check if the actor is already casting another spell
bool isCasting = MWBase::Environment::get().getMechanicsManager()->isCastingSpell(actor);
if (isCasting && !mCasting)
return false;
if (!mCasting)
{
MWBase::Environment::get().getMechanicsManager()->castSpell(actor, mSpellId, mScripted);
mCasting = true;
return false;
}
// Finish package, if actor finished spellcasting
return !isCasting;
}
MWWorld::Ptr MWMechanics::AiCast::getTarget() const
{
MWWorld::Ptr target = MWBase::Environment::get().getWorld()->searchPtr(mTargetId, false);
return target;
}
| 3,130
|
C++
|
.cpp
| 84
| 31.52381
| 115
| 0.677015
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,308
|
stat.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/stat.cpp
|
#include "stat.hpp"
#include <algorithm>
#include <components/esm3/statstate.hpp>
namespace MWMechanics
{
template <typename T>
Stat<T>::Stat()
: mBase(0)
, mModifier(0)
{
}
template <typename T>
Stat<T>::Stat(T base, T modified)
: mBase(base)
, mModifier(modified)
{
}
template <typename T>
T Stat<T>::getModified(bool capped) const
{
if (capped)
return std::max({}, mModifier + mBase);
return mModifier + mBase;
}
template <typename T>
void Stat<T>::writeState(ESM::StatState<T>& state) const
{
state.mBase = mBase;
state.mMod = mModifier;
}
template <typename T>
void Stat<T>::readState(const ESM::StatState<T>& state)
{
mBase = state.mBase;
mModifier = state.mMod;
}
template <typename T>
DynamicStat<T>::DynamicStat()
: mStatic(0, 0)
, mCurrent(0)
{
}
template <typename T>
DynamicStat<T>::DynamicStat(T base)
: mStatic(base, 0)
, mCurrent(base)
{
}
template <typename T>
DynamicStat<T>::DynamicStat(T base, T modified, T current)
: mStatic(base, modified)
, mCurrent(current)
{
}
template <typename T>
DynamicStat<T>::DynamicStat(const Stat<T>& stat, T current)
: mStatic(stat)
, mCurrent(current)
{
}
template <typename T>
void DynamicStat<T>::setCurrent(const T& value, bool allowDecreaseBelowZero, bool allowIncreaseAboveModified)
{
if (value > mCurrent)
{
// increase
if (value <= getModified() || allowIncreaseAboveModified)
mCurrent = value;
else if (mCurrent > getModified())
return;
else
mCurrent = getModified();
}
else if (value > 0 || allowDecreaseBelowZero)
{
// allowed decrease
mCurrent = value;
}
else if (mCurrent > 0)
{
// capped decrease
mCurrent = 0;
}
}
template <typename T>
T DynamicStat<T>::getRatio(bool nanIsZero) const
{
T modified = getModified();
if (modified == T{})
{
if (nanIsZero)
return modified;
return { 1 };
}
return getCurrent() / modified;
}
template <typename T>
void DynamicStat<T>::writeState(ESM::StatState<T>& state) const
{
mStatic.writeState(state);
state.mCurrent = mCurrent;
}
template <typename T>
void DynamicStat<T>::readState(const ESM::StatState<T>& state)
{
mStatic.readState(state);
mCurrent = state.mCurrent;
}
AttributeValue::AttributeValue()
: mBase(0.f)
, mModifier(0.f)
, mDamage(0.f)
{
}
float AttributeValue::getModified() const
{
return std::max(0.f, mBase - mDamage + mModifier);
}
float AttributeValue::getBase() const
{
return mBase;
}
float AttributeValue::getModifier() const
{
return mModifier;
}
void AttributeValue::setBase(float base, bool clearModifier)
{
mBase = base;
if (clearModifier)
{
mModifier = 0.f;
mDamage = 0.f;
}
}
void AttributeValue::setModifier(float mod)
{
if (mod < 0)
{
mModifier = 0.f;
mDamage -= mod;
}
else
mModifier = mod;
}
void AttributeValue::damage(float damage)
{
mDamage += damage;
}
void AttributeValue::restore(float amount)
{
if (mDamage <= 0)
return;
mDamage -= std::min(mDamage, amount);
}
float AttributeValue::getDamage() const
{
return mDamage;
}
void AttributeValue::writeState(ESM::StatState<float>& state) const
{
state.mBase = mBase;
state.mMod = mModifier;
state.mDamage = mDamage;
}
void AttributeValue::readState(const ESM::StatState<float>& state)
{
mBase = state.mBase;
mModifier = state.mMod;
mDamage = state.mDamage;
}
SkillValue::SkillValue()
: mProgress(0)
{
}
float SkillValue::getProgress() const
{
return mProgress;
}
void SkillValue::setProgress(float progress)
{
mProgress = progress;
}
void SkillValue::writeState(ESM::StatState<float>& state) const
{
AttributeValue::writeState(state);
state.mProgress = mProgress;
}
void SkillValue::readState(const ESM::StatState<float>& state)
{
AttributeValue::readState(state);
mProgress = state.mProgress;
}
}
template class MWMechanics::Stat<int>;
template class MWMechanics::Stat<float>;
template class MWMechanics::DynamicStat<int>;
template class MWMechanics::DynamicStat<float>;
| 4,984
|
C++
|
.cpp
| 198
| 17.974747
| 113
| 0.576317
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,309
|
actorutil.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/actorutil.cpp
|
#include "actorutil.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/player.hpp"
#include "../mwmechanics/creaturestats.hpp"
#include "../mwmechanics/magiceffects.hpp"
#include <components/esm3/loadmgef.hpp>
namespace MWMechanics
{
MWWorld::Ptr getPlayer()
{
return MWBase::Environment::get().getWorld()->getPlayerPtr();
}
bool isPlayerInCombat()
{
return MWBase::Environment::get().getWorld()->getPlayer().isInCombat();
}
bool canActorMoveByZAxis(const MWWorld::Ptr& actor)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
return (actor.getClass().canSwim(actor) && world->isSwimming(actor)) || world->isFlying(actor);
}
bool hasWaterWalking(const MWWorld::Ptr& actor)
{
const MWMechanics::MagicEffects& effects = actor.getClass().getCreatureStats(actor).getMagicEffects();
return effects.getOrDefault(ESM::MagicEffect::WaterWalking).getMagnitude() > 0;
}
bool isTargetMagicallyHidden(const MWWorld::Ptr& actor)
{
const MagicEffects& magicEffects = actor.getClass().getCreatureStats(actor).getMagicEffects();
return (magicEffects.getOrDefault(ESM::MagicEffect::Invisibility).getMagnitude() > 0)
|| (magicEffects.getOrDefault(ESM::MagicEffect::Chameleon).getMagnitude() >= 75);
}
}
| 1,419
|
C++
|
.cpp
| 35
| 35.4
| 110
| 0.703273
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,310
|
pathgrid.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/pathgrid.cpp
|
#include "pathgrid.hpp"
#include <algorithm>
#include <list>
#include <set>
namespace
{
// See https://theory.stanford.edu/~amitp/GameProgramming/Heuristics.html
//
// One of the smallest cost in Seyda Neen is between points 77 & 78:
// pt x y
// 77 = 8026, 4480
// 78 = 7986, 4218
//
// Euclidean distance is about 262 (ignoring z) and Manhattan distance is 300
// (again ignoring z). Using a value of about 300 for D seems like a reasonable
// starting point for experiments. If in doubt, just use value 1.
//
// The distance between 3 & 4 are pretty small, too.
// 3 = 5435, 223
// 4 = 5948, 193
//
// Approx. 514 Euclidean distance and 533 Manhattan distance.
//
float manhattan(const ESM::Pathgrid::Point& a, const ESM::Pathgrid::Point& b)
{
return 300.0f * (abs(a.mX - b.mX) + abs(a.mY - b.mY) + abs(a.mZ - b.mZ));
}
// Choose a heuristics - Note that these may not be the best for directed
// graphs with non-uniform edge costs.
//
// distance:
// - sqrt((curr.x - goal.x)^2 + (curr.y - goal.y)^2 + (curr.z - goal.z)^2)
// - slower but more accurate
//
// Manhattan:
// - |curr.x - goal.x| + |curr.y - goal.y| + |curr.z - goal.z|
// - faster but not the shortest path
float costAStar(const ESM::Pathgrid::Point& a, const ESM::Pathgrid::Point& b)
{
// return distance(a, b);
return manhattan(a, b);
}
constexpr size_t NoIndex = static_cast<size_t>(-1);
}
namespace MWMechanics
{
class PathgridGraph::Builder
{
std::vector<Node>& mGraph;
// variables used to calculate connected components
int mSCCId = 0;
size_t mSCCIndex = 0;
std::vector<size_t> mSCCStack;
std::vector<std::pair<size_t, size_t>> mSCCPoint; // first is index, second is lowlink
// v is the pathgrid point index (some call them vertices)
void recursiveStrongConnect(const size_t v)
{
mSCCPoint[v].first = mSCCIndex; // index
mSCCPoint[v].second = mSCCIndex; // lowlink
mSCCIndex++;
mSCCStack.push_back(v);
size_t w;
for (const auto& edge : mGraph[v].edges)
{
w = edge.index;
if (mSCCPoint[w].first == NoIndex) // not visited
{
recursiveStrongConnect(w); // recurse
mSCCPoint[v].second = std::min(mSCCPoint[v].second, mSCCPoint[w].second);
}
else if (std::find(mSCCStack.begin(), mSCCStack.end(), w) != mSCCStack.end())
mSCCPoint[v].second = std::min(mSCCPoint[v].second, mSCCPoint[w].first);
}
if (mSCCPoint[v].second == mSCCPoint[v].first)
{ // new component
do
{
w = mSCCStack.back();
mSCCStack.pop_back();
mGraph[w].componentId = mSCCId;
} while (w != v);
mSCCId++;
}
}
public:
/*
* mGraph contains the strongly connected component group id's along
* with pre-calculated edge costs.
*
* A cell can have disjointed pathgrids, e.g. Seyda Neen has 3
*
* mGraph for Seyda Neen will therefore have 3 different values. When
* selecting a random pathgrid point for AiWander, mGraph can be checked
* for quickly finding whether the destination is reachable.
*
* Otherwise, buildPath can automatically select a closest reachable end
* pathgrid point (reachable from the closest start point).
*
* Using Tarjan's algorithm:
*
* mGraph | graph G |
* mSCCPoint | V | derived from mPoints
* mGraph[v].edges | E (for v) |
* mSCCIndex | index | tracking smallest unused index
* mSCCStack | S |
* mGraph[v].edges[i].index | w |
*
*/
explicit Builder(PathgridGraph& graph)
: mGraph(graph.mGraph)
{
// both of these are set to zero in the constructor
// mSCCId = 0; // how many strongly connected components in this cell
// mSCCIndex = 0;
size_t pointsSize = graph.mPathgrid->mPoints.size();
mSCCPoint.resize(pointsSize, std::pair<size_t, size_t>(NoIndex, NoIndex));
mSCCStack.reserve(pointsSize);
for (size_t v = 0; v < pointsSize; ++v)
{
if (mSCCPoint[v].first == NoIndex) // undefined (haven't visited)
recursiveStrongConnect(v);
}
}
};
/*
* mGraph is populated with the cost of each allowed edge.
*
* The data structure is based on the code in buildPath2() but modified.
* Please check git history if interested.
*
* mGraph[v].edges[i].index = w
*
* v = point index of location "from"
* i = index of edges from point v
* w = point index of location "to"
*
*
* Example: (notice from p(0) to p(2) is not allowed in this example)
*
* mGraph[0].edges[0].index = 1
* .edges[1].index = 3
*
* mGraph[1].edges[0].index = 0
* .edges[1].index = 2
* .edges[2].index = 3
*
* mGraph[2].edges[0].index = 1
*
* (etc, etc)
*
*
* low
* cost
* p(0) <---> p(1) <------------> p(2)
* ^ ^
* | |
* | +-----> p(3)
* +---------------->
* high cost
*/
PathgridGraph::PathgridGraph(const ESM::Pathgrid& pathgrid)
: mPathgrid(&pathgrid)
{
mGraph.resize(mPathgrid->mPoints.size());
for (const auto& edge : mPathgrid->mEdges)
{
ConnectedPoint neighbour;
neighbour.cost = costAStar(mPathgrid->mPoints[edge.mV0], mPathgrid->mPoints[edge.mV1]);
// forward path of the edge
neighbour.index = edge.mV1;
mGraph[edge.mV0].edges.push_back(neighbour);
// reverse path of the edge
// NOTE: These are redundant, ESM already contains the required reverse paths
// neighbour.index = edge.mV0;
// mGraph[edge.mV1].edges.push_back(neighbour);
}
Builder(*this);
}
const PathgridGraph PathgridGraph::sEmpty = {};
bool PathgridGraph::isPointConnected(const size_t start, const size_t end) const
{
return (mGraph[start].componentId == mGraph[end].componentId);
}
void PathgridGraph::getNeighbouringPoints(const size_t index, ESM::Pathgrid::PointList& nodes) const
{
for (const auto& edge : mGraph[index].edges)
{
if (edge.index != index)
nodes.push_back(mPathgrid->mPoints[edge.index]);
}
}
/*
* NOTE: Based on buildPath2(), please check git history if interested
* Should consider using a 3rd party library version (e.g. boost)
*
* Find the shortest path to the target goal using a well known algorithm.
* Uses mGraph which has pre-computed costs for allowed edges. It is assumed
* that mGraph is already constructed.
*
* Should be possible to make this MT safe.
*
* Returns path which may be empty. path contains pathgrid points in local
* cell coordinates (indoors) or world coordinates (external).
*
* Input params:
* start, goal - pathgrid point indexes (for this cell)
*
* Variables:
* openset - point indexes to be traversed, lowest cost at the front
* closedset - point indexes already traversed
* gScore - past accumulated costs vector indexed by point index
* fScore - future estimated costs vector indexed by point index
*
* TODO: An interesting exercise might be to cache the paths created for a
* start/goal pair. To cache the results the paths need to be in
* pathgrid points form (currently they are converted to world
* coordinates). Essentially trading speed w/ memory.
*/
std::deque<ESM::Pathgrid::Point> PathgridGraph::aStarSearch(const size_t start, const size_t goal) const
{
std::deque<ESM::Pathgrid::Point> path;
if (!isPointConnected(start, goal))
{
return path; // there is no path, return an empty path
}
size_t graphSize = mGraph.size();
std::vector<float> gScore(graphSize, -1);
std::vector<float> fScore(graphSize, -1);
std::vector<size_t> graphParent(graphSize, NoIndex);
// gScore & fScore keep costs for each pathgrid point in mPoints
gScore[start] = 0;
fScore[start] = costAStar(mPathgrid->mPoints[start], mPathgrid->mPoints[goal]);
std::list<size_t> openset;
std::set<size_t> closedset;
openset.push_back(start);
size_t current = start;
while (!openset.empty())
{
current = openset.front(); // front has the lowest cost
openset.pop_front();
if (current == goal)
break;
closedset.insert(current); // remember we've been here
// check all edges for the current point index
for (const auto& edge : mGraph[current].edges)
{
if (!closedset.contains(edge.index))
{
// not in closedset - i.e. have not traversed this edge destination
size_t dest = edge.index;
float tentative_g = gScore[current] + edge.cost;
bool isInOpenSet = std::find(openset.begin(), openset.end(), dest) != openset.end();
if (!isInOpenSet || tentative_g < gScore[dest])
{
graphParent[dest] = current;
gScore[dest] = tentative_g;
fScore[dest] = tentative_g + costAStar(mPathgrid->mPoints[dest], mPathgrid->mPoints[goal]);
if (!isInOpenSet)
{
// add this edge to openset, lowest cost goes to the front
// TODO: if this causes performance problems a hash table may help
auto it = openset.begin();
for (; it != openset.end(); ++it)
{
if (fScore[*it] > fScore[dest])
break;
}
openset.insert(it, dest);
}
}
} // if in closedset, i.e. traversed this edge already, try the next edge
}
}
if (current != goal)
return path; // for some reason couldn't build a path
// reconstruct path to return, using local coordinates
while (graphParent[current] != NoIndex)
{
path.push_front(mPathgrid->mPoints[current]);
current = graphParent[current];
}
// add first node to path explicitly
path.push_front(mPathgrid->mPoints[start]);
return path;
}
}
| 11,527
|
C++
|
.cpp
| 286
| 30.174825
| 115
| 0.546241
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,311
|
spellutil.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/spellutil.cpp
|
#include "spellutil.hpp"
#include <limits>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadmgef.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "actorutil.hpp"
#include "creaturestats.hpp"
namespace MWMechanics
{
namespace
{
float getTotalCost(const ESM::EffectList& list, const EffectCostMethod method = EffectCostMethod::GameSpell)
{
float cost = 0;
for (const ESM::IndexedENAMstruct& effect : list.mList)
{
float effectCost = std::max(0.f, MWMechanics::calcEffectCost(effect.mData, nullptr, method));
// This is applied to the whole spell cost for each effect when
// creating spells, but is only applied on the effect itself in TES:CS.
if (effect.mData.mRange == ESM::RT_Target)
effectCost *= 1.5;
cost += effectCost;
}
return cost;
}
}
float calcEffectCost(
const ESM::ENAMstruct& effect, const ESM::MagicEffect* magicEffect, const EffectCostMethod method)
{
const MWWorld::ESMStore& store = *MWBase::Environment::get().getESMStore();
if (!magicEffect)
magicEffect = store.get<ESM::MagicEffect>().find(effect.mEffectID);
bool hasMagnitude = !(magicEffect->mData.mFlags & ESM::MagicEffect::NoMagnitude);
bool hasDuration = !(magicEffect->mData.mFlags & ESM::MagicEffect::NoDuration);
bool appliedOnce = magicEffect->mData.mFlags & ESM::MagicEffect::AppliedOnce;
int minMagn = hasMagnitude ? effect.mMagnMin : 1;
int maxMagn = hasMagnitude ? effect.mMagnMax : 1;
if (method == EffectCostMethod::PlayerSpell || method == EffectCostMethod::GameSpell)
{
minMagn = std::max(1, minMagn);
maxMagn = std::max(1, maxMagn);
}
int duration = hasDuration ? effect.mDuration : 1;
if (!appliedOnce)
duration = std::max(1, duration);
static const float fEffectCostMult = store.get<ESM::GameSetting>().find("fEffectCostMult")->mValue.getFloat();
static const float iAlchemyMod = store.get<ESM::GameSetting>().find("iAlchemyMod")->mValue.getFloat();
int durationOffset = 0;
int minArea = 0;
float costMult = fEffectCostMult;
if (method == EffectCostMethod::PlayerSpell)
{
durationOffset = 1;
minArea = 1;
}
else if (method == EffectCostMethod::GamePotion)
{
minArea = 1;
costMult = iAlchemyMod;
}
float x = 0.5 * (minMagn + maxMagn);
x *= 0.1 * magicEffect->mData.mBaseCost;
x *= durationOffset + duration;
x += 0.05 * std::max(minArea, effect.mArea) * magicEffect->mData.mBaseCost;
return x * costMult;
}
int calcSpellCost(const ESM::Spell& spell)
{
if (!(spell.mData.mFlags & ESM::Spell::F_Autocalc))
return spell.mData.mCost;
float cost = getTotalCost(spell.mEffects);
return std::round(cost);
}
int getEffectiveEnchantmentCastCost(float castCost, const MWWorld::Ptr& actor)
{
/*
* Each point of enchant skill above/under 10 subtracts/adds
* one percent of enchantment cost while minimum is 1.
*/
int eSkill = actor.getClass().getSkill(actor, ESM::Skill::Enchant);
const float result = castCost - (castCost / 100) * (eSkill - 10);
return static_cast<int>((result < 1) ? 1 : result);
}
int getEffectiveEnchantmentCastCost(const ESM::Enchantment& enchantment, const MWWorld::Ptr& actor)
{
float castCost;
if (enchantment.mData.mFlags & ESM::Enchantment::Autocalc)
castCost = getTotalCost(enchantment.mEffects, EffectCostMethod::GameEnchantment);
else
castCost = static_cast<float>(enchantment.mData.mCost);
return getEffectiveEnchantmentCastCost(castCost, actor);
}
int getEnchantmentCharge(const ESM::Enchantment& enchantment)
{
if (enchantment.mData.mFlags & ESM::Enchantment::Autocalc)
{
int charge
= static_cast<int>(std::round(getTotalCost(enchantment.mEffects, EffectCostMethod::GameEnchantment)));
const auto& store = MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
switch (enchantment.mData.mType)
{
case ESM::Enchantment::CastOnce:
{
static const int iMagicItemChargeOnce = store.find("iMagicItemChargeOnce")->mValue.getInteger();
return charge * iMagicItemChargeOnce;
}
case ESM::Enchantment::WhenStrikes:
{
static const int iMagicItemChargeStrike = store.find("iMagicItemChargeStrike")->mValue.getInteger();
return charge * iMagicItemChargeStrike;
}
case ESM::Enchantment::WhenUsed:
{
static const int iMagicItemChargeUse = store.find("iMagicItemChargeUse")->mValue.getInteger();
return charge * iMagicItemChargeUse;
}
case ESM::Enchantment::ConstantEffect:
{
static const int iMagicItemChargeConst = store.find("iMagicItemChargeConst")->mValue.getInteger();
return charge * iMagicItemChargeConst;
}
}
}
return enchantment.mData.mCharge;
}
int getPotionValue(const ESM::Potion& potion)
{
if (potion.mData.mFlags & ESM::Potion::Autocalc)
{
float cost = getTotalCost(potion.mEffects, EffectCostMethod::GamePotion);
return std::round(cost);
}
return potion.mData.mValue;
}
std::optional<ESM::EffectList> rollIngredientEffect(
MWWorld::Ptr caster, const ESM::Ingredient* ingredient, uint32_t index)
{
if (index >= 4)
throw std::range_error("Index out of range");
ESM::ENAMstruct effect;
effect.mEffectID = ingredient->mData.mEffectID[index];
effect.mSkill = ingredient->mData.mSkills[index];
effect.mAttribute = ingredient->mData.mAttributes[index];
effect.mRange = ESM::RT_Self;
effect.mArea = 0;
if (effect.mEffectID < 0)
return std::nullopt;
const MWWorld::ESMStore& store = *MWBase::Environment::get().getESMStore();
const auto magicEffect = store.get<ESM::MagicEffect>().find(effect.mEffectID);
const MWMechanics::CreatureStats& creatureStats = caster.getClass().getCreatureStats(caster);
float x = (caster.getClass().getSkill(caster, ESM::Skill::Alchemy)
+ 0.2f * creatureStats.getAttribute(ESM::Attribute::Intelligence).getModified()
+ 0.1f * creatureStats.getAttribute(ESM::Attribute::Luck).getModified())
* creatureStats.getFatigueTerm();
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
int roll = Misc::Rng::roll0to99(prng);
if (roll > x)
{
return std::nullopt;
}
float magnitude = 0;
float y = roll / std::min(x, 100.f);
y *= 0.25f * x;
if (magicEffect->mData.mFlags & ESM::MagicEffect::NoDuration)
effect.mDuration = 1;
else
effect.mDuration = static_cast<int>(y);
if (!(magicEffect->mData.mFlags & ESM::MagicEffect::NoMagnitude))
{
if (!(magicEffect->mData.mFlags & ESM::MagicEffect::NoDuration))
magnitude = floor((0.05f * y) / (0.1f * magicEffect->mData.mBaseCost));
else
magnitude = floor(y / (0.1f * magicEffect->mData.mBaseCost));
magnitude = std::max(1.f, magnitude);
}
else
magnitude = 1;
effect.mMagnMax = static_cast<int>(magnitude);
effect.mMagnMin = static_cast<int>(magnitude);
ESM::EffectList effects;
effects.mList.push_back({ effect, index });
return effects;
}
float calcSpellBaseSuccessChance(const ESM::Spell* spell, const MWWorld::Ptr& actor, ESM::RefId* effectiveSchool)
{
// Morrowind for some reason uses a formula slightly different from magicka cost calculation
float y = std::numeric_limits<float>::max();
float lowestSkill = 0;
for (const ESM::IndexedENAMstruct& effect : spell->mEffects.mList)
{
float x = static_cast<float>(effect.mData.mDuration);
const auto magicEffect
= MWBase::Environment::get().getESMStore()->get<ESM::MagicEffect>().find(effect.mData.mEffectID);
if (!(magicEffect->mData.mFlags & ESM::MagicEffect::AppliedOnce))
x = std::max(1.f, x);
x *= 0.1f * magicEffect->mData.mBaseCost;
x *= 0.5f * (effect.mData.mMagnMin + effect.mData.mMagnMax);
x += effect.mData.mArea * 0.05f * magicEffect->mData.mBaseCost;
if (effect.mData.mRange == ESM::RT_Target)
x *= 1.5f;
static const float fEffectCostMult = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fEffectCostMult")
->mValue.getFloat();
x *= fEffectCostMult;
float s = 2.0f * actor.getClass().getSkill(actor, magicEffect->mData.mSchool);
if (s - x < y)
{
y = s - x;
if (effectiveSchool)
*effectiveSchool = magicEffect->mData.mSchool;
lowestSkill = s;
}
}
CreatureStats& stats = actor.getClass().getCreatureStats(actor);
float actorWillpower = stats.getAttribute(ESM::Attribute::Willpower).getModified();
float actorLuck = stats.getAttribute(ESM::Attribute::Luck).getModified();
float castChance = (lowestSkill - calcSpellCost(*spell) + 0.2f * actorWillpower + 0.1f * actorLuck);
return castChance;
}
float getSpellSuccessChance(
const ESM::Spell* spell, const MWWorld::Ptr& actor, ESM::RefId* effectiveSchool, bool cap, bool checkMagicka)
{
// NB: Base chance is calculated here because the effective school pointer must be filled
float baseChance = calcSpellBaseSuccessChance(spell, actor, effectiveSchool);
bool godmode = actor == getPlayer() && MWBase::Environment::get().getWorld()->getGodModeState();
CreatureStats& stats = actor.getClass().getCreatureStats(actor);
if (stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Silence).getMagnitude() && !godmode)
return 0;
if (spell->mData.mType == ESM::Spell::ST_Power)
return stats.getSpells().canUsePower(spell) ? 100 : 0;
if (godmode)
return 100;
if (spell->mData.mType != ESM::Spell::ST_Spell)
return 100;
if (checkMagicka && calcSpellCost(*spell) > 0 && stats.getMagicka().getCurrent() < calcSpellCost(*spell))
return 0;
if (spell->mData.mFlags & ESM::Spell::F_Always)
return 100;
float castBonus = -stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Sound).getMagnitude();
float castChance = baseChance + castBonus;
castChance *= stats.getFatigueTerm();
if (cap)
return std::clamp(castChance, 0.f, 100.f);
return std::max(castChance, 0.f);
}
float getSpellSuccessChance(
const ESM::RefId& spellId, const MWWorld::Ptr& actor, ESM::RefId* effectiveSchool, bool cap, bool checkMagicka)
{
if (const auto spell = MWBase::Environment::get().getESMStore()->get<ESM::Spell>().search(spellId))
return getSpellSuccessChance(spell, actor, effectiveSchool, cap, checkMagicka);
return 0.f;
}
ESM::RefId getSpellSchool(const ESM::RefId& spellId, const MWWorld::Ptr& actor)
{
ESM::RefId school;
getSpellSuccessChance(spellId, actor, &school);
return school;
}
ESM::RefId getSpellSchool(const ESM::Spell* spell, const MWWorld::Ptr& actor)
{
ESM::RefId school;
getSpellSuccessChance(spell, actor, &school);
return school;
}
bool spellIncreasesSkill(const ESM::Spell* spell)
{
return spell->mData.mType == ESM::Spell::ST_Spell && !(spell->mData.mFlags & ESM::Spell::F_Always);
}
bool spellIncreasesSkill(const ESM::RefId& spellId)
{
const auto spell = MWBase::Environment::get().getESMStore()->get<ESM::Spell>().search(spellId);
return spell && spellIncreasesSkill(spell);
}
}
| 13,149
|
C++
|
.cpp
| 281
| 35.975089
| 120
| 0.608258
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,312
|
aiwander.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/aiwander.cpp
|
#include "aiwander.hpp"
#include <algorithm>
#include <osg/Matrixf>
#include <components/debug/debuglog.hpp>
#include <components/detournavigator/navigatorutils.hpp>
#include <components/esm3/aisequence.hpp>
#include <components/misc/coordinateconverter.hpp>
#include <components/misc/rng.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/cellstore.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/datetimemanager.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwphysics/raycasting.hpp"
#include "actorutil.hpp"
#include "character.hpp"
#include "creaturestats.hpp"
#include "movement.hpp"
#include "pathgrid.hpp"
namespace MWMechanics
{
static const int COUNT_BEFORE_RESET = 10;
static const float IDLE_POSITION_CHECK_INTERVAL = 1.5f;
// to prevent overcrowding
static const int DESTINATION_TOLERANCE = 64;
// distance must be long enough that NPC will need to move to get there.
static const int MINIMUM_WANDER_DISTANCE = DESTINATION_TOLERANCE * 2;
static const std::size_t MAX_IDLE_SIZE = 8;
const std::string AiWander::sIdleSelectToGroupName[GroupIndex_MaxIdle - GroupIndex_MinIdle + 1] = {
std::string("idle2"),
std::string("idle3"),
std::string("idle4"),
std::string("idle5"),
std::string("idle6"),
std::string("idle7"),
std::string("idle8"),
std::string("idle9"),
};
namespace
{
inline int getCountBeforeReset(const MWWorld::ConstPtr& actor)
{
if (actor.getClass().isPureWaterCreature(actor) || actor.getClass().isPureFlyingCreature(actor))
return 1;
return COUNT_BEFORE_RESET;
}
osg::Vec3f getRandomPointAround(const osg::Vec3f& position, const float distance)
{
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
const float randomDirection = Misc::Rng::rollClosedProbability(prng) * 2.0f * osg::PI;
osg::Matrixf rotation;
rotation.makeRotate(randomDirection, osg::Vec3f(0.0, 0.0, 1.0));
return position + osg::Vec3f(distance, 0.0, 0.0) * rotation;
}
bool isDestinationHidden(const MWWorld::ConstPtr& actor, const osg::Vec3f& destination)
{
const auto position = actor.getRefData().getPosition().asVec3();
const bool isWaterCreature = actor.getClass().isPureWaterCreature(actor);
const bool isFlyingCreature = actor.getClass().isPureFlyingCreature(actor);
const osg::Vec3f halfExtents
= MWBase::Environment::get().getWorld()->getPathfindingAgentBounds(actor).mHalfExtents;
osg::Vec3f direction = destination - position;
direction.normalize();
const auto visibleDestination
= (isWaterCreature || isFlyingCreature ? destination : destination + osg::Vec3f(0, 0, halfExtents.z()))
+ direction * std::max(halfExtents.x(), std::max(halfExtents.y(), halfExtents.z()));
const int mask = MWPhysics::CollisionType_World | MWPhysics::CollisionType_HeightMap
| MWPhysics::CollisionType_Door | MWPhysics::CollisionType_Actor;
return MWBase::Environment::get()
.getWorld()
->getRayCasting()
->castRay(position, visibleDestination, { actor }, {}, mask)
.mHit;
}
void stopMovement(const MWWorld::Ptr& actor)
{
auto& movementSettings = actor.getClass().getMovementSettings(actor);
movementSettings.mPosition[0] = 0;
movementSettings.mPosition[1] = 0;
}
std::vector<unsigned char> getInitialIdle(const std::vector<unsigned char>& idle)
{
std::vector<unsigned char> result(MAX_IDLE_SIZE, 0);
std::copy_n(idle.begin(), std::min(MAX_IDLE_SIZE, idle.size()), result.begin());
return result;
}
std::vector<unsigned char> getInitialIdle(const unsigned char (&idle)[MAX_IDLE_SIZE])
{
return std::vector<unsigned char>(std::begin(idle), std::end(idle));
}
}
AiWanderStorage::AiWanderStorage()
: mReaction(MWBase::Environment::get().getWorld()->getPrng())
, mState(Wander_ChooseAction)
, mIsWanderingManually(false)
, mCanWanderAlongPathGrid(true)
, mIdleAnimation(0)
, mBadIdles()
, mPopulateAvailableNodes(true)
, mAllowedNodes()
, mTrimCurrentNode(false)
, mCheckIdlePositionTimer(0)
, mStuckCount(0)
{
}
AiWander::AiWander(int distance, int duration, int timeOfDay, const std::vector<unsigned char>& idle, bool repeat)
: TypedAiPackage<AiWander>(repeat)
, mDistance(std::max(0, distance))
, mDuration(std::max(0, duration))
, mRemainingDuration(duration)
, mTimeOfDay(timeOfDay)
, mIdle(getInitialIdle(idle))
, mStoredInitialActorPosition(false)
, mInitialActorPosition(osg::Vec3f(0, 0, 0))
, mHasDestination(false)
, mDestination(osg::Vec3f(0, 0, 0))
, mUsePathgrid(false)
{
}
/*
* AiWander high level states (0.29.0). Not entirely accurate in some cases
* e.g. non-NPC actors do not greet and some creatures may be moving even in
* the IdleNow state.
*
* [select node,
* build path]
* +---------->MoveNow----------->Walking
* | |
* [allowed | |
* nodes] | [hello if near] |
* start--->ChooseAction----->IdleNow |
* ^ ^ | |
* | | | |
* | +-----------+ |
* | |
* +----------------------------------+
*
*
* New high level states. Not exactly as per vanilla (e.g. door stuff)
* but the differences are required because our physics does not work like
* vanilla and therefore have to compensate/work around.
*
* [select node, [if stuck evade
* build path] or remove nodes if near door]
* +---------->MoveNow<---------->Walking
* | ^ | |
* | |(near door) | |
* [allowed | | | |
* nodes] | [hello if near] | |
* start--->ChooseAction----->IdleNow | |
* ^ ^ | ^ | |
* | | | | (stuck near | |
* | +-----------+ +---------------+ |
* | player) |
* +----------------------------------+
*
* NOTE: non-time critical operations are run once every 250ms or so.
*
* TODO: It would be great if door opening/closing can be detected and pathgrid
* links dynamically updated. Currently (0.29.0) AiWander allows choosing a
* destination beyond closed doors which sometimes makes the actors stuck at the
* door and impossible for the player to open the door.
*
* For now detect being stuck at the door and simply delete the nodes from the
* allowed set. The issue is when the door opens the allowed set is not
* re-calculated. However this would not be an issue in most cases since hostile
* actors will enter combat (i.e. no longer wandering) and different pathfinding
* will kick in.
*/
bool AiWander::execute(
const MWWorld::Ptr& actor, CharacterController& characterController, AiState& state, float duration)
{
MWMechanics::CreatureStats& cStats = actor.getClass().getCreatureStats(actor);
if (cStats.isDead() || cStats.getHealth().getCurrent() <= 0)
return true; // Don't bother with dead actors
// get or create temporary storage
AiWanderStorage& storage = state.get<AiWanderStorage>();
mRemainingDuration
-= ((duration * MWBase::Environment::get().getWorld()->getTimeManager()->getGameTimeScale()) / 3600);
cStats.setDrawState(DrawState::Nothing);
cStats.setMovementFlag(CreatureStats::Flag_Run, false);
ESM::Position pos = actor.getRefData().getPosition();
// If there is already a destination due to the package having been interrupted by a combat or pursue package,
// rebuild a path to it
if (!mPathFinder.isPathConstructed() && mHasDestination)
{
const ESM::Pathgrid* pathgrid
= MWBase::Environment::get().getESMStore()->get<ESM::Pathgrid>().search(*actor.getCell()->getCell());
if (mUsePathgrid)
{
mPathFinder.buildPathByPathgrid(
pos.asVec3(), mDestination, actor.getCell(), getPathGridGraph(pathgrid));
}
else
{
const auto agentBounds = MWBase::Environment::get().getWorld()->getPathfindingAgentBounds(actor);
constexpr float endTolerance = 0;
const DetourNavigator::Flags navigatorFlags = getNavigatorFlags(actor);
const DetourNavigator::AreaCosts areaCosts = getAreaCosts(actor, navigatorFlags);
mPathFinder.buildPath(actor, pos.asVec3(), mDestination, actor.getCell(), getPathGridGraph(pathgrid),
agentBounds, navigatorFlags, areaCosts, endTolerance, PathType::Full);
}
if (mPathFinder.isPathConstructed())
storage.setState(AiWanderStorage::Wander_Walking, !mUsePathgrid);
}
if (!cStats.getMovementFlag(CreatureStats::Flag_ForceJump)
&& !cStats.getMovementFlag(CreatureStats::Flag_ForceSneak))
{
GreetingState greetingState = MWBase::Environment::get().getMechanicsManager()->getGreetingState(actor);
if (greetingState == Greet_InProgress)
{
if (storage.mState == AiWanderStorage::Wander_Walking)
{
stopMovement(actor);
mObstacleCheck.clear();
storage.setState(AiWanderStorage::Wander_IdleNow);
}
}
}
doPerFrameActionsForState(actor, duration, characterController.getSupportedMovementDirections(), storage);
if (storage.mReaction.update(duration) == Misc::TimerStatus::Waiting)
return false;
return reactionTimeActions(actor, storage, pos);
}
bool AiWander::reactionTimeActions(const MWWorld::Ptr& actor, AiWanderStorage& storage, ESM::Position& pos)
{
if (mDistance <= 0)
storage.mCanWanderAlongPathGrid = false;
if (isPackageCompleted())
{
stopWalking(actor);
// Reset package so it can be used again
mRemainingDuration = mDuration;
return true;
}
if (!mStoredInitialActorPosition)
{
mInitialActorPosition = actor.getRefData().getPosition().asVec3();
mStoredInitialActorPosition = true;
}
// Initialization to discover & store allowed node points for this actor.
if (storage.mPopulateAvailableNodes)
{
getAllowedNodes(actor, storage);
}
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
if (canActorMoveByZAxis(actor) && mDistance > 0)
{
// Typically want to idle for a short time before the next wander
if (Misc::Rng::rollDice(100, prng) >= 92 && storage.mState != AiWanderStorage::Wander_Walking)
{
wanderNearStart(actor, storage, mDistance);
}
storage.mCanWanderAlongPathGrid = false;
}
// If the package has a wander distance but no pathgrid is available,
// randomly idle or wander near spawn point
else if (storage.mAllowedNodes.empty() && mDistance > 0 && !storage.mIsWanderingManually)
{
// Typically want to idle for a short time before the next wander
if (Misc::Rng::rollDice(100, prng) >= 96)
{
wanderNearStart(actor, storage, mDistance);
}
else
{
storage.setState(AiWanderStorage::Wander_IdleNow);
}
}
else if (storage.mAllowedNodes.empty() && !storage.mIsWanderingManually)
{
storage.mCanWanderAlongPathGrid = false;
}
// If Wandering manually and hit an obstacle, stop
if (storage.mIsWanderingManually && mObstacleCheck.isEvading())
{
completeManualWalking(actor, storage);
}
if (storage.mState == AiWanderStorage::Wander_MoveNow && storage.mCanWanderAlongPathGrid)
{
// Construct a new path if there isn't one
if (!mPathFinder.isPathConstructed())
{
if (!storage.mAllowedNodes.empty())
{
setPathToAnAllowedNode(actor, storage, pos);
}
}
}
else if (storage.mIsWanderingManually && mPathFinder.checkPathCompleted())
{
completeManualWalking(actor, storage);
}
if (storage.mIsWanderingManually && storage.mState == AiWanderStorage::Wander_Walking
&& (mPathFinder.getPathSize() == 0 || isDestinationHidden(actor, mPathFinder.getPath().back())
|| isAreaOccupiedByOtherActor(actor, mPathFinder.getPath().back())))
completeManualWalking(actor, storage);
return false; // AiWander package not yet completed
}
osg::Vec3f AiWander::getDestination(const MWWorld::Ptr& actor) const
{
if (mHasDestination)
return mDestination;
return actor.getRefData().getPosition().asVec3();
}
bool AiWander::isPackageCompleted() const
{
// End package if duration is complete
return mDuration && mRemainingDuration <= 0;
}
/*
* Commands actor to walk to a random location near original spawn location.
*/
void AiWander::wanderNearStart(const MWWorld::Ptr& actor, AiWanderStorage& storage, int wanderDistance)
{
const auto currentPosition = actor.getRefData().getPosition().asVec3();
std::size_t attempts = 10; // If a unit can't wander out of water, don't want to hang here
const bool isWaterCreature = actor.getClass().isPureWaterCreature(actor);
const bool isFlyingCreature = actor.getClass().isPureFlyingCreature(actor);
const auto world = MWBase::Environment::get().getWorld();
const auto agentBounds = world->getPathfindingAgentBounds(actor);
const auto navigator = world->getNavigator();
const DetourNavigator::Flags navigatorFlags = getNavigatorFlags(actor);
const DetourNavigator::AreaCosts areaCosts = getAreaCosts(actor, navigatorFlags);
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
do
{
// Determine a random location within radius of original position
const float wanderRadius = (0.2f + Misc::Rng::rollClosedProbability(prng) * 0.8f) * wanderDistance;
if (!isWaterCreature && !isFlyingCreature)
{
// findRandomPointAroundCircle uses wanderDistance as limit for random and not as exact distance
const auto getRandom
= []() { return Misc::Rng::rollProbability(MWBase::Environment::get().getWorld()->getPrng()); };
auto destination = DetourNavigator::findRandomPointAroundCircle(
*navigator, agentBounds, mInitialActorPosition, wanderRadius, navigatorFlags, getRandom);
if (destination.has_value())
{
osg::Vec3f direction = *destination - mInitialActorPosition;
if (direction.length() > wanderDistance)
{
direction.normalize();
const osg::Vec3f adjustedDestination = mInitialActorPosition + direction * wanderRadius;
destination = DetourNavigator::raycast(
*navigator, agentBounds, currentPosition, adjustedDestination, navigatorFlags);
if (destination.has_value() && (*destination - mInitialActorPosition).length() > wanderDistance)
continue;
}
}
mDestination = destination.has_value() ? *destination
: getRandomPointAround(mInitialActorPosition, wanderRadius);
}
else
mDestination = getRandomPointAround(mInitialActorPosition, wanderRadius);
// Check if land creature will walk onto water or if water creature will swim onto land
if (!isWaterCreature && destinationIsAtWater(actor, mDestination))
continue;
if (isDestinationHidden(actor, mDestination))
continue;
if (isAreaOccupiedByOtherActor(actor, mDestination))
continue;
constexpr float endTolerance = 0;
if (isWaterCreature || isFlyingCreature)
mPathFinder.buildStraightPath(mDestination);
else
mPathFinder.buildPathByNavMesh(actor, currentPosition, mDestination, agentBounds, navigatorFlags,
areaCosts, endTolerance, PathType::Full);
if (mPathFinder.isPathConstructed())
{
storage.setState(AiWanderStorage::Wander_Walking, true);
mHasDestination = true;
mUsePathgrid = false;
}
break;
} while (--attempts);
}
/*
* Returns true if the position provided is above water.
*/
bool AiWander::destinationIsAtWater(const MWWorld::Ptr& actor, const osg::Vec3f& destination)
{
float heightToGroundOrWater = MWBase::Environment::get().getWorld()->getDistToNearestRayHit(
destination, osg::Vec3f(0, 0, -1), 1000.0, true);
osg::Vec3f positionBelowSurface = destination;
positionBelowSurface[2] = positionBelowSurface[2] - heightToGroundOrWater - 1.0f;
return MWBase::Environment::get().getWorld()->isUnderwater(actor.getCell(), positionBelowSurface);
}
void AiWander::completeManualWalking(const MWWorld::Ptr& actor, AiWanderStorage& storage)
{
stopWalking(actor);
mObstacleCheck.clear();
storage.setState(AiWanderStorage::Wander_IdleNow);
}
void AiWander::doPerFrameActionsForState(const MWWorld::Ptr& actor, float duration,
MWWorld::MovementDirectionFlags supportedMovementDirections, AiWanderStorage& storage)
{
// Attempt to fast forward to the next state instead of remaining in an intermediate state for a frame
for (int i = 0; i < 2; ++i)
{
switch (storage.mState)
{
case AiWanderStorage::Wander_IdleNow:
{
onIdleStatePerFrameActions(actor, duration, storage);
if (storage.mState != AiWanderStorage::Wander_ChooseAction)
return;
continue;
}
case AiWanderStorage::Wander_Walking:
onWalkingStatePerFrameActions(actor, duration, supportedMovementDirections, storage);
return;
case AiWanderStorage::Wander_ChooseAction:
{
onChooseActionStatePerFrameActions(actor, storage);
if (storage.mState != AiWanderStorage::Wander_IdleNow)
return;
continue;
}
case AiWanderStorage::Wander_MoveNow:
return; // nothing to do
default:
// should never get here
assert(false);
return;
}
}
}
void AiWander::onIdleStatePerFrameActions(const MWWorld::Ptr& actor, float duration, AiWanderStorage& storage)
{
// Check if an idle actor is too far from all allowed nodes or too close to a door - if so start walking.
storage.mCheckIdlePositionTimer += duration;
if (storage.mCheckIdlePositionTimer >= IDLE_POSITION_CHECK_INTERVAL && !isStationary())
{
storage.mCheckIdlePositionTimer = 0; // restart timer
static float distance = MWBase::Environment::get().getWorld()->getMaxActivationDistance() * 1.6f;
if (proximityToDoor(actor, distance) || !isNearAllowedNode(actor, storage, distance))
{
storage.setState(AiWanderStorage::Wander_MoveNow);
storage.mTrimCurrentNode = false; // just in case
return;
}
}
// Check if idle animation finished
GreetingState greetingState = MWBase::Environment::get().getMechanicsManager()->getGreetingState(actor);
if (!checkIdle(actor, storage.mIdleAnimation) && (greetingState == Greet_Done || greetingState == Greet_None))
{
if (mPathFinder.isPathConstructed())
storage.setState(AiWanderStorage::Wander_Walking, !mUsePathgrid);
else
storage.setState(AiWanderStorage::Wander_ChooseAction);
}
}
bool AiWander::isNearAllowedNode(const MWWorld::Ptr& actor, const AiWanderStorage& storage, float distance) const
{
const osg::Vec3f actorPos = actor.getRefData().getPosition().asVec3();
for (const ESM::Pathgrid::Point& node : storage.mAllowedNodes)
{
osg::Vec3f point(node.mX, node.mY, node.mZ);
if ((actorPos - point).length2() < distance * distance)
return true;
}
return false;
}
void AiWander::onWalkingStatePerFrameActions(const MWWorld::Ptr& actor, float duration,
MWWorld::MovementDirectionFlags supportedMovementDirections, AiWanderStorage& storage)
{
// Is there no destination or are we there yet?
if ((!mPathFinder.isPathConstructed())
|| pathTo(actor, osg::Vec3f(mPathFinder.getPath().back()), duration, supportedMovementDirections,
DESTINATION_TOLERANCE))
{
stopWalking(actor);
storage.setState(AiWanderStorage::Wander_ChooseAction);
}
else
{
// have not yet reached the destination
evadeObstacles(actor, storage);
}
}
void AiWander::onChooseActionStatePerFrameActions(const MWWorld::Ptr& actor, AiWanderStorage& storage)
{
// Wait while fully stop before starting idle animation (important if "smooth movement" is enabled).
if (actor.getClass().getCurrentSpeed(actor) > 0)
return;
unsigned short idleAnimation = getRandomIdle();
storage.mIdleAnimation = idleAnimation;
if (!idleAnimation && mDistance)
{
storage.setState(AiWanderStorage::Wander_MoveNow);
return;
}
if (idleAnimation)
{
if (std::find(storage.mBadIdles.begin(), storage.mBadIdles.end(), idleAnimation) == storage.mBadIdles.end())
{
if (!playIdle(actor, idleAnimation))
{
storage.mBadIdles.push_back(idleAnimation);
storage.setState(AiWanderStorage::Wander_ChooseAction);
return;
}
}
}
storage.setState(AiWanderStorage::Wander_IdleNow);
}
void AiWander::evadeObstacles(const MWWorld::Ptr& actor, AiWanderStorage& storage)
{
if (mObstacleCheck.isEvading())
{
// first check if we're walking into a door
static float distance = MWBase::Environment::get().getWorld()->getMaxActivationDistance();
if (proximityToDoor(actor, distance))
{
// remove allowed points then select another random destination
storage.mTrimCurrentNode = true;
trimAllowedNodes(storage.mAllowedNodes, mPathFinder);
mObstacleCheck.clear();
stopWalking(actor);
storage.setState(AiWanderStorage::Wander_MoveNow);
}
storage.mStuckCount++; // TODO: maybe no longer needed
}
// if stuck for sufficiently long, act like current location was the destination
if (storage.mStuckCount >= getCountBeforeReset(actor)) // something has gone wrong, reset
{
mObstacleCheck.clear();
stopWalking(actor);
storage.setState(AiWanderStorage::Wander_ChooseAction);
storage.mStuckCount = 0;
}
}
void AiWander::setPathToAnAllowedNode(
const MWWorld::Ptr& actor, AiWanderStorage& storage, const ESM::Position& actorPos)
{
auto world = MWBase::Environment::get().getWorld();
auto& prng = world->getPrng();
unsigned int randNode = Misc::Rng::rollDice(storage.mAllowedNodes.size(), prng);
const ESM::Pathgrid::Point& dest = storage.mAllowedNodes[randNode];
const osg::Vec3f start = actorPos.asVec3();
// don't take shortcuts for wandering
const ESM::Pathgrid* pathgrid = world->getStore().get<ESM::Pathgrid>().search(*actor.getCell()->getCell());
const osg::Vec3f destVec3f = PathFinder::makeOsgVec3(dest);
mPathFinder.buildPathByPathgrid(start, destVec3f, actor.getCell(), getPathGridGraph(pathgrid));
if (mPathFinder.isPathConstructed())
{
mDestination = destVec3f;
mHasDestination = true;
mUsePathgrid = true;
// Remove this node as an option and add back the previously used node (stops NPC from picking the same
// node):
ESM::Pathgrid::Point temp = storage.mAllowedNodes[randNode];
storage.mAllowedNodes.erase(storage.mAllowedNodes.begin() + randNode);
// check if mCurrentNode was taken out of mAllowedNodes
if (storage.mTrimCurrentNode && storage.mAllowedNodes.size() > 1)
storage.mTrimCurrentNode = false;
else
storage.mAllowedNodes.push_back(storage.mCurrentNode);
storage.mCurrentNode = temp;
storage.setState(AiWanderStorage::Wander_Walking);
}
// Choose a different node and delete this one from possible nodes because it is uncreachable:
else
storage.mAllowedNodes.erase(storage.mAllowedNodes.begin() + randNode);
}
void AiWander::trimAllowedNodes(std::vector<ESM::Pathgrid::Point>& nodes, const PathFinder& pathfinder)
{
// TODO: how to add these back in once the door opens?
// Idea: keep a list of detected closed doors (see aicombat.cpp)
// Every now and then check whether one of the doors is opened. (maybe
// at the end of playing idle?) If the door is opened then re-calculate
// allowed nodes starting from the spawn point.
auto paths = pathfinder.getPath();
while (paths.size() >= 2)
{
const auto pt = paths.back();
for (unsigned int j = 0; j < nodes.size(); j++)
{
// FIXME: doesn't handle a door with the same X/Y
// coordinates but with a different Z
if (std::abs(nodes[j].mX - pt.x()) <= 0.5 && std::abs(nodes[j].mY - pt.y()) <= 0.5)
{
nodes.erase(nodes.begin() + j);
break;
}
}
paths.pop_back();
}
}
void AiWander::stopWalking(const MWWorld::Ptr& actor)
{
mPathFinder.clearPath();
mHasDestination = false;
stopMovement(actor);
}
bool AiWander::playIdle(const MWWorld::Ptr& actor, unsigned short idleSelect)
{
if ((GroupIndex_MinIdle <= idleSelect) && (idleSelect <= GroupIndex_MaxIdle))
{
const std::string& groupName = sIdleSelectToGroupName[idleSelect - GroupIndex_MinIdle];
return MWBase::Environment::get().getMechanicsManager()->playAnimationGroup(actor, groupName, 0, 1);
}
else
{
Log(Debug::Verbose) << "Attempted to play out of range idle animation \"" << idleSelect << "\" for "
<< actor.getCellRef().getRefId();
return false;
}
}
bool AiWander::checkIdle(const MWWorld::Ptr& actor, unsigned short idleSelect)
{
if ((GroupIndex_MinIdle <= idleSelect) && (idleSelect <= GroupIndex_MaxIdle))
{
const std::string& groupName = sIdleSelectToGroupName[idleSelect - GroupIndex_MinIdle];
return MWBase::Environment::get().getMechanicsManager()->checkAnimationPlaying(actor, groupName);
}
else
{
return false;
}
}
int AiWander::getRandomIdle() const
{
MWBase::World* world = MWBase::Environment::get().getWorld();
static const float fIdleChanceMultiplier
= world->getStore().get<ESM::GameSetting>().find("fIdleChanceMultiplier")->mValue.getFloat();
if (Misc::Rng::rollClosedProbability(world->getPrng()) > fIdleChanceMultiplier)
return 0;
int newIdle = 0;
float maxRoll = 0.f;
for (size_t i = 0; i < mIdle.size(); i++)
{
float roll = Misc::Rng::rollClosedProbability(world->getPrng()) * 100.f;
if (roll <= mIdle[i] && roll > maxRoll)
{
newIdle = GroupIndex_MinIdle + i;
maxRoll = roll;
}
}
return newIdle;
}
void AiWander::fastForward(const MWWorld::Ptr& actor, AiState& state)
{
// Update duration counter
mRemainingDuration--;
if (mDistance == 0)
return;
AiWanderStorage& storage = state.get<AiWanderStorage>();
if (storage.mPopulateAvailableNodes)
getAllowedNodes(actor, storage);
if (storage.mAllowedNodes.empty())
return;
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
int index = Misc::Rng::rollDice(storage.mAllowedNodes.size(), prng);
ESM::Pathgrid::Point worldDest = storage.mAllowedNodes[index];
const Misc::CoordinateConverter converter = Misc::makeCoordinateConverter(*actor.getCell()->getCell());
ESM::Pathgrid::Point dest = converter.toLocalPoint(worldDest);
bool isPathGridOccupied = MWBase::Environment::get().getMechanicsManager()->isAnyActorInRange(
PathFinder::makeOsgVec3(worldDest), 60);
// add offset only if the selected pathgrid is occupied by another actor
if (isPathGridOccupied)
{
ESM::Pathgrid::PointList points;
getNeighbouringNodes(dest, actor.getCell(), points);
// there are no neighbouring nodes, nowhere to move
if (points.empty())
return;
bool isOccupied = false;
// AI will try to move the NPC towards every neighboring node until suitable place will be found
while (!points.empty())
{
int randomIndex = Misc::Rng::rollDice(points.size(), prng);
const ESM::Pathgrid::Point& connDest = points[randomIndex];
// add an offset towards random neighboring node
osg::Vec3f dir = PathFinder::makeOsgVec3(connDest) - PathFinder::makeOsgVec3(dest);
float length = dir.length();
dir.normalize();
for (int j = 1; j <= 3; j++)
{
// move for 5-15% towards random neighboring node
dest
= PathFinder::makePathgridPoint(PathFinder::makeOsgVec3(dest) + dir * (j * 5 * length / 100.f));
worldDest = converter.toWorldPoint(dest);
isOccupied = MWBase::Environment::get().getMechanicsManager()->isAnyActorInRange(
PathFinder::makeOsgVec3(worldDest), 60);
if (!isOccupied)
break;
}
if (!isOccupied)
break;
// Will try an another neighboring node
points.erase(points.begin() + randomIndex);
}
// there is no free space, nowhere to move
if (isOccupied)
return;
}
// place above to prevent moving inside objects, e.g. stairs, because a vector between pathgrids can be
// underground. Adding 20 in adjustPosition() is not enough.
dest.mZ += 60;
converter.toWorld(dest);
state.moveIn(std::make_unique<AiWanderStorage>());
osg::Vec3f pos(static_cast<float>(dest.mX), static_cast<float>(dest.mY), static_cast<float>(dest.mZ));
MWBase::Environment::get().getWorld()->moveObject(actor, pos);
actor.getClass().adjustPosition(actor, false);
}
void AiWander::getNeighbouringNodes(
ESM::Pathgrid::Point dest, const MWWorld::CellStore* currentCell, ESM::Pathgrid::PointList& points)
{
const ESM::Pathgrid* pathgrid
= MWBase::Environment::get().getESMStore()->get<ESM::Pathgrid>().search(*currentCell->getCell());
if (pathgrid == nullptr || pathgrid->mPoints.empty())
return;
int index = PathFinder::getClosestPoint(pathgrid, PathFinder::makeOsgVec3(dest));
getPathGridGraph(pathgrid).getNeighbouringPoints(index, points);
}
void AiWander::getAllowedNodes(const MWWorld::Ptr& actor, AiWanderStorage& storage)
{
// infrequently used, therefore no benefit in caching it as a member
const MWWorld::CellStore* cellStore = actor.getCell();
const ESM::Pathgrid* pathgrid
= MWBase::Environment::get().getESMStore()->get<ESM::Pathgrid>().search(*cellStore->getCell());
storage.mAllowedNodes.clear();
// If there is no path this actor doesn't go anywhere. See:
// https://forum.openmw.org/viewtopic.php?t=1556
// http://www.fliggerty.com/phpBB3/viewtopic.php?f=30&t=5833
// Note: In order to wander, need at least two points.
if (!pathgrid || (pathgrid->mPoints.size() < 2))
storage.mCanWanderAlongPathGrid = false;
// A distance value passed into the constructor indicates how far the
// actor can wander from the spawn position. AiWander assumes that
// pathgrid points are available, and uses them to randomly select wander
// destinations within the allowed set of pathgrid points (nodes).
// ... pathgrids don't usually include water, so swimmers ignore them
if (mDistance && storage.mCanWanderAlongPathGrid && !actor.getClass().isPureWaterCreature(actor))
{
// get NPC's position in local (i.e. cell) coordinates
const Misc::CoordinateConverter converter = Misc::makeCoordinateConverter(*cellStore->getCell());
const osg::Vec3f npcPos = converter.toLocalVec3(mInitialActorPosition);
// Find closest pathgrid point
int closestPointIndex = PathFinder::getClosestPoint(pathgrid, npcPos);
// mAllowedNodes for this actor with pathgrid point indexes based on mDistance
// and if the point is connected to the closest current point
// NOTE: mPoints is in local coordinates
size_t pointIndex = 0;
for (size_t counter = 0; counter < pathgrid->mPoints.size(); counter++)
{
osg::Vec3f nodePos(PathFinder::makeOsgVec3(pathgrid->mPoints[counter]));
if ((npcPos - nodePos).length2() <= mDistance * mDistance
&& getPathGridGraph(pathgrid).isPointConnected(closestPointIndex, counter))
{
storage.mAllowedNodes.push_back(converter.toWorldPoint(pathgrid->mPoints[counter]));
pointIndex = counter;
}
}
if (storage.mAllowedNodes.size() == 1)
{
storage.mAllowedNodes.push_back(PathFinder::makePathgridPoint(mInitialActorPosition));
addNonPathGridAllowedPoints(pathgrid, pointIndex, storage, converter);
}
if (!storage.mAllowedNodes.empty())
{
setCurrentNodeToClosestAllowedNode(storage);
}
}
storage.mPopulateAvailableNodes = false;
}
// When only one path grid point in wander distance,
// additional points for NPC to wander to are:
// 1. NPC's initial location
// 2. Partway along the path between the point and its connected points.
void AiWander::addNonPathGridAllowedPoints(const ESM::Pathgrid* pathGrid, size_t pointIndex,
AiWanderStorage& storage, const Misc::CoordinateConverter& converter)
{
for (const auto& edge : pathGrid->mEdges)
{
if (edge.mV0 == pointIndex)
{
AddPointBetweenPathGridPoints(converter.toWorldPoint(pathGrid->mPoints[edge.mV0]),
converter.toWorldPoint(pathGrid->mPoints[edge.mV1]), storage);
}
}
}
void AiWander::AddPointBetweenPathGridPoints(
const ESM::Pathgrid::Point& start, const ESM::Pathgrid::Point& end, AiWanderStorage& storage)
{
osg::Vec3f vectorStart = PathFinder::makeOsgVec3(start);
osg::Vec3f delta = PathFinder::makeOsgVec3(end) - vectorStart;
float length = delta.length();
delta.normalize();
int distance = std::max(mDistance / 2, MINIMUM_WANDER_DISTANCE);
// must not travel longer than distance between waypoints or NPC goes past waypoint
distance = std::min(distance, static_cast<int>(length));
delta *= distance;
storage.mAllowedNodes.push_back(PathFinder::makePathgridPoint(vectorStart + delta));
}
void AiWander::setCurrentNodeToClosestAllowedNode(AiWanderStorage& storage)
{
float distanceToClosestNode = std::numeric_limits<float>::max();
size_t index = 0;
for (size_t i = 0; i < storage.mAllowedNodes.size(); ++i)
{
osg::Vec3f nodePos(PathFinder::makeOsgVec3(storage.mAllowedNodes[i]));
float tempDist = (mInitialActorPosition - nodePos).length2();
if (tempDist < distanceToClosestNode)
{
index = i;
distanceToClosestNode = tempDist;
}
}
storage.mCurrentNode = storage.mAllowedNodes[index];
storage.mAllowedNodes.erase(storage.mAllowedNodes.begin() + index);
}
void AiWander::writeState(ESM::AiSequence::AiSequence& sequence) const
{
float remainingDuration;
if (mRemainingDuration > 0 && mRemainingDuration < 24)
remainingDuration = mRemainingDuration;
else
remainingDuration = mDuration;
auto wander = std::make_unique<ESM::AiSequence::AiWander>();
wander->mData.mDistance = mDistance;
wander->mData.mDuration = mDuration;
wander->mData.mTimeOfDay = mTimeOfDay;
wander->mDurationData.mRemainingDuration = remainingDuration;
assert(mIdle.size() == 8);
for (int i = 0; i < 8; ++i)
wander->mData.mIdle[i] = mIdle[i];
wander->mData.mShouldRepeat = mOptions.mRepeat;
wander->mStoredInitialActorPosition = mStoredInitialActorPosition;
if (mStoredInitialActorPosition)
wander->mInitialActorPosition = mInitialActorPosition;
ESM::AiSequence::AiPackageContainer package;
package.mType = ESM::AiSequence::Ai_Wander;
package.mPackage = std::move(wander);
sequence.mPackages.push_back(std::move(package));
}
AiWander::AiWander(const ESM::AiSequence::AiWander* wander)
: TypedAiPackage<AiWander>(makeDefaultOptions().withRepeat(wander->mData.mShouldRepeat != 0))
, mDistance(std::max(static_cast<short>(0), wander->mData.mDistance))
, mDuration(std::max(static_cast<short>(0), wander->mData.mDuration))
, mRemainingDuration(wander->mDurationData.mRemainingDuration)
, mTimeOfDay(wander->mData.mTimeOfDay)
, mIdle(getInitialIdle(wander->mData.mIdle))
, mStoredInitialActorPosition(wander->mStoredInitialActorPosition)
, mHasDestination(false)
, mDestination(osg::Vec3f(0, 0, 0))
, mUsePathgrid(false)
{
if (mStoredInitialActorPosition)
mInitialActorPosition = wander->mInitialActorPosition;
if (mRemainingDuration <= 0 || mRemainingDuration >= 24)
mRemainingDuration = mDuration;
}
}
| 41,557
|
C++
|
.cpp
| 857
| 37.507585
| 120
| 0.605259
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,313
|
steering.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/steering.cpp
|
#include "steering.hpp"
#include <components/misc/mathutil.hpp>
#include <components/settings/values.hpp>
#include "../mwworld/class.hpp"
#include "../mwworld/ptr.hpp"
#include "../mwbase/environment.hpp"
#include "movement.hpp"
namespace MWMechanics
{
bool smoothTurn(const MWWorld::Ptr& actor, float targetAngleRadians, int axis, float epsilonRadians)
{
MWMechanics::Movement& movement = actor.getClass().getMovementSettings(actor);
float diff = Misc::normalizeAngle(targetAngleRadians - actor.getRefData().getPosition().rot[axis]);
float absDiff = std::abs(diff);
// The turning animation actually moves you slightly, so the angle will be wrong again.
// Use epsilon to prevent jerkiness.
if (absDiff < epsilonRadians)
return true;
float limit
= getAngularVelocity(actor.getClass().getMaxSpeed(actor)) * MWBase::Environment::get().getFrameDuration();
if (Settings::game().mSmoothMovement)
limit *= std::min(absDiff / osg::PI + 0.1, 0.5);
if (absDiff > limit)
diff = osg::sign(diff) * limit;
movement.mRotation[axis] = diff;
return false;
}
bool zTurn(const MWWorld::Ptr& actor, float targetAngleRadians, float epsilonRadians)
{
return smoothTurn(actor, targetAngleRadians, 2, epsilonRadians);
}
}
| 1,380
|
C++
|
.cpp
| 32
| 36.5
| 118
| 0.682635
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,314
|
spellresistance.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/spellresistance.cpp
|
#include "spellresistance.hpp"
#include <components/misc/rng.hpp>
#include <components/esm3/loadmgef.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "creaturestats.hpp"
#include "spellutil.hpp"
namespace MWMechanics
{
float getEffectMultiplier(short effectId, const MWWorld::Ptr& actor, const MWWorld::Ptr& caster,
const ESM::Spell* spell, const MagicEffects* effects)
{
if (!actor.getClass().isActor())
return 1;
float resistance = getEffectResistance(effectId, actor, caster, spell, effects);
return 1 - resistance / 100.f;
}
float getEffectResistance(short effectId, const MWWorld::Ptr& actor, const MWWorld::Ptr& caster,
const ESM::Spell* spell, const MagicEffects* effects)
{
// Effects with no resistance attribute belonging to them can not be resisted
if (ESM::MagicEffect::getResistanceEffect(effectId) == -1)
return 0.f;
const auto magicEffect = MWBase::Environment::get().getESMStore()->get<ESM::MagicEffect>().find(effectId);
const MWMechanics::CreatureStats& stats = actor.getClass().getCreatureStats(actor);
const MWMechanics::MagicEffects* magicEffects = &stats.getMagicEffects();
if (effects)
magicEffects = effects;
float resistance = getEffectResistanceAttribute(effectId, magicEffects);
float willpower = stats.getAttribute(ESM::Attribute::Willpower).getModified();
float luck = stats.getAttribute(ESM::Attribute::Luck).getModified();
float x = (willpower + 0.1f * luck) * stats.getFatigueTerm();
// This makes spells that are easy to cast harder to resist and vice versa
float castChance = 100.f;
if (spell != nullptr && !caster.isEmpty() && caster.getClass().isActor())
castChance = getSpellSuccessChance(spell, caster, nullptr, false, false); // Uncapped casting chance
if (castChance > 0)
x *= 50 / castChance;
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
float roll = Misc::Rng::rollClosedProbability(prng) * 100;
if (magicEffect->mData.mFlags & ESM::MagicEffect::NoMagnitude)
roll -= resistance;
if (x <= roll)
x = 0;
else
{
if (magicEffect->mData.mFlags & ESM::MagicEffect::NoMagnitude)
x = 100;
else
x = roll / std::min(x, 100.f);
}
x = std::min(x + resistance, 100.f);
return x;
}
float getEffectResistanceAttribute(short effectId, const MagicEffects* actorEffects)
{
short resistanceEffect = ESM::MagicEffect::getResistanceEffect(effectId);
short weaknessEffect = ESM::MagicEffect::getWeaknessEffect(effectId);
float resistance = 0;
if (resistanceEffect != -1)
resistance += actorEffects->getOrDefault(resistanceEffect).getMagnitude();
if (weaknessEffect != -1)
resistance -= actorEffects->getOrDefault(weaknessEffect).getMagnitude();
if (effectId == ESM::MagicEffect::FireDamage)
resistance += actorEffects->getOrDefault(ESM::MagicEffect::FireShield).getMagnitude();
if (effectId == ESM::MagicEffect::ShockDamage)
resistance += actorEffects->getOrDefault(ESM::MagicEffect::LightningShield).getMagnitude();
if (effectId == ESM::MagicEffect::FrostDamage)
resistance += actorEffects->getOrDefault(ESM::MagicEffect::FrostShield).getMagnitude();
return resistance;
}
}
| 3,666
|
C++
|
.cpp
| 74
| 41.054054
| 114
| 0.663305
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,315
|
enchanting.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/enchanting.cpp
|
#include "enchanting.hpp"
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/misc/rng.hpp>
#include <components/settings/values.hpp>
#include "../mwworld/class.hpp"
#include "../mwworld/containerstore.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/world.hpp"
#include "actorutil.hpp"
#include "creaturestats.hpp"
#include "spellutil.hpp"
#include "weapontype.hpp"
namespace MWMechanics
{
Enchanting::Enchanting()
: mCastStyle(ESM::Enchantment::CastOnce)
, mSelfEnchanting(false)
, mObjectType(0)
, mWeaponType(-1)
{
}
void Enchanting::setOldItem(const MWWorld::Ptr& oldItem)
{
mOldItemPtr = oldItem;
mWeaponType = -1;
mObjectType = 0;
if (!itemEmpty())
{
mObjectType = mOldItemPtr.getType();
if (mObjectType == ESM::Weapon::sRecordId)
mWeaponType = mOldItemPtr.get<ESM::Weapon>()->mBase->mData.mType;
}
}
void Enchanting::setNewItemName(const std::string& s)
{
mNewItemName = s;
}
void Enchanting::setEffect(const ESM::EffectList& effectList)
{
mEffectList = effectList;
}
int Enchanting::getCastStyle() const
{
return mCastStyle;
}
void Enchanting::setSoulGem(const MWWorld::Ptr& soulGem)
{
mSoulGemPtr = soulGem;
}
bool Enchanting::create()
{
const MWWorld::Ptr& player = getPlayer();
MWWorld::ContainerStore& store = player.getClass().getContainerStore(player);
ESM::Enchantment enchantment;
enchantment.mData.mFlags = 0;
enchantment.mData.mType = mCastStyle;
enchantment.mData.mCost = getBaseCastCost();
enchantment.mRecordFlags = 0;
store.remove(mSoulGemPtr, 1);
// Exception for Azura Star, new one will be added after enchanting
auto azurasStarId = ESM::RefId::stringRefId("Misc_SoulGem_Azura");
if (mSoulGemPtr.get<ESM::Miscellaneous>()->mBase->mId == azurasStarId)
store.add(azurasStarId, 1);
if (mSelfEnchanting)
{
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
if (getEnchantChance() <= (Misc::Rng::roll0to99(prng)))
return false;
mEnchanter.getClass().skillUsageSucceeded(
mEnchanter, ESM::Skill::Enchant, ESM::Skill::Enchant_CreateMagicItem);
}
enchantment.mEffects = mEffectList;
int count = getEnchantItemsCount();
if (mCastStyle == ESM::Enchantment::ConstantEffect)
enchantment.mData.mCharge = 0;
else
enchantment.mData.mCharge = getGemCharge() / count;
// Try to find a dynamic enchantment with the same stats, create a new one if not found.
const ESM::Enchantment* enchantmentPtr = getRecord(enchantment);
if (enchantmentPtr == nullptr)
enchantmentPtr = MWBase::Environment::get().getESMStore()->insert(enchantment);
// Apply the enchantment
const ESM::RefId& newItemId
= mOldItemPtr.getClass().applyEnchantment(mOldItemPtr, enchantmentPtr->mId, getGemCharge(), mNewItemName);
if (!mSelfEnchanting)
payForEnchantment(count);
// Add the new item to player inventory and remove the old one
store.remove(mOldItemPtr, count);
store.add(newItemId, count);
return true;
}
void Enchanting::nextCastStyle()
{
if (itemEmpty())
return;
const bool powerfulSoul = getGemCharge() >= MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("iSoulAmountForConstantEffect")
->mValue.getInteger();
if ((mObjectType == ESM::Armor::sRecordId) || (mObjectType == ESM::Clothing::sRecordId))
{ // Armor or Clothing
switch (mCastStyle)
{
case ESM::Enchantment::WhenUsed:
if (powerfulSoul)
mCastStyle = ESM::Enchantment::ConstantEffect;
return;
default: // takes care of Constant effect too
mCastStyle = ESM::Enchantment::WhenUsed;
return;
}
}
else if (mWeaponType != -1)
{ // Weapon
ESM::WeaponType::Class weapclass = MWMechanics::getWeaponType(mWeaponType)->mWeaponClass;
switch (mCastStyle)
{
case ESM::Enchantment::WhenStrikes:
if (weapclass == ESM::WeaponType::Melee || weapclass == ESM::WeaponType::Ranged)
mCastStyle = ESM::Enchantment::WhenUsed;
return;
case ESM::Enchantment::WhenUsed:
if (powerfulSoul && weapclass != ESM::WeaponType::Ammo && weapclass != ESM::WeaponType::Thrown)
mCastStyle = ESM::Enchantment::ConstantEffect;
else if (weapclass != ESM::WeaponType::Ranged)
mCastStyle = ESM::Enchantment::WhenStrikes;
return;
default: // takes care of Constant effect too
mCastStyle = ESM::Enchantment::WhenUsed;
if (weapclass != ESM::WeaponType::Ranged)
mCastStyle = ESM::Enchantment::WhenStrikes;
return;
}
}
else if (mObjectType == ESM::Book::sRecordId)
{ // Scroll or Book
mCastStyle = ESM::Enchantment::CastOnce;
return;
}
// Fail case
mCastStyle = ESM::Enchantment::CastOnce;
}
/*
* Vanilla enchant cost formula:
*
* Touch/Self: (min + max) * baseCost * 0.025 * duration + area * baseCost * 0.025
* Target: 1.5 * ((min + max) * baseCost * 0.025 * duration + area * baseCost * 0.025)
* Constant eff: (min + max) * baseCost * 2.5 + area * baseCost * 0.025
*
* For multiple effects - cost of each effect is multiplied by number of effects that follows +1.
*
* Note: Minimal value inside formula for 'min' and 'max' is 1. So in vanilla:
* (0 + 0) == (1 + 0) == (1 + 1) => 2 or (2 + 0) == (1 + 2) => 3
*
* Formula on UESPWiki is not entirely correct.
*/
float Enchanting::getEnchantPoints(bool precise) const
{
if (mEffectList.mList.empty())
// No effects added, cost = 0
return 0;
const MWWorld::ESMStore& store = *MWBase::Environment::get().getESMStore();
const float fEffectCostMult = store.get<ESM::GameSetting>().find("fEffectCostMult")->mValue.getFloat();
const float fEnchantmentConstantDurationMult
= store.get<ESM::GameSetting>().find("fEnchantmentConstantDurationMult")->mValue.getFloat();
float enchantmentCost = 0.f;
float cost = 0.f;
for (const ESM::IndexedENAMstruct& effect : mEffectList.mList)
{
float baseCost = (store.get<ESM::MagicEffect>().find(effect.mData.mEffectID))->mData.mBaseCost;
int magMin = std::max(1, effect.mData.mMagnMin);
int magMax = std::max(1, effect.mData.mMagnMax);
int area = std::max(1, effect.mData.mArea);
float duration = static_cast<float>(effect.mData.mDuration);
if (mCastStyle == ESM::Enchantment::ConstantEffect)
duration = fEnchantmentConstantDurationMult;
cost += ((magMin + magMax) * duration + area) * baseCost * fEffectCostMult * 0.05f;
cost = std::max(1.f, cost);
if (effect.mData.mRange == ESM::RT_Target)
cost *= 1.5f;
enchantmentCost += precise ? cost : std::floor(cost);
}
return enchantmentCost;
}
const ESM::Enchantment* Enchanting::getRecord(const ESM::Enchantment& toFind) const
{
const MWWorld::Store<ESM::Enchantment>& enchantments
= MWBase::Environment::get().getESMStore()->get<ESM::Enchantment>();
MWWorld::Store<ESM::Enchantment>::iterator iter(enchantments.begin());
iter += (enchantments.getSize() - enchantments.getDynamicSize());
for (; iter != enchantments.end(); ++iter)
{
if (iter->mEffects.mList.size() != toFind.mEffects.mList.size())
continue;
if (iter->mData.mFlags != toFind.mData.mFlags || iter->mData.mType != toFind.mData.mType
|| iter->mData.mCost != toFind.mData.mCost || iter->mData.mCharge != toFind.mData.mCharge)
continue;
// Don't choose an ID that came from the content files, would have unintended side effects
if (!enchantments.isDynamic(iter->mId))
continue;
bool mismatch = false;
for (int i = 0; i < static_cast<int>(iter->mEffects.mList.size()); ++i)
{
if (iter->mEffects.mList[i] != toFind.mEffects.mList[i])
{
mismatch = true;
break;
}
}
if (!mismatch)
return &(*iter);
}
return nullptr;
}
int Enchanting::getBaseCastCost() const
{
if (mCastStyle == ESM::Enchantment::ConstantEffect)
return 0;
return static_cast<int>(getEnchantPoints(false));
}
int Enchanting::getEffectiveCastCost() const
{
int baseCost = getBaseCastCost();
MWWorld::Ptr player = getPlayer();
return getEffectiveEnchantmentCastCost(static_cast<float>(baseCost), player);
}
int Enchanting::getEnchantPrice(int count) const
{
if (mEnchanter.isEmpty())
return 0;
float priceMultipler = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fEnchantmentValueMult")
->mValue.getFloat();
int price = MWBase::Environment::get().getMechanicsManager()->getBarterOffer(
mEnchanter, static_cast<int>(getEnchantPoints() * priceMultipler), true);
price *= count * getTypeMultiplier();
return std::max(1, price);
}
int Enchanting::getGemCharge() const
{
const MWWorld::ESMStore& store = *MWBase::Environment::get().getESMStore();
if (soulEmpty())
return 0;
if (mSoulGemPtr.getCellRef().getSoul().empty())
return 0;
const ESM::Creature* soul = store.get<ESM::Creature>().search(mSoulGemPtr.getCellRef().getSoul());
if (soul)
return soul->mData.mSoul;
else
return 0;
}
int Enchanting::getMaxEnchantValue() const
{
if (itemEmpty())
return 0;
const MWWorld::ESMStore& store = *MWBase::Environment::get().getESMStore();
return static_cast<int>(mOldItemPtr.getClass().getEnchantmentPoints(mOldItemPtr)
* store.get<ESM::GameSetting>().find("fEnchantmentMult")->mValue.getFloat());
}
bool Enchanting::soulEmpty() const
{
return mSoulGemPtr.isEmpty();
}
bool Enchanting::itemEmpty() const
{
return mOldItemPtr.isEmpty();
}
void Enchanting::setSelfEnchanting(bool selfEnchanting)
{
mSelfEnchanting = selfEnchanting;
}
void Enchanting::setEnchanter(const MWWorld::Ptr& enchanter)
{
mEnchanter = enchanter;
// Reset cast style
mCastStyle = ESM::Enchantment::CastOnce;
}
int Enchanting::getEnchantChance() const
{
const CreatureStats& stats = mEnchanter.getClass().getCreatureStats(mEnchanter);
const MWWorld::Store<ESM::GameSetting>& gmst
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
const float a = static_cast<float>(mEnchanter.getClass().getSkill(mEnchanter, ESM::Skill::Enchant));
const float b = static_cast<float>(stats.getAttribute(ESM::Attribute::Intelligence).getModified());
const float c = static_cast<float>(stats.getAttribute(ESM::Attribute::Luck).getModified());
const float fEnchantmentChanceMult = gmst.find("fEnchantmentChanceMult")->mValue.getFloat();
const float fEnchantmentConstantChanceMult = gmst.find("fEnchantmentConstantChanceMult")->mValue.getFloat();
float x = (a - getEnchantPoints() * fEnchantmentChanceMult * getTypeMultiplier() * getEnchantItemsCount()
+ 0.2f * b + 0.1f * c)
* stats.getFatigueTerm();
if (mCastStyle == ESM::Enchantment::ConstantEffect)
x *= fEnchantmentConstantChanceMult;
return static_cast<int>(x);
}
int Enchanting::getEnchantItemsCount() const
{
int count = 1;
float enchantPoints = getEnchantPoints();
if (mWeaponType != -1 && enchantPoints > 0)
{
ESM::WeaponType::Class weapclass = MWMechanics::getWeaponType(mWeaponType)->mWeaponClass;
if (weapclass == ESM::WeaponType::Thrown || weapclass == ESM::WeaponType::Ammo)
{
MWWorld::Ptr player = getPlayer();
count = player.getClass().getContainerStore(player).count(mOldItemPtr.getCellRef().getRefId());
count = std::clamp<int>(
getGemCharge() * Settings::game().mProjectilesEnchantMultiplier / enchantPoints, 1, count);
}
}
return count;
}
float Enchanting::getTypeMultiplier() const
{
if (Settings::game().mProjectilesEnchantMultiplier > 0 && mWeaponType != -1 && getEnchantPoints() > 0)
{
ESM::WeaponType::Class weapclass = MWMechanics::getWeaponType(mWeaponType)->mWeaponClass;
if (weapclass == ESM::WeaponType::Thrown || weapclass == ESM::WeaponType::Ammo)
return 0.125f;
}
return 1.f;
}
void Enchanting::payForEnchantment(int count) const
{
const MWWorld::Ptr& player = getPlayer();
MWWorld::ContainerStore& store = player.getClass().getContainerStore(player);
int price = getEnchantPrice(count);
store.remove(MWWorld::ContainerStore::sGoldId, price);
// add gold to NPC trading gold pool
CreatureStats& enchanterStats = mEnchanter.getClass().getCreatureStats(mEnchanter);
enchanterStats.setGoldPool(enchanterStats.getGoldPool() + price);
}
}
| 14,872
|
C++
|
.cpp
| 338
| 33.230769
| 118
| 0.593877
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,316
|
weaponpriority.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/weaponpriority.cpp
|
#include "weaponpriority.hpp"
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadgmst.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwworld/inventorystore.hpp"
#include "aicombataction.hpp"
#include "combat.hpp"
#include "spellpriority.hpp"
#include "spellutil.hpp"
#include "weapontype.hpp"
namespace MWMechanics
{
float rateWeapon(const MWWorld::Ptr& item, const MWWorld::Ptr& actor, const MWWorld::Ptr& enemy, int type,
float arrowRating, float boltRating)
{
if (enemy.isEmpty() || item.getType() != ESM::Weapon::sRecordId)
return 0.f;
if (item.getClass().hasItemHealth(item) && item.getClass().getItemHealth(item) == 0)
return 0.f;
const ESM::Weapon* weapon = item.get<ESM::Weapon>()->mBase;
if (type != -1 && weapon->mData.mType != type)
return 0.f;
const MWBase::World* world = MWBase::Environment::get().getWorld();
const MWWorld::Store<ESM::GameSetting>& gmst = world->getStore().get<ESM::GameSetting>();
ESM::WeaponType::Class weapclass = MWMechanics::getWeaponType(weapon->mData.mType)->mWeaponClass;
if (type == -1 && weapclass == ESM::WeaponType::Ammo)
return 0.f;
float rating = 0.f;
static const float fAIMeleeWeaponMult = gmst.find("fAIMeleeWeaponMult")->mValue.getFloat();
float ratingMult = fAIMeleeWeaponMult;
if (weapclass != ESM::WeaponType::Melee)
{
// Underwater ranged combat is impossible
if (world->isUnderwater(MWWorld::ConstPtr(actor), 0.75f)
|| world->isUnderwater(MWWorld::ConstPtr(enemy), 0.75f))
return 0.f;
// Use a higher rating multiplier if the actor is out of enemy's reach, use the normal mult otherwise
if (getDistanceMinusHalfExtents(actor, enemy) >= getMaxAttackDistance(enemy))
{
static const float fAIRangeMeleeWeaponMult = gmst.find("fAIRangeMeleeWeaponMult")->mValue.getFloat();
ratingMult = fAIRangeMeleeWeaponMult;
}
}
const float chop = (weapon->mData.mChop[0] + weapon->mData.mChop[1]) / 2.f;
// We need to account for the fact that thrown weapons have 2x real damage applied to the target
// as they're both the weapon and the ammo of the hit
if (weapclass == ESM::WeaponType::Thrown)
{
rating = chop * 2;
}
else if (weapclass != ESM::WeaponType::Melee)
{
rating = chop;
}
else
{
const float slash = (weapon->mData.mSlash[0] + weapon->mData.mSlash[1]) / 2.f;
const float thrust = (weapon->mData.mThrust[0] + weapon->mData.mThrust[1]) / 2.f;
rating = (slash * slash + thrust * thrust + chop * chop) / (slash + thrust + chop);
}
adjustWeaponDamage(rating, item, actor);
if (weapclass != ESM::WeaponType::Ranged)
{
resistNormalWeapon(enemy, actor, item, rating);
applyWerewolfDamageMult(enemy, item, rating);
}
else
{
int ammotype = MWMechanics::getWeaponType(weapon->mData.mType)->mAmmoType;
if (ammotype == ESM::Weapon::Arrow)
{
if (arrowRating <= 0.f)
rating = 0.f;
else
rating += arrowRating;
}
else if (ammotype == ESM::Weapon::Bolt)
{
if (boltRating <= 0.f)
rating = 0.f;
else
rating += boltRating;
}
}
if (!weapon->mEnchant.empty())
{
const ESM::Enchantment* enchantment = world->getStore().get<ESM::Enchantment>().find(weapon->mEnchant);
if (enchantment->mData.mType == ESM::Enchantment::WhenStrikes)
{
int castCost = getEffectiveEnchantmentCastCost(*enchantment, actor);
float charge = item.getCellRef().getEnchantmentCharge();
if (charge == -1 || charge >= castCost || weapclass == ESM::WeaponType::Thrown
|| weapclass == ESM::WeaponType::Ammo)
rating += rateEffects(enchantment->mEffects, actor, enemy, false);
}
}
int value = 50.f;
ESM::RefId skill = item.getClass().getEquipmentSkill(item);
if (!skill.empty())
value = actor.getClass().getSkill(actor, skill);
// Prefer hand-to-hand if our skill is 0 (presumably due to magic)
if (value <= 0.f)
return 0.f;
// Note that a creature with a dagger and 0 Stealth will forgo the weapon despite using Combat for hit chance.
// The same creature will use a sword provided its Combat stat isn't 0. We're using the "skill" value here to
// decide whether to use the weapon at all, but adjusting the final rating based on actual hit chance - i.e. the
// Combat stat.
if (!actor.getClass().isNpc())
{
MWWorld::LiveCellRef<ESM::Creature>* ref = actor.get<ESM::Creature>();
value = ref->mBase->mData.mCombat;
}
// Take hit chance in account, but do not allow rating become negative.
rating *= std::clamp(getHitChance(actor, enemy, value) / 100.f, 0.01f, 1.f);
if (weapclass != ESM::WeaponType::Ammo)
rating *= weapon->mData.mSpeed;
return rating * ratingMult;
}
float rateAmmo(const MWWorld::Ptr& actor, const MWWorld::Ptr& enemy, MWWorld::Ptr& bestAmmo, int ammoType)
{
float bestAmmoRating = 0.f;
if (!actor.getClass().hasInventoryStore(actor))
return bestAmmoRating;
MWWorld::InventoryStore& store = actor.getClass().getInventoryStore(actor);
for (MWWorld::ContainerStoreIterator it = store.begin(); it != store.end(); ++it)
{
float rating = rateWeapon(*it, actor, enemy, ammoType);
if (rating > bestAmmoRating)
{
bestAmmoRating = rating;
bestAmmo = *it;
}
}
return bestAmmoRating;
}
float rateAmmo(const MWWorld::Ptr& actor, const MWWorld::Ptr& enemy, int ammoType)
{
MWWorld::Ptr emptyPtr;
return rateAmmo(actor, enemy, emptyPtr, ammoType);
}
float vanillaRateWeaponAndAmmo(
const MWWorld::Ptr& weapon, const MWWorld::Ptr& ammo, const MWWorld::Ptr& actor, const MWWorld::Ptr& enemy)
{
const MWWorld::Store<ESM::GameSetting>& gmst
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
static const float fAIMeleeWeaponMult = gmst.find("fAIMeleeWeaponMult")->mValue.getFloat();
static const float fAIMeleeArmorMult = gmst.find("fAIMeleeArmorMult")->mValue.getFloat();
static const float fAIRangeMeleeWeaponMult = gmst.find("fAIRangeMeleeWeaponMult")->mValue.getFloat();
if (weapon.isEmpty())
return 0.f;
float skillMult = actor.getClass().getSkill(actor, weapon.getClass().getEquipmentSkill(weapon)) * 0.01f;
float chopMult = fAIMeleeWeaponMult;
float bonusDamage = 0.f;
const ESM::Weapon* esmWeap = weapon.get<ESM::Weapon>()->mBase;
int type = esmWeap->mData.mType;
if (getWeaponType(type)->mWeaponClass != ESM::WeaponType::Melee)
{
if (!ammo.isEmpty() && !MWBase::Environment::get().getWorld()->isSwimming(enemy))
{
bonusDamage = ammo.get<ESM::Weapon>()->mBase->mData.mChop[1];
chopMult = fAIRangeMeleeWeaponMult;
}
else
chopMult = 0.f;
}
float chopRating = (esmWeap->mData.mChop[1] + bonusDamage) * skillMult * chopMult;
float slashRating = esmWeap->mData.mSlash[1] * skillMult * fAIMeleeWeaponMult;
float thrustRating = esmWeap->mData.mThrust[1] * skillMult * fAIMeleeWeaponMult;
return actor.getClass().getArmorRating(actor) * fAIMeleeArmorMult
+ std::max(std::max(chopRating, slashRating), thrustRating);
}
}
| 8,334
|
C++
|
.cpp
| 176
| 37.039773
| 120
| 0.605811
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,317
|
actors.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/actors.cpp
|
#include "actors.hpp"
#include <array>
#include <optional>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/debug/debuglog.hpp>
#include <components/misc/mathutil.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/misc/rng.hpp>
#include <components/sceneutil/positionattitudetransform.hpp>
#include <components/settings/values.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadstat.hpp>
#include "../mwworld/cellstore.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/datetimemanager.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwworld/inventorystore.hpp"
#include "../mwworld/player.hpp"
#include "../mwworld/scene.hpp"
#include "../mwbase/dialoguemanager.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/statemanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwmechanics/aibreathe.hpp"
#include "../mwrender/vismask.hpp"
#include "../mwsound/constants.hpp"
#include "actor.hpp"
#include "actorutil.hpp"
#include "aicombataction.hpp"
#include "aifollow.hpp"
#include "aipursue.hpp"
#include "aiwander.hpp"
#include "attacktype.hpp"
#include "character.hpp"
#include "creaturestats.hpp"
#include "movement.hpp"
#include "npcstats.hpp"
#include "steering.hpp"
#include "summoning.hpp"
namespace
{
bool isConscious(const MWWorld::Ptr& ptr)
{
const MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
return !stats.isDead() && !stats.getKnockedDown();
}
bool isCommanded(const MWWorld::Ptr& actor)
{
const auto& actorClass = actor.getClass();
const auto& stats = actorClass.getCreatureStats(actor);
const bool isActorNpc = actorClass.isNpc();
const auto level = stats.getLevel();
for (const auto& params : stats.getActiveSpells())
{
for (const auto& effect : params.getEffects())
{
if (((effect.mEffectId == ESM::MagicEffect::CommandHumanoid && isActorNpc)
|| (effect.mEffectId == ESM::MagicEffect::CommandCreature && !isActorNpc))
&& effect.mMagnitude >= level)
return true;
}
}
return false;
}
// Check for command effects having ended and remove package if necessary
void adjustCommandedActor(const MWWorld::Ptr& actor)
{
if (isCommanded(actor))
return;
MWMechanics::CreatureStats& stats = actor.getClass().getCreatureStats(actor);
stats.getAiSequence().erasePackageIf([](auto& entry) {
if (entry->getTypeId() == MWMechanics::AiPackageTypeId::Follow
&& static_cast<const MWMechanics::AiFollow*>(entry.get())->isCommanded())
{
return true;
}
return false;
});
}
std::pair<float, float> getRestorationPerHourOfSleep(const MWWorld::Ptr& ptr)
{
const MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
const MWWorld::Store<ESM::GameSetting>& settings
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
const float endurance = stats.getAttribute(ESM::Attribute::Endurance).getModified();
const float health = 0.1f * endurance;
static const float fRestMagicMult = settings.find("fRestMagicMult")->mValue.getFloat();
const float magicka = fRestMagicMult * stats.getAttribute(ESM::Attribute::Intelligence).getModified();
return { health, magicka };
}
template <class T>
void forEachFollowingPackage(
const std::list<MWMechanics::Actor>& actors, const MWWorld::Ptr& actorPtr, const MWWorld::Ptr& player, T&& func)
{
for (const MWMechanics::Actor& actor : actors)
{
const MWWorld::Ptr& iteratedActor = actor.getPtr();
if (iteratedActor == player || iteratedActor == actorPtr)
continue;
const MWMechanics::CreatureStats& stats = iteratedActor.getClass().getCreatureStats(iteratedActor);
if (stats.isDead())
continue;
// An actor counts as following if AiFollow is the current AiPackage,
// or there are only Combat and Wander packages before the AiFollow package
for (const auto& package : stats.getAiSequence())
{
if (!func(actor, package))
break;
}
}
}
float getStuntedMagickaDuration(const MWWorld::Ptr& actor)
{
float remainingTime = 0.f;
for (const auto& params : actor.getClass().getCreatureStats(actor).getActiveSpells())
{
for (const auto& effect : params.getEffects())
{
if (effect.mEffectId == ESM::MagicEffect::StuntedMagicka)
{
if (effect.mDuration == -1.f)
return -1.f;
remainingTime = std::max(remainingTime, effect.mTimeLeft);
}
}
}
return remainingTime;
}
void soulTrap(const MWWorld::Ptr& creature)
{
const auto& stats = creature.getClass().getCreatureStats(creature);
if (!stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Soultrap).getMagnitude())
return;
const int creatureSoulValue = creature.get<ESM::Creature>()->mBase->mData.mSoul;
if (creatureSoulValue == 0)
return;
MWBase::World* const world = MWBase::Environment::get().getWorld();
static const float fSoulgemMult
= world->getStore().get<ESM::GameSetting>().find("fSoulgemMult")->mValue.getFloat();
for (const auto& params : stats.getActiveSpells())
{
for (const auto& effect : params.getEffects())
{
if (effect.mEffectId != ESM::MagicEffect::Soultrap || effect.mMagnitude <= 0.f)
continue;
MWWorld::Ptr caster = world->searchPtrViaActorId(params.getCasterActorId());
if (caster.isEmpty() || !caster.getClass().isActor())
continue;
// Use the smallest soulgem that is large enough to hold the soul
MWWorld::ContainerStore& container = caster.getClass().getContainerStore(caster);
MWWorld::ContainerStoreIterator gem = container.end();
float gemCapacity = std::numeric_limits<float>::max();
for (auto it = container.begin(MWWorld::ContainerStore::Type_Miscellaneous); it != container.end();
++it)
{
if (it->getClass().isSoulGem(*it))
{
float thisGemCapacity = it->get<ESM::Miscellaneous>()->mBase->mData.mValue * fSoulgemMult;
if (thisGemCapacity >= creatureSoulValue && thisGemCapacity < gemCapacity
&& it->getCellRef().getSoul().empty())
{
gem = it;
gemCapacity = thisGemCapacity;
}
}
}
if (gem == container.end())
continue;
// Set the soul on just one of the gems, not the whole stack
gem->getContainerStore()->unstack(*gem);
gem->getCellRef().setSoul(creature.getCellRef().getRefId());
// Restack the gem with other gems with the same soul
gem->getContainerStore()->restack(*gem);
if (caster == MWMechanics::getPlayer())
MWBase::Environment::get().getWindowManager()->messageBox("#{sSoultrapSuccess}");
const ESM::Static* const fx
= world->getStore().get<ESM::Static>().search(ESM::RefId::stringRefId("VFX_Soul_Trap"));
if (fx != nullptr)
world->spawnEffect(VFS::Path::toNormalized(Misc::ResourceHelpers::correctMeshPath(fx->mModel)), "",
creature.getRefData().getPosition().asVec3());
MWBase::Environment::get().getSoundManager()->playSound3D(
creature.getRefData().getPosition().asVec3(), ESM::RefId::stringRefId("conjuration hit"), 1.f, 1.f);
return; // remove to get vanilla behaviour
}
}
}
void removeTemporaryEffects(const MWWorld::Ptr& ptr)
{
ptr.getClass().getCreatureStats(ptr).getActiveSpells().unloadActor(ptr);
}
}
namespace MWMechanics
{
static constexpr int GREETING_SHOULD_START = 4; // how many updates should pass before NPC can greet player
static constexpr int GREETING_SHOULD_END = 20; // how many updates should pass before NPC stops turning to player
static constexpr int GREETING_COOLDOWN = 40; // how many updates should pass before NPC can continue movement
static constexpr float DECELERATE_DISTANCE = 512.f;
namespace
{
std::string_view attackTypeName(AttackType attackType)
{
switch (attackType)
{
case AttackType::NoAttack:
case AttackType::Any:
return {};
case AttackType::Chop:
return "chop";
case AttackType::Slash:
return "slash";
case AttackType::Thrust:
return "thrust";
}
throw std::logic_error("Invalid attack type value: " + std::to_string(static_cast<int>(attackType)));
}
float getTimeToDestination(const AiPackage& package, const osg::Vec3f& position, float speed, float duration,
const osg::Vec3f& halfExtents)
{
const auto distanceToNextPathPoint
= (package.getNextPathPoint(package.getDestination()) - position).length();
return (distanceToNextPathPoint - package.getNextPathPointTolerance(speed, duration, halfExtents)) / speed;
}
void updateHeadTracking(const MWWorld::Ptr& actor, const MWWorld::Ptr& targetActor,
MWWorld::Ptr& headTrackTarget, float& sqrHeadTrackDistance, bool inCombatOrPursue)
{
const auto& actorRefData = actor.getRefData();
if (!actorRefData.getBaseNode())
return;
if (targetActor.getClass().getCreatureStats(targetActor).isDead())
return;
if (isTargetMagicallyHidden(targetActor))
return;
static const float fMaxHeadTrackDistance = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fMaxHeadTrackDistance")
->mValue.getFloat();
static const float fInteriorHeadTrackMult = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fInteriorHeadTrackMult")
->mValue.getFloat();
float maxDistance = fMaxHeadTrackDistance;
auto currentCell = actor.getCell()->getCell();
if (!currentCell->isExterior() && !(currentCell->isQuasiExterior()))
maxDistance *= fInteriorHeadTrackMult;
const osg::Vec3f actor1Pos(actorRefData.getPosition().asVec3());
const osg::Vec3f actor2Pos(targetActor.getRefData().getPosition().asVec3());
const float sqrDist = (actor1Pos - actor2Pos).length2();
if (sqrDist > std::min(maxDistance * maxDistance, sqrHeadTrackDistance) && !inCombatOrPursue)
return;
// stop tracking when target is behind the actor
osg::Vec3f actorDirection = actorRefData.getBaseNode()->getAttitude() * osg::Vec3f(0, 1, 0);
osg::Vec3f targetDirection(actor2Pos - actor1Pos);
actorDirection.z() = 0;
targetDirection.z() = 0;
if ((actorDirection * targetDirection > 0 || inCombatOrPursue)
// check LOS and awareness last as it's the most expensive function
&& MWBase::Environment::get().getWorld()->getLOS(actor, targetActor)
&& MWBase::Environment::get().getMechanicsManager()->awarenessCheck(targetActor, actor))
{
sqrHeadTrackDistance = sqrDist;
headTrackTarget = targetActor;
}
}
void updateHeadTracking(
const MWWorld::Ptr& ptr, const std::list<Actor>& actors, bool isPlayer, CharacterController& ctrl)
{
float sqrHeadTrackDistance = std::numeric_limits<float>::max();
MWWorld::Ptr headTrackTarget;
const MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
const bool firstPersonPlayer = isPlayer && MWBase::Environment::get().getWorld()->isFirstPerson();
// 1. Unconsious actor can not track target
// 2. Actors in combat and pursue mode do not bother to headtrack anyone except their target
// 3. Player character does not use headtracking in the 1st-person view
if (!stats.getKnockedDown() && !firstPersonPlayer)
{
bool inCombatOrPursue = stats.getAiSequence().isInCombat() || stats.getAiSequence().isInPursuit();
if (inCombatOrPursue)
{
auto activePackageTarget = stats.getAiSequence().getActivePackage().getTarget();
if (!activePackageTarget.isEmpty())
{
// Track the specified target of package.
updateHeadTracking(
ptr, activePackageTarget, headTrackTarget, sqrHeadTrackDistance, inCombatOrPursue);
}
}
else
{
// Find something nearby.
for (const Actor& otherActor : actors)
{
if (otherActor.getPtr() == ptr)
continue;
updateHeadTracking(
ptr, otherActor.getPtr(), headTrackTarget, sqrHeadTrackDistance, inCombatOrPursue);
}
}
}
ctrl.setHeadTrackTarget(headTrackTarget);
}
void updateLuaControls(const MWWorld::Ptr& ptr, bool isPlayer, MWBase::LuaManager::ActorControls& controls)
{
Movement& mov = ptr.getClass().getMovementSettings(ptr);
CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
const float speedFactor = isPlayer ? 1.f : mov.mSpeedFactor;
const osg::Vec2f movement = osg::Vec2f(mov.mPosition[0], mov.mPosition[1]) * speedFactor;
const float rotationX = mov.mRotation[0];
const float rotationZ = mov.mRotation[2];
const bool jump = mov.mPosition[2] == 1;
const bool runFlag = stats.getMovementFlag(MWMechanics::CreatureStats::Flag_Run);
const bool sneakFlag = stats.getMovementFlag(MWMechanics::CreatureStats::Flag_Sneak);
const bool attackingOrSpell = stats.getAttackingOrSpell();
if (controls.mChanged)
{
mov.mPosition[0] = controls.mSideMovement;
mov.mPosition[1] = controls.mMovement;
if (controls.mJump)
mov.mPosition[2] = 1;
mov.mRotation[0] = controls.mPitchChange;
mov.mRotation[1] = 0;
mov.mRotation[2] = controls.mYawChange;
mov.mSpeedFactor = osg::Vec2(controls.mMovement, controls.mSideMovement).length();
stats.setMovementFlag(MWMechanics::CreatureStats::Flag_Run, controls.mRun);
stats.setMovementFlag(MWMechanics::CreatureStats::Flag_Sneak, controls.mSneak);
AttackType attackType = static_cast<AttackType>(controls.mUse);
stats.setAttackingOrSpell(attackType != AttackType::NoAttack);
stats.setAttackType(attackTypeName(attackType));
controls.mChanged = false;
}
// For the player we don't need to copy these values to Lua because mwinput doesn't change them.
// All handling of these player controls was moved from C++ to a built-in Lua script.
if (!isPlayer)
{
controls.mSideMovement = movement.x();
controls.mMovement = movement.y();
controls.mJump = jump;
controls.mRun = runFlag;
controls.mSneak = sneakFlag;
controls.mUse = attackingOrSpell ? controls.mUse | 1 : controls.mUse & ~1;
}
// For the player these controls are still handled by mwinput, so we need to update the values.
controls.mPitchChange = rotationX;
controls.mYawChange = rotationZ;
}
}
void Actors::updateActor(const MWWorld::Ptr& ptr, float duration) const
{
// magic effects
adjustMagicEffects(ptr, duration);
// fatigue restoration
calculateRestoration(ptr, duration);
}
void Actors::playIdleDialogue(const MWWorld::Ptr& actor) const
{
if (!actor.getClass().isActor() || actor == getPlayer()
|| MWBase::Environment::get().getSoundManager()->sayActive(actor))
return;
const CreatureStats& stats = actor.getClass().getCreatureStats(actor);
if (stats.getAiSetting(AiSetting::Hello).getModified() == 0)
return;
const MWMechanics::AiSequence& seq = stats.getAiSequence();
if (seq.isInCombat() || seq.hasPackage(AiPackageTypeId::Follow) || seq.hasPackage(AiPackageTypeId::Escort))
return;
const osg::Vec3f playerPos(getPlayer().getRefData().getPosition().asVec3());
const osg::Vec3f actorPos(actor.getRefData().getPosition().asVec3());
MWBase::World* const world = MWBase::Environment::get().getWorld();
if (world->isSwimming(actor) || (playerPos - actorPos).length2() >= 3000 * 3000)
return;
// Our implementation is not FPS-dependent unlike Morrowind's so it needs to be recalibrated.
// We chose to use the chance MW would have when run at 60 FPS with the default value of the GMST.
const float delta = MWBase::Environment::get().getFrameDuration() * 6.f;
static const float fVoiceIdleOdds
= world->getStore().get<ESM::GameSetting>().find("fVoiceIdleOdds")->mValue.getFloat();
if (Misc::Rng::rollProbability(world->getPrng()) * 10000.f < fVoiceIdleOdds * delta
&& world->getLOS(getPlayer(), actor))
MWBase::Environment::get().getDialogueManager()->say(actor, ESM::RefId::stringRefId("idle"));
}
void Actors::updateMovementSpeed(const MWWorld::Ptr& actor) const
{
if (Settings::game().mSmoothMovement)
return;
const auto& actorClass = actor.getClass();
const CreatureStats& stats = actorClass.getCreatureStats(actor);
const MWMechanics::AiSequence& seq = stats.getAiSequence();
if (!seq.isEmpty() && seq.getActivePackage().useVariableSpeed())
{
const osg::Vec3f targetPos = seq.getActivePackage().getDestination();
const osg::Vec3f actorPos = actor.getRefData().getPosition().asVec3();
const float distance = (targetPos - actorPos).length();
if (distance < DECELERATE_DISTANCE)
{
const float speedCoef = std::max(0.7f, 0.2f + 0.8f * distance / DECELERATE_DISTANCE);
auto& movement = actorClass.getMovementSettings(actor);
movement.mPosition[0] *= speedCoef;
movement.mPosition[1] *= speedCoef;
}
}
}
void Actors::updateGreetingState(const MWWorld::Ptr& actor, Actor& actorState, bool turnOnly)
{
const auto& actorClass = actor.getClass();
if (!actorClass.isActor() || actor == getPlayer())
return;
const CreatureStats& actorStats = actorClass.getCreatureStats(actor);
const MWMechanics::AiSequence& seq = actorStats.getAiSequence();
const auto packageId = seq.getTypeId();
if (seq.isInCombat() || MWBase::Environment::get().getWorld()->isSwimming(actor)
|| (packageId != AiPackageTypeId::Wander && packageId != AiPackageTypeId::Travel
&& packageId != AiPackageTypeId::None))
{
actorState.setTurningToPlayer(false);
actorState.setGreetingTimer(0);
actorState.setGreetingState(Greet_None);
return;
}
const MWWorld::Ptr player = getPlayer();
const osg::Vec3f playerPos(player.getRefData().getPosition().asVec3());
const osg::Vec3f actorPos(actor.getRefData().getPosition().asVec3());
const osg::Vec3f dir = playerPos - actorPos;
if (actorState.isTurningToPlayer())
{
// Reduce the turning animation glitch by using a *HUGE* value of
// epsilon... TODO: a proper fix might be in either the physics or the
// animation subsystem
if (zTurn(actor, actorState.getAngleToPlayer(), osg::DegreesToRadians(5.f)))
{
actorState.setTurningToPlayer(false);
// An original engine launches an endless idle2 when an actor greets player.
playAnimationGroup(actor, "idle2", 0, std::numeric_limits<int>::max(), false);
}
}
if (turnOnly)
return;
// Play a random voice greeting if the player gets too close
static const int iGreetDistanceMultiplier = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("iGreetDistanceMultiplier")
->mValue.getInteger();
const float helloDistance
= static_cast<float>(actorStats.getAiSetting(AiSetting::Hello).getModified() * iGreetDistanceMultiplier);
const auto& playerStats = player.getClass().getCreatureStats(player);
int greetingTimer = actorState.getGreetingTimer();
GreetingState greetingState = actorState.getGreetingState();
if (greetingState == Greet_None)
{
if ((playerPos - actorPos).length2() <= helloDistance * helloDistance && !playerStats.isDead()
&& !actorStats.isParalyzed() && !isTargetMagicallyHidden(player)
&& MWBase::Environment::get().getWorld()->getLOS(player, actor)
&& MWBase::Environment::get().getMechanicsManager()->awarenessCheck(player, actor))
greetingTimer++;
if (greetingTimer >= GREETING_SHOULD_START)
{
greetingState = Greet_InProgress;
if (!MWBase::Environment::get().getDialogueManager()->say(actor, ESM::RefId::stringRefId("hello")))
greetingState = Greet_Done;
greetingTimer = 0;
}
}
if (greetingState == Greet_InProgress)
{
greetingTimer++;
if (!actorStats.getMovementFlag(CreatureStats::Flag_ForceJump)
&& !actorStats.getMovementFlag(CreatureStats::Flag_ForceSneak)
&& (greetingTimer <= GREETING_SHOULD_END
|| MWBase::Environment::get().getSoundManager()->sayActive(actor)))
turnActorToFacePlayer(actor, actorState, dir);
if (greetingTimer >= GREETING_COOLDOWN)
{
greetingState = Greet_Done;
greetingTimer = 0;
}
}
if (greetingState == Greet_Done)
{
float resetDist = 2 * helloDistance;
if ((playerPos - actorPos).length2() >= resetDist * resetDist)
greetingState = Greet_None;
}
actorState.setGreetingTimer(greetingTimer);
actorState.setGreetingState(greetingState);
}
void Actors::turnActorToFacePlayer(const MWWorld::Ptr& actor, Actor& actorState, const osg::Vec3f& dir) const
{
auto& movementSettings = actor.getClass().getMovementSettings(actor);
movementSettings.mPosition[1] = 0;
movementSettings.mPosition[0] = 0;
if (!actorState.isTurningToPlayer())
{
float from = dir.x();
float to = dir.y();
float angle = std::atan2(from, to);
actorState.setAngleToPlayer(angle);
float deltaAngle = Misc::normalizeAngle(angle - actor.getRefData().getPosition().rot[2]);
if (!Settings::game().mSmoothMovement || std::abs(deltaAngle) > osg::DegreesToRadians(60.f))
actorState.setTurningToPlayer(true);
}
}
void Actors::stopCombat(const MWWorld::Ptr& ptr) const
{
auto& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
std::vector<MWWorld::Ptr> targets;
if (ai.getCombatTargets(targets))
{
std::set<MWWorld::Ptr> allySet;
getActorsSidingWith(ptr, allySet);
std::vector<MWWorld::Ptr> allies(allySet.begin(), allySet.end());
for (const auto& ally : allies)
ally.getClass().getCreatureStats(ally).getAiSequence().stopCombat(targets);
for (const auto& target : targets)
target.getClass().getCreatureStats(target).getAiSequence().stopCombat(allies);
}
}
void Actors::engageCombat(
const MWWorld::Ptr& actor1, const MWWorld::Ptr& actor2, SidingCache& cachedAllies, bool againstPlayer) const
{
// No combat for totally static creatures
if (!actor1.getClass().isMobile(actor1))
return;
CreatureStats& creatureStats1 = actor1.getClass().getCreatureStats(actor1);
if (creatureStats1.isDead() || creatureStats1.getAiSequence().isInCombat(actor2))
return;
const CreatureStats& creatureStats2 = actor2.getClass().getCreatureStats(actor2);
if (creatureStats2.isDead())
return;
const osg::Vec3f actor1Pos(actor1.getRefData().getPosition().asVec3());
const osg::Vec3f actor2Pos(actor2.getRefData().getPosition().asVec3());
const float sqrDist = (actor1Pos - actor2Pos).length2();
const int actorsProcessingRange = Settings::game().mActorsProcessingRange;
if (sqrDist > actorsProcessingRange * actorsProcessingRange)
return;
// If this is set to true, actor1 will start combat with actor2 if the awareness check at the end of the method
// returns true
bool aggressive = false;
// Get actors allied with actor1. Includes those following or escorting actor1, actors following or escorting
// those actors, (recursive) and any actor currently being followed or escorted by actor1
const std::set<MWWorld::Ptr>& allies1 = cachedAllies.getActorsSidingWith(actor1);
const auto mechanicsManager = MWBase::Environment::get().getMechanicsManager();
// If an ally of actor1 has been attacked by actor2 or has attacked actor2, start combat between actor1 and
// actor2
for (const MWWorld::Ptr& ally : allies1)
{
if (creatureStats1.getAiSequence().isInCombat(ally))
continue;
if (creatureStats2.matchesActorId(ally.getClass().getCreatureStats(ally).getHitAttemptActorId()))
{
mechanicsManager->startCombat(actor1, actor2, &cachedAllies.getActorsSidingWith(actor2));
// Also set the same hit attempt actor. Otherwise, if fighting the player, they may stop combat
// if the player gets out of reach, while the ally would continue combat with the player
creatureStats1.setHitAttemptActorId(ally.getClass().getCreatureStats(ally).getHitAttemptActorId());
return;
}
// If there's been no attack attempt yet but an ally of actor1 is in combat with actor2, become aggressive
// to actor2
if (ally.getClass().getCreatureStats(ally).getAiSequence().isInCombat(actor2))
aggressive = true;
}
MWWorld::Ptr player = MWMechanics::getPlayer();
const std::set<MWWorld::Ptr>& playerAllies = cachedAllies.getActorsSidingWith(player);
bool isPlayerFollowerOrEscorter = playerAllies.find(actor1) != playerAllies.end();
// If actor2 and at least one actor2 are in combat with actor1, actor1 and its allies start combat with them
// Doesn't apply for player followers/escorters
if (!aggressive && !isPlayerFollowerOrEscorter)
{
// Check that actor2 is in combat with actor1
if (creatureStats2.getAiSequence().isInCombat(actor1))
{
const std::set<MWWorld::Ptr>& allies2 = cachedAllies.getActorsSidingWith(actor2);
// Check that an ally of actor2 is also in combat with actor1
for (const MWWorld::Ptr& ally2 : allies2)
{
if (ally2 != actor2 && ally2.getClass().getCreatureStats(ally2).getAiSequence().isInCombat(actor1))
{
mechanicsManager->startCombat(actor1, actor2, &allies2);
// Also have actor1's allies start combat
for (const MWWorld::Ptr& ally1 : allies1)
if (ally1 != player)
mechanicsManager->startCombat(ally1, actor2, &allies2);
return;
}
}
}
}
if (creatureStats2.getMagicEffects().getOrDefault(ESM::MagicEffect::Invisibility).getMagnitude() > 0)
return;
// Stop here if target is unreachable
if (!canFight(actor1, actor2))
return;
// If set in the settings file, player followers and escorters will become aggressive toward enemies in combat
// with them or the player
if (!aggressive && isPlayerFollowerOrEscorter && Settings::game().mFollowersAttackOnSight)
{
if (creatureStats2.getAiSequence().isInCombat(actor1))
aggressive = true;
else
{
for (const MWWorld::Ptr& ally : allies1)
{
if (ally != actor1 && creatureStats2.getAiSequence().isInCombat(ally))
{
aggressive = true;
break;
}
}
}
}
// Do aggression check if actor2 is the player or a player follower or escorter
if (!aggressive)
{
if (againstPlayer || playerAllies.find(actor2) != playerAllies.end())
{
// Player followers and escorters with high fight should not initiate combat with the player or with
// other player followers or escorters
if (!isPlayerFollowerOrEscorter)
aggressive = mechanicsManager->isAggressive(actor1, actor2);
}
}
// Make guards go aggressive with creatures and werewolves that are in combat
const auto world = MWBase::Environment::get().getWorld();
if (!aggressive && actor1.getClass().isClass(actor1, "Guard") && creatureStats2.getAiSequence().isInCombat())
{
// Check if the creature is too far
static const float fAlarmRadius
= world->getStore().get<ESM::GameSetting>().find("fAlarmRadius")->mValue.getFloat();
if (sqrDist > fAlarmRadius * fAlarmRadius)
return;
bool targetIsCreature = !actor2.getClass().isNpc();
if (targetIsCreature || actor2.getClass().getNpcStats(actor2).isWerewolf())
{
bool followerOrEscorter = false;
// ...unless the creature has allies
if (targetIsCreature)
{
for (const auto& package : creatureStats2.getAiSequence())
{
// The follow package must be first or have nothing but combat before it
if (package->sideWithTarget())
{
followerOrEscorter = true;
break;
}
else if (package->getTypeId() != MWMechanics::AiPackageTypeId::Combat)
break;
}
}
// Morrowind also checks "known werewolf" flag, but the player is never in combat
// so this code is unreachable for the player
if (!followerOrEscorter)
aggressive = true;
}
}
// If any of the above conditions turned actor1 aggressive towards actor2, do an awareness check. If it passes,
// start combat with actor2.
if (aggressive)
{
bool LOS = world->getLOS(actor1, actor2) && mechanicsManager->awarenessCheck(actor2, actor1);
if (LOS)
mechanicsManager->startCombat(actor1, actor2, &cachedAllies.getActorsSidingWith(actor2));
}
}
void Actors::adjustMagicEffects(const MWWorld::Ptr& creature, float duration) const
{
CreatureStats& creatureStats = creature.getClass().getCreatureStats(creature);
const bool wasDead = creatureStats.isDead();
creatureStats.getActiveSpells().update(creature, duration);
if (!wasDead && creatureStats.isDead())
{
// The actor was killed by a magic effect. Figure out if the player was responsible for it.
const ActiveSpells& spells = creatureStats.getActiveSpells();
const MWWorld::Ptr player = getPlayer();
std::set<MWWorld::Ptr> playerFollowers;
getActorsSidingWith(player, playerFollowers);
for (const ActiveSpells::ActiveSpellParams& spell : spells)
{
bool actorKilled = false;
MWWorld::Ptr caster
= MWBase::Environment::get().getWorld()->searchPtrViaActorId(spell.getCasterActorId());
if (caster.isEmpty())
continue;
for (const auto& effect : spell.getEffects())
{
static const std::array<int, 7> damageEffects{
ESM::MagicEffect::FireDamage,
ESM::MagicEffect::ShockDamage,
ESM::MagicEffect::FrostDamage,
ESM::MagicEffect::Poison,
ESM::MagicEffect::SunDamage,
ESM::MagicEffect::DamageHealth,
ESM::MagicEffect::AbsorbHealth,
};
const bool isDamageEffect = std::find(damageEffects.begin(), damageEffects.end(), effect.mEffectId)
!= damageEffects.end();
if (isDamageEffect)
{
if (caster.getClass().isNpc() && caster.getClass().getNpcStats(caster).isWerewolf())
caster.getClass().getNpcStats(caster).addWerewolfKill();
if (caster == player || playerFollowers.find(caster) != playerFollowers.end())
{
MWBase::Environment::get().getMechanicsManager()->actorKilled(creature, player);
actorKilled = true;
break;
}
}
}
if (actorKilled)
break;
}
}
// updateSummons assumes the actor belongs to a cell.
// This assumption isn't always valid for the player character.
if (!creature.isInCell())
return;
if (!creatureStats.getSummonedCreatureMap().empty() || !creatureStats.getSummonedCreatureGraveyard().empty())
updateSummons(creature, mTimerDisposeSummonsCorpses == 0.f);
}
void Actors::restoreDynamicStats(const MWWorld::Ptr& ptr, double hours, bool sleep) const
{
MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
if (stats.isDead())
return;
const MWWorld::Store<ESM::GameSetting>& settings
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
if (sleep)
{
const auto [health, magicka] = getRestorationPerHourOfSleep(ptr);
DynamicStat<float> stat = stats.getHealth();
stat.setCurrent(stat.getCurrent() + health * hours);
stats.setHealth(stat);
double restoreHours = hours;
const bool stunted
= stats.getMagicEffects().getOrDefault(ESM::MagicEffect::StuntedMagicka).getMagnitude() > 0;
if (stunted)
{
// Stunted Magicka effect should be taken into account.
float remainingTime = getStuntedMagickaDuration(ptr);
// Take a maximum remaining duration of Stunted Magicka effects (-1 is a constant one) in game hours.
if (remainingTime > 0)
{
double timeScale = MWBase::Environment::get().getWorld()->getTimeManager()->getGameTimeScale();
if (timeScale == 0.0)
timeScale = 1;
restoreHours = std::max(0.0, hours - remainingTime * timeScale / 3600.f);
}
else if (remainingTime == -1)
restoreHours = 0;
}
if (restoreHours > 0)
{
stat = stats.getMagicka();
stat.setCurrent(stat.getCurrent() + magicka * restoreHours);
stats.setMagicka(stat);
}
}
// Current fatigue can be above base value due to a fortify effect.
// In that case stop here and don't try to restore.
DynamicStat<float> fatigue = stats.getFatigue();
if (fatigue.getCurrent() >= fatigue.getBase())
return;
// Restore fatigue
static const float fFatigueReturnBase = settings.find("fFatigueReturnBase")->mValue.getFloat();
static const float fFatigueReturnMult = settings.find("fFatigueReturnMult")->mValue.getFloat();
static const float fEndFatigueMult = settings.find("fEndFatigueMult")->mValue.getFloat();
const float endurance = stats.getAttribute(ESM::Attribute::Endurance).getModified();
float normalizedEncumbrance = ptr.getClass().getNormalizedEncumbrance(ptr);
if (normalizedEncumbrance > 1)
normalizedEncumbrance = 1;
const float x
= (fFatigueReturnBase + fFatigueReturnMult * (1 - normalizedEncumbrance)) * (fEndFatigueMult * endurance);
fatigue.setCurrent(fatigue.getCurrent() + 3600 * x * hours);
stats.setFatigue(fatigue);
}
void Actors::calculateRestoration(const MWWorld::Ptr& ptr, float duration) const
{
if (ptr.getClass().getCreatureStats(ptr).isDead())
return;
MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
// Current fatigue can be above base value due to a fortify effect.
// In that case stop here and don't try to restore.
DynamicStat<float> fatigue = stats.getFatigue();
if (fatigue.getCurrent() >= fatigue.getBase())
return;
// Restore fatigue
const float endurance = stats.getAttribute(ESM::Attribute::Endurance).getModified();
const MWWorld::Store<ESM::GameSetting>& settings
= MWBase::Environment::get().getESMStore()->get<ESM::GameSetting>();
static const float fFatigueReturnBase = settings.find("fFatigueReturnBase")->mValue.getFloat();
static const float fFatigueReturnMult = settings.find("fFatigueReturnMult")->mValue.getFloat();
const float x = fFatigueReturnBase + fFatigueReturnMult * endurance;
fatigue.setCurrent(fatigue.getCurrent() + duration * x);
stats.setFatigue(fatigue);
}
bool Actors::isAttackPreparing(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return false;
return it->second->getCharacterController().isAttackPreparing();
}
bool Actors::isRunning(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return false;
return it->second->getCharacterController().isRunning();
}
bool Actors::isSneaking(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return false;
return it->second->getCharacterController().isSneaking();
}
static void updateDrowning(const MWWorld::Ptr& ptr, float duration, bool isKnockedOut, bool isPlayer)
{
const auto& actorClass = ptr.getClass();
NpcStats& stats = actorClass.getNpcStats(ptr);
// When npc stats are just initialized, mTimeToStartDrowning == -1 and we should get value from GMST
static const float fHoldBreathTime = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fHoldBreathTime")
->mValue.getFloat();
if (stats.getTimeToStartDrowning() == -1.f)
stats.setTimeToStartDrowning(fHoldBreathTime);
if (!isPlayer && stats.getTimeToStartDrowning() < fHoldBreathTime / 2)
{
AiSequence& seq = actorClass.getCreatureStats(ptr).getAiSequence();
if (seq.getTypeId() != AiPackageTypeId::Breathe) // Only add it once
seq.stack(AiBreathe(), ptr);
}
const MWBase::World* const world = MWBase::Environment::get().getWorld();
const bool knockedOutUnderwater
= (isKnockedOut && world->isUnderwater(ptr.getCell(), osg::Vec3f(ptr.getRefData().getPosition().asVec3())));
if ((world->isSubmerged(ptr) || knockedOutUnderwater)
&& stats.getMagicEffects().getOrDefault(ESM::MagicEffect::WaterBreathing).getMagnitude() == 0)
{
float timeLeft = 0.0f;
if (knockedOutUnderwater)
stats.setTimeToStartDrowning(0);
else
{
timeLeft = stats.getTimeToStartDrowning() - duration;
if (timeLeft < 0.0f)
timeLeft = 0.0f;
stats.setTimeToStartDrowning(timeLeft);
}
const bool godmode = isPlayer && world->getGodModeState();
if (timeLeft == 0.0f && !godmode)
{
// If drowning, apply 3 points of damage per second
static const float fSuffocationDamage
= world->getStore().get<ESM::GameSetting>().find("fSuffocationDamage")->mValue.getFloat();
DynamicStat<float> health = stats.getHealth();
health.setCurrent(health.getCurrent() - fSuffocationDamage * duration);
stats.setHealth(health);
// Play a drowning sound
MWBase::SoundManager* sndmgr = MWBase::Environment::get().getSoundManager();
auto soundDrown = ESM::RefId::stringRefId("drown");
if (!sndmgr->getSoundPlaying(ptr, soundDrown))
sndmgr->playSound3D(ptr, soundDrown, 1.0f, 1.0f);
if (isPlayer)
MWBase::Environment::get().getWindowManager()->activateHitOverlay(false);
}
}
else
stats.setTimeToStartDrowning(fHoldBreathTime);
}
static void updateEquippedLight(const MWWorld::Ptr& ptr, float duration, bool mayEquip)
{
const bool isPlayer = (ptr == getPlayer());
const auto& actorClass = ptr.getClass();
auto& inventoryStore = actorClass.getInventoryStore(ptr);
auto heldIter = inventoryStore.getSlot(MWWorld::InventoryStore::Slot_CarriedLeft);
/**
* Automatically equip NPCs torches at night and unequip them at day
*/
if (!isPlayer)
{
auto torchIter = std::find_if(std::begin(inventoryStore), std::end(inventoryStore), [&](auto entry) {
return entry.getType() == ESM::Light::sRecordId && entry.getClass().canBeEquipped(entry, ptr).first;
});
if (mayEquip)
{
if (torchIter != inventoryStore.end())
{
if (!actorClass.getCreatureStats(ptr).getAiSequence().isInCombat())
{
// For non-hostile NPCs, unequip whatever is in the left slot in favor of a light.
if (heldIter != inventoryStore.end() && heldIter->getType() != ESM::Light::sRecordId)
inventoryStore.unequipItem(*heldIter);
}
else if (heldIter == inventoryStore.end() || heldIter->getType() == ESM::Light::sRecordId)
{
// For hostile NPCs, see if they have anything better to equip first
auto shield = inventoryStore.getPreferredShield();
if (shield != inventoryStore.end())
inventoryStore.equip(MWWorld::InventoryStore::Slot_CarriedLeft, shield);
}
heldIter = inventoryStore.getSlot(MWWorld::InventoryStore::Slot_CarriedLeft);
// If we have a torch and can equip it, then equip it now.
if (heldIter == inventoryStore.end())
{
inventoryStore.equip(MWWorld::InventoryStore::Slot_CarriedLeft, torchIter);
}
}
}
else
{
if (heldIter != inventoryStore.end() && heldIter->getType() == ESM::Light::sRecordId)
{
// At day, unequip lights and auto equip shields or other suitable items
// (Note: autoEquip will ignore lights)
inventoryStore.autoEquip();
}
}
}
heldIter = inventoryStore.getSlot(MWWorld::InventoryStore::Slot_CarriedLeft);
// If holding a light...
const auto world = MWBase::Environment::get().getWorld();
MWRender::Animation* anim = world->getAnimation(ptr);
if (heldIter.getType() == MWWorld::ContainerStore::Type_Light && anim && anim->getCarriedLeftShown())
{
// Use time from the player's light
if (isPlayer)
{
float timeRemaining = heldIter->getClass().getRemainingUsageTime(*heldIter);
// -1 is infinite light source. Other negative values are treated as 0.
if (timeRemaining != -1.0f)
{
timeRemaining -= duration;
if (timeRemaining <= 0.f)
{
inventoryStore.remove(*heldIter, 1); // remove it
return;
}
heldIter->getClass().setRemainingUsageTime(*heldIter, timeRemaining);
}
}
// Both NPC and player lights extinguish in water.
if (world->isSwimming(ptr))
{
inventoryStore.remove(*heldIter, 1); // remove it
// ...But, only the player makes a sound.
if (isPlayer)
MWBase::Environment::get().getSoundManager()->playSound(
ESM::RefId::stringRefId("torch out"), 1.0, 1.0, MWSound::Type::Sfx, MWSound::PlayMode::NoEnv);
}
}
}
void Actors::updateCrimePursuit(const MWWorld::Ptr& ptr, float duration, SidingCache& cachedAllies) const
{
const MWWorld::Ptr player = getPlayer();
if (ptr == player)
return;
const auto& actorClass = ptr.getClass();
if (!actorClass.isNpc())
return;
// get stats of witness
CreatureStats& creatureStats = ptr.getClass().getCreatureStats(ptr);
NpcStats& npcStats = ptr.getClass().getNpcStats(ptr);
const auto& playerClass = player.getClass();
const auto& playerStats = playerClass.getNpcStats(player);
if (playerStats.isWerewolf())
return;
const auto mechanicsManager = MWBase::Environment::get().getMechanicsManager();
const auto world = MWBase::Environment::get().getWorld();
if (actorClass.isClass(ptr, "Guard") && !creatureStats.getAiSequence().isInPursuit()
&& !creatureStats.getAiSequence().isInCombat()
&& creatureStats.getMagicEffects().getOrDefault(ESM::MagicEffect::CalmHumanoid).getMagnitude() == 0)
{
const MWWorld::ESMStore& esmStore = world->getStore();
static const int cutoff = esmStore.get<ESM::GameSetting>().find("iCrimeThreshold")->mValue.getInteger();
// Force dialogue on sight if bounty is greater than the cutoff
// In vanilla morrowind, the greeting dialogue is scripted to either arrest the player (< 5000 bounty) or
// attack (>= 5000 bounty)
if (playerStats.getBounty() >= cutoff
// TODO: do not run these two every frame. keep an Aware state for each actor and update it every 0.2 s
// or so?
&& world->getLOS(ptr, player) && mechanicsManager->awarenessCheck(player, ptr))
{
static const int iCrimeThresholdMultiplier
= esmStore.get<ESM::GameSetting>().find("iCrimeThresholdMultiplier")->mValue.getInteger();
if (playerStats.getBounty() >= cutoff * iCrimeThresholdMultiplier)
{
mechanicsManager->startCombat(ptr, player, &cachedAllies.getActorsSidingWith(player));
creatureStats.setHitAttemptActorId(
playerClass.getCreatureStats(player)
.getActorId()); // Stops the guard from quitting combat if player is unreachable
}
else
creatureStats.getAiSequence().stack(AiPursue(player), ptr);
creatureStats.setAlarmed(true);
npcStats.setCrimeId(world->getPlayer().getNewCrimeId());
}
}
// if I was a witness to a crime
if (npcStats.getCrimeId() != -1)
{
// if you've paid for your crimes and I haven't noticed
if (npcStats.getCrimeId() <= world->getPlayer().getCrimeId())
{
// Calm witness down
if (ptr.getClass().isClass(ptr, "Guard"))
creatureStats.getAiSequence().stopPursuit();
stopCombat(ptr);
// Reset factors to attack
creatureStats.setAttacked(false);
creatureStats.setAlarmed(false);
creatureStats.setAiSetting(AiSetting::Fight, ptr.getClass().getBaseFightRating(ptr));
// Restore original disposition
npcStats.setCrimeDispositionModifier(0);
// Update witness crime id
npcStats.setCrimeId(-1);
}
}
}
void Actors::addActor(const MWWorld::Ptr& ptr, bool updateImmediately)
{
removeActor(ptr, true);
MWRender::Animation* anim = MWBase::Environment::get().getWorld()->getAnimation(ptr);
if (!anim)
return;
const auto it = mActors.emplace(mActors.end(), ptr, anim);
mIndex.emplace(ptr.mRef, it);
if (updateImmediately)
it->getCharacterController().update(0);
// We should initially hide actors outside of processing range.
// Note: since we update player after other actors, distance will be incorrect during teleportation.
// Do not update visibility if player was teleported, so actors will be visible during teleportation frame.
if (MWBase::Environment::get().getWorld()->getPlayer().wasTeleported())
return;
updateVisibility(ptr, it->getCharacterController());
}
void Actors::updateVisibility(const MWWorld::Ptr& ptr, CharacterController& ctrl) const
{
MWWorld::Ptr player = MWMechanics::getPlayer();
if (ptr == player)
return;
const float dist
= (player.getRefData().getPosition().asVec3() - ptr.getRefData().getPosition().asVec3()).length();
const int actorsProcessingRange = Settings::game().mActorsProcessingRange;
if (dist > actorsProcessingRange)
{
ptr.getRefData().getBaseNode()->setNodeMask(0);
return;
}
else
ptr.getRefData().getBaseNode()->setNodeMask(MWRender::Mask_Actor);
// Fade away actors on large distance (>90% of actor's processing distance)
float visibilityRatio = 1.0;
const float fadeStartDistance = actorsProcessingRange * 0.9f;
const float fadeEndDistance = actorsProcessingRange;
const float fadeRatio = (dist - fadeStartDistance) / (fadeEndDistance - fadeStartDistance);
if (fadeRatio > 0)
visibilityRatio -= std::max(0.f, fadeRatio);
visibilityRatio = std::min(1.f, visibilityRatio);
ctrl.setVisibility(visibilityRatio);
}
void Actors::removeActor(const MWWorld::Ptr& ptr, bool keepActive)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
{
if (!keepActive)
removeTemporaryEffects(iter->second->getPtr());
mActors.erase(iter->second);
mIndex.erase(iter);
}
}
void Actors::castSpell(const MWWorld::Ptr& ptr, const ESM::RefId& spellId, bool scriptedSpell) const
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->getCharacterController().castSpell(spellId, scriptedSpell);
}
bool Actors::isActorDetected(const MWWorld::Ptr& actor, const MWWorld::Ptr& observer) const
{
if (!actor.getClass().isActor())
return false;
// If an observer is NPC, check if he detected an actor
if (!observer.isEmpty() && observer.getClass().isNpc())
{
return MWBase::Environment::get().getWorld()->getLOS(observer, actor)
&& MWBase::Environment::get().getMechanicsManager()->awarenessCheck(actor, observer);
}
// Otherwise check if any actor in AI processing range sees the target actor
std::vector<MWWorld::Ptr> neighbors;
osg::Vec3f position(actor.getRefData().getPosition().asVec3());
getObjectsInRange(position, Settings::game().mActorsProcessingRange, neighbors);
for (const MWWorld::Ptr& neighbor : neighbors)
{
if (neighbor == actor)
continue;
const bool result = MWBase::Environment::get().getWorld()->getLOS(neighbor, actor)
&& MWBase::Environment::get().getMechanicsManager()->awarenessCheck(actor, neighbor);
if (result)
return true;
}
return false;
}
void Actors::updateActor(const MWWorld::Ptr& old, const MWWorld::Ptr& ptr) const
{
const auto iter = mIndex.find(old.mRef);
if (iter != mIndex.end())
iter->second->updatePtr(ptr);
}
void Actors::dropActors(const MWWorld::CellStore* cellStore, const MWWorld::Ptr& ignore)
{
for (auto iter = mActors.begin(); iter != mActors.end();)
{
if ((iter->getPtr().isInCell() && iter->getPtr().getCell() == cellStore) && iter->getPtr() != ignore)
{
removeTemporaryEffects(iter->getPtr());
mIndex.erase(iter->getPtr().mRef);
iter = mActors.erase(iter);
}
else
++iter;
}
}
void Actors::predictAndAvoidCollisions(float duration) const
{
if (!MWBase::Environment::get().getMechanicsManager()->isAIActive())
return;
const float minGap = 10.f;
const float maxDistForPartialAvoiding = 200.f;
const float maxDistForStrictAvoiding = 100.f;
const float maxTimeToCheck = 2.0f;
const bool giveWayWhenIdle = Settings::game().mNPCsGiveWay;
const MWWorld::Ptr player = getPlayer();
const MWBase::World* const world = MWBase::Environment::get().getWorld();
for (const Actor& actor : mActors)
{
const MWWorld::Ptr& ptr = actor.getPtr();
if (ptr == player)
continue; // Don't interfere with player controls.
const float maxSpeed = ptr.getClass().getMaxSpeed(ptr);
if (maxSpeed == 0.0)
continue; // Can't move, so there is no sense to predict collisions.
Movement& movement = ptr.getClass().getMovementSettings(ptr);
const osg::Vec2f origMovement(movement.mPosition[0], movement.mPosition[1]);
const bool isMoving = origMovement.length2() > 0.01;
if (movement.mPosition[1] < 0)
continue; // Actors can not see others when move backward.
// Moving NPCs always should avoid collisions.
// Standing NPCs give way to moving ones if they are not in combat (or pursue) mode and either
// follow player or have a AIWander package with non-empty wander area.
bool shouldAvoidCollision = isMoving;
bool shouldGiveWay = false;
bool shouldTurnToApproachingActor = !isMoving;
MWWorld::Ptr currentTarget; // Combat or pursue target (NPCs should not avoid collision with their targets).
const auto& aiSequence = ptr.getClass().getCreatureStats(ptr).getAiSequence();
if (!aiSequence.isEmpty())
{
const auto& package = aiSequence.getActivePackage();
if (package.getTypeId() == AiPackageTypeId::Follow)
{
shouldAvoidCollision = true;
}
else if (package.getTypeId() == AiPackageTypeId::Wander && giveWayWhenIdle)
{
if (!static_cast<const AiWander&>(package).isStationary())
shouldGiveWay = true;
}
else if (package.getTypeId() == AiPackageTypeId::Combat
|| package.getTypeId() == AiPackageTypeId::Pursue)
{
currentTarget = package.getTarget();
shouldAvoidCollision = isMoving;
shouldTurnToApproachingActor = false;
}
}
if (!shouldAvoidCollision && !shouldGiveWay)
continue;
const osg::Vec2f baseSpeed = origMovement * maxSpeed;
const osg::Vec3f basePos = ptr.getRefData().getPosition().asVec3();
const float baseRotZ = ptr.getRefData().getPosition().rot[2];
const osg::Vec3f halfExtents = world->getHalfExtents(ptr);
const float maxDistToCheck = isMoving ? maxDistForPartialAvoiding : maxDistForStrictAvoiding;
float timeToCheck = maxTimeToCheck;
if (!shouldGiveWay && !aiSequence.isEmpty())
timeToCheck = std::min(
timeToCheck, getTimeToDestination(**aiSequence.begin(), basePos, maxSpeed, duration, halfExtents));
float timeToCollision = timeToCheck;
osg::Vec2f movementCorrection(0, 0);
float angleToApproachingActor = 0;
// Iterate through all other actors and predict collisions.
for (const Actor& otherActor : mActors)
{
const MWWorld::Ptr& otherPtr = otherActor.getPtr();
if (otherPtr == ptr || otherPtr == currentTarget)
continue;
const osg::Vec3f otherHalfExtents = world->getHalfExtents(otherPtr);
const osg::Vec3f deltaPos = otherPtr.getRefData().getPosition().asVec3() - basePos;
const osg::Vec2f relPos = Misc::rotateVec2f(osg::Vec2f(deltaPos.x(), deltaPos.y()), baseRotZ);
const float dist = deltaPos.length();
// Ignore actors which are not close enough or come from behind.
if (dist > maxDistToCheck || relPos.y() < 0)
continue;
// Don't check for a collision if vertical distance is greater then the actor's height.
if (deltaPos.z() > halfExtents.z() * 2 || deltaPos.z() < -otherHalfExtents.z() * 2)
continue;
const osg::Vec3f speed = otherPtr.getClass().getMovementSettings(otherPtr).asVec3()
* otherPtr.getClass().getMaxSpeed(otherPtr);
const float rotZ = otherPtr.getRefData().getPosition().rot[2];
const osg::Vec2f relSpeed
= Misc::rotateVec2f(osg::Vec2f(speed.x(), speed.y()), baseRotZ - rotZ) - baseSpeed;
float collisionDist = minGap + halfExtents.x() + otherHalfExtents.x();
collisionDist = std::min(collisionDist, relPos.length());
// Find the earliest `t` when |relPos + relSpeed * t| == collisionDist.
const float vr = relPos.x() * relSpeed.x() + relPos.y() * relSpeed.y();
const float v2 = relSpeed.length2();
const float Dh = vr * vr - v2 * (relPos.length2() - collisionDist * collisionDist);
if (Dh <= 0 || v2 == 0)
continue; // No solution; distance is always >= collisionDist.
const float t = (-vr - std::sqrt(Dh)) / v2;
if (t < 0 || t > timeToCollision)
continue;
// Check visibility and awareness last as it's expensive.
if (!MWBase::Environment::get().getWorld()->getLOS(otherPtr, ptr))
continue;
if (!MWBase::Environment::get().getMechanicsManager()->awarenessCheck(otherPtr, ptr))
continue;
timeToCollision = t;
angleToApproachingActor = std::atan2(deltaPos.x(), deltaPos.y());
const osg::Vec2f posAtT = relPos + relSpeed * t;
const float coef = (posAtT.x() * relSpeed.x() + posAtT.y() * relSpeed.y())
/ (collisionDist * collisionDist * maxSpeed)
* std::clamp(
(maxDistForPartialAvoiding - dist) / (maxDistForPartialAvoiding - maxDistForStrictAvoiding),
0.f, 1.f);
movementCorrection = posAtT * coef;
if (otherPtr.getClass().getCreatureStats(otherPtr).isDead())
// In case of dead body still try to go around (it looks natural), but reduce the correction twice.
movementCorrection.y() *= 0.5f;
}
if (timeToCollision < timeToCheck)
{
// Try to evade the nearest collision.
osg::Vec2f newMovement = origMovement + movementCorrection;
// Step to the side rather than backward. Otherwise player will be able to push the NPC far away from
// it's original location.
newMovement.y() = std::max(newMovement.y(), 0.f);
newMovement.normalize();
if (isMoving)
newMovement *= origMovement.length(); // Keep the original speed.
movement.mPosition[0] = newMovement.x();
movement.mPosition[1] = newMovement.y();
if (shouldTurnToApproachingActor)
zTurn(ptr, angleToApproachingActor);
}
}
}
void Actors::update(float duration, bool paused)
{
if (!paused)
{
const float updateEquippedLightInterval = 1.0f;
if (mTimerUpdateHeadTrack >= 0.3f)
mTimerUpdateHeadTrack = 0;
if (mTimerUpdateHello >= 0.25f)
mTimerUpdateHello = 0;
if (mTimerDisposeSummonsCorpses >= 0.2f)
mTimerDisposeSummonsCorpses = 0;
if (mTimerUpdateEquippedLight >= updateEquippedLightInterval)
mTimerUpdateEquippedLight = 0;
// show torches only when there are darkness and no precipitations
MWBase::World* const world = MWBase::Environment::get().getWorld();
const bool showTorches = world->useTorches();
const MWWorld::Ptr player = getPlayer();
const osg::Vec3f playerPos = player.getRefData().getPosition().asVec3();
/// \todo move update logic to Actor class where appropriate
SidingCache cachedAllies{ *this, true }; // will be filled as engageCombat iterates
const bool aiActive = MWBase::Environment::get().getMechanicsManager()->isAIActive();
const int attackedByPlayerId = player.getClass().getCreatureStats(player).getHitAttemptActorId();
if (attackedByPlayerId != -1)
{
const MWWorld::Ptr playerHitAttemptActor = world->searchPtrViaActorId(attackedByPlayerId);
if (!playerHitAttemptActor.isInCell())
player.getClass().getCreatureStats(player).setHitAttemptActorId(-1);
}
const int actorsProcessingRange = Settings::game().mActorsProcessingRange;
// AI and magic effects update
for (Actor& actor : mActors)
{
const bool isPlayer = actor.getPtr() == player;
CharacterController& ctrl = actor.getCharacterController();
MWBase::LuaManager::ActorControls* luaControls
= MWBase::Environment::get().getLuaManager()->getActorControls(actor.getPtr());
const float distSqr = (playerPos - actor.getPtr().getRefData().getPosition().asVec3()).length2();
// AI processing is only done within given distance to the player.
const bool inProcessingRange = distSqr <= actorsProcessingRange * actorsProcessingRange;
// If dead or no longer in combat, no longer store any actors who attempted to hit us. Also remove for
// the player.
if (!isPlayer
&& (actor.getPtr().getClass().getCreatureStats(actor.getPtr()).isDead()
|| !actor.getPtr().getClass().getCreatureStats(actor.getPtr()).getAiSequence().isInCombat()
|| !inProcessingRange))
{
actor.getPtr().getClass().getCreatureStats(actor.getPtr()).setHitAttemptActorId(-1);
if (player.getClass().getCreatureStats(player).getHitAttemptActorId()
== actor.getPtr().getClass().getCreatureStats(actor.getPtr()).getActorId())
player.getClass().getCreatureStats(player).setHitAttemptActorId(-1);
}
const Misc::TimerStatus engageCombatTimerStatus = actor.updateEngageCombatTimer(duration);
// For dead actors we need to update looping spell particles
if (actor.getPtr().getClass().getCreatureStats(actor.getPtr()).isDead())
{
// They can be added during the death animation
if (!actor.getPtr().getClass().getCreatureStats(actor.getPtr()).isDeathAnimationFinished())
adjustMagicEffects(actor.getPtr(), duration);
ctrl.updateContinuousVfx();
}
else
{
MWWorld::Scene* worldScene = MWBase::Environment::get().getWorldScene();
const bool cellChanged = worldScene->hasCellChanged();
const MWWorld::Ptr actorPtr = actor.getPtr(); // make a copy of the map key to avoid it being
// invalidated when the player teleports
updateActor(actorPtr, duration);
// Looping magic VFX update
// Note: we need to do this before any of the animations are updated.
// Reaching the text keys may trigger Hit / Spellcast (and as such, particles),
// so updating VFX immediately after that would just remove the particle effects instantly.
// There needs to be a magic effect update in between.
ctrl.updateContinuousVfx();
if (!cellChanged && worldScene->hasCellChanged())
{
return; // for now abort update of the old cell when cell changes by teleportation magic effect
// a better solution might be to apply cell changes at the end of the frame
}
if (aiActive && inProcessingRange)
{
if (engageCombatTimerStatus == Misc::TimerStatus::Elapsed)
{
if (!isPlayer)
adjustCommandedActor(actor.getPtr());
for (const Actor& otherActor : mActors)
{
if (otherActor.getPtr() == actor.getPtr() || isPlayer) // player is not AI-controlled
continue;
engageCombat(
actor.getPtr(), otherActor.getPtr(), cachedAllies, otherActor.getPtr() == player);
}
}
if (mTimerUpdateHeadTrack == 0)
updateHeadTracking(actor.getPtr(), mActors, isPlayer, ctrl);
if (actor.getPtr().getClass().isNpc() && !isPlayer)
updateCrimePursuit(actor.getPtr(), duration, cachedAllies);
if (!isPlayer)
{
CreatureStats& stats = actor.getPtr().getClass().getCreatureStats(actor.getPtr());
if (isConscious(actor.getPtr()) && !(luaControls && luaControls->mDisableAI))
{
stats.getAiSequence().execute(actor.getPtr(), ctrl, duration);
updateGreetingState(actor.getPtr(), actor, mTimerUpdateHello > 0);
playIdleDialogue(actor.getPtr());
updateMovementSpeed(actor.getPtr());
}
}
}
else if (aiActive && !isPlayer && isConscious(actor.getPtr())
&& !(luaControls && luaControls->mDisableAI))
{
CreatureStats& stats = actor.getPtr().getClass().getCreatureStats(actor.getPtr());
stats.getAiSequence().execute(actor.getPtr(), ctrl, duration, /*outOfRange*/ true);
}
if (inProcessingRange && actor.getPtr().getClass().isNpc())
{
// We can not update drowning state for actors outside of AI distance - they can not resurface
// to breathe
updateDrowning(actor.getPtr(), duration, ctrl.isKnockedOut(), isPlayer);
}
if (mTimerUpdateEquippedLight == 0 && actor.getPtr().getClass().hasInventoryStore(actor.getPtr()))
updateEquippedLight(actor.getPtr(), updateEquippedLightInterval, showTorches);
if (luaControls != nullptr && isConscious(actor.getPtr()))
updateLuaControls(actor.getPtr(), isPlayer, *luaControls);
}
}
if (Settings::game().mNPCsAvoidCollisions)
predictAndAvoidCollisions(duration);
mTimerUpdateHeadTrack += duration;
mTimerUpdateEquippedLight += duration;
mTimerUpdateHello += duration;
mTimerDisposeSummonsCorpses += duration;
// Animation/movement update
CharacterController* playerCharacter = nullptr;
for (Actor& actor : mActors)
{
const float dist = (playerPos - actor.getPtr().getRefData().getPosition().asVec3()).length();
const bool isPlayer = actor.getPtr() == player;
CreatureStats& stats = actor.getPtr().getClass().getCreatureStats(actor.getPtr());
// Actors with active AI should be able to move.
bool alwaysActive = false;
if (!isPlayer && isConscious(actor.getPtr()) && !stats.isParalyzed())
{
MWMechanics::AiSequence& seq = stats.getAiSequence();
alwaysActive = !seq.isEmpty() && seq.getActivePackage().alwaysActive();
}
const bool inRange = isPlayer || dist <= actorsProcessingRange || alwaysActive;
const int activeFlag = isPlayer ? 2 : 1; // Can be changed back to '2' to keep updating bounding boxes
// off screen (more accurate, but slower)
const int active = inRange ? activeFlag : 0;
CharacterController& ctrl = actor.getCharacterController();
ctrl.setActive(active);
if (!inRange)
{
actor.getPtr().getRefData().getBaseNode()->setNodeMask(0);
world->setActorActive(actor.getPtr(), false);
continue;
}
world->setActorActive(actor.getPtr(), true);
const bool isDead = actor.getPtr().getClass().getCreatureStats(actor.getPtr()).isDead();
if (!isDead && actor.getPtr().getClass().getCreatureStats(actor.getPtr()).isParalyzed())
ctrl.skipAnim();
// Handle player last, in case a cell transition occurs by casting a teleportation spell
// (would invalidate the iterator)
if (isPlayer)
{
playerCharacter = &ctrl;
continue;
}
actor.getPtr().getRefData().getBaseNode()->setNodeMask(MWRender::Mask_Actor);
world->setActorCollisionMode(actor.getPtr(), true,
!actor.getPtr().getClass().getCreatureStats(actor.getPtr()).isDeathAnimationFinished());
if (!actor.getPositionAdjusted())
{
actor.getPtr().getClass().adjustPosition(actor.getPtr(), false);
actor.setPositionAdjusted(true);
}
ctrl.update(duration);
updateVisibility(actor.getPtr(), ctrl);
}
if (playerCharacter)
{
MWBase::Environment::get().getWorld()->applyDeferredPreviewRotationToPlayer(duration);
playerCharacter->update(duration);
playerCharacter->setVisibility(1.f);
MWBase::LuaManager::ActorControls* luaControls
= MWBase::Environment::get().getLuaManager()->getActorControls(player);
if (luaControls && player.getClass().getMovementSettings(player).mPosition[2] < 1)
luaControls->mJump = false;
}
for (const Actor& actor : mActors)
{
const MWWorld::Class& cls = actor.getPtr().getClass();
CreatureStats& stats = cls.getCreatureStats(actor.getPtr());
// KnockedOutOneFrameLogic
// Used for "OnKnockedOut" command
// Put here to ensure that it's run for PRECISELY one frame.
if (stats.getKnockedDown() && !stats.getKnockedDownOneFrame() && !stats.getKnockedDownOverOneFrame())
{ // Start it for one frame if necessary
stats.setKnockedDownOneFrame(true);
}
else if (stats.getKnockedDownOneFrame() && !stats.getKnockedDownOverOneFrame())
{ // Turn off KnockedOutOneframe
stats.setKnockedDownOneFrame(false);
stats.setKnockedDownOverOneFrame(true);
}
}
killDeadActors();
updateSneaking(playerCharacter, duration);
}
}
void Actors::notifyDied(const MWWorld::Ptr& actor)
{
actor.getClass().getCreatureStats(actor).notifyDied();
++mDeathCount[actor.getCellRef().getRefId()];
MWBase::Environment::get().getLuaManager()->actorDied(actor);
}
void Actors::resurrect(const MWWorld::Ptr& ptr) const
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
{
if (iter->second->getCharacterController().isDead())
{
// Actor has been resurrected. Notify the CharacterController and re-enable collision.
MWBase::Environment::get().getWorld()->enableActorCollision(iter->second->getPtr(), true);
iter->second->getCharacterController().resurrect();
}
}
}
void Actors::killDeadActors()
{
for (Actor& actor : mActors)
{
const MWWorld::Class& cls = actor.getPtr().getClass();
CreatureStats& stats = cls.getCreatureStats(actor.getPtr());
if (!stats.isDead())
continue;
MWBase::Environment::get().getWorld()->removeActorPath(actor.getPtr());
CharacterController::KillResult killResult = actor.getCharacterController().kill();
if (killResult == CharacterController::Result_DeathAnimStarted)
{
// Play dying words
// Note: It's not known whether the soundgen tags scream, roar, and moan are reliable
// for NPCs since some of the npc death animation files are missing them.
MWBase::Environment::get().getDialogueManager()->say(actor.getPtr(), ESM::RefId::stringRefId("hit"));
// Apply soultrap
if (actor.getPtr().getType() == ESM::Creature::sRecordId)
soulTrap(actor.getPtr());
if (cls.isEssential(actor.getPtr()))
MWBase::Environment::get().getWindowManager()->messageBox("#{sKilledEssential}");
}
else if (killResult == CharacterController::Result_DeathAnimJustFinished)
{
const bool isPlayer = actor.getPtr() == getPlayer();
notifyDied(actor.getPtr());
// Reset magic effects and recalculate derived effects
// One case where we need this is to make sure bound items are removed upon death
const float vampirism
= stats.getMagicEffects().getOrDefault(ESM::MagicEffect::Vampirism).getMagnitude();
stats.getActiveSpells().clear(actor.getPtr());
// Make sure spell effects are removed
purgeSpellEffects(stats.getActorId());
stats.getMagicEffects().add(ESM::MagicEffect::Vampirism, vampirism);
if (isPlayer)
{
// player's death animation is over
MWBase::Environment::get().getStateManager()->askLoadRecent();
}
else
{
// NPC death animation is over, disable actor collision
MWBase::Environment::get().getWorld()->enableActorCollision(actor.getPtr(), false);
}
}
}
}
void Actors::cleanupSummonedCreature(MWMechanics::CreatureStats& casterStats, int creatureActorId) const
{
const MWWorld::Ptr ptr = MWBase::Environment::get().getWorld()->searchPtrViaActorId(creatureActorId);
if (!ptr.isEmpty())
{
MWBase::Environment::get().getWorld()->deleteObject(ptr);
const ESM::Static* fx = MWBase::Environment::get().getESMStore()->get<ESM::Static>().search(
ESM::RefId::stringRefId("VFX_Summon_End"));
if (fx)
MWBase::Environment::get().getWorld()->spawnEffect(
VFS::Path::toNormalized(Misc::ResourceHelpers::correctMeshPath(fx->mModel)), "",
ptr.getRefData().getPosition().asVec3());
// Remove the summoned creature's summoned creatures as well
MWMechanics::CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
auto& creatureMap = stats.getSummonedCreatureMap();
for (const auto& creature : creatureMap)
cleanupSummonedCreature(stats, creature.second);
creatureMap.clear();
}
else if (creatureActorId != -1)
{
// We didn't find the creature. It's probably in an inactive cell.
// Add to graveyard so we can delete it when the cell becomes active.
std::vector<int>& graveyard = casterStats.getSummonedCreatureGraveyard();
graveyard.push_back(creatureActorId);
}
purgeSpellEffects(creatureActorId);
}
void Actors::purgeSpellEffects(int casterActorId) const
{
for (const Actor& actor : mActors)
{
MWMechanics::ActiveSpells& spells
= actor.getPtr().getClass().getCreatureStats(actor.getPtr()).getActiveSpells();
spells.purge(actor.getPtr(), casterActorId);
}
}
void Actors::rest(double hours, bool sleep) const
{
float duration = hours * 3600.f;
const float timeScale = MWBase::Environment::get().getWorld()->getTimeManager()->getGameTimeScale();
if (timeScale != 0.f)
duration /= timeScale;
const MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
const osg::Vec3f playerPos = player.getRefData().getPosition().asVec3();
const int actorsProcessingRange = Settings::game().mActorsProcessingRange;
for (const Actor& actor : mActors)
{
if (actor.getPtr().getClass().getCreatureStats(actor.getPtr()).isDead())
{
adjustMagicEffects(actor.getPtr(), duration);
continue;
}
if (!sleep || actor.getPtr() == player)
restoreDynamicStats(actor.getPtr(), hours, sleep);
if ((!actor.getPtr().getRefData().getBaseNode())
|| (playerPos - actor.getPtr().getRefData().getPosition().asVec3()).length2()
> actorsProcessingRange * actorsProcessingRange)
continue;
// Get rid of effects pending removal so they are not applied when resting
updateMagicEffects(actor.getPtr());
adjustMagicEffects(actor.getPtr(), duration);
MWRender::Animation* animation = MWBase::Environment::get().getWorld()->getAnimation(actor.getPtr());
if (animation)
{
animation->removeEffects();
MWBase::Environment::get().getWorld()->applyLoopingParticles(actor.getPtr());
}
}
fastForwardAi();
}
void Actors::updateSneaking(CharacterController* ctrl, float duration)
{
if (!ctrl)
{
MWBase::Environment::get().getWindowManager()->setSneakVisibility(false);
return;
}
const MWWorld::Ptr player = getPlayer();
if (!MWBase::Environment::get().getMechanicsManager()->isSneaking(player))
{
MWBase::Environment::get().getWindowManager()->setSneakVisibility(false);
return;
}
MWBase::World* const world = MWBase::Environment::get().getWorld();
const MWWorld::Store<ESM::GameSetting>& gmst = world->getStore().get<ESM::GameSetting>();
static const float fSneakUseDist = gmst.find("fSneakUseDist")->mValue.getFloat();
static const float fSneakUseDelay = gmst.find("fSneakUseDelay")->mValue.getFloat();
if (mSneakTimer >= fSneakUseDelay)
mSneakTimer = 0.f;
if (mSneakTimer == 0.f)
{
// Set when an NPC is within line of sight and distance, but is still unaware. Used for skill progress.
bool avoidedNotice = false;
bool detected = false;
std::vector<MWWorld::Ptr> observers;
const osg::Vec3f position(player.getRefData().getPosition().asVec3());
const float radius = std::min<float>(fSneakUseDist, Settings::game().mActorsProcessingRange);
getObjectsInRange(position, radius, observers);
std::set<MWWorld::Ptr> sidingActors;
getActorsSidingWith(player, sidingActors);
for (const MWWorld::Ptr& observer : observers)
{
if (observer == player || observer.getClass().getCreatureStats(observer).isDead())
continue;
if (sidingActors.find(observer) != sidingActors.cend())
continue;
if (world->getLOS(player, observer))
{
if (MWBase::Environment::get().getMechanicsManager()->awarenessCheck(player, observer))
{
detected = true;
avoidedNotice = false;
MWBase::Environment::get().getWindowManager()->setSneakVisibility(false);
break;
}
else
{
avoidedNotice = true;
}
}
}
if (mSneakSkillTimer >= fSneakUseDelay)
mSneakSkillTimer = 0.f;
if (avoidedNotice && mSneakSkillTimer == 0.f)
player.getClass().skillUsageSucceeded(player, ESM::Skill::Sneak, ESM::Skill::Sneak_AvoidNotice);
if (!detected)
MWBase::Environment::get().getWindowManager()->setSneakVisibility(true);
}
mSneakTimer += duration;
mSneakSkillTimer += duration;
}
int Actors::getHoursToRest(const MWWorld::Ptr& ptr) const
{
const auto [healthPerHour, magickaPerHour] = getRestorationPerHourOfSleep(ptr);
CreatureStats& stats = ptr.getClass().getCreatureStats(ptr);
const bool stunted = stats.getMagicEffects().getOrDefault(ESM::MagicEffect::StuntedMagicka).getMagnitude() > 0;
const float healthHours = healthPerHour > 0
? (stats.getHealth().getModified() - stats.getHealth().getCurrent()) / healthPerHour
: 1.0f;
const float magickaHours = magickaPerHour > 0 && !stunted
? (stats.getMagicka().getModified() - stats.getMagicka().getCurrent()) / magickaPerHour
: 1.0f;
return static_cast<int>(std::ceil(std::max(1.f, std::max(healthHours, magickaHours))));
}
int Actors::countDeaths(const ESM::RefId& id) const
{
const auto iter = mDeathCount.find(id);
if (iter != mDeathCount.end())
return iter->second;
return 0;
}
void Actors::forceStateUpdate(const MWWorld::Ptr& ptr) const
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->getCharacterController().forceStateUpdate();
}
bool Actors::playAnimationGroup(
const MWWorld::Ptr& ptr, std::string_view groupName, int mode, uint32_t number, bool scripted) const
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
{
return iter->second->getCharacterController().playGroup(groupName, mode, number, scripted);
}
else
{
Log(Debug::Warning) << "Warning: Actors::playAnimationGroup: Unable to find "
<< ptr.getCellRef().getRefId();
return false;
}
}
bool Actors::playAnimationGroupLua(const MWWorld::Ptr& ptr, std::string_view groupName, uint32_t loops, float speed,
std::string_view startKey, std::string_view stopKey, bool forceLoop)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
return iter->second->getCharacterController().playGroupLua(
groupName, speed, startKey, stopKey, loops, forceLoop);
return false;
}
void Actors::enableLuaAnimations(const MWWorld::Ptr& ptr, bool enable)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->getCharacterController().enableLuaAnimations(enable);
}
void Actors::skipAnimation(const MWWorld::Ptr& ptr) const
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->getCharacterController().skipAnim();
}
bool Actors::checkAnimationPlaying(const MWWorld::Ptr& ptr, const std::string& groupName) const
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
return iter->second->getCharacterController().isAnimPlaying(groupName);
return false;
}
bool Actors::checkScriptedAnimationPlaying(const MWWorld::Ptr& ptr) const
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
return iter->second->getCharacterController().isScriptedAnimPlaying();
return false;
}
void Actors::persistAnimationStates() const
{
for (const Actor& actor : mActors)
actor.getCharacterController().persistAnimationState();
}
void Actors::clearAnimationQueue(const MWWorld::Ptr& ptr, bool clearScripted)
{
const auto iter = mIndex.find(ptr.mRef);
if (iter != mIndex.end())
iter->second->getCharacterController().clearAnimQueue(clearScripted);
}
void Actors::getObjectsInRange(const osg::Vec3f& position, float radius, std::vector<MWWorld::Ptr>& out) const
{
for (const Actor& actor : mActors)
{
if ((actor.getPtr().getRefData().getPosition().asVec3() - position).length2() <= radius * radius)
out.push_back(actor.getPtr());
}
}
bool Actors::isAnyObjectInRange(const osg::Vec3f& position, float radius) const
{
for (const Actor& actor : mActors)
{
if ((actor.getPtr().getRefData().getPosition().asVec3() - position).length2() <= radius * radius)
return true;
}
return false;
}
std::vector<MWWorld::Ptr> Actors::getActorsSidingWith(const MWWorld::Ptr& actorPtr, bool excludeInfighting) const
{
std::vector<MWWorld::Ptr> list;
list.push_back(actorPtr);
for (const Actor& actor : mActors)
{
const MWWorld::Ptr& iteratedActor = actor.getPtr();
if (iteratedActor == getPlayer())
continue;
const bool sameActor = (iteratedActor == actorPtr);
const CreatureStats& stats = iteratedActor.getClass().getCreatureStats(iteratedActor);
if (stats.isDead())
continue;
// An actor counts as siding with this actor if Follow or Escort is the current AI package, or there are
// only Wander packages before the Follow/Escort package Actors that are targeted by this actor's Follow or
// Escort packages also side with them
for (const auto& package : stats.getAiSequence())
{
if (excludeInfighting && !sameActor && package->getTypeId() == AiPackageTypeId::Combat
&& package->targetIs(actorPtr))
break;
if (package->sideWithTarget() && !package->getTarget().isEmpty())
{
if (sameActor)
{
if (excludeInfighting)
{
MWWorld::Ptr ally = package->getTarget();
std::vector<MWWorld::Ptr> enemies;
if (ally.getClass().getCreatureStats(ally).getAiSequence().getCombatTargets(enemies)
&& std::find(enemies.begin(), enemies.end(), actorPtr) != enemies.end())
break;
enemies.clear();
if (actorPtr.getClass().getCreatureStats(actorPtr).getAiSequence().getCombatTargets(enemies)
&& std::find(enemies.begin(), enemies.end(), ally) != enemies.end())
break;
}
list.push_back(package->getTarget());
}
else if (package->targetIs(actorPtr))
{
list.push_back(iteratedActor);
}
break;
}
else if (package->getTypeId() > AiPackageTypeId::Wander
&& package->getTypeId() <= AiPackageTypeId::Activate) // Don't count "fake" package types
break;
}
}
return list;
}
std::vector<MWWorld::Ptr> Actors::getActorsFollowing(const MWWorld::Ptr& actorPtr) const
{
std::vector<MWWorld::Ptr> list;
forEachFollowingPackage(
mActors, actorPtr, getPlayer(), [&](const Actor& actor, const std::shared_ptr<AiPackage>& package) {
if (package->followTargetThroughDoors() && package->targetIs(actorPtr))
list.push_back(actor.getPtr());
else if (package->getTypeId() != AiPackageTypeId::Combat
&& package->getTypeId() != AiPackageTypeId::Wander)
return false;
return true;
});
return list;
}
void Actors::getActorsFollowing(const MWWorld::Ptr& actor, std::set<MWWorld::Ptr>& out) const
{
auto followers = getActorsFollowing(actor);
for (const MWWorld::Ptr& follower : followers)
if (out.insert(follower).second)
getActorsFollowing(follower, out);
}
void Actors::getActorsSidingWith(
const MWWorld::Ptr& actor, std::set<MWWorld::Ptr>& out, bool excludeInfighting) const
{
auto followers = getActorsSidingWith(actor, excludeInfighting);
for (const MWWorld::Ptr& follower : followers)
if (out.insert(follower).second && follower != actor)
getActorsSidingWith(follower, out, excludeInfighting);
}
std::vector<int> Actors::getActorsFollowingIndices(const MWWorld::Ptr& actor) const
{
std::vector<int> list;
forEachFollowingPackage(
mActors, actor, getPlayer(), [&](const Actor&, const std::shared_ptr<AiPackage>& package) {
if (package->followTargetThroughDoors() && package->targetIs(actor))
{
list.push_back(static_cast<const AiFollow*>(package.get())->getFollowIndex());
return false;
}
else if (package->getTypeId() != AiPackageTypeId::Combat
&& package->getTypeId() != AiPackageTypeId::Wander)
return false;
return true;
});
return list;
}
std::map<int, MWWorld::Ptr> Actors::getActorsFollowingByIndex(const MWWorld::Ptr& actor) const
{
std::map<int, MWWorld::Ptr> map;
forEachFollowingPackage(
mActors, actor, getPlayer(), [&](const Actor& otherActor, const std::shared_ptr<AiPackage>& package) {
if (package->followTargetThroughDoors() && package->targetIs(actor))
{
const int index = static_cast<const AiFollow*>(package.get())->getFollowIndex();
map[index] = otherActor.getPtr();
return false;
}
else if (package->getTypeId() != AiPackageTypeId::Combat
&& package->getTypeId() != AiPackageTypeId::Wander)
return false;
return true;
});
return map;
}
std::vector<MWWorld::Ptr> Actors::getActorsFighting(const MWWorld::Ptr& actor) const
{
std::vector<MWWorld::Ptr> list;
std::vector<MWWorld::Ptr> neighbors;
const osg::Vec3f position(actor.getRefData().getPosition().asVec3());
getObjectsInRange(position, Settings::game().mActorsProcessingRange, neighbors);
for (const MWWorld::Ptr& neighbor : neighbors)
{
if (neighbor == actor)
continue;
const CreatureStats& stats = neighbor.getClass().getCreatureStats(neighbor);
if (stats.isDead())
continue;
if (stats.getAiSequence().isInCombat(actor))
list.push_back(neighbor);
}
return list;
}
std::vector<MWWorld::Ptr> Actors::getEnemiesNearby(const MWWorld::Ptr& actor) const
{
std::vector<MWWorld::Ptr> list;
std::vector<MWWorld::Ptr> neighbors;
osg::Vec3f position(actor.getRefData().getPosition().asVec3());
getObjectsInRange(position, Settings::game().mActorsProcessingRange, neighbors);
std::set<MWWorld::Ptr> followers;
getActorsFollowing(actor, followers);
for (const MWWorld::Ptr& neighbor : neighbors)
{
const CreatureStats& stats = neighbor.getClass().getCreatureStats(neighbor);
if (stats.isDead() || neighbor == actor || neighbor.getClass().isPureWaterCreature(neighbor))
continue;
const bool isFollower = followers.find(neighbor) != followers.end();
if (stats.getAiSequence().isInCombat(actor)
|| (MWBase::Environment::get().getMechanicsManager()->isAggressive(neighbor, actor) && !isFollower))
list.push_back(neighbor);
}
return list;
}
void Actors::write(ESM::ESMWriter& writer, Loading::Listener& listener) const
{
writer.startRecord(ESM::REC_DCOU);
for (const auto& [id, count] : mDeathCount)
{
writer.writeHNRefId("ID__", id);
writer.writeHNT("COUN", count);
}
writer.endRecord(ESM::REC_DCOU);
}
void Actors::readRecord(ESM::ESMReader& reader, uint32_t type)
{
if (type == ESM::REC_DCOU)
{
while (reader.isNextSub("ID__"))
{
ESM::RefId id = reader.getRefId();
int count;
reader.getHNT(count, "COUN");
if (MWBase::Environment::get().getESMStore()->find(id))
mDeathCount[id] = count;
}
}
}
void Actors::clear()
{
mIndex.clear();
mActors.clear();
mDeathCount.clear();
}
void Actors::updateMagicEffects(const MWWorld::Ptr& ptr) const
{
adjustMagicEffects(ptr, 0.f);
}
bool Actors::isReadyToBlock(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return false;
return it->second->getCharacterController().isReadyToBlock();
}
bool Actors::isCastingSpell(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return false;
return it->second->getCharacterController().isCastingSpell();
}
bool Actors::isAttackingOrSpell(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return false;
return it->second->getCharacterController().isAttackingOrSpell();
}
int Actors::getGreetingTimer(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return 0;
return it->second->getGreetingTimer();
}
float Actors::getAngleToPlayer(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return 0.f;
return it->second->getAngleToPlayer();
}
GreetingState Actors::getGreetingState(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return Greet_None;
return it->second->getGreetingState();
}
bool Actors::isTurningToPlayer(const MWWorld::Ptr& ptr) const
{
const auto it = mIndex.find(ptr.mRef);
if (it == mIndex.end())
return false;
return it->second->isTurningToPlayer();
}
void Actors::fastForwardAi() const
{
if (!MWBase::Environment::get().getMechanicsManager()->isAIActive())
return;
for (auto it = mActors.begin(); it != mActors.end();)
{
const MWWorld::Ptr ptr = it->getPtr();
++it;
if (ptr == getPlayer() || !isConscious(ptr) || ptr.getClass().getCreatureStats(ptr).isParalyzed())
continue;
MWMechanics::AiSequence& seq = ptr.getClass().getCreatureStats(ptr).getAiSequence();
seq.fastForward(ptr);
}
}
const std::set<MWWorld::Ptr>& SidingCache::getActorsSidingWith(const MWWorld::Ptr& actor)
{
// If we have already found actor's allies, use the cache
auto search = mCache.find(actor);
if (search != mCache.end())
return search->second;
std::set<MWWorld::Ptr>& out = mCache[actor];
for (const MWWorld::Ptr& follower : mActors.getActorsSidingWith(actor, mExcludeInfighting))
{
if (out.insert(follower).second && follower != actor)
{
const auto& allies = getActorsSidingWith(follower);
out.insert(allies.begin(), allies.end());
}
}
// Cache ptrs and their sets of allies
for (const MWWorld::Ptr& iter : out)
{
if (iter == actor)
continue;
search = mCache.find(iter);
if (search == mCache.end())
mCache.emplace(iter, out);
}
return out;
}
}
| 104,233
|
C++
|
.cpp
| 2,053
| 36.982465
| 120
| 0.579061
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,318
|
character.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/character.cpp
|
/*
* OpenMW - The completely unofficial reimplementation of Morrowind
*
* This file (character.cpp) is part of the OpenMW package.
*
* OpenMW is distributed as free software: you can redistribute it
* and/or modify it under the terms of the GNU General Public License
* version 3, as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* version 3 along with this program. If not, see
* https://www.gnu.org/licenses/ .
*/
#include "character.hpp"
#include <array>
#include <unordered_set>
#include <components/esm/records.hpp>
#include <components/misc/mathutil.hpp>
#include <components/misc/resourcehelpers.hpp>
#include <components/misc/rng.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <components/misc/strings/conversion.hpp>
#include <components/settings/values.hpp>
#include <components/sceneutil/positionattitudetransform.hpp>
#include "../mwrender/animation.hpp"
#include "../mwbase/environment.hpp"
#include "../mwbase/luamanager.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/soundmanager.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/esmstore.hpp"
#include "../mwworld/inventorystore.hpp"
#include "../mwworld/player.hpp"
#include "../mwworld/spellcaststate.hpp"
#include "actorutil.hpp"
#include "aicombataction.hpp"
#include "creaturestats.hpp"
#include "movement.hpp"
#include "npcstats.hpp"
#include "security.hpp"
#include "spellcasting.hpp"
#include "weapontype.hpp"
namespace
{
std::string_view getBestAttack(const ESM::Weapon* weapon)
{
int slash = weapon->mData.mSlash[0] + weapon->mData.mSlash[1];
int chop = weapon->mData.mChop[0] + weapon->mData.mChop[1];
int thrust = weapon->mData.mThrust[0] + weapon->mData.mThrust[1];
if (slash == chop && slash == thrust)
return "slash";
else if (thrust >= chop && thrust >= slash)
return "thrust";
else if (slash >= chop && slash >= thrust)
return "slash";
else
return "chop";
}
// Converts a movement Run state to its equivalent Walk state, if there is one.
MWMechanics::CharacterState runStateToWalkState(MWMechanics::CharacterState state)
{
using namespace MWMechanics;
switch (state)
{
case CharState_RunForward:
return CharState_WalkForward;
case CharState_RunBack:
return CharState_WalkBack;
case CharState_RunLeft:
return CharState_WalkLeft;
case CharState_RunRight:
return CharState_WalkRight;
case CharState_SwimRunForward:
return CharState_SwimWalkForward;
case CharState_SwimRunBack:
return CharState_SwimWalkBack;
case CharState_SwimRunLeft:
return CharState_SwimWalkLeft;
case CharState_SwimRunRight:
return CharState_SwimWalkRight;
default:
return state;
}
}
// Converts a Hit state to its equivalent Death state.
MWMechanics::CharacterState hitStateToDeathState(MWMechanics::CharacterState state)
{
using namespace MWMechanics;
switch (state)
{
case CharState_SwimKnockDown:
return CharState_SwimDeathKnockDown;
case CharState_SwimKnockOut:
return CharState_SwimDeathKnockOut;
case CharState_KnockDown:
return CharState_DeathKnockDown;
case CharState_KnockOut:
return CharState_DeathKnockOut;
default:
return CharState_None;
}
}
// Converts a movement state to its equivalent base animation group as long as it is a movement state.
std::string_view movementStateToAnimGroup(MWMechanics::CharacterState state)
{
using namespace MWMechanics;
switch (state)
{
case CharState_WalkForward:
return "walkforward";
case CharState_WalkBack:
return "walkback";
case CharState_WalkLeft:
return "walkleft";
case CharState_WalkRight:
return "walkright";
case CharState_SwimWalkForward:
return "swimwalkforward";
case CharState_SwimWalkBack:
return "swimwalkback";
case CharState_SwimWalkLeft:
return "swimwalkleft";
case CharState_SwimWalkRight:
return "swimwalkright";
case CharState_RunForward:
return "runforward";
case CharState_RunBack:
return "runback";
case CharState_RunLeft:
return "runleft";
case CharState_RunRight:
return "runright";
case CharState_SwimRunForward:
return "swimrunforward";
case CharState_SwimRunBack:
return "swimrunback";
case CharState_SwimRunLeft:
return "swimrunleft";
case CharState_SwimRunRight:
return "swimrunright";
case CharState_SneakForward:
return "sneakforward";
case CharState_SneakBack:
return "sneakback";
case CharState_SneakLeft:
return "sneakleft";
case CharState_SneakRight:
return "sneakright";
case CharState_TurnLeft:
return "turnleft";
case CharState_TurnRight:
return "turnright";
case CharState_SwimTurnLeft:
return "swimturnleft";
case CharState_SwimTurnRight:
return "swimturnright";
default:
return {};
}
}
// Converts a death state to its equivalent animation group as long as it is a death state.
std::string_view deathStateToAnimGroup(MWMechanics::CharacterState state)
{
using namespace MWMechanics;
switch (state)
{
case CharState_SwimDeath:
return "swimdeath";
case CharState_SwimDeathKnockDown:
return "swimdeathknockdown";
case CharState_SwimDeathKnockOut:
return "swimdeathknockout";
case CharState_DeathKnockDown:
return "deathknockdown";
case CharState_DeathKnockOut:
return "deathknockout";
case CharState_Death1:
return "death1";
case CharState_Death2:
return "death2";
case CharState_Death3:
return "death3";
case CharState_Death4:
return "death4";
case CharState_Death5:
return "death5";
default:
return {};
}
}
// Converts a hit state to its equivalent animation group as long as it is a hit state.
std::string hitStateToAnimGroup(MWMechanics::CharacterState state)
{
using namespace MWMechanics;
switch (state)
{
case CharState_SwimHit:
return "swimhit";
case CharState_SwimKnockDown:
return "swimknockdown";
case CharState_SwimKnockOut:
return "swimknockout";
case CharState_Hit:
return "hit";
case CharState_KnockDown:
return "knockdown";
case CharState_KnockOut:
return "knockout";
case CharState_Block:
return "shield";
default:
return {};
}
}
// Converts an idle state to its equivalent animation group.
std::string idleStateToAnimGroup(MWMechanics::CharacterState state)
{
using namespace MWMechanics;
switch (state)
{
case CharState_IdleSwim:
return "idleswim";
case CharState_IdleSneak:
return "idlesneak";
case CharState_Idle:
case CharState_SpecialIdle:
return "idle";
default:
return {};
}
}
MWRender::Animation::AnimPriority getIdlePriority(MWMechanics::CharacterState state)
{
using namespace MWMechanics;
MWRender::Animation::AnimPriority priority(Priority_Default);
switch (state)
{
case CharState_IdleSwim:
return Priority_SwimIdle;
case CharState_IdleSneak:
priority[MWRender::BoneGroup_LowerBody] = Priority_SneakIdleLowerBody;
[[fallthrough]];
default:
return priority;
}
}
float getFallDamage(const MWWorld::Ptr& ptr, float fallHeight)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
const MWWorld::Store<ESM::GameSetting>& store = world->getStore().get<ESM::GameSetting>();
const float fallDistanceMin = store.find("fFallDamageDistanceMin")->mValue.getFloat();
if (fallHeight >= fallDistanceMin)
{
const float acrobaticsSkill = static_cast<float>(ptr.getClass().getSkill(ptr, ESM::Skill::Acrobatics));
const float jumpSpellBonus = ptr.getClass()
.getCreatureStats(ptr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Jump)
.getMagnitude();
const float fallAcroBase = store.find("fFallAcroBase")->mValue.getFloat();
const float fallAcroMult = store.find("fFallAcroMult")->mValue.getFloat();
const float fallDistanceBase = store.find("fFallDistanceBase")->mValue.getFloat();
const float fallDistanceMult = store.find("fFallDistanceMult")->mValue.getFloat();
float x = fallHeight - fallDistanceMin;
x -= (1.5f * acrobaticsSkill) + jumpSpellBonus;
x = std::max(0.0f, x);
float a = fallAcroBase + fallAcroMult * (100 - acrobaticsSkill);
x = fallDistanceBase + fallDistanceMult * x;
x *= a;
return x;
}
return 0.f;
}
bool isRealWeapon(int weaponType)
{
return weaponType != ESM::Weapon::HandToHand && weaponType != ESM::Weapon::Spell
&& weaponType != ESM::Weapon::None;
}
}
namespace MWMechanics
{
std::string CharacterController::chooseRandomGroup(const std::string& prefix, int* num) const
{
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
int numAnims = 0;
while (mAnimation->hasAnimation(prefix + std::to_string(numAnims + 1)))
++numAnims;
int roll = Misc::Rng::rollDice(numAnims, prng) + 1; // [1, numAnims]
if (num)
*num = roll;
return prefix + std::to_string(roll);
}
void CharacterController::clearStateAnimation(std::string& anim) const
{
if (anim.empty())
return;
if (mAnimation)
mAnimation->disable(anim);
anim.clear();
}
void CharacterController::resetCurrentJumpState()
{
clearStateAnimation(mCurrentJump);
mJumpState = JumpState_None;
}
void CharacterController::resetCurrentMovementState()
{
clearStateAnimation(mCurrentMovement);
mMovementState = CharState_None;
mMovementAnimationHasMovement = false;
}
void CharacterController::resetCurrentIdleState()
{
clearStateAnimation(mCurrentIdle);
mIdleState = CharState_None;
}
void CharacterController::resetCurrentHitState()
{
clearStateAnimation(mCurrentHit);
mHitState = CharState_None;
}
void CharacterController::resetCurrentWeaponState()
{
clearStateAnimation(mCurrentWeapon);
mUpperBodyState = UpperBodyState::None;
}
void CharacterController::resetCurrentDeathState()
{
clearStateAnimation(mCurrentDeath);
mDeathState = CharState_None;
}
void CharacterController::refreshHitRecoilAnims()
{
auto& charClass = mPtr.getClass();
if (!charClass.isActor())
return;
const auto world = MWBase::Environment::get().getWorld();
auto& stats = charClass.getCreatureStats(mPtr);
bool knockout = stats.getFatigue().getCurrent() < 0 || stats.getFatigue().getBase() == 0;
bool recovery = stats.getHitRecovery();
bool knockdown = stats.getKnockedDown();
bool block = stats.getBlock() && !knockout && !recovery && !knockdown;
bool isSwimming = world->isSwimming(mPtr);
stats.setBlock(false);
if (mPtr == getPlayer() && mHitState == CharState_Block && block)
{
mHitState = CharState_None;
resetCurrentIdleState();
}
if (mHitState != CharState_None)
{
if (!mAnimation->isPlaying(mCurrentHit))
{
if (isKnockedOut() && mCurrentHit.empty() && knockout)
return;
mHitState = CharState_None;
mCurrentHit.clear();
stats.setKnockedDown(false);
stats.setHitRecovery(false);
resetCurrentIdleState();
}
else if (isKnockedOut())
mAnimation->setLoopingEnabled(mCurrentHit, knockout);
return;
}
if (!knockout && !knockdown && !recovery && !block)
return;
MWRender::Animation::AnimPriority priority(Priority_Knockdown);
std::string_view startKey = "start";
std::string_view stopKey = "stop";
if (knockout)
{
mHitState = isSwimming ? CharState_SwimKnockOut : CharState_KnockOut;
stats.setKnockedDown(true);
}
else if (knockdown)
{
mHitState = isSwimming ? CharState_SwimKnockDown : CharState_KnockDown;
}
else if (recovery)
{
mHitState = isSwimming ? CharState_SwimHit : CharState_Hit;
priority = Priority_Hit;
}
else if (block)
{
mHitState = CharState_Block;
priority = Priority_Hit;
priority[MWRender::BoneGroup_LeftArm] = Priority_Block;
priority[MWRender::BoneGroup_LowerBody] = Priority_WeaponLowerBody;
startKey = "block start";
stopKey = "block stop";
}
mCurrentHit = hitStateToAnimGroup(mHitState);
if (isRecovery())
{
mCurrentHit = chooseRandomGroup(mCurrentHit);
if (mHitState == CharState_SwimHit && !mAnimation->hasAnimation(mCurrentHit))
mCurrentHit = chooseRandomGroup(hitStateToAnimGroup(CharState_Hit));
}
// Cancel upper body animations
if (isKnockedOut() || isKnockedDown())
{
if (!mCurrentWeapon.empty())
mAnimation->disable(mCurrentWeapon);
if (mUpperBodyState > UpperBodyState::WeaponEquipped)
{
mUpperBodyState = UpperBodyState::WeaponEquipped;
if (mWeaponType > ESM::Weapon::None)
mAnimation->showWeapons(true);
}
else if (mUpperBodyState < UpperBodyState::WeaponEquipped)
{
mUpperBodyState = UpperBodyState::None;
}
}
if (!mAnimation->hasAnimation(mCurrentHit))
{
mCurrentHit.clear();
return;
}
playBlendedAnimation(mCurrentHit, priority, MWRender::BlendMask_All, true, 1, startKey, stopKey, 0.0f,
std::numeric_limits<uint32_t>::max());
}
void CharacterController::refreshJumpAnims(JumpingState jump, bool force)
{
if (!force && jump == mJumpState)
return;
if (jump == JumpState_None)
{
if (!mCurrentJump.empty())
resetCurrentIdleState();
resetCurrentJumpState();
return;
}
std::string_view weapShortGroup = getWeaponShortGroup(mWeaponType);
std::string jumpAnimName = "jump";
jumpAnimName += weapShortGroup;
MWRender::Animation::BlendMask jumpmask = MWRender::BlendMask_All;
if (!weapShortGroup.empty() && !mAnimation->hasAnimation(jumpAnimName))
jumpAnimName = fallbackShortWeaponGroup("jump", &jumpmask);
if (!mAnimation->hasAnimation(jumpAnimName))
{
if (!mCurrentJump.empty())
resetCurrentIdleState();
resetCurrentJumpState();
return;
}
bool startAtLoop = (jump == mJumpState);
mJumpState = jump;
clearStateAnimation(mCurrentJump);
mCurrentJump = jumpAnimName;
if (mJumpState == JumpState_InAir)
playBlendedAnimation(jumpAnimName, Priority_Jump, jumpmask, false, 1.0f,
startAtLoop ? "loop start" : "start", "stop", 0.f, std::numeric_limits<uint32_t>::max());
else if (mJumpState == JumpState_Landing)
playBlendedAnimation(jumpAnimName, Priority_Jump, jumpmask, true, 1.0f, "loop stop", "stop", 0.0f, 0);
}
bool CharacterController::onOpen() const
{
if (mPtr.getType() == ESM::Container::sRecordId)
{
if (!mAnimation->hasAnimation("containeropen"))
return true;
if (mAnimation->isPlaying("containeropen"))
return false;
if (mAnimation->isPlaying("containerclose"))
return false;
mAnimation->play(
"containeropen", Priority_Scripted, MWRender::BlendMask_All, false, 1.0f, "start", "stop", 0.f, 0);
if (mAnimation->isPlaying("containeropen"))
return false;
}
return true;
}
void CharacterController::onClose() const
{
if (mPtr.getType() == ESM::Container::sRecordId)
{
if (!mAnimation->hasAnimation("containerclose"))
return;
float complete, startPoint = 0.f;
bool animPlaying = mAnimation->getInfo("containeropen", &complete);
if (animPlaying)
startPoint = 1.f - complete;
mAnimation->play("containerclose", Priority_Scripted, MWRender::BlendMask_All, false, 1.0f, "start", "stop",
startPoint, 0);
}
}
std::string_view CharacterController::getWeaponAnimation(int weaponType) const
{
std::string_view weaponGroup = getWeaponType(weaponType)->mLongGroup;
if (isRealWeapon(weaponType) && !mAnimation->hasAnimation(weaponGroup))
{
static const std::string_view oneHandFallback = getWeaponType(ESM::Weapon::LongBladeOneHand)->mLongGroup;
static const std::string_view twoHandFallback = getWeaponType(ESM::Weapon::LongBladeTwoHand)->mLongGroup;
const ESM::WeaponType* weapInfo = getWeaponType(weaponType);
// For real two-handed melee weapons use 2h swords animations as fallback, otherwise use the 1h ones
if (weapInfo->mFlags & ESM::WeaponType::TwoHanded && weapInfo->mWeaponClass == ESM::WeaponType::Melee)
weaponGroup = twoHandFallback;
else
weaponGroup = oneHandFallback;
}
else if (weaponType == ESM::Weapon::HandToHand && !mPtr.getClass().isBipedal(mPtr))
return "attack1";
return weaponGroup;
}
std::string_view CharacterController::getWeaponShortGroup(int weaponType) const
{
if (weaponType == ESM::Weapon::HandToHand && !mPtr.getClass().isBipedal(mPtr))
return {};
return getWeaponType(weaponType)->mShortGroup;
}
std::string CharacterController::fallbackShortWeaponGroup(
const std::string& baseGroupName, MWRender::Animation::BlendMask* blendMask) const
{
if (!isRealWeapon(mWeaponType))
{
if (blendMask != nullptr)
*blendMask = MWRender::BlendMask_LowerBody;
return baseGroupName;
}
static const std::string_view oneHandFallback = getWeaponShortGroup(ESM::Weapon::LongBladeOneHand);
static const std::string_view twoHandFallback = getWeaponShortGroup(ESM::Weapon::LongBladeTwoHand);
std::string groupName = baseGroupName;
const ESM::WeaponType* weapInfo = getWeaponType(mWeaponType);
// For real two-handed melee weapons use 2h swords animations as fallback, otherwise use the 1h ones
if (weapInfo->mFlags & ESM::WeaponType::TwoHanded && weapInfo->mWeaponClass == ESM::WeaponType::Melee)
groupName += twoHandFallback;
else
groupName += oneHandFallback;
// Special case for crossbows - we should apply 1h animations a fallback only for lower body
if (mWeaponType == ESM::Weapon::MarksmanCrossbow && blendMask != nullptr)
*blendMask = MWRender::BlendMask_LowerBody;
if (!mAnimation->hasAnimation(groupName))
{
groupName = baseGroupName;
if (blendMask != nullptr)
*blendMask = MWRender::BlendMask_LowerBody;
}
return groupName;
}
void CharacterController::refreshMovementAnims(CharacterState movement, bool force)
{
if (movement == mMovementState && !force)
return;
std::string_view movementAnimGroup = movementStateToAnimGroup(movement);
if (movementAnimGroup.empty())
{
if (!mCurrentMovement.empty())
resetCurrentIdleState();
resetCurrentMovementState();
return;
}
std::string movementAnimName{ movementAnimGroup };
mMovementState = movement;
std::string::size_type swimpos = movementAnimName.find("swim");
if (!mAnimation->hasAnimation(movementAnimName))
{
if (swimpos != std::string::npos)
{
movementAnimName.erase(swimpos, 4);
swimpos = std::string::npos;
}
}
MWRender::Animation::BlendMask movemask = MWRender::BlendMask_All;
std::string_view weapShortGroup = getWeaponShortGroup(mWeaponType);
// Non-biped creatures don't use spellcasting-specific movement animations.
if (!isRealWeapon(mWeaponType) && !mPtr.getClass().isBipedal(mPtr))
weapShortGroup = {};
if (swimpos == std::string::npos && !weapShortGroup.empty())
{
std::string weapMovementAnimName;
// Spellcasting stance turning is a special case
if (mWeaponType == ESM::Weapon::Spell && isTurning())
{
weapMovementAnimName = weapShortGroup;
weapMovementAnimName += movementAnimName;
}
else
{
weapMovementAnimName = movementAnimName;
weapMovementAnimName += weapShortGroup;
}
if (!mAnimation->hasAnimation(weapMovementAnimName))
weapMovementAnimName = fallbackShortWeaponGroup(movementAnimName, &movemask);
movementAnimName = std::move(weapMovementAnimName);
}
if (!mAnimation->hasAnimation(movementAnimName))
{
std::string::size_type runpos = movementAnimName.find("run");
if (runpos != std::string::npos)
movementAnimName.replace(runpos, 3, "walk");
if (!mAnimation->hasAnimation(movementAnimName))
{
if (!mCurrentMovement.empty())
resetCurrentIdleState();
resetCurrentMovementState();
return;
}
}
// If we're playing the same animation, start it from the point it ended
float startpoint = 0.f;
if (!mCurrentMovement.empty() && movementAnimName == mCurrentMovement)
mAnimation->getInfo(mCurrentMovement, &startpoint);
mMovementAnimationHasMovement = true;
clearStateAnimation(mCurrentMovement);
mCurrentMovement = std::move(movementAnimName);
// For non-flying creatures, MW uses the Walk animation to calculate the animation velocity
// even if we are running. This must be replicated, otherwise the observed speed would differ drastically.
mAdjustMovementAnimSpeed = true;
if (mPtr.getClass().getType() == ESM::Creature::sRecordId
&& !(mPtr.get<ESM::Creature>()->mBase->mFlags & ESM::Creature::Flies))
{
CharacterState walkState = runStateToWalkState(mMovementState);
std::string_view anim = movementStateToAnimGroup(walkState);
mMovementAnimSpeed = mAnimation->getVelocity(anim);
if (mMovementAnimSpeed <= 1.0f)
{
// Another bug: when using a fallback animation (e.g. RunForward as fallback to SwimRunForward),
// then the equivalent Walk animation will not use a fallback, and if that animation doesn't exist
// we will play without any scaling.
// Makes the speed attribute of most water creatures totally useless.
// And again, this can not be fixed without patching game data.
mAdjustMovementAnimSpeed = false;
mMovementAnimSpeed = 1.f;
}
}
else
{
mMovementAnimSpeed = mAnimation->getVelocity(mCurrentMovement);
if (mMovementAnimSpeed <= 1.0f)
{
// The first person anims don't have any velocity to calculate a speed multiplier from.
// We use the third person velocities instead.
// FIXME: should be pulled from the actual animation, but it is not presently loaded.
bool sneaking = mMovementState == CharState_SneakForward || mMovementState == CharState_SneakBack
|| mMovementState == CharState_SneakLeft || mMovementState == CharState_SneakRight;
mMovementAnimSpeed = (sneaking ? 33.5452f : (isRunning() ? 222.857f : 154.064f));
mMovementAnimationHasMovement = false;
}
}
playBlendedAnimation(mCurrentMovement, Priority_Movement, movemask, false, 1.f, "start", "stop", startpoint,
std::numeric_limits<uint32_t>::max(), true);
}
void CharacterController::refreshIdleAnims(CharacterState idle, bool force)
{
// FIXME: if one of the below states is close to their last animation frame (i.e. will be disabled in the coming
// update), the idle animation should be displayed
if (((mUpperBodyState != UpperBodyState::None && mUpperBodyState != UpperBodyState::WeaponEquipped)
|| mMovementState != CharState_None || !mCurrentHit.empty())
&& !mPtr.getClass().isBipedal(mPtr))
{
resetCurrentIdleState();
return;
}
if (!force && idle == mIdleState && (mAnimation->isPlaying(mCurrentIdle) || !mAnimQueue.empty()))
return;
mIdleState = idle;
std::string idleGroup = idleStateToAnimGroup(mIdleState);
if (idleGroup.empty())
{
resetCurrentIdleState();
return;
}
MWRender::Animation::AnimPriority priority = getIdlePriority(mIdleState);
size_t numLoops = std::numeric_limits<uint32_t>::max();
// Only play "idleswim" or "idlesneak" if they exist. Otherwise, fallback to
// "idle"+weapon or "idle".
bool fallback = mIdleState != CharState_Idle && !mAnimation->hasAnimation(idleGroup);
if (fallback)
{
priority = getIdlePriority(CharState_Idle);
idleGroup = idleStateToAnimGroup(CharState_Idle);
}
if (fallback || mIdleState == CharState_Idle || mIdleState == CharState_SpecialIdle)
{
std::string_view weapShortGroup = getWeaponShortGroup(mWeaponType);
if (!weapShortGroup.empty())
{
std::string weapIdleGroup = idleGroup;
weapIdleGroup += weapShortGroup;
if (!mAnimation->hasAnimation(weapIdleGroup))
weapIdleGroup = fallbackShortWeaponGroup(idleGroup);
idleGroup = std::move(weapIdleGroup);
// play until the Loop Stop key 2 to 5 times, then play until the Stop key
// this replicates original engine behavior for the "Idle1h" 1st-person animation
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
numLoops = 1 + Misc::Rng::rollDice(4, prng);
}
}
if (!mAnimation->hasAnimation(idleGroup))
{
resetCurrentIdleState();
return;
}
float startPoint = 0.f;
// There is no need to restart anim if the new and old anims are the same.
// Just update the number of loops.
if (mCurrentIdle == idleGroup)
mAnimation->getInfo(mCurrentIdle, &startPoint);
clearStateAnimation(mCurrentIdle);
mCurrentIdle = std::move(idleGroup);
playBlendedAnimation(
mCurrentIdle, priority, MWRender::BlendMask_All, false, 1.0f, "start", "stop", startPoint, numLoops, true);
}
void CharacterController::refreshCurrentAnims(
CharacterState idle, CharacterState movement, JumpingState jump, bool force)
{
// If the current animation is scripted, do not touch it
if (isScriptedAnimPlaying())
return;
refreshHitRecoilAnims();
refreshJumpAnims(jump, force);
refreshMovementAnims(movement, force);
// idle handled last as it can depend on the other states
refreshIdleAnims(idle, force);
}
void CharacterController::playDeath(float startpoint, CharacterState death)
{
mDeathState = death;
mCurrentDeath = deathStateToAnimGroup(mDeathState);
mPtr.getClass().getCreatureStats(mPtr).setDeathAnimation(mDeathState - CharState_Death1);
// For dead actors, refreshCurrentAnims is no longer called, so we need to disable the movement state manually.
// Note that these animations wouldn't actually be visible (due to the Death animation's priority being higher).
// However, they could still trigger text keys, such as Hit events, or sounds.
resetCurrentMovementState();
resetCurrentWeaponState();
resetCurrentHitState();
resetCurrentIdleState();
resetCurrentJumpState();
playBlendedAnimation(
mCurrentDeath, Priority_Death, MWRender::BlendMask_All, false, 1.0f, "start", "stop", startpoint, 0);
}
CharacterState CharacterController::chooseRandomDeathState() const
{
int selected = 0;
chooseRandomGroup("death", &selected);
return static_cast<CharacterState>(CharState_Death1 + (selected - 1));
}
void CharacterController::playRandomDeath(float startpoint)
{
if (mPtr == getPlayer())
{
// The first-person animations do not include death, so we need to
// force-switch to third person before playing the death animation.
MWBase::Environment::get().getWorld()->useDeathCamera();
}
mDeathState = hitStateToDeathState(mHitState);
if (mDeathState == CharState_None && MWBase::Environment::get().getWorld()->isSwimming(mPtr))
mDeathState = CharState_SwimDeath;
if (mDeathState == CharState_None || !mAnimation->hasAnimation(deathStateToAnimGroup(mDeathState)))
mDeathState = chooseRandomDeathState();
// Do not interrupt scripted animation by death
if (isScriptedAnimPlaying())
return;
playDeath(startpoint, mDeathState);
}
std::string CharacterController::chooseRandomAttackAnimation() const
{
std::string result;
bool isSwimming = MWBase::Environment::get().getWorld()->isSwimming(mPtr);
if (isSwimming)
result = chooseRandomGroup("swimattack");
if (!isSwimming || !mAnimation->hasAnimation(result))
result = chooseRandomGroup("attack");
return result;
}
CharacterController::CharacterController(const MWWorld::Ptr& ptr, MWRender::Animation* anim)
: mPtr(ptr)
, mAnimation(anim)
{
if (!mAnimation)
return;
mAnimation->setTextKeyListener(this);
const MWWorld::Class& cls = mPtr.getClass();
if (cls.isActor())
{
/* Accumulate along X/Y only for now, until we can figure out how we should
* handle knockout and death which moves the character down. */
mAnimation->setAccumulation(osg::Vec3f(1.0f, 1.0f, 0.0f));
if (cls.hasInventoryStore(mPtr))
{
getActiveWeapon(mPtr, &mWeaponType);
if (mWeaponType != ESM::Weapon::None)
{
mUpperBodyState = UpperBodyState::WeaponEquipped;
mCurrentWeapon = getWeaponAnimation(mWeaponType);
}
if (mWeaponType != ESM::Weapon::None && mWeaponType != ESM::Weapon::Spell
&& mWeaponType != ESM::Weapon::HandToHand)
{
mAnimation->showWeapons(true);
// Note: controllers for ranged weapon should use time for beginning of animation to play shooting
// properly, for other weapons they should use absolute time. Some mods rely on this behaviour (to
// rotate throwing projectiles, for example)
ESM::WeaponType::Class weaponClass = getWeaponType(mWeaponType)->mWeaponClass;
bool useRelativeDuration = weaponClass == ESM::WeaponType::Ranged;
mAnimation->setWeaponGroup(mCurrentWeapon, useRelativeDuration);
}
mAnimation->showCarriedLeft(updateCarriedLeftVisible(mWeaponType));
}
if (!cls.getCreatureStats(mPtr).isDead())
{
mIdleState = CharState_Idle;
if (cls.getCreatureStats(mPtr).getFallHeight() > 0)
mJumpState = JumpState_InAir;
}
else
{
const MWMechanics::CreatureStats& cStats = mPtr.getClass().getCreatureStats(mPtr);
if (cStats.isDeathAnimationFinished())
{
// Set the death state, but don't play it yet
// We will play it in the first frame, but only if no script set the skipAnim flag
signed char deathanim = cStats.getDeathAnimation();
if (deathanim == -1)
mDeathState = chooseRandomDeathState();
else
mDeathState = static_cast<CharacterState>(CharState_Death1 + deathanim);
mFloatToSurface = cStats.getHealth().getBase() != 0;
}
// else: nothing to do, will detect death in the next frame and start playing death animation
}
}
else
{
/* Don't accumulate with non-actors. */
mAnimation->setAccumulation(osg::Vec3f(0.f, 0.f, 0.f));
mIdleState = CharState_Idle;
}
// Do not update animation status for dead actors
if (mDeathState == CharState_None && (!cls.isActor() || !cls.getCreatureStats(mPtr).isDead()))
refreshCurrentAnims(mIdleState, mMovementState, mJumpState, true);
mAnimation->runAnimation(0.f);
unpersistAnimationState();
}
CharacterController::~CharacterController()
{
if (mAnimation)
{
persistAnimationState();
mAnimation->setTextKeyListener(nullptr);
}
}
void CharacterController::handleTextKey(
std::string_view groupname, SceneUtil::TextKeyMap::ConstIterator key, const SceneUtil::TextKeyMap& map)
{
std::string_view evt = key->second;
MWBase::Environment::get().getLuaManager()->animationTextKey(mPtr, key->second);
if (evt.substr(0, 7) == "sound: ")
{
MWBase::SoundManager* sndMgr = MWBase::Environment::get().getSoundManager();
sndMgr->playSound3D(mPtr, ESM::RefId::stringRefId(evt.substr(7)), 1.0f, 1.0f);
return;
}
auto& charClass = mPtr.getClass();
if (evt.substr(0, 10) == "soundgen: ")
{
std::string_view soundgen = evt.substr(10);
// The event can optionally contain volume and pitch modifiers
float volume = 1.0f;
float pitch = 1.0f;
if (soundgen.find(' ') != std::string::npos)
{
std::vector<std::string_view> tokens;
Misc::StringUtils::split(soundgen, tokens);
soundgen = tokens[0];
if (tokens.size() >= 2)
{
volume = Misc::StringUtils::toNumeric<float>(tokens[1], volume);
}
if (tokens.size() >= 3)
{
pitch = Misc::StringUtils::toNumeric<float>(tokens[2], pitch);
}
}
const ESM::RefId sound = charClass.getSoundIdFromSndGen(mPtr, soundgen);
if (!sound.empty())
{
MWBase::SoundManager* sndMgr = MWBase::Environment::get().getSoundManager();
if (soundgen == "left" || soundgen == "right")
{
sndMgr->playSound3D(
mPtr, sound, volume, pitch, MWSound::Type::Foot, MWSound::PlayMode::NoPlayerLocal);
}
else
{
sndMgr->playSound3D(mPtr, sound, volume, pitch);
}
}
return;
}
if (evt.substr(0, groupname.size()) != groupname || evt.substr(groupname.size(), 2) != ": ")
{
// Not ours, skip it
return;
}
std::string_view action = evt.substr(groupname.size() + 2);
if (action == "equip attach")
{
if (mUpperBodyState == UpperBodyState::Equipping)
{
if (groupname == "shield")
mAnimation->showCarriedLeft(true);
else
mAnimation->showWeapons(true);
}
}
else if (action == "unequip detach")
{
if (mUpperBodyState == UpperBodyState::Unequipping)
{
if (groupname == "shield")
mAnimation->showCarriedLeft(false);
else
mAnimation->showWeapons(false);
}
}
else if (action == "chop hit" || action == "slash hit" || action == "thrust hit" || action == "hit")
{
int attackType = -1;
if (action == "hit")
{
if (groupname == "attack1" || groupname == "swimattack1")
attackType = ESM::Weapon::AT_Chop;
else if (groupname == "attack2" || groupname == "swimattack2")
attackType = ESM::Weapon::AT_Slash;
else if (groupname == "attack3" || groupname == "swimattack3")
attackType = ESM::Weapon::AT_Thrust;
}
else if (action == "chop hit")
attackType = ESM::Weapon::AT_Chop;
else if (action == "slash hit")
attackType = ESM::Weapon::AT_Slash;
else if (action == "thrust hit")
attackType = ESM::Weapon::AT_Thrust;
// We want to avoid hit keys that come out of nowhere (e.g. in the follow animation)
// and processing multiple hit keys for a single attack
if (mAttackStrength != -1.f)
{
charClass.hit(mPtr, mAttackStrength, attackType, mAttackVictim, mAttackHitPos, mAttackSuccess);
mAttackStrength = -1.f;
}
}
else if (isRandomAttackAnimation(groupname) && action == "start")
{
std::multimap<float, std::string>::const_iterator hitKey = key;
// Not all animations have a hit key defined. If there is none, the hit happens with the start key.
bool hasHitKey = false;
while (hitKey != map.end())
{
if (hitKey->second.starts_with(groupname))
{
std::string_view suffix = std::string_view(hitKey->second).substr(groupname.size());
if (suffix == ": hit")
{
hasHitKey = true;
break;
}
if (suffix == ": stop")
break;
}
++hitKey;
}
if (!hasHitKey)
{
// State update doesn't expect the start key to be the hit key,
// so we have to do this early.
prepareHit();
if (groupname == "attack1" || groupname == "swimattack1")
charClass.hit(
mPtr, mAttackStrength, ESM::Weapon::AT_Chop, mAttackVictim, mAttackHitPos, mAttackSuccess);
else if (groupname == "attack2" || groupname == "swimattack2")
charClass.hit(
mPtr, mAttackStrength, ESM::Weapon::AT_Slash, mAttackVictim, mAttackHitPos, mAttackSuccess);
else if (groupname == "attack3" || groupname == "swimattack3")
charClass.hit(
mPtr, mAttackStrength, ESM::Weapon::AT_Thrust, mAttackVictim, mAttackHitPos, mAttackSuccess);
}
}
else if (action == "shoot attach")
mAnimation->attachArrow();
else if (action == "shoot release")
{
// See notes for melee release above
if (mAttackStrength != -1.f)
{
mAnimation->releaseArrow(mAttackStrength);
mAttackStrength = -1.f;
}
}
else if (action == "shoot follow attach")
mAnimation->attachArrow();
// Make sure this key is actually for the RangeType we are casting. The flame atronach has
// the same animation for all range types, so there are 3 "release" keys on the same time, one for each range
// type.
else if (groupname == "spellcast" && action == mAttackType + " release")
{
if (mCanCast)
MWBase::Environment::get().getWorld()->castSpell(mPtr, mCastingScriptedSpell);
mCastingScriptedSpell = false;
mCanCast = false;
}
else if (groupname == "containeropen" && action == "loot")
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Container, mPtr);
}
void CharacterController::updatePtr(const MWWorld::Ptr& ptr)
{
mPtr = ptr;
}
void CharacterController::updateIdleStormState(bool inwater) const
{
if (!mAnimation->hasAnimation("idlestorm"))
return;
bool animPlaying = mAnimation->isPlaying("idlestorm");
if (mUpperBodyState != UpperBodyState::None || inwater)
{
if (animPlaying)
mAnimation->disable("idlestorm");
return;
}
const auto world = MWBase::Environment::get().getWorld();
if (world->isInStorm())
{
osg::Vec3f stormDirection = world->getStormDirection();
osg::Vec3f characterDirection = mPtr.getRefData().getBaseNode()->getAttitude() * osg::Vec3f(0, 1, 0);
stormDirection.normalize();
characterDirection.normalize();
if (stormDirection * characterDirection < -0.5f)
{
if (!animPlaying)
{
int mask = MWRender::BlendMask_Torso | MWRender::BlendMask_RightArm;
playBlendedAnimation("idlestorm", Priority_Storm, mask, true, 1.0f, "start", "stop", 0.0f,
std::numeric_limits<uint32_t>::max(), true);
}
else
{
mAnimation->setLoopingEnabled("idlestorm", true);
}
return;
}
}
if (animPlaying)
{
mAnimation->setLoopingEnabled("idlestorm", false);
}
}
bool CharacterController::updateCarriedLeftVisible(const int weaptype) const
{
// Shields/torches shouldn't be visible during any operation involving two hands
// There seems to be no text keys for this purpose, except maybe for "[un]equip start/stop",
// but they are also present in weapon drawing animation.
return mAnimation->updateCarriedLeftVisible(weaptype);
}
float CharacterController::calculateWindUp() const
{
if (mCurrentWeapon.empty() || mWeaponType == ESM::Weapon::PickProbe || isRandomAttackAnimation(mCurrentWeapon))
return -1.f;
float minAttackTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + " min attack");
float maxAttackTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + " max attack");
if (minAttackTime == -1.f || minAttackTime >= maxAttackTime)
return -1.f;
return std::clamp(
(mAnimation->getCurrentTime(mCurrentWeapon) - minAttackTime) / (maxAttackTime - minAttackTime), 0.f, 1.f);
}
void CharacterController::prepareHit()
{
if (mAttackStrength != -1.f)
return;
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
mAttackStrength = calculateWindUp();
if (mAttackStrength == -1.f)
mAttackStrength = std::min(1.f, 0.1f + Misc::Rng::rollClosedProbability(prng));
ESM::WeaponType::Class weapclass = getWeaponType(mWeaponType)->mWeaponClass;
if (weapclass != ESM::WeaponType::Ranged && weapclass != ESM::WeaponType::Thrown)
{
mAttackSuccess = mPtr.getClass().evaluateHit(mPtr, mAttackVictim, mAttackHitPos);
if (!mAttackSuccess)
mAttackStrength = 0.f;
playSwishSound();
}
}
bool CharacterController::updateWeaponState()
{
// If the current animation is scripted, we can't do anything here.
if (isScriptedAnimPlaying())
return false;
const auto world = MWBase::Environment::get().getWorld();
auto& prng = world->getPrng();
MWBase::SoundManager* sndMgr = MWBase::Environment::get().getSoundManager();
const MWWorld::Class& cls = mPtr.getClass();
CreatureStats& stats = cls.getCreatureStats(mPtr);
int weaptype = ESM::Weapon::None;
if (stats.getDrawState() == DrawState::Weapon)
weaptype = ESM::Weapon::HandToHand;
else if (stats.getDrawState() == DrawState::Spell)
weaptype = ESM::Weapon::Spell;
const bool isWerewolf = cls.isNpc() && cls.getNpcStats(mPtr).isWerewolf();
const ESM::RefId* downSoundId = nullptr;
bool weaponChanged = false;
bool ammunition = true;
float weapSpeed = 1.f;
if (cls.hasInventoryStore(mPtr))
{
MWWorld::InventoryStore& inv = cls.getInventoryStore(mPtr);
MWWorld::ContainerStoreIterator weapon = getActiveWeapon(mPtr, &weaptype);
if (stats.getDrawState() == DrawState::Spell)
weapon = inv.getSlot(MWWorld::InventoryStore::Slot_CarriedRight);
MWWorld::Ptr newWeapon;
if (weapon != inv.end())
{
newWeapon = *weapon;
if (isRealWeapon(mWeaponType))
downSoundId = &newWeapon.getClass().getDownSoundId(newWeapon);
}
// weapon->HtH switch: weapon is empty already, so we need to take sound from previous weapon
else if (!mWeapon.isEmpty() && weaptype == ESM::Weapon::HandToHand && mWeaponType != ESM::Weapon::Spell)
downSoundId = &mWeapon.getClass().getDownSoundId(mWeapon);
if (mWeapon != newWeapon)
{
mWeapon = newWeapon;
weaponChanged = true;
}
if (stats.getDrawState() == DrawState::Weapon && !mWeapon.isEmpty()
&& mWeapon.getType() == ESM::Weapon::sRecordId)
{
weapSpeed = mWeapon.get<ESM::Weapon>()->mBase->mData.mSpeed;
MWWorld::ConstContainerStoreIterator ammo = inv.getSlot(MWWorld::InventoryStore::Slot_Ammunition);
int ammotype = getWeaponType(mWeapon.get<ESM::Weapon>()->mBase->mData.mType)->mAmmoType;
if (ammotype != ESM::Weapon::None)
ammunition = ammo != inv.end() && ammo->get<ESM::Weapon>()->mBase->mData.mType == ammotype;
// Cancel attack if we no longer have ammunition
if (!ammunition)
{
if (mUpperBodyState == UpperBodyState::AttackWindUp)
{
mAnimation->disable(mCurrentWeapon);
mUpperBodyState = UpperBodyState::WeaponEquipped;
}
setAttackingOrSpell(false);
}
}
MWWorld::ConstContainerStoreIterator torch = inv.getSlot(MWWorld::InventoryStore::Slot_CarriedLeft);
if (torch != inv.end() && torch->getType() == ESM::Light::sRecordId
&& updateCarriedLeftVisible(mWeaponType))
{
if (mAnimation->isPlaying("shield"))
mAnimation->disable("shield");
playBlendedAnimation("torch", Priority_Torch, MWRender::BlendMask_LeftArm, false, 1.0f, "start", "stop",
0.0f, std::numeric_limits<uint32_t>::max(), true);
}
else if (mAnimation->isPlaying("torch"))
{
mAnimation->disable("torch");
}
}
// For biped actors, blend weapon animations with lower body animations with higher priority
MWRender::Animation::AnimPriority priorityWeapon(Priority_Weapon);
if (cls.isBipedal(mPtr))
priorityWeapon[MWRender::BoneGroup_LowerBody] = Priority_WeaponLowerBody;
bool forcestateupdate = false;
// We should not play equipping animation and sound during weapon->weapon transition
const bool isStillWeapon = isRealWeapon(mWeaponType) && isRealWeapon(weaptype);
// If the current weapon type was changed in the middle of attack (e.g. by Equip console command or when bound
// spell expires), we should force actor to the "weapon equipped" state, interrupt attack and update animations.
if (isStillWeapon && mWeaponType != weaptype && mUpperBodyState > UpperBodyState::WeaponEquipped)
{
forcestateupdate = true;
if (!mCurrentWeapon.empty())
mAnimation->disable(mCurrentWeapon);
mUpperBodyState = UpperBodyState::WeaponEquipped;
setAttackingOrSpell(false);
mAnimation->showWeapons(true);
}
if (!isKnockedOut() && !isKnockedDown() && !isRecovery())
{
std::string weapgroup;
if ((!isWerewolf || mWeaponType != ESM::Weapon::Spell) && weaptype != mWeaponType
&& mUpperBodyState <= UpperBodyState::AttackWindUp && mUpperBodyState != UpperBodyState::Unequipping
&& !isStillWeapon)
{
// We can not play un-equip animation if weapon changed since last update
if (!weaponChanged)
{
// Note: we do not disable unequipping animation automatically to avoid body desync
weapgroup = getWeaponAnimation(mWeaponType);
int unequipMask = MWRender::BlendMask_All;
bool useShieldAnims = mAnimation->useShieldAnimations();
if (useShieldAnims && mWeaponType != ESM::Weapon::HandToHand && mWeaponType != ESM::Weapon::Spell
&& !(mWeaponType == ESM::Weapon::None && weaptype == ESM::Weapon::Spell))
{
unequipMask = unequipMask | ~MWRender::BlendMask_LeftArm;
playBlendedAnimation("shield", Priority_Block, MWRender::BlendMask_LeftArm, true, 1.0f,
"unequip start", "unequip stop", 0.0f, 0);
}
else if (mWeaponType == ESM::Weapon::HandToHand)
mAnimation->showCarriedLeft(false);
playBlendedAnimation(
weapgroup, priorityWeapon, unequipMask, false, 1.0f, "unequip start", "unequip stop", 0.0f, 0);
mUpperBodyState = UpperBodyState::Unequipping;
mAnimation->detachArrow();
// If we do not have the "unequip detach" key, hide weapon manually.
if (mAnimation->getTextKeyTime(weapgroup + ": unequip detach") < 0)
mAnimation->showWeapons(false);
}
if (downSoundId && !downSoundId->empty())
{
sndMgr->playSound3D(mPtr, *downSoundId, 1.0f, 1.0f);
}
}
float complete;
bool animPlaying = mAnimation->getInfo(mCurrentWeapon, &complete);
if (!animPlaying || complete >= 1.0f)
{
// Weapon is changed, no current animation (e.g. unequipping or attack).
// Start equipping animation now.
if (weaptype != mWeaponType && mUpperBodyState <= UpperBodyState::WeaponEquipped)
{
forcestateupdate = true;
bool useShieldAnims = mAnimation->useShieldAnimations();
if (!useShieldAnims)
mAnimation->showCarriedLeft(updateCarriedLeftVisible(weaptype));
weapgroup = getWeaponAnimation(weaptype);
// Note: controllers for ranged weapon should use time for beginning of animation to play shooting
// properly, for other weapons they should use absolute time. Some mods rely on this behaviour (to
// rotate throwing projectiles, for example)
ESM::WeaponType::Class weaponClass = getWeaponType(weaptype)->mWeaponClass;
bool useRelativeDuration = weaponClass == ESM::WeaponType::Ranged;
mAnimation->setWeaponGroup(weapgroup, useRelativeDuration);
if (!isStillWeapon)
{
if (animPlaying)
mAnimation->disable(mCurrentWeapon);
if (weaptype != ESM::Weapon::None)
{
mAnimation->showWeapons(false);
int equipMask = MWRender::BlendMask_All;
if (useShieldAnims && weaptype != ESM::Weapon::Spell)
{
equipMask = equipMask | ~MWRender::BlendMask_LeftArm;
playBlendedAnimation("shield", Priority_Block, MWRender::BlendMask_LeftArm, true, 1.0f,
"equip start", "equip stop", 0.0f, 0);
}
playBlendedAnimation(
weapgroup, priorityWeapon, equipMask, true, 1.0f, "equip start", "equip stop", 0.0f, 0);
mUpperBodyState = UpperBodyState::Equipping;
// If we do not have the "equip attach" key, show weapon manually.
if (weaptype != ESM::Weapon::Spell
&& mAnimation->getTextKeyTime(weapgroup + ": equip attach") < 0)
{
mAnimation->showWeapons(true);
}
if (!mWeapon.isEmpty() && mWeaponType != ESM::Weapon::HandToHand && isRealWeapon(weaptype))
{
const ESM::RefId& upSoundId = mWeapon.getClass().getUpSoundId(mWeapon);
if (!upSoundId.empty())
sndMgr->playSound3D(mPtr, upSoundId, 1.0f, 1.0f);
}
}
}
if (isWerewolf)
{
const MWWorld::ESMStore& store = world->getStore();
const ESM::Sound* sound = store.get<ESM::Sound>().searchRandom("WolfEquip", prng);
if (sound)
{
sndMgr->playSound3D(mPtr, sound->mId, 1.0f, 1.0f);
}
}
mWeaponType = weaptype;
mCurrentWeapon = weapgroup;
}
// Make sure that we disabled unequipping animation
if (mUpperBodyState == UpperBodyState::Unequipping)
{
resetCurrentWeaponState();
mWeaponType = ESM::Weapon::None;
}
}
}
if (isWerewolf)
{
const ESM::RefId wolfRun = ESM::RefId::stringRefId("WolfRun");
if (isRunning() && !world->isSwimming(mPtr) && mWeaponType == ESM::Weapon::None)
{
if (!sndMgr->getSoundPlaying(mPtr, wolfRun))
sndMgr->playSound3D(mPtr, wolfRun, 1.0f, 1.0f, MWSound::Type::Sfx, MWSound::PlayMode::Loop);
}
else
sndMgr->stopSound3D(mPtr, wolfRun);
}
float complete = 0.f;
bool animPlaying = false;
ESM::WeaponType::Class weapclass = getWeaponType(mWeaponType)->mWeaponClass;
if (getAttackingOrSpell())
{
bool resetIdle = true;
if (mUpperBodyState == UpperBodyState::WeaponEquipped
&& (mHitState == CharState_None || mHitState == CharState_Block))
{
mAttackStrength = -1.f;
// Randomize attacks for non-bipedal creatures
if (!cls.isBipedal(mPtr)
&& (!mAnimation->hasAnimation(mCurrentWeapon) || isRandomAttackAnimation(mCurrentWeapon)))
{
mCurrentWeapon = chooseRandomAttackAnimation();
}
if (mWeaponType == ESM::Weapon::Spell)
{
// Unset casting flag, otherwise pressing the mouse button down would
// continue casting every frame if there is no animation
setAttackingOrSpell(false);
if (mPtr == getPlayer())
{
// For the player, set the spell we want to cast
// This has to be done at the start of the casting animation,
// *not* when selecting a spell in the GUI (otherwise you could change the spell mid-animation)
const ESM::RefId& selectedSpell
= MWBase::Environment::get().getWindowManager()->getSelectedSpell();
stats.getSpells().setSelectedSpell(selectedSpell);
}
ESM::RefId spellid = stats.getSpells().getSelectedSpell();
bool isMagicItem = false;
// Play hand VFX and allow castSpell use (assuming an animation is going to be played) if
// spellcasting is successful. Scripted spellcasting bypasses restrictions.
MWWorld::SpellCastState spellCastResult = MWWorld::SpellCastState::Success;
if (!mCastingScriptedSpell)
spellCastResult = world->startSpellCast(mPtr);
mCanCast = spellCastResult == MWWorld::SpellCastState::Success;
if (spellid.empty() && cls.hasInventoryStore(mPtr))
{
MWWorld::InventoryStore& inv = cls.getInventoryStore(mPtr);
if (inv.getSelectedEnchantItem() != inv.end())
{
const MWWorld::Ptr& enchantItem = *inv.getSelectedEnchantItem();
spellid = enchantItem.getClass().getEnchantment(enchantItem);
isMagicItem = true;
}
}
if (isMagicItem && !Settings::game().mUseMagicItemAnimations)
{
world->breakInvisibility(mPtr);
// Enchanted items by default do not use casting animations
world->castSpell(mPtr);
resetIdle = false;
// Spellcasting animation needs to "play" for at least one frame to reset the aiming factor
animPlaying = true;
mUpperBodyState = UpperBodyState::Casting;
}
// Play the spellcasting animation/VFX if the spellcasting was successful or failed due to
// insufficient magicka. Used up powers are exempt from this from some reason.
else if (!spellid.empty() && spellCastResult != MWWorld::SpellCastState::PowerAlreadyUsed)
{
world->breakInvisibility(mPtr);
MWMechanics::CastSpell cast(mPtr, {}, false, mCastingScriptedSpell);
const std::vector<ESM::IndexedENAMstruct>* effects{ nullptr };
const MWWorld::ESMStore& store = world->getStore();
if (isMagicItem)
{
const ESM::Enchantment* enchantment = store.get<ESM::Enchantment>().find(spellid);
effects = &enchantment->mEffects.mList;
cast.playSpellCastingEffects(enchantment);
}
else
{
const ESM::Spell* spell = store.get<ESM::Spell>().find(spellid);
effects = &spell->mEffects.mList;
cast.playSpellCastingEffects(spell);
}
if (!effects->empty())
{
if (mCanCast)
{
const ESM::MagicEffect* effect = store.get<ESM::MagicEffect>().find(
effects->back().mData.mEffectID); // use last effect of list for color of VFX_Hands
const ESM::Static* castStatic
= world->getStore().get<ESM::Static>().find(ESM::RefId::stringRefId("VFX_Hands"));
if (mAnimation->getNode("Bip01 L Hand"))
mAnimation->addEffect(Misc::ResourceHelpers::correctMeshPath(castStatic->mModel),
"", false, "Bip01 L Hand", effect->mParticle);
if (mAnimation->getNode("Bip01 R Hand"))
mAnimation->addEffect(Misc::ResourceHelpers::correctMeshPath(castStatic->mModel),
"", false, "Bip01 R Hand", effect->mParticle);
}
// first effect used for casting animation
const ESM::ENAMstruct& firstEffect = effects->front().mData;
std::string startKey;
std::string stopKey;
if (isRandomAttackAnimation(mCurrentWeapon))
{
startKey = "start";
stopKey = "stop";
if (mCanCast)
world->castSpell(mPtr,
mCastingScriptedSpell); // No "release" text key to use, so cast immediately
mCastingScriptedSpell = false;
mCanCast = false;
}
else
{
switch (firstEffect.mRange)
{
case 0:
mAttackType = "self";
break;
case 1:
mAttackType = "touch";
break;
case 2:
mAttackType = "target";
break;
}
startKey = mAttackType + " start";
stopKey = mAttackType + " stop";
}
playBlendedAnimation(mCurrentWeapon, priorityWeapon, MWRender::BlendMask_All, false, 1,
startKey, stopKey, 0.0f, 0);
mUpperBodyState = UpperBodyState::Casting;
}
}
else
{
resetIdle = false;
}
}
else
{
std::string startKey = "start";
std::string stopKey = "stop";
MWBase::LuaManager::ActorControls* actorControls
= MWBase::Environment::get().getLuaManager()->getActorControls(mPtr);
const bool aiInactive
= actorControls->mDisableAI || !MWBase::Environment::get().getMechanicsManager()->isAIActive();
if (mWeaponType != ESM::Weapon::PickProbe && !isRandomAttackAnimation(mCurrentWeapon))
{
if (weapclass == ESM::WeaponType::Ranged || weapclass == ESM::WeaponType::Thrown)
mAttackType = "shoot";
else if (mPtr == getPlayer())
{
if (Settings::game().mBestAttack)
{
if (!mWeapon.isEmpty() && mWeapon.getType() == ESM::Weapon::sRecordId)
{
mAttackType = getBestAttack(mWeapon.get<ESM::Weapon>()->mBase);
}
else
{
// There is no "best attack" for Hand-to-Hand
mAttackType = getRandomAttackType();
}
}
else
{
mAttackType = getMovementBasedAttackType();
}
}
else if (aiInactive)
{
mAttackType = getDesiredAttackType();
if (mAttackType == "")
mAttackType = getRandomAttackType();
}
// else if (mPtr != getPlayer()) use mAttackType set by AiCombat
startKey = mAttackType + ' ' + startKey;
stopKey = mAttackType + " max attack";
}
mUpperBodyState = UpperBodyState::AttackWindUp;
// Reset the attack results when the attack starts.
// Strictly speaking this should probably be done when the attack ends,
// but the attack animation might be cancelled in a myriad different ways.
mAttackSuccess = false;
mAttackVictim = MWWorld::Ptr();
mAttackHitPos = osg::Vec3f();
playBlendedAnimation(mCurrentWeapon, priorityWeapon, MWRender::BlendMask_All, false, weapSpeed,
startKey, stopKey, 0.0f, 0);
}
}
// We should not break swim and sneak animations
if (resetIdle && mIdleState != CharState_IdleSneak && mIdleState != CharState_IdleSwim)
{
resetCurrentIdleState();
}
}
// Random attack and pick/probe animations never have wind up and are played to their end.
// Other animations must be released when the attack state is unset.
if (mUpperBodyState == UpperBodyState::AttackWindUp
&& (mWeaponType == ESM::Weapon::PickProbe || isRandomAttackAnimation(mCurrentWeapon)
|| !getAttackingOrSpell()))
{
mUpperBodyState = UpperBodyState::AttackRelease;
world->breakInvisibility(mPtr);
if (mWeaponType == ESM::Weapon::PickProbe)
{
// TODO: this will only work for the player, and needs to be fixed if NPCs should ever use
// lockpicks/probes.
MWWorld::Ptr target = world->getFacedObject();
if (!target.isEmpty())
{
std::string_view resultMessage, resultSound;
if (mWeapon.getType() == ESM::Lockpick::sRecordId)
Security(mPtr).pickLock(target, mWeapon, resultMessage, resultSound);
else if (mWeapon.getType() == ESM::Probe::sRecordId)
Security(mPtr).probeTrap(target, mWeapon, resultMessage, resultSound);
if (!resultMessage.empty())
MWBase::Environment::get().getWindowManager()->messageBox(resultMessage);
if (!resultSound.empty())
sndMgr->playSound3D(target, ESM::RefId::stringRefId(resultSound), 1.0f, 1.0f);
}
}
// Evaluate the attack results and play the swish sound.
// Attack animations with no hit key do this earlier.
else
{
prepareHit();
}
if (mWeaponType == ESM::Weapon::PickProbe || isRandomAttackAnimation(mCurrentWeapon))
mUpperBodyState = UpperBodyState::AttackEnd;
}
if (mUpperBodyState == UpperBodyState::AttackRelease)
{
// The release state might have been reached before reaching the wind-up section. We'll play the new section
// only when the wind-up section is reached.
float currentTime = mAnimation->getCurrentTime(mCurrentWeapon);
float minAttackTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + " min attack");
float maxAttackTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + " max attack");
if (minAttackTime <= currentTime && currentTime <= maxAttackTime)
{
std::string hit = mAttackType != "shoot" ? "hit" : "release";
float startPoint = 0.f;
// Skip a bit of the pre-hit section based on the attack strength
if (minAttackTime != -1.f && minAttackTime < maxAttackTime)
{
startPoint = 1.f - mAttackStrength;
float minHitTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + " min hit");
float hitTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + ' ' + hit);
if (maxAttackTime <= minHitTime && minHitTime < hitTime)
startPoint *= (minHitTime - maxAttackTime) / (hitTime - maxAttackTime);
}
mAnimation->disable(mCurrentWeapon);
playBlendedAnimation(mCurrentWeapon, priorityWeapon, MWRender::BlendMask_All, false, weapSpeed,
mAttackType + " max attack", mAttackType + ' ' + hit, startPoint, 0);
}
animPlaying = mAnimation->getInfo(mCurrentWeapon, &complete);
// Try playing the "follow" section if the attack animation ended naturally or didn't play at all.
if (!animPlaying || (currentTime >= maxAttackTime && complete >= 1.f))
{
std::string start = "follow start";
std::string stop = "follow stop";
if (mAttackType != "shoot")
{
std::string strength = mAttackStrength < 0.33f ? "small"
: mAttackStrength < 0.66f ? "medium"
: "large";
start = strength + ' ' + start;
stop = strength + ' ' + stop;
}
// Reset attack strength to make extra sure hits that come out of nowhere aren't processed
mAttackStrength = -1.f;
if (animPlaying)
mAnimation->disable(mCurrentWeapon);
MWRender::Animation::AnimPriority priorityFollow(priorityWeapon);
// Follow animations have lower priority than movement for non-biped creatures, logic be damned
if (!cls.isBipedal(mPtr))
priorityFollow = Priority_Default;
playBlendedAnimation(mCurrentWeapon, priorityFollow, MWRender::BlendMask_All, false, weapSpeed,
mAttackType + ' ' + start, mAttackType + ' ' + stop, 0.0f, 0);
mUpperBodyState = UpperBodyState::AttackEnd;
animPlaying = mAnimation->getInfo(mCurrentWeapon, &complete);
}
}
if (!animPlaying)
animPlaying = mAnimation->getInfo(mCurrentWeapon, &complete);
if (!animPlaying || complete >= 1.f)
{
if (mUpperBodyState == UpperBodyState::Equipping || mUpperBodyState == UpperBodyState::AttackEnd
|| mUpperBodyState == UpperBodyState::Casting)
{
if (ammunition && mWeaponType == ESM::Weapon::MarksmanCrossbow)
mAnimation->attachArrow();
// Cancel stagger animation at the end of an attack to avoid abrupt transitions
// in favor of a different abrupt transition, like Morrowind
if (mUpperBodyState != UpperBodyState::Equipping && isRecovery())
mAnimation->disable(mCurrentHit);
if (animPlaying)
mAnimation->disable(mCurrentWeapon);
mUpperBodyState = UpperBodyState::WeaponEquipped;
}
else if (mUpperBodyState == UpperBodyState::Unequipping)
{
if (animPlaying)
mAnimation->disable(mCurrentWeapon);
mUpperBodyState = UpperBodyState::None;
}
}
mAnimation->setPitchFactor(0.f);
if (mUpperBodyState > UpperBodyState::WeaponEquipped
&& (weapclass == ESM::WeaponType::Ranged || weapclass == ESM::WeaponType::Thrown))
{
mAnimation->setPitchFactor(1.f);
// A smooth transition can be provided if a pre-wind-up section is defined. Random attack animations never
// have one.
if (mUpperBodyState == UpperBodyState::AttackWindUp && !isRandomAttackAnimation(mCurrentWeapon))
{
float currentTime = mAnimation->getCurrentTime(mCurrentWeapon);
float minAttackTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + " min attack");
float startTime = mAnimation->getTextKeyTime(mCurrentWeapon + ": " + mAttackType + " start");
if (startTime <= currentTime && currentTime < minAttackTime)
mAnimation->setPitchFactor((currentTime - startTime) / (minAttackTime - startTime));
}
else if (mUpperBodyState == UpperBodyState::AttackEnd)
{
// technically we do not need a pitch for crossbow reload animation,
// but we should avoid abrupt repositioning
if (mWeaponType == ESM::Weapon::MarksmanCrossbow)
mAnimation->setPitchFactor(std::max(0.f, 1.f - complete * 10.f));
else
mAnimation->setPitchFactor(1.f - complete);
}
}
mAnimation->setAccurateAiming(mUpperBodyState > UpperBodyState::WeaponEquipped);
return forcestateupdate;
}
void CharacterController::updateAnimQueue()
{
if (mAnimQueue.empty())
return;
if (!mAnimation->isPlaying(mAnimQueue.front().mGroup))
{
// Playing animations through mwscript is weird. If an animation is
// a looping animation (idle or other cyclical animations), then they
// will end as expected. However, if they are non-looping animations, they
// will stick around forever or until another animation appears in the queue.
bool shouldPlayOrRestart = mAnimQueue.size() > 1;
if (shouldPlayOrRestart || !mAnimQueue.front().mScripted
|| (mAnimQueue.front().mLoopCount == 0 && mAnimQueue.front().mLooping))
{
mAnimation->setPlayScriptedOnly(false);
mAnimation->disable(mAnimQueue.front().mGroup);
mAnimQueue.pop_front();
shouldPlayOrRestart = true;
}
else
// A non-looping animation will stick around forever, so only restart if the animation
// actually was removed for some reason.
shouldPlayOrRestart = !mAnimation->getInfo(mAnimQueue.front().mGroup)
&& mAnimation->hasAnimation(mAnimQueue.front().mGroup);
if (shouldPlayOrRestart)
{
// Move on to the remaining items of the queue
playAnimQueue();
}
}
else
{
float complete;
size_t loopcount;
mAnimation->getInfo(mAnimQueue.front().mGroup, &complete, nullptr, &loopcount);
mAnimQueue.front().mLoopCount = loopcount;
mAnimQueue.front().mTime = complete;
}
if (!mAnimQueue.empty())
mAnimation->setLoopingEnabled(mAnimQueue.front().mGroup, mAnimQueue.size() <= 1);
}
void CharacterController::playAnimQueue(bool loopStart)
{
if (!mAnimQueue.empty())
{
clearStateAnimation(mCurrentIdle);
mIdleState = CharState_SpecialIdle;
auto priority = mAnimQueue.front().mScripted ? Priority_Scripted : Priority_Default;
mAnimation->setPlayScriptedOnly(mAnimQueue.front().mScripted);
if (mAnimQueue.front().mScripted)
mAnimation->play(mAnimQueue.front().mGroup, priority, MWRender::BlendMask_All, false,
mAnimQueue.front().mSpeed, (loopStart ? "loop start" : mAnimQueue.front().mStartKey),
mAnimQueue.front().mStopKey, mAnimQueue.front().mTime, mAnimQueue.front().mLoopCount,
mAnimQueue.front().mLooping);
else
playBlendedAnimation(mAnimQueue.front().mGroup, priority, MWRender::BlendMask_All, false,
mAnimQueue.front().mSpeed, (loopStart ? "loop start" : mAnimQueue.front().mStartKey),
mAnimQueue.front().mStopKey, mAnimQueue.front().mTime, mAnimQueue.front().mLoopCount,
mAnimQueue.front().mLooping);
}
}
void CharacterController::update(float duration)
{
MWBase::World* world = MWBase::Environment::get().getWorld();
MWBase::SoundManager* sndMgr = MWBase::Environment::get().getSoundManager();
const MWWorld::Class& cls = mPtr.getClass();
osg::Vec3f movement(0.f, 0.f, 0.f);
float speed = 0.f;
updateMagicEffects();
bool isPlayer = mPtr == MWMechanics::getPlayer();
bool isFirstPersonPlayer = isPlayer && MWBase::Environment::get().getWorld()->isFirstPerson();
bool godmode = isPlayer && MWBase::Environment::get().getWorld()->getGodModeState();
float scale = mPtr.getCellRef().getScale();
if (!Settings::game().mNormaliseRaceSpeed && cls.isNpc())
{
const ESM::NPC* npc = mPtr.get<ESM::NPC>()->mBase;
const ESM::Race* race = world->getStore().get<ESM::Race>().find(npc->mRace);
float weight = npc->isMale() ? race->mData.mMaleWeight : race->mData.mFemaleWeight;
scale *= weight;
}
if (cls.isActor() && cls.getCreatureStats(mPtr).wasTeleported())
{
mSmoothedSpeed = osg::Vec2f();
cls.getCreatureStats(mPtr).setTeleported(false);
}
if (!cls.isActor())
updateAnimQueue();
else if (!cls.getCreatureStats(mPtr).isDead())
{
bool onground = world->isOnGround(mPtr);
bool inwater = world->isSwimming(mPtr);
bool flying = world->isFlying(mPtr);
bool solid = world->isActorCollisionEnabled(mPtr);
// Can't run and sneak while flying (see speed formula in Npc/Creature::getSpeed)
bool sneak
= cls.getCreatureStats(mPtr).getStance(MWMechanics::CreatureStats::Stance_Sneak) && !flying && !inwater;
bool isrunning = cls.getCreatureStats(mPtr).getStance(MWMechanics::CreatureStats::Stance_Run) && !flying;
CreatureStats& stats = cls.getCreatureStats(mPtr);
Movement& movementSettings = cls.getMovementSettings(mPtr);
// Force Jump Logic
bool isMoving
= (std::abs(movementSettings.mPosition[0]) > .5 || std::abs(movementSettings.mPosition[1]) > .5);
if (!inwater && !flying)
{
// Force Jump
if (stats.getMovementFlag(MWMechanics::CreatureStats::Flag_ForceJump))
movementSettings.mPosition[2] = onground ? 1 : 0;
// Force Move Jump, only jump if they're otherwise moving
if (stats.getMovementFlag(MWMechanics::CreatureStats::Flag_ForceMoveJump) && isMoving)
movementSettings.mPosition[2] = onground ? 1 : 0;
}
osg::Vec3f rot = cls.getRotationVector(mPtr);
osg::Vec3f vec(movementSettings.asVec3());
movementSettings.mSpeedFactor = std::min(vec.length(), 1.f);
vec.normalize();
const bool smoothMovement = Settings::game().mSmoothMovement;
if (smoothMovement)
{
float angle = mPtr.getRefData().getPosition().rot[2];
osg::Vec2f targetSpeed
= Misc::rotateVec2f(osg::Vec2f(vec.x(), vec.y()), -angle) * movementSettings.mSpeedFactor;
osg::Vec2f delta = targetSpeed - mSmoothedSpeed;
float speedDelta = movementSettings.mSpeedFactor - mSmoothedSpeed.length();
float deltaLen = delta.length();
float maxDelta;
if (isFirstPersonPlayer)
maxDelta = 1;
else if (std::abs(speedDelta) < deltaLen / 2)
// Turning is smooth for player and less smooth for NPCs (otherwise NPC can miss a path point).
maxDelta = duration * (isPlayer ? 1.0 / Settings::game().mSmoothMovementPlayerTurningDelay : 6.f);
else if (isPlayer && speedDelta < -deltaLen / 2)
// As soon as controls are released, mwinput switches player from running to walking.
// So stopping should be instant for player, otherwise it causes a small twitch.
maxDelta = 1;
else // In all other cases speeding up and stopping are smooth.
maxDelta = duration * 3.f;
if (deltaLen > maxDelta)
delta *= maxDelta / deltaLen;
mSmoothedSpeed += delta;
osg::Vec2f newSpeed = Misc::rotateVec2f(mSmoothedSpeed, angle);
movementSettings.mSpeedFactor = newSpeed.normalize();
vec.x() = newSpeed.x();
vec.y() = newSpeed.y();
const float eps = 0.001f;
if (movementSettings.mSpeedFactor < eps)
{
movementSettings.mSpeedFactor = 0;
vec.x() = 0;
vec.y() = 1;
}
else if ((vec.y() < 0) != mIsMovingBackward)
{
if (targetSpeed.length() < eps || (movementSettings.mPosition[1] < 0) == mIsMovingBackward)
vec.y() = mIsMovingBackward ? -eps : eps;
}
vec.normalize();
}
float effectiveRotation = rot.z();
bool canMove = cls.getMaxSpeed(mPtr) > 0;
const bool turnToMovementDirection = Settings::game().mTurnToMovementDirection;
const bool isBiped = mPtr.getClass().isBipedal(mPtr);
if (!isBiped || !turnToMovementDirection || isFirstPersonPlayer)
{
movementSettings.mIsStrafing = std::abs(vec.x()) > std::abs(vec.y()) * 2;
stats.setSideMovementAngle(0);
}
else if (canMove)
{
float targetMovementAngle
= vec.y() >= 0 ? std::atan2(-vec.x(), vec.y()) : std::atan2(vec.x(), -vec.y());
movementSettings.mIsStrafing = (stats.getDrawState() != MWMechanics::DrawState::Nothing || inwater)
&& std::abs(targetMovementAngle) > osg::DegreesToRadians(60.0f);
if (movementSettings.mIsStrafing)
targetMovementAngle = 0;
float delta = targetMovementAngle - stats.getSideMovementAngle();
float cosDelta = cosf(delta);
if ((vec.y() < 0) == mIsMovingBackward)
movementSettings.mSpeedFactor
*= std::min(std::max(cosDelta, 0.f) + 0.3f, 1.f); // slow down when turn
if (std::abs(delta) < osg::DegreesToRadians(20.0f))
mIsMovingBackward = vec.y() < 0;
float maxDelta = osg::PI * duration * (2.5f - cosDelta);
delta = std::clamp(delta, -maxDelta, maxDelta);
stats.setSideMovementAngle(stats.getSideMovementAngle() + delta);
effectiveRotation += delta;
}
mAnimation->setLegsYawRadians(stats.getSideMovementAngle());
if (stats.getDrawState() == MWMechanics::DrawState::Nothing || inwater)
mAnimation->setUpperBodyYawRadians(stats.getSideMovementAngle() / 2);
else
mAnimation->setUpperBodyYawRadians(stats.getSideMovementAngle() / 4);
if (smoothMovement && !isPlayer && !inwater)
mAnimation->setUpperBodyYawRadians(mAnimation->getUpperBodyYawRadians() + mAnimation->getHeadYaw() / 2);
speed = cls.getCurrentSpeed(mPtr);
vec.x() *= speed;
vec.y() *= speed;
if (isKnockedOut() || isKnockedDown() || isRecovery() || isScriptedAnimPlaying())
vec = osg::Vec3f();
CharacterState movestate = CharState_None;
CharacterState idlestate = CharState_None;
JumpingState jumpstate = JumpState_None;
const MWWorld::Store<ESM::GameSetting>& gmst = world->getStore().get<ESM::GameSetting>();
if (vec.x() != 0.f || vec.y() != 0.f)
{
// advance athletics
if (isPlayer)
{
if (inwater)
{
mSecondsOfSwimming += duration;
while (mSecondsOfSwimming > 1)
{
cls.skillUsageSucceeded(mPtr, ESM::Skill::Athletics, ESM::Skill::Athletics_SwimOneSecond);
mSecondsOfSwimming -= 1;
}
}
else if (isrunning && !sneak)
{
mSecondsOfRunning += duration;
while (mSecondsOfRunning > 1)
{
cls.skillUsageSucceeded(mPtr, ESM::Skill::Athletics, ESM::Skill::Athletics_RunOneSecond);
mSecondsOfRunning -= 1;
}
}
}
if (!godmode)
{
// reduce fatigue
float fatigueLoss = 0.f;
static const float fFatigueRunBase = gmst.find("fFatigueRunBase")->mValue.getFloat();
static const float fFatigueRunMult = gmst.find("fFatigueRunMult")->mValue.getFloat();
static const float fFatigueSwimWalkBase = gmst.find("fFatigueSwimWalkBase")->mValue.getFloat();
static const float fFatigueSwimRunBase = gmst.find("fFatigueSwimRunBase")->mValue.getFloat();
static const float fFatigueSwimWalkMult = gmst.find("fFatigueSwimWalkMult")->mValue.getFloat();
static const float fFatigueSwimRunMult = gmst.find("fFatigueSwimRunMult")->mValue.getFloat();
static const float fFatigueSneakBase = gmst.find("fFatigueSneakBase")->mValue.getFloat();
static const float fFatigueSneakMult = gmst.find("fFatigueSneakMult")->mValue.getFloat();
if (cls.getEncumbrance(mPtr) <= cls.getCapacity(mPtr))
{
const float encumbrance = cls.getNormalizedEncumbrance(mPtr);
if (sneak)
fatigueLoss = fFatigueSneakBase + encumbrance * fFatigueSneakMult;
else
{
if (inwater)
{
if (!isrunning)
fatigueLoss = fFatigueSwimWalkBase + encumbrance * fFatigueSwimWalkMult;
else
fatigueLoss = fFatigueSwimRunBase + encumbrance * fFatigueSwimRunMult;
}
else if (isrunning)
fatigueLoss = fFatigueRunBase + encumbrance * fFatigueRunMult;
}
}
fatigueLoss *= duration;
fatigueLoss *= movementSettings.mSpeedFactor;
DynamicStat<float> fatigue = cls.getCreatureStats(mPtr).getFatigue();
fatigue.setCurrent(fatigue.getCurrent() - fatigueLoss, fatigue.getCurrent() < 0);
cls.getCreatureStats(mPtr).setFatigue(fatigue);
}
}
bool wasInJump = mInJump;
mInJump = false;
const float jumpHeight = cls.getJump(mPtr);
if (jumpHeight <= 0.f || sneak || inwater || flying || !solid)
{
vec.z() = 0.f;
// Following code might assign some vertical movement regardless, need to reset this manually
// This is used for jumping detection
movementSettings.mPosition[2] = 0;
}
if (!inwater && !flying && solid)
{
// In the air (either getting up —ascending part of jump— or falling).
if (!onground)
{
mInJump = true;
jumpstate = JumpState_InAir;
static const float fJumpMoveBase = gmst.find("fJumpMoveBase")->mValue.getFloat();
static const float fJumpMoveMult = gmst.find("fJumpMoveMult")->mValue.getFloat();
float factor = fJumpMoveBase
+ fJumpMoveMult * mPtr.getClass().getSkill(mPtr, ESM::Skill::Acrobatics) / 100.f;
factor = std::min(1.f, factor);
vec.x() *= factor;
vec.y() *= factor;
vec.z() = 0.0f;
}
// Started a jump.
else if (mJumpState != JumpState_InAir && vec.z() > 0.f)
{
mInJump = true;
if (vec.x() == 0 && vec.y() == 0)
vec.z() = jumpHeight;
else
{
osg::Vec3f lat(vec.x(), vec.y(), 0.0f);
lat.normalize();
vec = osg::Vec3f(lat.x(), lat.y(), 1.0f) * jumpHeight * 0.707f;
}
}
}
if (!mInJump)
{
if (mJumpState == JumpState_InAir && !flying && solid && wasInJump)
{
float height = cls.getCreatureStats(mPtr).land(isPlayer);
float healthLost = 0.f;
if (!inwater)
healthLost = getFallDamage(mPtr, height);
if (healthLost > 0.0f)
{
const float fatigueTerm = cls.getCreatureStats(mPtr).getFatigueTerm();
// inflict fall damages
if (!godmode)
{
DynamicStat<float> health = cls.getCreatureStats(mPtr).getHealth();
float realHealthLost = healthLost * (1.0f - 0.25f * fatigueTerm);
health.setCurrent(health.getCurrent() - realHealthLost);
cls.getCreatureStats(mPtr).setHealth(health);
sndMgr->playSound3D(mPtr, ESM::RefId::stringRefId("Health Damage"), 1.0f, 1.0f);
if (isPlayer)
MWBase::Environment::get().getWindowManager()->activateHitOverlay();
}
const float acrobaticsSkill = cls.getSkill(mPtr, ESM::Skill::Acrobatics);
if (healthLost > (acrobaticsSkill * fatigueTerm))
{
if (!godmode)
cls.getCreatureStats(mPtr).setKnockedDown(true);
}
else
{
// report acrobatics progression
if (isPlayer)
cls.skillUsageSucceeded(mPtr, ESM::Skill::Acrobatics, ESM::Skill::Acrobatics_Fall);
}
}
if (mPtr.getClass().isNpc())
{
std::string_view sound;
osg::Vec3f pos(mPtr.getRefData().getPosition().asVec3());
if (world->isUnderwater(mPtr.getCell(), pos) || world->isWalkingOnWater(mPtr))
sound = "DefaultLandWater";
else if (onground)
sound = "DefaultLand";
if (!sound.empty())
sndMgr->playSound3D(mPtr, ESM::RefId::stringRefId(sound), 1.f, 1.f, MWSound::Type::Foot,
MWSound::PlayMode::NoPlayerLocal);
}
}
if (mAnimation->isPlaying(mCurrentJump))
jumpstate = JumpState_Landing;
vec.z() = 0.0f;
if (movementSettings.mIsStrafing)
{
if (vec.x() > 0.0f)
movestate = (inwater ? (isrunning ? CharState_SwimRunRight : CharState_SwimWalkRight)
: (sneak ? CharState_SneakRight
: (isrunning ? CharState_RunRight : CharState_WalkRight)));
else if (vec.x() < 0.0f)
movestate = (inwater
? (isrunning ? CharState_SwimRunLeft : CharState_SwimWalkLeft)
: (sneak ? CharState_SneakLeft : (isrunning ? CharState_RunLeft : CharState_WalkLeft)));
}
else if (vec.length2() > 0.0f)
{
if (vec.y() >= 0.0f)
movestate = (inwater ? (isrunning ? CharState_SwimRunForward : CharState_SwimWalkForward)
: (sneak ? CharState_SneakForward
: (isrunning ? CharState_RunForward : CharState_WalkForward)));
else
movestate = (inwater
? (isrunning ? CharState_SwimRunBack : CharState_SwimWalkBack)
: (sneak ? CharState_SneakBack : (isrunning ? CharState_RunBack : CharState_WalkBack)));
}
else
{
// Do not play turning animation for player if rotation speed is very slow.
// Actual threshold should take framerate in account.
float rotationThreshold = (isPlayer ? 0.015f : 0.001f) * 60 * duration;
// It seems only bipedal actors use turning animations.
// Also do not use turning animations in the first-person view and when sneaking.
if (!sneak && !isFirstPersonPlayer && isBiped)
{
if (effectiveRotation > rotationThreshold)
movestate = inwater ? CharState_SwimTurnRight : CharState_TurnRight;
else if (effectiveRotation < -rotationThreshold)
movestate = inwater ? CharState_SwimTurnLeft : CharState_TurnLeft;
}
}
}
if (turnToMovementDirection && !isFirstPersonPlayer && isBiped
&& (movestate == CharState_SwimRunForward || movestate == CharState_SwimWalkForward
|| movestate == CharState_SwimRunBack || movestate == CharState_SwimWalkBack))
{
float swimmingPitch = mAnimation->getBodyPitchRadians();
float targetSwimmingPitch = -mPtr.getRefData().getPosition().rot[0];
float maxSwimPitchDelta = 3.0f * duration;
swimmingPitch += std::clamp(targetSwimmingPitch - swimmingPitch, -maxSwimPitchDelta, maxSwimPitchDelta);
mAnimation->setBodyPitchRadians(swimmingPitch);
}
else
mAnimation->setBodyPitchRadians(0);
if (inwater && isPlayer && !isFirstPersonPlayer && Settings::game().mSwimUpwardCorrection)
{
const float swimUpwardCoef = Settings::game().mSwimUpwardCoef;
vec.z() = std::abs(vec.y()) * swimUpwardCoef;
vec.y() *= std::sqrt(1.0f - swimUpwardCoef * swimUpwardCoef);
}
// Player can not use smooth turning as NPCs, so we play turning animation a bit to avoid jittering
if (isPlayer)
{
float threshold = mCurrentMovement.find("swim") == std::string::npos ? 0.4f : 0.8f;
float complete;
bool animPlaying = mAnimation->getInfo(mCurrentMovement, &complete);
if (movestate == CharState_None && jumpstate == JumpState_None && isTurning())
{
if (animPlaying && complete < threshold)
movestate = mMovementState;
}
}
else
{
if (isBiped)
{
if (mTurnAnimationThreshold > 0)
mTurnAnimationThreshold -= duration;
if (movestate == CharState_TurnRight || movestate == CharState_TurnLeft
|| movestate == CharState_SwimTurnRight || movestate == CharState_SwimTurnLeft)
{
mTurnAnimationThreshold = 0.05f;
}
else if (movestate == CharState_None && isTurning() && mTurnAnimationThreshold > 0)
{
movestate = mMovementState;
}
}
}
if (movestate != CharState_None)
{
clearAnimQueue();
jumpstate = JumpState_None;
}
updateAnimQueue();
if (!mAnimQueue.empty())
idlestate = CharState_SpecialIdle;
else if (sneak && !mInJump)
idlestate = CharState_IdleSneak;
else
idlestate = CharState_Idle;
if (inwater)
idlestate = CharState_IdleSwim;
if (!mSkipAnim)
{
refreshCurrentAnims(idlestate, movestate, jumpstate, updateWeaponState());
updateIdleStormState(inwater);
}
if (isTurning())
{
// Adjust animation speed from 1.0 to 1.5 multiplier
if (duration > 0)
{
float turnSpeed = std::min(1.5f, std::abs(rot.z()) / duration / static_cast<float>(osg::PI));
mAnimation->adjustSpeedMult(mCurrentMovement, std::max(turnSpeed, 1.0f));
}
}
else if (mMovementState != CharState_None && mAdjustMovementAnimSpeed)
{
// Vanilla caps the played animation speed.
const float maxSpeedMult = 10.f;
const float speedMult = speed / mMovementAnimSpeed;
mAnimation->adjustSpeedMult(mCurrentMovement, std::min(maxSpeedMult, speedMult));
// Make sure the actual speed is the "expected" speed even though the animation is slower
if (isMovementAnimationControlled())
scale *= std::max(1.f, speedMult / maxSpeedMult);
}
if (!mSkipAnim)
{
if (!isKnockedDown() && !isKnockedOut())
{
if (rot != osg::Vec3f())
world->rotateObject(mPtr, rot, true);
}
else // avoid z-rotating for knockdown
{
if (rot.x() != 0 && rot.y() != 0)
{
rot.z() = 0.0f;
world->rotateObject(mPtr, rot, true);
}
}
updateHeadTracking(duration);
}
movement = vec;
movementSettings.mPosition[0] = movementSettings.mPosition[1] = 0;
// Can't reset jump state (mPosition[2]) here in full; we don't know for sure whether the PhysicsSystem will
// actually handle it in this frame due to the fixed minimum timestep used for the physics update. It will
// be reset in PhysicsSystem::move once the jump is handled.
if (movement.z() == 0.f)
movementSettings.mPosition[2] = 0;
}
else if (cls.getCreatureStats(mPtr).isDead())
{
// initial start of death animation for actors that started the game as dead
// not done in constructor since we need to give scripts a chance to set the mSkipAnim flag
if (!mSkipAnim && mDeathState != CharState_None && mCurrentDeath.empty())
{
// Fast-forward death animation to end for persisting corpses or corpses after end of death animation
if (cls.isPersistent(mPtr) || cls.getCreatureStats(mPtr).isDeathAnimationFinished())
playDeath(1.f, mDeathState);
}
}
osg::Vec3f movementFromAnimation
= mAnimation->runAnimation(mSkipAnim && !isScriptedAnimPlaying() ? 0.f : duration);
if (mPtr.getClass().isActor() && !isScriptedAnimPlaying())
{
if (isMovementAnimationControlled())
{
if (duration != 0.f && movementFromAnimation != osg::Vec3f())
{
movementFromAnimation /= duration;
// Ensure we're moving in the right general direction.
// In vanilla, all horizontal movement is taken from animations, even when moving diagonally (which
// doesn't have a corresponding animation). So to achieve diagonal movement, we have to rotate the
// movement taken from the animation to the intended direction.
//
// Note that while a complete movement animation cycle will have a well defined direction, no
// individual frame will, and therefore we have to determine the direction based on the currently
// playing cycle instead.
if (speed > 0.f)
{
float animMovementAngle = getAnimationMovementDirection();
float targetMovementAngle = std::atan2(-movement.x(), movement.y());
float diff = targetMovementAngle - animMovementAngle;
movementFromAnimation = osg::Quat(diff, osg::Vec3f(0, 0, 1)) * movementFromAnimation;
}
movement = movementFromAnimation;
}
else
{
movement = osg::Vec3f();
}
}
else if (mSkipAnim)
{
movement = osg::Vec3f();
}
if (mFloatToSurface && world->isSwimming(mPtr))
{
if (cls.getCreatureStats(mPtr).isDead()
|| (!godmode
&& cls.getCreatureStats(mPtr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Paralyze)
.getModifier()
> 0))
{
movement.z() = 1.0;
}
}
movement.x() *= scale;
movement.y() *= scale;
world->queueMovement(mPtr, movement);
}
mSkipAnim = false;
mAnimation->enableHeadAnimation(cls.isActor() && !cls.getCreatureStats(mPtr).isDead());
}
void CharacterController::persistAnimationState() const
{
ESM::AnimationState& state = mPtr.getRefData().getAnimationState();
state.mScriptedAnims.clear();
for (AnimationQueue::const_iterator iter = mAnimQueue.begin(); iter != mAnimQueue.end(); ++iter)
{
// TODO: Probably want to presist lua animations too
if (!iter->mScripted)
continue;
ESM::AnimationState::ScriptedAnimation anim;
anim.mGroup = iter->mGroup;
if (iter == mAnimQueue.begin())
{
float complete;
size_t loopcount;
mAnimation->getInfo(anim.mGroup, &complete, nullptr, &loopcount);
anim.mTime = complete;
anim.mLoopCount = loopcount;
}
else
{
anim.mLoopCount = iter->mLoopCount;
anim.mTime = 0.f;
}
state.mScriptedAnims.push_back(anim);
}
}
void CharacterController::unpersistAnimationState()
{
const ESM::AnimationState& state = mPtr.getRefData().getAnimationState();
if (!state.mScriptedAnims.empty())
{
clearAnimQueue();
for (ESM::AnimationState::ScriptedAnimations::const_iterator iter = state.mScriptedAnims.begin();
iter != state.mScriptedAnims.end(); ++iter)
{
AnimationQueueEntry entry;
entry.mGroup = iter->mGroup;
entry.mLoopCount
= static_cast<uint32_t>(std::min<uint64_t>(iter->mLoopCount, std::numeric_limits<uint32_t>::max()));
entry.mLooping = mAnimation->isLoopingAnimation(entry.mGroup);
entry.mScripted = true;
entry.mStartKey = "start";
entry.mStopKey = "stop";
entry.mSpeed = 1.f;
entry.mTime = iter->mTime;
if (iter->mAbsolute)
{
float start = mAnimation->getTextKeyTime(iter->mGroup + ": start");
float stop = mAnimation->getTextKeyTime(iter->mGroup + ": stop");
float time = std::clamp(iter->mTime, start, stop);
entry.mTime = (time - start) / (stop - start);
}
mAnimQueue.push_back(entry);
}
playAnimQueue();
}
}
void CharacterController::playBlendedAnimation(const std::string& groupname, const MWRender::AnimPriority& priority,
int blendMask, bool autodisable, float speedmult, std::string_view start, std::string_view stop,
float startpoint, uint32_t loops, bool loopfallback) const
{
if (mLuaAnimations)
MWBase::Environment::get().getLuaManager()->playAnimation(mPtr, groupname, priority, blendMask, autodisable,
speedmult, start, stop, startpoint, loops, loopfallback);
else
mAnimation->play(
groupname, priority, blendMask, autodisable, speedmult, start, stop, startpoint, loops, loopfallback);
}
bool CharacterController::playGroup(std::string_view groupname, int mode, uint32_t count, bool scripted)
{
if (!mAnimation || !mAnimation->hasAnimation(groupname))
return false;
// We should not interrupt scripted animations with non-scripted ones
if (isScriptedAnimPlaying() && !scripted)
return true;
bool looping = mAnimation->isLoopingAnimation(groupname);
// If this animation is a looped animation that is already playing
// and has not yet reached the end of the loop, allow it to continue animating with its existing loop count
// and remove any other animations that were queued.
// This emulates observed behavior from the original allows the script "OutsideBanner" to animate banners
// correctly.
if (!mAnimQueue.empty() && mAnimQueue.front().mGroup == groupname && looping
&& mAnimation->isPlaying(groupname))
{
float endOfLoop = mAnimation->getTextKeyTime(mAnimQueue.front().mGroup + ": loop stop");
if (endOfLoop < 0) // if no Loop Stop key was found, use the Stop key
endOfLoop = mAnimation->getTextKeyTime(mAnimQueue.front().mGroup + ": stop");
if (endOfLoop > 0 && (mAnimation->getCurrentTime(mAnimQueue.front().mGroup) < endOfLoop))
{
mAnimQueue.resize(1);
return true;
}
}
// The loop count in vanilla is weird.
// if played with a count of 0, all objects play exactly once from start to stop.
// But if the count is x > 0, actors and non-actors behave differently. actors will loop
// exactly x times, while non-actors will loop x+1 instead.
if (mPtr.getClass().isActor() && count > 0)
count--;
AnimationQueueEntry entry;
entry.mGroup = groupname;
entry.mLoopCount = count;
entry.mTime = 0.f;
// "PlayGroup idle" is a special case, used to remove to stop scripted animations playing
entry.mScripted = (scripted && groupname != "idle");
entry.mLooping = looping;
entry.mSpeed = 1.f;
entry.mStartKey = ((mode == 2) ? "loop start" : "start");
entry.mStopKey = "stop";
bool playImmediately = false;
if (mode != 0 || mAnimQueue.empty() || !isAnimPlaying(mAnimQueue.front().mGroup))
{
clearAnimQueue(scripted);
playImmediately = true;
}
else
{
mAnimQueue.resize(1);
}
mAnimQueue.push_back(entry);
if (playImmediately)
playAnimQueue(mode == 2);
return true;
}
bool CharacterController::playGroupLua(std::string_view groupname, float speed, std::string_view startKey,
std::string_view stopKey, uint32_t loops, bool forceLoop)
{
// Note: In mwscript, "idle" is a special case used to clear the anim queue.
// In lua we offer an explicit clear method instead so this method does not treat "idle" special.
if (!mAnimation || !mAnimation->hasAnimation(groupname))
return false;
AnimationQueueEntry entry;
entry.mGroup = groupname;
// Note: MWScript gives one less loop to actors than non-actors.
// But this is the Lua version. We don't need to reproduce this weirdness here.
entry.mLoopCount = loops;
entry.mStartKey = startKey;
entry.mStopKey = stopKey;
entry.mLooping = mAnimation->isLoopingAnimation(groupname) || forceLoop;
entry.mScripted = true;
entry.mSpeed = speed;
entry.mTime = 0;
if (mAnimQueue.size() > 1)
mAnimQueue.resize(1);
mAnimQueue.push_back(entry);
if (mAnimQueue.size() == 1)
playAnimQueue();
return true;
}
void CharacterController::enableLuaAnimations(bool enable)
{
mLuaAnimations = enable;
}
void CharacterController::skipAnim()
{
mSkipAnim = true;
}
bool CharacterController::isScriptedAnimPlaying() const
{
// If the front of the anim queue is scripted, morrowind treats it as if it's
// still playing even if it's actually done.
if (!mAnimQueue.empty())
return mAnimQueue.front().mScripted;
return false;
}
bool CharacterController::isAnimPlaying(std::string_view groupName) const
{
if (mAnimation == nullptr)
return false;
return mAnimation->isPlaying(groupName);
}
bool CharacterController::isMovementAnimationControlled() const
{
if (mHitState != CharState_None)
return true;
if (Settings::game().mPlayerMovementIgnoresAnimation && mPtr == getPlayer())
return false;
if (mInJump)
return false;
bool movementAnimationControlled = mIdleState != CharState_None;
if (mMovementState != CharState_None)
movementAnimationControlled = mMovementAnimationHasMovement;
return movementAnimationControlled;
}
void CharacterController::clearAnimQueue(bool clearScriptedAnims)
{
// Do not interrupt scripted animations, if we want to keep them
if ((!isScriptedAnimPlaying() || clearScriptedAnims) && !mAnimQueue.empty())
mAnimation->disable(mAnimQueue.front().mGroup);
if (clearScriptedAnims)
{
mAnimation->setPlayScriptedOnly(false);
mAnimQueue.clear();
return;
}
for (AnimationQueue::iterator it = mAnimQueue.begin(); it != mAnimQueue.end();)
{
if (!it->mScripted)
it = mAnimQueue.erase(it);
else
++it;
}
}
void CharacterController::forceStateUpdate()
{
if (!mAnimation)
return;
clearAnimQueue();
// Make sure we canceled the current attack or spellcasting,
// because we disabled attack animations anyway.
mCanCast = false;
mCastingScriptedSpell = false;
setAttackingOrSpell(false);
if (mUpperBodyState != UpperBodyState::None)
mUpperBodyState = UpperBodyState::WeaponEquipped;
refreshCurrentAnims(mIdleState, mMovementState, mJumpState, true);
if (mDeathState != CharState_None)
{
playRandomDeath();
}
updateAnimQueue();
mAnimation->runAnimation(0.f);
}
CharacterController::KillResult CharacterController::kill()
{
if (mDeathState == CharState_None)
{
playRandomDeath();
resetCurrentIdleState();
return Result_DeathAnimStarted;
}
MWMechanics::CreatureStats& cStats = mPtr.getClass().getCreatureStats(mPtr);
if (isAnimPlaying(mCurrentDeath))
return Result_DeathAnimPlaying;
if (!cStats.isDeathAnimationFinished())
{
cStats.setDeathAnimationFinished(true);
return Result_DeathAnimJustFinished;
}
return Result_DeathAnimFinished;
}
void CharacterController::resurrect()
{
if (mDeathState == CharState_None)
return;
resetCurrentDeathState();
mWeaponType = ESM::Weapon::None;
}
void CharacterController::updateContinuousVfx() const
{
// Keeping track of when to stop a continuous VFX seems to be very difficult to do inside the spells code,
// as it's extremely spread out (ActiveSpells, Spells, InventoryStore effects, etc...) so we do it here.
// Stop any effects that are no longer active
std::vector<std::string_view> effects = mAnimation->getLoopingEffects();
for (std::string_view effectId : effects)
{
auto index = ESM::MagicEffect::indexNameToIndex(effectId);
if (index >= 0
&& (mPtr.getClass().getCreatureStats(mPtr).isDeathAnimationFinished()
|| mPtr.getClass()
.getCreatureStats(mPtr)
.getMagicEffects()
.getOrDefault(MWMechanics::EffectKey(index))
.getMagnitude()
<= 0))
mAnimation->removeEffect(effectId);
}
}
void CharacterController::updateMagicEffects() const
{
if (!mPtr.getClass().isActor())
return;
float light = mPtr.getClass()
.getCreatureStats(mPtr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Light)
.getMagnitude();
mAnimation->setLightEffect(light);
// If you're dead you don't care about whether you've started/stopped being a vampire or not
if (mPtr.getClass().getCreatureStats(mPtr).isDead())
return;
bool vampire = mPtr.getClass()
.getCreatureStats(mPtr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Vampirism)
.getMagnitude()
> 0.0f;
mAnimation->setVampire(vampire);
}
void CharacterController::setVisibility(float visibility) const
{
// We should take actor's invisibility in account
if (mPtr.getClass().isActor())
{
float alpha = 1.f;
if (mPtr.getClass()
.getCreatureStats(mPtr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Invisibility)
.getModifier()) // Ignore base magnitude (see bug #3555).
{
if (mPtr == getPlayer())
alpha = 0.25f;
else
alpha = 0.05f;
}
float chameleon = mPtr.getClass()
.getCreatureStats(mPtr)
.getMagicEffects()
.getOrDefault(ESM::MagicEffect::Chameleon)
.getMagnitude();
if (chameleon)
{
alpha *= std::clamp(1.f - chameleon / 100.f, 0.25f, 0.75f);
}
visibility = std::min(visibility, alpha);
}
// TODO: implement a dithering shader rather than just change object transparency.
mAnimation->setAlpha(visibility);
}
std::string_view CharacterController::getMovementBasedAttackType() const
{
float* move = mPtr.getClass().getMovementSettings(mPtr).mPosition;
if (std::abs(move[1]) > std::abs(move[0]) + 0.2f) // forward-backward
return "thrust";
if (std::abs(move[0]) > std::abs(move[1]) + 0.2f) // sideway
return "slash";
return "chop";
}
bool CharacterController::isRandomAttackAnimation(std::string_view group)
{
return (group == "attack1" || group == "swimattack1" || group == "attack2" || group == "swimattack2"
|| group == "attack3" || group == "swimattack3");
}
bool CharacterController::isAttackPreparing() const
{
return mUpperBodyState == UpperBodyState::AttackWindUp;
}
bool CharacterController::isCastingSpell() const
{
return mCastingScriptedSpell || mUpperBodyState == UpperBodyState::Casting;
}
bool CharacterController::isReadyToBlock() const
{
return updateCarriedLeftVisible(mWeaponType);
}
bool CharacterController::isKnockedDown() const
{
return mHitState == CharState_KnockDown || mHitState == CharState_SwimKnockDown;
}
bool CharacterController::isKnockedOut() const
{
return mHitState == CharState_KnockOut || mHitState == CharState_SwimKnockOut;
}
bool CharacterController::isTurning() const
{
return mMovementState == CharState_TurnLeft || mMovementState == CharState_TurnRight
|| mMovementState == CharState_SwimTurnLeft || mMovementState == CharState_SwimTurnRight;
}
bool CharacterController::isRecovery() const
{
return mHitState == CharState_Hit || mHitState == CharState_SwimHit;
}
bool CharacterController::isAttackingOrSpell() const
{
return mUpperBodyState != UpperBodyState::None && mUpperBodyState != UpperBodyState::WeaponEquipped;
}
bool CharacterController::isSneaking() const
{
return mIdleState == CharState_IdleSneak || mMovementState == CharState_SneakForward
|| mMovementState == CharState_SneakBack || mMovementState == CharState_SneakLeft
|| mMovementState == CharState_SneakRight;
}
bool CharacterController::isRunning() const
{
return mMovementState == CharState_RunForward || mMovementState == CharState_RunBack
|| mMovementState == CharState_RunLeft || mMovementState == CharState_RunRight
|| mMovementState == CharState_SwimRunForward || mMovementState == CharState_SwimRunBack
|| mMovementState == CharState_SwimRunLeft || mMovementState == CharState_SwimRunRight;
}
void CharacterController::setAttackingOrSpell(bool attackingOrSpell) const
{
mPtr.getClass().getCreatureStats(mPtr).setAttackingOrSpell(attackingOrSpell);
}
void CharacterController::castSpell(const ESM::RefId& spellId, bool scriptedSpell)
{
setAttackingOrSpell(true);
mCastingScriptedSpell = scriptedSpell;
ActionSpell action = ActionSpell(spellId);
action.prepare(mPtr);
}
void CharacterController::setAIAttackType(std::string_view attackType)
{
mAttackType = attackType;
}
std::string_view CharacterController::getRandomAttackType()
{
MWBase::World* world = MWBase::Environment::get().getWorld();
float random = Misc::Rng::rollProbability(world->getPrng());
if (random >= 2 / 3.f)
return "thrust";
if (random >= 1 / 3.f)
return "slash";
return "chop";
}
bool CharacterController::readyToPrepareAttack() const
{
return (mHitState == CharState_None || mHitState == CharState_Block)
&& mUpperBodyState <= UpperBodyState::WeaponEquipped;
}
bool CharacterController::readyToStartAttack() const
{
if (mHitState != CharState_None && mHitState != CharState_Block)
return false;
return mUpperBodyState == UpperBodyState::WeaponEquipped;
}
float CharacterController::getAttackStrength() const
{
return mAttackStrength;
}
bool CharacterController::getAttackingOrSpell() const
{
return mPtr.getClass().getCreatureStats(mPtr).getAttackingOrSpell();
}
std::string_view CharacterController::getDesiredAttackType() const
{
return mPtr.getClass().getCreatureStats(mPtr).getAttackType();
}
void CharacterController::setActive(int active) const
{
mAnimation->setActive(active);
}
void CharacterController::setHeadTrackTarget(const MWWorld::ConstPtr& target)
{
mHeadTrackTarget = target;
}
void CharacterController::playSwishSound() const
{
static ESM::RefId weaponSwish = ESM::RefId::stringRefId("Weapon Swish");
const ESM::RefId* soundId = &weaponSwish;
float volume = 0.98f + mAttackStrength * 0.02f;
float pitch = 0.75f + mAttackStrength * 0.4f;
const MWWorld::Class& cls = mPtr.getClass();
if (cls.isNpc() && cls.getNpcStats(mPtr).isWerewolf())
{
MWBase::World* world = MWBase::Environment::get().getWorld();
const MWWorld::ESMStore& store = world->getStore();
const ESM::Sound* sound = store.get<ESM::Sound>().searchRandom("WolfSwing", world->getPrng());
if (sound)
soundId = &sound->mId;
}
if (!soundId->empty())
MWBase::Environment::get().getSoundManager()->playSound3D(mPtr, *soundId, volume, pitch);
}
float CharacterController::getAnimationMovementDirection() const
{
switch (mMovementState)
{
case CharState_RunLeft:
case CharState_SneakLeft:
case CharState_SwimWalkLeft:
case CharState_SwimRunLeft:
case CharState_WalkLeft:
return osg::PI_2f;
case CharState_RunRight:
case CharState_SneakRight:
case CharState_SwimWalkRight:
case CharState_SwimRunRight:
case CharState_WalkRight:
return -osg::PI_2f;
case CharState_RunForward:
case CharState_SneakForward:
case CharState_SwimRunForward:
case CharState_SwimWalkForward:
case CharState_WalkForward:
return mAnimation->getLegsYawRadians();
case CharState_RunBack:
case CharState_SneakBack:
case CharState_SwimWalkBack:
case CharState_SwimRunBack:
case CharState_WalkBack:
return mAnimation->getLegsYawRadians() - osg::PIf;
default:
return 0.0f;
}
}
void CharacterController::updateHeadTracking(float duration)
{
const osg::Node* head = mAnimation->getNode("Bip01 Head");
if (!head)
return;
double zAngleRadians = 0.f;
double xAngleRadians = 0.f;
if (!mHeadTrackTarget.isEmpty())
{
osg::NodePathList nodepaths = head->getParentalNodePaths();
if (nodepaths.empty())
return;
osg::Matrixf mat = osg::computeLocalToWorld(nodepaths[0]);
osg::Vec3f headPos = mat.getTrans();
osg::Vec3f direction;
if (const MWRender::Animation* anim = MWBase::Environment::get().getWorld()->getAnimation(mHeadTrackTarget))
{
const osg::Node* node = anim->getNode("Head");
if (node == nullptr)
node = anim->getNode("Bip01 Head");
if (node != nullptr)
{
nodepaths = node->getParentalNodePaths();
if (!nodepaths.empty())
direction = osg::computeLocalToWorld(nodepaths[0]).getTrans() - headPos;
}
else
// no head node to look at, fall back to look at center of collision box
direction = MWBase::Environment::get().getWorld()->aimToTarget(mPtr, mHeadTrackTarget, false);
}
direction.normalize();
if (!mPtr.getRefData().getBaseNode())
return;
const osg::Vec3f actorDirection = mPtr.getRefData().getBaseNode()->getAttitude() * osg::Vec3f(0, 1, 0);
zAngleRadians
= std::atan2(actorDirection.x(), actorDirection.y()) - std::atan2(direction.x(), direction.y());
zAngleRadians = Misc::normalizeAngle(zAngleRadians - mAnimation->getHeadYaw()) + mAnimation->getHeadYaw();
zAngleRadians *= (1 - direction.z() * direction.z());
xAngleRadians = std::asin(direction.z());
}
const double xLimit = osg::DegreesToRadians(40.0);
const double zLimit = osg::DegreesToRadians(30.0);
double zLimitOffset = mAnimation->getUpperBodyYawRadians();
xAngleRadians = std::clamp(xAngleRadians, -xLimit, xLimit);
zAngleRadians = std::clamp(zAngleRadians, -zLimit + zLimitOffset, zLimit + zLimitOffset);
float factor = duration * 5;
factor = std::min(factor, 1.f);
xAngleRadians = (1.f - factor) * mAnimation->getHeadPitch() + factor * xAngleRadians;
zAngleRadians = (1.f - factor) * mAnimation->getHeadYaw() + factor * zAngleRadians;
mAnimation->setHeadPitch(xAngleRadians);
mAnimation->setHeadYaw(zAngleRadians);
}
MWWorld::MovementDirectionFlags CharacterController::getSupportedMovementDirections() const
{
using namespace std::string_view_literals;
// There are fallbacks in the CharacterController::refreshMovementAnims for certain animations. Arrays below
// represent them.
constexpr std::array all = { ""sv };
constexpr std::array walk = { "walk"sv };
constexpr std::array swimWalk = { "swimwalk"sv, "walk"sv };
constexpr std::array sneak = { "sneak"sv };
constexpr std::array run = { "run"sv, "walk"sv };
constexpr std::array swimRun = { "swimrun"sv, "run"sv, "walk"sv };
constexpr std::array swim = { "swim"sv };
switch (mMovementState)
{
case CharState_None:
case CharState_SpecialIdle:
case CharState_Idle:
case CharState_IdleSwim:
case CharState_IdleSneak:
return mAnimation->getSupportedMovementDirections(all);
case CharState_WalkForward:
case CharState_WalkBack:
case CharState_WalkLeft:
case CharState_WalkRight:
return mAnimation->getSupportedMovementDirections(walk);
case CharState_SwimWalkForward:
case CharState_SwimWalkBack:
case CharState_SwimWalkLeft:
case CharState_SwimWalkRight:
return mAnimation->getSupportedMovementDirections(swimWalk);
case CharState_RunForward:
case CharState_RunBack:
case CharState_RunLeft:
case CharState_RunRight:
return mAnimation->getSupportedMovementDirections(run);
case CharState_SwimRunForward:
case CharState_SwimRunBack:
case CharState_SwimRunLeft:
case CharState_SwimRunRight:
return mAnimation->getSupportedMovementDirections(swimRun);
case CharState_SneakForward:
case CharState_SneakBack:
case CharState_SneakLeft:
case CharState_SneakRight:
return mAnimation->getSupportedMovementDirections(sneak);
case CharState_TurnLeft:
case CharState_TurnRight:
return mAnimation->getSupportedMovementDirections(all);
case CharState_SwimTurnLeft:
case CharState_SwimTurnRight:
return mAnimation->getSupportedMovementDirections(swim);
case CharState_Death1:
case CharState_Death2:
case CharState_Death3:
case CharState_Death4:
case CharState_Death5:
case CharState_SwimDeath:
case CharState_SwimDeathKnockDown:
case CharState_SwimDeathKnockOut:
case CharState_DeathKnockDown:
case CharState_DeathKnockOut:
case CharState_Hit:
case CharState_SwimHit:
case CharState_KnockDown:
case CharState_KnockOut:
case CharState_SwimKnockDown:
case CharState_SwimKnockOut:
case CharState_Block:
return mAnimation->getSupportedMovementDirections(all);
}
return 0;
}
}
| 134,678
|
C++
|
.cpp
| 2,811
| 33.41302
| 120
| 0.55833
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,319
|
aiavoiddoor.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/aiavoiddoor.cpp
|
#include "aiavoiddoor.hpp"
#include <components/misc/rng.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "actorutil.hpp"
#include "creaturestats.hpp"
#include "movement.hpp"
#include "steering.hpp"
static const int MAX_DIRECTIONS = 4;
MWMechanics::AiAvoidDoor::AiAvoidDoor(const MWWorld::ConstPtr& doorPtr)
: mDuration(1)
, mDoorPtr(doorPtr)
, mDirection(0)
{
}
bool MWMechanics::AiAvoidDoor::execute(
const MWWorld::Ptr& actor, CharacterController& characterController, AiState& state, float duration)
{
ESM::Position pos = actor.getRefData().getPosition();
if (mDuration == 1) // If it just started, get the actor position as the stuck detection thing
mLastPos = pos.asVec3();
mDuration -= duration; // Update timer
if (mDuration < 0)
{
if (isStuck(pos.asVec3()))
{
adjustDirection();
mDuration = 1; // reset timer
}
else
return true; // We have tried backing up for more than one second, we've probably cleared it
}
if (mDoorPtr.getClass().getDoorState(mDoorPtr) == MWWorld::DoorState::Idle)
return true; // Door is no longer opening
ESM::Position tPos = mDoorPtr.getRefData().getPosition(); // Position of the door
float x = pos.pos[1] - tPos.pos[1];
float y = pos.pos[0] - tPos.pos[0];
actor.getClass().getCreatureStats(actor).setMovementFlag(CreatureStats::Flag_Run, true);
// Turn away from the door and move when turn completed
if (zTurn(actor, std::atan2(y, x) + getAdjustedAngle(), osg::DegreesToRadians(5.f)))
actor.getClass().getMovementSettings(actor).mPosition[1] = 1;
else
actor.getClass().getMovementSettings(actor).mPosition[1] = 0;
actor.getClass().getMovementSettings(actor).mPosition[0] = 0;
// Make all nearby actors also avoid the door
std::vector<MWWorld::Ptr> actors;
MWBase::Environment::get().getMechanicsManager()->getActorsInRange(pos.asVec3(), 100, actors);
for (auto& neighbor : actors)
{
if (neighbor == getPlayer())
continue;
MWMechanics::AiSequence& seq = neighbor.getClass().getCreatureStats(neighbor).getAiSequence();
if (seq.getTypeId() != MWMechanics::AiPackageTypeId::AvoidDoor)
seq.stack(MWMechanics::AiAvoidDoor(mDoorPtr), neighbor);
}
return false;
}
bool MWMechanics::AiAvoidDoor::isStuck(const osg::Vec3f& actorPos) const
{
return (actorPos - mLastPos).length2() < 10 * 10;
}
void MWMechanics::AiAvoidDoor::adjustDirection()
{
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
mDirection = Misc::Rng::rollDice(MAX_DIRECTIONS, prng);
}
float MWMechanics::AiAvoidDoor::getAdjustedAngle() const
{
return 2 * osg::PI / MAX_DIRECTIONS * mDirection;
}
| 2,898
|
C++
|
.cpp
| 72
| 35.25
| 104
| 0.692445
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,320
|
repair.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/repair.cpp
|
#include "repair.hpp"
#include <components/misc/rng.hpp>
#include <components/misc/strings/format.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/containerstore.hpp"
#include "../mwworld/esmstore.hpp"
#include "actorutil.hpp"
#include "creaturestats.hpp"
namespace MWMechanics
{
void Repair::repair(const MWWorld::Ptr& itemToRepair)
{
MWWorld::Ptr player = getPlayer();
MWWorld::LiveCellRef<ESM::Repair>* ref = mTool.get<ESM::Repair>();
MWBase::Environment::get().getWorld()->breakInvisibility(player);
// unstack tool if required
player.getClass().getContainerStore(player).unstack(mTool);
// reduce number of uses left
int uses = mTool.getClass().getItemHealth(mTool);
uses -= std::min(uses, 1);
mTool.getCellRef().setCharge(uses);
MWMechanics::CreatureStats& stats = player.getClass().getCreatureStats(player);
float fatigueTerm = stats.getFatigueTerm();
float pcStrength = stats.getAttribute(ESM::Attribute::Strength).getModified();
float pcLuck = stats.getAttribute(ESM::Attribute::Luck).getModified();
float armorerSkill = player.getClass().getSkill(player, ESM::Skill::Armorer);
float fRepairAmountMult = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("fRepairAmountMult")
->mValue.getFloat();
float toolQuality = ref->mBase->mData.mQuality;
float x = (0.1f * pcStrength + 0.1f * pcLuck + armorerSkill) * fatigueTerm;
auto& prng = MWBase::Environment::get().getWorld()->getPrng();
int roll = Misc::Rng::roll0to99(prng);
if (roll <= x)
{
int y = static_cast<int>(fRepairAmountMult * toolQuality * roll);
y = std::max(1, y);
// repair by 'y' points
int charge = itemToRepair.getClass().getItemHealth(itemToRepair);
charge = std::min(charge + y, itemToRepair.getClass().getItemMaxHealth(itemToRepair));
itemToRepair.getCellRef().setCharge(charge);
// attempt to re-stack item, in case it was fully repaired
MWWorld::ContainerStoreIterator stacked = player.getClass().getContainerStore(player).restack(itemToRepair);
// set the OnPCRepair variable on the item's script
const ESM::RefId& script = stacked->getClass().getScript(itemToRepair);
if (!script.empty())
stacked->getRefData().getLocals().setVarByInt(script, "onpcrepair", 1);
// increase skill
player.getClass().skillUsageSucceeded(player, ESM::Skill::Armorer, ESM::Skill::Armorer_Repair);
MWBase::Environment::get().getWindowManager()->playSound(ESM::RefId::stringRefId("Repair"));
MWBase::Environment::get().getWindowManager()->messageBox("#{sRepairSuccess}");
}
else
{
MWBase::Environment::get().getWindowManager()->playSound(ESM::RefId::stringRefId("Repair Fail"));
MWBase::Environment::get().getWindowManager()->messageBox("#{sRepairFailed}");
}
// tool used up?
if (mTool.getCellRef().getCharge() == 0)
{
MWWorld::ContainerStore& store = player.getClass().getContainerStore(player);
store.remove(mTool, 1);
std::string message = MWBase::Environment::get()
.getESMStore()
->get<ESM::GameSetting>()
.find("sNotifyMessage51")
->mValue.getString();
message = Misc::StringUtils::format(message, mTool.getClass().getName(mTool));
MWBase::Environment::get().getWindowManager()->messageBox(message);
// try to find a new tool of the same ID
for (MWWorld::ContainerStoreIterator iter(store.begin()); iter != store.end(); ++iter)
{
if (iter->getCellRef().getRefId() == mTool.getCellRef().getRefId())
{
mTool = *iter;
MWBase::Environment::get().getWindowManager()->playSound(ESM::RefId::stringRefId("Item Repair Up"));
break;
}
}
}
}
}
| 4,548
|
C++
|
.cpp
| 87
| 39.643678
| 120
| 0.591924
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| true
| false
|
35,321
|
weapontype.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/weapontype.cpp
|
#include "weapontype.hpp"
#include "creaturestats.hpp"
#include "drawstate.hpp"
#include "../mwworld/class.hpp"
#include "../mwworld/inventorystore.hpp"
#include <components/esm3/loadweap.hpp>
#include <set>
namespace MWMechanics
{
template <enum ESM::Weapon::Type>
struct Weapon
{
};
template <>
struct Weapon<ESM::Weapon::None>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "",
/* long group */ "",
/* sound ID */ "",
/* attach bone */ "",
/* sheath bone */ "",
/* usage skill */ ESM::Skill::HandToHand,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ 0 };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::PickProbe>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "1h",
/* long group */ "pickprobe",
/* sound ID */ "",
/* attach bone */ "",
/* sheath bone */ "",
/* usage skill */ ESM::Skill::Security,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ 0 };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::Spell>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "spell",
/* long group */ "spellcast",
/* sound ID */ "",
/* attach bone */ "",
/* sheath bone */ "",
/* usage skill */ ESM::Skill::HandToHand,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::HandToHand>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "hh",
/* long group */ "handtohand",
/* sound ID */ "",
/* attach bone */ "",
/* sheath bone */ "",
/* usage skill */ ESM::Skill::HandToHand,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::ShortBladeOneHand>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "1s",
/* long group */ "shortbladeonehand",
/* sound ID */ "Item Weapon Shortblade",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 ShortBladeOneHand",
/* usage skill */ ESM::Skill::ShortBlade,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::LongBladeOneHand>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "1h",
/* long group */ "weapononehand",
/* sound ID */ "Item Weapon Longblade",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 LongBladeOneHand",
/* usage skill */ ESM::Skill::LongBlade,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::BluntOneHand>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "1b",
/* long group */ "bluntonehand",
/* sound ID */ "Item Weapon Blunt",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 BluntOneHand",
/* usage skill */ ESM::Skill::BluntWeapon,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::AxeOneHand>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "1b",
/* long group */ "bluntonehand",
/* sound ID */ "Item Weapon Blunt",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 LongBladeOneHand",
/* usage skill */ ESM::Skill::Axe,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::LongBladeTwoHand>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "2c",
/* long group */ "weapontwohand",
/* sound ID */ "Item Weapon Longblade",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 LongBladeTwoClose",
/* usage skill */ ESM::Skill::LongBlade,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth | ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::AxeTwoHand>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "2b",
/* long group */ "blunttwohand",
/* sound ID */ "Item Weapon Blunt",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 AxeTwoClose",
/* usage skill */ ESM::Skill::Axe,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth | ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::BluntTwoClose>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "2b",
/* long group */ "blunttwohand",
/* sound ID */ "Item Weapon Blunt",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 BluntTwoClose",
/* usage skill */ ESM::Skill::BluntWeapon,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth | ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::BluntTwoWide>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "2w",
/* long group */ "weapontwowide",
/* sound ID */ "Item Weapon Blunt",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 BluntTwoWide",
/* usage skill */ ESM::Skill::BluntWeapon,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth | ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::SpearTwoWide>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "2w",
/* long group */ "weapontwowide",
/* sound ID */ "Item Weapon Spear",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 SpearTwoWide",
/* usage skill */ ESM::Skill::Spear,
/* weapon class*/ ESM::WeaponType::Melee,
/* ammo type */ ESM::Weapon::None,
/* flags */ ESM::WeaponType::HasHealth | ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::MarksmanBow>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "bow",
/* long group */ "bowandarrow",
/* sound ID */ "Item Weapon Bow",
/* attach bone */ "Weapon Bone Left",
/* sheath bone */ "Bip01 MarksmanBow",
/* usage skill */ ESM::Skill::Marksman,
/* weapon class*/ ESM::WeaponType::Ranged,
/* ammo type */ ESM::Weapon::Arrow,
/* flags */ ESM::WeaponType::HasHealth | ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::MarksmanCrossbow>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "crossbow",
/* long group */ "crossbow",
/* sound ID */ "Item Weapon Crossbow",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 MarksmanCrossbow",
/* usage skill */ ESM::Skill::Marksman,
/* weapon class*/ ESM::WeaponType::Ranged,
/* ammo type */ ESM::Weapon::Bolt,
/* flags */ ESM::WeaponType::HasHealth | ESM::WeaponType::TwoHanded };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::MarksmanThrown>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "1t",
/* long group */ "throwweapon",
/* sound ID */ "Item Weapon Blunt",
/* attach bone */ "Weapon Bone",
/* sheath bone */ "Bip01 MarksmanThrown",
/* usage skill */ ESM::Skill::Marksman,
/* weapon class*/ ESM::WeaponType::Thrown,
/* ammo type */ ESM::Weapon::None,
/* flags */ 0 };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::Arrow>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "",
/* long group */ "",
/* sound ID */ "Item Ammo",
/* attach bone */ "Bip01 Arrow",
/* sheath bone */ "",
/* usage skill */ ESM::Skill::Marksman,
/* weapon class*/ ESM::WeaponType::Ammo,
/* ammo type */ ESM::Weapon::None,
/* flags */ 0 };
return value;
}
};
template <>
struct Weapon<ESM::Weapon::Bolt>
{
inline static const ESM::WeaponType& getValue()
{
static const ESM::WeaponType value{ /* short group */ "",
/* long group */ "",
/* sound ID */ "Item Ammo",
/* attach bone */ "ArrowBone",
/* sheath bone */ "",
/* usage skill */ ESM::Skill::Marksman,
/* weapon class*/ ESM::WeaponType::Ammo,
/* ammo type */ ESM::Weapon::None,
/* flags */ 0 };
return value;
}
};
MWWorld::ContainerStoreIterator getActiveWeapon(const MWWorld::Ptr& actor, int* weaptype)
{
MWWorld::InventoryStore& inv = actor.getClass().getInventoryStore(actor);
CreatureStats& stats = actor.getClass().getCreatureStats(actor);
if (stats.getDrawState() == MWMechanics::DrawState::Spell)
{
*weaptype = ESM::Weapon::Spell;
return inv.end();
}
if (stats.getDrawState() == MWMechanics::DrawState::Weapon)
{
MWWorld::ContainerStoreIterator weapon = inv.getSlot(MWWorld::InventoryStore::Slot_CarriedRight);
if (weapon == inv.end())
*weaptype = ESM::Weapon::HandToHand;
else
{
auto type = weapon->getType();
if (type == ESM::Weapon::sRecordId)
{
const MWWorld::LiveCellRef<ESM::Weapon>* ref = weapon->get<ESM::Weapon>();
*weaptype = ref->mBase->mData.mType;
}
else if (type == ESM::Lockpick::sRecordId || type == ESM::Probe::sRecordId)
*weaptype = ESM::Weapon::PickProbe;
}
return weapon;
}
return inv.getSlot(MWWorld::InventoryStore::Slot_CarriedRight);
}
const ESM::WeaponType* getWeaponType(const int weaponType)
{
switch (static_cast<ESM::Weapon::Type>(weaponType))
{
case ESM::Weapon::PickProbe:
return &Weapon<ESM::Weapon::PickProbe>::getValue();
case ESM::Weapon::HandToHand:
return &Weapon<ESM::Weapon::HandToHand>::getValue();
case ESM::Weapon::Spell:
return &Weapon<ESM::Weapon::Spell>::getValue();
case ESM::Weapon::None:
return &Weapon<ESM::Weapon::None>::getValue();
case ESM::Weapon::ShortBladeOneHand:
return &Weapon<ESM::Weapon::ShortBladeOneHand>::getValue();
case ESM::Weapon::LongBladeOneHand:
return &Weapon<ESM::Weapon::LongBladeOneHand>::getValue();
case ESM::Weapon::LongBladeTwoHand:
return &Weapon<ESM::Weapon::LongBladeTwoHand>::getValue();
case ESM::Weapon::BluntOneHand:
return &Weapon<ESM::Weapon::BluntOneHand>::getValue();
case ESM::Weapon::BluntTwoClose:
return &Weapon<ESM::Weapon::BluntTwoClose>::getValue();
case ESM::Weapon::BluntTwoWide:
return &Weapon<ESM::Weapon::BluntTwoWide>::getValue();
case ESM::Weapon::SpearTwoWide:
return &Weapon<ESM::Weapon::SpearTwoWide>::getValue();
case ESM::Weapon::AxeOneHand:
return &Weapon<ESM::Weapon::AxeOneHand>::getValue();
case ESM::Weapon::AxeTwoHand:
return &Weapon<ESM::Weapon::AxeTwoHand>::getValue();
case ESM::Weapon::MarksmanBow:
return &Weapon<ESM::Weapon::MarksmanBow>::getValue();
case ESM::Weapon::MarksmanCrossbow:
return &Weapon<ESM::Weapon::MarksmanCrossbow>::getValue();
case ESM::Weapon::MarksmanThrown:
return &Weapon<ESM::Weapon::MarksmanThrown>::getValue();
case ESM::Weapon::Arrow:
return &Weapon<ESM::Weapon::Arrow>::getValue();
case ESM::Weapon::Bolt:
return &Weapon<ESM::Weapon::Bolt>::getValue();
}
return &Weapon<ESM::Weapon::ShortBladeOneHand>::getValue();
}
std::vector<std::string_view> getAllWeaponTypeShortGroups()
{
// Go via a set to eliminate duplicates.
std::set<std::string_view> shortGroupSet;
for (int type = ESM::Weapon::Type::First; type <= ESM::Weapon::Type::Last; type++)
{
std::string_view shortGroup = getWeaponType(type)->mShortGroup;
if (!shortGroup.empty())
shortGroupSet.insert(shortGroup);
}
return std::vector<std::string_view>(shortGroupSet.begin(), shortGroupSet.end());
}
}
| 16,650
|
C++
|
.cpp
| 404
| 29.106436
| 109
| 0.504286
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
35,322
|
aisequence.cpp
|
OpenMW_openmw/apps/openmw/mwmechanics/aisequence.cpp
|
#include "aisequence.hpp"
#include <algorithm>
#include <limits>
#include <components/debug/debuglog.hpp>
#include <components/esm3/aisequence.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/mechanicsmanager.hpp"
#include "../mwworld/class.hpp"
#include "actorutil.hpp"
#include "aiactivate.hpp"
#include "aicombat.hpp"
#include "aicombataction.hpp"
#include "aiescort.hpp"
#include "aifollow.hpp"
#include "aipackage.hpp"
#include "aipursue.hpp"
#include "aitravel.hpp"
#include "aiwander.hpp"
#include "creaturestats.hpp"
namespace MWMechanics
{
void AiSequence::copy(const AiSequence& sequence)
{
for (const auto& package : sequence.mPackages)
mPackages.push_back(package->clone());
// We need to keep an AiWander storage, if present - it has a state machine.
// Not sure about another temporary storages
sequence.mAiState.copy<AiWanderStorage>(mAiState);
mNumCombatPackages = sequence.mNumCombatPackages;
mNumPursuitPackages = sequence.mNumPursuitPackages;
}
AiSequence::AiSequence()
: mDone(false)
, mLastAiPackage(AiPackageTypeId::None)
{
}
AiSequence::AiSequence(const AiSequence& sequence)
{
copy(sequence);
mDone = sequence.mDone;
mLastAiPackage = sequence.mLastAiPackage;
}
AiSequence& AiSequence::operator=(const AiSequence& sequence)
{
if (this != &sequence)
{
clear();
copy(sequence);
mDone = sequence.mDone;
mLastAiPackage = sequence.mLastAiPackage;
}
return *this;
}
AiSequence::~AiSequence()
{
clear();
}
void AiSequence::onPackageAdded(const AiPackage& package)
{
if (package.getTypeId() == AiPackageTypeId::Combat)
mNumCombatPackages++;
else if (package.getTypeId() == AiPackageTypeId::Pursue)
mNumPursuitPackages++;
assert(mNumCombatPackages >= 0);
assert(mNumPursuitPackages >= 0);
}
void AiSequence::onPackageRemoved(const AiPackage& package)
{
if (package.getTypeId() == AiPackageTypeId::Combat)
{
mNumCombatPackages--;
if (mNumCombatPackages == 0)
mResetFriendlyHits = true;
}
else if (package.getTypeId() == AiPackageTypeId::Pursue)
mNumPursuitPackages--;
assert(mNumCombatPackages >= 0);
assert(mNumPursuitPackages >= 0);
}
AiPackageTypeId AiSequence::getTypeId() const
{
if (mPackages.empty())
return AiPackageTypeId::None;
return mPackages.front()->getTypeId();
}
bool AiSequence::getCombatTarget(MWWorld::Ptr& targetActor) const
{
if (getTypeId() != AiPackageTypeId::Combat)
return false;
targetActor = mPackages.front()->getTarget();
return !targetActor.isEmpty();
}
bool AiSequence::getCombatTargets(std::vector<MWWorld::Ptr>& targetActors) const
{
for (auto it = mPackages.begin(); it != mPackages.end(); ++it)
{
if ((*it)->getTypeId() == MWMechanics::AiPackageTypeId::Combat)
targetActors.push_back((*it)->getTarget());
}
return !targetActors.empty();
}
AiPackages::iterator AiSequence::erase(AiPackages::iterator package)
{
// Not sure if manually terminated packages should trigger mDone, probably not?
auto& ptr = *package;
onPackageRemoved(*ptr);
return mPackages.erase(package);
}
bool AiSequence::isInCombat() const
{
return mNumCombatPackages > 0;
}
bool AiSequence::isInPursuit() const
{
return mNumPursuitPackages > 0;
}
bool AiSequence::isFleeing() const
{
if (!isInCombat())
return false;
const AiCombatStorage* storage = mAiState.getPtr<AiCombatStorage>();
return storage && storage->isFleeing();
}
bool AiSequence::isEngagedWithActor() const
{
if (!isInCombat())
return false;
for (auto it = mPackages.begin(); it != mPackages.end(); ++it)
{
if ((*it)->getTypeId() == AiPackageTypeId::Combat)
{
MWWorld::Ptr target2 = (*it)->getTarget();
if (!target2.isEmpty() && target2.getClass().isNpc())
return true;
}
}
return false;
}
bool AiSequence::hasPackage(AiPackageTypeId typeId) const
{
auto it = std::find_if(mPackages.begin(), mPackages.end(),
[typeId](const auto& package) { return package->getTypeId() == typeId; });
return it != mPackages.end();
}
bool AiSequence::isInCombat(const MWWorld::Ptr& actor) const
{
if (!isInCombat())
return false;
for (const auto& package : mPackages)
{
if (package->getTypeId() == AiPackageTypeId::Combat)
{
if (package->targetIs(actor))
return true;
}
}
return false;
}
void AiSequence::removePackagesById(AiPackageTypeId id)
{
for (auto it = mPackages.begin(); it != mPackages.end();)
{
if ((*it)->getTypeId() == id)
{
it = erase(it);
}
else
++it;
}
}
void AiSequence::stopCombat()
{
removePackagesById(AiPackageTypeId::Combat);
}
void AiSequence::stopCombat(const std::vector<MWWorld::Ptr>& targets)
{
for (auto it = mPackages.begin(); it != mPackages.end();)
{
if ((*it)->getTypeId() == AiPackageTypeId::Combat
&& std::find(targets.begin(), targets.end(), (*it)->getTarget()) != targets.end())
{
it = erase(it);
}
else
++it;
}
}
void AiSequence::stopPursuit()
{
removePackagesById(AiPackageTypeId::Pursue);
}
bool AiSequence::isPackageDone() const
{
return mDone;
}
namespace
{
bool isActualAiPackage(AiPackageTypeId packageTypeId)
{
return (packageTypeId >= AiPackageTypeId::Wander && packageTypeId <= AiPackageTypeId::Activate);
}
}
void AiSequence::execute(
const MWWorld::Ptr& actor, CharacterController& characterController, float duration, bool outOfRange)
{
if (actor == getPlayer())
{
// Players don't use this.
return;
}
if (mResetFriendlyHits)
{
actor.getClass().getCreatureStats(actor).resetFriendlyHits();
mResetFriendlyHits = false;
}
if (mPackages.empty())
{
mLastAiPackage = AiPackageTypeId::None;
return;
}
auto* package = mPackages.front().get();
if (!package->alwaysActive() && outOfRange)
return;
auto packageTypeId = package->getTypeId();
// workaround ai packages not being handled as in the vanilla engine
if (isActualAiPackage(packageTypeId))
mLastAiPackage = packageTypeId;
// if active package is combat one, choose nearest target
if (packageTypeId == AiPackageTypeId::Combat)
{
auto itActualCombat = mPackages.end();
float nearestDist = std::numeric_limits<float>::max();
osg::Vec3f vActorPos = actor.getRefData().getPosition().asVec3();
float bestRating = 0.f;
for (auto it = mPackages.begin(); it != mPackages.end();)
{
if ((*it)->getTypeId() != AiPackageTypeId::Combat)
break;
MWWorld::Ptr target = (*it)->getTarget();
// target disappeared (e.g. summoned creatures)
if (target.isEmpty())
{
it = erase(it);
}
else
{
float rating = 0.f;
if (MWMechanics::canFight(actor, target))
rating = MWMechanics::getBestActionRating(actor, target);
const ESM::Position& targetPos = target.getRefData().getPosition();
float distTo = (targetPos.asVec3() - vActorPos).length2();
// Small threshold for changing target
if (it == mPackages.begin())
distTo = std::max(0.f, distTo - 2500.f);
// if a target has higher priority than current target or has same priority but closer
if (rating > bestRating || ((distTo < nearestDist) && rating == bestRating))
{
nearestDist = distTo;
itActualCombat = it;
bestRating = rating;
}
++it;
}
}
if (mPackages.empty())
return;
if (nearestDist < std::numeric_limits<float>::max() && mPackages.begin() != itActualCombat)
{
assert(itActualCombat != mPackages.end());
// move combat package with nearest target to the front
std::rotate(mPackages.begin(), itActualCombat, std::next(itActualCombat));
}
package = mPackages.front().get();
packageTypeId = package->getTypeId();
}
try
{
if (package->execute(actor, characterController, mAiState, duration))
{
// Put repeating non-combat AI packages on the end of the stack so they can be used again
if (isActualAiPackage(packageTypeId) && package->getRepeat())
{
package->reset();
mPackages.push_back(package->clone());
}
// The active package is typically the first entry, this is however not always the case
// e.g. AiPursue executing a dialogue script that uses startCombat adds a combat package to the front
// due to the priority.
auto activePackageIt = std::find_if(
mPackages.begin(), mPackages.end(), [&](auto& entry) { return entry.get() == package; });
erase(activePackageIt);
if (isActualAiPackage(packageTypeId))
mDone = true;
}
else
{
mDone = false;
}
}
catch (std::exception& e)
{
Log(Debug::Error) << "Error during AiSequence::execute: " << e.what();
}
}
void AiSequence::clear()
{
mPackages.clear();
mNumCombatPackages = 0;
mNumPursuitPackages = 0;
}
void AiSequence::stack(const AiPackage& package, const MWWorld::Ptr& actor, bool cancelOther)
{
if (actor == getPlayer())
throw std::runtime_error("Can't add AI packages to player");
// Stop combat when a non-combat AI package is added
if (isActualAiPackage(package.getTypeId()))
{
if (package.getTypeId() == MWMechanics::AiPackageTypeId::Follow
|| package.getTypeId() == MWMechanics::AiPackageTypeId::Escort)
{
const auto& mechanicsManager = MWBase::Environment::get().getMechanicsManager();
std::vector<MWWorld::Ptr> newAllies = mechanicsManager->getActorsSidingWith(package.getTarget());
std::vector<MWWorld::Ptr> allies = mechanicsManager->getActorsSidingWith(actor);
for (const auto& ally : allies)
ally.getClass().getCreatureStats(ally).getAiSequence().stopCombat(newAllies);
for (const auto& ally : newAllies)
ally.getClass().getCreatureStats(ally).getAiSequence().stopCombat(allies);
}
stopCombat();
}
// We should return a wandering actor back after combat, casting or pursuit.
// The same thing for actors without AI packages.
// Also there is no point to stack return packages.
const auto currentTypeId = getTypeId();
const auto newTypeId = package.getTypeId();
if (currentTypeId <= MWMechanics::AiPackageTypeId::Wander
&& !hasPackage(MWMechanics::AiPackageTypeId::InternalTravel)
&& (newTypeId <= MWMechanics::AiPackageTypeId::Combat || newTypeId == MWMechanics::AiPackageTypeId::Pursue
|| newTypeId == MWMechanics::AiPackageTypeId::Cast))
{
osg::Vec3f dest;
if (currentTypeId == MWMechanics::AiPackageTypeId::Wander)
{
dest = getActivePackage().getDestination(actor);
}
else
{
dest = actor.getRefData().getPosition().asVec3();
}
MWMechanics::AiInternalTravel travelPackage(dest.x(), dest.y(), dest.z());
stack(travelPackage, actor, false);
}
// remove previous packages if required
if (cancelOther && package.shouldCancelPreviousAi())
{
for (auto it = mPackages.begin(); it != mPackages.end();)
{
if ((*it)->canCancel())
{
it = erase(it);
}
else
++it;
}
}
// insert new package in correct place depending on priority
for (auto it = mPackages.begin(); it != mPackages.end(); ++it)
{
// We should override current AiCast package, if we try to add a new one.
if ((*it)->getTypeId() == MWMechanics::AiPackageTypeId::Cast
&& package.getTypeId() == MWMechanics::AiPackageTypeId::Cast)
{
*it = package.clone();
return;
}
if ((*it)->getPriority() <= package.getPriority())
{
onPackageAdded(package);
mPackages.insert(it, package.clone());
return;
}
}
onPackageAdded(package);
mPackages.push_back(package.clone());
// Make sure that temporary storage is empty
if (cancelOther)
{
mAiState.moveIn(std::make_unique<AiCombatStorage>());
mAiState.moveIn(std::make_unique<AiFollowStorage>());
mAiState.moveIn(std::make_unique<AiWanderStorage>());
}
}
bool MWMechanics::AiSequence::isEmpty() const
{
return mPackages.empty();
}
const AiPackage& MWMechanics::AiSequence::getActivePackage() const
{
if (mPackages.empty())
throw std::runtime_error(std::string("No AI Package!"));
return *mPackages.front();
}
void AiSequence::fill(const ESM::AIPackageList& list)
{
for (const auto& esmPackage : list.mList)
{
std::unique_ptr<MWMechanics::AiPackage> package;
if (esmPackage.mType == ESM::AI_Wander)
{
ESM::AIWander data = esmPackage.mWander;
std::vector<unsigned char> idles;
idles.reserve(8);
for (int i = 0; i < 8; ++i)
idles.push_back(data.mIdle[i]);
package = std::make_unique<MWMechanics::AiWander>(
data.mDistance, data.mDuration, data.mTimeOfDay, idles, data.mShouldRepeat != 0);
}
else if (esmPackage.mType == ESM::AI_Escort)
{
ESM::AITarget data = esmPackage.mTarget;
package = std::make_unique<MWMechanics::AiEscort>(ESM::RefId::stringRefId(data.mId.toStringView()),
esmPackage.mCellName, data.mDuration, data.mX, data.mY, data.mZ, data.mShouldRepeat != 0);
}
else if (esmPackage.mType == ESM::AI_Travel)
{
ESM::AITravel data = esmPackage.mTravel;
package = std::make_unique<MWMechanics::AiTravel>(data.mX, data.mY, data.mZ, data.mShouldRepeat != 0);
}
else if (esmPackage.mType == ESM::AI_Activate)
{
ESM::AIActivate data = esmPackage.mActivate;
package = std::make_unique<MWMechanics::AiActivate>(
ESM::RefId::stringRefId(data.mName.toStringView()), data.mShouldRepeat != 0);
}
else // if (esmPackage.mType == ESM::AI_Follow)
{
ESM::AITarget data = esmPackage.mTarget;
package = std::make_unique<MWMechanics::AiFollow>(ESM::RefId::stringRefId(data.mId.toStringView()),
esmPackage.mCellName, data.mDuration, data.mX, data.mY, data.mZ, data.mShouldRepeat != 0);
}
onPackageAdded(*package);
mPackages.push_back(std::move(package));
}
}
void AiSequence::writeState(ESM::AiSequence::AiSequence& sequence) const
{
for (const auto& package : mPackages)
package->writeState(sequence);
sequence.mLastAiPackage = static_cast<int>(mLastAiPackage);
}
void AiSequence::readState(const ESM::AiSequence::AiSequence& sequence)
{
if (!sequence.mPackages.empty())
clear();
// Load packages
for (auto& container : sequence.mPackages)
{
std::unique_ptr<MWMechanics::AiPackage> package;
switch (container.mType)
{
case ESM::AiSequence::Ai_Wander:
{
package = std::make_unique<AiWander>(
&static_cast<const ESM::AiSequence::AiWander&>(*container.mPackage));
break;
}
case ESM::AiSequence::Ai_Travel:
{
const ESM::AiSequence::AiTravel& source
= static_cast<const ESM::AiSequence::AiTravel&>(*container.mPackage);
if (source.mHidden)
package = std::make_unique<AiInternalTravel>(&source);
else
package = std::make_unique<AiTravel>(&source);
break;
}
case ESM::AiSequence::Ai_Escort:
{
package = std::make_unique<AiEscort>(
&static_cast<const ESM::AiSequence::AiEscort&>(*container.mPackage));
break;
}
case ESM::AiSequence::Ai_Follow:
{
package = std::make_unique<AiFollow>(
&static_cast<const ESM::AiSequence::AiFollow&>(*container.mPackage));
break;
}
case ESM::AiSequence::Ai_Activate:
{
package = std::make_unique<AiActivate>(
&static_cast<const ESM::AiSequence::AiActivate&>(*container.mPackage));
break;
}
case ESM::AiSequence::Ai_Combat:
{
package = std::make_unique<AiCombat>(
&static_cast<const ESM::AiSequence::AiCombat&>(*container.mPackage));
break;
}
case ESM::AiSequence::Ai_Pursue:
{
package = std::make_unique<AiPursue>(
&static_cast<const ESM::AiSequence::AiPursue&>(*container.mPackage));
break;
}
default:
break;
}
if (!package.get())
continue;
onPackageAdded(*package);
mPackages.push_back(std::move(package));
}
mLastAiPackage = static_cast<AiPackageTypeId>(sequence.mLastAiPackage);
}
void AiSequence::fastForward(const MWWorld::Ptr& actor)
{
if (!mPackages.empty())
{
mPackages.front()->fastForward(actor, mAiState);
}
}
} // namespace MWMechanics
| 20,268
|
C++
|
.cpp
| 524
| 26.870229
| 118
| 0.548779
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.