openmw-tes3mp/apps/openmw/mwmp/DedicatedPlayer.cpp

#include <boost/algorithm/clamp.hpp>
#include <components/openmw-mp/Log.hpp>
#include <apps/openmw/mwmechanics/steering.hpp>

#include "../mwbase/environment.hpp"
#include "../mwbase/soundmanager.hpp"

#include "../mwclass/npc.hpp"

#include "../mwdialogue/dialoguemanagerimp.hpp"

#include "../mwgui/windowmanagerimp.hpp"

#include "../mwinput/inputmanagerimp.hpp"

#include "../mwmechanics/actor.hpp"
#include "../mwmechanics/aitravel.hpp"
#include "../mwmechanics/creaturestats.hpp"
#include "../mwmechanics/npcstats.hpp"
#include "../mwmechanics/mechanicsmanagerimp.hpp"
#include "../mwmechanics/spellcasting.hpp"

#include "../mwstate/statemanagerimp.hpp"

#include "../mwworld/action.hpp"
#include "../mwworld/cellstore.hpp"
#include "../mwworld/customdata.hpp"
#include "../mwworld/inventorystore.hpp"
#include "../mwworld/player.hpp"
#include "../mwworld/worldimp.hpp"

#include "DedicatedPlayer.hpp"
#include "Main.hpp"
#include "GUIController.hpp"
#include "CellController.hpp"
#include "MechanicsHelper.hpp"


using namespace mwmp;
using namespace std;

DedicatedPlayer::DedicatedPlayer(RakNet::RakNetGUID guid) : BasePlayer(guid)
{
    reference = 0;
    attack.pressed = 0;
    creatureStats.mDead = false;
    movementFlags = 0;
    attack.instant = false;
}
DedicatedPlayer::~DedicatedPlayer()
{

}

void DedicatedPlayer::update(float dt)
{
    MWMechanics::CreatureStats *ptrCreatureStats = &ptr.getClass().getCreatureStats(ptr);

    MWMechanics::DynamicStat<float> value;

    if (creatureStats.mDead)
    {
        value.readState(creatureStats.mDynamic[0]);
        ptrCreatureStats->setHealth(value);
        return;
    }

    for (int i = 0; i < 3; ++i)
    {
        value.readState(creatureStats.mDynamic[i]);
        ptrCreatureStats->setDynamic(i, value);
    }

    if (ptrCreatureStats->isDead())
        ptrCreatureStats->resurrect();

    ptrCreatureStats->setAttacked(false);

    ptrCreatureStats->getAiSequence().stopCombat();

    ptrCreatureStats->setAlarmed(false);
    ptrCreatureStats->setAiSetting(MWMechanics::CreatureStats::AI_Alarm, 0);
    ptrCreatureStats->setAiSetting(MWMechanics::CreatureStats::AI_Fight, 0);
    ptrCreatureStats->setAiSetting(MWMechanics::CreatureStats::AI_Flee, 0);
    ptrCreatureStats->setAiSetting(MWMechanics::CreatureStats::AI_Hello, 0);

    // Only move and set anim flags if the framerate isn't too low
    if (dt < 0.1)
    {
        move(dt);
        setAnimFlags();
    }
}

void DedicatedPlayer::move(float dt)
{
    if (state != 2) return;

    ESM::Position refPos = ptr.getRefData().getPosition();
    MWBase::World *world = MWBase::Environment::get().getWorld();
    const int maxInterpolationDistance = 40;

    // Apply interpolation only if the position hasn't changed too much from last time
    bool shouldInterpolate =
            abs(position.pos[0] - refPos.pos[0]) < maxInterpolationDistance &&
            abs(position.pos[1] - refPos.pos[1]) < maxInterpolationDistance &&
            abs(position.pos[2] - refPos.pos[2]) < maxInterpolationDistance;

    if (shouldInterpolate)
    {
        static const int timeMultiplier = 15;
        osg::Vec3f lerp = MechanicsHelper::getLinearInterpolation(refPos.asVec3(), position.asVec3(), dt * timeMultiplier);

        world->moveObject(ptr, lerp.x(), lerp.y(), lerp.z());
    }
    else
        world->moveObject(ptr, position.pos[0], position.pos[1], position.pos[2]);

    float oldZ = ptr.getRefData().getPosition().rot[2];
    world->rotateObject(ptr, position.rot[0], 0, oldZ);

    MWMechanics::Movement *move = &ptr.getClass().getMovementSettings(ptr);
    move->mPosition[0] = direction.pos[0];
    move->mPosition[1] = direction.pos[1];

    MWMechanics::zTurn(ptr, position.rot[2], osg::DegreesToRadians(1.0));
}

