world.hpp

Go to the documentation of this file.

#ifndef GAME_MWBASE_WORLD_H
#define GAME_MWBASE_WORLD_H

#include <vector>
#include <map>
#include <set>

#include <components/esm/cellid.hpp>

#include "../mwworld/ptr.hpp"

#include "../mwrender/rendermode.hpp"

namespace osg
{
    class Vec3f;
    class Matrixf;
    class Quat;
    class Image;
}

namespace Loading
{
    class Listener;
}

namespace ESM
{
    class ESMReader;
    class ESMWriter;
    struct Position;
    struct Cell;
    struct Class;
    struct Potion;
    struct Spell;
    struct NPC;
    struct Armor;
    struct Weapon;
    struct Clothing;
    struct Enchantment;
    struct Book;
    struct EffectList;
    struct CreatureLevList;
    struct ItemLevList;
}

namespace MWRender
{
    class Animation;
}

namespace MWMechanics
{
    struct Movement;
}

namespace MWWorld
{
    class CellStore;
    class Player;
    class LocalScripts;
    class TimeStamp;
    class ESMStore;
    class RefData;

    typedef std::vector<std::pair<MWWorld::Ptr,MWMechanics::Movement> > PtrMovementList;
}

namespace Fallback
{
    class Map;
}

namespace MWBase
{
    class World
    {
            World (const World&);

            World& operator= (const World&);

        public:

            struct DoorMarker
            {
                std::string name;
                float x, y; // world position
                ESM::CellId dest;
            };

            World() {}

            virtual ~World() {}

            virtual void startNewGame (bool bypass) = 0;

            virtual void clear() = 0;

            virtual int countSavedGameRecords() const = 0;
            virtual int countSavedGameCells() const = 0;

            virtual void write (ESM::ESMWriter& writer, Loading::Listener& listener) const = 0;

            virtual void readRecord (ESM::ESMReader& reader, uint32_t type,
                const std::map<int, int>& contentFileMap) = 0;

            virtual MWWorld::CellStore *getExterior (int x, int y) = 0;

            virtual MWWorld::CellStore *getInterior (const std::string& name) = 0;

            virtual MWWorld::CellStore *getCell (const ESM::CellId& id) = 0;

            virtual void useDeathCamera() = 0;

            virtual void setWaterHeight(const float height) = 0;

            virtual bool toggleWater() = 0;
            virtual bool toggleWorld() = 0;
            virtual bool toggleBorders() = 0;

            virtual void adjustSky() = 0;

            virtual const Fallback::Map *getFallback () const = 0;

            virtual MWWorld::Player& getPlayer() = 0;
            virtual MWWorld::Ptr getPlayerPtr() = 0;

            virtual const MWWorld::ESMStore& getStore() const = 0;

            virtual std::vector<ESM::ESMReader>& getEsmReader() = 0;

            virtual MWWorld::LocalScripts& getLocalScripts() = 0;

            virtual bool hasCellChanged() const = 0;

            virtual bool isCellExterior() const = 0;

            virtual bool isCellQuasiExterior() const = 0;

            virtual osg::Vec2f getNorthVector (const MWWorld::CellStore* cell) = 0;

            virtual void getDoorMarkers (MWWorld::CellStore* cell, std::vector<DoorMarker>& out) = 0;

            virtual void setGlobalInt (const std::string& name, int value) = 0;

            virtual void setGlobalFloat (const std::string& name, float value) = 0;

            virtual int getGlobalInt (const std::string& name) const = 0;

            virtual float getGlobalFloat (const std::string& name) const = 0;

            virtual char getGlobalVariableType (const std::string& name) const = 0;

            virtual std::string getCellName (const MWWorld::CellStore *cell = 0) const = 0;

            virtual void removeRefScript (MWWorld::RefData *ref) = 0;
            //< Remove the script attached to ref from mLocalScripts

            virtual MWWorld::Ptr getPtr (const std::string& name, bool activeOnly) = 0;

            virtual MWWorld::Ptr searchPtr (const std::string& name, bool activeOnly) = 0;

            virtual MWWorld::Ptr searchPtrViaActorId (int actorId) = 0;

            virtual MWWorld::Ptr findContainer (const MWWorld::ConstPtr& ptr) = 0;

            virtual void enable (const MWWorld::Ptr& ptr) = 0;

            virtual void disable (const MWWorld::Ptr& ptr) = 0;

            virtual void advanceTime (double hours, bool incremental = false) = 0;

            virtual void setHour (double hour) = 0;

