Merge branch 'master' of https://github.com/zinnschlag/openmw.git into AI

Conflicts:
	apps/openmw/CMakeLists.txt

apps/esmtool/esmtool.cpp

@@ -227,7 +227,10 @@ void loadCell(ESM::Cell &cell, ESM::ESMReader &esm, Arguments& info)
         std::cout << "    Refnum: " << ref.mRefnum << std::endl;
         std::cout << "    ID: '" << ref.mRefID << "'\n";
         std::cout << "    Owner: '" << ref.mOwner << "'\n";
-        std::cout << "    Uses/health: " << ref.mCharge << "   NAM9: " << ref.mNam9 << std::endl;
+        std::cout << "    Enchantment charge: '" << ref.mEnchantmentCharge << "'\n";
+        std::cout << "    Uses/health: '" << ref.mCharge << "'\n";
+        std::cout << "    Gold value: '" << ref.mGoldValue << "'\n";
+        std::cout << "    Blocked: '" << static_cast<int>(ref.mReferenceBlocked) << "'" << std::endl;
     }
 }
 

apps/esmtool/labels.cpp

@@ -627,10 +627,10 @@ std::string bodyPartFlags(int flags)
     std::string properties = "";
     if (flags == 0) properties += "[None] ";    
     if (flags & ESM::BodyPart::BPF_Female) properties += "Female ";
-    if (flags & ESM::BodyPart::BPF_Playable) properties += "Playable ";
+    if (flags & ESM::BodyPart::BPF_NotPlayable) properties += "NotPlayable ";
     int unused = (0xFFFFFFFF ^
                   (ESM::BodyPart::BPF_Female|
-                   ESM::BodyPart::BPF_Playable));
+                   ESM::BodyPart::BPF_NotPlayable));
     if (flags & unused) properties += "Invalid ";
     properties += str(boost::format("(0x%08X)") % flags);
     return properties;

apps/opencs/editor.hpp

@@ -2,9 +2,9 @@
 #define CS_EDITOR_H
 
 #include <QObject>
-
+#ifndef Q_MOC_RUN
 #include <components/files/configurationmanager.hpp>
-
+#endif
 #include "model/doc/documentmanager.hpp"
 
 #include "view/doc/viewmanager.hpp"

apps/opencs/model/doc/document.cpp

@@ -207,7 +207,7 @@ void CSMDoc::Document::createBase()
     {
         ESM::Skill record;
         record.mIndex = i;
-        record.mId = ESM::Skill::getIndexToId (record.mIndex);
+        record.mId = ESM::Skill::indexToId (record.mIndex);
         record.blank();
 
         getData().getSkills().add (record);

apps/opencs/model/world/columnbase.hpp

@@ -33,7 +33,8 @@ namespace CSMWorld
             Display_GmstVarType,
             Display_GlobalVarType,
             Display_Specialisation,
-            Display_Attribute
+            Display_Attribute,
+            Display_Boolean
         };
 
         std::string mTitle;

apps/opencs/model/world/columns.hpp

@@ -1,6 +1,8 @@
 #ifndef CSM_WOLRD_COLUMNS_H
 #define CSM_WOLRD_COLUMNS_H
 
+#include <sstream>
+
 #include <boost/lexical_cast.hpp>
 
 #include "columnbase.hpp"
@@ -285,6 +287,128 @@ namespace CSMWorld
         }
     };
 
+    template<typename ESXRecordT>
+    struct NameColumn : public Column<ESXRecordT>
+    {
+        NameColumn() : Column<ESXRecordT> ("Name", ColumnBase::Display_String) {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            return QString::fromUtf8 (record.get().mName.c_str());
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            ESXRecordT record2 = record.get();
+
+            record2.mName = data.toString().toUtf8().constData();
+
+            record.setModified (record2);
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
+
+    template<typename ESXRecordT>
+    struct AttributesColumn : public Column<ESXRecordT>
+    {
+        int mIndex;
+
+        AttributesColumn (int index)
+        : Column<ESXRecordT> ("Attribute #" + boost::lexical_cast<std::string> (index),
+            ColumnBase::Display_Attribute), mIndex (index) {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            return record.get().mData.mAttribute[mIndex];
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            ESXRecordT record2 = record.get();
+
+            record2.mData.mAttribute[mIndex] = data.toInt();
+
+            record.setModified (record2);
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
+
+    template<typename ESXRecordT>
+    struct SkillsColumn : public Column<ESXRecordT>
+    {
+        int mIndex;
+        bool mMajor;
+
+        SkillsColumn (int index, bool major)
+        : Column<ESXRecordT> ((major ? "Major Skill #" : "Minor Skill #")+
+            boost::lexical_cast<std::string> (index), ColumnBase::Display_String),
+            mIndex (index), mMajor (major)
+        {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            int skill = record.get().mData.mSkills[mIndex][mMajor ? 1 : 0];
+
+            return QString::fromUtf8 (ESM::Skill::indexToId (skill).c_str());
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            std::istringstream stream (data.toString().toUtf8().constData());
+
+            int index = -1;
+            char c;
+
+            stream >> c >> index;
+
+            if (index!=-1)
+            {
+                ESXRecordT record2 = record.get();
+
+                record2.mData.mSkills[mIndex][mMajor ? 1 : 0] = index;
+
+                record.setModified (record2);
+            }
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
+
+    template<typename ESXRecordT>
+    struct PlayableColumn : public Column<ESXRecordT>
+    {
+        PlayableColumn() : Column<ESXRecordT> ("Playable", ColumnBase::Display_Boolean) {}
+
+        virtual QVariant get (const Record<ESXRecordT>& record) const
+        {
+            return record.get().mData.mIsPlayable!=0;
+        }
+
+        virtual void set (Record<ESXRecordT>& record, const QVariant& data)
+        {
+            ESXRecordT record2 = record.get();
+
+            record2.mData.mIsPlayable = data.toInt();
+
+            record.setModified (record2);
+        }
+
+        virtual bool isEditable() const
+        {
+            return true;
+        }
+    };
 }
 
 #endif

apps/opencs/model/world/data.cpp

@@ -44,9 +44,23 @@ CSMWorld::Data::Data()
         mSkills.addColumn (new UseValueColumn<ESM::Skill> (i));
     mSkills.addColumn (new DescriptionColumn<ESM::Skill>);
 
+    mClasses.addColumn (new StringIdColumn<ESM::Class>);
+    mClasses.addColumn (new RecordStateColumn<ESM::Class>);
+    mClasses.addColumn (new NameColumn<ESM::Class>);
+    mClasses.addColumn (new AttributesColumn<ESM::Class> (0));
+    mClasses.addColumn (new AttributesColumn<ESM::Class> (1));
+    mClasses.addColumn (new SpecialisationColumn<ESM::Class>);
+    for (int i=0; i<5; ++i)
+        mClasses.addColumn (new SkillsColumn<ESM::Class> (i, true));
+    for (int i=0; i<5; ++i)
+        mClasses.addColumn (new SkillsColumn<ESM::Class> (i, false));
+    mClasses.addColumn (new PlayableColumn<ESM::Class>);
+    mClasses.addColumn (new DescriptionColumn<ESM::Class>);
+
     addModel (new IdTable (&mGlobals), UniversalId::Type_Globals, UniversalId::Type_Global);
     addModel (new IdTable (&mGmsts), UniversalId::Type_Gmsts, UniversalId::Type_Gmst);
     addModel (new IdTable (&mSkills), UniversalId::Type_Skills, UniversalId::Type_Skill);
+    addModel (new IdTable (&mClasses), UniversalId::Type_Classes, UniversalId::Type_Class);
 }
 
 CSMWorld::Data::~Data()
@@ -122,6 +136,7 @@ void CSMWorld::Data::loadFile (const boost::filesystem::path& path, bool base)
             case ESM::REC_GLOB: mGlobals.load (reader, base); break;
             case ESM::REC_GMST: mGmsts.load (reader, base); break;
             case ESM::REC_SKIL: mSkills.load (reader, base); break;
+            case ESM::REC_CLAS: mClasses.load (reader, base); break;
 
             default:
 

apps/opencs/model/world/data.hpp

@@ -9,6 +9,7 @@
 #include <components/esm/loadglob.hpp>
 #include <components/esm/loadgmst.hpp>
 #include <components/esm/loadskil.hpp>
+#include <components/esm/loadclas.hpp>
 
 #include "idcollection.hpp"
 #include "universalid.hpp"
@@ -22,6 +23,7 @@ namespace CSMWorld
             IdCollection<ESM::Global> mGlobals;
             IdCollection<ESM::GameSetting> mGmsts;
             IdCollection<ESM::Skill> mSkills;
+            IdCollection<ESM::Class> mClasses;
             std::vector<QAbstractItemModel *> mModels;
             std::map<UniversalId::Type, QAbstractItemModel *> mModelIndex;
 

apps/opencs/model/world/universalid.cpp

@@ -20,6 +20,7 @@ namespace
         { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Globals, "Global Variables" },
         { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Gmsts, "Game Settings" },
         { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Skills, "Skills" },
+        { CSMWorld::UniversalId::Class_RecordList, CSMWorld::UniversalId::Type_Classes, "Classes" },
 
         { CSMWorld::UniversalId::Class_None, CSMWorld::UniversalId::Type_None, 0 } // end marker
     };
@@ -29,6 +30,7 @@ namespace
         { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Global, "Global Variable" },
         { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Gmst, "Game Setting" },
         { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Skill, "Skill" },
+        { CSMWorld::UniversalId::Class_Record, CSMWorld::UniversalId::Type_Class, "Class" },
 
         { CSMWorld::UniversalId::Class_None, CSMWorld::UniversalId::Type_None, 0 } // end marker
     };

apps/opencs/model/world/universalid.hpp

@@ -39,7 +39,9 @@ namespace CSMWorld
                 Type_Gmsts,
                 Type_Gmst,
                 Type_Skills,
-                Type_Skill
+                Type_Skill,
+                Type_Classes,
+                Type_Class
             };
 
         private:

apps/opencs/view/doc/view.cpp

@@ -90,6 +90,10 @@ void CSVDoc::View::setupWorldMenu()
     connect (skills, SIGNAL (triggered()), this, SLOT (addSkillsSubView()));
     world->addAction (skills);
 
+    QAction *classes = new QAction (tr ("Classes"), this);
+    connect (classes, SIGNAL (triggered()), this, SLOT (addClassesSubView()));
+    world->addAction (classes);
+
     mVerify = new QAction (tr ("&Verify"), this);
     connect (mVerify, SIGNAL (triggered()), this, SLOT (verify()));
     world->addAction (mVerify);
@@ -253,6 +257,11 @@ void CSVDoc::View::addSkillsSubView()
     addSubView (CSMWorld::UniversalId::Type_Skills);
 }
 
+void CSVDoc::View::addClassesSubView()
+{
+    addSubView (CSMWorld::UniversalId::Type_Classes);
+}
+
 void CSVDoc::View::abortOperation (int type)
 {
     mDocument->abortOperation (type);

apps/opencs/view/doc/view.hpp

@@ -117,6 +117,8 @@ namespace CSVDoc
             void addGmstsSubView();
 
             void addSkillsSubView();
+
+            void addClassesSubView();
     };
 }
 

apps/opencs/view/world/subviews.cpp

@@ -17,6 +17,9 @@ void CSVWorld::addSubViewFactories (CSVDoc::SubViewFactoryManager& manager)
     manager.add (CSMWorld::UniversalId::Type_Skills,
         new CSVDoc::SubViewFactoryWithCreateFlag<TableSubView> (false));
 
-    manager.add (CSMWorld::UniversalId::Type_Global,
+    manager.add (CSMWorld::UniversalId::Type_Classes,
-        new CSVDoc::SubViewFactoryWithCreateFlag<DialogueSubView> (true));
+        new CSVDoc::SubViewFactoryWithCreateFlag<TableSubView> (true));
+
+//    manager.add (CSMWorld::UniversalId::Type_Global,
+//        new CSVDoc::SubViewFactoryWithCreateFlag<DialogueSubView> (true));
 }

apps/openmw/CMakeLists.txt

@@ -31,7 +31,7 @@ add_openmw_dir (mwgui
     confirmationdialog alchemywindow referenceinterface spellwindow mainmenu quickkeysmenu
     itemselection spellbuyingwindow loadingscreen levelupdialog waitdialog spellcreationdialog
     enchantingdialog trainingwindow travelwindow imagebutton exposedwindow cursor spellicons
-    merchantrepair repair
+    merchantrepair repair soulgemdialog companionwindow
     )
 
 add_openmw_dir (mwdialogue
@@ -54,7 +54,7 @@ add_openmw_dir (mwworld
     containerstore actiontalk actiontake manualref player cellfunctors failedaction
     cells localscripts customdata weather inventorystore ptr actionopen actionread
     actionequip timestamp actionalchemy cellstore actionapply actioneat
-    esmstore store recordcmp fallback actionrepair
+    esmstore store recordcmp fallback actionrepair actionsoulgem
     )
 
 add_openmw_dir (mwclass
@@ -63,9 +63,9 @@ add_openmw_dir (mwclass
     )
 
 add_openmw_dir (mwmechanics
-    mechanicsmanagerimp stat character creaturestats magiceffects movement actors activators
+    mechanicsmanagerimp stat character creaturestats magiceffects movement actors objects
     drawstate spells activespells npcstats aipackage aisequence alchemy aiwander aitravel aifollow
-    aiescort aiactivate repair pathfinding
+    aiescort aiactivate repair enchanting pathfinding
     )
 
 add_openmw_dir (mwbase

apps/openmw/mwbase/dialoguemanager.hpp

@@ -25,6 +25,8 @@ namespace MWBase
 
             virtual ~DialogueManager() {}
 
+            virtual bool isInChoice() const = 0;
+
             virtual void startDialogue (const MWWorld::Ptr& actor) = 0;
 
             virtual void addTopic (const std::string& topic) = 0;

apps/openmw/mwbase/windowmanager.hpp

@@ -201,6 +201,7 @@ namespace MWBase
             ///< Hides dialog and schedules dialog to be deleted.
 
             virtual void messageBox (const std::string& message, const std::vector<std::string>& buttons = std::vector<std::string>()) = 0;
+
             virtual void enterPressed () = 0;
             virtual int readPressedButton() = 0;
             ///< returns the index of the pressed button or -1 if no button was pressed (->MessageBoxmanager->InteractiveMessageBox)
@@ -235,12 +236,16 @@ namespace MWBase
             virtual bool getPlayerSleeping() = 0;
             virtual void wakeUpPlayer() = 0;
 
+            virtual void showCompanionWindow(MWWorld::Ptr actor) = 0;
             virtual void startSpellMaking(MWWorld::Ptr actor) = 0;
             virtual void startEnchanting(MWWorld::Ptr actor) = 0;
+            virtual void startSelfEnchanting(MWWorld::Ptr soulgem) = 0;
             virtual void startTraining(MWWorld::Ptr actor) = 0;
             virtual void startRepair(MWWorld::Ptr actor) = 0;
             virtual void startRepairItem(MWWorld::Ptr item) = 0;
 
+            virtual void showSoulgemDialog (MWWorld::Ptr item) = 0;
+
             virtual void changePointer (const std::string& name) = 0;
 
             virtual const Translation::Storage& getTranslationDataStorage() const = 0;

apps/openmw/mwbase/world.hpp

@@ -44,6 +44,11 @@ namespace MWRender
     class Animation;
 }
 
+namespace MWMechanics
+{
+    class Movement;
+}
+
 namespace MWWorld
 {
     class Fallback;
@@ -54,7 +59,7 @@ namespace MWWorld
     class ESMStore;
     class RefData;
 
-    typedef std::vector<std::pair<MWWorld::Ptr,Ogre::Vector3> > PtrMovementList;
+    typedef std::vector<std::pair<MWWorld::Ptr,MWMechanics::Movement> > PtrMovementList;
 }
 
 namespace MWBase
@@ -244,27 +249,44 @@ namespace MWBase
             ///< Toggle a render mode.
             ///< \return Resulting mode
 
-            virtual const ESM::Potion *createRecord (const ESM::Potion& record)
+            virtual const ESM::Potion *createRecord (const ESM::Potion& record) = 0;
-                = 0;
+            ///< Create a new record (of type potion) in the ESM store.
-            ///< Create a new recrod (of type potion) in the ESM store.
             /// \return pointer to created record
 
-            virtual const ESM::Spell *createRecord (const ESM::Spell& record)
+            virtual const ESM::Spell *createRecord (const ESM::Spell& record) = 0;
-                = 0;
+            ///< Create a new record (of type spell) in the ESM store.
-            ///< Create a new recrod (of type spell) in the ESM store.
             /// \return pointer to created record
 
-            virtual const ESM::Class *createRecord (const ESM::Class& record)
+            virtual const ESM::Class *createRecord (const ESM::Class& record) = 0;
-                = 0;
+            ///< Create a new record (of type class) in the ESM store.
-            ///< Create a new recrod (of type class) in the ESM store.
             /// \return pointer to created record
 
             virtual const ESM::Cell *createRecord (const ESM::Cell& record) = 0;
-            ///< Create a new recrod (of type cell) in the ESM store.
+            ///< Create a new record (of type cell) in the ESM store.
             /// \return pointer to created record
 
             virtual const ESM::NPC *createRecord(const ESM::NPC &record) = 0;
-            ///< Create a new recrod (of type npc) in the ESM store.
+            ///< Create a new record (of type npc) in the ESM store.
+            /// \return pointer to created record
+
+            virtual const ESM::Armor *createRecord (const ESM::Armor& record) = 0;
+            ///< Create a new record (of type armor) in the ESM store.
+            /// \return pointer to created record
+
+            virtual const ESM::Weapon *createRecord (const ESM::Weapon& record) = 0;
+            ///< Create a new record (of type weapon) in the ESM store.
+            /// \return pointer to created record
+
+            virtual const ESM::Clothing *createRecord (const ESM::Clothing& record) = 0;
+            ///< Create a new record (of type clothing) in the ESM store.
+            /// \return pointer to created record
+
+            virtual const ESM::Enchantment *createRecord (const ESM::Enchantment& record) = 0;
+            ///< Create a new record (of type enchantment) in the ESM store.
+            /// \return pointer to created record
+
+            virtual const ESM::Book *createRecord (const ESM::Book& record) = 0;
+            ///< Create a new record (of type book) in the ESM store.
             /// \return pointer to created record
 
             virtual void update (float duration, bool paused) = 0;

apps/openmw/mwclass/armor.cpp

@@ -274,6 +274,20 @@ namespace MWClass
         return ref->mBase->mEnchant;
     }
 
+    std::string Armor::applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const
+    {
+        MWWorld::LiveCellRef<ESM::Armor> *ref =
+            ptr.get<ESM::Armor>();
+
+        ESM::Armor newItem = *ref->mBase;
+        newItem.mId="";
+        newItem.mName=newName;
+        newItem.mData.mEnchant=enchCharge;
+        newItem.mEnchant=enchId;
+        const ESM::Armor *record = MWBase::Environment::get().getWorld()->createRecord (newItem);
+        return record->mId;
+    }
+
     boost::shared_ptr<MWWorld::Action> Armor::use (const MWWorld::Ptr& ptr) const
     {
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr));
@@ -291,4 +305,12 @@ namespace MWClass
 
         return MWWorld::Ptr(&cell.mArmors.insert(*ref), &cell);
     }
+
+    short Armor::getEnchantmentPoints (const MWWorld::Ptr& ptr) const
+    {
+        MWWorld::LiveCellRef<ESM::Armor> *ref =
+                ptr.get<ESM::Armor>();
+
+        return ref->mBase->mData.mEnchant;
+    }
 }

apps/openmw/mwclass/armor.hpp

@@ -65,11 +65,15 @@ namespace MWClass
             virtual std::string getEnchantment (const MWWorld::Ptr& ptr) const;
             ///< @return the enchantment ID if the object is enchanted, otherwise an empty string
 
+            virtual std::string applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const;
+
             virtual boost::shared_ptr<MWWorld::Action> use (const MWWorld::Ptr& ptr)
                 const;
             ///< Generate action for using via inventory menu
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
+
+            virtual short getEnchantmentPoints (const MWWorld::Ptr& ptr) const;
     };
 }
 

apps/openmw/mwclass/book.cpp