void DedicatedPlayer::setBaseInfo()
{
    MWBase::World *world = MWBase::Environment::get().getWorld();

    ESM::Creature tempCreature;
    ESM::NPC tempNpc;

    if (!creatureRefId.empty())
    {
        const ESM::Creature *tmpCreature = world->getStore().get<ESM::Creature>().search(creatureRefId);
        if (tmpCreature == 0)
        {
            creatureRefId = "";
        }
        else
        {
            tempCreature = getCreatureRecord();
        }
    }

    if (creatureRefId.empty())
    {
        tempNpc = getNpcRecord();
    }

    bool reset = false;
    if (reference)
    {
        deleteReference();
        reset = true;
    }

    if (state == 0)
    {
        createReference(tempNpc, tempCreature, reset);
    }
    else
    {
        updateReference(tempNpc, tempCreature);
    }

    state = 2;

    // Give this new character a fatigue of at least 1 so it doesn't spawn
    // on the ground
    creatureStats.mDynamic[2].mBase = 1;

    world->enable(ptr);
}

void DedicatedPlayer::setAnimFlags()
{
    using namespace MWMechanics;

    MWBase::World *world = MWBase::Environment::get().getWorld();

    // Until we figure out a better workaround for disabling player gravity,
    // simply cast Levitate over and over on a player that's supposed to be flying
    if (!isFlying)
        ptr.getClass().getCreatureStats(ptr).getActiveSpells().purgeEffect(ESM::MagicEffect::Levitate);
    else if (isFlying && !world->isFlying(ptr))
    {
        MWMechanics::CastSpell cast(ptr, ptr);
        cast.mHitPosition = ptr.getRefData().getPosition().asVec3();
        cast.mAlwaysSucceed = true;
        cast.cast("Levitate");
    }

    if (drawState == 0)
        ptr.getClass().getCreatureStats(ptr).setDrawState(DrawState_Nothing);
    else if (drawState == 1)
        ptr.getClass().getCreatureStats(ptr).setDrawState(DrawState_Weapon);
    else if (drawState == 2)
        ptr.getClass().getCreatureStats(ptr).setDrawState(DrawState_Spell);

    MWMechanics::CreatureStats *ptrCreatureStats = &ptr.getClass().getCreatureStats(ptr);
    ptrCreatureStats->setMovementFlag(CreatureStats::Flag_Run, (movementFlags & CreatureStats::Flag_Run) != 0);
    ptrCreatureStats->setMovementFlag(CreatureStats::Flag_Sneak, (movementFlags & CreatureStats::Flag_Sneak) != 0);
    ptrCreatureStats->setMovementFlag(CreatureStats::Flag_ForceJump, (movementFlags & CreatureStats::Flag_ForceJump) != 0);
    ptrCreatureStats->setMovementFlag(CreatureStats::Flag_ForceMoveJump, (movementFlags & CreatureStats::Flag_ForceMoveJump) != 0);
}

void DedicatedPlayer::setEquipment()
{
    MWWorld::InventoryStore& invStore = ptr.getClass().getInventoryStore(ptr);
    for (int slot = 0; slot < MWWorld::InventoryStore::Slots; ++slot)
    {
        MWWorld::ContainerStoreIterator it = invStore.getSlot(slot);

        const string &dedicItem = equipedItems[slot].refId;
        std::string item = "";
        bool equal = false;
        if (it != invStore.end())
        {
            item = it->getCellRef().getRefId();
            if (!Misc::StringUtils::ciEqual(item, dedicItem)) // if other item equiped
            {
                MWWorld::ContainerStore &store = ptr.getClass().getContainerStore(ptr);
                store.remove(item, store.count(item), ptr);
            }
            else
                equal = true;
        }

        if (dedicItem.empty() || equal)
            continue;

        const int count = equipedItems[slot].count;
        ptr.getClass().getContainerStore(ptr).add(dedicItem, count, ptr);

        for (const auto &ptr : invStore)
        {
            if (::Misc::StringUtils::ciEqual(ptr.getCellRef().getRefId(), dedicItem)) // equip item
            {
                std::shared_ptr<MWWorld::Action> action = ptr.getClass().use(ptr);
                action->execute(this->ptr);
                break;
            }
        }
    }
}

