worldimp.hpp

Go to the documentation of this file.

#ifndef GAME_MWWORLD_WORLDIMP_H
#define GAME_MWWORLD_WORLDIMP_H

#include <boost/shared_ptr.hpp>

#include <osg/ref_ptr>

#include <components/settings/settings.hpp>
#include <components/fallback/fallback.hpp>

#include "../mwbase/world.hpp"

#include "ptr.hpp"
#include "scene.hpp"
#include "esmstore.hpp"
#include "cells.hpp"
#include "localscripts.hpp"
#include "timestamp.hpp"
#include "globals.hpp"
#include "contentloader.hpp"

namespace osg
{
    class Group;
}

namespace osgViewer
{
    class Viewer;
}

namespace Resource
{
    class ResourceSystem;
}

namespace ESM
{
    struct Position;
}

namespace Files
{
    class Collections;
}

namespace MWRender
{
    class SkyManager;
    class Animation;
    class Camera;
}

namespace ToUTF8
{
    class Utf8Encoder;
}

struct ContentLoader;

namespace MWWorld
{
    class WeatherManager;
    class Player;
    class ProjectileManager;


    class World : public MWBase::World
    {
            Resource::ResourceSystem* mResourceSystem;

            Fallback::Map mFallback;
            MWRender::RenderingManager* mRendering;

            MWWorld::WeatherManager* mWeatherManager;

            MWWorld::Scene *mWorldScene;
            MWWorld::Player *mPlayer;
            std::vector<ESM::ESMReader> mEsm;
            MWWorld::ESMStore mStore;
            LocalScripts mLocalScripts;
            MWWorld::Globals mGlobalVariables;
            MWPhysics::PhysicsSystem *mPhysics;
            bool mSky;

            ESM::Variant* mGameHour;
            ESM::Variant* mDaysPassed;
            ESM::Variant* mDay;
            ESM::Variant* mMonth;
            ESM::Variant* mYear;
            ESM::Variant* mTimeScale;

            Cells mCells;

            std::string mCurrentWorldSpace;

            boost::shared_ptr<ProjectileManager> mProjectileManager;

            bool mGodMode;
            bool mScriptsEnabled;
            std::vector<std::string> mContentFiles;

            // not implemented
            World (const World&);
            World& operator= (const World&);

            int mActivationDistanceOverride;

            std::string mStartupScript;

            std::map<MWWorld::Ptr, int> mDoorStates;

            std::string mStartCell;

            void updateWeather(float duration, bool paused = false);
            int getDaysPerMonth (int month) const;

            void rotateObjectImp (const Ptr& ptr, const osg::Vec3f& rot, bool adjust);

            Ptr moveObjectImp (const Ptr& ptr, float x, float y, float z, bool movePhysics=true);

            Ptr copyObjectToCell(const ConstPtr &ptr, CellStore* cell, ESM::Position pos, int count, bool adjustPos);

            void updateSoundListener();
            void updateWindowManager ();
            void updatePlayer(bool paused);

            MWWorld::Ptr getFacedObject(float maxDistance, bool ignorePlayer=true);

    public: // FIXME
            void removeContainerScripts(const Ptr& reference);
    private:
            void addContainerScripts(const Ptr& reference, CellStore* cell);
            void PCDropped (const Ptr& item);

            void processDoors(float duration);

            void doPhysics(float duration);

            void ensureNeededRecords();

            void fillGlobalVariables();

            void loadContentFiles(const Files::Collections& fileCollections,
                const std::vector<std::string>& content, ContentLoader& contentLoader);

            float mSwimHeightScale;

            float mDistanceToFacedObject;

            bool isUnderwater(const MWWorld::ConstPtr &object, const float heightRatio) const;

            bool mTeleportEnabled;
            bool mLevitationEnabled;
            bool mGoToJail;
            int mDaysInPrison;

            float feetToGameUnits(float feet);
            float getActivationDistancePlusTelekinesis();

            MWWorld::ConstPtr getClosestMarker( const MWWorld::Ptr &ptr, const std::string &id );
            MWWorld::ConstPtr getClosestMarkerFromExteriorPosition( const osg::Vec3f& worldPos, const std::string &id );

        public:

            World (
                osgViewer::Viewer* viewer,
                osg::ref_ptr<osg::Group> rootNode,
                Resource::ResourceSystem* resourceSystem,
                const Files::Collections& fileCollections,
                const std::vector<std::string>& contentFiles,
                ToUTF8::Utf8Encoder* encoder, const std::map<std::string,std::string>& fallbackMap,
                int activationDistanceOverride, const std::string& startCell, const std::string& startupScript, const std::string& resourcePath);

            virtual ~World();

            virtual void startNewGame (bool bypass);

            virtual void preloadCommonAssets();

            virtual void clear();

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

            virtual void write (ESM::ESMWriter& writer, Loading::Listener& progress) const;

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

            virtual CellStore *getExterior (int x, int y);

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

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

