An OpenMW mod that lets you play the whole Elder Scrolls III: Morrowind as a top-down isometric game — with full online co-op or MMO modes.
C++
#include "Hooks.hpp"
#include <algorithm>
#include <components/esm/util.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/windowmanager.hpp"
#include "../mwbase/world.hpp"
#include "../mwgui/container.hpp"
#include "../mwworld/cellstore.hpp"
#include <components/misc/strings/algorithm.hpp>
#include "ActorList.hpp"
#include "Cell.hpp"
#include "CellController.hpp"
#include "DedicatedActor.hpp"
#include "DedicatedPlayer.hpp"
#include "LocalActor.hpp"
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadspel.hpp>
#include <components/esm3/loadweap.hpp>
#include "MechanicsHelper.hpp"
#include <osg/Quat>
#include <components/interpreter/context.hpp>
#include "../mwmechanics/creaturestats.hpp"
#include "../mwmechanics/npcstats.hpp"
#include "../mwmechanics/summoning.hpp"
#include "../mwworld/containerstore.hpp"
#include "../mwworld/player.hpp"
#include "../mwworld/worldmodel.hpp"
#include "../mwworld/class.hpp"
#include "Ids.hpp"
#include "LocalPlayer.hpp"
#include "Main.hpp"
#include "Networking.hpp"
#include "ObjectList.hpp"
#include "PlayerList.hpp"
#include "ScriptController.hpp"
#include "Worldstate.hpp"
namespace mwmp::hooks
{
namespace
{
bool shouldSendProgress()
{
return isLoggedIn() && !ServerChange::isActive();
}
bool isLocalPlayerStats(const void* stats)
{
const MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
return !player.isEmpty() && stats == &player.getClass().getNpcStats(player);
}
int sServerChanges = 0;
// The object list to fill, reset, or nullptr when there is nothing to send (single player, or an object
// outside the world, such as an item in a container)
ObjectList* startObjectList(const MWWorld::Ptr& ptr)
{
if (!isMultiplayer() || ptr.isEmpty() || !ptr.isInCell() || ptr.getCell()->getCell()->isEsm4())
return nullptr;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin = CLIENT_GAMEPLAY;
return objectList;
}
}
bool isMultiplayer()
{
return Main::isInitialized();
}
bool isLoggedIn()
{
return isMultiplayer() && Main::get().getLocalPlayer()->isLoggedIn();
}
bool isLocalPlayer(const MWWorld::Ptr& ptr)
{
return !ptr.isEmpty() && ptr == MWBase::Environment::get().getWorld()->getPlayerPtr();
}
bool isDedicatedPlayer(const MWWorld::Ptr& ptr)
{
return isMultiplayer() && !ptr.isEmpty() && PlayerList::isDedicatedPlayer(ptr);
}
bool isLocalActor(const MWWorld::Ptr& ptr)
{
return isMultiplayer() && !ptr.isEmpty() && Main::get().getCellController()->isLocalActor(ptr);
}
bool isDedicatedActor(const MWWorld::Ptr& ptr)
{
return isMultiplayer() && !ptr.isEmpty() && Main::get().getCellController()->isDedicatedActor(ptr);
}
bool isLocallyControlled(const MWWorld::Ptr& actor)
{
return isLocalPlayer(actor) || isLocalActor(actor);
}
bool isRemotelyControlled(const MWWorld::Ptr& actor)
{
return isDedicatedPlayer(actor) || isDedicatedActor(actor);
}
bool requestActivation(const MWWorld::Ptr& object, const MWWorld::Ptr& actor)
{
if (!isMultiplayer() || !isLocallyControlled(actor))
return false;
// Before logging in there is nothing to ask; the activation then doesn't happen at all
if (!isLoggedIn())
return true;
ObjectList* objectList = startObjectList(object);
if (!objectList)
return false;
objectList->addObjectActivate(object, actor);
objectList->sendObjectActivate();
return true;
}
void sendObjectSound(const MWWorld::Ptr& ptr, const ESM::RefId& soundId, float volume, float pitch)
{
if (soundId.empty())
return;
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectSound(ptr, idString(soundId), volume, pitch);
objectList->sendObjectSound();
}
}
void sendObjectDelete(const MWWorld::Ptr& ptr)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectGeneric(ptr);
objectList->sendObjectDelete();
}
}
void sendObjectLock(const MWWorld::Ptr& ptr, int lockLevel)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectLock(ptr, lockLevel);
objectList->sendObjectLock();
}
}
void sendObjectTrap(const MWWorld::Ptr& ptr, const ESM::Position& pos, bool isDisarmed)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectTrap(ptr, pos, isDisarmed);
objectList->sendObjectTrap();
}
}
void sendObjectState(const MWWorld::Ptr& ptr, bool enabled)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectState(ptr, enabled);
objectList->sendObjectState();
}
}
void sendObjectScale(const MWWorld::Ptr& ptr, float scale)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectScale(ptr, scale);
objectList->sendObjectScale();
}
}
void sendObjectAnimPlay(const MWWorld::Ptr& ptr, const std::string& group, int mode)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectAnimPlay(ptr, group, mode);
objectList->sendObjectAnimPlay();
}
}
void sendDoorState(const MWWorld::Ptr& door, MWWorld::DoorState state)
{
if (ObjectList* objectList = startObjectList(door))
{
objectList->addDoorState(door, state);
objectList->sendDoorState();
}
}
void sendObjectPlace(const MWWorld::Ptr& ptr, bool droppedByPlayer)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectPlace(ptr, droppedByPlayer);
objectList->sendObjectPlace();
}
}
bool requestItemUse(const MWWorld::Ptr& item, bool usingItemMagic, int drawState)
{
if (!isMultiplayer() || item.isEmpty())
return false;
if (isLoggedIn())
Main::get().getLocalPlayer()->sendItemUse(item, usingItemMagic, static_cast<char>(drawState));
return true;
}
void sendSelectedSpell(const ESM::RefId& spellId)
{
if (isLoggedIn())
Main::get().getLocalPlayer()->sendSelectedSpell(spellId);
}
void sendContainerChange(const MWWorld::Ptr& container, int action, int subAction,
const std::vector<std::pair<MWWorld::Ptr, int>>& items)
{
if (items.empty())
return;
ObjectList* objectList = startObjectList(container);
if (!objectList)
return;
objectList->cell = container.getCell()->getCell()->getEsm3();
objectList->action = static_cast<unsigned char>(action);
objectList->containerSubAction = static_cast<unsigned char>(subAction);
BaseObject baseObject = objectList->getBaseObjectFromPtr(container);
for (const auto& [item, count] : items)
{
// An item put in: count is how many; an item taken out: how many there are, and how many are taken
if (action == BaseObjectList::ADD)
objectList->addContainerItem(baseObject, item, count, 0);
else
objectList->addContainerItem(baseObject, item, item.getCellRef().getCount(), count);
}
objectList->addBaseObject(baseObject);
objectList->sendContainer();
}
bool isCurrentContainer(const MWWorld::Ptr& container)
{
if (!isMultiplayer() || container.isEmpty())
return false;
const CurrentContainer& current = Main::get().getLocalPlayer()->currentContainer;
if (current.refNum == container.getCellRef().getMpRefNum()
&& current.mpNum == container.getCellRef().getMpNum())
return true;
// Containers next to it that opened with it, in its window, count as open too (ContainerWindow::setPtr)
MWBase::WindowManager* windowManager = MWBase::Environment::get().getWindowManager();
if (!windowManager->containsMode(MWGui::GM_Container))
return false;
MWGui::ContainerWindow* containerWindow = windowManager->getContainerWindow();
MWGui::ItemModel* model = containerWindow ? containerWindow->getModel() : nullptr;
return model && model->usesContainer(container);
}
bool denyRemoteCellChange(const MWWorld::Ptr& ptr, const MWWorld::CellStore& newCell)
{
if (!isMultiplayer() || newCell.getCell()->isEsm4())
return false;
CellController* cellController = Main::get().getCellController();
const ESM::Cell& cell = newCell.getCell()->getEsm3();
if (DedicatedPlayer* player = PlayerList::getPlayer(ptr))
return !cellController->isSameCell(player->cell, cell);
if (cellController->isDedicatedActor(ptr))
return !cellController->isSameCell(cellController->getDedicatedActor(ptr)->cell, cell);
return false;
}
void updatePtr(const MWWorld::Ptr& oldPtr, const MWWorld::Ptr& newPtr)
{
// Not skipped when the two compare equal: a Ptr compares only its reference, which an object moved to
// another cell keeps (CellStore::moveTo), so the new Ptr differs only in its cell, which is what's tracked
// (an actor's cell change is seen by its Ptr's cell: mwmp::Cell::updateLocal)
if (!isMultiplayer())
return;
CellController* cellController = Main::get().getCellController();
if (cellController->isLocalActor(oldPtr))
cellController->getLocalActor(oldPtr)->setPtr(newPtr);
else if (cellController->isDedicatedActor(oldPtr))
cellController->getDedicatedActor(oldPtr)->setPtr(newPtr);
else if (DedicatedPlayer* player = PlayerList::getPlayer(oldPtr))
player->setPtr(newPtr);
// Isowind MMO: this player's own followers (what the others see of them goes with them)
else if (MechanicsHelper::isPrivateFollower(newPtr))
MechanicsHelper::onPrivateFollowerMoved(newPtr);
}
ServerChange::ServerChange()
{
++sServerChanges;
}
ServerChange::~ServerChange()
{
--sServerChanges;
}
bool ServerChange::isActive()
{
return sServerChanges > 0;
}
mwmp::Attack* getLocalAttack(const MWWorld::Ptr& actor)
{
return isMultiplayer() && !actor.isEmpty() ? MechanicsHelper::getLocalAttack(actor) : nullptr;
}
mwmp::Attack* getDedicatedAttack(const MWWorld::Ptr& actor)
{
return isMultiplayer() && !actor.isEmpty() ? MechanicsHelper::getDedicatedAttack(actor) : nullptr;
}
mwmp::Cast* getLocalCast(const MWWorld::Ptr& actor)
{
return isMultiplayer() && !actor.isEmpty() ? MechanicsHelper::getLocalCast(actor) : nullptr;
}
mwmp::Cast* getDedicatedCast(const MWWorld::Ptr& actor)
{
return isMultiplayer() && !actor.isEmpty() ? MechanicsHelper::getDedicatedCast(actor) : nullptr;
}
void updateLocalAttackState(const MWWorld::Ptr& actor)
{
mwmp::Attack* attack = getLocalAttack(actor);
if (!attack)
return;
const MWMechanics::CreatureStats& stats = actor.getClass().getCreatureStats(actor);
if (stats.getDrawState() != MWMechanics::DrawState::Weapon)
return;
const bool pressed = stats.getAttackingOrSpell();
if (attack->pressed == pressed)
return;
MechanicsHelper::resetAttack(attack);
attack->type = MechanicsHelper::isUsingRangedWeapon(actor) ? mwmp::Attack::RANGED : mwmp::Attack::MELEE;
attack->pressed = pressed;
// A ranged attack being released is sent when the projectile leaves (onProjectileReleased), with the final
// attack strength that decides its speed
if (attack->type == mwmp::Attack::MELEE || pressed)
attack->shouldSend = true;
}
void recordAttackAnimation(const MWWorld::Ptr& actor, const std::string& attackType)
{
if (mwmp::Attack* attack = getLocalAttack(actor))
attack->attackAnimation = attackType;
}
void prepareLocalHit(const MWWorld::Ptr& attacker, const MWWorld::Ptr& victim, const osg::Vec3f& hitPosition,
bool success, bool appliedEnchantment)
{
mwmp::Attack* attack = getLocalAttack(attacker);
if (!attack)
return;
attack->type = mwmp::Attack::MELEE;
attack->isHit = true;
attack->success = success;
attack->applyWeaponEnchantment = appliedEnchantment;
attack->hitPosition = MechanicsHelper::getPositionFromVector(hitPosition);
MechanicsHelper::assignAttackTarget(attack, victim);
}
void finishLocalMiss(const MWWorld::Ptr& attacker)
{
mwmp::Attack* attack = getLocalAttack(attacker);
if (!attack)
return;
attack->pressed = false;
attack->isHit = false;
attack->success = false;
attack->shouldSend = true;
}
void finishLocalHit(const MWWorld::Ptr& attacker, const MWWorld::Ptr& victim, float damage, bool success)
{
mwmp::Attack* attack = getLocalAttack(attacker);
if (!attack || !attack->isHit)
return;
attack->pressed = false;
attack->success = success;
attack->damage = success ? damage : 0.f;
attack->knockdown = success && victim.getClass().getCreatureStats(victim).getKnockedDown();
MechanicsHelper::assignAttackTarget(attack, victim);
attack->shouldSend = true;
// The server hears of the hit too, for its scripts
if (ObjectList* objectList = startObjectList(victim))
{
objectList->addObjectHit(victim, attacker, *attack);
objectList->sendObjectHit();
}
if (isLocalPlayer(victim))
Main::get().getLocalPlayer()->updateStatsDynamic(true);
}
bool decideKnockdown(const MWWorld::Ptr& attacker, bool localDecision)
{
if (mwmp::Attack* attack = getDedicatedAttack(attacker))
return attack->knockdown;
return localDecision;
}
bool decideBlock(const MWWorld::Ptr& attacker, bool localDecision)
{
if (mwmp::Attack* attack = getDedicatedAttack(attacker))
return attack->block;
if (mwmp::Attack* attack = getLocalAttack(attacker))
attack->block = localDecision;
return localDecision;
}
void recordKiller(const MWWorld::Ptr& victim, const MWWorld::Ptr& killer)
{
if (!isMultiplayer() || victim.isEmpty())
return;
const mwmp::Target target = killer.isEmpty() ? mwmp::Target() : MechanicsHelper::getTarget(killer);
if (isLocalPlayer(victim))
Main::get().getLocalPlayer()->killer = target;
else if (isLocalActor(victim))
Main::get().getCellController()->getLocalActor(victim)->killer = target;
}
void onProjectileReleased(const MWWorld::Ptr& actor, const MWWorld::Ptr& weapon, const MWWorld::Ptr& ammo,
float& attackStrength, osg::Vec3f& launchPos, osg::Quat& orient)
{
if (mwmp::Attack* attack = getLocalAttack(actor))
{
attack->type = mwmp::Attack::RANGED;
attack->pressed = false;
attack->attackStrength = attackStrength;
attack->rangedWeaponId = weapon.isEmpty() ? std::string() : idString(weapon.getCellRef().getRefId());
attack->rangedAmmoId = ammo.isEmpty() || ammo == weapon ? std::string() : idString(ammo.getCellRef().getRefId());
attack->projectileOrigin.origin[0] = launchPos.x();
attack->projectileOrigin.origin[1] = launchPos.y();
attack->projectileOrigin.origin[2] = launchPos.z();
attack->projectileOrigin.orientation[0] = static_cast<float>(orient.x());
attack->projectileOrigin.orientation[1] = static_cast<float>(orient.y());
attack->projectileOrigin.orientation[2] = static_cast<float>(orient.z());
attack->projectileOrigin.orientation[3] = static_cast<float>(orient.w());
attack->shouldSend = true;
}
else if (mwmp::Attack* attack = getDedicatedAttack(actor))
{
attackStrength = attack->attackStrength;
const auto& origin = attack->projectileOrigin;
launchPos = osg::Vec3f(origin.origin[0], origin.origin[1], origin.origin[2]);
orient = osg::Quat(origin.orientation[0], origin.orientation[1], origin.orientation[2], origin.orientation[3]);
}
}
bool onProjectileHit(const MWWorld::Ptr& attacker, bool hasVictim, const osg::Vec3f& hitPosition,
bool success, bool appliedEnchantment)
{
if (isRemotelyControlled(attacker))
return false;
mwmp::Attack* attack = getLocalAttack(attacker);
if (!attack)
return true;
attack->type = mwmp::Attack::RANGED;
attack->isHit = true;
attack->success = success;
attack->applyAmmoEnchantment = appliedEnchantment;
attack->hitPosition = MechanicsHelper::getPositionFromVector(hitPosition);
// Without a victim no damage comes to say how it went: send it now
if (!hasVictim)
attack->shouldSend = true;
return true;
}
void onDeathAnimation(const MWWorld::Ptr& actor, int deathState, float& startpoint)
{
if (!isMultiplayer())
return;
const bool finished = actor.getClass().getCreatureStats(actor).isDeathAnimationFinished();
if (finished && (isLocalActor(actor) || isDedicatedActor(actor)))
startpoint = 1.f;
// Isowind MMO: a one-off event's person this client runs itself, dead where it died for this player
if (finished && Main::get().getCellController()->isClientLocalActor(actor))
startpoint = 1.f;
if (isLocalPlayer(actor))
Main::get().getLocalPlayer()->sendDeath(static_cast<char>(deathState));
else if (!finished && isLocalActor(actor))
Main::get().getCellController()->getLocalActor(actor)->sendDeath(static_cast<char>(deathState));
}
void onDeathAnimationFinished(const MWWorld::Ptr& actor)
{
if (isLocalActor(actor))
Main::get().getCellController()->getLocalActor(actor)->creatureStats.mDeathAnimationFinished = true;
// Isowind MMO: a one-off event's person this client runs itself died, for this player (the body at rest)
if (isMultiplayer() && Main::get().getCellController()->isClientLocalActor(actor))
MechanicsHelper::sendClientLocalDeath(actor);
}
void recordAnimationPlay(const MWWorld::Ptr& actor, std::string_view group, int mode, int count, bool persist)
{
if (!isLocalActor(actor))
return;
LocalActor* localActor = Main::get().getCellController()->getLocalActor(actor);
localActor->animation.groupname = std::string(group);
localActor->animation.mode = mode;
localActor->animation.count = count;
localActor->animation.persist = persist;
}
void sendFactionExpulsion(const ESM::RefId& factionId, bool expelled)
{
if (isLoggedIn())
Main::get().getLocalPlayer()->sendFactionExpulsionState(factionId, expelled);
}
void onArrestAttempt()
{
if (!isMultiplayer())
return;
LocalPlayer* localPlayer = Main::get().getLocalPlayer();
localPlayer->diedSinceArrestAttempt = false;
localPlayer->closeInventoryWindows();
}
bool hasDiedSinceArrestAttempt()
{
return isMultiplayer() && Main::get().getLocalPlayer()->diedSinceArrestAttempt;
}
bool isAlliedPlayer(const MWWorld::Ptr& actor, const MWWorld::Ptr& other)
{
if (!isMultiplayer() || actor.isEmpty() || other.isEmpty() || actor == other)
return false;
const auto contains = [](const std::vector<RakNet::RakNetGUID>& guids, const RakNet::RakNetGUID& guid) {
return std::find(guids.begin(), guids.end(), guid) != guids.end();
};
LocalPlayer* localPlayer = Main::get().getLocalPlayer();
if (isLocalPlayer(actor))
{
DedicatedPlayer* otherPlayer = PlayerList::getPlayer(other);
return otherPlayer && contains(localPlayer->alliedPlayers, otherPlayer->guid);
}
DedicatedPlayer* player = PlayerList::getPlayer(actor);
if (!player)
return false;
if (isLocalPlayer(other))
return contains(player->alliedPlayers, localPlayer->guid);
DedicatedPlayer* otherPlayer = PlayerList::getPlayer(other);
return otherPlayer && contains(player->alliedPlayers, otherPlayer->guid);
}
namespace
{
bool sPvp = false;
bool sMmo = false;
bool isPlayer(const MWWorld::Ptr& ptr)
{
return isLocalPlayer(ptr) || isDedicatedPlayer(ptr);
}
}
bool applyServerRule(const std::string& name, const std::string& value)
{
if (name == "isowind pvp")
sPvp = value == "true";
else if (name == "isowind mode")
sMmo = value == "mmo";
else
return false;
return true;
}
bool isPvpBlocked(const MWWorld::Ptr& attacker, const MWWorld::Ptr& victim)
{
if (!isMultiplayer() || attacker.isEmpty() || victim.isEmpty() || attacker == victim || !isPlayer(attacker))
return false;
// Isowind MMO: someone's follower as this game shows it can't be hurt by a player (the real one is in its
// owner's game)
if (MechanicsHelper::isFollowerCopy(victim))
return true;
return !sPvp && isPlayer(victim);
}
bool isMmoMode()
{
return isMultiplayer() && sMmo;
}
bool isFollowerCopy(const MWWorld::Ptr& ptr)
{
return isMultiplayer() && MechanicsHelper::isFollowerCopy(ptr);
}
void requestFollowerCopy(const MWWorld::Ptr& ptr)
{
if (isMultiplayer())
MechanicsHelper::requestFollowerCopy(ptr);
}
void sendSummonRemoval(const MWWorld::Ptr& creature)
{
if (!isLoggedIn() || creature.isEmpty())
return;
// The local player's own summons, or those in cells this client has authority over
bool isOurs = isLocalActor(creature);
if (!isOurs)
{
const MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
for (const auto& [_, refNum] : player.getClass().getCreatureStats(player).getSummonedCreatureMap())
isOurs = isOurs || refNum == creature.getCellRef().getRefNum();
}
if (isOurs)
sendObjectDelete(creature);
}
void onLocalCastStart(const MWWorld::Ptr& caster, const ESM::RefId& spellId, bool isMagicItem)
{
mwmp::Cast* cast = getLocalCast(caster);
if (!cast || spellId.empty())
return;
MechanicsHelper::resetCast(cast);
cast->type = isMagicItem ? mwmp::Cast::ITEM : mwmp::Cast::REGULAR;
cast->spellId = isMagicItem ? std::string() : idString(spellId);
cast->pressed = true;
cast->shouldSend = true;
}
void onLocalItemCast(const MWWorld::Ptr& caster, const MWWorld::Ptr& item)
{
mwmp::Cast* cast = getLocalCast(caster);
if (!cast || item.isEmpty())
return;
MechanicsHelper::resetCast(cast);
cast->type = mwmp::Cast::ITEM;
cast->itemId = idString(item.getCellRef().getRefId());
cast->success = true;
cast->shouldSend = true;
}
bool decideSpellSuccess(const MWWorld::Ptr& caster, bool localRoll)
{
if (mwmp::Cast* cast = getDedicatedCast(caster))
{
cast->pressed = false;
return cast->success;
}
if (mwmp::Cast* cast = getLocalCast(caster))
{
cast->success = localRoll;
cast->pressed = false;
cast->shouldSend = true;
}
return localRoll;
}
bool isCastPaidHere(const MWWorld::Ptr& caster)
{
return !isRemotelyControlled(caster);
}
void onMagicBoltLaunched(const MWWorld::Ptr& caster, osg::Vec3f& pos, osg::Quat& orient)
{
if (mwmp::Cast* cast = getLocalCast(caster))
{
cast->hasProjectile = true;
cast->projectileOrigin.origin[0] = pos.x();
cast->projectileOrigin.origin[1] = pos.y();
cast->projectileOrigin.origin[2] = pos.z();
cast->projectileOrigin.orientation[0] = static_cast<float>(orient.x());
cast->projectileOrigin.orientation[1] = static_cast<float>(orient.y());
cast->projectileOrigin.orientation[2] = static_cast<float>(orient.z());
cast->projectileOrigin.orientation[3] = static_cast<float>(orient.w());
}
else if (mwmp::Cast* cast = getDedicatedCast(caster))
{
if (!cast->hasProjectile)
return;
const auto& origin = cast->projectileOrigin;
pos = osg::Vec3f(origin.origin[0], origin.origin[1], origin.origin[2]);
orient = osg::Quat(origin.orientation[0], origin.orientation[1], origin.orientation[2], origin.orientation[3]);
}
}
bool requestSpellLock(const MWWorld::Ptr& caster, const MWWorld::Ptr& target, int lockLevel)
{
if (!isMultiplayer())
return false;
// Every client carries out a remote caster's spell too: only the caster's own client asks
if (!isRemotelyControlled(caster))
sendObjectLock(target, lockLevel);
return true;
}
void sendMarkLocation(const MWWorld::Ptr& player)
{
if (isLoggedIn() && isLocalPlayer(player) && player.isInCell() && !player.getCell()->getCell()->isEsm4())
Main::get().getLocalPlayer()->sendMarkLocation(
player.getCell()->getCell()->getEsm3(), player.getRefData().getPosition());
}
ESM::RefNum requestSummon(const ESM::RefId& effectId, const MWWorld::Ptr& summoner,
const ESM::RefId& spellId, float duration)
{
if (!isMultiplayer())
return MWMechanics::summonCreature(effectId, summoner);
// A remote summoner's creature comes from the server, asked for by its own client
if (isRemotelyControlled(summoner))
return ESM::RefNum();
// Placed here only to find a spot for it, then handed to the server to spawn for everyone
const ESM::RefNum placedNum = MWMechanics::summonCreature(effectId, summoner);
auto& creatureMap = summoner.getClass().getCreatureStats(summoner).getSummonedCreatureMap();
for (auto it = creatureMap.begin(); it != creatureMap.end(); ++it)
{
if (it->first == effectId && it->second == placedNum)
{
it->second = ESM::RefNum();
break;
}
}
const MWWorld::Ptr placed = placedNum.isSet()
? MWBase::Environment::get().getWorldModel()->getPtr(placedNum)
: MWWorld::Ptr();
if (placed.isEmpty())
return ESM::RefNum();
if (ObjectList* objectList = startObjectList(placed))
{
objectList->addObjectSpawn(placed, summoner, idString(spellId),
ESM::MagicEffect::refIdToIndex(effectId), duration);
objectList->sendObjectSpawn();
}
MWBase::Environment::get().getWorld()->deleteObject(placed);
return ESM::RefNum();
}
void linkSummon(const MWWorld::Ptr& summoner, const ESM::RefId& effectId, ESM::RefNum creature)
{
MWMechanics::CreatureStats& stats = summoner.getClass().getCreatureStats(summoner);
auto& creatureMap = stats.getSummonedCreatureMap();
bool linked = false;
for (auto it = creatureMap.begin(); it != creatureMap.end(); ++it)
{
if (it->first == effectId && !it->second.isSet())
{
it->second = creature;
linked = true;
break;
}
}
if (!linked)
creatureMap.emplace(effectId, creature);
stats.getActiveSpells().linkSummon(effectId, creature);
}
void onActiveSpellAdded(const MWWorld::Ptr& actor, const MWMechanics::ActiveSpells::ActiveSpellParams& params)
{
if (!isLoggedIn() || params.isFromServer() || !params.hasFlag(ESM::ActiveSpells::Flag_Temporary))
return;
if (isLocalPlayer(actor))
Main::get().getLocalPlayer()->sendSpellsActiveAddition(params);
else if (isLocalActor(actor))
Main::get().getCellController()->getLocalActor(actor)->sendSpellsActiveAddition(params);
}
void onActiveSpellExpired(const MWWorld::Ptr& actor, const MWMechanics::ActiveSpells::ActiveSpellParams& params)
{
if (!isLoggedIn() || !params.hasFlag(ESM::ActiveSpells::Flag_Temporary))
return;
const bool stacking = params.hasFlag(ESM::ActiveSpells::Flag_Stackable);
if (isLocalPlayer(actor))
Main::get().getLocalPlayer()->sendSpellsActiveRemoval(params.getSourceSpellId(), stacking);
else if (isLocalActor(actor))
Main::get().getCellController()->getLocalActor(actor)->sendSpellsActiveRemoval(
params.getSourceSpellId(), stacking);
}
void sendSpellbookChange(const MWWorld::Ptr& actor, const ESM::RefId& spellId, bool added)
{
if (isLoggedIn() && isLocalPlayer(actor))
Main::get().getLocalPlayer()->sendSpellChange(
spellId, added ? SpellbookChanges::ADD : SpellbookChanges::REMOVE);
}
void sendPowerUse(const MWWorld::Ptr& actor, const ESM::RefId& spellId)
{
if (!isLoggedIn() || !isLocalPlayer(actor))
return;
const MWWorld::TimeStamp now = MWBase::Environment::get().getWorld()->getTimeStamp();
Main::get().getLocalPlayer()->sendCooldownChange(spellId, now.getDay(), now.getHour());
}
void onPlayerItemAdded(const MWWorld::Ptr& container, const MWWorld::Ptr& item, int count)
{
if (!isLoggedIn() || !isLocalPlayer(container) || count <= 0)
return;
LocalPlayer* localPlayer = Main::get().getLocalPlayer();
if (!localPlayer->avoidSendingInventoryPackets)
localPlayer->sendItemChange(item, count, InventoryChanges::ADD);
}
void onPlayerItemRemoved(const MWWorld::Ptr& container, const MWWorld::Ptr& item, int count)
{
if (!isLoggedIn() || !isLocalPlayer(container) || count <= 0)
return;
LocalPlayer* localPlayer = Main::get().getLocalPlayer();
if (!localPlayer->avoidSendingInventoryPackets)
localPlayer->sendItemChange(item, count, InventoryChanges::REMOVE);
}
void onJournalEntry(const ESM::RefId& quest, int index, const MWWorld::Ptr& actor)
{
if (shouldSendProgress())
Main::get().getLocalPlayer()->sendJournalEntry(quest, index, actor);
}
void onJournalIndex(const ESM::RefId& quest, int index)
{
if (shouldSendProgress())
Main::get().getLocalPlayer()->sendJournalIndex(quest, index);
}
void onTopicLearned(const ESM::RefId& topic)
{
if (shouldSendProgress())
Main::get().getLocalPlayer()->sendTopic(topic);
}
void onFactionRank(const void* stats, const ESM::RefId& faction, int rank)
{
if (shouldSendProgress() && isLocalPlayerStats(stats))
Main::get().getLocalPlayer()->sendFactionRank(faction, rank);
}
void onFactionExpulsion(const void* stats, const ESM::RefId& faction, bool expelled)
{
if (shouldSendProgress() && isLocalPlayerStats(stats))
Main::get().getLocalPlayer()->sendFactionExpulsionState(faction, expelled);
}
void onFactionReputation(const void* stats, const ESM::RefId& faction, int reputation)
{
if (shouldSendProgress() && isLocalPlayerStats(stats))
Main::get().getLocalPlayer()->sendFactionReputation(faction, reputation);
}
void onSpellbookChange(const void* spells, const ESM::RefId& spellId, bool added)
{
if (!shouldSendProgress())
return;
const MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayerPtr();
if (!player.isEmpty() && spells == &player.getClass().getCreatureStats(player).getSpells())
Main::get().getLocalPlayer()->sendSpellChange(
spellId, added ? SpellbookChanges::ADD : SpellbookChanges::REMOVE);
}
bool sendPotionRecord(const ESM::Potion& potion, int count)
{
if (!isMultiplayer())
return false;
if (count > 0)
Main::get().getNetworking()->getWorldstate()->sendPotionRecord(&potion, static_cast<unsigned int>(count));
return true;
}
bool sendEnchantmentRecord(const ESM::Enchantment& enchantment, int itemCount)
{
if (!isMultiplayer())
return false;
Main::get().getNetworking()->getWorldstate()->sendEnchantmentRecord(&enchantment);
Main::get().getLocalPlayer()->storeLastEnchantmentQuantity(static_cast<unsigned int>(itemCount));
return true;
}
bool sendEnchantedItemRecord(const ESM::Armor* armor, const ESM::Book* book, const ESM::Clothing* clothing,
const ESM::Weapon* weapon, const ESM::RefId& baseId)
{
if (!isMultiplayer())
return false;
Worldstate* worldstate = Main::get().getNetworking()->getWorldstate();
const std::string base = idString(baseId);
if (armor)
worldstate->sendArmorRecord(armor, base);
else if (book)
worldstate->sendBookRecord(book, base);
else if (clothing)
worldstate->sendClothingRecord(clothing, base);
else if (weapon)
worldstate->sendWeaponRecord(weapon, base, Main::get().getLocalPlayer()->lastEnchantmentQuantity);
return true;
}
bool sendSpellRecord(const ESM::Spell& spell)
{
if (!isMultiplayer())
return false;
Main::get().getNetworking()->getWorldstate()->sendSpellRecord(&spell);
return true;
}
void sendPlayerInventory()
{
if (isLoggedIn())
Main::get().getLocalPlayer()->sendInventory();
}
void beginBatchedItemRemovals()
{
if (isMultiplayer())
Main::get().getLocalPlayer()->avoidSendingInventoryPackets = true;
}
void endBatchedItemRemovals()
{
if (!isMultiplayer())
return;
// The inventory as it is now, all at once
LocalPlayer* localPlayer = Main::get().getLocalPlayer();
localPlayer->avoidSendingInventoryPackets = false;
if (isLoggedIn())
localPlayer->sendInventory();
}
namespace
{
// An object list for a change a script makes, telling the server which script it was; nullptr when there is
// nothing to send (single player, not logged in, an object without a network identity)
ObjectList* startScriptObjectList(const Interpreter::Context& context, const MWWorld::Ptr& ptr)
{
if (!isLoggedIn() || ptr.isEmpty() || !ptr.isInCell() || ptr.getCell()->getCell()->isEsm4())
return nullptr;
if (ptr.getCellRef().getMpRefNum() == 0 && ptr.getCellRef().getMpNum() == 0
&& !PlayerList::isDedicatedPlayer(ptr))
return nullptr;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin
= static_cast<unsigned char>(ScriptController::getPacketOriginFromContextType(context.getContextType()));
objectList->originClientScript = context.getCurrentScriptName();
return objectList;
}
bool isFromConsoleOrDialogue(const Interpreter::Context& context)
{
return context.getContextType() == Interpreter::Context::CONSOLE
|| context.getContextType() == Interpreter::Context::DIALOGUE;
}
}
bool requestScriptObjectState(const Interpreter::Context& context, const MWWorld::Ptr& ptr, bool enabled)
{
if (!isMultiplayer())
return false;
ObjectList* objectList = startScriptObjectList(context, ptr);
if (!objectList)
return false;
// A local script runs every frame: only ask once (the server kicks clients that keep asking)
const auto state = enabled ? MWWorld::RefData::StateCommunication::Enabled
: MWWorld::RefData::StateCommunication::Disabled;
if (isFromConsoleOrDialogue(context) || ptr.getRefData().getLastCommunicatedState() != state)
{
ptr.getRefData().setLastCommunicatedState(state);
objectList->addObjectState(ptr, enabled);
objectList->sendObjectState();
}
return true;
}
bool requestScriptLock(const Interpreter::Context& context, const MWWorld::Ptr& ptr, int lockLevel)
{
if (!isMultiplayer())
return false;
ObjectList* objectList = startScriptObjectList(context, ptr);
if (!objectList)
return false;
if (ptr.getCellRef().getLockLevel() != lockLevel)
{
objectList->addObjectLock(ptr, lockLevel);
objectList->sendObjectLock();
}
return true;
}
bool requestScriptDelete(const Interpreter::Context& context, const MWWorld::Ptr& ptr)
{
if (!isMultiplayer())
return false;
ObjectList* objectList = startScriptObjectList(context, ptr);
if (!objectList)
return false;
if (ptr.getRefData().getLastCommunicatedState() != MWWorld::RefData::StateCommunication::Deleted)
{
ptr.getRefData().setLastCommunicatedState(MWWorld::RefData::StateCommunication::Deleted);
objectList->addObjectGeneric(ptr);
objectList->sendObjectDelete();
}
return true;
}
void sendScriptVideo(const Interpreter::Context& context, const std::string& name, bool allowSkipping)
{
if (!isLoggedIn())
return;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin
= static_cast<unsigned char>(ScriptController::getPacketOriginFromContextType(context.getContextType()));
objectList->originClientScript = context.getCurrentScriptName();
objectList->addVideoPlay(name, allowSkipping);
objectList->sendVideoPlay();
}
void onScriptLocalChanged(const Interpreter::Context& context, bool sendPackets, const MWWorld::Ptr& ptr,
int index, int value, bool isLong)
{
if (!sendPackets || ServerChange::isActive())
return;
if (ObjectList* objectList = startScriptObjectList(context, ptr))
{
objectList->addClientScriptLocal(ptr, index, value, isLong ? VARIABLE_TYPE::LONG : VARIABLE_TYPE::SHORT);
objectList->sendClientScriptLocal();
}
}
void onScriptLocalFloatChanged(
const Interpreter::Context& context, bool sendPackets, const MWWorld::Ptr& ptr, int index, float value)
{
if (!sendPackets || ServerChange::isActive())
return;
if (ObjectList* objectList = startScriptObjectList(context, ptr))
{
objectList->addClientScriptLocal(ptr, index, value);
objectList->sendClientScriptLocal();
}
}
void onScriptGlobalChanged(bool sendPackets, std::string_view name, int value, bool isLong)
{
if (!isLoggedIn() || ServerChange::isActive())
return;
const std::string id(name);
if (sendPackets || Main::isValidPacketGlobal(id))
Main::get().getNetworking()->getWorldstate()->sendClientGlobal(
id, value, isLong ? VARIABLE_TYPE::LONG : VARIABLE_TYPE::SHORT);
}
void onScriptGlobalFloatChanged(bool sendPackets, std::string_view name, float value)
{
if (!isLoggedIn() || ServerChange::isActive())
return;
const std::string id(name);
if (sendPackets || Main::isValidPacketGlobal(id))
Main::get().getNetworking()->getWorldstate()->sendClientGlobal(id, value);
}
void onScriptMemberShortChanged(
const Interpreter::Context& context, bool sendPackets, const ESM::RefId& scriptId, int index, int value)
{
if (!sendPackets || !isLoggedIn() || ServerChange::isActive())
return;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin
= static_cast<unsigned char>(ScriptController::getPacketOriginFromContextType(context.getContextType()));
objectList->originClientScript = context.getCurrentScriptName();
objectList->addScriptMemberShort(idString(scriptId), index, value);
objectList->sendScriptMemberShort();
}
bool requestScriptScale(const Interpreter::Context& context, const MWWorld::Ptr& ptr, float scale)
{
if (!isMultiplayer())
return false;
if (isLocalPlayer(ptr) || isDedicatedPlayer(ptr))
{
MWBase::Environment::get().getWindowManager()->messageBox(
"Only the server can change the scale of players in multiplayer.");
return true;
}
ObjectList* objectList = startScriptObjectList(context, ptr);
if (!objectList)
return false;
if (ptr.getCellRef().getScale() != scale)
{
objectList->addObjectScale(ptr, scale);
objectList->sendObjectScale();
}
return true;
}
bool requestScriptPlacement(const Interpreter::Context& context, const MWWorld::Ptr& placed)
{
if (!isLoggedIn() || placed.isEmpty() || !placed.isInCell() || placed.getCell()->getCell()->isEsm4())
return false;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin
= static_cast<unsigned char>(ScriptController::getPacketOriginFromContextType(context.getContextType()));
objectList->originClientScript = context.getCurrentScriptName();
if (placed.getClass().isActor())
{
objectList->addObjectSpawn(placed);
objectList->sendObjectSpawn();
}
else
{
objectList->addObjectPlace(placed);
objectList->sendObjectPlace();
}
MWBase::Environment::get().getWorld()->deleteObject(placed);
return true;
}
void sendActorCellChange(const MWWorld::Ptr& actor, const ESM::Cell& originalCell, bool isFollower)
{
if (!isLoggedIn() || !actor.getClass().isActor() || isLocalPlayer(actor) || isDedicatedPlayer(actor)
|| !actor.isInCell() || actor.getCell()->getCell()->isEsm4())
return;
const ESM::Cell& newCell = actor.getCell()->getCell()->getEsm3();
CellController* cellController = Main::get().getCellController();
if (cellController->isSameCell(originalCell, newCell))
return;
// Isowind MMO: a one-off event's person this client runs itself goes where it goes here only
if (cellController->isClientLocalActor(actor))
return;
BaseActor baseActor;
baseActor.refNum = actor.getCellRef().getMpRefNum();
baseActor.mpNum = actor.getCellRef().getMpNum();
baseActor.cell = newCell;
baseActor.position = actor.getRefData().getPosition();
baseActor.isFollowerCellChange = true;
ActorList* actorList = Main::get().getNetworking()->getActorList();
actorList->reset();
actorList->cell = originalCell;
actorList->addCellChangeActor(baseActor);
actorList->sendCellChangeActors();
// A follower stays the player's follower, whoever has authority over the cell it arrives in
if (isFollower)
{
actorList->reset();
actorList->cell = newCell;
actorList->addAiActor(actor, MWBase::Environment::get().getWorld()->getPlayerPtr(), BaseActorList::FOLLOW);
actorList->sendAiActors();
}
}
void allowRemoteCellChange(const MWWorld::Ptr& actor, const MWWorld::CellStore& newCell)
{
if (!isDedicatedActor(actor) || newCell.getCell()->isEsm4())
return;
Main::get().getCellController()->getDedicatedActor(actor)->cell = newCell.getCell()->getEsm3();
}
bool sendScriptContainerChange(
const Interpreter::Context& context, const MWWorld::Ptr& ptr, const ESM::RefId& itemId, int count, bool added)
{
if (!isLoggedIn() || isLocalPlayer(ptr) || isDedicatedPlayer(ptr) || !ptr.isInCell()
|| ptr.getCell()->getCell()->isEsm4() || count <= 0)
return false;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin
= static_cast<unsigned char>(ScriptController::getPacketOriginFromContextType(context.getContextType()));
objectList->originClientScript = context.getCurrentScriptName();
objectList->cell = ptr.getCell()->getCell()->getEsm3();
objectList->action = added ? BaseObjectList::ADD : BaseObjectList::REMOVE;
objectList->containerSubAction = BaseObjectList::NONE;
BaseObject baseObject = objectList->getBaseObjectFromPtr(ptr);
if (added)
objectList->addContainerItem(baseObject, idString(itemId), count, 0);
else
objectList->addContainerItem(baseObject, idString(itemId),
ptr.getClass().getContainerStore(ptr).count(itemId), count);
objectList->addBaseObject(baseObject);
objectList->sendContainer();
// Scripts and dialogue change it here too (some mods would loop otherwise); console commands only through
// the server
return context.getContextType() == Interpreter::Context::CONSOLE;
}
void sendScriptAi(const MWWorld::Ptr& actor, const MWWorld::Ptr& target, int aiAction)
{
if (!isLoggedIn() || actor.isEmpty() || target.isEmpty() || !actor.isInCell()
|| actor.getCell()->getCell()->isEsm4())
return;
// Isowind MMO: a one-off event's person this client runs itself has its AI here only
if (Main::get().getCellController()->isClientLocalActor(actor))
return;
ActorList* actorList = Main::get().getNetworking()->getActorList();
actorList->reset();
actorList->cell = actor.getCell()->getCell()->getEsm3();
actorList->addAiActor(actor, target, static_cast<unsigned int>(aiAction));
actorList->sendAiActors();
}
void sendScriptEscort(const MWWorld::Ptr& actor, const MWWorld::Ptr& target, int duration, float x, float y, float z)
{
if (!isLoggedIn() || actor.isEmpty() || target.isEmpty() || !actor.isInCell()
|| actor.getCell()->getCell()->isEsm4())
return;
// Isowind MMO: as for sendScriptAi
if (Main::get().getCellController()->isClientLocalActor(actor))
return;
ActorList* actorList = Main::get().getNetworking()->getActorList();
actorList->reset();
actorList->cell = actor.getCell()->getCell()->getEsm3();
BaseActor escort;
escort.refNum = actor.getCellRef().getMpRefNum();
escort.mpNum = actor.getCellRef().getMpNum();
escort.aiAction = BaseActorList::ESCORT;
escort.hasAiTarget = true;
escort.aiTarget = MechanicsHelper::getTarget(target);
escort.aiDuration = static_cast<unsigned int>(std::max(duration, 0));
escort.aiCoordinates.pos[0] = x;
escort.aiCoordinates.pos[1] = y;
escort.aiCoordinates.pos[2] = z;
actorList->addAiActor(escort);
actorList->sendAiActors();
}
void sendScriptAnimation(const Interpreter::Context& context, const MWWorld::Ptr& ptr, const std::string& group,
int mode)
{
if (ptr.isEmpty() || !isScriptSynchronized(ptr.getClass().getScript(ptr)))
return;
if (ObjectList* objectList = startScriptObjectList(context, ptr))
{
objectList->addObjectAnimPlay(ptr, group, mode);
objectList->sendObjectAnimPlay();
}
}
void sendScriptMusic(const Interpreter::Context& context, const std::string& music)
{
if (!isLoggedIn() || ServerChange::isActive())
return;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin
= static_cast<unsigned char>(ScriptController::getPacketOriginFromContextType(context.getContextType()));
objectList->originClientScript = context.getCurrentScriptName();
objectList->addMusicPlay(music);
objectList->sendMusicPlay();
}
void setNoClip(bool noClip)
{
if (isMultiplayer())
Main::get().getLocalPlayer()->hasTcl = noClip;
}
void sendWerewolfState(const MWWorld::Ptr& actor, bool werewolf)
{
if (isLoggedIn() && isLocalPlayer(actor) && !ServerChange::isActive())
Main::get().getLocalPlayer()->sendWerewolfState(werewolf);
}
bool mayRestInBed()
{
if (!isMultiplayer())
return true;
LocalPlayer* localPlayer = Main::get().getLocalPlayer();
if (!localPlayer->bedRestAllowed)
{
MWBase::Environment::get().getWindowManager()->messageBox("You are not allowed to rest in beds.");
return false;
}
localPlayer->isUsingBed = true;
return true;
}
bool isScriptSynchronized(const ESM::RefId& scriptId)
{
return isMultiplayer() && Main::isValidPacketScript(idString(scriptId));
}
void sendConsoleCommand(const std::string& command, const MWWorld::Ptr& target)
{
if (!isLoggedIn() || ServerChange::isActive())
return;
ObjectList* objectList = Main::get().getNetworking()->getObjectList();
objectList->reset();
objectList->packetOrigin = CLIENT_CONSOLE;
objectList->consoleCommand = command;
if (target.isEmpty() || !target.isInCell() || target.getCell()->getCell()->isEsm4())
objectList->cell = Main::get().getLocalPlayer()->cell;
else
objectList->addObjectGeneric(target);
objectList->sendConsoleCommand();
}
void onCellRefsChanged(const MWWorld::CellStore& cell)
{
if (!isMultiplayer() || cell.getCell()->isEsm4())
return;
CellController* cellController = Main::get().getCellController();
const ESM::Cell& esmCell = cell.getCell()->getEsm3();
if (!cellController->hasLocalAuthority(esmCell))
return;
if (Cell* mpCell = cellController->getCell(esmCell))
mpCell->shouldInitializeActors = true;
}
std::vector<OtherPlayer> getOtherPlayers()
{
std::vector<OtherPlayer> players;
if (!isLoggedIn())
return players;
for (DedicatedPlayer* player : PlayerList::getPlayers())
{
if (player->npc.mName.empty())
continue;
OtherPlayer& other = players.emplace_back();
other.name = player->npc.mName;
other.exterior = player->cell.isExterior();
other.cellName = player->cell.mName;
// Where they are drawn, if they are near; otherwise the last position heard of
const MWWorld::Ptr ptr = player->getPtr();
const ESM::Position& pos
= !ptr.isEmpty() && ptr.isInCell() ? ptr.getRefData().getPosition() : player->position;
other.x = pos.pos[0];
other.y = pos.pos[1];
other.yaw = pos.rot[2];
}
return players;
}
bool hasActorCollision(const MWWorld::Ptr& actor)
{
if (!isMultiplayer() || isLocalPlayer(actor))
return true;
const BaseWorldstate* worldstate = Main::get().getNetworking()->getWorldstate();
return isDedicatedPlayer(actor) ? worldstate->hasPlayerCollision : worldstate->hasActorCollision;
}
ESM::RefId getDoorDestination(const ESM::RefId& destination)
{
if (!isMultiplayer() || !destination.is<ESM::StringRefId>())
return destination;
const std::string name = destination.getRefIdString();
for (const auto& [original, replacement] : Main::get().getNetworking()->getWorldstate()->destinationOverrides)
{
if (Misc::StringUtils::ciEqual(original, name))
return ESM::RefId::stringRefId(replacement);
}
return destination;
}
bool hasEnforcedCollision(const MWWorld::Ptr& ptr, bool& asActor)
{
if (!isMultiplayer())
return false;
const BaseWorldstate* worldstate = Main::get().getNetworking()->getWorldstate();
asActor = worldstate->useActorCollisionForPlacedObjects;
if (worldstate->hasPlacedObjectCollision)
return true;
for (const std::string& refId : worldstate->enforcedCollisionRefIds)
{
if (isSameId(ptr.getCellRef().getRefId(), refId))
return true;
}
return false;
}
void sendObjectSpawn(const MWWorld::Ptr& ptr)
{
if (ObjectList* objectList = startObjectList(ptr))
{
objectList->addObjectSpawn(ptr);
objectList->sendObjectSpawn();
}
}
bool claimExploredMapTile(int cellX, int cellY)
{
if (!isLoggedIn())
return false;
mwmp::Worldstate* worldstate = Main::get().getNetworking()->getWorldstate();
if (worldstate->containsExploredMapTile(cellX, cellY))
return false;
worldstate->markExploredMapTile(cellX, cellY);
return true;
}
void sendExploredMapTile(int cellX, int cellY, const std::vector<char>& png)
{
Main::get().getNetworking()->getWorldstate()->sendMapExplored(cellX, cellY, png);
}
}