void DedicatedPlayer::setCell()
{
    // Prevent cell update when player hasn't been instantiated yet
    if (state == 0)
        return;

    MWBase::World *world = MWBase::Environment::get().getWorld();

    LOG_MESSAGE_SIMPLE(Log::LOG_INFO, "Server says DedicatedPlayer %s moved to %s",
        npc.mName.c_str(), cell.getDescription().c_str());

    MWWorld::CellStore *cellStore = Main::get().getCellController()->getCellStore(cell);

    if (!cellStore)
    {
        LOG_APPEND(Log::LOG_INFO, "%s", "- Cell doesn't exist on this client");
        world->disable(getPtr());
        return;
    }
    else
        world->enable(getPtr());

    // Allow this player's reference to move across a cell now that a manual cell
    // update has been called
    setPtr(world->moveObject(ptr, cellStore, position.pos[0], position.pos[1], position.pos[2]));

    // Remove the marker entirely if this player has moved to an interior that is inactive for us
    if (!cell.isExterior() && !Main::get().getCellController()->isActiveWorldCell(cell))
        removeMarker();
    // Otherwise, update their marker so the player shows up in the right cell on the world map
    else
        updateMarker();

    // If this player is now in a cell that we are the local authority over, we should send them all
    // NPC data in that cell
    if (Main::get().getCellController()->hasLocalAuthority(cell))
        Main::get().getCellController()->getCell(cell)->updateLocal(true);
}

void DedicatedPlayer::setShapeshift()
{
    MWBase::Environment::get().getWorld()->scaleObject(ptr, scale);
    MWBase::Environment::get().getMechanicsManager()->setWerewolf(ptr, isWerewolf);
}

void DedicatedPlayer::updateMarker()
{
    if (!markerEnabled)
        return;

    GUIController *gui = Main::get().getGUIController();

    if (gui->mPlayerMarkers.contains(marker))
    {
        gui->mPlayerMarkers.deleteMarker(marker);
        marker = gui->createMarker(guid);
        gui->mPlayerMarkers.addMarker(marker);
    }
    else
        gui->mPlayerMarkers.addMarker(marker, true);
}

void DedicatedPlayer::removeMarker()
{
    if (!markerEnabled)
        return;

    markerEnabled = false;
    GUIController *gui = Main::get().getGUIController();

    if (gui->mPlayerMarkers.contains(marker))
        Main::get().getGUIController()->mPlayerMarkers.deleteMarker(marker);
}

void DedicatedPlayer::setMarkerState(bool state)
{
    if (state)
    {
        markerEnabled = true;
        updateMarker();
    }
    else
        removeMarker();
}

void DedicatedPlayer::playAnimation()
{
    MWBase::Environment::get().getMechanicsManager()->playAnimationGroup(getPtr(),
        animation.groupname, animation.mode, animation.count, animation.persist);
}

void DedicatedPlayer::playSpeech()
{
    MWBase::Environment::get().getSoundManager()->say(getPtr(), sound);

    MWBase::WindowManager *winMgr = MWBase::Environment::get().getWindowManager();
    if (winMgr->getSubtitlesEnabled())
        winMgr->messageBox(MWBase::Environment::get().getDialogueManager()->getVoiceCaption(sound), MWGui::ShowInDialogueMode_Never);
}


ESM::Creature DedicatedPlayer::getCreatureRecord()
{
    MWBase::World *world = MWBase::Environment::get().getWorld();

    ESM::Creature creature;

    const ESM::Creature *tmpCreature = world->getStore().get<ESM::Creature>().search(creatureRefId);

    creature = *tmpCreature;
    creature.mScript = "";
    if (!displayCreatureName)
        creature.mName = npc.mName;
    LOG_APPEND(Log::LOG_INFO, "Player %s looks like %s", npc.mName.c_str(), creatureRefId.c_str());

    return creature;
}

ESM::NPC DedicatedPlayer::getNpcRecord()
{
    MWBase::World *world = MWBase::Environment::get().getWorld();

    MWWorld::Ptr player = world->getPlayerPtr();

    ESM::NPC newNpc = *player.get<ESM::NPC>()->mBase;

    // To avoid freezes caused by invalid races, only set race if we find it
    // on our client
    if (world->getStore().get<ESM::Race>().search(npc.mRace) != 0)
        newNpc.mRace = npc.mRace;

    newNpc.mHead = npc.mHead;
    newNpc.mHair = npc.mHair;
    newNpc.mClass = npc.mClass;
    newNpc.mName = npc.mName;
    newNpc.mFlags = npc.mFlags;

    return newNpc;
}