            virtual void setMonth (int month) = 0;

            virtual void setDay (int day) = 0;

            virtual int getDay() const = 0;
            virtual int getMonth() const = 0;
            virtual int getYear() const = 0;

            virtual std::string getMonthName (int month = -1) const = 0;

            virtual MWWorld::TimeStamp getTimeStamp() const = 0;

            virtual bool toggleSky() = 0;

            virtual void changeWeather(const std::string& region, const unsigned int id) = 0;

            virtual int getCurrentWeather() const = 0;

            virtual int getMasserPhase() const = 0;

            virtual int getSecundaPhase() const = 0;

            virtual void setMoonColour (bool red) = 0;

            virtual void modRegion(const std::string &regionid, const std::vector<char> &chances) = 0;

            virtual float getTimeScaleFactor() const = 0;

            virtual void changeToInteriorCell (const std::string& cellName, const ESM::Position& position, bool adjustPlayerPos, bool changeEvent=true) = 0;

            virtual void changeToExteriorCell (const ESM::Position& position, bool adjustPlayerPos, bool changeEvent=true) = 0;

            virtual void changeToCell (const ESM::CellId& cellId, const ESM::Position& position, bool adjustPlayerPos, bool changeEvent=true) = 0;

            virtual const ESM::Cell *getExterior (const std::string& cellName) const = 0;

            virtual void markCellAsUnchanged() = 0;

            virtual MWWorld::Ptr  getFacedObject() = 0;

            virtual float getDistanceToFacedObject() = 0;

            virtual float getMaxActivationDistance() = 0;

            virtual std::pair<MWWorld::Ptr,osg::Vec3f> getHitContact(const MWWorld::ConstPtr &ptr, float distance, std::vector<MWWorld::Ptr> &targets) = 0;

            virtual void adjustPosition (const MWWorld::Ptr& ptr, bool force) = 0;

            virtual void fixPosition (const MWWorld::Ptr& actor) = 0;

            virtual void deleteObject (const MWWorld::Ptr& ptr) = 0;
            virtual void undeleteObject (const MWWorld::Ptr& ptr) = 0;

            virtual MWWorld::Ptr moveObject (const MWWorld::Ptr& ptr, float x, float y, float z) = 0;

            virtual MWWorld::Ptr moveObject(const MWWorld::Ptr &ptr, MWWorld::CellStore* newCell, float x, float y, float z, bool movePhysics=true) = 0;

            virtual void scaleObject (const MWWorld::Ptr& ptr, float scale) = 0;

            virtual void rotateObject(const MWWorld::Ptr& ptr,float x,float y,float z, bool adjust = false) = 0;

            virtual MWWorld::Ptr placeObject(const MWWorld::ConstPtr& ptr, MWWorld::CellStore* cell, ESM::Position pos) = 0;

            virtual MWWorld::Ptr safePlaceObject (const MWWorld::ConstPtr& ptr, const MWWorld::ConstPtr& referenceObject, MWWorld::CellStore* referenceCell, int direction, float distance) = 0;

            virtual void indexToPosition (int cellX, int cellY, float &x, float &y, bool centre = false)
                const = 0;

            virtual void positionToIndex (float x, float y, int &cellX, int &cellY) const = 0;

            virtual void queueMovement(const MWWorld::Ptr &ptr, const osg::Vec3f &velocity) = 0;

            virtual bool castRay (float x1, float y1, float z1, float x2, float y2, float z2, bool ignoreDoors=false) = 0;

            virtual bool toggleCollisionMode() = 0;

            virtual bool toggleRenderMode (MWRender::RenderMode mode) = 0;

            virtual const ESM::Potion *createRecord (const ESM::Potion& record) = 0;

            virtual const ESM::Spell *createRecord (const ESM::Spell& record) = 0;

            virtual const ESM::Class *createRecord (const ESM::Class& record) = 0;

            virtual const ESM::Cell *createRecord (const ESM::Cell& record) = 0;

            virtual const ESM::NPC *createRecord(const ESM::NPC &record) = 0;

            virtual const ESM::Armor *createRecord (const ESM::Armor& record) = 0;

            virtual const ESM::Weapon *createRecord (const ESM::Weapon& record) = 0;

            virtual const ESM::Clothing *createRecord (const ESM::Clothing& record) = 0;

            virtual const ESM::Enchantment *createRecord (const ESM::Enchantment& record) = 0;

            virtual const ESM::Book *createRecord (const ESM::Book& record) = 0;

            virtual const ESM::CreatureLevList *createOverrideRecord (const ESM::CreatureLevList& record) = 0;

