Ashlar checks / tooling (push) Successful in 9s
New [Game] sprint setting, on by default, with sprint speed multiplier (1.4 times run speed), sprint fatigue drain (10 per second on top of running, halved at Athletics 100) and sprint fatigue threshold (0.1 of maximum fatigue to start). A sprint ends when fatigue falls below 1% of maximum; regeneration keeps fatigue just above 0 while running, so exactly 0 is never reached. Sprint is engine action 52, Lua input.ACTION.Sprint and the player's 'Sprint' Lua action, with self.controls.sprint. Defaults are Left Alt and D-pad up, because L3 is already Sneak. Sprinting needs forward movement within 45 degrees, and isn't possible while sneaking, in the block stance, swimming, levitating, knocked down or paralyzed. Pressing Use with a weapon or spell ready ends the sprint until Sprint is released, so no attack starts while sprinting. A sprint counts as running for animations, Athletics and the running fatigue cost. AI doesn't sprint. With the setting off the control does nothing. The rules are in mwmechanics/sprint.cpp with unit tests. The movement scenario gains sprint, tiredsprint and sprintuse phases, run in a circle from the start point so the player stays on land. Closes #27 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
272 lines
13 KiB
C++
272 lines
13 KiB
C++
#include "localscripts.hpp"
|
|
|
|
#include "../mwbase/environment.hpp"
|
|
#include "../mwbase/mechanicsmanager.hpp"
|
|
#include "../mwmechanics/aicombat.hpp"
|
|
#include "../mwmechanics/aiescort.hpp"
|
|
#include "../mwmechanics/aifollow.hpp"
|
|
#include "../mwmechanics/aipackage.hpp"
|
|
#include "../mwmechanics/aipursue.hpp"
|
|
#include "../mwmechanics/aisequence.hpp"
|
|
#include "../mwmechanics/aitravel.hpp"
|
|
#include "../mwmechanics/aiwander.hpp"
|
|
#include "../mwmechanics/attacktype.hpp"
|
|
#include "../mwmechanics/creaturestats.hpp"
|
|
#include "../mwworld/class.hpp"
|
|
#include "../mwworld/ptr.hpp"
|
|
|
|
#include "context.hpp"
|
|
#include "luamanagerimp.hpp"
|
|
|
|
namespace sol
|
|
{
|
|
template <>
|
|
struct is_automagical<MWBase::LuaManager::ActorControls> : std::false_type
|
|
{
|
|
};
|
|
template <>
|
|
struct is_automagical<MWLua::SelfObject> : std::false_type
|
|
{
|
|
};
|
|
}
|
|
|
|
namespace MWLua
|
|
{
|
|
void SelfObject::cacheStat(LuaManager& manager, SelfObject::CachedStat key, sol::main_object value)
|
|
{
|
|
if (mStatsCache.empty())
|
|
{
|
|
manager.addAction(
|
|
[obj = Object(*this)] {
|
|
LocalScripts* scripts = obj.ptr().getRefData().getLuaScripts();
|
|
if (scripts)
|
|
scripts->applyStatsCache();
|
|
},
|
|
"StatUpdateAction");
|
|
}
|
|
mStatsCache[std::move(key)] = std::move(value);
|
|
}
|
|
|
|
void LocalScripts::initializeSelfPackage(const Context& context)
|
|
{
|
|
auto lua = context.sol();
|
|
using ActorControls = MWBase::LuaManager::ActorControls;
|
|
sol::usertype<ActorControls> controls = lua.new_usertype<ActorControls>("ActorControls");
|
|
|
|
#define CONTROL(TYPE, FIELD) \
|
|
sol::property([](const ActorControls& c) { return c.FIELD; }, \
|
|
[](ActorControls& c, const TYPE& v) { \
|
|
c.FIELD = v; \
|
|
c.mChanged = true; \
|
|
})
|
|
controls["movement"] = CONTROL(float, mMovement);
|
|
controls["sideMovement"] = CONTROL(float, mSideMovement);
|
|
controls["pitchChange"] = CONTROL(float, mPitchChange);
|
|
controls["yawChange"] = CONTROL(float, mYawChange);
|
|
controls["run"] = CONTROL(bool, mRun);
|
|
controls["sneak"] = CONTROL(bool, mSneak);
|
|
controls["jump"] = CONTROL(bool, mJump);
|
|
controls["block"] = CONTROL(bool, mBlock);
|
|
controls["sprint"] = CONTROL(bool, mSprint);
|
|
controls["use"] = CONTROL(MWMechanics::AttackType, mUse);
|
|
#undef CONTROL
|
|
|
|
sol::usertype<SelfObject> selfAPI
|
|
= lua.new_usertype<SelfObject>("SelfObject", sol::base_classes, sol::bases<LObject, Object>());
|
|
selfAPI[sol::meta_function::to_string]
|
|
= [](SelfObject& self) { return "openmw.self[" + self.toString() + "]"; };
|
|
selfAPI["object"] = sol::readonly_property([](SelfObject& self) -> LObject { return LObject(self); });
|
|
selfAPI["controls"] = sol::readonly_property([](SelfObject& self) { return &self.mControls; });
|
|
selfAPI["isActive"] = [](SelfObject& self) -> bool { return self.mIsActive; };
|
|
selfAPI["enableAI"] = [](SelfObject& self, bool v) { self.mControls.mDisableAI = !v; };
|
|
selfAPI["saveState"]
|
|
= sol::readonly_property([](const SelfObject& self) { return self.ptr().getRefData().hasChanged(); });
|
|
selfAPI["ATTACK_TYPE"]
|
|
= LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, MWMechanics::AttackType>(lua,
|
|
{ { "NoAttack", MWMechanics::AttackType::NoAttack }, { "Any", MWMechanics::AttackType::Any },
|
|
{ "Chop", MWMechanics::AttackType::Chop }, { "Slash", MWMechanics::AttackType::Slash },
|
|
{ "Thrust", MWMechanics::AttackType::Thrust } }));
|
|
|
|
using AiPackage = MWMechanics::AiPackage;
|
|
sol::usertype<AiPackage> aiPackage = lua.new_usertype<AiPackage>("AiPackage");
|
|
aiPackage["type"] = sol::readonly_property([](const AiPackage& p) -> std::string_view {
|
|
switch (p.getTypeId())
|
|
{
|
|
case MWMechanics::AiPackageTypeId::Wander:
|
|
return "Wander";
|
|
case MWMechanics::AiPackageTypeId::Travel:
|
|
return "Travel";
|
|
case MWMechanics::AiPackageTypeId::Escort:
|
|
return "Escort";
|
|
case MWMechanics::AiPackageTypeId::Follow:
|
|
return "Follow";
|
|
case MWMechanics::AiPackageTypeId::Activate:
|
|
return "Activate";
|
|
case MWMechanics::AiPackageTypeId::Combat:
|
|
return "Combat";
|
|
case MWMechanics::AiPackageTypeId::Pursue:
|
|
return "Pursue";
|
|
case MWMechanics::AiPackageTypeId::AvoidDoor:
|
|
return "AvoidDoor";
|
|
case MWMechanics::AiPackageTypeId::Face:
|
|
return "Face";
|
|
case MWMechanics::AiPackageTypeId::Breathe:
|
|
return "Breathe";
|
|
case MWMechanics::AiPackageTypeId::Cast:
|
|
return "Cast";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
});
|
|
aiPackage["target"] = sol::readonly_property([](const AiPackage& p) -> sol::optional<LObject> {
|
|
MWWorld::Ptr target = p.getTarget();
|
|
if (target.isEmpty())
|
|
return sol::nullopt;
|
|
else
|
|
return LObject(getId(target));
|
|
});
|
|
aiPackage["sideWithTarget"] = sol::readonly_property([](const AiPackage& p) { return p.sideWithTarget(); });
|
|
aiPackage["destPosition"] = sol::readonly_property([](const AiPackage& p) { return p.getDestination(); });
|
|
aiPackage["distance"] = sol::readonly_property([](const AiPackage& p) { return p.getDistance(); });
|
|
aiPackage["duration"] = sol::readonly_property([](const AiPackage& p) { return p.getDuration(); });
|
|
aiPackage["idle"]
|
|
= sol::readonly_property([lua = lua.lua_state()](const AiPackage& p) -> sol::optional<sol::table> {
|
|
if (p.getTypeId() == MWMechanics::AiPackageTypeId::Wander)
|
|
{
|
|
sol::table idles(lua, sol::create);
|
|
const std::vector<unsigned char>& idle = static_cast<const MWMechanics::AiWander&>(p).getIdle();
|
|
if (!idle.empty())
|
|
{
|
|
for (size_t i = 0; i < idle.size(); ++i)
|
|
{
|
|
std::string_view groupName = MWMechanics::AiWander::getIdleGroupName(i);
|
|
idles[groupName] = idle[i];
|
|
}
|
|
return idles;
|
|
}
|
|
}
|
|
return sol::nullopt;
|
|
});
|
|
|
|
aiPackage["isRepeat"] = sol::readonly_property([](const AiPackage& p) { return p.getRepeat(); });
|
|
|
|
selfAPI["_isFleeing"] = [](SelfObject& self) -> bool {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
if (ai.isEmpty())
|
|
return false;
|
|
else
|
|
return ai.isFleeing();
|
|
};
|
|
selfAPI["_getActiveAiPackage"] = [](SelfObject& self) -> sol::optional<std::shared_ptr<AiPackage>> {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
if (ai.isEmpty())
|
|
return sol::nullopt;
|
|
else
|
|
return *ai.begin();
|
|
};
|
|
selfAPI["_iterateAndFilterAiSequence"] = [](SelfObject& self, sol::function callback) {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
|
|
ai.erasePackagesIf([&](auto& entry) {
|
|
auto result = LuaUtil::call(callback, entry);
|
|
if (result.get_type() == sol::type::nil || result.return_count() == 0)
|
|
return false;
|
|
|
|
bool keep = result.template get<bool>();
|
|
return !keep;
|
|
});
|
|
};
|
|
selfAPI["_startAiCombat"] = [](SelfObject& self, const LObject& target, bool cancelOther) {
|
|
const MWWorld::Ptr& targetPtr = target.ptr();
|
|
if (!targetPtr.getClass().isActor())
|
|
throw std::runtime_error("Combat target must be an actor");
|
|
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
ai.stack(MWMechanics::AiCombat(targetPtr), ptr, cancelOther);
|
|
};
|
|
selfAPI["_startAiPursue"] = [](SelfObject& self, const LObject& target, bool cancelOther) {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
ai.stack(MWMechanics::AiPursue(target.ptr()), ptr, cancelOther);
|
|
};
|
|
selfAPI["_startAiFollow"] = [](SelfObject& self, const LObject& target, sol::optional<LCell> cell,
|
|
float duration, const osg::Vec3f& dest, bool repeat, bool cancelOther) {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
std::string_view cellNameId;
|
|
if (cell)
|
|
cellNameId = cell->mStore->getCell()->getNameId();
|
|
ai.stack(
|
|
MWMechanics::AiFollow(getId(target.ptr()), cellNameId, duration, dest.x(), dest.y(), dest.z(), repeat),
|
|
ptr, cancelOther);
|
|
};
|
|
selfAPI["_startAiEscort"] = [](SelfObject& self, const LObject& target, LCell cell, float duration,
|
|
const osg::Vec3f& dest, bool repeat, bool cancelOther) {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
int gameHoursDuration = static_cast<int>(std::ceil(duration / 3600.0));
|
|
auto* esmCell = cell.mStore->getCell();
|
|
std::string_view cellNameId;
|
|
if (!esmCell->isExterior())
|
|
cellNameId = esmCell->getNameId();
|
|
ai.stack(MWMechanics::AiEscort(
|
|
getId(target.ptr()), cellNameId, gameHoursDuration, dest.x(), dest.y(), dest.z(), repeat),
|
|
ptr, cancelOther);
|
|
};
|
|
selfAPI["_startAiWander"]
|
|
= [](SelfObject& self, int distance, int duration, sol::table luaIdle, bool repeat, bool cancelOther) {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
std::vector<unsigned char> idle;
|
|
// Lua index starts at 1
|
|
for (size_t i = 1; i <= luaIdle.size(); i++)
|
|
idle.emplace_back(luaIdle.get<unsigned char>(i));
|
|
ai.stack(MWMechanics::AiWander(distance, duration, 0, idle, repeat), ptr, cancelOther);
|
|
};
|
|
selfAPI["_startAiTravel"] = [](SelfObject& self, const osg::Vec3f& target, bool repeat, bool cancelOther) {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWMechanics::AiSequence& ai = ptr.getClass().getCreatureStats(ptr).getAiSequence();
|
|
ai.stack(MWMechanics::AiTravel(target.x(), target.y(), target.z(), repeat), ptr, cancelOther);
|
|
};
|
|
selfAPI["_enableLuaAnimations"] = [](SelfObject& self, bool enable) {
|
|
const MWWorld::Ptr& ptr = self.ptr();
|
|
MWBase::Environment::get().getMechanicsManager()->enableLuaAnimations(ptr, enable);
|
|
};
|
|
}
|
|
|
|
LocalScripts::LocalScripts(LuaUtil::LuaState* lua, const LObject& obj, LuaUtil::ScriptTracker* tracker)
|
|
: LuaUtil::ScriptsContainer(lua, "L" + obj.id().toString(), tracker, false)
|
|
, mData(obj)
|
|
{
|
|
lua->protectedCall(
|
|
[&](LuaUtil::LuaView& view) { addPackage("openmw.self", sol::make_object(view.sol(), &mData)); });
|
|
registerEngineHandlers({ &mOnActiveHandlers, &mOnInactiveHandlers, &mOnConsumeHandlers, &mOnActivatedHandlers,
|
|
&mOnTeleportedHandlers, &mOnAnimationTextKeyHandlers, &mOnPlayAnimationHandlers, &mOnAnimationEndedHandlers,
|
|
&mOnSkillUse, &mOnSkillLevelUp, &mOnJailTimeServed });
|
|
}
|
|
|
|
void LocalScripts::setActive(bool active, bool callHandlers)
|
|
{
|
|
mData.mIsActive = active;
|
|
if (callHandlers)
|
|
{
|
|
if (active)
|
|
callEngineHandlers(mOnActiveHandlers);
|
|
else
|
|
callEngineHandlers(mOnInactiveHandlers);
|
|
}
|
|
}
|
|
|
|
void LocalScripts::applyStatsCache()
|
|
{
|
|
const auto& ptr = mData.ptr();
|
|
for (auto& [stat, value] : mData.mStatsCache)
|
|
stat(ptr, value);
|
|
mData.mStatsCache.clear();
|
|
}
|
|
}
|