void DedicatedPlayer::createReference(ESM::NPC& npc, ESM::Creature& creature, bool reset)
{
    MWBase::World *world = MWBase::Environment::get().getWorld();

    // Temporarily spawn or move player to the center of exterior 0, 0
    ESM::Position spawnPos;
    spawnPos.pos[0] = spawnPos.pos[1] = Main::get().getCellController()->getCellSize() / 2;
    spawnPos.pos[2] = 0;
    MWWorld::CellStore *cellStore = world->getExterior(0, 0);

    string recid;
    if (creatureRefId.empty())
    {
        LOG_APPEND(Log::LOG_INFO, "- Creating new NPC record");
        npc.mId = "Dedicated Player";
        recid = world->createRecord(npc)->mId;
    }
    else
    {
        LOG_APPEND(Log::LOG_INFO, "- Creating new Creature record");
        creature.mId = "Dedicated Player";
        recid = world->createRecord(creature)->mId;
    }

    reference = new MWWorld::ManualRef(world->getStore(), recid, 1);

    LOG_APPEND(Log::LOG_INFO, "- Creating new reference pointer for %s", this->npc.mName.c_str());

    MWWorld::Ptr tmp;

    if (reset)
    {
        if (cell.isExterior())
            cellStore = world->getExterior(cell.mData.mX, cell.mData.mY);
        else
            cellStore = world->getInterior(cell.mName);

        spawnPos = position;
    }

    tmp = world->placeObject(reference->getPtr(), cellStore, spawnPos);

    ptr.mCell = tmp.mCell;
    ptr.mRef = tmp.mRef;

    if (!reset)
    {
        cell = *ptr.getCell()->getCell();
        position = ptr.getRefData().getPosition();
    }

    ESM::CustomMarker mEditingMarker = Main::get().getGUIController()->createMarker(guid);
    marker = mEditingMarker;
    setMarkerState(true);
}

void DedicatedPlayer::updateReference(ESM::NPC& npc, ESM::Creature& creature)
{
    MWBase::World *world = MWBase::Environment::get().getWorld();

    // Temporarily spawn or move player to the center of exterior 0, 0
    ESM::Position spawnPos;
    spawnPos.pos[0] = spawnPos.pos[1] = Main::get().getCellController()->getCellSize() / 2;
    spawnPos.pos[2] = 0;
    MWWorld::CellStore *cellStore = world->getExterior(0, 0);

    LOG_APPEND(Log::LOG_INFO, "- Updating reference pointer for %s", npc.mName.c_str());

    MWWorld::ESMStore *store = const_cast<MWWorld::ESMStore *>(&world->getStore());
    MWWorld::Store<ESM::Creature> *creature_store = const_cast<MWWorld::Store<ESM::Creature> *> (&store->get<ESM::Creature>());
    MWWorld::Store<ESM::NPC> *npc_store = const_cast<MWWorld::Store<ESM::NPC> *> (&store->get<ESM::NPC>());

    if (!creatureRefId.empty())
    {
        if (!npc.mId.empty() || npc.mId != "Dedicated Player")
        {
            LOG_APPEND(Log::LOG_INFO, "- Deleting NPC record");
            npc_store->erase(npc.mId);
            npc.mId.clear();
        }
        creature.mId = ptr.get<ESM::Creature>()->mBase->mId;
        creature_store->insert(creature);
    }
    else
    {
        if (!creature.mId.empty() || creature.mId != "Dedicated Player")
        {
            LOG_APPEND(Log::LOG_INFO, "- Deleting Creature record");
            creature_store->erase(creature.mId);
            creature.mId.clear();
        }
        npc.mId = ptr.get<ESM::NPC>()->mBase->mId;
        npc_store->insert(npc);
    }

    // Disable Ptr to avoid graphical glitches caused by race changes
    world->disable(ptr);

    setPtr(world->moveObject(ptr, cellStore, spawnPos.pos[0], spawnPos.pos[1], spawnPos.pos[2]));
    setCell();
}

void DedicatedPlayer::deleteReference()
{
    MWBase::World *world = MWBase::Environment::get().getWorld();

    bool isNPC = reference->getPtr().getTypeName() == typeid(ESM::NPC).name();
    if ((!creatureRefId.empty() && isNPC) ||
        (creatureRefId.empty() && !isNPC))
    {
        LOG_APPEND(Log::LOG_INFO, "- Deleting old reference");
        state = 0;
        world->deleteObject(ptr);
        delete reference;
        reference = nullptr;
    }
}

MWWorld::Ptr DedicatedPlayer::getPtr()
{
    return ptr;
}

MWWorld::ManualRef *DedicatedPlayer::getRef()
{
    return reference;
}

void DedicatedPlayer::setPtr(const MWWorld::Ptr& newPtr)
{
    ptr = newPtr;
}