@@ -147,6 +147,21 @@ namespace MWClass
         return ref->mBase->mEnchant;
     }
 
+    std::string Book::applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const
+    {
+        MWWorld::LiveCellRef<ESM::Book> *ref =
+            ptr.get<ESM::Book>();
+
+        ESM::Book newItem = *ref->mBase;
+        newItem.mId="";
+        newItem.mName=newName;
+        newItem.mData.mIsScroll = 1;
+        newItem.mData.mEnchant=enchCharge;
+        newItem.mEnchant=enchId;
+        const ESM::Book *record = MWBase::Environment::get().getWorld()->createRecord (newItem);
+        return record->mId;
+    }
+
     boost::shared_ptr<MWWorld::Action> Book::use (const MWWorld::Ptr& ptr) const
     {
         return boost::shared_ptr<MWWorld::Action>(new MWWorld::ActionRead(ptr));
@@ -160,4 +175,12 @@ namespace MWClass
 
         return MWWorld::Ptr(&cell.mBooks.insert(*ref), &cell);
     }
+
+    short Book::getEnchantmentPoints (const MWWorld::Ptr& ptr) const
+    {
+        MWWorld::LiveCellRef<ESM::Book> *ref =
+                ptr.get<ESM::Book>();
+
+        return ref->mBase->mData.mEnchant;
+    }
 }

apps/openmw/mwclass/book.hpp

@@ -51,10 +51,14 @@ namespace MWClass
             virtual std::string getEnchantment (const MWWorld::Ptr& ptr) const;
             ///< @return the enchantment ID if the object is enchanted, otherwise an empty string
 
+            virtual std::string applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const;
+
             virtual boost::shared_ptr<MWWorld::Action> use (const MWWorld::Ptr& ptr) const;
             ///< Generate action for using via inventory menu
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
+
+            virtual short getEnchantmentPoints (const MWWorld::Ptr& ptr) const; 
     };
 }
 

apps/openmw/mwclass/clothing.cpp

@@ -221,6 +221,20 @@ namespace MWClass
         return ref->mBase->mEnchant;
     }
 
+    std::string Clothing::applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const
+    {
+        MWWorld::LiveCellRef<ESM::Clothing> *ref =
+            ptr.get<ESM::Clothing>();
+
+        ESM::Clothing newItem = *ref->mBase;
+        newItem.mId="";
+        newItem.mName=newName;
+        newItem.mData.mEnchant=enchCharge;
+        newItem.mEnchant=enchId;
+        const ESM::Clothing *record = MWBase::Environment::get().getWorld()->createRecord (newItem);
+        return record->mId;
+    }
+
     boost::shared_ptr<MWWorld::Action> Clothing::use (const MWWorld::Ptr& ptr) const
     {
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr));
@@ -238,4 +252,12 @@ namespace MWClass
 
         return MWWorld::Ptr(&cell.mClothes.insert(*ref), &cell);
     }
+
+    short Clothing::getEnchantmentPoints (const MWWorld::Ptr& ptr) const
+    {
+        MWWorld::LiveCellRef<ESM::Clothing> *ref =
+                ptr.get<ESM::Clothing>();
+
+        return ref->mBase->mData.mEnchant;
+    }
 }

apps/openmw/mwclass/clothing.hpp

@@ -59,11 +59,15 @@ namespace MWClass
             virtual std::string getEnchantment (const MWWorld::Ptr& ptr) const;
             ///< @return the enchantment ID if the object is enchanted, otherwise an empty string
 
+            virtual std::string applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const;
+
             virtual boost::shared_ptr<MWWorld::Action> use (const MWWorld::Ptr& ptr)
                 const;
             ///< Generate action for using via inventory menu
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
+
+            virtual short getEnchantmentPoints (const MWWorld::Ptr& ptr) const;
     };
 }
 

apps/openmw/mwclass/container.cpp

@@ -115,7 +115,7 @@ namespace MWClass
 
         if (needKey && hasKey)
         {
-            MWBase::Environment::get().getWindowManager ()->messageBox (keyName + " #{sKeyUsed}", std::vector<std::string>());
+            MWBase::Environment::get().getWindowManager ()->messageBox (keyName + " #{sKeyUsed}");
             ptr.getCellRef().mLockLevel = 0;
             // using a key disarms the trap
             ptr.getCellRef().mTrap = "";

apps/openmw/mwclass/door.cpp

@@ -98,7 +98,7 @@ namespace MWClass
 
         if (needKey && hasKey)
         {
-            MWBase::Environment::get().getWindowManager ()->messageBox (keyName + " #{sKeyUsed}", std::vector<std::string>());
+            MWBase::Environment::get().getWindowManager ()->messageBox (keyName + " #{sKeyUsed}");
             ptr.getCellRef().mLockLevel = 0;
             // using a key disarms the trap
             ptr.getCellRef().mTrap = "";

apps/openmw/mwclass/misc.cpp

@@ -15,6 +15,7 @@
 #include "../mwworld/physicssystem.hpp"
 #include "../mwworld/manualref.hpp"
 #include "../mwworld/nullaction.hpp"
+#include "../mwworld/actionsoulgem.hpp"
 
 #include "../mwgui/tooltips.hpp"
 
@@ -23,6 +24,18 @@
 
 #include <boost/lexical_cast.hpp>
 
+namespace
+{
+bool isGold (const MWWorld::Ptr& ptr)
+{
+    return Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_001")
+                    || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_005")
+                    || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_010")
+                    || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_025")
+                    || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_100");
+}
+}
+
 namespace MWClass
 {
     void Miscellaneous::insertObjectRendering (const MWWorld::Ptr& ptr, MWRender::RenderingInterface& renderingInterface) const
@@ -89,7 +102,15 @@ namespace MWClass
         MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
             ptr.get<ESM::Miscellaneous>();
 
-        return ref->mBase->mData.mValue;
+        int value = (ptr.getCellRef().mGoldValue == 1) ? ref->mBase->mData.mValue : ptr.getCellRef().mGoldValue;
+
+        if (ptr.getCellRef().mSoul != "")
+        {
+            const ESM::Creature *creature = MWBase::Environment::get().getWorld()->getStore().get<ESM::Creature>().find(ref->mRef.mSoul);
+            value *= creature->mData.mSoul;
+        }
+
+        return value;
     }
 
     void Miscellaneous::registerSelf()
@@ -101,25 +122,15 @@ namespace MWClass
 
     std::string Miscellaneous::getUpSoundId (const MWWorld::Ptr& ptr) const
     {
-        MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
+        if (isGold(ptr))
-            ptr.get<ESM::Miscellaneous>();
-
-        if (ref->mBase->mName == MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>().find("sGold")->getString())
-        {
             return std::string("Item Gold Up");
-        }
         return std::string("Item Misc Up");
     }
 
     std::string Miscellaneous::getDownSoundId (const MWWorld::Ptr& ptr) const
     {
-        MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
+        if (isGold(ptr))
-            ptr.get<ESM::Miscellaneous>();
-
-        if (ref->mBase->mName == MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>().find("sGold")->getString())
-        {
             return std::string("Item Gold Down");
-        }
         return std::string("Item Misc Down");
     }
 
@@ -150,12 +161,15 @@ namespace MWClass
 
         int count = ptr.getRefData().getCount();
 
-        bool isGold = (ref->mBase->mName == store.get<ESM::GameSetting>().find("sGold")->getString());
+        bool gold = isGold(ptr);
-        if (isGold && count == 1)
+
-            count = ref->mBase->mData.mValue;
+        if (gold && ptr.getCellRef().mGoldValue != 1)
+            count = ptr.getCellRef().mGoldValue;
+        else if (gold)
+            count *= ref->mBase->mData.mValue;
 
         std::string countString;
-        if (!isGold)
+        if (!gold)
             countString = MWGui::ToolTips::getCountString(count);
         else // gold displays its count also if it's 1.
             countString = " (" + boost::lexical_cast<std::string>(count) + ")";
@@ -171,10 +185,10 @@ namespace MWClass
 
         std::string text;
 
-        if (!isGold)
+        if (!gold)
         {
             text += "\n#{sWeight}: " + MWGui::ToolTips::toString(ref->mBase->mData.mWeight);
-            text += MWGui::ToolTips::getValueString(ref->mBase->mData.mValue, "#{sValue}");
+            text += MWGui::ToolTips::getValueString(getValue(ptr), "#{sValue}");
         }
 
         if (MWBase::Environment::get().getWindowManager()->getFullHelp()) {
@@ -195,7 +209,7 @@ namespace MWClass
         const MWWorld::ESMStore &store =
             MWBase::Environment::get().getWorld()->getStore();
 
-        if (MWWorld::Class::get(ptr).getName(ptr) == store.get<ESM::GameSetting>().find("sGold")->getString()) {
+        if (isGold(ptr)) {
             int goldAmount = ptr.getRefData().getCount();
 
             std::string base = "Gold_001";
@@ -214,7 +228,8 @@ namespace MWClass
             MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
                 newRef.getPtr().get<ESM::Miscellaneous>();
             newPtr = MWWorld::Ptr(&cell.mMiscItems.insert(*ref), &cell);
-            newPtr.getRefData ().setCount(goldAmount);
+            newPtr.getRefData ().setCount(1);
+            newPtr.getCellRef().mGoldValue = goldAmount;
         } else {
             MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
                 ptr.get<ESM::Miscellaneous>();
@@ -222,4 +237,13 @@ namespace MWClass
         }
         return newPtr;
     }
+
+    boost::shared_ptr<MWWorld::Action> Miscellaneous::use (const MWWorld::Ptr& ptr) const
+    {
+        if (ptr.getCellRef().mSoul == "")
+            return boost::shared_ptr<MWWorld::Action>(new MWWorld::NullAction());
+        else
+            return boost::shared_ptr<MWWorld::Action>(new MWWorld::ActionSoulgem(ptr));
+    }
+
 }

apps/openmw/mwclass/misc.hpp

@@ -49,6 +49,10 @@ namespace MWClass
             ///< Return name of inventory icon.
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
+
+            virtual boost::shared_ptr<MWWorld::Action> use (const MWWorld::Ptr& ptr)
+                const;
+            ///< Generate action for using via inventory menu
     };
 }
 

apps/openmw/mwclass/npc.cpp

@@ -368,7 +368,7 @@ namespace MWClass
             moveSpeed = runSpeed;
         else
             moveSpeed = walkSpeed;
-        if(getMovementSettings(ptr).mLeftRight != 0 && getMovementSettings(ptr).mForwardBackward == 0)
+        if(getMovementSettings(ptr).mPosition[0] != 0 && getMovementSettings(ptr).mPosition[1] == 0)
             moveSpeed *= 0.75f;
 
         return moveSpeed;
@@ -414,12 +414,22 @@ namespace MWClass
 
     Ogre::Vector3 Npc::getMovementVector (const MWWorld::Ptr& ptr) const
     {
-        Ogre::Vector3 vector;
+        MWMechanics::Movement &movement = getMovementSettings(ptr);
-        vector.x = getMovementSettings(ptr).mLeftRight;
+        Ogre::Vector3 vec(movement.mPosition);
-        vector.y = getMovementSettings(ptr).mForwardBackward;
+        movement.mPosition[0] = 0.0f;
-        vector.z = getMovementSettings(ptr).mUpDown;
+        movement.mPosition[1] = 0.0f;
+        movement.mPosition[2] = 0.0f;
+        return vec;
+    }
 
-        return vector;
+    Ogre::Vector3 Npc::getRotationVector (const MWWorld::Ptr& ptr) const
+    {
+        MWMechanics::Movement &movement = getMovementSettings(ptr);
+        Ogre::Vector3 vec(movement.mRotation);
+        movement.mRotation[0] = 0.0f;
+        movement.mRotation[1] = 0.0f;
+        movement.mRotation[2] = 0.0f;
+        return vec;
     }
 
     bool Npc::isEssential (const MWWorld::Ptr& ptr) const

apps/openmw/mwclass/npc.hpp

@@ -96,6 +96,9 @@ namespace MWClass
             ///< Return desired movement vector (determined based on movement settings,
             /// stance and stats).
 
+            virtual Ogre::Vector3 getRotationVector (const MWWorld::Ptr& ptr) const;
+            ///< Return desired rotations, as euler angles.
+
             virtual float getCapacity (const MWWorld::Ptr& ptr) const;
             ///< Return total weight that fits into the object. Throws an exception, if the object can't
             /// hold other objects.

apps/openmw/mwclass/weapon.cpp

@@ -367,6 +367,20 @@ namespace MWClass
         return ref->mBase->mEnchant;
     }
 
+    std::string Weapon::applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const
+    {
+            MWWorld::LiveCellRef<ESM::Weapon> *ref =
+            ptr.get<ESM::Weapon>();
+
+            ESM::Weapon newItem = *ref->mBase;
+            newItem.mId="";
+            newItem.mName=newName;
+            newItem.mData.mEnchant=enchCharge;
+            newItem.mEnchant=enchId;
+            const ESM::Weapon *record = MWBase::Environment::get().getWorld()->createRecord (newItem);
+            return record->mId;
+    }
+
     boost::shared_ptr<MWWorld::Action> Weapon::use (const MWWorld::Ptr& ptr) const
     {
         boost::shared_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr));
@@ -384,4 +398,12 @@ namespace MWClass
 
         return MWWorld::Ptr(&cell.mWeapons.insert(*ref), &cell);
     }
+
+    short Weapon::getEnchantmentPoints (const MWWorld::Ptr& ptr) const
+    {
+        MWWorld::LiveCellRef<ESM::Weapon> *ref =
+                ptr.get<ESM::Weapon>();
+
+        return ref->mBase->mData.mEnchant;
+    }
 }

apps/openmw/mwclass/weapon.hpp

@@ -65,11 +65,15 @@ namespace MWClass
             virtual std::string getEnchantment (const MWWorld::Ptr& ptr) const;
             ///< @return the enchantment ID if the object is enchanted, otherwise an empty string
 
+            virtual std::string applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const;
+
             virtual boost::shared_ptr<MWWorld::Action> use (const MWWorld::Ptr& ptr)
                 const;
             ///< Generate action for using via inventory menu
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
+
+            virtual short getEnchantmentPoints (const MWWorld::Ptr& ptr) const;
     };
 }
 

apps/openmw/mwdialogue/dialoguemanagerimp.cpp

@@ -117,6 +117,8 @@ namespace MWDialogue
 
     void DialogueManager::startDialogue (const MWWorld::Ptr& actor)
     {
+        mLastTopic = "";
+
         mChoice = -1;
         mIsInChoice = false;
 
@@ -127,6 +129,9 @@ namespace MWDialogue
 
         mActorKnownTopics.clear();
 
+        MWGui::DialogueWindow* win = MWBase::Environment::get().getWindowManager()->getDialogueWindow();
+        win->startDialogue(actor, MWWorld::Class::get (actor).getName (actor));
+
         //setup the list of topics known by the actor. Topics who are also on the knownTopics list will be added to the GUI
         updateTopics();
 
@@ -145,8 +150,6 @@ namespace MWDialogue
                 {
                     //initialise the GUI
                     MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Dialogue);
-                    MWGui::DialogueWindow* win = MWBase::Environment::get().getWindowManager()->getDialogueWindow();
-                    win->startDialogue(actor, MWWorld::Class::get (actor).getName (actor));
 
                     creatureStats.talkedToPlayer();
 
@@ -160,7 +163,7 @@ namespace MWDialogue
                     MWScript::InterpreterContext interpreterContext(&mActor.getRefData().getLocals(),mActor);
                     win->addText (Interpreter::fixDefinesDialog(info->mResponse, interpreterContext));
                     executeScript (info->mResultScript);
-                    mLastTopic = it->mId;
+                    mLastTopic = Misc::StringUtils::lowerCase(it->mId);
                     mLastDialogue = *info;
                     break;
                 }
@@ -398,6 +401,11 @@ namespace MWDialogue
         updateTopics();
     }
 