            virtual const ESM::ItemLevList *createOverrideRecord (const ESM::ItemLevList& record) = 0;

            virtual void update (float duration, bool paused) = 0;

            virtual void updateWindowManager () = 0;

            virtual MWWorld::Ptr placeObject (const MWWorld::ConstPtr& object, float cursorX, float cursorY, int amount) = 0;

            virtual MWWorld::Ptr dropObjectOnGround (const MWWorld::Ptr& actor, const MWWorld::ConstPtr& object, int amount) = 0;

            virtual bool canPlaceObject (float cursorX, float cursorY) = 0;

            virtual void processChangedSettings (const std::set< std::pair<std::string, std::string> >& settings) = 0;

            virtual bool isFlying(const MWWorld::Ptr &ptr) const = 0;
            virtual bool isSlowFalling(const MWWorld::Ptr &ptr) const = 0;
            virtual bool isSwimming(const MWWorld::ConstPtr &object) const = 0;
            virtual bool isWading(const MWWorld::ConstPtr &object) const = 0;
            virtual bool isSubmerged(const MWWorld::ConstPtr &object) const = 0;
            virtual bool isUnderwater(const MWWorld::CellStore* cell, const osg::Vec3f &pos) const = 0;
            virtual bool isUnderwater(const MWWorld::ConstPtr &object, const float heightRatio) const = 0;
            virtual bool isWaterWalkingCastableOnTarget(const MWWorld::ConstPtr &target) const = 0;
            virtual bool isOnGround(const MWWorld::Ptr &ptr) const = 0;

            virtual osg::Matrixf getActorHeadTransform(const MWWorld::ConstPtr& actor) const = 0;

            virtual void togglePOV() = 0;
            virtual bool isFirstPerson() const = 0;
            virtual void togglePreviewMode(bool enable) = 0;
            virtual bool toggleVanityMode(bool enable) = 0;
            virtual void allowVanityMode(bool allow) = 0;
            virtual void togglePlayerLooking(bool enable) = 0;
            virtual void changeVanityModeScale(float factor) = 0;
            virtual bool vanityRotateCamera(float * rot) = 0;
            virtual void setCameraDistance(float dist, bool adjust = false, bool override = true)=0;

            virtual void setupPlayer() = 0;
            virtual void renderPlayer() = 0;

            virtual void activateDoor(const MWWorld::Ptr& door) = 0;
            virtual void activateDoor(const MWWorld::Ptr& door, int state) = 0;

            virtual void getActorsStandingOn (const MWWorld::ConstPtr& object, std::vector<MWWorld::Ptr> &actors) = 0; 
            virtual bool getPlayerStandingOn (const MWWorld::ConstPtr& object) = 0; 
            virtual bool getActorStandingOn (const MWWorld::ConstPtr& object) = 0; 
            virtual bool getPlayerCollidingWith(const MWWorld::ConstPtr& object) = 0; 
            virtual bool getActorCollidingWith (const MWWorld::ConstPtr& object) = 0; 
            virtual void hurtStandingActors (const MWWorld::ConstPtr& object, float dmgPerSecond) = 0;
            virtual void hurtCollidingActors (const MWWorld::ConstPtr& object, float dmgPerSecond) = 0;

            virtual float getWindSpeed() = 0;

            virtual void getContainersOwnedBy (const MWWorld::ConstPtr& npc, std::vector<MWWorld::Ptr>& out) = 0;
            virtual void getItemsOwnedBy (const MWWorld::ConstPtr& npc, std::vector<MWWorld::Ptr>& out) = 0;

            virtual bool getLOS(const MWWorld::ConstPtr& actor,const MWWorld::ConstPtr& targetActor) = 0;

            virtual float getDistToNearestRayHit(const osg::Vec3f& from, const osg::Vec3f& dir, float maxDist, bool includeWater = false) = 0;

            virtual void enableActorCollision(const MWWorld::Ptr& actor, bool enable) = 0;

            enum RestPermitted
            {
                Rest_Allowed = 0,
                Rest_OnlyWaiting = 1,
                Rest_PlayerIsUnderwater = 2,
                Rest_EnemiesAreNearby = 3
            };

            virtual RestPermitted canRest() const = 0;

            virtual MWRender::Animation* getAnimation(const MWWorld::Ptr &ptr) = 0;
            virtual const MWRender::Animation* getAnimation(const MWWorld::ConstPtr &ptr) const = 0;
            virtual void reattachPlayerCamera() = 0;