            //switch to POV before showing player's death animation
            virtual void useDeathCamera();

            virtual void setWaterHeight(const float height);

            virtual bool toggleWater();
            virtual bool toggleWorld();

            virtual void adjustSky();

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

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

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

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

            virtual LocalScripts& getLocalScripts();

            virtual bool hasCellChanged() const;

            virtual bool isCellExterior() const;

            virtual bool isCellQuasiExterior() const;

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

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

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

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

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

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

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

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

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

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

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

            virtual Ptr searchPtrViaActorId (int actorId);

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

            virtual void adjustPosition (const Ptr& ptr, bool force);

            virtual void fixPosition (const Ptr& actor);

            virtual void enable (const Ptr& ptr);

            virtual void disable (const Ptr& ptr);

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

            virtual void setHour (double hour);

            virtual void setMonth (int month);

            virtual void setDay (int day);

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

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

            virtual TimeStamp getTimeStamp() const;

            virtual bool toggleSky();

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

            virtual int getCurrentWeather() const;

            virtual int getMasserPhase() const;

            virtual int getSecundaPhase() const;

            virtual void setMoonColour (bool red);

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

            virtual float getTimeScaleFactor() const;

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

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

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

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

            virtual void markCellAsUnchanged();

            virtual MWWorld::Ptr getFacedObject();

            virtual float getDistanceToFacedObject();

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

            virtual void deleteObject (const Ptr& ptr);

            virtual void undeleteObject (const Ptr& ptr);

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

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

            virtual void scaleObject (const Ptr& ptr, float scale);

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

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

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

            virtual float getMaxActivationDistance();

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

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

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

            virtual bool castRay (float x1, float y1, float z1, float x2, float y2, float z2);

            virtual bool toggleCollisionMode();

            virtual bool toggleRenderMode (MWRender::RenderMode mode);

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

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

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

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

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

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

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

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

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

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

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

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

            virtual void update (float duration, bool paused);

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

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

            virtual bool canPlaceObject(float cursorX, float cursorY);

            virtual void processChangedSettings(const Settings::CategorySettingVector& settings);

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

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

            virtual void togglePOV();

            virtual bool isFirstPerson() const;

            virtual void togglePreviewMode(bool enable);

            virtual bool toggleVanityMode(bool enable);

            virtual void allowVanityMode(bool allow);

            virtual void togglePlayerLooking(bool enable);

            virtual void changeVanityModeScale(float factor);

            virtual bool vanityRotateCamera(float * rot);
            virtual void setCameraDistance(float dist, bool adjust = false, bool override = true);

            virtual void setupPlayer();
            virtual void renderPlayer();

            virtual void activateDoor(const MWWorld::Ptr& door);

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

            virtual bool getPlayerStandingOn (const MWWorld::ConstPtr& object); 
            virtual bool getActorStandingOn (const MWWorld::ConstPtr& object); 
            virtual bool getPlayerCollidingWith(const MWWorld::ConstPtr& object); 
            virtual bool getActorCollidingWith (const MWWorld::ConstPtr& object); 
            virtual void hurtStandingActors (const MWWorld::ConstPtr& object, float dmgPerSecond);
            virtual void hurtCollidingActors (const MWWorld::ConstPtr& object, float dmgPerSecond);

            virtual float getWindSpeed();

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

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

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

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

            virtual int canRest();

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

            virtual void screenshot (osg::Image* image, int w, int h);

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

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

            virtual void enableTeleporting(bool enable);

            virtual bool isTeleportingEnabled() const;

            virtual void enableLevitation(bool enable);

            virtual bool isLevitationEnabled() const;

            virtual bool getGodModeState();

            virtual bool toggleGodMode();

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

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

            virtual void castSpell (const MWWorld::Ptr& actor);

            virtual void launchMagicBolt (const std::string& spellId, bool stack, const ESM::EffectList& effects,
                                          const MWWorld::Ptr& caster, const std::string& sourceName, const osg::Vec3f& fallbackDirection);
            virtual void launchProjectile (MWWorld::Ptr actor, MWWorld::ConstPtr projectile,
                                           const osg::Vec3f& worldPos, const osg::Quat& orient, MWWorld::Ptr bow, float speed, float attackStrength);


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

            virtual void breakInvisibility (const MWWorld::Ptr& actor);
            // Are we in an exterior or pseudo-exterior cell and it's night?
            virtual bool isDark() const;

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

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

            virtual void listDetectedReferences (const MWWorld::Ptr& ptr, std::vector<MWWorld::Ptr>& out,
                                                  DetectionType type);

            virtual void updateDialogueGlobals();

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

            virtual void goToJail ();

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

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

            virtual void spawnEffect (const std::string& model, const std::string& textureOverride, const osg::Vec3f& worldPos);

            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);

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

            virtual bool isInStorm() const;

            virtual osg::Vec3f getStormDirection() const;

            virtual void resetActors();

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

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

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

            virtual bool isPlayerInJail() const;

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

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

#endif