+    bool DialogueManager::isInChoice() const
+    {
+        return mIsInChoice;
+    }
+
     void DialogueManager::goodbyeSelected()
     {
         // Do not close the dialogue window if the player has to answer a question
@@ -424,15 +432,13 @@ namespace MWDialogue
 
             if (mDialogueMap.find(mLastTopic) != mDialogueMap.end())
             {
-                if (mDialogueMap[mLastTopic].mType == ESM::Dialogue::Topic)
+                Filter filter (mActor, mChoice, mTalkedTo);
-                {
-                    Filter filter (mActor, mChoice, mTalkedTo);
 
+                if (mDialogueMap[mLastTopic].mType == ESM::Dialogue::Topic
+                        || mDialogueMap[mLastTopic].mType == ESM::Dialogue::Greeting)
+                {
                     if (const ESM::DialInfo *info = filter.search (mDialogueMap[mLastTopic], true))
                     {
-                        mChoiceMap.clear();
-                        mChoice = -1;
-                        mIsInChoice = false;
                         std::string text = info->mResponse;
                         parseText (text);
 
@@ -440,10 +446,12 @@ namespace MWDialogue
                         MWBase::Environment::get().getWindowManager()->getDialogueWindow()->addText (Interpreter::fixDefinesDialog(text, interpreterContext));
                         MWBase::Environment::get().getJournal()->addTopic (mLastTopic, info->mId);
                         executeScript (info->mResultScript);
-                        mLastTopic = mLastTopic;
                         mLastDialogue = *info;
                     }
                 }
+                mChoiceMap.clear();
+                mChoice = -1;
+                mIsInChoice = false;
             }
 
             updateTopics();

apps/openmw/mwdialogue/dialoguemanagerimp.hpp

@@ -54,6 +54,8 @@ namespace MWDialogue
 
             DialogueManager (const Compiler::Extensions& extensions, bool scriptVerbose, Translation::Storage& translationDataStorage);
 
+            virtual bool isInChoice() const;
+
             virtual void startDialogue (const MWWorld::Ptr& actor);
 
             virtual void addTopic (const std::string& topic);

apps/openmw/mwdialogue/filter.cpp

@@ -198,7 +198,7 @@ bool MWDialogue::Filter::testSelectStructNumeric (const SelectWrapper& select) c
             if (i<script->mData.mNumLongs)
                 return select.selectCompare (locals.mLongs[i]);
 
-            i -= script->mData.mNumShorts;
+            i -= script->mData.mNumLongs;
 
             return select.selectCompare (locals.mFloats.at (i));
         }

apps/openmw/mwgui/alchemywindow.cpp

@@ -77,40 +77,40 @@ namespace MWGui
 
         if (result == MWMechanics::Alchemy::Result_NoName)
         {
-            mWindowManager.messageBox("#{sNotifyMessage37}", std::vector<std::string>());
+            mWindowManager.messageBox("#{sNotifyMessage37}");
             return;
         }
 
         // check if mortar & pestle is available (always needed)
         if (result == MWMechanics::Alchemy::Result_NoMortarAndPestle)
         {
-            mWindowManager.messageBox("#{sNotifyMessage45}", std::vector<std::string>());
+            mWindowManager.messageBox("#{sNotifyMessage45}");
             return;
         }
 
         // make sure 2 or more ingredients were selected
         if (result == MWMechanics::Alchemy::Result_LessThanTwoIngredients)
         {
-            mWindowManager.messageBox("#{sNotifyMessage6a}", std::vector<std::string>());
+            mWindowManager.messageBox("#{sNotifyMessage6a}");
             return;
         }
 
         if (result == MWMechanics::Alchemy::Result_NoEffects)
         {
-            mWindowManager.messageBox("#{sNotifyMessage8}", std::vector<std::string>());
+            mWindowManager.messageBox("#{sNotifyMessage8}");
             MWBase::Environment::get().getSoundManager()->playSound("potion fail", 1.f, 1.f);
             return;
         }
 
         if (result == MWMechanics::Alchemy::Result_Success)
         {
-            mWindowManager.messageBox("#{sPotionSuccess}", std::vector<std::string>());
+            mWindowManager.messageBox("#{sPotionSuccess}");
             MWBase::Environment::get().getSoundManager()->playSound("potion success", 1.f, 1.f);
         }
         else if (result == MWMechanics::Alchemy::Result_RandomFailure)
         {
             // potion failed
-            mWindowManager.messageBox("#{sNotifyMessage8}", std::vector<std::string>());
+            mWindowManager.messageBox("#{sNotifyMessage8}");
             MWBase::Environment::get().getSoundManager()->playSound("potion fail", 1.f, 1.f);
         }
 

apps/openmw/mwgui/companionwindow.cpp

@@ -0,0 +1,107 @@
+#include "companionwindow.hpp"
+
+#include <boost/lexical_cast.hpp>
+
+#include "../mwbase/windowmanager.hpp"
+#include "../mwbase/environment.hpp"
+#include "../mwbase/dialoguemanager.hpp"
+
+#include "../mwmechanics/npcstats.hpp"
+
+#include "messagebox.hpp"
+
+namespace MWGui
+{
+
+CompanionWindow::CompanionWindow(MWBase::WindowManager &parWindowManager, DragAndDrop *dragAndDrop, MessageBoxManager* manager)
+    : ContainerBase(dragAndDrop)
+    , WindowBase("openmw_companion_window.layout", parWindowManager)
+    , mMessageBoxManager(manager)
+{
+    MyGUI::ScrollView* itemView;
+    MyGUI::Widget* containerWidget;
+    getWidget(containerWidget, "Items");
+    getWidget(itemView, "ItemView");
+    setWidgets(containerWidget, itemView);
+
+    getWidget(mCloseButton, "CloseButton");
+    getWidget(mProfitLabel, "ProfitLabel");
+    getWidget(mEncumbranceBar, "EncumbranceBar");
+
+    mCloseButton->eventMouseButtonClick += MyGUI::newDelegate(this, &CompanionWindow::onCloseButtonClicked);
+
+    setCoord(200,0,600,300);
+}
+
+void CompanionWindow::open(MWWorld::Ptr npc)
+{
+    openContainer(npc);
+    setTitle(MWWorld::Class::get(npc).getName(npc));
+    drawItems();
+    updateEncumbranceBar();
+}
+
+void CompanionWindow::notifyItemDragged(MWWorld::Ptr item, int count)
+{
+    if (mPtr.getTypeName() == typeid(ESM::NPC).name())
+    {
+        MWMechanics::NpcStats& stats = MWWorld::Class::get(mPtr).getNpcStats(mPtr);
+        stats.modifyProfit(MWWorld::Class::get(item).getValue(item) * count);
+    }
+    updateEncumbranceBar();
+}
+
+void CompanionWindow::updateEncumbranceBar()
+{
+    float capacity = MWWorld::Class::get(mPtr).getCapacity(mPtr);
+    float encumbrance = MWWorld::Class::get(mPtr).getEncumbrance(mPtr);
+    mEncumbranceBar->setValue(encumbrance, capacity);
+
+    if (mPtr.getTypeName() != typeid(ESM::NPC).name())
+        mProfitLabel->setCaption("");
+    else
+    {
+        MWMechanics::NpcStats& stats = MWWorld::Class::get(mPtr).getNpcStats(mPtr);
+        mProfitLabel->setCaptionWithReplacing("#{sProfitValue} " + boost::lexical_cast<std::string>(stats.getProfit()));
+    }
+}
+
+void CompanionWindow::onWindowResize(MyGUI::Window* window)
+{
+    drawItems();
+}
+
+void CompanionWindow::onCloseButtonClicked(MyGUI::Widget* _sender)
+{
+    if (mPtr.getTypeName() == typeid(ESM::NPC).name() && MWWorld::Class::get(mPtr).getNpcStats(mPtr).getProfit() < 0)
+    {
+        std::vector<std::string> buttons;
+        buttons.push_back("#{sCompanionWarningButtonOne}");
+        buttons.push_back("#{sCompanionWarningButtonTwo}");
+        mMessageBoxManager->createInteractiveMessageBox("#{sCompanionWarningMessage}", buttons);
+        mMessageBoxManager->eventButtonPressed += MyGUI::newDelegate(this, &CompanionWindow::onMessageBoxButtonClicked);
+    }
+    else
+        MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Companion);
+}
+
+void CompanionWindow::onMessageBoxButtonClicked(int button)
+{
+    if (button == 0)
+    {
+        mPtr.getRefData().getLocals().setVarByInt(MWWorld::Class::get(mPtr).getScript(mPtr),
+            "minimumProfit", MWWorld::Class::get(mPtr).getNpcStats(mPtr).getProfit());
+
+        MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Companion);
+        MWBase::Environment::get().getDialogueManager()->startDialogue (mPtr);
+    }
+}
+
+void CompanionWindow::onReferenceUnavailable()
+{
+    MWBase::Environment::get().getWindowManager()->removeGuiMode(GM_Companion);
+}
+
+
+
+}

apps/openmw/mwgui/companionwindow.hpp

@@ -0,0 +1,39 @@
+#ifndef OPENMW_MWGUI_COMPANIONWINDOW_H
+#define OPENMW_MWGUI_COMPANIONWINDOW_H
+
+#include "container.hpp"
+#include "widgets.hpp"
+
+namespace MWGui
+{
+    class MessageBoxManager;
+
+    class CompanionWindow : public ContainerBase, public WindowBase
+    {
+    public:
+        CompanionWindow(MWBase::WindowManager& parWindowManager,DragAndDrop* dragAndDrop, MessageBoxManager* manager);
+        virtual ~CompanionWindow() {}
+
+        void open(MWWorld::Ptr npc);
+
+        virtual void notifyItemDragged(MWWorld::Ptr item, int count);
+
+    protected:
+        MyGUI::Button* mCloseButton;
+        MyGUI::TextBox* mProfitLabel;
+        Widgets::MWDynamicStat* mEncumbranceBar;
+        MessageBoxManager* mMessageBoxManager;
+
+        void onMessageBoxButtonClicked(int button);
+
+        void updateEncumbranceBar();
+
+        void onWindowResize(MyGUI::Window* window);
+        void onCloseButtonClicked(MyGUI::Widget* _sender);
+
+        virtual void onReferenceUnavailable();
+    };
+
+}
+
+#endif

apps/openmw/mwgui/container.cpp

@@ -68,6 +68,16 @@ namespace
             return compareType(left.getTypeName(), right.getTypeName());
         }
     }
+
+    bool isChargedSoulstone (MWWorld::Ptr ptr)
+    {
+        if (ptr.getTypeName() != typeid(ESM::Miscellaneous).name())
+            return false;
+        MWWorld::LiveCellRef<ESM::Miscellaneous> *ref =
+            ptr.get<ESM::Miscellaneous>();
+
+        return (ref->mRef.mSoul != "");
+    }
 }
 
 
@@ -130,17 +140,12 @@ void ContainerBase::onSelectedItem(MyGUI::Widget* _sender)
 
         if (isInventory())
         {
-            const MWWorld::Store<ESM::GameSetting> &gmst =
-                MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>();
-
             // the player is trying to sell an item, check if the merchant accepts it
-            // also, don't allow selling gold (let's be better than Morrowind at this, can we?)
+            if (!MWBase::Environment::get().getWindowManager()->getTradeWindow()->npcAcceptsItem(object))
-            if (!MWBase::Environment::get().getWindowManager()->getTradeWindow()->npcAcceptsItem(object) ||
-                MWWorld::Class::get(object).getName(object) == gmst.find("sGold")->getString())
             {
                 // user notification "i don't buy this item"
                 MWBase::Environment::get().getWindowManager()->
-                        messageBox("#{sBarterDialog4}", std::vector<std::string>());
+                        messageBox("#{sBarterDialog4}");
                 return;
             }
         }
@@ -284,7 +289,7 @@ void ContainerBase::onContainerClicked(MyGUI::Widget* _sender)
                 {
                     // user notification
                     MWBase::Environment::get().getWindowManager()->
-                        messageBox("#{sContentsMessage2}", std::vector<std::string>());
+                        messageBox("#{sContentsMessage2}");
 
                     return;
                 }
@@ -308,7 +313,7 @@ void ContainerBase::onContainerClicked(MyGUI::Widget* _sender)
                     object.getRefData().setCount(origCount);
                     // user notification
                     MWBase::Environment::get().getWindowManager()->
-                        messageBox("#{sContentsMessage3}", std::vector<std::string>());
+                        messageBox("#{sContentsMessage3}");
 
                     return;
                 }
@@ -330,6 +335,9 @@ void ContainerBase::onContainerClicked(MyGUI::Widget* _sender)
         drawItems();
         mDragAndDrop->mDraggedFrom->drawItems();
 
+        mDragAndDrop->mDraggedFrom->notifyItemDragged(object, -mDragAndDrop->mDraggedCount);
+        notifyItemDragged(object, mDragAndDrop->mDraggedCount);
+
         MWBase::Environment::get().getWindowManager()->setDragDrop(false);
 
         std::string sound = MWWorld::Class::get(object).getDownSoundId(object);
@@ -345,7 +353,7 @@ void ContainerBase::onMouseWheel(MyGUI::Widget* _sender, int _rel)
         mItemView->setViewOffset(MyGUI::IntPoint(mItemView->getViewOffset().left + _rel*0.3, 0));
 }
 