            virtual void screenshot (osg::Image* image, int w, int h) = 0;
            virtual bool screenshot360 (osg::Image* image, std::string settingStr) = 0;

            virtual bool findExteriorPosition(const std::string &name, ESM::Position &pos) = 0;

            virtual bool findInteriorPosition(const std::string &name, ESM::Position &pos) = 0;

            virtual void enableTeleporting(bool enable) = 0;

            virtual bool isTeleportingEnabled() const = 0;

            virtual void enableLevitation(bool enable) = 0;

            virtual bool isLevitationEnabled() const = 0;

            virtual bool getGodModeState() = 0;

            virtual bool toggleGodMode() = 0;

            virtual bool toggleScripts() = 0;
            virtual bool getScriptsEnabled() const = 0;

            virtual bool startSpellCast (const MWWorld::Ptr& actor) = 0;

            virtual void castSpell (const MWWorld::Ptr& actor, bool manualSpell=false) = 0;

            virtual void launchMagicBolt (const std::string& spellId, const MWWorld::Ptr& caster, const osg::Vec3f& fallbackDirection) = 0;
            virtual void launchProjectile (MWWorld::Ptr& actor, MWWorld::Ptr& projectile,
                                           const osg::Vec3f& worldPos, const osg::Quat& orient, MWWorld::Ptr& bow, float speed, float attackStrength) = 0;

            virtual void applyLoopingParticles(const MWWorld::Ptr& ptr) = 0;

            virtual const std::vector<std::string>& getContentFiles() const = 0;

            virtual void breakInvisibility (const MWWorld::Ptr& actor) = 0;

            // Allow NPCs to use torches?
            virtual bool useTorches() const = 0;

            virtual bool findInteriorPositionInWorldSpace(const MWWorld::CellStore* cell, osg::Vec3f& result) = 0;

            virtual void teleportToClosestMarker (const MWWorld::Ptr& ptr,
                                                  const std::string& id) = 0;

            enum DetectionType
            {
                Detect_Enchantment,
                Detect_Key,
                Detect_Creature
            };
            virtual void listDetectedReferences (const MWWorld::Ptr& ptr, std::vector<MWWorld::Ptr>& out,
                                                  DetectionType type) = 0;

            virtual void updateDialogueGlobals() = 0;

            virtual void confiscateStolenItems(const MWWorld::Ptr& ptr) = 0;

            virtual void goToJail () = 0;

            virtual void spawnRandomCreature(const std::string& creatureList) = 0;

            virtual void spawnBloodEffect (const MWWorld::Ptr& ptr, const osg::Vec3f& worldPosition) = 0;

            virtual void spawnEffect (const std::string& model, const std::string& textureOverride, const osg::Vec3f& worldPos, float scale = 1.f, bool isMagicVFX = true) = 0;

            virtual void explodeSpell(const osg::Vec3f& origin, const ESM::EffectList& effects, const MWWorld::Ptr& caster,
                                      const MWWorld::Ptr& ignore, ESM::RangeType rangeType, const std::string& id,
                                      const std::string& sourceName, const bool fromProjectile=false) = 0;

            virtual void activate (const MWWorld::Ptr& object, const MWWorld::Ptr& actor) = 0;

            virtual bool isInStorm() const = 0;

            virtual osg::Vec3f getStormDirection() const = 0;

            virtual void resetActors() = 0;

            virtual bool isWalkingOnWater (const MWWorld::ConstPtr& actor) const = 0;

            virtual osg::Vec3f aimToTarget(const MWWorld::ConstPtr& actor, const MWWorld::ConstPtr& target) = 0;

            virtual float getHitDistance(const MWWorld::ConstPtr& actor, const MWWorld::ConstPtr& target) = 0;

            virtual void removeContainerScripts(const MWWorld::Ptr& reference) = 0;

            virtual bool isPlayerInJail() const = 0;

            virtual void rest() = 0;

            virtual void setPlayerTraveling(bool traveling) = 0;
            virtual bool isPlayerTraveling() const = 0;

            virtual void rotateWorldObject (const MWWorld::Ptr& ptr, osg::Quat rotate) = 0;

            virtual float getTerrainHeightAt(const osg::Vec3f& worldPos) const = 0;

            virtual osg::Vec3f getHalfExtents(const MWWorld::ConstPtr& actor, bool rendering=false) const = 0;

            virtual std::string exportSceneGraph(const MWWorld::Ptr& ptr) = 0;

            virtual void preloadEffects(const ESM::EffectList* effectList) = 0;
    };
}

#endif