-void ContainerBase::setFilter(ContainerBase::Filter filter)
+void ContainerBase::setFilter(int filter)
 {
     mFilter = filter;
     drawItems();
@@ -369,29 +377,34 @@ void ContainerBase::drawItems()
     int maxHeight = mItemView->getSize().height - 58;
 
     bool onlyMagic = false;
+    bool noMagic = false;
     int categories = 0;
-    if (mFilter == Filter_All)
+    if (mFilter & Filter_All)
-        categories = MWWorld::ContainerStore::Type_All;
+        categories |= MWWorld::ContainerStore::Type_All;
-    else if (mFilter == Filter_Weapon)
+    if (mFilter & Filter_Weapon)
-        categories = MWWorld::ContainerStore::Type_Weapon;
+        categories |= MWWorld::ContainerStore::Type_Weapon;
-    else if (mFilter == Filter_Apparel)
+    if (mFilter & Filter_Apparel)
-        categories = MWWorld::ContainerStore::Type_Clothing + MWWorld::ContainerStore::Type_Armor;
+        categories |= MWWorld::ContainerStore::Type_Clothing | MWWorld::ContainerStore::Type_Armor;
-    else if (mFilter == Filter_Magic)
+    if (mFilter & Filter_Magic)
     {
-        categories = MWWorld::ContainerStore::Type_Clothing + MWWorld::ContainerStore::Type_Armor
+        categories |= MWWorld::ContainerStore::Type_Clothing | MWWorld::ContainerStore::Type_Armor
-                    + MWWorld::ContainerStore::Type_Weapon + MWWorld::ContainerStore::Type_Book
+                    | MWWorld::ContainerStore::Type_Weapon | MWWorld::ContainerStore::Type_Book
-                    + MWWorld::ContainerStore::Type_Potion;
+                    | MWWorld::ContainerStore::Type_Potion;
         onlyMagic = true;
     }
-    else if (mFilter == Filter_Misc)
+    if (mFilter & Filter_Misc)
     {
-        categories = MWWorld::ContainerStore::Type_Miscellaneous + MWWorld::ContainerStore::Type_Book
+        categories |= MWWorld::ContainerStore::Type_Miscellaneous | MWWorld::ContainerStore::Type_Book
-                    + MWWorld::ContainerStore::Type_Ingredient + MWWorld::ContainerStore::Type_Repair
+                    | MWWorld::ContainerStore::Type_Ingredient | MWWorld::ContainerStore::Type_Repair
-                    + MWWorld::ContainerStore::Type_Lockpick + MWWorld::ContainerStore::Type_Light
+                    | MWWorld::ContainerStore::Type_Lockpick | MWWorld::ContainerStore::Type_Light
-                    + MWWorld::ContainerStore::Type_Apparatus + MWWorld::ContainerStore::Type_Probe;
+                    | MWWorld::ContainerStore::Type_Apparatus | MWWorld::ContainerStore::Type_Probe;
     }
-    else if (mFilter == Filter_Ingredients)
+    if (mFilter & Filter_Ingredients)
-        categories = MWWorld::ContainerStore::Type_Ingredient;
+        categories |= MWWorld::ContainerStore::Type_Ingredient;
+    if (mFilter & Filter_ChargedSoulstones)
+        categories |= MWWorld::ContainerStore::Type_Miscellaneous;
+    if (mFilter & Filter_NoMagic)
+        noMagic = true;
 
     /// \todo performance improvement: don't create/destroy all the widgets everytime the container window changes size, only reposition them
 
@@ -466,12 +479,29 @@ void ContainerBase::drawItems()
     {
         const MWWorld::Ptr* iter = &((*it).first);
 
+
+        if (onlyMagic
+                && it->second != ItemState_Barter
+                && MWWorld::Class::get(*iter).getEnchantment(*iter) == ""
+                && iter->getTypeName() != typeid(ESM::Potion).name())
+            continue;
+
+        if (noMagic
+                && it->second != ItemState_Barter
+                && (MWWorld::Class::get(*iter).getEnchantment(*iter) != ""
+                || iter->getTypeName() == typeid(ESM::Potion).name()))
+            continue;
+
+        if ( (mFilter & Filter_ChargedSoulstones)
+                && !isChargedSoulstone(*iter))
+            continue;
+
         int displayCount = iter->getRefData().getCount();
         if (mDragAndDrop != NULL && mDragAndDrop->mIsOnDragAndDrop && *iter == *mDragAndDrop->mDraggedWidget->getUserData<MWWorld::Ptr>())
         {
             displayCount -= mDragAndDrop->mDraggedCount;
         }
-        if(displayCount > 0 && !(onlyMagic && it->second != ItemState_Barter && MWWorld::Class::get(*iter).getEnchantment(*iter) == "" && iter->getTypeName() != typeid(ESM::Potion).name()))
+        if(displayCount > 0)
         {
             std::string path = std::string("icons\\");
             path += MWWorld::Class::get(*iter).getInventoryIcon(*iter);

apps/openmw/mwgui/container.hpp

@@ -48,16 +48,17 @@ namespace MWGui
         ContainerBase(DragAndDrop* dragAndDrop);
         virtual ~ContainerBase();
 
-        enum Filter
+        // basic types (inclusive)
-        {
+        static const int Filter_All = (1<<0);
-            Filter_All = 0x01,
+        static const int Filter_Weapon = (1<<1);
-            Filter_Weapon = 0x02,
+        static const int Filter_Apparel = (1<<2);
-            Filter_Apparel = 0x03,
+        static const int Filter_Ingredients = (1<<3);
-            Filter_Magic = 0x04,
+        static const int Filter_Misc = (1<<4);
-            Filter_Misc = 0x05,
 
-            Filter_Ingredients = 0x06
+        // special filtering (exclusive)
-        };
+        static const int Filter_Magic = (1<<5);
+        static const int Filter_NoMagic = (1<<6);
+        static const int Filter_ChargedSoulstones = (1<<7);
 
         enum ItemState
         {
@@ -78,9 +79,13 @@ namespace MWGui
         MWWorld::ContainerStore& getBoughtItems() { return mBoughtItems; }
 
         void openContainer(MWWorld::Ptr container);
-        void setFilter(Filter filter); ///< set category filter
+        void setFilter(int filter); ///< set category filter
         void drawItems();
 
+        /// fired when an item was moved by drag&drop. \n
+        /// if it was removed from this container, count will be negative.
+        virtual void notifyItemDragged(MWWorld::Ptr item, int count) {}
+
     protected:
         bool mDisplayEquippedItems;
         bool mHighlightEquippedItems;
@@ -92,7 +97,7 @@ namespace MWGui
 
         DragAndDrop* mDragAndDrop;
 
-        Filter mFilter;
+        int mFilter;
 
         // bought items are put in a separate ContainerStore so that they don't stack with other (not bought) items.
         MWWorld::ContainerStore mBoughtItems;

apps/openmw/mwgui/dialogue.cpp

@@ -228,7 +228,8 @@ void DialogueWindow::onByeClicked(MyGUI::Widget* _sender)
 
 void DialogueWindow::onSelectTopic(const std::string& topic, int id)
 {
-    if (!mEnabled) return;
+    if (!mEnabled || MWBase::Environment::get().getDialogueManager()->isInChoice())
+        return;
 
     int separatorPos = 0;
     for (unsigned int i=0; i<mTopicsList->getItemCount(); ++i)
@@ -248,6 +249,11 @@ void DialogueWindow::onSelectTopic(const std::string& topic, int id)
         {
             mPersuasionDialog.setVisible(true);
         }
+        else if (topic == gmst.find("sCompanionShare")->getString())
+        {
+            mWindowManager.pushGuiMode(GM_Companion);
+            mWindowManager.showCompanionWindow(mPtr);
+        }
         else if (!MWBase::Environment::get().getDialogueManager()->checkServiceRefused())
         {
             if (topic == gmst.find("sBarter")->getString())
@@ -306,7 +312,10 @@ void DialogueWindow::setKeywords(std::list<std::string> keyWords)
 {
     mTopicsList->clear();
 
-    bool anyService = mServices > 0;
+    bool isCompanion = !MWWorld::Class::get(mPtr).getScript(mPtr).empty()
+            && mPtr.getRefData().getLocals().getIntVar(MWWorld::Class::get(mPtr).getScript(mPtr), "companion");
+
+    bool anyService = mServices > 0 || isCompanion || mPtr.getTypeName() == typeid(ESM::NPC).name();
 
     const MWWorld::Store<ESM::GameSetting> &gmst =
         MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>();
@@ -326,8 +335,8 @@ void DialogueWindow::setKeywords(std::list<std::string> keyWords)
     if (mServices & Service_CreateSpells)
         mTopicsList->addItem(gmst.find("sSpellmakingMenuTitle")->getString());
 
-//    if (mServices & Service_Enchant)
+    if (mServices & Service_Enchant)
-//        mTopicsList->addItem(gmst.find("sEnchanting")->getString());
+        mTopicsList->addItem(gmst.find("sEnchanting")->getString());
 
     if (mServices & Service_Training)
         mTopicsList->addItem(gmst.find("sServiceTrainingTitle")->getString());
@@ -335,9 +344,13 @@ void DialogueWindow::setKeywords(std::list<std::string> keyWords)
     if (mServices & Service_Repair)
         mTopicsList->addItem(gmst.find("sRepair")->getString());
 
-    if (anyService || mPtr.getTypeName() == typeid(ESM::NPC).name())
+    if (isCompanion)
+        mTopicsList->addItem(gmst.find("sCompanionShare")->getString());
+
+    if (anyService)
         mTopicsList->addSeparator();
 
+
     for(std::list<std::string>::iterator it = keyWords.begin(); it != keyWords.end(); ++it)
     {
         mTopicsList->addItem(*it);

apps/openmw/mwgui/enchantingdialog.cpp

@@ -1,5 +1,15 @@
 #include "enchantingdialog.hpp"
 
+#include <boost/lexical_cast.hpp>
+
+#include "../mwbase/environment.hpp"
+#include "../mwbase/world.hpp"
+#include "../mwworld/player.hpp"
+#include "../mwworld/manualref.hpp"
+
+#include "itemselection.hpp"
+#include "container.hpp"
+#include "inventorywindow.hpp"
 
 namespace MWGui
 {
@@ -8,19 +18,71 @@ namespace MWGui
     EnchantingDialog::EnchantingDialog(MWBase::WindowManager &parWindowManager)
         : WindowBase("openmw_enchanting_dialog.layout", parWindowManager)
         , EffectEditorBase(parWindowManager)
+        , mItemSelectionDialog(NULL)
+        , mEnchanting(MWBase::Environment::get().getWorld()->getPlayer().getPlayer())
     {
+        getWidget(mName, "NameEdit");
         getWidget(mCancelButton, "CancelButton");
         getWidget(mAvailableEffectsList, "AvailableEffects");
         getWidget(mUsedEffectsView, "UsedEffects");
+        getWidget(mItemBox, "ItemBox");
+        getWidget(mSoulBox, "SoulBox");
+        getWidget(mEnchantmentPoints, "Enchantment");
+        getWidget(mCastCost, "CastCost");
+        getWidget(mCharge, "Charge");
+        getWidget(mTypeButton, "TypeButton");
+        getWidget(mBuyButton, "BuyButton");
+        getWidget(mPrice, "PriceLabel");
 
         setWidgets(mAvailableEffectsList, mUsedEffectsView);
 
         mCancelButton->eventMouseButtonClick += MyGUI::newDelegate(this, &EnchantingDialog::onCancelButtonClicked);
+        mItemBox->eventMouseButtonClick += MyGUI::newDelegate(this, &EnchantingDialog::onSelectItem);
+        mSoulBox->eventMouseButtonClick += MyGUI::newDelegate(this, &EnchantingDialog::onSelectSoul);
+        mBuyButton->eventMouseButtonClick += MyGUI::newDelegate(this, &EnchantingDialog::onBuyButtonClicked);
+        mTypeButton->eventMouseButtonClick += MyGUI::newDelegate(this, &EnchantingDialog::onTypeButtonClicked);
+    }
+
+    EnchantingDialog::~EnchantingDialog()
+    {
+        delete mItemSelectionDialog;
     }
 
     void EnchantingDialog::open()
     {
         center();
+        onRemoveItem(NULL);
+        onRemoveSoul(NULL);
+    }
+
+    void EnchantingDialog::updateLabels()
+    {
+        mEnchantmentPoints->setCaption(boost::lexical_cast<std::string>(mEnchanting.getEnchantCost())
+                                       + " / " + boost::lexical_cast<std::string>(mEnchanting.getMaxEnchantValue()));
+
+        mCharge->setCaption(boost::lexical_cast<std::string>(mEnchanting.getGemCharge()));
+
+        mCastCost->setCaption(boost::lexical_cast<std::string>(mEnchanting.getEnchantCost()));
+
+        switch(mEnchanting.getEnchantType())
+        {
+            case 0:
+                mTypeButton->setCaption(mWindowManager.getGameSettingString("sItemCastOnce","Cast Once"));
+                mAddEffectDialog.constantEffect=false;
+                break;
+            case 1:
+                mTypeButton->setCaption(mWindowManager.getGameSettingString("sItemCastWhenStrikes", "When Strikes"));
+                mAddEffectDialog.constantEffect=false;
+                break;
+            case 2:
+                mTypeButton->setCaption(mWindowManager.getGameSettingString("sItemCastWhenUsed", "When Used"));
+                mAddEffectDialog.constantEffect=false;
+                break;
+            case 3:
+                mTypeButton->setCaption(mWindowManager.getGameSettingString("sItemCastConstant", "Cast Constant"));
+                mAddEffectDialog.constantEffect=true;
+                break;
+        }
     }
 
     void EnchantingDialog::startEnchanting (MWWorld::Ptr actor)
@@ -30,6 +92,11 @@ namespace MWGui
         startEditing ();
     }
 
+    void EnchantingDialog::startSelfEnchanting(MWWorld::Ptr soulgem)
+    {
+        /// \todo
+    }
+
     void EnchantingDialog::onReferenceUnavailable ()
     {
         mWindowManager.removeGuiMode (GM_Dialogue);
@@ -40,4 +107,165 @@ namespace MWGui
     {
         mWindowManager.removeGuiMode (GM_Enchanting);
     }
+
+    void EnchantingDialog::onSelectItem(MyGUI::Widget *sender)
+    {
+        delete mItemSelectionDialog;
+        mItemSelectionDialog = new ItemSelectionDialog("#{sEnchantItems}",
+            ContainerBase::Filter_Apparel|ContainerBase::Filter_Weapon|ContainerBase::Filter_NoMagic, mWindowManager);
+        mItemSelectionDialog->eventItemSelected += MyGUI::newDelegate(this, &EnchantingDialog::onItemSelected);
+        mItemSelectionDialog->eventDialogCanceled += MyGUI::newDelegate(this, &EnchantingDialog::onItemCancel);
+        mItemSelectionDialog->setVisible(true);
+        mItemSelectionDialog->openContainer(MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
+        mItemSelectionDialog->drawItems ();
+    }
+
+    void EnchantingDialog::onItemSelected(MWWorld::Ptr item)
+    {
+        mItemSelectionDialog->setVisible(false);
+
+        while (mItemBox->getChildCount ())
+            MyGUI::Gui::getInstance ().destroyWidget (mItemBox->getChildAt(0));
+
+        MyGUI::ImageBox* image = mItemBox->createWidget<MyGUI::ImageBox>("ImageBox", MyGUI::IntCoord(0, 0, 32, 32), MyGUI::Align::Default);
+        std::string path = std::string("icons\\");
+        path += MWWorld::Class::get(item).getInventoryIcon(item);
+        int pos = path.rfind(".");
+        path.erase(pos);
+        path.append(".dds");
+        image->setImageTexture (path);
+        image->setUserString ("ToolTipType", "ItemPtr");
+        image->setUserData(item);
+        image->eventMouseButtonClick += MyGUI::newDelegate(this, &EnchantingDialog::onRemoveItem);
+
+        mEnchanting.setOldItem(item);
+        mEnchanting.nextEnchantType();
+        updateLabels();
+    }
+
+    void EnchantingDialog::onRemoveItem(MyGUI::Widget *sender)
+    {
+        while (mItemBox->getChildCount ())
+            MyGUI::Gui::getInstance ().destroyWidget (mItemBox->getChildAt(0));
+        mEnchanting.setOldItem(MWWorld::Ptr());
+        updateLabels();
+    }
+
+    void EnchantingDialog::onItemCancel()
+    {
+        mItemSelectionDialog->setVisible(false);
+    }
+
+    void EnchantingDialog::onSoulSelected(MWWorld::Ptr item)
+    {
+        mItemSelectionDialog->setVisible(false);
+        mEnchanting.setSoulGem(item);
+
+        if(mEnchanting.getGemCharge()==0)
+        {
+            mWindowManager.messageBox ("#{sNotifyMessage32}");
+            return;
+        }
+
+        while (mSoulBox->getChildCount ())
+            MyGUI::Gui::getInstance ().destroyWidget (mSoulBox->getChildAt(0));
+
+        MyGUI::ImageBox* image = mSoulBox->createWidget<MyGUI::ImageBox>("ImageBox", MyGUI::IntCoord(0, 0, 32, 32), MyGUI::Align::Default);
+        std::string path = std::string("icons\\");
+        path += MWWorld::Class::get(item).getInventoryIcon(item);
+        int pos = path.rfind(".");
+        path.erase(pos);
+        path.append(".dds");
+        image->setImageTexture (path);
+        image->setUserString ("ToolTipType", "ItemPtr");
+        image->setUserData(item);
+        image->eventMouseButtonClick += MyGUI::newDelegate(this, &EnchantingDialog::onRemoveSoul);
+        updateLabels();
+    }
+
+    void EnchantingDialog::onRemoveSoul(MyGUI::Widget *sender)
+    {
+        while (mSoulBox->getChildCount ())
+            MyGUI::Gui::getInstance ().destroyWidget (mSoulBox->getChildAt(0));
+        mEnchanting.setSoulGem(MWWorld::Ptr());
+        updateLabels();
+    }
+
+    void EnchantingDialog::onSoulCancel()
+    {
+        mItemSelectionDialog->setVisible(false);
+    }
+
+    void EnchantingDialog::onSelectSoul(MyGUI::Widget *sender)
+    {
+        delete mItemSelectionDialog;
+        mItemSelectionDialog = new ItemSelectionDialog("#{sSoulGemsWithSouls}",
+            ContainerBase::Filter_Misc|ContainerBase::Filter_ChargedSoulstones, mWindowManager);
+        mItemSelectionDialog->eventItemSelected += MyGUI::newDelegate(this, &EnchantingDialog::onSoulSelected);
+        mItemSelectionDialog->eventDialogCanceled += MyGUI::newDelegate(this, &EnchantingDialog::onSoulCancel);
+        mItemSelectionDialog->setVisible(true);
+        mItemSelectionDialog->openContainer(MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
+        mItemSelectionDialog->drawItems ();
+
+        //mWindowManager.messageBox("#{sInventorySelectNoSoul}");
+    }
+
+    void EnchantingDialog::notifyEffectsChanged ()
+    {
+        mEffectList.mList = mEffects;
+        mEnchanting.setEffect(mEffectList);
+        updateLabels();
+    }
+
+    void EnchantingDialog::onTypeButtonClicked(MyGUI::Widget* sender)
+    {
+        mEnchanting.nextEnchantType();
+        updateLabels();
+    }
+
+    void EnchantingDialog::onBuyButtonClicked(MyGUI::Widget* sender)
+    {
+        if (mEffects.size() <= 0)
+        {
+            mWindowManager.messageBox ("#{sNotifyMessage30}");
+            return;
+        }
+
+        if (mName->getCaption ().empty())
+        {
+            mWindowManager.messageBox ("#{sNotifyMessage10}");
+            return;
+        }
+
+        if (boost::lexical_cast<int>(mPrice->getCaption()) > mWindowManager.getInventoryWindow()->getPlayerGold())
+        {
+            mWindowManager.messageBox ("#{sNotifyMessage18}");
+            return;
+        }
+
+        if (mEnchanting.soulEmpty())
+        {
+            mWindowManager.messageBox ("#{sNotifyMessage52}");
+            return;
+        }
+
+        if (mEnchanting.itemEmpty())
+        {
+            mWindowManager.messageBox ("#{sNotifyMessage11}");
+            return;
+        }
+
+        if (mEnchanting.getEnchantCost() > mEnchanting.getMaxEnchantValue())
+        {
+            mWindowManager.messageBox ("#{sNotifyMessage29}");
+            return;
+        }
+
+        mEnchanting.setNewItemName(mName->getCaption());
+        mEnchanting.setEffect(mEffectList);
+
+        mEnchanting.create();
+        mWindowManager.messageBox ("#{sEnchantmentMenu12}");
+        mWindowManager.removeGuiMode (GM_Enchanting);
+    }
 }

apps/openmw/mwgui/enchantingdialog.hpp

@@ -7,23 +7,58 @@
 
 #include "../mwbase/windowmanager.hpp"
 
+#include "../mwmechanics/enchanting.hpp"
+
 namespace MWGui
 {
 
+    class ItemSelectionDialog;
+
     class EnchantingDialog : public WindowBase, public ReferenceInterface, public EffectEditorBase
     {
     public:
         EnchantingDialog(MWBase::WindowManager& parWindowManager);
+        virtual ~EnchantingDialog();
 
         virtual void open();
         void startEnchanting(MWWorld::Ptr actor);
+        void startSelfEnchanting(MWWorld::Ptr soulgem);
 
     protected:
         virtual void onReferenceUnavailable();
+        virtual void notifyEffectsChanged ();
 
         void onCancelButtonClicked(MyGUI::Widget* sender);
+        void onSelectItem (MyGUI::Widget* sender);
+        void onSelectSoul (MyGUI::Widget* sender);
+        void onRemoveItem (MyGUI::Widget* sender);
+        void onRemoveSoul (MyGUI::Widget* sender);
+
+        void onItemSelected(MWWorld::Ptr item);
+        void onItemCancel();
+        void onSoulSelected(MWWorld::Ptr item);
+        void onSoulCancel();
+        void onBuyButtonClicked(MyGUI::Widget* sender);
+        void updateLabels();
+        void onTypeButtonClicked(MyGUI::Widget* sender);
+
+        ItemSelectionDialog* mItemSelectionDialog;
 
         MyGUI::Button* mCancelButton;
+        MyGUI::ImageBox* mItemBox;
+        MyGUI::ImageBox* mSoulBox;
+
+        MyGUI::Button* mTypeButton;
+        MyGUI::Button* mBuyButton;
+
+        MyGUI::TextBox* mName;
+        MyGUI::TextBox* mEnchantmentPoints;
+        MyGUI::TextBox* mCastCost;
+        MyGUI::TextBox* mCharge;
+        MyGUI::TextBox* mPrice;
+
+        MWMechanics::Enchanting mEnchanting;
+        ESM::EffectList mEffectList;
     };
 
 }

apps/openmw/mwgui/hud.cpp

@@ -234,7 +234,8 @@ void HUD::onWorldClicked(MyGUI::Widget* _sender)
         mDragAndDrop->mDraggedWidget = 0;
 
         MWBase::Environment::get().getWindowManager()->setDragDrop(false);
-        MWBase::Environment::get().getWindowManager()->getInventoryWindow()->drawItems();
+        mDragAndDrop->mDraggedFrom->drawItems();
+        mDragAndDrop->mDraggedFrom->notifyItemDragged(object, -mDragAndDrop->mDraggedCount);
     }
     else
     {

apps/openmw/mwgui/inventorywindow.cpp

@@ -43,7 +43,6 @@ namespace MWGui
         getWidget(mAvatar, "Avatar");
         getWidget(mAvatarImage, "AvatarImage");
         getWidget(mEncumbranceBar, "EncumbranceBar");
-        getWidget(mEncumbranceText, "EncumbranceBarT");
         getWidget(mFilterAll, "AllButton");
         getWidget(mFilterWeapon, "WeaponButton");
         getWidget(mFilterApparel, "ApparelButton");
@@ -240,9 +239,7 @@ namespace MWGui
 
         float capacity = MWWorld::Class::get(player).getCapacity(player);
         float encumbrance = MWWorld::Class::get(player).getEncumbrance(player);
-        mEncumbranceBar->setProgressRange(capacity);
+        mEncumbranceBar->setValue(encumbrance, capacity);
-        mEncumbranceBar->setProgressPosition(encumbrance);
-        mEncumbranceText->setCaption( boost::lexical_cast<std::string>(int(encumbrance)) + "/" + boost::lexical_cast<std::string>(int(capacity)) );
     }
 
     void InventoryWindow::onFrame()

apps/openmw/mwgui/inventorywindow.hpp

@@ -5,6 +5,7 @@
 
 #include "container.hpp"
 #include "window_pinnable_base.hpp"
+#include "widgets.hpp"
 
 namespace MWGui
 {
@@ -36,8 +37,7 @@ namespace MWGui
             MyGUI::Widget* mAvatar;
             MyGUI::ImageBox* mAvatarImage;
             MyGUI::TextBox* mArmorRating;
-            MyGUI::ProgressBar* mEncumbranceBar;
+            Widgets::MWDynamicStat* mEncumbranceBar;
-            MyGUI::TextBox* mEncumbranceText;
 
             MyGUI::Widget* mLeftPane;
             MyGUI::Widget* mRightPane;

apps/openmw/mwgui/itemselection.cpp

@@ -3,7 +3,7 @@
 namespace MWGui
 {
 
-    ItemSelectionDialog::ItemSelectionDialog(const std::string &label, ContainerBase::Filter filter, MWBase::WindowManager& parWindowManager)
+    ItemSelectionDialog::ItemSelectionDialog(const std::string &label, int filter, MWBase::WindowManager& parWindowManager)
         : ContainerBase(NULL)
         , WindowModal("openmw_itemselection_dialog.layout", parWindowManager)
     {

apps/openmw/mwgui/itemselection.hpp

@@ -8,7 +8,7 @@ namespace MWGui
     class ItemSelectionDialog : public ContainerBase, public WindowModal
     {
     public:
-        ItemSelectionDialog(const std::string& label, ContainerBase::Filter filter, MWBase::WindowManager& parWindowManager);
+        ItemSelectionDialog(const std::string& label, int filter, MWBase::WindowManager& parWindowManager);
 
         typedef MyGUI::delegates::CMultiDelegate0 EventHandle_Void;
         typedef MyGUI::delegates::CMultiDelegate1<MWWorld::Ptr> EventHandle_Item;

apps/openmw/mwgui/levelupdialog.cpp

@@ -162,7 +162,7 @@ namespace MWGui
         MWMechanics::NpcStats& pcStats = MWWorld::Class::get(player).getNpcStats (player);
 
         if (mSpentAttributes.size() < 3)
-            MWBase::Environment::get().getWindowManager ()->messageBox("#{sNotifyMessage36}", std::vector<std::string>());
+            MWBase::Environment::get().getWindowManager ()->messageBox("#{sNotifyMessage36}");
         else
         {
             // increase attributes

apps/openmw/mwgui/messagebox.cpp

@@ -3,6 +3,7 @@
 #include "messagebox.hpp"
 #include "../mwbase/environment.hpp"
 #include "../mwbase/soundmanager.hpp"
+#include "../mwbase/inputmanager.hpp"
 
 using namespace MWGui;
 
@@ -62,7 +63,8 @@ void MessageBoxManager::onFrame (float frameDuration)
     if(mInterMessageBoxe != NULL && mInterMessageBoxe->mMarkedToDelete) {
         delete mInterMessageBoxe;
         mInterMessageBoxe = NULL;
-        mWindowManager->removeGuiMode(GM_InterMessageBox);
+        MWBase::Environment::get().getInputManager()->changeInputMode(
+                    MWBase::Environment::get().getWindowManager()->isGuiMode());
     }
 }
 
@@ -90,11 +92,8 @@ void MessageBoxManager::createMessageBox (const std::string& message)
 
 bool MessageBoxManager::createInteractiveMessageBox (const std::string& message, const std::vector<std::string>& buttons)
 {
-    /// \todo Don't write this kind of error message to cout. Either discard the old message box
-    /// silently or throw an exception.
     if(mInterMessageBoxe != NULL) {
-        std::cout << "there is a MessageBox already" << std::endl;
+        throw std::runtime_error("There is a message box already");
-        return false;
     }
 
     mInterMessageBoxe = new InteractiveMessageBox(*this, message, buttons);
@@ -139,7 +138,8 @@ void MessageBoxManager::setMessageBoxSpeed (int speed)
 
 void MessageBoxManager::enterPressed ()
 {
-    mInterMessageBoxe->enterPressed();
+    if(mInterMessageBoxe != NULL)
+        mInterMessageBoxe->enterPressed();
 }
 
 int MessageBoxManager::readPressedButton ()
@@ -213,10 +213,12 @@ int MessageBox::getHeight ()
 
 
 InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message, const std::vector<std::string>& buttons)
-  : Layout("openmw_interactive_messagebox.layout")
+    : WindowModal("openmw_interactive_messagebox.layout", *MWBase::Environment::get().getWindowManager())
   , mMessageBoxManager(parMessageBoxManager)
   , mButtonPressed(-1)
 {
+    WindowModal::open();
+
     int fixedWidth = 500;
     int textPadding = 10; // padding between text-widget and main-widget
     int textButtonPadding = 20; // padding between the text-widget und the button-widget
@@ -232,7 +234,7 @@ InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxMan
     getWidget(mButtonsWidget, "buttons");
 
     mMessageWidget->setOverflowToTheLeft(true);
-    mMessageWidget->addText(message);
+    mMessageWidget->setCaptionWithReplacing(message);
 
     MyGUI::IntSize textSize = mMessageWidget->getTextSize();
 
@@ -252,7 +254,7 @@ InteractiveMessageBox::InteractiveMessageBox(MessageBoxManager& parMessageBoxMan
             std::string("MW_Button"),
             dummyCoord,
             MyGUI::Align::Default);
-        button->setCaption(*it);
+        button->setCaptionWithReplacing(*it);
 
         button->eventMouseButtonClick += MyGUI::newDelegate(this, &InteractiveMessageBox::mousePressed);
 
@@ -399,6 +401,7 @@ void InteractiveMessageBox::buttonActivated (MyGUI::Widget* pressed)
         if(*button == pressed)
         {
             mButtonPressed = index;
+            mMessageBoxManager.onButtonPressed(mButtonPressed);
             return;
         }
         index++;

apps/openmw/mwgui/messagebox.hpp

@@ -44,6 +44,13 @@ namespace MWGui
             void enterPressed();
             int readPressedButton ();
 
+            typedef MyGUI::delegates::CMultiDelegate1<int> EventHandle_Int;
+
+            // Note: this delegate unassigns itself after it was fired, i.e. works once.
+            EventHandle_Int eventButtonPressed;
+
+            void onButtonPressed(int button) { eventButtonPressed(button); eventButtonPressed.clear(); }
+
             MWBase::WindowManager *mWindowManager;
 
         private:
@@ -73,7 +80,7 @@ namespace MWGui
             int mNextBoxPadding;
     };
 
-    class InteractiveMessageBox : public OEngine::GUI::Layout
+    class InteractiveMessageBox : public WindowModal
     {
         public:
             InteractiveMessageBox (MessageBoxManager& parMessageBoxManager, const std::string& message, const std::vector<std::string>& buttons);

apps/openmw/mwgui/mode.hpp

@@ -5,9 +5,11 @@ namespace MWGui
 {
   enum GuiMode
     {
+      GM_None,
       GM_Settings,      // Settings window
       GM_Inventory,     // Inventory mode
       GM_Container,
+      GM_Companion,
       GM_MainMenu,      // Main menu mode
 
       GM_Console,       // Console mode
@@ -41,9 +43,6 @@ namespace MWGui
       GM_ClassCreate,
       GM_Review,
       
-      // interactive MessageBox
-      GM_InterMessageBox,
-
       GM_Loading,
       GM_LoadingWallpaper,
 

apps/openmw/mwgui/quickkeysmenu.cpp

@@ -291,7 +291,7 @@ namespace MWGui
             if (item.getRefData ().getCount() == 0)
             {
                 MWBase::Environment::get().getWindowManager ()->messageBox (
-                            "#{sQuickMenu5} " + MWWorld::Class::get(item).getName(item), std::vector<std::string>());
+                            "#{sQuickMenu5} " + MWWorld::Class::get(item).getName(item));
                 return;
             }
 
@@ -317,7 +317,7 @@ namespace MWGui
             if (item.getRefData ().getCount() == 0)
             {
                 MWBase::Environment::get().getWindowManager ()->messageBox (
-                            "#{sQuickMenu5} " + MWWorld::Class::get(item).getName(item), std::vector<std::string>());
+                            "#{sQuickMenu5} " + MWWorld::Class::get(item).getName(item));
                 return;
             }
 

apps/openmw/mwgui/race.cpp

@@ -19,6 +19,49 @@
 using namespace MWGui;
 using namespace Widgets;
 
+namespace
+{
+int wrap(int index, int max)
+{
+    if (index < 0)
+        return max - 1;
+    else if (index >= max)
+        return 0;
+    else
+        return index;
+}
+
+int countParts(const std::string &part, const std::string &race, bool male)
+{
+    /// \todo loop through the whole store for appropriate bodyparts instead of looking for fixed IDs
+    const MWWorld::Store<ESM::BodyPart> &store =
+        MWBase::Environment::get().getWorld()->getStore().get<ESM::BodyPart>();
+
+    std::string prefix =
+        "b_n_" + race + ((male) ? "_m_" : "_f_") + part;
+
+    std::string suffix;
+    suffix.reserve(prefix.size() + 3);
+
+    int count = -1;
+    do {
+        ++count;
+        suffix = "_" + (boost::format("%02d") % (count + 1)).str();
+    }
+    while (store.search(prefix + suffix) != 0);
+
+    if (count == 0 && part == "hair") {
+        count = -1;
+        do {
+            ++count;
+            suffix = (boost::format("%02d") % (count + 1)).str();
+        }
+        while (store.search(prefix + suffix) != 0);
+    }
+    return count;
+}
+}
+
 RaceDialog::RaceDialog(MWBase::WindowManager& parWindowManager)
   : WindowModal("openmw_chargen_race.layout", parWindowManager)
   , mGenderIndex(0)
@@ -144,45 +187,6 @@ void RaceDialog::setRaceId(const std::string &raceId)
     updateSpellPowers();
 }
 
-int wrap(int index, int max)
-{
-    if (index < 0)
-        return max - 1;
-    else if (index >= max)
-        return 0;
-    else
-        return index;
-}
-
-int countParts(const std::string &part, const std::string &race, bool male)
-{
-    const MWWorld::Store<ESM::BodyPart> &store =
-        MWBase::Environment::get().getWorld()->getStore().get<ESM::BodyPart>();
-
-    std::string prefix =
-        "b_n_" + race + ((male) ? "_m_" : "_f_") + part;
-
-    std::string suffix;
-    suffix.reserve(prefix.size() + 3);
-    
-    int count = -1;
-    do {
-        ++count;
-        suffix = "_" + (boost::format("%02d") % (count + 1)).str();
-    }
-    while (store.search(prefix + suffix) != 0);
-
-    if (count == 0 && part == "hair") {
-        count = -1;
-        do {
-            ++count;
-            suffix = (boost::format("%02d") % (count + 1)).str();
-        }
-        while (store.search(prefix + suffix) != 0);
-    }
-    return count;
-}
-
 void RaceDialog::close()
 {
     delete mPreview;
@@ -229,28 +233,67 @@ void RaceDialog::onSelectNextGender(MyGUI::Widget*)
 
 void RaceDialog::onSelectPreviousFace(MyGUI::Widget*)
 {
-    mFaceIndex = wrap(mFaceIndex - 1, mFaceCount);
+    do
+        mFaceIndex = wrap(mFaceIndex - 1, mFaceCount);
+    while (!isFacePlayable());
     updatePreview();
 }
 
 void RaceDialog::onSelectNextFace(MyGUI::Widget*)
 {
-    mFaceIndex = wrap(mFaceIndex + 1, mFaceCount);
+    do
+        mFaceIndex = wrap(mFaceIndex + 1, mFaceCount);
+    while (!isFacePlayable());
     updatePreview();
 }
 
 void RaceDialog::onSelectPreviousHair(MyGUI::Widget*)
 {
-    mHairIndex = wrap(mHairIndex - 1, mHairCount);
+    do
+        mHairIndex = wrap(mHairIndex - 1, mHairCount);
+    while (!isHairPlayable());
     updatePreview();
 }
 
 void RaceDialog::onSelectNextHair(MyGUI::Widget*)
 {
-    mHairIndex = wrap(mHairIndex + 1, mHairCount);
+    do
+        mHairIndex = wrap(mHairIndex + 1, mHairCount);
+    while (!isHairPlayable());
     updatePreview();
 }
 
+bool RaceDialog::isFacePlayable()
+{
+    std::string prefix =
+            "b_n_" + mCurrentRaceId + ((mGenderIndex == 0) ? "_m_" : "_f_");
+
+    std::string headIndex = (boost::format("%02d") % (mFaceIndex + 1)).str();
+
+    const MWWorld::Store<ESM::BodyPart> &parts =
+        MWBase::Environment::get().getWorld()->getStore().get<ESM::BodyPart>();
+
+    if (parts.search(prefix + "head_" + headIndex) == 0)
+        return !(parts.find(prefix + "head" + headIndex)->mData.mFlags & ESM::BodyPart::BPF_NotPlayable);
+    else
+        return !(parts.find(prefix + "head_" + headIndex)->mData.mFlags & ESM::BodyPart::BPF_NotPlayable);
+}
+
+bool RaceDialog::isHairPlayable()
+{
+    std::string prefix =
+        "b_n_" + mCurrentRaceId + ((mGenderIndex == 0) ? "_m_" : "_f_");
+
+    std::string hairIndex = (boost::format("%02d") % (mHairIndex + 1)).str();
+
+    const MWWorld::Store<ESM::BodyPart> &parts =
+        MWBase::Environment::get().getWorld()->getStore().get<ESM::BodyPart>();
+    if (parts.search(prefix + "hair_" + hairIndex) == 0)
+        return !(parts.find(prefix + "hair" + hairIndex)->mData.mFlags & ESM::BodyPart::BPF_NotPlayable);
+    else
+        return !(parts.find(prefix + "hair_" + hairIndex)->mData.mFlags & ESM::BodyPart::BPF_NotPlayable);
+}
+
 void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
 {
     if (_index == MyGUI::ITEM_NONE)
@@ -273,11 +316,16 @@ void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
 
 void RaceDialog::recountParts()
 {
+    mFaceCount = countParts("head", mCurrentRaceId, mGenderIndex == 0);
+    mHairCount = countParts("hair", mCurrentRaceId, mGenderIndex == 0);
+
     mFaceIndex = 0;
     mHairIndex = 0;
 
-    mFaceCount = countParts("head", mCurrentRaceId, mGenderIndex == 0);
+    while (!isHairPlayable())
-    mHairCount = countParts("hair", mCurrentRaceId, mGenderIndex == 0);
+        mHairIndex = wrap(mHairIndex + 1, mHairCount);
+    while (!isFacePlayable())
+        mFaceIndex = wrap(mFaceIndex + 1, mFaceCount);
 }
 
 // update widget content

apps/openmw/mwgui/race.hpp

@@ -81,6 +81,9 @@ namespace MWGui
         void updatePreview();
         void recountParts();
 
+        bool isHairPlayable();
+        bool isFacePlayable();
+
         MyGUI::ImageBox*  mPreviewImage;
         MyGUI::ListBox*   mRaceList;
         MyGUI::ScrollBar* mHeadRotate;

apps/openmw/mwgui/referenceinterface.cpp

@@ -26,7 +26,10 @@ namespace MWGui
         // check if player has changed cell, or count of the reference has become 0
         if ((playerCell != mCurrentPlayerCell && mCurrentPlayerCell != NULL)
             || mPtr.getRefData().getCount() == 0)
+        {
+            mPtr = MWWorld::Ptr();
             onReferenceUnavailable();
+        }
 
         mCurrentPlayerCell = playerCell;
     }

apps/openmw/mwgui/settingswindow.cpp

@@ -362,7 +362,7 @@ namespace MWGui
             {
                 std::string msg = "This resolution is not supported in Fullscreen mode. Please select a resolution from the list.";
                 MWBase::Environment::get().getWindowManager()->
-                    messageBox(msg, std::vector<std::string>());
+                    messageBox(msg);
                 _sender->castType<MyGUI::Button>()->setCaption(off);
             }
             else
@@ -593,7 +593,7 @@ namespace MWGui
 
         static_cast<MyGUI::Button*>(_sender)->setCaptionWithReplacing("#{sNone}");
 
-        MWBase::Environment::get().getWindowManager ()->messageBox ("#{sControlsMenu3}", std::vector<std::string>());
+        MWBase::Environment::get().getWindowManager ()->messageBox ("#{sControlsMenu3}");
         MWBase::Environment::get().getWindowManager ()->disallowMouse();
 
         MWBase::Environment::get().getInputManager ()->enableDetectingBindingMode (actionId);

apps/openmw/mwgui/soulgemdialog.cpp

@@ -0,0 +1,34 @@
+#include "soulgemdialog.hpp"
+
+#include "../mwbase/windowmanager.hpp"
+#include "../mwbase/environment.hpp"
+
+#include "messagebox.hpp"
+
+namespace MWGui
+{
+
+    void SoulgemDialog::show(const MWWorld::Ptr &soulgem)
+    {
+        mSoulgem = soulgem;
+        std::vector<std::string> buttons;
+        buttons.push_back("#{sRechargeEnchantment}");
+        buttons.push_back("#{sMake Enchantment}");
+        mManager->createInteractiveMessageBox("#{sDoYouWantTo}", buttons);
+        mManager->eventButtonPressed += MyGUI::newDelegate(this, &SoulgemDialog::onButtonPressed);
+    }
+
+    void SoulgemDialog::onButtonPressed(int button)
+    {
+        if (button == 0)
+        {
+            /// \todo show recharge enchanted item dialog here
+        }
+        else
+        {
+            MWBase::Environment::get().getWindowManager()->pushGuiMode(GM_Enchanting);
+            MWBase::Environment::get().getWindowManager()->startSelfEnchanting(mSoulgem);
+        }
+    }
+
+}

apps/openmw/mwgui/soulgemdialog.hpp

@@ -0,0 +1,28 @@
+#ifndef OPENMW_MWGUI_SOULGEMDIALOG_H
+#define OPENMW_MWGUI_SOULGEMDIALOG_H
+
+#include "../mwworld/ptr.hpp"
+
+namespace MWGui
+{
+
+    class MessageBoxManager;
+
+    class SoulgemDialog
+    {
+    public:
+        SoulgemDialog (MessageBoxManager* manager)
+            : mManager(manager) {}
+
+        void show (const MWWorld::Ptr& soulgem);
+
+        void onButtonPressed(int button);
+
+    private:
+        MessageBoxManager* mManager;
+        MWWorld::Ptr mSoulgem;
+    };
+
+}
+
+#endif

apps/openmw/mwgui/spellcreationdialog.cpp

@@ -72,6 +72,7 @@ namespace MWGui
         mMagnitudeMaxSlider->eventScrollChangePosition += MyGUI::newDelegate(this, &EditEffectDialog::onMagnitudeMaxChanged);
         mDurationSlider->eventScrollChangePosition += MyGUI::newDelegate(this, &EditEffectDialog::onDurationChanged);
         mAreaSlider->eventScrollChangePosition += MyGUI::newDelegate(this, &EditEffectDialog::onAreaChanged);
+        constantEffect=false;
     }
 
     void EditEffectDialog::open()
@@ -164,7 +165,7 @@ namespace MWGui
             mMagnitudeBox->setVisible (true);
             curY += mMagnitudeBox->getSize().height;
         }
-        if (!(mMagicEffect->mData.mFlags & ESM::MagicEffect::NoDuration))
+        if (!(mMagicEffect->mData.mFlags & ESM::MagicEffect::NoDuration)&&constantEffect==false)
         {
             mDurationBox->setPosition(mDurationBox->getPosition().left, curY);
             mDurationBox->setVisible (true);
@@ -309,25 +310,25 @@ namespace MWGui
     {
         if (mEffects.size() <= 0)
         {
-            mWindowManager.messageBox ("#{sNotifyMessage30}", std::vector<std::string>());
+            mWindowManager.messageBox ("#{sNotifyMessage30}");
             return;
         }
 
         if (mNameEdit->getCaption () == "")
         {
-            mWindowManager.messageBox ("#{sNotifyMessage10}", std::vector<std::string>());
+            mWindowManager.messageBox ("#{sNotifyMessage10}");
             return;
         }
 
         if (mMagickaCost->getCaption() == "0")
         {
-            mWindowManager.messageBox ("#{sEnchantmentMenu8}", std::vector<std::string>());
+            mWindowManager.messageBox ("#{sEnchantmentMenu8}");
             return;
         }
 
         if (boost::lexical_cast<int>(mPriceLabel->getCaption()) > mWindowManager.getInventoryWindow()->getPlayerGold())
         {
-            mWindowManager.messageBox ("#{sNotifyMessage18}", std::vector<std::string>());
+            mWindowManager.messageBox ("#{sNotifyMessage18}");
             return;
         }
 
@@ -516,7 +517,7 @@ namespace MWGui
     {
         if (mEffects.size() >= 8)
         {
-            MWBase::Environment::get().getWindowManager()->messageBox("#{sNotifyMessage28}", std::vector<std::string>());
+            MWBase::Environment::get().getWindowManager()->messageBox("#{sNotifyMessage28}");
             return;
         }
 
@@ -527,7 +528,7 @@ namespace MWGui
         {
             if (it->mEffectID == effectId)
             {
-                MWBase::Environment::get().getWindowManager()->messageBox ("#{sOnetypeEffectMessage}", std::vector<std::string>());
+                MWBase::Environment::get().getWindowManager()->messageBox ("#{sOnetypeEffectMessage}");
                 return;
             }
         }

apps/openmw/mwgui/spellcreationdialog.hpp

@@ -24,7 +24,7 @@ namespace MWGui
 
         void newEffect (const ESM::MagicEffect* effect);
         void editEffect (ESM::ENAMstruct effect);
-
+        bool constantEffect;
         typedef MyGUI::delegates::CMultiDelegate1<ESM::ENAMstruct> EventHandle_Effect;
 
         EventHandle_Effect eventEffectAdded;
@@ -69,7 +69,6 @@ namespace MWGui
         void onMagnitudeMaxChanged (MyGUI::ScrollBar* sender, size_t pos);
         void onDurationChanged (MyGUI::ScrollBar* sender, size_t pos);
         void onAreaChanged (MyGUI::ScrollBar* sender, size_t pos);
-
         void setMagicEffect(const ESM::MagicEffect* effect);
 
         void updateBoxes();

apps/openmw/mwgui/spellicons.cpp

@@ -139,12 +139,13 @@ namespace MWGui
             }
         }
 
-        parent->setVisible(effects.size() != 0);
-
         int w=2;
+
         if (adjustSize)
         {
             int s = effects.size() * 16+4;
+            if (!effects.size())
+                s = 0;
             int diff = parent->getWidth() - s;
             parent->setSize(s, parent->getHeight());
             parent->setPosition(parent->getLeft()+diff, parent->getTop());

apps/openmw/mwgui/spellwindow.cpp

@@ -404,7 +404,7 @@ namespace MWGui
             if (spell->mData.mFlags & ESM::Spell::F_Always
                 || spell->mData.mType == ESM::Spell::ST_Power)
             {
-                mWindowManager.messageBox("#{sDeleteSpellError}", std::vector<std::string>());
+                mWindowManager.messageBox("#{sDeleteSpellError}");
             }
             else
             {

apps/openmw/mwgui/text_input.cpp

@@ -50,7 +50,7 @@ void TextInputDialog::onOkClicked(MyGUI::Widget* _sender)
 {
     if (mTextEdit->getCaption() == "")
     {
-        mWindowManager.messageBox ("#{sNotifyMessage37}", std::vector<std::string>());
+        mWindowManager.messageBox ("#{sNotifyMessage37}");
         MyGUI::InputManager::getInstance ().setKeyFocusWidget (mTextEdit);
     }
     else
@@ -61,7 +61,7 @@ void TextInputDialog::onTextAccepted(MyGUI::Edit* _sender)
 {
     if (mTextEdit->getCaption() == "")
     {
-        mWindowManager.messageBox ("#{sNotifyMessage37}", std::vector<std::string>());
+        mWindowManager.messageBox ("#{sNotifyMessage37}");
         MyGUI::InputManager::getInstance ().setKeyFocusWidget (mTextEdit);
     }
     else

apps/openmw/mwgui/tradewindow.cpp

@@ -129,13 +129,10 @@ namespace MWGui
         MWWorld::Ptr gold;
         MWWorld::ContainerStore& playerStore = mWindowManager.getInventoryWindow()->getContainerStore();
 
-        const MWWorld::Store<ESM::GameSetting> &gmst =
-            MWBase::Environment::get().getWorld()->getStore().get<ESM::GameSetting>();
-
         for (MWWorld::ContainerStoreIterator it = playerStore.begin();
                 it != playerStore.end(); ++it)
         {
-            if (MWWorld::Class::get(*it).getName(*it) == gmst.find("sGold")->getString())
+            if (Misc::StringUtils::ciEqual(it->getCellRef().mRefID, "gold_001"))
             {
                 goldFound = true;
                 gold = *it;
@@ -181,7 +178,7 @@ namespace MWGui
         {
             // user notification
             MWBase::Environment::get().getWindowManager()->
-                messageBox("#{sBarterDialog11}", std::vector<std::string>());
+                messageBox("#{sBarterDialog11}");
             return;
         }
 
@@ -190,7 +187,7 @@ namespace MWGui
         {
             // user notification
             MWBase::Environment::get().getWindowManager()->
-                messageBox("#{sBarterDialog1}", std::vector<std::string>());
+                messageBox("#{sBarterDialog1}");
             return;
         }
 
@@ -199,7 +196,7 @@ namespace MWGui
         {
             // user notification
             MWBase::Environment::get().getWindowManager()->
-                messageBox("#{sBarterDialog2}", std::vector<std::string>());
+                messageBox("#{sBarterDialog2}");
             return;
         }
 
@@ -209,7 +206,7 @@ namespace MWGui
             if (mPtr.getTypeName() != typeid(ESM::NPC).name())
             {
                 MWBase::Environment::get().getWindowManager()->
-                    messageBox("#{sNotifyMessage9}", std::vector<std::string>());
+                    messageBox("#{sNotifyMessage9}");
                 return;
             }
 
@@ -245,7 +242,7 @@ namespace MWGui
             if(roll > x) //trade refused
             {
                 MWBase::Environment::get().getWindowManager()->
-                    messageBox("#{sNotifyMessage9}", std::vector<std::string>());
+                    messageBox("#{sNotifyMessage9}");
 
                 int iBarterFailDisposition = gmst.find("iBarterFailDisposition")->getInt();
                 MWBase::Environment::get().getDialogueManager()->applyTemporaryDispositionChange(iBarterFailDisposition);
@@ -342,6 +339,9 @@ namespace MWGui
 
     bool TradeWindow::npcAcceptsItem(MWWorld::Ptr item)
     {
+        if (Misc::StringUtils::ciEqual(item.getCellRef().mRefID, "gold_001"))
+            return false;
+
         int services = 0;
         if (mPtr.getTypeName() == typeid(ESM::NPC).name())
         {

apps/openmw/mwgui/trainingwindow.cpp

@@ -129,7 +129,7 @@ namespace MWGui
         MWMechanics::NpcStats& npcStats = MWWorld::Class::get(mPtr).getNpcStats (mPtr);
         if (npcStats.getSkill (skillId).getBase () <= pcStats.getSkill (skillId).getBase ())
         {
-            mWindowManager.messageBox ("#{sServiceTrainingWords}", std::vector<std::string>());
+            mWindowManager.messageBox ("#{sServiceTrainingWords}");
             return;
         }
 

apps/openmw/mwgui/waitdialog.cpp

@@ -83,7 +83,7 @@ namespace MWGui
         if (canRest == 2)
         {
             // resting underwater or mid-air not allowed
-            mWindowManager.messageBox ("#{sNotifyMessage1}", std::vector<std::string>());
+            mWindowManager.messageBox ("#{sNotifyMessage1}");
             mWindowManager.popGuiMode ();
         }
 

apps/openmw/mwgui/windowmanagerimp.cpp

@@ -57,6 +57,8 @@
 #include "spellicons.hpp"
 #include "merchantrepair.hpp"
 #include "repair.hpp"
+#include "soulgemdialog.hpp"
+#include "companionwindow.hpp"
 
 using namespace MWGui;
 
@@ -94,6 +96,8 @@ WindowManager::WindowManager(
   , mTrainingWindow(NULL)
   , mMerchantRepair(NULL)
   , mRepair(NULL)
+  , mSoulgemDialog(NULL)
+  , mCompanionWindow(NULL)
   , mPlayerName()
   , mPlayerRaceId()
   , mPlayerAttributes()
@@ -186,6 +190,8 @@ WindowManager::WindowManager(
     mTrainingWindow = new TrainingWindow(*this);
     mMerchantRepair = new MerchantRepair(*this);
     mRepair = new Repair(*this);
+    mSoulgemDialog = new SoulgemDialog(mMessageBoxManager);
+    mCompanionWindow = new CompanionWindow(*this, mDragAndDrop, mMessageBoxManager);
 
     mLoadingScreen = new LoadingScreen(mRendering->getScene (), mRendering->getWindow (), *this);
     mLoadingScreen->onResChange (w,h);
@@ -253,6 +259,7 @@ WindowManager::~WindowManager()
     delete mQuickKeysMenu;
     delete mMerchantRepair;
     delete mRepair;
+    delete mSoulgemDialog;
     delete mCursor;
 
     cleanupGarbage();
@@ -313,12 +320,10 @@ void WindowManager::updateVisible()
     mTrainingWindow->setVisible(false);
     mMerchantRepair->setVisible(false);
     mRepair->setVisible(false);
+    mCompanionWindow->setVisible(false);
 
     mHud->setVisible(mHudEnabled);
 
-    // Mouse is visible whenever we're not in game mode
-    mCursor->setVisible(isGuiMode());
-
     bool gameMode = !isGuiMode();
 
     mInputBlocker->setVisible (gameMode);
@@ -416,6 +421,10 @@ void WindowManager::updateVisible()
             mContainerWindow->setVisible(true);
             mInventoryWindow->setVisible(true);
             break;
+        case GM_Companion:
+            mCompanionWindow->setVisible(true);
+            mInventoryWindow->setVisible(true);
+            break;
         case GM_Dialogue:
             mDialogueWindow->setVisible(true);
             break;
@@ -444,8 +453,6 @@ void WindowManager::updateVisible()
         case GM_Repair:
             mRepair->setVisible(true);
             break;
-        case GM_InterMessageBox:
-            break;
         case GM_Journal:
             mJournal->setVisible(true);
             break;
@@ -609,7 +616,7 @@ void WindowManager::messageBox (const std::string& message, const std::vector<st
     else
     {
         mMessageBoxManager->createInteractiveMessageBox(message, buttons);
-        pushGuiMode(GM_InterMessageBox);
+        MWBase::Environment::get().getInputManager()->changeInputMode(isGuiMode());
     }
 }
 
@@ -648,6 +655,7 @@ void WindowManager::onDialogueWindowBye()
 void WindowManager::onFrame (float frameDuration)
 {
     mMessageBoxManager->onFrame(frameDuration);
+
     mToolTips->onFrame(frameDuration);
 
     if (mDragAndDrop->mIsOnDragAndDrop)
@@ -676,6 +684,7 @@ void WindowManager::onFrame (float frameDuration)
     mSpellCreationDialog->checkReferenceAvailable();
     mEnchantingDialog->checkReferenceAvailable();
     mContainerWindow->checkReferenceAvailable();
+    mCompanionWindow->checkReferenceAvailable();
     mConsole->checkReferenceAvailable();
 }
 
@@ -1033,12 +1042,12 @@ void WindowManager::toggleVisible (GuiWindow wnd)
 
 bool WindowManager::isGuiMode() const
 {
-    return !mGuiModes.empty();
+    return !mGuiModes.empty() || mMessageBoxManager->isInteractiveMessageBox();
 }
 
 bool WindowManager::isConsoleMode() const
 {
-    if (mGuiModes.back()==GM_Console)
+    if (!mGuiModes.empty() && mGuiModes.back()==GM_Console)
         return true;
     return false;
 }
@@ -1046,8 +1055,7 @@ bool WindowManager::isConsoleMode() const
 MWGui::GuiMode WindowManager::getMode() const
 {
     if (mGuiModes.empty())
-        throw std::runtime_error ("getMode() called, but there is no active mode");
+        return GM_None;
-
     return mGuiModes.back();
 }
 
@@ -1143,6 +1151,11 @@ void WindowManager::startEnchanting (MWWorld::Ptr actor)
     mEnchantingDialog->startEnchanting (actor);
 }
 
+void WindowManager::startSelfEnchanting(MWWorld::Ptr soulgem)
+{
+    mEnchantingDialog->startSelfEnchanting(soulgem);
+}
+
 void WindowManager::startTraining(MWWorld::Ptr actor)
 {
     mTrainingWindow->startTraining(actor);
@@ -1163,7 +1176,17 @@ const Translation::Storage& WindowManager::getTranslationDataStorage() const
     return mTranslationDataStorage;
 }
 
+void WindowManager::showCompanionWindow(MWWorld::Ptr actor)
+{
+    mCompanionWindow->open(actor);
+}
+
 void WindowManager::changePointer(const std::string &name)
 {
     mCursor->onCursorChange(name);
 }
+
+void WindowManager::showSoulgemDialog(MWWorld::Ptr item)
+{
+    mSoulgemDialog->show(item);
+}

apps/openmw/mwgui/windowmanagerimp.hpp

@@ -76,6 +76,8 @@ namespace MWGui
   class SpellIcons;
   class MerchantRepair;
   class Repair;
+  class SoulgemDialog;
+  class CompanionWindow;
 
   class WindowManager : public MWBase::WindowManager
   {
@@ -228,16 +230,22 @@ namespace MWGui
     virtual bool getPlayerSleeping();
     virtual void wakeUpPlayer();
 
+    virtual void showCompanionWindow(MWWorld::Ptr actor);
     virtual void startSpellMaking(MWWorld::Ptr actor);
     virtual void startEnchanting(MWWorld::Ptr actor);
+    virtual void startSelfEnchanting(MWWorld::Ptr soulgem);
     virtual void startTraining(MWWorld::Ptr actor);
     virtual void startRepair(MWWorld::Ptr actor);
     virtual void startRepairItem(MWWorld::Ptr item);
 
+    virtual void showSoulgemDialog (MWWorld::Ptr item);
+
     virtual void changePointer (const std::string& name);
 
     virtual const Translation::Storage& getTranslationDataStorage() const;
 
+    void onSoulgemDialogButtonPressed (int button);
+
   private:
     OEngine::GUI::MyGUIManager *mGuiManager;
     OEngine::Render::OgreRenderer *mRendering;
@@ -271,7 +279,9 @@ namespace MWGui
     EnchantingDialog* mEnchantingDialog;
     TrainingWindow* mTrainingWindow;
     MerchantRepair* mMerchantRepair;
+    SoulgemDialog* mSoulgemDialog;
     Repair* mRepair;
+    CompanionWindow* mCompanionWindow;
 
     Translation::Storage& mTranslationDataStorage;
     Cursor* mCursor;

apps/openmw/mwinput/inputmanagerimp.cpp

@@ -181,8 +181,7 @@ namespace MWInput
                 break;
             case A_Activate:
                 resetIdleTime();
-                if( MWBase::Environment::get().getWindowManager()->isGuiMode()
+                if( MWBase::Environment::get().getWindowManager()->isGuiMode()) {
-                    && MWBase::Environment::get().getWindowManager()->getMode() == MWGui::GM_InterMessageBox ) {
                         // Pressing the activation key when a messagebox is prompting for "ok" will activate the ok button
                         MWBase::Environment::get().getWindowManager()->enterPressed();
                     }
@@ -288,8 +287,6 @@ namespace MWInput
                 triedToMove = true;
                 mPlayer.setLeftRight (1);
             }
-            else
-                mPlayer.setLeftRight (0);
 
             if (actionIsActive(A_MoveForward))
             {
@@ -303,8 +300,6 @@ namespace MWInput
                 mPlayer.setAutoMove (false);
                 mPlayer.setForwardBackward (-1);
             }
-            else
-                mPlayer.setForwardBackward (0);
 
             mPlayer.setSneak(actionIsActive(A_Sneak));
 
@@ -313,8 +308,6 @@ namespace MWInput
                 mPlayer.setUpDown (1);
                 triedToMove = true;
             }
-            else
-                mPlayer.setUpDown (0);
 
             if (mAlwaysRunActive)
                 mPlayer.setRunState(!actionIsActive(A_Run));
@@ -378,27 +371,12 @@ namespace MWInput
 
     void InputManager::changeInputMode(bool guiMode)
     {
-        // Are we in GUI mode now?
+        MWBase::Environment::get().getWindowManager()->setMouseVisible(guiMode);
-        if(guiMode)
+        mGuiCursorEnabled = guiMode;
-        {
+        mMouseLookEnabled = !guiMode;
-            // Disable mouse look
+        if (guiMode)
-            mMouseLookEnabled = false;
+            mWindows.showCrosshair(false);
-
+        // if not in gui mode, the camera decides whether to show crosshair or not.
-            mWindows.showCrosshair (false);
-
-            // Enable GUI events
-            mGuiCursorEnabled = true;
-        }
-        else
-        {
-            // Enable mouse look
-            mMouseLookEnabled = true;
-
-            mWindows.showCrosshair (false);
-
-            // Disable GUI events
-            mGuiCursorEnabled = false;
-        }
     }
 
     void InputManager::processChangedSettings(const Settings::CategorySettingVector& changed)
@@ -462,8 +440,7 @@ namespace MWInput
     bool InputManager::keyPressed( const OIS::KeyEvent &arg )
     {
         if(arg.key == OIS::KC_RETURN
-            && MWBase::Environment::get().getWindowManager()->isGuiMode()
+            && MWBase::Environment::get().getWindowManager()->isGuiMode())
-            && MWBase::Environment::get().getWindowManager()->getMode() == MWGui::GM_InterMessageBox )
         {
             // Pressing enter when a messagebox is prompting for "ok" will activate the ok button
             MWBase::Environment::get().getWindowManager()->enterPressed();
@@ -544,11 +521,13 @@ namespace MWInput
         {
             resetIdleTime();
 
-            float x = arg.state.X.rel * mCameraSensitivity * 0.2;
+            float x = arg.state.X.rel * (1.0f/256.0f) * mCameraSensitivity;
-            float y = arg.state.Y.rel * mCameraSensitivity * 0.2 * (mInvertY ? -1 : 1) * mUIYMultiplier;
+            float y = arg.state.Y.rel * (1.0f/256.0f) * mCameraSensitivity * mCameraYMultiplier * (mInvertY ? -1 : 1);
+            float scale = MWBase::Environment::get().getFrameDuration();
+            if(scale <= 0.0f) scale = 1.0f;
 
-            MWBase::World *world = MWBase::Environment::get().getWorld();
+            mPlayer.setYaw(x/scale);
-            world->rotateObject(world->getPlayer().getPlayer(), -y, 0.f, x, true);
+            mPlayer.setPitch(-y/scale);
 
             if (arg.state.Z.rel)
                 MWBase::Environment::get().getWorld()->changeVanityModeScale(arg.state.Z.rel);
@@ -623,6 +602,9 @@ namespace MWInput
 
     void InputManager::toggleInventory()
     {
+        if (MyGUI::InputManager::getInstance ().isModalAny())
+            return;
+
         bool gameMode = !mWindows.isGuiMode();
 
         // Toggle between game mode and inventory mode
@@ -660,6 +642,9 @@ namespace MWInput
 
     void InputManager::toggleJournal()
     {
+        if (MyGUI::InputManager::getInstance ().isModalAny())
+            return;
+
         // Toggle between game mode and journal mode
         bool gameMode = !mWindows.isGuiMode();
 

apps/openmw/mwmechanics/activators.cpp

@@ -1,76 +0,0 @@
-#include "activators.hpp"
-
-#include <OgreVector3.h>
-
-#include "../mwbase/environment.hpp"
-#include "../mwbase/world.hpp"
-
-namespace MWMechanics
-{
-
-Activators::Activators()
-{
-}
-
-void Activators::addActivator(const MWWorld::Ptr& ptr)
-{
-    MWRender::Animation *anim = MWBase::Environment::get().getWorld()->getAnimation(ptr);
-    if(anim != NULL)
-        mActivators.insert(std::make_pair(ptr, CharacterController(ptr, anim, CharState_Idle, true)));
-}
-
-void Activators::removeActivator (const MWWorld::Ptr& ptr)
-{
-    PtrControllerMap::iterator iter = mActivators.find(ptr);
-    if(iter != mActivators.end())
-        mActivators.erase(iter);
-}
-
-void Activators::updateActivator(const MWWorld::Ptr &old, const MWWorld::Ptr &ptr)
-{
-    PtrControllerMap::iterator iter = mActivators.find(old);
-    if(iter != mActivators.end())
-    {
-        CharacterController ctrl = iter->second;
-        mActivators.erase(iter);
-
-        ctrl.updatePtr(ptr);
-        mActivators.insert(std::make_pair(ptr, ctrl));
-    }
-}
-
-void Activators::dropActivators (const MWWorld::Ptr::CellStore *cellStore)
-{
-    PtrControllerMap::iterator iter = mActivators.begin();
-    while(iter != mActivators.end())
-    {
-        if(iter->first.getCell()==cellStore)
-            mActivators.erase(iter++);
-        else
-            ++iter;
-    }
-}
-
-void Activators::update(float duration, bool paused)
-{
-    if(!paused)
-    {
-        for(PtrControllerMap::iterator iter(mActivators.begin());iter != mActivators.end();++iter)
-            iter->second.update(duration);
-    }
-}
-
-void Activators::playAnimationGroup(const MWWorld::Ptr& ptr, const std::string& groupName, int mode, int number)
-{
-    PtrControllerMap::iterator iter = mActivators.find(ptr);
-    if(iter != mActivators.end())
-        iter->second.playGroup(groupName, mode, number);
-}
-void Activators::skipAnimation(const MWWorld::Ptr& ptr)
-{
-    PtrControllerMap::iterator iter = mActivators.find(ptr);
-    if(iter != mActivators.end())
-        iter->second.skipAnim();
-}
-
-}

apps/openmw/mwmechanics/activators.hpp

@@ -1,45 +0,0 @@
-#ifndef GAME_MWMECHANICS_ACTIVATORS_H
-#define GAME_MWMECHANICS_ACTOVATRS_H
-
-#include <string>
-#include <map>
-
-#include "character.hpp"
-
-namespace MWWorld
-{
-    class Ptr;
-    class CellStore;
-}
-
-namespace MWMechanics
-{
-    class Activators
-    {
-        typedef std::map<MWWorld::Ptr,CharacterController> PtrControllerMap;
-        PtrControllerMap mActivators;
-
-    public:
-        Activators();
-
-        void addActivator (const MWWorld::Ptr& ptr);
-        ///< Register an animated activator
-
-        void removeActivator (const MWWorld::Ptr& ptr);
-        ///< Deregister an activator
-
-        void updateActivator(const MWWorld::Ptr &old, const MWWorld::Ptr& ptr);
-        ///< Updates an activator with a new Ptr
-
-        void dropActivators (const MWWorld::CellStore *cellStore);
-        ///< Deregister all activators in the given cell.
-
-        void update (float duration, bool paused);
-        ///< Update activator animations
-
-        void playAnimationGroup(const MWWorld::Ptr& ptr, const std::string& groupName, int mode, int number);
-        void skipAnimation(const MWWorld::Ptr& ptr);
-    };
-}
-
-#endif

apps/openmw/mwmechanics/actors.cpp

@@ -17,6 +17,7 @@
 #include "../mwbase/windowmanager.hpp"
 
 #include "creaturestats.hpp"
+#include "movement.hpp"
 
 namespace MWMechanics
 {
@@ -256,7 +257,7 @@ namespace MWMechanics
 
                 if(MWWorld::Class::get(iter->first).isEssential(iter->first))
                     MWBase::Environment::get().getWindowManager()->messageBox(
-                        "#{sKilledEssential}", std::vector<std::string>());
+                        "#{sKilledEssential}");
             }
         }
 
@@ -266,7 +267,8 @@ namespace MWMechanics
 
             for(PtrControllerMap::iterator iter(mActors.begin());iter != mActors.end();++iter)
             {
-                Ogre::Vector3 movement = iter->second.update(duration);
+                Movement movement;
+                iter->second.update(duration, movement);
                 mMovement.push_back(std::make_pair(iter->first, movement));
             }
             MWBase::Environment::get().getWorld()->doPhysics(mMovement, duration);

apps/openmw/mwmechanics/actors.hpp

@@ -7,6 +7,7 @@
 #include <map>
 
 #include "character.hpp"
+#include "movement.hpp"
 #include "../mwbase/world.hpp"
 
 namespace Ogre

apps/openmw/mwmechanics/character.cpp

@@ -21,6 +21,8 @@
 
 #include <OgreStringConverter.h>
 
+#include "movement.hpp"
+
 #include "../mwrender/animation.hpp"
 
 #include "../mwbase/environment.hpp"
@@ -73,6 +75,9 @@ static const struct {
     { CharState_SneakLeft, "sneakleft" },
     { CharState_SneakRight, "sneakright" },
 
+    { CharState_TurnLeft, "turnleft" },
+    { CharState_TurnRight, "turnright" },
+
     { CharState_Jump, "jump" },
 
     { CharState_Death1, "death1" },
@@ -106,17 +111,17 @@ CharacterController::CharacterController(const MWWorld::Ptr &ptr, MWRender::Anim
     mAnimation->setController(this);
 
     getStateInfo(mState, &mCurrentGroup);
-    if(ptr.getTypeName() == typeid(ESM::Activator).name())
+    if(MWWorld::Class::get(mPtr).isActor())
-    {
-        /* Don't accumulate with activators (they don't get moved). */
-        mAnimation->setAccumulation(Ogre::Vector3::ZERO);
-    }
-    else
     {
         /* Accumulate along X/Y only for now, until we can figure out how we should
          * handle knockout and death which moves the character down. */
         mAnimation->setAccumulation(Ogre::Vector3(1.0f, 1.0f, 0.0f));
     }
+    else
+    {
+        /* Don't accumulate with non-actors. */
+        mAnimation->setAccumulation(Ogre::Vector3(0.0f));
+    }
     if(mAnimation->hasAnimation(mCurrentGroup))
         mAnimation->play(mCurrentGroup, "stop", "stop", loop);
 }
@@ -168,21 +173,20 @@ void CharacterController::markerEvent(float time, const std::string &evt)
 }
 
 
-Ogre::Vector3 CharacterController::update(float duration)
+void CharacterController::update(float duration, Movement &movement)
 {
-    Ogre::Vector3 movement(0.0f);
-
     float speed = 0.0f;
     if(!(getState() >= CharState_Death1))
     {
         const MWBase::World *world = MWBase::Environment::get().getWorld();
         const MWWorld::Class &cls = MWWorld::Class::get(mPtr);
-        const Ogre::Vector3 &vec = cls.getMovementVector(mPtr);
 
         bool onground = world->isOnGround(mPtr);
         bool inwater = world->isSwimming(mPtr);
         bool isrunning = cls.getStance(mPtr, MWWorld::Class::Run);
         bool sneak = cls.getStance(mPtr, MWWorld::Class::Sneak);
+        const Ogre::Vector3 &vec = cls.getMovementVector(mPtr);
+        const Ogre::Vector3 &rot = cls.getRotationVector(mPtr);
         speed = cls.getSpeed(mPtr);
 
         /* FIXME: The state should be set to Jump, and X/Y movement should be disallowed except
@@ -192,14 +196,14 @@ Ogre::Vector3 CharacterController::update(float duration)
             float x = cls.getJump(mPtr);
 
             if(vec.x == 0 && vec.y == 0)
-                movement.z += x*duration;
+                movement.mPosition[2] += x*duration;
             else
             {
                 /* FIXME: this would be more correct if we were going into a jumping state,
                  * rather than normal walking/idle states. */
                 //Ogre::Vector3 lat = Ogre::Vector3(vec.x, vec.y, 0.0f).normalisedCopy();
                 //movement += Ogre::Vector3(lat.x, lat.y, 1.0f) * x * 0.707f * duration;
-                movement.z += x * 0.707f * duration;
+                movement.mPosition[2] += x * 0.707f * duration;
             }
 
             //decrease fatigue by fFatigueJumpBase + (1 - normalizedEncumbrance) * fFatigueJumpMult;
@@ -216,7 +220,7 @@ Ogre::Vector3 CharacterController::update(float duration)
                                  : (sneak ? CharState_SneakLeft : (isrunning ? CharState_RunLeft : CharState_WalkLeft)), true);
 
             // Apply any forward/backward movement manually
-            movement.y += vec.y * (speed*duration);
+            movement.mPosition[1] += vec.y * (speed*duration);
         }
         else if(vec.y != 0.0f && speed > 0.0f)
         {
@@ -228,20 +232,32 @@ Ogre::Vector3 CharacterController::update(float duration)
                 setState(inwater ? (isrunning ? CharState_SwimRunBack : CharState_SwimWalkBack)
                                  : (sneak ? CharState_SneakBack : (isrunning ? CharState_RunBack : CharState_WalkBack)), true);
             // Apply any sideways movement manually
-            movement.x += vec.x * (speed*duration);
+            movement.mPosition[0] += vec.x * (speed*duration);
+        }
+        else if(rot.z != 0.0f && !inwater && !sneak)
+        {
+            if(rot.z > 0.0f)
+                setState(CharState_TurnRight, true);
+            else if(rot.z < 0.0f)
+                setState(CharState_TurnLeft, true);
         }
         else if(mAnimQueue.size() == 0)
             setState((inwater ? CharState_IdleSwim : (sneak ? CharState_IdleSneak : CharState_Idle)), true);
+
+        movement.mRotation[0] += rot.x * duration;
+        movement.mRotation[1] += rot.y * duration;
+        movement.mRotation[2] += rot.z * duration;
     }
 
     if(mAnimation && !mSkipAnim)
     {
         mAnimation->setSpeed(speed);
-        movement += mAnimation->runAnimation(duration);
+        Ogre::Vector3 moved = mAnimation->runAnimation(duration);
+        movement.mPosition[0] += moved.x;
+        movement.mPosition[1] += moved.y;
+        movement.mPosition[2] += moved.z;
     }
     mSkipAnim = false;
-
-    return movement;
 }
 
 

apps/openmw/mwmechanics/character.hpp

@@ -13,6 +13,8 @@ namespace MWRender
 namespace MWMechanics
 {
 
+class Movement;
+
 enum CharacterState {
     CharState_SpecialIdle,
     CharState_Idle,
@@ -52,6 +54,9 @@ enum CharacterState {
     CharState_SneakLeft,
     CharState_SneakRight,
 
+    CharState_TurnLeft,
+    CharState_TurnRight,
+
     CharState_Jump,
 
     /* Death states must be last! */
@@ -87,7 +92,7 @@ public:
 
     void updatePtr(const MWWorld::Ptr &ptr);
 
-    Ogre::Vector3 update(float duration);
+    void update(float duration, Movement &movement);
 
     void playGroup(const std::string &groupname, int mode, int count);
     void skipAnim();

apps/openmw/mwmechanics/enchanting.cpp

@@ -0,0 +1,167 @@
+#include "enchanting.hpp"
+#include "../mwworld/player.hpp"
+#include "../mwworld/manualref.hpp"
+#include "../mwworld/class.hpp"
+#include "../mwworld/containerstore.hpp"
+namespace MWMechanics
+{
+    Enchanting::Enchanting(MWWorld::Ptr enchanter):
+    mEnchanter(enchanter),
+    mEnchantType(0)
+    {}
+
+    void Enchanting::setOldItem(MWWorld::Ptr oldItem)
+    {
+        mOldItemPtr=oldItem;
+        if(!itemEmpty())
+        {
+            mObjectType = mOldItemPtr.getTypeName();
+            mOldItemId = mOldItemPtr.getCellRef().mRefID;
+        }
+        else
+        {
+            mObjectType="";
+            mOldItemId="";
+        }
+    }
+
+    void Enchanting::setNewItemName(std::string s)
+    {
+        mNewItemName=s;
+    }
+
+    void Enchanting::setEffect(ESM::EffectList effectList)
+    {
+        mEffectList=effectList;
+    }
+
+    int Enchanting::getEnchantType()
+    {
+        return mEnchantType;
+    }
+
+    void Enchanting::setSoulGem(MWWorld::Ptr soulGem)
+    {
+        mSoulGemPtr=soulGem;
+    }
+
+    void Enchanting::create()
+    {
+        mOldItemPtr.getRefData().setCount(mOldItemPtr.getRefData().getCount()-1);
+        mSoulGemPtr.getRefData().setCount(mSoulGemPtr.getRefData().getCount()-1);
+
+        mEnchantment.mData.mCharge = getGemCharge();
+        if(mEnchantType==3)
+        {
+            mEnchantment.mData.mCharge=0;
+        }
+        mEnchantment.mData.mType = mEnchantType;
+        mEnchantment.mData.mCost = getEnchantCost();
+        mEnchantment.mEffects = mEffectList;
+        const ESM::Enchantment *enchantment = MWBase::Environment::get().getWorld()->createRecord (mEnchantment);
+
+        std::string newobjId = MWWorld::Class::get(mOldItemPtr).applyEnchantment(mOldItemPtr, enchantment->mId, getGemCharge(), mNewItemName);
+
+        MWWorld::ManualRef ref (MWBase::Environment::get().getWorld()->getStore(), newobjId);
+        MWWorld::Ptr newobjPtr = ref.getPtr();
+        MWWorld::Ptr result = mOldItemPtr;
+        result.mPtr = newobjPtr.mPtr;
+        MWWorld::Class::get (mEnchanter).getContainerStore (mEnchanter).add (result);
+    }
+    
+    void Enchanting::nextEnchantType()
+    {
+        mEnchantType++;
+        if (itemEmpty())
+        {
+            mEnchantType = 0;
+            return;
+        }
+        if ((mObjectType == typeid(ESM::Armor).name())||(mObjectType == typeid(ESM::Clothing).name()))
+        {
+            switch(mEnchantType)
+            {
+                case 1:
+                    mEnchantType = 2;
+                case 3:
+                    if(getGemCharge()<400)
+                        mEnchantType=2;
+                case 4:
+                    mEnchantType = 2;
+            }
+        }
+        else if(mObjectType == typeid(ESM::Weapon).name())
+        {
+            switch(mEnchantType)
+            {
+                case 3:
+                    mEnchantType = 1;
+            }
+        }
+        else if(mObjectType == typeid(ESM::Book).name())
+        {
+            mEnchantType=0;
+        }
+    }
+
+    int Enchanting::getEnchantCost()
+    {
+        const MWWorld::ESMStore &store = MWBase::Environment::get().getWorld()->getStore();
+        float cost = 0;
+        std::vector<ESM::ENAMstruct> mEffects = mEffectList.mList;
+        int i=mEffects.size();
+        for (std::vector<ESM::ENAMstruct>::const_iterator it = mEffects.begin(); it != mEffects.end(); ++it)
+        {
+            const ESM::MagicEffect* effect = store.get<ESM::MagicEffect>().find(it->mEffectID);
+
+            float cost1 = ((it->mMagnMin + it->mMagnMax)*it->mDuration*effect->mData.mBaseCost*0.025);
+
+            float cost2 = (std::max(1, it->mArea)*0.125*effect->mData.mBaseCost);
+
+            if(mEnchantType==3)
+            {
+                cost1 *= 100;
+                cost2 *= 2;
+            }
+            if(effect->mData.mFlags & ESM::MagicEffect::CastTarget)
+                cost1 *= 1.5;
+
+            float fullcost = cost1+cost2;
+            fullcost*= i;
+            i--;
+
+            cost+=fullcost;
+        }
+        return cost;
+    }
+    int Enchanting::getGemCharge()
+    {
+        const MWWorld::ESMStore &store = MWBase::Environment::get().getWorld()->getStore();
+        if(soulEmpty())
+            return 0;
+        if(mSoulGemPtr.getCellRef().mSoul=="")
+            return 0;
+        const ESM::Creature* soul = store.get<ESM::Creature>().find(mSoulGemPtr.getCellRef().mSoul);
+        return soul->mData.mSoul;
+    }
+
+    int Enchanting::getMaxEnchantValue()
+    {
+        if (itemEmpty())
+            return 0;
+        return MWWorld::Class::get(mOldItemPtr).getEnchantmentPoints(mOldItemPtr);
+    }
+    bool Enchanting::soulEmpty()
+    {
+        if (mSoulGemPtr.isEmpty())
+            return true;
+        return false;
+    }
+
+    bool Enchanting::itemEmpty()
+    {
+        if(mOldItemPtr.isEmpty())
+            return true;
+        return false;
+    }
+}

apps/openmw/mwmechanics/enchanting.hpp

@@ -0,0 +1,41 @@
+#ifndef GAME_MWMECHANICS_ENCHANTING_H
+#define GAME_MWMECHANICS_ENCHANTING_H
+#include <string>
+#include "../mwworld/ptr.hpp"
+#include <components/esm/effectlist.hpp>
+#include "../mwbase/world.hpp"
+#include "../mwbase/environment.hpp"
+namespace MWMechanics
+{
+    class Enchanting
+    {
+            
+            MWWorld::Ptr mOldItemPtr;
+            MWWorld::Ptr mSoulGemPtr;
+            MWWorld::Ptr mEnchanter;
+            const MWWorld::Ptr *mNewItemPtr;
+            int mEnchantType;
+
+            ESM::EffectList mEffectList;
+            ESM::Enchantment mEnchantment;
+
+            std::string mNewItemName;
+            std::string mObjectType;
+            std::string mOldItemId;
+        public:
+            Enchanting(MWWorld::Ptr enchanter);
+            void setOldItem(MWWorld::Ptr oldItem);
+            void setNewItemName(std::string s);
+            void setEffect(ESM::EffectList effectList);
+            void setSoulGem(MWWorld::Ptr soulGem);
+            void create();
+            void nextEnchantType();
+            int getEnchantType();
+            int getEnchantCost();
+            int getMaxEnchantValue();
+            int getGemCharge();
+            bool soulEmpty();
+            bool itemEmpty();
+    };
+}
+#endif

apps/openmw/mwmechanics/mechanicsmanagerimp.cpp

@@ -178,10 +178,10 @@ namespace MWMechanics
 
     void MechanicsManager::add(const MWWorld::Ptr& ptr)
     {
-        if(ptr.getTypeName() == typeid(ESM::Activator).name())
+        if(MWWorld::Class::get(ptr).isActor())
-            mActivators.addActivator(ptr);
-        else
             mActors.addActor(ptr);
+        else
+            mObjects.addObject(ptr);
     }
 
     void MechanicsManager::remove(const MWWorld::Ptr& ptr)
@@ -189,15 +189,15 @@ namespace MWMechanics
         if(ptr == mWatched)
             mWatched = MWWorld::Ptr();
         mActors.removeActor(ptr);
-        mActivators.removeActivator(ptr);
+        mObjects.removeObject(ptr);
     }
 
     void MechanicsManager::updateCell(const MWWorld::Ptr &old, const MWWorld::Ptr &ptr)
     {
-        if(ptr.getTypeName() == typeid(ESM::Activator).name())
+        if(MWWorld::Class::get(ptr).isActor())
-            mActivators.updateActivator(old, ptr);
-        else
             mActors.updateActor(old, ptr);
+        else
+            mObjects.updateObject(old, ptr);
     }
 
 
@@ -207,7 +207,7 @@ namespace MWMechanics
             mWatched = MWWorld::Ptr();
 
         mActors.dropActors(cellStore);
-        mActivators.dropActivators(cellStore);
+        mObjects.dropObjects(cellStore);
     }
 
 
@@ -319,7 +319,7 @@ namespace MWMechanics
         }
 
         mActors.update(duration, paused);
-        mActivators.update(duration, paused);
+        mObjects.update(duration, paused);
     }
 
     void MechanicsManager::restoreDynamicStats()
@@ -656,17 +656,17 @@ namespace MWMechanics
 
     void MechanicsManager::playAnimationGroup(const MWWorld::Ptr& ptr, const std::string& groupName, int mode, int number)
     {
-        if(ptr.getTypeName() == typeid(ESM::Activator).name())
+        if(MWWorld::Class::get(ptr).isActor())
-            mActivators.playAnimationGroup(ptr, groupName, mode, number);
-        else
             mActors.playAnimationGroup(ptr, groupName, mode, number);
+        else
+            mObjects.playAnimationGroup(ptr, groupName, mode, number);
     }
     void MechanicsManager::skipAnimation(const MWWorld::Ptr& ptr)
     {
-        if(ptr.getTypeName() == typeid(ESM::Activator).name())
+        if(MWWorld::Class::get(ptr).isActor())
-            mActivators.skipAnimation(ptr);
-        else
             mActors.skipAnimation(ptr);
+        else
+            mObjects.skipAnimation(ptr);
     }
 
 }

apps/openmw/mwmechanics/mechanicsmanagerimp.hpp

@@ -7,7 +7,7 @@
 
 #include "creaturestats.hpp"
 #include "npcstats.hpp"
-#include "activators.hpp"
+#include "objects.hpp"
 #include "actors.hpp"
 
 namespace Ogre
@@ -31,7 +31,7 @@ namespace MWMechanics
             bool mClassSelected;
             bool mRaceSelected;
 
-            Activators mActivators;
+            Objects mObjects;
             Actors mActors;
 
             void buildPlayer();

apps/openmw/mwmechanics/movement.hpp

@@ -6,11 +6,14 @@ namespace MWMechanics
     /// Desired movement for an actor
     struct Movement
     {
-        signed char mLeftRight; // 1: wants to move left, -1: wants to move right
+        float mPosition[3];
-        signed char mForwardBackward; // 1:wants to move forward, -1: wants to move backward
+        float mRotation[3];
-		signed char mUpDown;
 
-        Movement() : mLeftRight (0), mForwardBackward (0), mUpDown(0) {}
+        Movement()
+        {
+            mPosition[0] = mPosition[1] = mPosition[2] = 0.0f;
+            mRotation[0] = mRotation[1] = mRotation[2] = 0.0f;
+        }
     };
 }
 

apps/openmw/mwmechanics/npcstats.cpp

@@ -21,8 +21,16 @@
 #include "../mwbase/soundmanager.hpp"
 
 MWMechanics::NpcStats::NpcStats()
-: mMovementFlags (0), mDrawState (DrawState_Nothing), mBounty (0)
+: mMovementFlags (0)
-, mLevelProgress(0), mDisposition(0), mVampire (0), mReputation(0), mWerewolf (false), mWerewolfKills (0)
+, mDrawState (DrawState_Nothing)
+, mBounty (0)
+, mLevelProgress(0)
+, mDisposition(0)
+, mVampire (0)
+, mReputation(0)
+, mWerewolf (false)
+, mWerewolfKills (0)
+, mProfit(0)
 {
     mSkillIncreases.resize (ESM::Attribute::Length);
     for (int i=0; i<ESM::Attribute::Length; ++i)
@@ -221,12 +229,12 @@ void MWMechanics::NpcStats::increaseSkill(int skillIndex, const ESM::Class &clas
     message << boost::format(MWBase::Environment::get().getWindowManager ()->getGameSettingString ("sNotifyMessage39", ""))
                % std::string("#{" + ESM::Skill::sSkillNameIds[skillIndex] + "}")
                % static_cast<int> (base);
-    MWBase::Environment::get().getWindowManager ()->messageBox(message.str(), std::vector<std::string>());
+    MWBase::Environment::get().getWindowManager ()->messageBox(message.str());
 
     if (mLevelProgress >= 10)
     {
         // levelup is possible now
-        MWBase::Environment::get().getWindowManager ()->messageBox ("#{sLevelUpMsg}", std::vector<std::string>());
+        MWBase::Environment::get().getWindowManager ()->messageBox ("#{sLevelUpMsg}");
     }
 
     getSkill (skillIndex).setBase (base);
@@ -354,3 +362,13 @@ int MWMechanics::NpcStats::getWerewolfKills() const
 {
     return mWerewolfKills;
 }
+
+int MWMechanics::NpcStats::getProfit() const
+{
+    return mProfit;
+}
+
+void MWMechanics::NpcStats::modifyProfit(int diff)
+{
+    mProfit += diff;
+}

apps/openmw/mwmechanics/npcstats.hpp

@@ -53,6 +53,7 @@ namespace MWMechanics
             int mReputation;
             bool mWerewolf;
             int mWerewolfKills;
+            int mProfit;
 
             int mLevelProgress; // 0-10
 
@@ -64,6 +65,10 @@ namespace MWMechanics
 
             NpcStats();
 
+            /// for mercenary companions. starts out as 0, and changes when items are added or removed through the UI.
+            int getProfit() const;
+            void modifyProfit(int diff);
+
             DrawState_ getDrawState() const;
 
             void setDrawState (DrawState_ state);

apps/openmw/mwmechanics/objects.cpp

@@ -0,0 +1,81 @@
+#include "objects.hpp"
+
+#include <OgreVector3.h>
+
+#include "movement.hpp"
+
+#include "../mwbase/environment.hpp"
+#include "../mwbase/world.hpp"
+
+namespace MWMechanics
+{
+
+Objects::Objects()
+{
+}
+
+void Objects::addObject(const MWWorld::Ptr& ptr)
+{
+    MWRender::Animation *anim = MWBase::Environment::get().getWorld()->getAnimation(ptr);
+    if(anim != NULL)
+        mObjects.insert(std::make_pair(ptr, CharacterController(ptr, anim, CharState_Idle, true)));
+}
+
+void Objects::removeObject(const MWWorld::Ptr& ptr)
+{
+    PtrControllerMap::iterator iter = mObjects.find(ptr);
+    if(iter != mObjects.end())
+        mObjects.erase(iter);
+}
+
+void Objects::updateObject(const MWWorld::Ptr &old, const MWWorld::Ptr &ptr)
+{
+    PtrControllerMap::iterator iter = mObjects.find(old);
+    if(iter != mObjects.end())
+    {
+        CharacterController ctrl = iter->second;
+        mObjects.erase(iter);
+
+        ctrl.updatePtr(ptr);
+        mObjects.insert(std::make_pair(ptr, ctrl));
+    }
+}
+
+void Objects::dropObjects (const MWWorld::Ptr::CellStore *cellStore)
+{
+    PtrControllerMap::iterator iter = mObjects.begin();
+    while(iter != mObjects.end())
+    {
+        if(iter->first.getCell()==cellStore)
+            mObjects.erase(iter++);
+        else
+            ++iter;
+    }
+}
+
+void Objects::update(float duration, bool paused)
+{
+    if(!paused)
+    {
+        for(PtrControllerMap::iterator iter(mObjects.begin());iter != mObjects.end();++iter)
+        {
+            Movement movement;
+            iter->second.update(duration, movement);
+        }
+    }
+}
+
+void Objects::playAnimationGroup(const MWWorld::Ptr& ptr, const std::string& groupName, int mode, int number)
+{
+    PtrControllerMap::iterator iter = mObjects.find(ptr);
+    if(iter != mObjects.end())
+        iter->second.playGroup(groupName, mode, number);
+}
+void Objects::skipAnimation(const MWWorld::Ptr& ptr)
+{
+    PtrControllerMap::iterator iter = mObjects.find(ptr);
+    if(iter != mObjects.end())
+        iter->second.skipAnim();
+}
+
+}

apps/openmw/mwmechanics/objects.hpp

@@ -0,0 +1,45 @@
+#ifndef GAME_MWMECHANICS_ACTIVATORS_H
+#define GAME_MWMECHANICS_ACTOVATORS_H
+
+#include <string>
+#include <map>
+
+#include "character.hpp"
+
+namespace MWWorld
+{
+    class Ptr;
+    class CellStore;
+}
+
+namespace MWMechanics
+{
+    class Objects
+    {
+        typedef std::map<MWWorld::Ptr,CharacterController> PtrControllerMap;
+        PtrControllerMap mObjects;
+
+    public:
+        Objects();
+
+        void addObject (const MWWorld::Ptr& ptr);
+        ///< Register an animated object
+
+        void removeObject (const MWWorld::Ptr& ptr);
+        ///< Deregister an object
+
+        void updateObject(const MWWorld::Ptr &old, const MWWorld::Ptr& ptr);
+        ///< Updates an object with a new Ptr
+
+        void dropObjects(const MWWorld::CellStore *cellStore);
+        ///< Deregister all objects in the given cell.
+
+        void update(float duration, bool paused);
+        ///< Update object animations
+
+        void playAnimationGroup(const MWWorld::Ptr& ptr, const std::string& groupName, int mode, int number);
+        void skipAnimation(const MWWorld::Ptr& ptr);
+    };
+}
+
+#endif

apps/openmw/mwrender/objects.cpp

@@ -1,5 +1,7 @@
 #include "objects.hpp"
 
+#include <cmath>
+
 #include <OgreSceneNode.h>
 #include <OgreSceneManager.h>
 #include <OgreEntity.h>
@@ -271,28 +273,25 @@ void Objects::insertLight (const MWWorld::Ptr& ptr, Ogre::Entity* skelBase, Ogre
     info.time = Ogre::Math::RangeRandom(-500, +500);
     info.phase = Ogre::Math::RangeRandom(-500, +500);
 
-    // changed to linear to look like morrowind
+    bool quadratic = lightOutQuadInLin() ? !info.interior : lightQuadratic();
-    bool quadratic = false;
+
-    /*
+    // with the standard 1 / (c + d*l + d*d*q) equation the attenuation factor never becomes zero,
-    if (!lightOutQuadInLin)
+    // so we ignore lights if their attenuation falls below this factor.
-        quadratic = lightQuadratic;
+    const float threshold = 0.03;
-    else
-    {
-        quadratic = !info.interior;
-    }
-    */
 
     if (!quadratic)
     {
         float r = radius * lightLinearRadiusMult();
         float attenuation = lightLinearValue() / r;
-        light->setAttenuation(r*10, 0, attenuation, 0);
+        float activationRange = 1 / (threshold * attenuation);
+        light->setAttenuation(activationRange, 0, attenuation, 0);
     }
     else
     {
         float r = radius * lightQuadraticRadiusMult();
-        float attenuation = lightQuadraticValue() / pow(r, 2);
+        float attenuation = lightQuadraticValue() / std::pow(r, 2);
-        light->setAttenuation(r*10, 0, 0, attenuation);
+        float activationRange = std::sqrt(1 / (threshold * attenuation));
+        light->setAttenuation(activationRange, 0, 0, attenuation);
     }
 
     // If there's an AttachLight bone, attach the light to that, otherwise attach it to the base scene node

apps/openmw/mwrender/renderingmanager.cpp

@@ -262,7 +262,7 @@ void RenderingManager::scaleObject (const MWWorld::Ptr& ptr, const Ogre::Vector3
     ptr.getRefData().getBaseNode()->setScale(scale);
 }
 
-bool RenderingManager::rotateObject( const MWWorld::Ptr &ptr, Ogre::Vector3 &rot, bool adjust)
+bool RenderingManager::rotateObject(const MWWorld::Ptr &ptr, Ogre::Vector3 &rot, bool adjust)
 {
     bool isActive = ptr.getRefData().getBaseNode() != 0;
     bool isPlayer = isActive && ptr.getRefData().getHandle() == "player";
@@ -272,27 +272,19 @@ bool RenderingManager::rotateObject( const MWWorld::Ptr &ptr, Ogre::Vector3 &rot
         force = mPlayer->rotate(rot, adjust);
 
     MWWorld::Class::get(ptr).adjustRotation(ptr, rot.x, rot.y, rot.z);
-
     if (!isPlayer && isActive)
     {
-        Ogre::Quaternion xr(Ogre::Radian(-rot.x), Ogre::Vector3::UNIT_X);
+        if(adjust)
-        Ogre::Quaternion yr(Ogre::Radian(-rot.y), Ogre::Vector3::UNIT_Y);
+        {
-        Ogre::Quaternion zr(Ogre::Radian(-rot.z), Ogre::Vector3::UNIT_Z);
+            const float *objRot = ptr.getRefData().getPosition().rot;
-
+            rot.x += objRot[0];
-        Ogre::Quaternion xref(Ogre::Radian(-ptr.getRefData().getPosition().rot[0]), Ogre::Vector3::UNIT_X);
+            rot.y += objRot[1];
-        Ogre::Quaternion yref(Ogre::Radian(-ptr.getRefData().getPosition().rot[1]), Ogre::Vector3::UNIT_Y);
+            rot.z += objRot[2];
-        Ogre::Quaternion zref(Ogre::Radian(-ptr.getRefData().getPosition().rot[2]), Ogre::Vector3::UNIT_Z);
+        }
-
-        Ogre::Quaternion newo = adjust ? (xr * yr * zr) * (xref*yref*zref) : xr * yr * zr;
-
-        Ogre::Matrix3 mat;
-        newo.ToRotationMatrix(mat);
-        Ogre::Radian ax,ay,az;
-        mat.ToEulerAnglesXYZ(ax,ay,az);
-        rot.x = -ax.valueRadians();
-        rot.y = -ay.valueRadians();
-        rot.z = -az.valueRadians();
 
+        Ogre::Quaternion newo = Ogre::Quaternion(Ogre::Radian(-rot.x), Ogre::Vector3::UNIT_X) *
+                                Ogre::Quaternion(Ogre::Radian(-rot.y), Ogre::Vector3::UNIT_Y) *
+                                Ogre::Quaternion(Ogre::Radian(-rot.z), Ogre::Vector3::UNIT_Z);
         ptr.getRefData().getBaseNode()->setOrientation(newo);
     }
     else if(isPlayer)

apps/openmw/mwscript/containerextensions.cpp

@@ -83,7 +83,7 @@ namespace MWScript
                             msgBox = boost::str(boost::format(msgBox) % count % itemName);
                         }
 
-                        MWBase::Environment::get().getWindowManager()->messageBox(msgBox, std::vector<std::string>());
+                        MWBase::Environment::get().getWindowManager()->messageBox(msgBox);
                     }
                 }
         };
@@ -179,7 +179,7 @@ namespace MWScript
                         }
 
                         if (numRemoved > 0)
-                            MWBase::Environment::get().getWindowManager()->messageBox(msgBox, std::vector<std::string>());
+                            MWBase::Environment::get().getWindowManager()->messageBox(msgBox);
                     }
                 }
         };

apps/openmw/mwscript/docs/vmformat.txt

@@ -316,5 +316,7 @@ op 0x20001f9: Drop, explicit reference
 op 0x20001fa: DropSoulGem
 op 0x20001fb: DropSoulGem, explicit reference
 op 0x20001fc: OnDeath
+op 0x20001fd: IsWerewolf
+op 0x20001fe: IsWerewolf, explicit reference
 
-opcodes 0x20001fd-0x3ffffff unused
+opcodes 0x20001ff-0x3ffffff unused

apps/openmw/mwscript/locals.cpp

@@ -16,6 +16,30 @@ namespace MWScript
         mFloats.resize (script.mData.mNumFloats, 0);
     }
 
+    int Locals::getIntVar(const std::string &script, const std::string &var)
+    {
+        Compiler::Locals locals = MWBase::Environment::get().getScriptManager()->getLocals(script);
+        int index = locals.getIndex(var);
+        char type = locals.getType(var);
+        if(index != -1)
+        {
+            switch(type)
+            {
+                case 's':
+                    return mShorts.at (index);
+
+                case 'l':
+                    return mLongs.at (index);
+
+                case 'f':
+                    return mFloats.at (index);
+                default:
+                    return 0;
+            }
+        }
+        return 0;
+    }
+        
     bool Locals::setVarByInt(const std::string& script, const std::string& var, int val)
     {    
         Compiler::Locals locals = MWBase::Environment::get().getScriptManager()->getLocals(script);

apps/openmw/mwscript/locals.hpp

@@ -17,6 +17,7 @@ namespace MWScript
             
             void configure (const ESM::Script& script);
             bool setVarByInt(const std::string& script, const std::string& var, int val);
+            int getIntVar (const std::string& script, const std::string& var); ///< if var does not exist, returns 0
         
     };
 }

apps/openmw/mwscript/scriptmanagerimp.cpp

@@ -114,7 +114,7 @@ namespace MWScript
             }
             catch (const std::exception& e)
             {
-                std::cerr << "exeution of script " << name << " failed." << std::endl;
+                std::cerr << "execution of script " << name << " failed." << std::endl;
 
                 if (mVerbose)
                     std::cerr << "(" << e.what() << ")" << std::endl;

apps/openmw/mwscript/statsextensions.cpp

@@ -1046,6 +1046,18 @@ namespace MWScript
                 }
         };
 
+        template <class R>
+        class OpIsWerewolf : public Interpreter::Opcode0
+        {
+            public:
+
+                virtual void execute (Interpreter::Runtime& runtime)
+                {
+                    MWWorld::Ptr ptr = R()(runtime);
+                    runtime.push(MWWorld::Class::get(ptr).getNpcStats(ptr).isWerewolf());
+                }
+        };
+
         const int numberOfAttributes = 8;
 
         const int opcodeGetAttribute = 0x2000027;
@@ -1137,6 +1149,9 @@ namespace MWScript
 
         const int opcodeOnDeath = 0x20001fc;
 
+        const int opcodeIsWerewolf = 0x20001fd;
+        const int opcodeIsWerewolfExplicit = 0x20001fe;
+
         void registerExtensions (Compiler::Extensions& extensions)
         {
             static const char *attributes[numberOfAttributes] =
@@ -1252,6 +1267,8 @@ namespace MWScript
             extensions.registerInstruction ("lowerrank", "", opcodeLowerRank, opcodeLowerRankExplicit);
 
             extensions.registerFunction ("ondeath", 'l', "", opcodeOnDeath);
+
+            extensions.registerFunction ("iswerewolf", 'l', "", opcodeIsWerewolf, opcodeIsWerewolfExplicit);
         }
 
         void installOpcodes (Interpreter::Interpreter& interpreter)
@@ -1368,6 +1385,9 @@ namespace MWScript
             interpreter.installSegment5 (opcodeLowerRankExplicit, new OpLowerRank<ExplicitRef>);
 
             interpreter.installSegment5 (opcodeOnDeath, new OpOnDeath);
+
+            interpreter.installSegment5 (opcodeIsWerewolf, new OpIsWerewolf<ImplicitRef>);
+            interpreter.installSegment5 (opcodeIsWerewolfExplicit, new OpIsWerewolf<ExplicitRef>);
         }
     }
 }

apps/openmw/mwworld/actionequip.cpp

@@ -62,7 +62,7 @@ namespace MWWorld
                         if((*itr).mPart == ESM::PRT_Head)
                         {
                             if(actor == MWBase::Environment::get().getWorld()->getPlayer().getPlayer() )
-                                MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage13}", std::vector<std::string>());
+                                MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage13}");
 
                             allow = false;
                             break;
@@ -90,12 +90,12 @@ namespace MWWorld
                             if(actor == MWBase::Environment::get().getWorld()->getPlayer().getPlayer() )
                             {
                                 if(it.getType() == MWWorld::ContainerStore::Type_Clothing){ // It's shoes
-                                    MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage15}", std::vector<std::string>());
+                                    MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage15}");
                                 }
 
                                 else // It's boots
                                 {
-                                    MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage14}", std::vector<std::string>());
+                                    MWBase::Environment::get().getWindowManager()->messageBox ("#{sNotifyMessage14}");
                                 }
                             }
                             break;

apps/openmw/mwworld/actionsoulgem.cpp

@@ -0,0 +1,21 @@
+#include "actionsoulgem.hpp"
+
+#include "../mwbase/windowmanager.hpp"
+#include "../mwbase/environment.hpp"
+
+namespace MWWorld
+{
+
+ActionSoulgem::ActionSoulgem(const Ptr &object)
+    : Action(false, object)
+{
+
+}
+
+void ActionSoulgem::executeImp(const Ptr &actor)
+{
+    MWBase::Environment::get().getWindowManager()->showSoulgemDialog(getTarget());
+}
+
+
+}

apps/openmw/mwworld/actionsoulgem.hpp

@@ -0,0 +1,19 @@
+#ifndef GAME_MWWORLD_ACTIONSOULGEM_H
+#define GAME_MWWORLD_ACTIONSOULGEM_H
+
+#include "action.hpp"
+#include "ptr.hpp"
+
+namespace MWWorld
+{
+    class ActionSoulgem : public Action
+    {
+            virtual void executeImp (const MWWorld::Ptr& actor);
+
+        public:
+            /// @param soulgem to use
+            ActionSoulgem (const Ptr& object);
+    };
+}
+
+#endif

apps/openmw/mwworld/class.cpp

@@ -127,6 +127,11 @@ namespace MWWorld
         return 0;
     }
 
+    short Class::getEnchantmentPoints (const MWWorld::Ptr& ptr) const
+    {
+        throw std::runtime_error ("class does not support enchanting");
+    }
+
     MWMechanics::Movement& Class::getMovementSettings (const Ptr& ptr) const
     {
         throw std::runtime_error ("movement settings not supported by class");
@@ -137,6 +142,11 @@ namespace MWWorld
         return Ogre::Vector3 (0, 0, 0);
     }
 
+    Ogre::Vector3 Class::getRotationVector (const Ptr& ptr) const
+    {
+        return Ogre::Vector3 (0, 0, 0);
+    }
+
     std::pair<std::vector<int>, bool> Class::getEquipmentSlots (const Ptr& ptr) const
     {
         return std::make_pair (std::vector<int>(), false);
@@ -179,10 +189,13 @@ namespace MWWorld
 
     const Class& Class::get (const std::string& key)
     {
+        if (key.empty())
+            throw std::logic_error ("Class::get(): attempting to get an empty key");
+
         std::map<std::string, boost::shared_ptr<Class> >::const_iterator iter = sClasses.find (key);
 
         if (iter==sClasses.end())
-            throw std::logic_error ("unknown class key: " + key);
+            throw std::logic_error ("Class::get(): unknown class key: " + key);
 
         return *iter->second;
     }
@@ -241,6 +254,11 @@ namespace MWWorld
         return "";
     }
 
+    std::string Class::applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const
+    {
+        throw std::runtime_error ("class can't be enchanted");
+    }
+
     MWWorld::Ptr
     Class::copyToCellImpl(const Ptr &ptr, CellStore &cell) const
     {

apps/openmw/mwworld/class.hpp

@@ -150,6 +150,9 @@ namespace MWWorld
             ///< Return desired movement vector (determined based on movement settings,
             /// stance and stats).
 
+            virtual Ogre::Vector3 getRotationVector (const Ptr& ptr) const;
+            ///< Return desired rotations, as euler angles.
+
             virtual std::pair<std::vector<int>, bool> getEquipmentSlots (const Ptr& ptr) const;
             ///< \return first: Return IDs of the slot this object can be equipped in; second: can object
             /// stay stacked when equipped?
@@ -225,12 +228,17 @@ namespace MWWorld
             ///< @return the enchantment ID if the object is enchanted, otherwise an empty string
             /// (default implementation: return empty string)
 
+            virtual short getEnchantmentPoints (const MWWorld::Ptr& ptr) const;
+            ///< @return the number of enchantment points available for possible enchanting
+
             virtual void adjustScale(const MWWorld::Ptr& ptr,float& scale) const;
 
             virtual void adjustRotation(const MWWorld::Ptr& ptr,float& x,float& y,float& z) const;
 
             virtual std::string getModel(const MWWorld::Ptr &ptr) const;
 
+            virtual std::string applyEnchantment(const MWWorld::Ptr &ptr, const std::string& enchId, int enchCharge, const std::string& newName) const;
+
             virtual Ptr
             copyToCell(const Ptr &ptr, CellStore &cell) const;
 

apps/openmw/mwworld/containerstore.cpp

@@ -111,33 +111,28 @@ MWWorld::ContainerStoreIterator MWWorld::ContainerStore::addImp (const Ptr& ptr)
 
     // gold needs special handling: when it is inserted into a container, the base object automatically becomes Gold_001
     // this ensures that gold piles of different sizes stack with each other (also, several scripts rely on Gold_001 for detecting player gold)
-    if (MWWorld::Class::get(ptr).getName(ptr) == esmStore.get<ESM::GameSetting>().find("sGold")->getString())
+    if (Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_001")
+        || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_005")
+        || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_010")
+        || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_025")
+        || Misc::StringUtils::ciEqual(ptr.getCellRef().mRefID, "gold_100"))
     {
-        MWWorld::LiveCellRef<ESM::Miscellaneous> *gold =
+        MWWorld::ManualRef ref(esmStore, "Gold_001");
-            ptr.get<ESM::Miscellaneous>();
 
-        if (Misc::StringUtils::ciEqual(gold->mRef.mRefID, "gold_001")
+        int count = MWWorld::Class::get(ptr).getValue(ptr) * ptr.getRefData().getCount();
-            || Misc::StringUtils::ciEqual(gold->mRef.mRefID, "gold_005")
+
-            || Misc::StringUtils::ciEqual(gold->mRef.mRefID, "gold_010")
+        ref.getPtr().getRefData().setCount(count);
-            || Misc::StringUtils::ciEqual(gold->mRef.mRefID, "gold_025")
+        for (MWWorld::ContainerStoreIterator iter (begin(type)); iter!=end(); ++iter)
-            || Misc::StringUtils::ciEqual(gold->mRef.mRefID, "gold_100"))
         {
-            MWWorld::ManualRef ref(esmStore, "Gold_001");
+            if (Misc::StringUtils::ciEqual((*iter).get<ESM::Miscellaneous>()->mRef.mRefID, "gold_001"))
-
-            int count = (ptr.getRefData().getCount() == 1) ? gold->mBase->mData.mValue : ptr.getRefData().getCount();
-            ref.getPtr().getRefData().setCount(count);
-            for (MWWorld::ContainerStoreIterator iter (begin(type)); iter!=end(); ++iter)
             {
-                if (Misc::StringUtils::ciEqual((*iter).get<ESM::Miscellaneous>()->mRef.mRefID, "gold_001"))
+                (*iter).getRefData().setCount( (*iter).getRefData().getCount() + count);
-                {
+                flagAsModified();
-                    (*iter).getRefData().setCount( (*iter).getRefData().getCount() + count);
+                return iter;
-                    flagAsModified();
-                    return iter;
-                }
             }
-
-            return addImpl(ref.getPtr());
         }
+
+        return addImpl(ref.getPtr());
     }
 
     // determine whether to stack or not

apps/openmw/mwworld/failedaction.cpp

@@ -15,7 +15,7 @@ namespace MWWorld
     {
         if ( actor.getRefData().getHandle()=="player" && !(message.empty()))
 	{
-	  MWBase::Environment::get().getWindowManager() ->messageBox(message, std::vector<std::string>());
+      MWBase::Environment::get().getWindowManager() ->messageBox(message);
 	}
     }
 }

apps/openmw/mwworld/manualref.hpp

@@ -69,10 +69,11 @@ namespace MWWorld
                 cellRef.mScale = 1;
                 cellRef.mFactIndex = 0;
                 cellRef.mCharge = -1;
-                cellRef.mNam9 = 0;
+                cellRef.mGoldValue = 1;
+                cellRef.mEnchantmentCharge = -1;
                 cellRef.mTeleport = false;
                 cellRef.mLockLevel = 0;
-                cellRef.mUnam = 0;
+                cellRef.mReferenceBlocked = 0;
             }
 
             const Ptr& getPtr() const