mirror
/
openmw-tes3mp
mirror of https://github.com/TES3MP/openmw-tes3mp.git
1
0
Fork 1
Code Issues Releases Wiki Activity

Merge branch 'master' into shadersystem

Browse Source
actorid
scrawl 13 years ago
parent 509e9d7034 483b125aad
commit 4434fb640e
119 changed files with 2806 additions and 2495 deletions
Show Stats Download Patch File Download Diff File

1
.gitignore vendored
Unescape Escape View File

@ -13,3 +13,4 @@ cmake_install.cmake
Makefile
makefile
data
*.kdev4

2
CMakeLists.txt
Unescape Escape View File

@ -23,7 +23,7 @@ set (OPENMW_VERSION "${OPENMW_VERSION_MAJOR}.${OPENMW_VERSION_MINOR}.${OPENMW_VE
# Debug suffix for plugins
set(DEBUG_SUFFIX "")
if (DEFINED CMAKE_BUILD_TYPE)
if (${CMAKE_BUILD_TYPE} STREQUAL "Debug")
if (CMAKE_BUILD_TYPE STREQUAL "Debug")
set(DEBUG_SUFFIX "_d")
endif()
endif()

2
apps/esmtool/esmtool.cpp
Unescape Escape View File

@ -187,7 +187,7 @@ int main(int argc, char**argv)
case REC_ALCH:
{
Potion p;
p.load(esm);
p.load(esm, id);
if(quiet) break;
cout << " Name: " << p.name << endl;
break;

4
apps/openmw/CMakeLists.txt
Unescape Escape View File

@ -50,7 +50,7 @@ add_openmw_dir (mwworld
refdata worldimp physicssystem scene globals class action nullaction actionteleport
containerstore actiontalk actiontake manualref player cellfunctors
cells localscripts customdata weather inventorystore ptr actionopen actionread
actionequip timestamp actionalchemy cellstore
actionequip timestamp actionalchemy cellstore actionapply
)
add_openmw_dir (mwclass
@ -60,7 +60,7 @@ add_openmw_dir (mwclass
add_openmw_dir (mwmechanics
mechanicsmanager stat creaturestats magiceffects movement actors drawstate spells
activespells
activespells npcstats
)
add_openmw_dir (mwbase

19
apps/openmw/engine.cpp
Unescape Escape View File

@ -1,25 +1,13 @@
#include "engine.hpp"
#include "components/esm/loadcell.hpp"
#include <cassert>
#include <iostream>
#include <utility>
#include <OgreRoot.h>
#include <OgreRenderWindow.h>
#include <MyGUI_WidgetManager.h>
#include <openengine/ogre/renderer.hpp>
#include <openengine/gui/manager.hpp>
#include <components/esm/records.hpp>
#include <components/bsa/bsa_archive.hpp>
#include <components/esm/esm_reader.hpp>
#include <components/files/fixedpath.hpp>
#include <components/files/configurationmanager.hpp>
#include <components/settings/settings.hpp>
#include <components/nifoverrides/nifoverrides.hpp>
#include <components/nifbullet/bullet_nif_loader.hpp>
@ -31,16 +19,12 @@
#include "mwgui/cursorreplace.hpp"
#include "mwscript/scriptmanager.hpp"
#include "mwscript/compilercontext.hpp"
#include "mwscript/interpretercontext.hpp"
#include "mwscript/extensions.hpp"
#include "mwscript/globalscripts.hpp"
#include "mwsound/soundmanager.hpp"
#include "mwworld/class.hpp"
#include "mwworld/player.hpp"
#include "mwworld/cellstore.hpp"
#include "mwworld/worldimp.hpp"
#include "mwclass/classes.hpp"
@ -50,9 +34,6 @@
#include "mwmechanics/mechanicsmanager.hpp"
#include "mwbase/environment.hpp"
#include "mwbase/world.hpp"
void OMW::Engine::executeLocalScripts()
{

4
apps/openmw/engine.hpp
Unescape Escape View File

@ -1,10 +1,6 @@
#ifndef ENGINE_H
#define ENGINE_H
#include <string>
#include <boost/filesystem.hpp>
#include <OgreFrameListener.h>
#include <components/compiler/extensions.hpp>

17
apps/openmw/main.cpp
Unescape Escape View File

@ -1,13 +1,5 @@
#include <iostream>
#include <string>
#include <fstream>
#include <boost/program_options.hpp>
#include <components/files/fileops.hpp>
#include <components/files/fixedpath.hpp>
#include <components/files/collections.hpp>
#include <components/files/configurationmanager.hpp>
#include "engine.hpp"
@ -16,15 +8,10 @@
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/stream_buffer.hpp>
# if !defined(_DEBUG)
# include <iostream>
# include <fstream>
# endif
// For OutputDebugString
#include <Windows.h>
// makes __argc and __argv available on windows
#include <stdlib.h>
#include <cstdlib>
#endif
@ -52,8 +39,6 @@ inline boost::filesystem::path lexical_cast<boost::filesystem::path, std::string
} /* namespace boost */
#endif /* (BOOST_VERSION <= 104600) */
using namespace std;
struct FallbackMap {
std::map<std::string,std::string> mMap;
};

2
apps/openmw/mwbase/world.hpp
Unescape Escape View File

@ -1,8 +1,6 @@
#ifndef GAME_MWBASE_WORLD_H
#define GAME_MWBASE_WORLD_H
#include <string>
#include <map>
#include <vector>
#include <components/settings/settings.hpp>

1
apps/openmw/mwclass/creature.hpp
Unescape Escape View File

@ -1,7 +1,6 @@
#ifndef GAME_MWCLASS_CREATURE_H
#define GAME_MWCLASS_CREATURE_H
#include "../mwworld/class.hpp"
#include "../mwrender/renderinginterface.hpp"
#include "../mwrender/actors.hpp"

50
apps/openmw/mwclass/npc.cpp
Unescape Escape View File

@ -67,11 +67,11 @@ namespace MWClass
boost::algorithm::to_lower(faction);
if(ref->base->npdt52.gold != -10)
{
data->mNpcStats.mFactionRank[faction] = (int)ref->base->npdt52.rank;
data->mNpcStats.getFactionRanks()[faction] = (int)ref->base->npdt52.rank;
}
else
{
data->mNpcStats.mFactionRank[faction] = (int)ref->base->npdt12.rank;
data->mNpcStats.getFactionRanks()[faction] = (int)ref->base->npdt12.rank;
}
}
@ -79,7 +79,7 @@ namespace MWClass
if(ref->base->npdt52.gold != -10)
{
for (int i=0; i<27; ++i)
data->mNpcStats.mSkill[i].setBase (ref->base->npdt52.skills[i]);
data->mNpcStats.getSkill (i).setBase (ref->base->npdt52.skills[i]);
data->mCreatureStats.mAttributes[0].set (ref->base->npdt52.strength);
data->mCreatureStats.mAttributes[1].set (ref->base->npdt52.intelligence);
@ -206,12 +206,12 @@ namespace MWClass
{
case Run:
stats.mForceRun = force;
stats.setMovementFlag (MWMechanics::NpcStats::Flag_ForceRun, force);
break;
case Sneak:
stats.mForceSneak = force;
stats.setMovementFlag (MWMechanics::NpcStats::Flag_ForceSneak, force);
break;
case Combat:
@ -228,17 +228,18 @@ namespace MWClass
{
case Run:
stats.mRun = set;
stats.setMovementFlag (MWMechanics::NpcStats::Flag_Run, set);
break;
case Sneak:
stats.mSneak = set;
stats.setMovementFlag (MWMechanics::NpcStats::Flag_Sneak, set);
break;
case Combat:
stats.mCombat = set;
// Combat stance ignored for now; need to be determined based on draw state instead of
// being maunally set.
break;
}
}
@ -251,21 +252,21 @@ namespace MWClass
{
case Run:
if (!ignoreForce && stats.mForceRun)
if (!ignoreForce && stats.getMovementFlag (MWMechanics::NpcStats::Flag_ForceRun))
return true;
return stats.mRun;
return stats.getMovementFlag (MWMechanics::NpcStats::Flag_Run);
case Sneak:
if (!ignoreForce && stats.mForceSneak)
if (!ignoreForce && stats.getMovementFlag (MWMechanics::NpcStats::Flag_ForceSneak))
return true;
return stats.mSneak;
return stats.getMovementFlag (MWMechanics::NpcStats::Flag_Sneak);
case Combat:
return stats.mCombat;
return false;
}
return false;
@ -348,10 +349,31 @@ namespace MWClass
return weight;
}
bool Npc::apply (const MWWorld::Ptr& ptr, const std::string& id,
const MWWorld::Ptr& actor) const
{
MWMechanics::CreatureStats& stats = getCreatureStats (ptr);
/// \todo consider instant effects
return stats.mActiveSpells.addSpell (id);
}
void Npc::skillUsageSucceeded (const MWWorld::Ptr& ptr, int skill, int usageType) const
{
MWMechanics::NpcStats& stats = getNpcStats (ptr);
MWWorld::LiveCellRef<ESM::NPC> *ref = ptr.get<ESM::NPC>();
const ESM::Class *class_ = MWBase::Environment::get().getWorld()->getStore().classes.find (
ref->base->cls);
stats.useSkill (skill, *class_, usageType);
}
void Npc::adjustRotation(const MWWorld::Ptr& ptr,float& x,float& y,float& z) const
{
y = 0;
x = 0;
std::cout << "dfdfdfdfnzdofnmqsldgnmqskdhblqkdbv lqksdf";
}
}

9
apps/openmw/mwclass/npc.hpp
Unescape Escape View File

@ -76,6 +76,15 @@ namespace MWClass
///< Returns total weight of objects inside this object (including modifications from magic
/// effects). Throws an exception, if the object can't hold other objects.
virtual bool apply (const MWWorld::Ptr& ptr, const std::string& id,
const MWWorld::Ptr& actor) const;
///< Apply \a id on \a ptr.
/// \param actor Actor that is resposible for the ID being applied to \a ptr.
/// \return Any effect?
virtual void skillUsageSucceeded (const MWWorld::Ptr& ptr, int skill, int usageType) const;
///< Inform actor \a ptr that a skill use has succeeded.
virtual void adjustRotation(const MWWorld::Ptr& ptr,float& x,float& y,float& z) const;
static void registerSelf();

15
apps/openmw/mwclass/potion.cpp
Unescape Escape View File

@ -8,8 +8,10 @@
#include "../mwworld/ptr.hpp"
#include "../mwworld/actiontake.hpp"
#include "../mwworld/actionapply.hpp"
#include "../mwworld/cellstore.hpp"
#include "../mwworld/physicssystem.hpp"
#include "../mwworld/player.hpp"
#include "../mwgui/window_manager.hpp"
#include "../mwgui/tooltips.hpp"
@ -144,4 +146,17 @@ namespace MWClass
return info;
}
boost::shared_ptr<MWWorld::Action> Potion::use (const MWWorld::Ptr& ptr) const
{
MWWorld::LiveCellRef<ESM::Potion> *ref =
ptr.get<ESM::Potion>();
ptr.getRefData().setCount (ptr.getRefData().getCount()-1);
MWWorld::Ptr actor = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
return boost::shared_ptr<MWWorld::Action> (
new MWWorld::ActionApply (actor, ref->base->mId, actor));
}
}

3
apps/openmw/mwclass/potion.hpp
Unescape Escape View File

@ -34,6 +34,9 @@ namespace MWClass
virtual int getValue (const MWWorld::Ptr& ptr) const;
///< Return trade value of the object. Throws an exception, if the object can't be traded.
virtual boost::shared_ptr<MWWorld::Action> use (const MWWorld::Ptr& ptr) const;
///< Generate action for using via inventory menu
static void registerSelf();
virtual std::string getUpSoundId (const MWWorld::Ptr& ptr) const;

36
apps/openmw/mwdialogue/dialoguemanager.cpp
Unescape Escape View File

@ -203,10 +203,10 @@ namespace MWDialogue
MWMechanics::NpcStats PCstats = MWWorld::Class::get(MWBase::Environment::get().getWorld()->getPlayer().getPlayer()).getNpcStats(MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
MWMechanics::NpcStats NPCstats = MWWorld::Class::get(actor).getNpcStats(actor);
int sameFaction = 0;
if(!NPCstats.mFactionRank.empty())
if(!NPCstats.getFactionRanks().empty())
{
std::string NPCFaction = NPCstats.mFactionRank.begin()->first;
if(PCstats.mFactionRank.find(toLower(NPCFaction)) != PCstats.mFactionRank.end()) sameFaction = 1;
std::string NPCFaction = NPCstats.getFactionRanks().begin()->first;
if(PCstats.getFactionRanks().find(toLower(NPCFaction)) != PCstats.getFactionRanks().end()) sameFaction = 1;
}
if(!selectCompare<int,int>(comp,sameFaction,select.i)) return false;
}
@ -525,8 +525,8 @@ namespace MWDialogue
//MWWorld::Class npcClass = MWWorld::Class::get(actor);
MWMechanics::NpcStats stats = MWWorld::Class::get(actor).getNpcStats(actor);
std::map<std::string,int>::iterator it = stats.mFactionRank.find(toLower(info.npcFaction));
if(it!=stats.mFactionRank.end())
std::map<std::string,int>::iterator it = stats.getFactionRanks().find(toLower(info.npcFaction));
if(it!=stats.getFactionRanks().end())
{
//check rank
if(it->second < (int)info.data.rank) return false;
@ -542,8 +542,8 @@ namespace MWDialogue
if(!info.pcFaction.empty())
{
MWMechanics::NpcStats stats = MWWorld::Class::get(MWBase::Environment::get().getWorld()->getPlayer().getPlayer()).getNpcStats(MWBase::Environment::get().getWorld()->getPlayer().getPlayer());
std::map<std::string,int>::iterator it = stats.mFactionRank.find(toLower(info.pcFaction));
if(it!=stats.mFactionRank.end())
std::map<std::string,int>::iterator it = stats.getFactionRanks().find(toLower(info.pcFaction));
if(it!=stats.getFactionRanks().end())
{
//check rank
if(it->second < (int)info.data.PCrank) return false;
@ -591,7 +591,7 @@ namespace MWDialogue
mIsInChoice = false;
mCompilerContext.setExtensions (&extensions);
mDialogueMap.clear();
actorKnownTopics.clear();
mActorKnownTopics.clear();
ESMS::RecListCaseT<ESM::Dialogue>::MapType dialogueList = MWBase::Environment::get().getWorld()->getStore().dialogs.list;
for(ESMS::RecListCaseT<ESM::Dialogue>::MapType::iterator it = dialogueList.begin(); it!=dialogueList.end();it++)
{
@ -601,24 +601,24 @@ namespace MWDialogue
void DialogueManager::addTopic(std::string topic)
{
knownTopics[toLower(topic)] = true;
mKnownTopics[toLower(topic)] = true;
}
void DialogueManager::parseText(std::string text)
{
std::list<std::string>::iterator it;
for(it = actorKnownTopics.begin();it != actorKnownTopics.end();++it)
for(it = mActorKnownTopics.begin();it != mActorKnownTopics.end();++it)
{
size_t pos = find_str_ci(text,*it,0);
if(pos !=std::string::npos)
{
if(pos==0)
{
knownTopics[*it] = true;
mKnownTopics[*it] = true;
}
else if(text.substr(pos -1,1) == " ")
{
knownTopics[*it] = true;
mKnownTopics[*it] = true;
}
}
}
@ -632,7 +632,7 @@ namespace MWDialogue
mActor = actor;
actorKnownTopics.clear();
mActorKnownTopics.clear();
//initialise the GUI
MWBase::Environment::get().getWindowManager()->pushGuiMode(MWGui::GM_Dialogue);
@ -742,7 +742,7 @@ namespace MWDialogue
std::list<std::string> keywordList;
int choice = mChoice;
mChoice = -1;
actorKnownTopics.clear();
mActorKnownTopics.clear();
MWGui::DialogueWindow* win = MWBase::Environment::get().getWindowManager()->getDialogueWindow();
ESMS::RecListCaseT<ESM::Dialogue>::MapType dialogueList = MWBase::Environment::get().getWorld()->getStore().dialogs.list;
for(ESMS::RecListCaseT<ESM::Dialogue>::MapType::iterator it = dialogueList.begin(); it!=dialogueList.end();it++)
@ -755,9 +755,9 @@ namespace MWDialogue
{
if (isMatching (mActor, *iter) && functionFilter(mActor,*iter,true))
{
actorKnownTopics.push_back(toLower(it->first));
mActorKnownTopics.push_back(toLower(it->first));
//does the player know the topic?
if(knownTopics.find(toLower(it->first)) != knownTopics.end())
if(mKnownTopics.find(toLower(it->first)) != mKnownTopics.end())
{
keywordList.push_back(it->first);
break;
@ -903,13 +903,13 @@ namespace MWDialogue
std::string factionID("");
MWMechanics::NpcStats stats = MWWorld::Class::get(mActor).getNpcStats(mActor);
if(stats.mFactionRank.empty())
if(stats.getFactionRanks().empty())
{
std::cout << "No faction for this actor!";
}
else
{
factionID = stats.mFactionRank.begin()->first;
factionID = stats.getFactionRanks().begin()->first;
}
return factionID;
}

4
apps/openmw/mwdialogue/dialoguemanager.hpp
Unescape Escape View File

@ -26,8 +26,8 @@ namespace MWDialogue
void updateTopics();
std::map<std::string,ESM::Dialogue> mDialogueMap;
std::map<std::string,bool> knownTopics;// Those are the topics the player knows.
std::list<std::string> actorKnownTopics;
std::map<std::string,bool> mKnownTopics;// Those are the topics the player knows.
std::list<std::string> mActorKnownTopics;
MWScript::CompilerContext mCompilerContext;
std::ostream mErrorStream;

60
apps/openmw/mwgui/birth.cpp
Unescape Escape View File

@ -15,15 +15,15 @@ BirthDialog::BirthDialog(WindowManager& parWindowManager)
// Centre dialog
center();
getWidget(spellArea, "SpellArea");
getWidget(mSpellArea, "SpellArea");
getWidget(birthImage, "BirthsignImage");
getWidget(mBirthImage, "BirthsignImage");
getWidget(birthList, "BirthsignList");
birthList->setScrollVisible(true);
birthList->eventListSelectAccept += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
birthList->eventListMouseItemActivate += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
birthList->eventListChangePosition += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
getWidget(mBirthList, "BirthsignList");
mBirthList->setScrollVisible(true);
mBirthList->eventListSelectAccept += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
mBirthList->eventListMouseItemActivate += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
mBirthList->eventListChangePosition += MyGUI::newDelegate(this, &BirthDialog::onSelectBirth);
MyGUI::ButtonPtr backButton;
getWidget(backButton, "BackButton");
@ -68,14 +68,14 @@ void BirthDialog::open()
void BirthDialog::setBirthId(const std::string &birthId)
{
currentBirthId = birthId;
birthList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = birthList->getItemCount();
mCurrentBirthId = birthId;
mBirthList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = mBirthList->getItemCount();
for (size_t i = 0; i < count; ++i)
{
if (boost::iequals(*birthList->getItemDataAt<std::string>(i), birthId))
if (boost::iequals(*mBirthList->getItemDataAt<std::string>(i), birthId))
{
birthList->setIndexSelected(i);
mBirthList->setIndexSelected(i);
break;
}
}
@ -100,11 +100,11 @@ void BirthDialog::onSelectBirth(MyGUI::ListBox* _sender, size_t _index)
if (_index == MyGUI::ITEM_NONE)
return;
const std::string *birthId = birthList->getItemDataAt<std::string>(_index);
if (boost::iequals(currentBirthId, *birthId))
const std::string *birthId = mBirthList->getItemDataAt<std::string>(_index);
if (boost::iequals(mCurrentBirthId, *birthId))
return;
currentBirthId = *birthId;
mCurrentBirthId = *birthId;
updateSpells();
}
@ -112,7 +112,7 @@ void BirthDialog::onSelectBirth(MyGUI::ListBox* _sender, size_t _index)
void BirthDialog::updateBirths()
{
birthList->removeAllItems();
mBirthList->removeAllItems();
const ESMS::ESMStore &store = mWindowManager.getStore();
@ -122,34 +122,34 @@ void BirthDialog::updateBirths()
for (; it != end; ++it)
{
const ESM::BirthSign &birth = it->second;
birthList->addItem(birth.name, it->first);
if (boost::iequals(it->first, currentBirthId))
birthList->setIndexSelected(index);
mBirthList->addItem(birth.name, it->first);
if (boost::iequals(it->first, mCurrentBirthId))
mBirthList->setIndexSelected(index);
++index;
}
}
void BirthDialog::updateSpells()
{
for (std::vector<MyGUI::WidgetPtr>::iterator it = spellItems.begin(); it != spellItems.end(); ++it)
for (std::vector<MyGUI::WidgetPtr>::iterator it = mSpellItems.begin(); it != mSpellItems.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
spellItems.clear();
mSpellItems.clear();
if (currentBirthId.empty())
if (mCurrentBirthId.empty())
return;
MWSpellPtr spellWidget;
const int lineHeight = 18;
MyGUI::IntCoord coord(0, 0, spellArea->getWidth(), 18);
MyGUI::IntCoord coord(0, 0, mSpellArea->getWidth(), 18);
const ESMS::ESMStore &store = mWindowManager.getStore();
const ESM::BirthSign *birth = store.birthSigns.find(currentBirthId);
const ESM::BirthSign *birth = store.birthSigns.find(mCurrentBirthId);
std::string texturePath = std::string("textures\\") + birth->texture;
fixTexturePath(texturePath);
birthImage->setImageTexture(texturePath);
mBirthImage->setImageTexture(texturePath);
std::vector<std::string> abilities, powers, spells;
@ -183,25 +183,25 @@ void BirthDialog::updateSpells()
{
if (!categories[category].spells.empty())
{
MyGUI::TextBox* label = spellArea->createWidget<MyGUI::TextBox>("SandBrightText", coord, MyGUI::Align::Default, std::string("Label"));
MyGUI::TextBox* label = mSpellArea->createWidget<MyGUI::TextBox>("SandBrightText", coord, MyGUI::Align::Default, std::string("Label"));
label->setCaption(mWindowManager.getGameSettingString(categories[category].label, ""));
spellItems.push_back(label);
mSpellItems.push_back(label);
coord.top += lineHeight;
std::vector<std::string>::const_iterator end = categories[category].spells.end();
for (std::vector<std::string>::const_iterator it = categories[category].spells.begin(); it != end; ++it)
{
const std::string &spellId = *it;
spellWidget = spellArea->createWidget<MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("Spell") + boost::lexical_cast<std::string>(i));
spellWidget = mSpellArea->createWidget<MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("Spell") + boost::lexical_cast<std::string>(i));
spellWidget->setWindowManager(&mWindowManager);
spellWidget->setSpellId(spellId);
spellItems.push_back(spellWidget);
mSpellItems.push_back(spellWidget);
coord.top += lineHeight;
MyGUI::IntCoord spellCoord = coord;
spellCoord.height = 24; // TODO: This should be fetched from the skin somehow, or perhaps a widget in the layout as a template?
spellWidget->createEffectWidgets(spellItems, spellArea, spellCoord, (category == 0) ? MWEffectList::EF_Constant : 0);
spellWidget->createEffectWidgets(mSpellItems, mSpellArea, spellCoord, (category == 0) ? MWEffectList::EF_Constant : 0);
coord.top = spellCoord.top;
++i;

12
apps/openmw/mwgui/birth.hpp
Unescape Escape View File

@ -25,7 +25,7 @@ namespace MWGui
GM_Female
};
const std::string &getBirthId() const { return currentBirthId; }
const std::string &getBirthId() const { return mCurrentBirthId; }
void setBirthId(const std::string &raceId);
void setNextButtonShow(bool shown);
@ -49,12 +49,12 @@ namespace MWGui
void updateBirths();
void updateSpells();
MyGUI::ListBox* birthList;
MyGUI::WidgetPtr spellArea;
MyGUI::ImageBox* birthImage;
std::vector<MyGUI::WidgetPtr> spellItems;
MyGUI::ListBox* mBirthList;
MyGUI::WidgetPtr mSpellArea;
MyGUI::ImageBox* mBirthImage;
std::vector<MyGUI::WidgetPtr> mSpellItems;
std::string currentBirthId;
std::string mCurrentBirthId;
};
}
#endif

473
apps/openmw/mwgui/class.cpp
Unescape Escape View File

@ -1,6 +1,5 @@
#include "class.hpp"
#include <assert.h>
#include <iterator>
#include <boost/algorithm/string.hpp>
@ -26,8 +25,8 @@ GenerateClassResultDialog::GenerateClassResultDialog(WindowManager& parWindowMan
setText("ReflectT", mWindowManager.getGameSettingString("sMessageQuestionAnswer1", ""));
getWidget(classImage, "ClassImage");
getWidget(className, "ClassName");
getWidget(mClassImage, "ClassImage");
getWidget(mClassName, "ClassName");
MyGUI::ButtonPtr backButton;
getWidget(backButton, "BackButton");
@ -51,15 +50,15 @@ void GenerateClassResultDialog::open()
std::string GenerateClassResultDialog::getClassId() const
{
return className->getCaption();
return mClassName->getCaption();
}
void GenerateClassResultDialog::setClassId(const std::string &classId)
{
currentClassId = classId;
classImage->setImageTexture(std::string("textures\\levelup\\") + currentClassId + ".dds");
mCurrentClassId = classId;
mClassImage->setImageTexture(std::string("textures\\levelup\\") + mCurrentClassId + ".dds");
const ESMS::ESMStore &store = mWindowManager.getStore();
className->setCaption(store.classes.find(currentClassId)->name);
mClassName->setCaption(store.classes.find(mCurrentClassId)->name);
}
// widget controls
@ -82,29 +81,29 @@ PickClassDialog::PickClassDialog(WindowManager& parWindowManager)
// Centre dialog
center();
getWidget(specializationName, "SpecializationName");
getWidget(mSpecializationName, "SpecializationName");
getWidget(favoriteAttribute[0], "FavoriteAttribute0");
getWidget(favoriteAttribute[1], "FavoriteAttribute1");
favoriteAttribute[0]->setWindowManager(&mWindowManager);
favoriteAttribute[1]->setWindowManager(&mWindowManager);
getWidget(mFavoriteAttribute[0], "FavoriteAttribute0");
getWidget(mFavoriteAttribute[1], "FavoriteAttribute1");
mFavoriteAttribute[0]->setWindowManager(&mWindowManager);
mFavoriteAttribute[1]->setWindowManager(&mWindowManager);
for(int i = 0; i < 5; i++)
{
char theIndex = '0'+i;
getWidget(majorSkill[i], std::string("MajorSkill").append(1, theIndex));
getWidget(minorSkill[i], std::string("MinorSkill").append(1, theIndex));
majorSkill[i]->setWindowManager(&mWindowManager);
minorSkill[i]->setWindowManager(&mWindowManager);
getWidget(mMajorSkill[i], std::string("MajorSkill").append(1, theIndex));
getWidget(mMinorSkill[i], std::string("MinorSkill").append(1, theIndex));
mMajorSkill[i]->setWindowManager(&mWindowManager);
mMinorSkill[i]->setWindowManager(&mWindowManager);
}
getWidget(classList, "ClassList");
classList->setScrollVisible(true);
classList->eventListSelectAccept += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
classList->eventListMouseItemActivate += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
classList->eventListChangePosition += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
getWidget(mClassList, "ClassList");
mClassList->setScrollVisible(true);
mClassList->eventListSelectAccept += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
mClassList->eventListMouseItemActivate += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
mClassList->eventListChangePosition += MyGUI::newDelegate(this, &PickClassDialog::onSelectClass);
getWidget(classImage, "ClassImage");
getWidget(mClassImage, "ClassImage");
MyGUI::ButtonPtr backButton;
getWidget(backButton, "BackButton");
@ -148,14 +147,14 @@ void PickClassDialog::open()
void PickClassDialog::setClassId(const std::string &classId)
{
currentClassId = classId;
classList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = classList->getItemCount();
mCurrentClassId = classId;
mClassList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = mClassList->getItemCount();
for (size_t i = 0; i < count; ++i)
{
if (boost::iequals(*classList->getItemDataAt<std::string>(i), classId))
if (boost::iequals(*mClassList->getItemDataAt<std::string>(i), classId))
{
classList->setIndexSelected(i);
mClassList->setIndexSelected(i);
break;
}
}
@ -180,11 +179,11 @@ void PickClassDialog::onSelectClass(MyGUI::ListBox* _sender, size_t _index)
if (_index == MyGUI::ITEM_NONE)
return;
const std::string *classId = classList->getItemDataAt<std::string>(_index);
if (boost::iequals(currentClassId, *classId))
const std::string *classId = mClassList->getItemDataAt<std::string>(_index);
if (boost::iequals(mCurrentClassId, *classId))
return;
currentClassId = *classId;
mCurrentClassId = *classId;
updateStats();
}
@ -192,7 +191,7 @@ void PickClassDialog::onSelectClass(MyGUI::ListBox* _sender, size_t _index)
void PickClassDialog::updateClasses()
{
classList->removeAllItems();
mClassList->removeAllItems();
const ESMS::ESMStore &store = mWindowManager.getStore();
@ -207,19 +206,19 @@ void PickClassDialog::updateClasses()
continue;
const std::string &id = it->first;
classList->addItem(klass.name, id);
if (boost::iequals(id, currentClassId))
classList->setIndexSelected(index);
mClassList->addItem(klass.name, id);
if (boost::iequals(id, mCurrentClassId))
mClassList->setIndexSelected(index);
++index;
}
}
void PickClassDialog::updateStats()
{
if (currentClassId.empty())
if (mCurrentClassId.empty())
return;
const ESMS::ESMStore &store = mWindowManager.getStore();
const ESM::Class *klass = store.classes.search(currentClassId);
const ESM::Class *klass = store.classes.search(mCurrentClassId);
if (!klass)
return;
@ -231,23 +230,23 @@ void PickClassDialog::updateStats()
"sSpecializationStealth"
};
std::string specName = mWindowManager.getGameSettingString(specIds[specialization], specIds[specialization]);
specializationName->setCaption(specName);
ToolTips::createSpecializationToolTip(specializationName, specName, specialization);
mSpecializationName->setCaption(specName);
ToolTips::createSpecializationToolTip(mSpecializationName, specName, specialization);
favoriteAttribute[0]->setAttributeId(klass->data.attribute[0]);
favoriteAttribute[1]->setAttributeId(klass->data.attribute[1]);
ToolTips::createAttributeToolTip(favoriteAttribute[0], favoriteAttribute[0]->getAttributeId());
ToolTips::createAttributeToolTip(favoriteAttribute[1], favoriteAttribute[1]->getAttributeId());
mFavoriteAttribute[0]->setAttributeId(klass->data.attribute[0]);
mFavoriteAttribute[1]->setAttributeId(klass->data.attribute[1]);
ToolTips::createAttributeToolTip(mFavoriteAttribute[0], mFavoriteAttribute[0]->getAttributeId());
ToolTips::createAttributeToolTip(mFavoriteAttribute[1], mFavoriteAttribute[1]->getAttributeId());
for (int i = 0; i < 5; ++i)
{
minorSkill[i]->setSkillNumber(klass->data.skills[i][0]);
majorSkill[i]->setSkillNumber(klass->data.skills[i][1]);
ToolTips::createSkillToolTip(minorSkill[i], klass->data.skills[i][0]);
ToolTips::createSkillToolTip(majorSkill[i], klass->data.skills[i][1]);
mMinorSkill[i]->setSkillNumber(klass->data.skills[i][0]);
mMajorSkill[i]->setSkillNumber(klass->data.skills[i][1]);
ToolTips::createSkillToolTip(mMinorSkill[i], klass->data.skills[i][0]);
ToolTips::createSkillToolTip(mMajorSkill[i], klass->data.skills[i][1]);
}
classImage->setImageTexture(std::string("textures\\levelup\\") + currentClassId + ".dds");
mClassImage->setImageTexture(std::string("textures\\levelup\\") + mCurrentClassId + ".dds");
}
/* InfoBoxDialog */
@ -284,59 +283,59 @@ void InfoBoxDialog::layoutVertically(MyGUI::WidgetPtr widget, int margin)
InfoBoxDialog::InfoBoxDialog(WindowManager& parWindowManager)
: WindowBase("openmw_infobox.layout", parWindowManager)
, currentButton(-1)
, mCurrentButton(-1)
{
getWidget(textBox, "TextBox");
getWidget(text, "Text");
text->getSubWidgetText()->setWordWrap(true);
getWidget(buttonBar, "ButtonBar");
getWidget(mTextBox, "TextBox");
getWidget(mText, "Text");
mText->getSubWidgetText()->setWordWrap(true);
getWidget(mButtonBar, "ButtonBar");
center();
}
void InfoBoxDialog::setText(const std::string &str)
{
text->setCaption(str);
textBox->setVisible(!str.empty());
fitToText(text);
mText->setCaption(str);
mTextBox->setVisible(!str.empty());
fitToText(mText);
}
std::string InfoBoxDialog::getText() const
{
return text->getCaption();
return mText->getCaption();
}
void InfoBoxDialog::setButtons(ButtonList &buttons)
{
for (std::vector<MyGUI::ButtonPtr>::iterator it = this->buttons.begin(); it != this->buttons.end(); ++it)
for (std::vector<MyGUI::ButtonPtr>::iterator it = this->mButtons.begin(); it != this->mButtons.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
this->buttons.clear();
currentButton = -1;
this->mButtons.clear();
mCurrentButton = -1;
// TODO: The buttons should be generated from a template in the layout file, ie. cloning an existing widget
MyGUI::ButtonPtr button;
MyGUI::IntCoord coord = MyGUI::IntCoord(0, 0, buttonBar->getWidth(), 10);
MyGUI::IntCoord coord = MyGUI::IntCoord(0, 0, mButtonBar->getWidth(), 10);
ButtonList::const_iterator end = buttons.end();
for (ButtonList::const_iterator it = buttons.begin(); it != end; ++it)
{
const std::string &text = *it;
button = buttonBar->createWidget<MyGUI::Button>("MW_Button", coord, MyGUI::Align::Top | MyGUI::Align::HCenter, "");
button = mButtonBar->createWidget<MyGUI::Button>("MW_Button", coord, MyGUI::Align::Top | MyGUI::Align::HCenter, "");
button->getSubWidgetText()->setWordWrap(true);
button->setCaption(text);
fitToText(button);
button->eventMouseButtonClick += MyGUI::newDelegate(this, &InfoBoxDialog::onButtonClicked);
coord.top += button->getHeight();
this->buttons.push_back(button);
this->mButtons.push_back(button);
}
}
void InfoBoxDialog::open()
{
// Fix layout
layoutVertically(textBox, 4);
layoutVertically(buttonBar, 6);
layoutVertically(mTextBox, 4);
layoutVertically(mButtonBar, 6);
layoutVertically(mMainWidget, 4 + 6);
center();
@ -345,18 +344,18 @@ void InfoBoxDialog::open()
int InfoBoxDialog::getChosenButton() const
{
return currentButton;
return mCurrentButton;
}
void InfoBoxDialog::onButtonClicked(MyGUI::WidgetPtr _sender)
{
std::vector<MyGUI::ButtonPtr>::const_iterator end = buttons.end();
std::vector<MyGUI::ButtonPtr>::const_iterator end = mButtons.end();
int i = 0;
for (std::vector<MyGUI::ButtonPtr>::const_iterator it = buttons.begin(); it != end; ++it)
for (std::vector<MyGUI::ButtonPtr>::const_iterator it = mButtons.begin(); it != end; ++it)
{
if (*it == _sender)
{
currentButton = i;
mCurrentButton = i;
eventButtonSelected(i);
return;
}
@ -382,49 +381,49 @@ ClassChoiceDialog::ClassChoiceDialog(WindowManager& parWindowManager)
CreateClassDialog::CreateClassDialog(WindowManager& parWindowManager)
: WindowBase("openmw_chargen_create_class.layout", parWindowManager)
, specDialog(nullptr)
, attribDialog(nullptr)
, skillDialog(nullptr)
, descDialog(nullptr)
, mSpecDialog(nullptr)
, mAttribDialog(nullptr)
, mSkillDialog(nullptr)
, mDescDialog(nullptr)
{
// Centre dialog
center();
setText("SpecializationT", mWindowManager.getGameSettingString("sChooseClassMenu1", "Specialization"));
getWidget(specializationName, "SpecializationName");
specializationName->eventMouseButtonClick += MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationClicked);
getWidget(mSpecializationName, "SpecializationName");
mSpecializationName->eventMouseButtonClick += MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationClicked);
setText("FavoriteAttributesT", mWindowManager.getGameSettingString("sChooseClassMenu2", "Favorite Attributes:"));
getWidget(favoriteAttribute0, "FavoriteAttribute0");
getWidget(favoriteAttribute1, "FavoriteAttribute1");
favoriteAttribute0->setWindowManager(&mWindowManager);
favoriteAttribute1->setWindowManager(&mWindowManager);
favoriteAttribute0->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
favoriteAttribute1->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
getWidget(mFavoriteAttribute0, "FavoriteAttribute0");
getWidget(mFavoriteAttribute1, "FavoriteAttribute1");
mFavoriteAttribute0->setWindowManager(&mWindowManager);
mFavoriteAttribute1->setWindowManager(&mWindowManager);
mFavoriteAttribute0->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
mFavoriteAttribute1->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeClicked);
setText("MajorSkillT", mWindowManager.getGameSettingString("sSkillClassMajor", ""));
setText("MinorSkillT", mWindowManager.getGameSettingString("sSkillClassMinor", ""));
for(int i = 0; i < 5; i++)
{
char theIndex = '0'+i;
getWidget(majorSkill[i], std::string("MajorSkill").append(1, theIndex));
getWidget(minorSkill[i], std::string("MinorSkill").append(1, theIndex));
skills.push_back(majorSkill[i]);
skills.push_back(minorSkill[i]);
getWidget(mMajorSkill[i], std::string("MajorSkill").append(1, theIndex));
getWidget(mMinorSkill[i], std::string("MinorSkill").append(1, theIndex));
mSkills.push_back(mMajorSkill[i]);
mSkills.push_back(mMinorSkill[i]);
}
std::vector<Widgets::MWSkillPtr>::const_iterator end = skills.end();
for (std::vector<Widgets::MWSkillPtr>::const_iterator it = skills.begin(); it != end; ++it)
std::vector<Widgets::MWSkillPtr>::const_iterator end = mSkills.end();
for (std::vector<Widgets::MWSkillPtr>::const_iterator it = mSkills.begin(); it != end; ++it)
{
(*it)->setWindowManager(&mWindowManager);
(*it)->eventClicked += MyGUI::newDelegate(this, &CreateClassDialog::onSkillClicked);
}
setText("LabelT", mWindowManager.getGameSettingString("sName", ""));
getWidget(editName, "EditName");
getWidget(mEditName, "EditName");
// Make sure the edit box has focus
MyGUI::InputManager::getInstance().setKeyFocusWidget(editName);
MyGUI::InputManager::getInstance().setKeyFocusWidget(mEditName);
MyGUI::ButtonPtr descriptionButton;
getWidget(descriptionButton, "DescriptionButton");
@ -441,20 +440,20 @@ CreateClassDialog::CreateClassDialog(WindowManager& parWindowManager)
// Set default skills, attributes
favoriteAttribute0->setAttributeId(ESM::Attribute::Strength);
favoriteAttribute1->setAttributeId(ESM::Attribute::Agility);
mFavoriteAttribute0->setAttributeId(ESM::Attribute::Strength);
mFavoriteAttribute1->setAttributeId(ESM::Attribute::Agility);
majorSkill[0]->setSkillId(ESM::Skill::Block);
majorSkill[1]->setSkillId(ESM::Skill::Armorer);
majorSkill[2]->setSkillId(ESM::Skill::MediumArmor);
majorSkill[3]->setSkillId(ESM::Skill::HeavyArmor);
majorSkill[4]->setSkillId(ESM::Skill::BluntWeapon);
mMajorSkill[0]->setSkillId(ESM::Skill::Block);
mMajorSkill[1]->setSkillId(ESM::Skill::Armorer);
mMajorSkill[2]->setSkillId(ESM::Skill::MediumArmor);
mMajorSkill[3]->setSkillId(ESM::Skill::HeavyArmor);
mMajorSkill[4]->setSkillId(ESM::Skill::BluntWeapon);
minorSkill[0]->setSkillId(ESM::Skill::LongBlade);
minorSkill[1]->setSkillId(ESM::Skill::Axe);
minorSkill[2]->setSkillId(ESM::Skill::Spear);
minorSkill[3]->setSkillId(ESM::Skill::Athletics);
minorSkill[4]->setSkillId(ESM::Skill::Enchant);
mMinorSkill[0]->setSkillId(ESM::Skill::LongBlade);
mMinorSkill[1]->setSkillId(ESM::Skill::Axe);
mMinorSkill[2]->setSkillId(ESM::Skill::Spear);
mMinorSkill[3]->setSkillId(ESM::Skill::Athletics);
mMinorSkill[4]->setSkillId(ESM::Skill::Enchant);
setSpecialization(0);
update();
@ -462,44 +461,44 @@ CreateClassDialog::CreateClassDialog(WindowManager& parWindowManager)
CreateClassDialog::~CreateClassDialog()
{
delete specDialog;
delete attribDialog;
delete skillDialog;
delete descDialog;
delete mSpecDialog;
delete mAttribDialog;
delete mSkillDialog;
delete mDescDialog;
}
void CreateClassDialog::update()
{
for (int i = 0; i < 5; ++i)
{
ToolTips::createSkillToolTip(majorSkill[i], majorSkill[i]->getSkillId());
ToolTips::createSkillToolTip(minorSkill[i], minorSkill[i]->getSkillId());
ToolTips::createSkillToolTip(mMajorSkill[i], mMajorSkill[i]->getSkillId());
ToolTips::createSkillToolTip(mMinorSkill[i], mMinorSkill[i]->getSkillId());
}
ToolTips::createAttributeToolTip(favoriteAttribute0, favoriteAttribute0->getAttributeId());
ToolTips::createAttributeToolTip(favoriteAttribute1, favoriteAttribute1->getAttributeId());
ToolTips::createAttributeToolTip(mFavoriteAttribute0, mFavoriteAttribute0->getAttributeId());
ToolTips::createAttributeToolTip(mFavoriteAttribute1, mFavoriteAttribute1->getAttributeId());
}
std::string CreateClassDialog::getName() const
{
return editName->getOnlyText();
return mEditName->getOnlyText();
}
std::string CreateClassDialog::getDescription() const
{
return description;
return mDescription;
}
ESM::Class::Specialization CreateClassDialog::getSpecializationId() const
{
return specializationId;
return mSpecializationId;
}
std::vector<int> CreateClassDialog::getFavoriteAttributes() const
{
std::vector<int> v;
v.push_back(favoriteAttribute0->getAttributeId());
v.push_back(favoriteAttribute1->getAttributeId());
v.push_back(mFavoriteAttribute0->getAttributeId());
v.push_back(mFavoriteAttribute1->getAttributeId());
return v;
}
@ -508,7 +507,7 @@ std::vector<ESM::Skill::SkillEnum> CreateClassDialog::getMajorSkills() const
std::vector<ESM::Skill::SkillEnum> v;
for(int i = 0; i < 5; i++)
{
v.push_back(majorSkill[i]->getSkillId());
v.push_back(mMajorSkill[i]->getSkillId());
}
return v;
}
@ -518,7 +517,7 @@ std::vector<ESM::Skill::SkillEnum> CreateClassDialog::getMinorSkills() const
std::vector<ESM::Skill::SkillEnum> v;
for(int i=0; i < 5; i++)
{
v.push_back(minorSkill[i]->getSkillId());
v.push_back(mMinorSkill[i]->getSkillId());
}
return v;
}
@ -557,108 +556,108 @@ void CreateClassDialog::open()
void CreateClassDialog::onDialogCancel()
{
if (specDialog)
if (mSpecDialog)
{
mWindowManager.removeDialog(specDialog);
specDialog = 0;
mWindowManager.removeDialog(mSpecDialog);
mSpecDialog = 0;
}
if (attribDialog)
if (mAttribDialog)
{
mWindowManager.removeDialog(attribDialog);
attribDialog = 0;
mWindowManager.removeDialog(mAttribDialog);
mAttribDialog = 0;
}
if (skillDialog)
if (mSkillDialog)
{
mWindowManager.removeDialog(skillDialog);
skillDialog = 0;
mWindowManager.removeDialog(mSkillDialog);
mSkillDialog = 0;
}
if (descDialog)
if (mDescDialog)
{
mWindowManager.removeDialog(descDialog);
descDialog = 0;
mWindowManager.removeDialog(mDescDialog);
mDescDialog = 0;
}
}
void CreateClassDialog::onSpecializationClicked(MyGUI::WidgetPtr _sender)
{
delete specDialog;
specDialog = new SelectSpecializationDialog(mWindowManager);
specDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
specDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationSelected);
specDialog->setVisible(true);
delete mSpecDialog;
mSpecDialog = new SelectSpecializationDialog(mWindowManager);
mSpecDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
mSpecDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSpecializationSelected);
mSpecDialog->setVisible(true);
}
void CreateClassDialog::onSpecializationSelected()
{
specializationId = specDialog->getSpecializationId();
setSpecialization(specializationId);
mSpecializationId = mSpecDialog->getSpecializationId();
setSpecialization(mSpecializationId);
mWindowManager.removeDialog(specDialog);
specDialog = 0;
mWindowManager.removeDialog(mSpecDialog);
mSpecDialog = 0;
}
void CreateClassDialog::setSpecialization(int id)
{
specializationId = (ESM::Class::Specialization) id;
mSpecializationId = (ESM::Class::Specialization) id;
static const char *specIds[3] = {
"sSpecializationCombat",
"sSpecializationMagic",
"sSpecializationStealth"
};
std::string specName = mWindowManager.getGameSettingString(specIds[specializationId], specIds[specializationId]);
specializationName->setCaption(specName);
ToolTips::createSpecializationToolTip(specializationName, specName, specializationId);
std::string specName = mWindowManager.getGameSettingString(specIds[mSpecializationId], specIds[mSpecializationId]);
mSpecializationName->setCaption(specName);
ToolTips::createSpecializationToolTip(mSpecializationName, specName, mSpecializationId);
}
void CreateClassDialog::onAttributeClicked(Widgets::MWAttributePtr _sender)
{
delete attribDialog;
attribDialog = new SelectAttributeDialog(mWindowManager);
attribDialog->setAffectedWidget(_sender);
attribDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
attribDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeSelected);
attribDialog->setVisible(true);
delete mAttribDialog;
mAttribDialog = new SelectAttributeDialog(mWindowManager);
mAttribDialog->setAffectedWidget(_sender);
mAttribDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
mAttribDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onAttributeSelected);
mAttribDialog->setVisible(true);
}
void CreateClassDialog::onAttributeSelected()
{
ESM::Attribute::AttributeID id = attribDialog->getAttributeId();
Widgets::MWAttributePtr attribute = attribDialog->getAffectedWidget();
if (attribute == favoriteAttribute0)
ESM::Attribute::AttributeID id = mAttribDialog->getAttributeId();
Widgets::MWAttributePtr attribute = mAttribDialog->getAffectedWidget();
if (attribute == mFavoriteAttribute0)
{
if (favoriteAttribute1->getAttributeId() == id)
favoriteAttribute1->setAttributeId(favoriteAttribute0->getAttributeId());
if (mFavoriteAttribute1->getAttributeId() == id)
mFavoriteAttribute1->setAttributeId(mFavoriteAttribute0->getAttributeId());
}
else if (attribute == favoriteAttribute1)
else if (attribute == mFavoriteAttribute1)
{
if (favoriteAttribute0->getAttributeId() == id)
favoriteAttribute0->setAttributeId(favoriteAttribute1->getAttributeId());
if (mFavoriteAttribute0->getAttributeId() == id)
mFavoriteAttribute0->setAttributeId(mFavoriteAttribute1->getAttributeId());
}
attribute->setAttributeId(id);
mWindowManager.removeDialog(attribDialog);
attribDialog = 0;
mWindowManager.removeDialog(mAttribDialog);
mAttribDialog = 0;
update();
}
void CreateClassDialog::onSkillClicked(Widgets::MWSkillPtr _sender)
{
delete skillDialog;
skillDialog = new SelectSkillDialog(mWindowManager);
skillDialog->setAffectedWidget(_sender);
skillDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
skillDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSkillSelected);
skillDialog->setVisible(true);
delete mSkillDialog;
mSkillDialog = new SelectSkillDialog(mWindowManager);
mSkillDialog->setAffectedWidget(_sender);
mSkillDialog->eventCancel += MyGUI::newDelegate(this, &CreateClassDialog::onDialogCancel);
mSkillDialog->eventItemSelected += MyGUI::newDelegate(this, &CreateClassDialog::onSkillSelected);
mSkillDialog->setVisible(true);
}
void CreateClassDialog::onSkillSelected()
{
ESM::Skill::SkillEnum id = skillDialog->getSkillId();
Widgets::MWSkillPtr skill = skillDialog->getAffectedWidget();
ESM::Skill::SkillEnum id = mSkillDialog->getSkillId();
Widgets::MWSkillPtr skill = mSkillDialog->getAffectedWidget();
// Avoid duplicate skills by swapping any skill field that matches the selected one
std::vector<Widgets::MWSkillPtr>::const_iterator end = skills.end();
for (std::vector<Widgets::MWSkillPtr>::const_iterator it = skills.begin(); it != end; ++it)
std::vector<Widgets::MWSkillPtr>::const_iterator end = mSkills.end();
for (std::vector<Widgets::MWSkillPtr>::const_iterator it = mSkills.begin(); it != end; ++it)
{
if (*it == skill)
continue;
@ -669,25 +668,25 @@ void CreateClassDialog::onSkillSelected()
}
}
skill->setSkillId(skillDialog->getSkillId());
mWindowManager.removeDialog(skillDialog);
skillDialog = 0;
skill->setSkillId(mSkillDialog->getSkillId());
mWindowManager.removeDialog(mSkillDialog);
mSkillDialog = 0;
update();
}
void CreateClassDialog::onDescriptionClicked(MyGUI::Widget* _sender)
{
descDialog = new DescriptionDialog(mWindowManager);
descDialog->setTextInput(description);
descDialog->eventDone += MyGUI::newDelegate(this, &CreateClassDialog::onDescriptionEntered);
descDialog->setVisible(true);
mDescDialog = new DescriptionDialog(mWindowManager);
mDescDialog->setTextInput(mDescription);
mDescDialog->eventDone += MyGUI::newDelegate(this, &CreateClassDialog::onDescriptionEntered);
mDescDialog->setVisible(true);
}
void CreateClassDialog::onDescriptionEntered(WindowBase* parWindow)
{
description = descDialog->getTextInput();
mWindowManager.removeDialog(descDialog);
descDialog = 0;
mDescription = mDescDialog->getTextInput();
mWindowManager.removeDialog(mDescDialog);
mDescDialog = 0;
}
void CreateClassDialog::onOkClicked(MyGUI::Widget* _sender)
@ -710,24 +709,24 @@ SelectSpecializationDialog::SelectSpecializationDialog(WindowManager& parWindowM
setText("LabelT", mWindowManager.getGameSettingString("sSpecializationMenu1", ""));
getWidget(specialization0, "Specialization0");
getWidget(specialization1, "Specialization1");
getWidget(specialization2, "Specialization2");
getWidget(mSpecialization0, "Specialization0");
getWidget(mSpecialization1, "Specialization1");
getWidget(mSpecialization2, "Specialization2");
std::string combat = mWindowManager.getGameSettingString(ESM::Class::gmstSpecializationIds[ESM::Class::Combat], "");
std::string magic = mWindowManager.getGameSettingString(ESM::Class::gmstSpecializationIds[ESM::Class::Magic], "");
std::string stealth = mWindowManager.getGameSettingString(ESM::Class::gmstSpecializationIds[ESM::Class::Stealth], "");
specialization0->setCaption(combat);
specialization0->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
specialization1->setCaption(magic);
specialization1->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
specialization2->setCaption(stealth);
specialization2->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
specializationId = ESM::Class::Combat;
mSpecialization0->setCaption(combat);
mSpecialization0->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
mSpecialization1->setCaption(magic);
mSpecialization1->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
mSpecialization2->setCaption(stealth);
mSpecialization2->eventMouseButtonClick += MyGUI::newDelegate(this, &SelectSpecializationDialog::onSpecializationClicked);
mSpecializationId = ESM::Class::Combat;
ToolTips::createSpecializationToolTip(specialization0, combat, ESM::Class::Combat);
ToolTips::createSpecializationToolTip(specialization1, magic, ESM::Class::Magic);
ToolTips::createSpecializationToolTip(specialization2, stealth, ESM::Class::Stealth);
ToolTips::createSpecializationToolTip(mSpecialization0, combat, ESM::Class::Combat);
ToolTips::createSpecializationToolTip(mSpecialization1, magic, ESM::Class::Magic);
ToolTips::createSpecializationToolTip(mSpecialization2, stealth, ESM::Class::Stealth);
MyGUI::ButtonPtr cancelButton;
getWidget(cancelButton, "CancelButton");
@ -748,12 +747,12 @@ SelectSpecializationDialog::~SelectSpecializationDialog()
void SelectSpecializationDialog::onSpecializationClicked(MyGUI::WidgetPtr _sender)
{
if (_sender == specialization0)
specializationId = ESM::Class::Combat;
else if (_sender == specialization1)
specializationId = ESM::Class::Magic;
else if (_sender == specialization2)
specializationId = ESM::Class::Stealth;
if (_sender == mSpecialization0)
mSpecializationId = ESM::Class::Combat;
else if (_sender == mSpecialization1)
mSpecializationId = ESM::Class::Magic;
else if (_sender == mSpecialization2)
mSpecializationId = ESM::Class::Stealth;
else
return;
@ -807,7 +806,7 @@ SelectAttributeDialog::~SelectAttributeDialog()
void SelectAttributeDialog::onAttributeClicked(Widgets::MWAttributePtr _sender)
{
// TODO: Change MWAttribute to set and get AttributeID enum instead of int
attributeId = static_cast<ESM::Attribute::AttributeID>(_sender->getAttributeId());
mAttributeId = static_cast<ESM::Attribute::AttributeID>(_sender->getAttributeId());
eventItemSelected();
}
@ -833,44 +832,44 @@ SelectSkillDialog::SelectSkillDialog(WindowManager& parWindowManager)
for(int i = 0; i < 9; i++)
{
char theIndex = '0'+i;
getWidget(combatSkill[i], std::string("CombatSkill").append(1, theIndex));
getWidget(magicSkill[i], std::string("MagicSkill").append(1, theIndex));
getWidget(stealthSkill[i], std::string("StealthSkill").append(1, theIndex));
}
struct {Widgets::MWSkillPtr widget; ESM::Skill::SkillEnum skillId;} skills[3][9] = {
{
{combatSkill[0], ESM::Skill::Block},
{combatSkill[1], ESM::Skill::Armorer},
{combatSkill[2], ESM::Skill::MediumArmor},
{combatSkill[3], ESM::Skill::HeavyArmor},
{combatSkill[4], ESM::Skill::BluntWeapon},
{combatSkill[5], ESM::Skill::LongBlade},
{combatSkill[6], ESM::Skill::Axe},
{combatSkill[7], ESM::Skill::Spear},
{combatSkill[8], ESM::Skill::Athletics}
getWidget(mCombatSkill[i], std::string("CombatSkill").append(1, theIndex));
getWidget(mMagicSkill[i], std::string("MagicSkill").append(1, theIndex));
getWidget(mStealthSkill[i], std::string("StealthSkill").append(1, theIndex));
}
struct {Widgets::MWSkillPtr widget; ESM::Skill::SkillEnum skillId;} mSkills[3][9] = {
{
{mCombatSkill[0], ESM::Skill::Block},
{mCombatSkill[1], ESM::Skill::Armorer},
{mCombatSkill[2], ESM::Skill::MediumArmor},
{mCombatSkill[3], ESM::Skill::HeavyArmor},
{mCombatSkill[4], ESM::Skill::BluntWeapon},
{mCombatSkill[5], ESM::Skill::LongBlade},
{mCombatSkill[6], ESM::Skill::Axe},
{mCombatSkill[7], ESM::Skill::Spear},
{mCombatSkill[8], ESM::Skill::Athletics}
},
{
{magicSkill[0], ESM::Skill::Enchant},
{magicSkill[1], ESM::Skill::Destruction},
{magicSkill[2], ESM::Skill::Alteration},
{magicSkill[3], ESM::Skill::Illusion},
{magicSkill[4], ESM::Skill::Conjuration},
{magicSkill[5], ESM::Skill::Mysticism},
{magicSkill[6], ESM::Skill::Restoration},
{magicSkill[7], ESM::Skill::Alchemy},
{magicSkill[8], ESM::Skill::Unarmored}
{mMagicSkill[0], ESM::Skill::Enchant},
{mMagicSkill[1], ESM::Skill::Destruction},
{mMagicSkill[2], ESM::Skill::Alteration},
{mMagicSkill[3], ESM::Skill::Illusion},
{mMagicSkill[4], ESM::Skill::Conjuration},
{mMagicSkill[5], ESM::Skill::Mysticism},
{mMagicSkill[6], ESM::Skill::Restoration},
{mMagicSkill[7], ESM::Skill::Alchemy},
{mMagicSkill[8], ESM::Skill::Unarmored}
},
{
{stealthSkill[0], ESM::Skill::Security},
{stealthSkill[1], ESM::Skill::Sneak},
{stealthSkill[2], ESM::Skill::Acrobatics},
{stealthSkill[3], ESM::Skill::LightArmor},
{stealthSkill[4], ESM::Skill::ShortBlade},
{stealthSkill[5] ,ESM::Skill::Marksman},
{stealthSkill[6] ,ESM::Skill::Mercantile},
{stealthSkill[7] ,ESM::Skill::Speechcraft},
{stealthSkill[8] ,ESM::Skill::HandToHand}
{mStealthSkill[0], ESM::Skill::Security},
{mStealthSkill[1], ESM::Skill::Sneak},
{mStealthSkill[2], ESM::Skill::Acrobatics},
{mStealthSkill[3], ESM::Skill::LightArmor},
{mStealthSkill[4], ESM::Skill::ShortBlade},
{mStealthSkill[5] ,ESM::Skill::Marksman},
{mStealthSkill[6] ,ESM::Skill::Mercantile},
{mStealthSkill[7] ,ESM::Skill::Speechcraft},
{mStealthSkill[8] ,ESM::Skill::HandToHand}
}
};
@ -878,10 +877,10 @@ SelectSkillDialog::SelectSkillDialog(WindowManager& parWindowManager)
{
for (int i = 0; i < 9; ++i)
{
skills[spec][i].widget->setWindowManager(&mWindowManager);
skills[spec][i].widget->setSkillId(skills[spec][i].skillId);
skills[spec][i].widget->eventClicked += MyGUI::newDelegate(this, &SelectSkillDialog::onSkillClicked);
ToolTips::createSkillToolTip(skills[spec][i].widget, skills[spec][i].widget->getSkillId());
mSkills[spec][i].widget->setWindowManager(&mWindowManager);
mSkills[spec][i].widget->setSkillId(mSkills[spec][i].skillId);
mSkills[spec][i].widget->eventClicked += MyGUI::newDelegate(this, &SelectSkillDialog::onSkillClicked);
ToolTips::createSkillToolTip(mSkills[spec][i].widget, mSkills[spec][i].widget->getSkillId());
}
}
@ -904,7 +903,7 @@ SelectSkillDialog::~SelectSkillDialog()
void SelectSkillDialog::onSkillClicked(Widgets::MWSkillPtr _sender)
{
skillId = _sender->getSkillId();
mSkillId = _sender->getSkillId();
eventItemSelected();
}
@ -921,7 +920,7 @@ DescriptionDialog::DescriptionDialog(WindowManager& parWindowManager)
// Centre dialog
center();
getWidget(textEdit, "TextEdit");
getWidget(mTextEdit, "TextEdit");
MyGUI::ButtonPtr okButton;
getWidget(okButton, "OKButton");
@ -931,7 +930,7 @@ DescriptionDialog::DescriptionDialog(WindowManager& parWindowManager)
okButton->setCoord(234 - buttonWidth, 214, buttonWidth, 24);
// Make sure the edit box has focus
MyGUI::InputManager::getInstance().setKeyFocusWidget(textEdit);
MyGUI::InputManager::getInstance().setKeyFocusWidget(mTextEdit);
MyGUI::InputManager::getInstance().addWidgetModal(mMainWidget);
}

98
apps/openmw/mwgui/class.hpp
Unescape Escape View File

@ -45,11 +45,11 @@ namespace MWGui
void fitToText(MyGUI::TextBox* widget);
void layoutVertically(MyGUI::WidgetPtr widget, int margin);
int currentButton;
MyGUI::WidgetPtr textBox;
MyGUI::TextBox* text;
MyGUI::WidgetPtr buttonBar;
std::vector<MyGUI::ButtonPtr> buttons;
int mCurrentButton;
MyGUI::WidgetPtr mTextBox;
MyGUI::TextBox* mText;
MyGUI::WidgetPtr mButtonBar;
std::vector<MyGUI::ButtonPtr> mButtons;
};
// Lets the player choose between 3 ways of creating a class
@ -90,10 +90,10 @@ namespace MWGui
void onBackClicked(MyGUI::Widget* _sender);
private:
MyGUI::ImageBox* classImage;
MyGUI::TextBox* className;
MyGUI::ImageBox* mClassImage;
MyGUI::TextBox* mClassName;
std::string currentClassId;
std::string mCurrentClassId;
};
class PickClassDialog : public WindowBase
@ -101,7 +101,7 @@ namespace MWGui
public:
PickClassDialog(WindowManager& parWindowManager);
const std::string &getClassId() const { return currentClassId; }
const std::string &getClassId() const { return mCurrentClassId; }
void setClassId(const std::string &classId);
void setNextButtonShow(bool shown);
@ -125,14 +125,14 @@ namespace MWGui
void updateClasses();
void updateStats();
MyGUI::ImageBox* classImage;
MyGUI::ListBox* classList;
MyGUI::TextBox* specializationName;
Widgets::MWAttributePtr favoriteAttribute[2];
Widgets::MWSkillPtr majorSkill[5];
Widgets::MWSkillPtr minorSkill[5];
MyGUI::ImageBox* mClassImage;
MyGUI::ListBox* mClassList;
MyGUI::TextBox* mSpecializationName;
Widgets::MWAttributePtr mFavoriteAttribute[2];
Widgets::MWSkillPtr mMajorSkill[5];
Widgets::MWSkillPtr mMinorSkill[5];
std::string currentClassId;
std::string mCurrentClassId;
};
class SelectSpecializationDialog : public WindowBase
@ -141,7 +141,7 @@ namespace MWGui
SelectSpecializationDialog(WindowManager& parWindowManager);
~SelectSpecializationDialog();
ESM::Class::Specialization getSpecializationId() const { return specializationId; }
ESM::Class::Specialization getSpecializationId() const { return mSpecializationId; }
// Events
typedef delegates::CMultiDelegate0 EventHandle_Void;
@ -161,9 +161,9 @@ namespace MWGui
void onCancelClicked(MyGUI::Widget* _sender);
private:
MyGUI::TextBox *specialization0, *specialization1, *specialization2;
MyGUI::TextBox *mSpecialization0, *mSpecialization1, *mSpecialization2;
ESM::Class::Specialization specializationId;
ESM::Class::Specialization mSpecializationId;
};
class SelectAttributeDialog : public WindowBase
@ -172,9 +172,9 @@ namespace MWGui
SelectAttributeDialog(WindowManager& parWindowManager);
~SelectAttributeDialog();
ESM::Attribute::AttributeID getAttributeId() const { return attributeId; }
Widgets::MWAttributePtr getAffectedWidget() const { return affectedWidget; }
void setAffectedWidget(Widgets::MWAttributePtr widget) { affectedWidget = widget; }
ESM::Attribute::AttributeID getAttributeId() const { return mAttributeId; }
Widgets::MWAttributePtr getAffectedWidget() const { return mAffectedWidget; }
void setAffectedWidget(Widgets::MWAttributePtr widget) { mAffectedWidget = widget; }
// Events
typedef delegates::CMultiDelegate0 EventHandle_Void;
@ -194,9 +194,9 @@ namespace MWGui
void onCancelClicked(MyGUI::Widget* _sender);
private:
Widgets::MWAttributePtr affectedWidget;
Widgets::MWAttributePtr mAffectedWidget;
ESM::Attribute::AttributeID attributeId;
ESM::Attribute::AttributeID mAttributeId;
};
class SelectSkillDialog : public WindowBase
@ -205,9 +205,9 @@ namespace MWGui
SelectSkillDialog(WindowManager& parWindowManager);
~SelectSkillDialog();
ESM::Skill::SkillEnum getSkillId() const { return skillId; }
Widgets::MWSkillPtr getAffectedWidget() const { return affectedWidget; }
void setAffectedWidget(Widgets::MWSkillPtr widget) { affectedWidget = widget; }
ESM::Skill::SkillEnum getSkillId() const { return mSkillId; }
Widgets::MWSkillPtr getAffectedWidget() const { return mAffectedWidget; }
void setAffectedWidget(Widgets::MWSkillPtr widget) { mAffectedWidget = widget; }
// Events
typedef delegates::CMultiDelegate0 EventHandle_Void;
@ -227,12 +227,12 @@ namespace MWGui
void onCancelClicked(MyGUI::Widget* _sender);
private:
Widgets::MWSkillPtr combatSkill[9];
Widgets::MWSkillPtr magicSkill[9];
Widgets::MWSkillPtr stealthSkill[9];
Widgets::MWSkillPtr affectedWidget;
Widgets::MWSkillPtr mCombatSkill[9];
Widgets::MWSkillPtr mMagicSkill[9];
Widgets::MWSkillPtr mStealthSkill[9];
Widgets::MWSkillPtr mAffectedWidget;
ESM::Skill::SkillEnum skillId;
ESM::Skill::SkillEnum mSkillId;
};
class DescriptionDialog : public WindowBase
@ -241,14 +241,14 @@ namespace MWGui
DescriptionDialog(WindowManager& parWindowManager);
~DescriptionDialog();
std::string getTextInput() const { return textEdit ? textEdit->getOnlyText() : ""; }
void setTextInput(const std::string &text) { if (textEdit) textEdit->setOnlyText(text); }
std::string getTextInput() const { return mTextEdit ? mTextEdit->getOnlyText() : ""; }
void setTextInput(const std::string &text) { if (mTextEdit) mTextEdit->setOnlyText(text); }
protected:
void onOkClicked(MyGUI::Widget* _sender);
private:
MyGUI::EditPtr textEdit;
MyGUI::EditPtr mTextEdit;
};
class CreateClassDialog : public WindowBase
@ -294,20 +294,20 @@ namespace MWGui
void update();
private:
MyGUI::EditPtr editName;
MyGUI::TextBox* specializationName;
Widgets::MWAttributePtr favoriteAttribute0, favoriteAttribute1;
Widgets::MWSkillPtr majorSkill[5];
Widgets::MWSkillPtr minorSkill[5];
std::vector<Widgets::MWSkillPtr> skills;
std::string description;
SelectSpecializationDialog *specDialog;
SelectAttributeDialog *attribDialog;
SelectSkillDialog *skillDialog;
DescriptionDialog *descDialog;
ESM::Class::Specialization specializationId;
MyGUI::EditPtr mEditName;
MyGUI::TextBox* mSpecializationName;
Widgets::MWAttributePtr mFavoriteAttribute0, mFavoriteAttribute1;
Widgets::MWSkillPtr mMajorSkill[5];
Widgets::MWSkillPtr mMinorSkill[5];
std::vector<Widgets::MWSkillPtr> mSkills;
std::string mDescription;
SelectSpecializationDialog *mSpecDialog;
SelectAttributeDialog *mAttribDialog;
SelectSkillDialog *mSkillDialog;
DescriptionDialog *mDescDialog;
ESM::Class::Specialization mSpecializationId;
};
}
#endif

81
apps/openmw/mwgui/dialogue.cpp
Unescape Escape View File

@ -1,6 +1,5 @@
#include "dialogue.hpp"
#include <assert.h>
#include <iostream>
#include <iterator>
@ -51,9 +50,9 @@ DialogueWindow::DialogueWindow(WindowManager& parWindowManager)
center();
//History view
getWidget(history, "History");
history->setOverflowToTheLeft(true);
history->setMaxTextLength(1000000);
getWidget(mHistory, "History");
mHistory->setOverflowToTheLeft(true);
mHistory->setMaxTextLength(1000000);
Widget* eventbox;
//An EditBox cannot receive mouse click events, so we use an
@ -63,36 +62,36 @@ DialogueWindow::DialogueWindow(WindowManager& parWindowManager)
eventbox->eventMouseWheel += MyGUI::newDelegate(this, &DialogueWindow::onMouseWheel);
//Topics list
getWidget(topicsList, "TopicsList");
topicsList->eventItemSelected += MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
getWidget(mTopicsList, "TopicsList");
mTopicsList->eventItemSelected += MyGUI::newDelegate(this, &DialogueWindow::onSelectTopic);
MyGUI::ButtonPtr byeButton;
getWidget(byeButton, "ByeButton");
byeButton->eventMouseButtonClick += MyGUI::newDelegate(this, &DialogueWindow::onByeClicked);
getWidget(pDispositionBar, "Disposition");
getWidget(pDispositionText,"DispositionText");
getWidget(mDispositionBar, "Disposition");
getWidget(mDispositionText,"DispositionText");
static_cast<MyGUI::Window*>(mMainWidget)->eventWindowChangeCoord += MyGUI::newDelegate(this, &DialogueWindow::onWindowResize);
}
void DialogueWindow::onHistoryClicked(MyGUI::Widget* _sender)
{
ISubWidgetText* t = history->getClient()->getSubWidgetText();
ISubWidgetText* t = mHistory->getClient()->getSubWidgetText();
if(t == nullptr)
return;
const IntPoint& lastPressed = InputManager::getInstance().getLastPressedPosition(MyGUI::MouseButton::Left);
size_t cursorPosition = t->getCursorPosition(lastPressed);
MyGUI::UString color = history->getColorAtPos(cursorPosition);
MyGUI::UString color = mHistory->getColorAtPos(cursorPosition);
if (!mEnabled && color == "#572D21")
MWBase::Environment::get().getDialogueManager()->goodbyeSelected();
if(color != "#B29154")
{
UString key = history->getColorTextAt(cursorPosition);
UString key = mHistory->getColorTextAt(cursorPosition);
if(color == "#686EBA") MWBase::Environment::get().getDialogueManager()->keywordSelected(lower_string(key));
if(color == "#572D21") MWBase::Environment::get().getDialogueManager()->questionAnswered(lower_string(key));
@ -101,15 +100,15 @@ void DialogueWindow::onHistoryClicked(MyGUI::Widget* _sender)
void DialogueWindow::onWindowResize(MyGUI::Window* _sender)
{
topicsList->adjustSize();
mTopicsList->adjustSize();
}
void DialogueWindow::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
if (history->getVScrollPosition() - _rel*0.3 < 0)
history->setVScrollPosition(0);
if (mHistory->getVScrollPosition() - _rel*0.3 < 0)
mHistory->setVScrollPosition(0);
else
history->setVScrollPosition(history->getVScrollPosition() - _rel*0.3);
mHistory->setVScrollPosition(mHistory->getVScrollPosition() - _rel*0.3);
}
void DialogueWindow::onByeClicked(MyGUI::Widget* _sender)
@ -136,40 +135,40 @@ void DialogueWindow::startDialogue(MWWorld::Ptr actor, std::string npcName)
{
mEnabled = true;
mPtr = actor;
topicsList->setEnabled(true);
mTopicsList->setEnabled(true);
setTitle(npcName);
topicsList->clear();
history->eraseText(0,history->getTextLength());
mTopicsList->clear();
mHistory->eraseText(0,mHistory->getTextLength());
updateOptions();
}
void DialogueWindow::setKeywords(std::list<std::string> keyWords)
{
topicsList->clear();
mTopicsList->clear();
bool anyService = mShowTrade;
if (mShowTrade)
topicsList->addItem(MWBase::Environment::get().getWorld()->getStore().gameSettings.search("sBarter")->str);
mTopicsList->addItem(MWBase::Environment::get().getWorld()->getStore().gameSettings.search("sBarter")->str);
if (anyService)
topicsList->addSeparator();
mTopicsList->addSeparator();
for(std::list<std::string>::iterator it = keyWords.begin(); it != keyWords.end(); ++it)
{
topicsList->addItem(*it);
mTopicsList->addItem(*it);
}
topicsList->adjustSize();
mTopicsList->adjustSize();
}
void DialogueWindow::removeKeyword(std::string keyWord)
{
if(topicsList->hasItem(keyWord))
if(mTopicsList->hasItem(keyWord))
{
topicsList->removeItem(keyWord);
mTopicsList->removeItem(keyWord);
}
topicsList->adjustSize();
mTopicsList->adjustSize();
}
void addColorInString(std::string& str, const std::string& keyword,std::string color1, std::string color2)
@ -206,9 +205,9 @@ void addColorInString(std::string& str, const std::string& keyword,std::string c
std::string DialogueWindow::parseText(std::string text)
{
bool separatorReached = false; // only parse topics that are below the separator (this prevents actions like "Barter" that are not topics from getting blue-colored)
for(unsigned int i = 0;i<topicsList->getItemCount();i++)
for(unsigned int i = 0;i<mTopicsList->getItemCount();i++)
{
std::string keyWord = topicsList->getItemNameAt(i);
std::string keyWord = mTopicsList->getItemNameAt(i);
if (separatorReached && keyWord != "")
addColorInString(text,keyWord,"#686EBA","#B29154");
else
@ -219,7 +218,7 @@ std::string DialogueWindow::parseText(std::string text)
void DialogueWindow::addText(std::string text)
{
history->addDialogText("#B29154"+parseText(text)+"#B29154");
mHistory->addDialogText("#B29154"+parseText(text)+"#B29154");
}
void DialogueWindow::addTitle(std::string text)
@ -227,37 +226,37 @@ void DialogueWindow::addTitle(std::string text)
// This is called from the dialogue manager, so text is
// case-smashed - thus we have to retrieve the correct case
// of the text through the topic list.
for (size_t i=0; i<topicsList->getItemCount(); ++i)
for (size_t i=0; i<mTopicsList->getItemCount(); ++i)
{
std::string item = topicsList->getItemNameAt(i);
std::string item = mTopicsList->getItemNameAt(i);
if (lower_string(item) == text)
text = item;
}
history->addDialogHeading(text);
mHistory->addDialogHeading(text);
}
void DialogueWindow::askQuestion(std::string question)
{
history->addDialogText("#572D21"+question+"#B29154"+" ");
mHistory->addDialogText("#572D21"+question+"#B29154"+" ");
}
void DialogueWindow::updateOptions()
{
//Clear the list of topics
topicsList->clear();
history->eraseText(0,history->getTextLength());
mTopicsList->clear();
mHistory->eraseText(0, mHistory->getTextLength());
pDispositionBar->setProgressRange(100);
pDispositionBar->setProgressPosition(40);
pDispositionText->eraseText(0,pDispositionText->getTextLength());
pDispositionText->addText("#B29154"+std::string("40/100")+"#B29154");
mDispositionBar->setProgressRange(100);
mDispositionBar->setProgressPosition(40);
mDispositionText->eraseText(0, mDispositionText->getTextLength());
mDispositionText->addText("#B29154"+std::string("40/100")+"#B29154");
}
void DialogueWindow::goodbye()
{
history->addDialogText("\n#572D21" + MWBase::Environment::get().getWorld()->getStore().gameSettings.search("sGoodbye")->str);
topicsList->setEnabled(false);
mHistory->addDialogText("\n#572D21" + MWBase::Environment::get().getWorld()->getStore().gameSettings.search("sGoodbye")->str);
mTopicsList->setEnabled(false);
mEnabled = false;
}

8
apps/openmw/mwgui/dialogue.hpp
Unescape Escape View File

@ -73,10 +73,10 @@ namespace MWGui
bool mEnabled;
DialogueHistory* history;
Widgets::MWList* topicsList;
MyGUI::ProgressPtr pDispositionBar;
MyGUI::EditPtr pDispositionText;
DialogueHistory* mHistory;
Widgets::MWList* mTopicsList;
MyGUI::ProgressPtr mDispositionBar;
MyGUI::EditPtr mDispositionText;
};
}
#endif

1
apps/openmw/mwgui/dialogue_history.cpp
Unescape Escape View File

@ -3,7 +3,6 @@
#include "widgets.hpp"
#include "components/esm_store/store.hpp"
#include <assert.h>
#include <iostream>
#include <iterator>

172
apps/openmw/mwgui/hud.cpp
Unescape Escape View File

@ -28,24 +28,24 @@ HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
, health(NULL)
, magicka(NULL)
, stamina(NULL)
, weapImage(NULL)
, spellImage(NULL)
, weapStatus(NULL)
, spellStatus(NULL)
, effectBox(NULL)
, effect1(NULL)
, minimap(NULL)
, compass(NULL)
, crosshair(NULL)
, mWeapImage(NULL)
, mSpellImage(NULL)
, mWeapStatus(NULL)
, mSpellStatus(NULL)
, mEffectBox(NULL)
, mEffect1(NULL)
, mMinimap(NULL)
, mCompass(NULL)
, mCrosshair(NULL)
, fpsbox(NULL)
, fpscounter(NULL)
, trianglecounter(NULL)
, batchcounter(NULL)
, hmsBaseLeft(0)
, weapBoxBaseLeft(0)
, spellBoxBaseLeft(0)
, effectBoxBaseRight(0)
, minimapBoxBaseRight(0)
, mHealthManaStaminaBaseLeft(0)
, mWeapBoxBaseLeft(0)
, mSpellBoxBaseLeft(0)
, mEffectBoxBaseRight(0)
, mMinimapBoxBaseRight(0)
, mDragAndDrop(dragAndDrop)
, mCellNameTimer(0.0f)
, mCellNameBox(NULL)
@ -62,7 +62,7 @@ HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
getWidget(magicka, "Magicka");
getWidget(stamina, "Stamina");
hmsBaseLeft = mHealthFrame->getLeft();
mHealthManaStaminaBaseLeft = mHealthFrame->getLeft();
MyGUI::Widget *healthFrame, *magickaFrame, *fatigueFrame;
getWidget(healthFrame, "HealthFrame");
@ -75,33 +75,33 @@ HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
const MyGUI::IntSize& viewSize = MyGUI::RenderManager::getInstance().getViewSize();
// Item and spell images and status bars
getWidget(weapBox, "WeapBox");
getWidget(weapImage, "WeapImage");
getWidget(weapStatus, "WeapStatus");
weapBoxBaseLeft = weapBox->getLeft();
weapBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onWeaponClicked);
getWidget(spellBox, "SpellBox");
getWidget(spellImage, "SpellImage");
getWidget(spellStatus, "SpellStatus");
spellBoxBaseLeft = spellBox->getLeft();
spellBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onMagicClicked);
getWidget(effectBox, "EffectBox");
getWidget(effect1, "Effect1");
effectBoxBaseRight = viewSize.width - effectBox->getRight();
effectBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onMagicClicked);
getWidget(minimapBox, "MiniMapBox");
minimapBoxBaseRight = viewSize.width - minimapBox->getRight();
minimapBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onMapClicked);
getWidget(minimap, "MiniMap");
getWidget(compass, "Compass");
getWidget(mWeapBox, "WeapBox");
getWidget(mWeapImage, "WeapImage");
getWidget(mWeapStatus, "WeapStatus");
mWeapBoxBaseLeft = mWeapBox->getLeft();
mWeapBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onWeaponClicked);
getWidget(mSpellBox, "SpellBox");
getWidget(mSpellImage, "SpellImage");
getWidget(mSpellStatus, "SpellStatus");
mSpellBoxBaseLeft = mSpellBox->getLeft();
mSpellBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onMagicClicked);
getWidget(mEffectBox, "EffectBox");
getWidget(mEffect1, "Effect1");
mEffectBoxBaseRight = viewSize.width - mEffectBox->getRight();
mEffectBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onMagicClicked);
getWidget(mMinimapBox, "MiniMapBox");
mMinimapBoxBaseRight = viewSize.width - mMinimapBox->getRight();
mMinimapBox->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onMapClicked);
getWidget(mMinimap, "MiniMap");
getWidget(mCompass, "Compass");
getWidget(mCellNameBox, "CellName");
getWidget(mWeaponSpellBox, "WeaponSpellName");
getWidget(crosshair, "Crosshair");
getWidget(mCrosshair, "Crosshair");
setFpsLevel(fpsLevel);
@ -110,7 +110,7 @@ HUD::HUD(int width, int height, int fpsLevel, DragAndDrop* dragAndDrop)
setEffect("icons\\s\\tx_s_chameleon.dds");
LocalMapBase::init(minimap, compass, this);
LocalMapBase::init(mMinimap, mCompass, this);
mMainWidget->eventMouseButtonClick += MyGUI::newDelegate(this, &HUD::onWorldClicked);
mMainWidget->eventMouseMove += MyGUI::newDelegate(this, &HUD::onWorldMouseOver);
@ -159,7 +159,7 @@ void HUD::setBatchCount(unsigned int count)
void HUD::setEffect(const char *img)
{
effect1->setImageTexture(img);
mEffect1->setImageTexture(img);
}
void HUD::setValue(const std::string& id, const MWMechanics::DynamicStat<int>& value)
@ -202,10 +202,10 @@ void HUD::setBottomLeftVisibility(bool hmsVisible, bool weapVisible, bool spellV
{
int weapDx = 0, spellDx = 0;
if (!hmsVisible)
spellDx = weapDx = weapBoxBaseLeft - hmsBaseLeft;
spellDx = weapDx = mWeapBoxBaseLeft - mHealthManaStaminaBaseLeft;
if (!weapVisible)
spellDx += spellBoxBaseLeft - weapBoxBaseLeft;
spellDx += mSpellBoxBaseLeft - mWeapBoxBaseLeft;
mWeaponVisible = weapVisible;
mSpellVisible = spellVisible;
@ -215,10 +215,10 @@ void HUD::setBottomLeftVisibility(bool hmsVisible, bool weapVisible, bool spellV
health->setVisible(hmsVisible);
stamina->setVisible(hmsVisible);
magicka->setVisible(hmsVisible);
weapBox->setPosition(weapBoxBaseLeft - weapDx, weapBox->getTop());
weapBox->setVisible(weapVisible);
spellBox->setPosition(spellBoxBaseLeft - spellDx, spellBox->getTop());
spellBox->setVisible(spellVisible);
mWeapBox->setPosition(mWeapBoxBaseLeft - weapDx, mWeapBox->getTop());
mWeapBox->setVisible(weapVisible);
mSpellBox->setPosition(mSpellBoxBaseLeft - spellDx, mSpellBox->getTop());
mSpellBox->setVisible(spellVisible);
}
void HUD::setBottomRightVisibility(bool effectBoxVisible, bool minimapBoxVisible)
@ -228,12 +228,12 @@ void HUD::setBottomRightVisibility(bool effectBoxVisible, bool minimapBoxVisible
// effect box can have variable width -> variable left coordinate
int effectsDx = 0;
if (!minimapBoxVisible)
effectsDx = (viewSize.width - minimapBoxBaseRight) - (viewSize.width - effectBoxBaseRight);
effectsDx = (viewSize.width - mMinimapBoxBaseRight) - (viewSize.width - mEffectBoxBaseRight);
mMapVisible = minimapBoxVisible;
minimapBox->setVisible(minimapBoxVisible);
effectBox->setPosition((viewSize.width - effectBoxBaseRight) - effectBox->getWidth() + effectsDx, effectBox->getTop());
effectBox->setVisible(effectBoxVisible);
mMinimapBox->setVisible(minimapBoxVisible);
mEffectBox->setPosition((viewSize.width - mEffectBoxBaseRight) - mEffectBox->getWidth() + effectsDx, mEffectBox->getTop());
mEffectBox->setVisible(effectBoxVisible);
}
void HUD::onWorldClicked(MyGUI::Widget* _sender)
@ -395,14 +395,14 @@ void HUD::setSelectedSpell(const std::string& spellId, int successChancePercent)
mWeaponSpellBox->setVisible(true);
}
spellStatus->setProgressRange(100);
spellStatus->setProgressPosition(successChancePercent);
mSpellStatus->setProgressRange(100);
mSpellStatus->setProgressPosition(successChancePercent);
if (spellImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(spellImage->getChildAt(0));
if (mSpellImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(mSpellImage->getChildAt(0));
spellBox->setUserString("ToolTipType", "Spell");
spellBox->setUserString("Spell", spellId);
mSpellBox->setUserString("ToolTipType", "Spell");
mSpellBox->setUserString("Spell", spellId);
// use the icon of the first effect
const ESM::MagicEffect* effect = MWBase::Environment::get().getWorld()->getStore().magicEffects.find(spell->effects.list.front().effectID);
@ -411,7 +411,7 @@ void HUD::setSelectedSpell(const std::string& spellId, int successChancePercent)
icon.insert(slashPos+1, "b_");
icon = std::string("icons\\") + icon;
Widgets::fixTexturePath(icon);
spellImage->setImageTexture(icon);
mSpellImage->setImageTexture(icon);
}
void HUD::setSelectedEnchantItem(const MWWorld::Ptr& item, int chargePercent)
@ -425,17 +425,17 @@ void HUD::setSelectedEnchantItem(const MWWorld::Ptr& item, int chargePercent)
mWeaponSpellBox->setVisible(true);
}
spellStatus->setProgressRange(100);
spellStatus->setProgressPosition(chargePercent);
mSpellStatus->setProgressRange(100);
mSpellStatus->setProgressPosition(chargePercent);
if (spellImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(spellImage->getChildAt(0));
if (mSpellImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(mSpellImage->getChildAt(0));
spellBox->setUserString("ToolTipType", "ItemPtr");
spellBox->setUserData(item);
mSpellBox->setUserString("ToolTipType", "ItemPtr");
mSpellBox->setUserData(item);
spellImage->setImageTexture("textures\\menu_icon_magic_mini.dds");
MyGUI::ImageBox* itemBox = spellImage->createWidgetReal<MyGUI::ImageBox>("ImageBox", MyGUI::FloatCoord(0,0,1,1)
mSpellImage->setImageTexture("textures\\menu_icon_magic_mini.dds");
MyGUI::ImageBox* itemBox = mSpellImage->createWidgetReal<MyGUI::ImageBox>("ImageBox", MyGUI::FloatCoord(0,0,1,1)
, MyGUI::Align::Stretch);
std::string path = std::string("icons\\");
@ -456,14 +456,14 @@ void HUD::setSelectedWeapon(const MWWorld::Ptr& item, int durabilityPercent)
mWeaponSpellBox->setVisible(true);
}
weapBox->setUserString("ToolTipType", "ItemPtr");
weapBox->setUserData(item);
mWeapBox->setUserString("ToolTipType", "ItemPtr");
mWeapBox->setUserData(item);
weapStatus->setProgressRange(100);
weapStatus->setProgressPosition(durabilityPercent);
mWeapStatus->setProgressRange(100);
mWeapStatus->setProgressPosition(durabilityPercent);
if (weapImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(weapImage->getChildAt(0));
if (mWeapImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(mWeapImage->getChildAt(0));
std::string path = std::string("icons\\");
path+=MWWorld::Class::get(item).getInventoryIcon(item);
@ -471,14 +471,14 @@ void HUD::setSelectedWeapon(const MWWorld::Ptr& item, int durabilityPercent)
if (MWWorld::Class::get(item).getEnchantment(item) != "")
{
weapImage->setImageTexture("textures\\menu_icon_magic_mini.dds");
MyGUI::ImageBox* itemBox = weapImage->createWidgetReal<MyGUI::ImageBox>("ImageBox", MyGUI::FloatCoord(0,0,1,1)
mWeapImage->setImageTexture("textures\\menu_icon_magic_mini.dds");
MyGUI::ImageBox* itemBox = mWeapImage->createWidgetReal<MyGUI::ImageBox>("ImageBox", MyGUI::FloatCoord(0,0,1,1)
, MyGUI::Align::Stretch);
itemBox->setImageTexture(path);
itemBox->setNeedMouseFocus(false);
}
else
weapImage->setImageTexture(path);
mWeapImage->setImageTexture(path);
}
void HUD::unsetSelectedSpell()
@ -492,12 +492,12 @@ void HUD::unsetSelectedSpell()
mWeaponSpellBox->setVisible(true);
}
if (spellImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(spellImage->getChildAt(0));
spellStatus->setProgressRange(100);
spellStatus->setProgressPosition(0);
spellImage->setImageTexture("");
spellBox->clearUserStrings();
if (mSpellImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(mSpellImage->getChildAt(0));
mSpellStatus->setProgressRange(100);
mSpellStatus->setProgressPosition(0);
mSpellImage->setImageTexture("");
mSpellBox->clearUserStrings();
}
void HUD::unsetSelectedWeapon()
@ -511,10 +511,10 @@ void HUD::unsetSelectedWeapon()
mWeaponSpellBox->setVisible(true);
}
if (weapImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(weapImage->getChildAt(0));
weapStatus->setProgressRange(100);
weapStatus->setProgressPosition(0);
weapImage->setImageTexture("icons\\k\\stealth_handtohand.dds");
weapBox->clearUserStrings();
if (mWeapImage->getChildCount())
MyGUI::Gui::getInstance().destroyWidget(mWeapImage->getChildAt(0));
mWeapStatus->setProgressRange(100);
mWeapStatus->setProgressPosition(0);
mWeapImage->setImageTexture("icons\\k\\stealth_handtohand.dds");
mWeapBox->clearUserStrings();
}

20
apps/openmw/mwgui/hud.hpp
Unescape Escape View File

@ -37,14 +37,14 @@ namespace MWGui
MyGUI::ProgressPtr health, magicka, stamina;
MyGUI::Widget* mHealthFrame;
MyGUI::Widget *weapBox, *spellBox;
MyGUI::ImageBox *weapImage, *spellImage;
MyGUI::ProgressPtr weapStatus, spellStatus;
MyGUI::Widget *effectBox, *minimapBox;
MyGUI::ImageBox* effect1;
MyGUI::ScrollView* minimap;
MyGUI::ImageBox* compass;
MyGUI::ImageBox* crosshair;
MyGUI::Widget *mWeapBox, *mSpellBox;
MyGUI::ImageBox *mWeapImage, *mSpellImage;
MyGUI::ProgressPtr mWeapStatus, mSpellStatus;
MyGUI::Widget *mEffectBox, *mMinimapBox;
MyGUI::ImageBox* mEffect1;
MyGUI::ScrollView* mMinimap;
MyGUI::ImageBox* mCompass;
MyGUI::ImageBox* mCrosshair;
MyGUI::TextBox* mCellNameBox;
MyGUI::TextBox* mWeaponSpellBox;
@ -55,9 +55,9 @@ namespace MWGui
private:
// bottom left elements
int hmsBaseLeft, weapBoxBaseLeft, spellBoxBaseLeft;
int mHealthManaStaminaBaseLeft, mWeapBoxBaseLeft, mSpellBoxBaseLeft;
// bottom right elements
int minimapBoxBaseRight, effectBoxBaseRight;
int mMinimapBoxBaseRight, mEffectBoxBaseRight;
DragAndDrop* mDragAndDrop;

24
apps/openmw/mwgui/journalwindow.cpp
Unescape Escape View File

@ -84,7 +84,7 @@ book formatText(std::string text,book mBook,int maxLine, int lineSize)
MWGui::JournalWindow::JournalWindow (WindowManager& parWindowManager)
: WindowBase("openmw_journal.layout", parWindowManager)
, lastPos(0)
, mLastPos(0)
, mVisible(false)
{
//setCoord(0,0,498, 342);
@ -148,19 +148,19 @@ void MWGui::JournalWindow::open()
{
if(left)
{
leftPages.push_back(*it);
mLeftPages.push_back(*it);
}
else
{
rightPages.push_back(*it);
mRightPages.push_back(*it);
}
left = !left;
}
if(!left) rightPages.push_back("");
if(!left) mRightPages.push_back("");
mPageNumber = leftPages.size()-1;
displayLeftText(leftPages[mPageNumber]);
displayRightText(rightPages[mPageNumber]);
mPageNumber = mLeftPages.size()-1;
displayLeftText(mLeftPages[mPageNumber]);
displayRightText(mRightPages[mPageNumber]);
}
else
@ -184,13 +184,13 @@ void MWGui::JournalWindow::displayRightText(std::string text)
void MWGui::JournalWindow::notifyNextPage(MyGUI::WidgetPtr _sender)
{
if(mPageNumber < int(leftPages.size())-1)
if(mPageNumber < int(mLeftPages.size())-1)
{
std::string nextSound = "book page2";
MWBase::Environment::get().getSoundManager()->playSound (nextSound, 1.0, 1.0);
mPageNumber = mPageNumber + 1;
displayLeftText(leftPages[mPageNumber]);
displayRightText(rightPages[mPageNumber]);
displayLeftText(mLeftPages[mPageNumber]);
displayRightText(mRightPages[mPageNumber]);
}
}
@ -201,7 +201,7 @@ void MWGui::JournalWindow::notifyPrevPage(MyGUI::WidgetPtr _sender)
std::string prevSound = "book page";
MWBase::Environment::get().getSoundManager()->playSound (prevSound, 1.0, 1.0);
mPageNumber = mPageNumber - 1;
displayLeftText(leftPages[mPageNumber]);
displayRightText(rightPages[mPageNumber]);
displayLeftText(mLeftPages[mPageNumber]);
displayRightText(mRightPages[mPageNumber]);
}
}

12
apps/openmw/mwgui/journalwindow.hpp
Unescape Escape View File

@ -31,17 +31,17 @@ namespace MWGui
void notifyNextPage(MyGUI::WidgetPtr _sender);
void notifyPrevPage(MyGUI::WidgetPtr _sender);
static const int lineHeight;
static const int sLineHeight;
MyGUI::WidgetPtr skillAreaWidget, skillClientWidget;
MyGUI::ScrollBar* skillScrollerWidget;
int lastPos, clientHeight;
MyGUI::WidgetPtr mSkillAreaWidget, mSkillClientWidget;
MyGUI::ScrollBar* mSkillScrollerWidget;
int mLastPos, mClientHeight;
MyGUI::EditPtr mLeftTextWidget;
MyGUI::EditPtr mRightTextWidget;
MyGUI::ButtonPtr mPrevBtn;
MyGUI::ButtonPtr mNextBtn;
std::vector<std::string> leftPages;
std::vector<std::string> rightPages;
std::vector<std::string> mLeftPages;
std::vector<std::string> mRightPages;
int mPageNumber; //store the number of the current left page
bool mVisible;
};

4
apps/openmw/mwgui/messagebox.cpp
Unescape Escape View File

@ -149,7 +149,7 @@ int MessageBoxManager::readPressedButton ()
MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::string& message)
: Layout("openmw_messagebox.layout")
, mMessageBoxManager(parMessageBoxManager)
, cMessage(message)
, mMessage(message)
{
// defines
mFixedWidth = 300;
@ -160,7 +160,7 @@ MessageBox::MessageBox(MessageBoxManager& parMessageBoxManager, const std::strin
getWidget(mMessageWidget, "message");
mMessageWidget->setOverflowToTheLeft(true);
mMessageWidget->setCaptionWithReplacing(cMessage);
mMessageWidget->setCaptionWithReplacing(mMessage);
MyGUI::IntSize size;
size.width = mFixedWidth;

2
apps/openmw/mwgui/messagebox.hpp
Unescape Escape View File

@ -59,7 +59,7 @@ namespace MWGui
protected:
MessageBoxManager& mMessageBoxManager;
int mHeight;
const std::string& cMessage;
const std::string& mMessage;
MyGUI::EditPtr mMessageWidget;
int mFixedWidth;
int mBottomPadding;

101
apps/openmw/mwgui/race.cpp
Unescape Escape View File

@ -1,6 +1,5 @@
#include "race.hpp"
#include <assert.h>
#include <iostream>
#include <iterator>
@ -18,11 +17,11 @@ using namespace Widgets;
RaceDialog::RaceDialog(WindowManager& parWindowManager)
: WindowBase("openmw_chargen_race.layout", parWindowManager)
, genderIndex(0)
, faceIndex(0)
, hairIndex(0)
, faceCount(10)
, hairCount(14)
, mGenderIndex(0)
, mFaceIndex(0)
, mHairIndex(0)
, mFaceCount(10)
, mHairCount(14)
{
// Centre dialog
center();
@ -31,13 +30,13 @@ RaceDialog::RaceDialog(WindowManager& parWindowManager)
// real calls from outside the class later.
setText("AppearanceT", mWindowManager.getGameSettingString("sRaceMenu1", "Appearance"));
getWidget(appearanceBox, "AppearanceBox");
getWidget(mAppearanceBox, "AppearanceBox");
getWidget(headRotate, "HeadRotate");
headRotate->setScrollRange(50);
headRotate->setScrollPosition(20);
headRotate->setScrollViewPage(10);
headRotate->eventScrollChangePosition += MyGUI::newDelegate(this, &RaceDialog::onHeadRotate);
getWidget(mHeadRotate, "HeadRotate");
mHeadRotate->setScrollRange(50);
mHeadRotate->setScrollPosition(20);
mHeadRotate->setScrollViewPage(10);
mHeadRotate->eventScrollChangePosition += MyGUI::newDelegate(this, &RaceDialog::onHeadRotate);
// Set up next/previous buttons
MyGUI::ButtonPtr prevButton, nextButton;
@ -61,16 +60,16 @@ RaceDialog::RaceDialog(WindowManager& parWindowManager)
nextButton->eventMouseButtonClick += MyGUI::newDelegate(this, &RaceDialog::onSelectNextHair);
setText("RaceT", mWindowManager.getGameSettingString("sRaceMenu4", "Race"));
getWidget(raceList, "RaceList");
raceList->setScrollVisible(true);
raceList->eventListSelectAccept += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
raceList->eventListMouseItemActivate += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
raceList->eventListChangePosition += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
getWidget(mRaceList, "RaceList");
mRaceList->setScrollVisible(true);
mRaceList->eventListSelectAccept += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
mRaceList->eventListMouseItemActivate += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
mRaceList->eventListChangePosition += MyGUI::newDelegate(this, &RaceDialog::onSelectRace);
setText("SkillsT", mWindowManager.getGameSettingString("sBonusSkillTitle", "Skill Bonus"));
getWidget(skillList, "SkillList");
getWidget(mSkillList, "SkillList");
setText("SpellPowerT", mWindowManager.getGameSettingString("sRaceMenu7", "Specials"));
getWidget(spellPowerList, "SpellPowerList");
getWidget(mSpellPowerList, "SpellPowerList");
MyGUI::ButtonPtr backButton;
getWidget(backButton, "BackButton");
@ -117,14 +116,14 @@ void RaceDialog::open()
void RaceDialog::setRaceId(const std::string &raceId)
{
currentRaceId = raceId;
raceList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = raceList->getItemCount();
mCurrentRaceId = raceId;
mRaceList->setIndexSelected(MyGUI::ITEM_NONE);
size_t count = mRaceList->getItemCount();
for (size_t i = 0; i < count; ++i)
{
if (boost::iequals(*raceList->getItemDataAt<std::string>(i), raceId))
if (boost::iequals(*mRaceList->getItemDataAt<std::string>(i), raceId))
{
raceList->setIndexSelected(i);
mRaceList->setIndexSelected(i);
break;
}
}
@ -162,32 +161,32 @@ void RaceDialog::onHeadRotate(MyGUI::ScrollBar*, size_t _position)
void RaceDialog::onSelectPreviousGender(MyGUI::Widget*)
{
genderIndex = wrap(genderIndex - 1, 2);
mGenderIndex = wrap(mGenderIndex - 1, 2);
}
void RaceDialog::onSelectNextGender(MyGUI::Widget*)
{
genderIndex = wrap(genderIndex + 1, 2);
mGenderIndex = wrap(mGenderIndex + 1, 2);
}
void RaceDialog::onSelectPreviousFace(MyGUI::Widget*)
{
faceIndex = wrap(faceIndex - 1, faceCount);
mFaceIndex = wrap(mFaceIndex - 1, mFaceCount);
}
void RaceDialog::onSelectNextFace(MyGUI::Widget*)
{
faceIndex = wrap(faceIndex + 1, faceCount);
mFaceIndex = wrap(mFaceIndex + 1, mFaceCount);
}
void RaceDialog::onSelectPreviousHair(MyGUI::Widget*)
{
hairIndex = wrap(hairIndex - 1, hairCount);
mHairIndex = wrap(mHairIndex - 1, mHairCount);
}
void RaceDialog::onSelectNextHair(MyGUI::Widget*)
{
hairIndex = wrap(hairIndex - 1, hairCount);
mHairIndex = wrap(mHairIndex - 1, mHairCount);
}
void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
@ -195,11 +194,11 @@ void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
if (_index == MyGUI::ITEM_NONE)
return;
const std::string *raceId = raceList->getItemDataAt<std::string>(_index);
if (boost::iequals(currentRaceId, *raceId))
const std::string *raceId = mRaceList->getItemDataAt<std::string>(_index);
if (boost::iequals(mCurrentRaceId, *raceId))
return;
currentRaceId = *raceId;
mCurrentRaceId = *raceId;
updateSkills();
updateSpellPowers();
}
@ -208,7 +207,7 @@ void RaceDialog::onSelectRace(MyGUI::ListBox* _sender, size_t _index)
void RaceDialog::updateRaces()
{
raceList->removeAllItems();
mRaceList->removeAllItems();
const ESMS::ESMStore &store = mWindowManager.getStore();
@ -222,30 +221,30 @@ void RaceDialog::updateRaces()
if (!playable) // Only display playable races
continue;
raceList->addItem(race.name, it->first);
if (boost::iequals(it->first, currentRaceId))
raceList->setIndexSelected(index);
mRaceList->addItem(race.name, it->first);
if (boost::iequals(it->first, mCurrentRaceId))
mRaceList->setIndexSelected(index);
++index;
}
}
void RaceDialog::updateSkills()
{
for (std::vector<MyGUI::WidgetPtr>::iterator it = skillItems.begin(); it != skillItems.end(); ++it)
for (std::vector<MyGUI::WidgetPtr>::iterator it = mSkillItems.begin(); it != mSkillItems.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
skillItems.clear();
mSkillItems.clear();
if (currentRaceId.empty())
if (mCurrentRaceId.empty())
return;
MWSkillPtr skillWidget;
const int lineHeight = 18;
MyGUI::IntCoord coord1(0, 0, skillList->getWidth(), 18);
MyGUI::IntCoord coord1(0, 0, mSkillList->getWidth(), 18);
const ESMS::ESMStore &store = mWindowManager.getStore();
const ESM::Race *race = store.races.find(currentRaceId);
const ESM::Race *race = store.races.find(mCurrentRaceId);
int count = sizeof(race->data.bonus)/sizeof(race->data.bonus[0]); // TODO: Find a portable macro for this ARRAYSIZE?
for (int i = 0; i < count; ++i)
{
@ -253,7 +252,7 @@ void RaceDialog::updateSkills()
if (skillId < 0 || skillId > ESM::Skill::Length) // Skip unknown skill indexes
continue;
skillWidget = skillList->createWidget<MWSkill>("MW_StatNameValue", coord1, MyGUI::Align::Default,
skillWidget = mSkillList->createWidget<MWSkill>("MW_StatNameValue", coord1, MyGUI::Align::Default,
std::string("Skill") + boost::lexical_cast<std::string>(i));
skillWidget->setWindowManager(&mWindowManager);
skillWidget->setSkillNumber(skillId);
@ -261,7 +260,7 @@ void RaceDialog::updateSkills()
ToolTips::createSkillToolTip(skillWidget, skillId);
skillItems.push_back(skillWidget);
mSkillItems.push_back(skillWidget);
coord1.top += lineHeight;
}
@ -269,34 +268,34 @@ void RaceDialog::updateSkills()
void RaceDialog::updateSpellPowers()
{
for (std::vector<MyGUI::WidgetPtr>::iterator it = spellPowerItems.begin(); it != spellPowerItems.end(); ++it)
for (std::vector<MyGUI::WidgetPtr>::iterator it = mSpellPowerItems.begin(); it != mSpellPowerItems.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
spellPowerItems.clear();
mSpellPowerItems.clear();
if (currentRaceId.empty())
if (mCurrentRaceId.empty())
return;
MWSpellPtr spellPowerWidget;
const int lineHeight = 18;
MyGUI::IntCoord coord(0, 0, spellPowerList->getWidth(), 18);
MyGUI::IntCoord coord(0, 0, mSpellPowerList->getWidth(), 18);
const ESMS::ESMStore &store = mWindowManager.getStore();
const ESM::Race *race = store.races.find(currentRaceId);
const ESM::Race *race = store.races.find(mCurrentRaceId);
std::vector<std::string>::const_iterator it = race->powers.list.begin();
std::vector<std::string>::const_iterator end = race->powers.list.end();
for (int i = 0; it != end; ++it)
{
const std::string &spellpower = *it;
spellPowerWidget = spellPowerList->createWidget<MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("SpellPower") + boost::lexical_cast<std::string>(i));
spellPowerWidget = mSpellPowerList->createWidget<MWSpell>("MW_StatName", coord, MyGUI::Align::Default, std::string("SpellPower") + boost::lexical_cast<std::string>(i));
spellPowerWidget->setWindowManager(&mWindowManager);
spellPowerWidget->setSpellId(spellpower);
spellPowerWidget->setUserString("ToolTipType", "Spell");
spellPowerWidget->setUserString("Spell", spellpower);
spellPowerItems.push_back(spellPowerWidget);
mSpellPowerItems.push_back(spellPowerWidget);
coord.top += lineHeight;
++i;

26
apps/openmw/mwgui/race.hpp
Unescape Escape View File

@ -32,13 +32,13 @@ namespace MWGui
GM_Female
};
const std::string &getRaceId() const { return currentRaceId; }
Gender getGender() const { return genderIndex == 0 ? GM_Male : GM_Female; }
const std::string &getRaceId() const { return mCurrentRaceId; }
Gender getGender() const { return mGenderIndex == 0 ? GM_Male : GM_Female; }
// getFace()
// getHair()
void setRaceId(const std::string &raceId);
void setGender(Gender gender) { genderIndex = gender == GM_Male ? 0 : 1; }
void setGender(Gender gender) { mGenderIndex = gender == GM_Male ? 0 : 1; }
// setFace()
// setHair()
@ -75,20 +75,20 @@ namespace MWGui
void updateSkills();
void updateSpellPowers();
MyGUI::CanvasPtr appearanceBox;
MyGUI::ListBox* raceList;
MyGUI::ScrollBar* headRotate;
MyGUI::CanvasPtr mAppearanceBox;
MyGUI::ListBox* mRaceList;
MyGUI::ScrollBar* mHeadRotate;
MyGUI::WidgetPtr skillList;
std::vector<MyGUI::WidgetPtr> skillItems;
MyGUI::WidgetPtr mSkillList;
std::vector<MyGUI::WidgetPtr> mSkillItems;
MyGUI::WidgetPtr spellPowerList;
std::vector<MyGUI::WidgetPtr> spellPowerItems;
MyGUI::WidgetPtr mSpellPowerList;
std::vector<MyGUI::WidgetPtr> mSpellPowerItems;
int genderIndex, faceIndex, hairIndex;
int faceCount, hairCount;
int mGenderIndex, mFaceIndex, mHairIndex;
int mFaceCount, mHairCount;
std::string currentRaceId;
std::string mCurrentRaceId;
};
}
#endif

188
apps/openmw/mwgui/review.cpp
Unescape Escape View File

@ -17,49 +17,49 @@
using namespace MWGui;
using namespace Widgets;
const int ReviewDialog::lineHeight = 18;
const int ReviewDialog::sLineHeight = 18;
ReviewDialog::ReviewDialog(WindowManager& parWindowManager)
: WindowBase("openmw_chargen_review.layout", parWindowManager)
, lastPos(0)
, mLastPos(0)
{
// Centre dialog
center();
// Setup static stats
ButtonPtr button;
getWidget(nameWidget, "NameText");
getWidget(mNameWidget, "NameText");
getWidget(button, "NameButton");
adjustButtonSize(button);
button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onNameClicked);;
getWidget(raceWidget, "RaceText");
getWidget(mRaceWidget, "RaceText");
getWidget(button, "RaceButton");
adjustButtonSize(button);
button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onRaceClicked);;
getWidget(classWidget, "ClassText");
getWidget(mClassWidget, "ClassText");
getWidget(button, "ClassButton");
adjustButtonSize(button);
button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onClassClicked);;
getWidget(birthSignWidget, "SignText");
getWidget(mBirthSignWidget, "SignText");
getWidget(button, "SignButton");
adjustButtonSize(button);
button->eventMouseButtonClick += MyGUI::newDelegate(this, &ReviewDialog::onBirthSignClicked);;
// Setup dynamic stats
getWidget(health, "Health");
health->setTitle(mWindowManager.getGameSettingString("sHealth", ""));
health->setValue(45, 45);
getWidget(mHealth, "Health");
mHealth->setTitle(mWindowManager.getGameSettingString("sHealth", ""));
mHealth->setValue(45, 45);
getWidget(magicka, "Magicka");
magicka->setTitle(mWindowManager.getGameSettingString("sMagic", ""));
magicka->setValue(50, 50);
getWidget(mMagicka, "Magicka");
mMagicka->setTitle(mWindowManager.getGameSettingString("sMagic", ""));
mMagicka->setValue(50, 50);
getWidget(fatigue, "Fatigue");
fatigue->setTitle(mWindowManager.getGameSettingString("sFatigue", ""));
fatigue->setValue(160, 160);
getWidget(mFatigue, "Fatigue");
mFatigue->setTitle(mWindowManager.getGameSettingString("sFatigue", ""));
mFatigue->setValue(160, 160);
// Setup attributes
@ -67,24 +67,24 @@ ReviewDialog::ReviewDialog(WindowManager& parWindowManager)
for (int idx = 0; idx < ESM::Attribute::Length; ++idx)
{
getWidget(attribute, std::string("Attribute") + boost::lexical_cast<std::string>(idx));
attributeWidgets.insert(std::make_pair(static_cast<int>(ESM::Attribute::attributeIds[idx]), attribute));
mAttributeWidgets.insert(std::make_pair(static_cast<int>(ESM::Attribute::attributeIds[idx]), attribute));
attribute->setWindowManager(&mWindowManager);
attribute->setAttributeId(ESM::Attribute::attributeIds[idx]);
attribute->setAttributeValue(MWAttribute::AttributeValue(0, 0));
}
// Setup skills
getWidget(skillAreaWidget, "Skills");
getWidget(skillClientWidget, "SkillClient");
getWidget(skillScrollerWidget, "SkillScroller");
skillClientWidget->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
skillScrollerWidget->eventScrollChangePosition += MyGUI::newDelegate(this, &ReviewDialog::onScrollChangePosition);
getWidget(mSkillAreaWidget, "Skills");
getWidget(mSkillClientWidget, "SkillClient");
getWidget(mSkillScrollerWidget, "SkillScroller");
mSkillClientWidget->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
mSkillScrollerWidget->eventScrollChangePosition += MyGUI::newDelegate(this, &ReviewDialog::onScrollChangePosition);
updateScroller();
for (int i = 0; i < ESM::Skill::Length; ++i)
{
skillValues.insert(std::make_pair(i, MWMechanics::Stat<float>()));
skillWidgetMap.insert(std::make_pair(i, static_cast<MyGUI::TextBox*> (0)));
mSkillValues.insert(std::make_pair(i, MWMechanics::Stat<float>()));
mSkillWidgetMap.insert(std::make_pair(i, static_cast<MyGUI::TextBox*> (0)));
}
static_cast<MyGUI::WindowPtr>(mMainWidget)->eventWindowChangeCoord += MyGUI::newDelegate(this, &ReviewDialog::onWindowResize);
@ -112,14 +112,14 @@ void ReviewDialog::open()
void ReviewDialog::onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos)
{
int diff = lastPos - pos;
int diff = mLastPos - pos;
// Adjust position of all widget according to difference
if (diff == 0)
return;
lastPos = pos;
mLastPos = pos;
std::vector<MyGUI::WidgetPtr>::const_iterator end = skillWidgets.end();
for (std::vector<MyGUI::WidgetPtr>::const_iterator it = skillWidgets.begin(); it != end; ++it)
std::vector<MyGUI::WidgetPtr>::const_iterator end = mSkillWidgets.end();
for (std::vector<MyGUI::WidgetPtr>::const_iterator it = mSkillWidgets.begin(); it != end; ++it)
{
(*it)->setCoord((*it)->getCoord() + MyGUI::IntPoint(0, diff));
}
@ -132,63 +132,63 @@ void ReviewDialog::onWindowResize(MyGUI::Window* window)
void ReviewDialog::setPlayerName(const std::string &name)
{
nameWidget->setCaption(name);
mNameWidget->setCaption(name);
}
void ReviewDialog::setRace(const std::string &raceId_)
void ReviewDialog::setRace(const std::string &raceId)
{
raceId = raceId_;
const ESM::Race *race = mWindowManager.getStore().races.search(raceId);
mRaceId = raceId;
const ESM::Race *race = mWindowManager.getStore().races.search(mRaceId);
if (race)
{
ToolTips::createRaceToolTip(raceWidget, race);
raceWidget->setCaption(race->name);
ToolTips::createRaceToolTip(mRaceWidget, race);
mRaceWidget->setCaption(race->name);
}
}
void ReviewDialog::setClass(const ESM::Class& class_)
{
klass = class_;
classWidget->setCaption(klass.name);
ToolTips::createClassToolTip(classWidget, klass);
mKlass = class_;
mClassWidget->setCaption(mKlass.name);
ToolTips::createClassToolTip(mClassWidget, mKlass);
}
void ReviewDialog::setBirthSign(const std::string& signId)
{
birthSignId = signId;
const ESM::BirthSign *sign = mWindowManager.getStore().birthSigns.search(birthSignId);
mBirthSignId = signId;
const ESM::BirthSign *sign = mWindowManager.getStore().birthSigns.search(mBirthSignId);
if (sign)
{
birthSignWidget->setCaption(sign->name);
ToolTips::createBirthsignToolTip(birthSignWidget, birthSignId);
mBirthSignWidget->setCaption(sign->name);
ToolTips::createBirthsignToolTip(mBirthSignWidget, mBirthSignId);
}
}
void ReviewDialog::setHealth(const MWMechanics::DynamicStat<int>& value)
{
health->setValue(value.getCurrent(), value.getModified());
mHealth->setValue(value.getCurrent(), value.getModified());
std::string valStr = boost::lexical_cast<std::string>(value.getCurrent()) + "/" + boost::lexical_cast<std::string>(value.getModified());
health->setUserString("Caption_HealthDescription", "#{sHealthDesc}\n" + valStr);
mHealth->setUserString("Caption_HealthDescription", "#{sHealthDesc}\n" + valStr);
}
void ReviewDialog::setMagicka(const MWMechanics::DynamicStat<int>& value)
{
magicka->setValue(value.getCurrent(), value.getModified());
mMagicka->setValue(value.getCurrent(), value.getModified());
std::string valStr = boost::lexical_cast<std::string>(value.getCurrent()) + "/" + boost::lexical_cast<std::string>(value.getModified());
magicka->setUserString("Caption_HealthDescription", "#{sIntDesc}\n" + valStr);
mMagicka->setUserString("Caption_HealthDescription", "#{sIntDesc}\n" + valStr);
}
void ReviewDialog::setFatigue(const MWMechanics::DynamicStat<int>& value)
{
fatigue->setValue(value.getCurrent(), value.getModified());
mFatigue->setValue(value.getCurrent(), value.getModified());
std::string valStr = boost::lexical_cast<std::string>(value.getCurrent()) + "/" + boost::lexical_cast<std::string>(value.getModified());
fatigue->setUserString("Caption_HealthDescription", "#{sFatDesc}\n" + valStr);
mFatigue->setUserString("Caption_HealthDescription", "#{sFatDesc}\n" + valStr);
}
void ReviewDialog::setAttribute(ESM::Attribute::AttributeID attributeId, const MWMechanics::Stat<int>& value)
{
std::map<int, MWAttributePtr>::iterator attr = attributeWidgets.find(static_cast<int>(attributeId));
if (attr == attributeWidgets.end())
std::map<int, MWAttributePtr>::iterator attr = mAttributeWidgets.find(static_cast<int>(attributeId));
if (attr == mAttributeWidgets.end())
return;
attr->second->setAttributeValue(value);
@ -196,8 +196,8 @@ void ReviewDialog::setAttribute(ESM::Attribute::AttributeID attributeId, const M
void ReviewDialog::setSkillValue(ESM::Skill::SkillEnum skillId, const MWMechanics::Stat<float>& value)
{
skillValues[skillId] = value;
MyGUI::TextBox* widget = skillWidgetMap[skillId];
mSkillValues[skillId] = value;
MyGUI::TextBox* widget = mSkillWidgetMap[skillId];
if (widget)
{
float modified = value.getModified(), base = value.getBase();
@ -216,20 +216,20 @@ void ReviewDialog::setSkillValue(ESM::Skill::SkillEnum skillId, const MWMechanic
void ReviewDialog::configureSkills(const std::vector<int>& major, const std::vector<int>& minor)
{
majorSkills = major;
minorSkills = minor;
mMajorSkills = major;
mMinorSkills = minor;
// Update misc skills with the remaining skills not in major or minor
std::set<int> skillSet;
std::copy(major.begin(), major.end(), std::inserter(skillSet, skillSet.begin()));
std::copy(minor.begin(), minor.end(), std::inserter(skillSet, skillSet.begin()));
boost::array<ESM::Skill::SkillEnum, ESM::Skill::Length>::const_iterator end = ESM::Skill::skillIds.end();
miscSkills.clear();
mMiscSkills.clear();
for (boost::array<ESM::Skill::SkillEnum, ESM::Skill::Length>::const_iterator it = ESM::Skill::skillIds.begin(); it != end; ++it)
{
int skill = *it;
if (skillSet.find(skill) == skillSet.end())
miscSkills.push_back(skill);
mMiscSkills.push_back(skill);
}
updateSkillArea();
@ -237,10 +237,10 @@ void ReviewDialog::configureSkills(const std::vector<int>& major, const std::vec
void ReviewDialog::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::ImageBox* separator = skillClientWidget->createWidget<MyGUI::ImageBox>("MW_HLine", MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18), MyGUI::Align::Default);
MyGUI::ImageBox* separator = mSkillClientWidget->createWidget<MyGUI::ImageBox>("MW_HLine", MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18), MyGUI::Align::Default);
separator->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
skillWidgets.push_back(separator);
mSkillWidgets.push_back(separator);
coord1.top += separator->getHeight();
coord2.top += separator->getHeight();
@ -248,13 +248,13 @@ void ReviewDialog::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2
void ReviewDialog::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* groupWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandBrightText", MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height), MyGUI::Align::Default);
MyGUI::TextBox* groupWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandBrightText", MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height), MyGUI::Align::Default);
groupWidget->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
groupWidget->setCaption(label);
skillWidgets.push_back(groupWidget);
mSkillWidgets.push_back(groupWidget);
coord1.top += lineHeight;
coord2.top += lineHeight;
coord1.top += sLineHeight;
coord2.top += sLineHeight;
}
MyGUI::TextBox* ReviewDialog::addValueItem(const std::string& text, const std::string &value, const std::string& state, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
@ -262,20 +262,20 @@ MyGUI::TextBox* ReviewDialog::addValueItem(const std::string& text, const std::s
MyGUI::TextBox* skillNameWidget;
MyGUI::TextBox* skillValueWidget;
skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1, MyGUI::Align::Default);
skillNameWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1, MyGUI::Align::Default);
skillNameWidget->setCaption(text);
skillNameWidget->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
skillValueWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandTextRight", coord2, MyGUI::Align::Top | MyGUI::Align::Right);
skillValueWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandTextRight", coord2, MyGUI::Align::Top | MyGUI::Align::Right);
skillValueWidget->setCaption(value);
skillValueWidget->_setWidgetState(state);
skillValueWidget->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
skillWidgets.push_back(skillNameWidget);
skillWidgets.push_back(skillValueWidget);
mSkillWidgets.push_back(skillNameWidget);
mSkillWidgets.push_back(skillValueWidget);
coord1.top += lineHeight;
coord2.top += lineHeight;
coord1.top += sLineHeight;
coord2.top += sLineHeight;
return skillValueWidget;
}
@ -284,20 +284,20 @@ void ReviewDialog::addItem(const std::string& text, MyGUI::IntCoord &coord1, MyG
{
MyGUI::TextBox* skillNameWidget;
skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
skillNameWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
skillNameWidget->setCaption(text);
skillNameWidget->eventMouseWheel += MyGUI::newDelegate(this, &ReviewDialog::onMouseWheel);
skillWidgets.push_back(skillNameWidget);
mSkillWidgets.push_back(skillNameWidget);
coord1.top += lineHeight;
coord2.top += lineHeight;
coord1.top += sLineHeight;
coord2.top += sLineHeight;
}
void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
// Add a line separator if there are items above
if (!skillWidgets.empty())
if (!mSkillWidgets.empty())
{
addSeparator(coord1, coord2);
}
@ -312,7 +312,7 @@ void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId
continue;
assert(skillId >= 0 && skillId < ESM::Skill::Length);
const std::string &skillNameId = ESMS::Skill::sSkillNameIds[skillId];
const MWMechanics::Stat<float> &stat = skillValues.find(skillId)->second;
const MWMechanics::Stat<float> &stat = mSkillValues.find(skillId)->second;
float base = stat.getBase();
float modified = stat.getModified();
@ -325,44 +325,44 @@ void ReviewDialog::addSkills(const SkillList &skills, const std::string &titleId
for (int i=0; i<2; ++i)
{
ToolTips::createSkillToolTip(skillWidgets[skillWidgets.size()-1-i], skillId);
ToolTips::createSkillToolTip(mSkillWidgets[mSkillWidgets.size()-1-i], skillId);
}
skillWidgetMap[skillId] = widget;
mSkillWidgetMap[skillId] = widget;
}
}
void ReviewDialog::updateSkillArea()
{
for (std::vector<MyGUI::WidgetPtr>::iterator it = skillWidgets.begin(); it != skillWidgets.end(); ++it)
for (std::vector<MyGUI::WidgetPtr>::iterator it = mSkillWidgets.begin(); it != mSkillWidgets.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
skillWidgets.clear();
mSkillWidgets.clear();
const int valueSize = 40;
MyGUI::IntCoord coord1(10, 0, skillClientWidget->getWidth() - (10 + valueSize), 18);
MyGUI::IntCoord coord1(10, 0, mSkillClientWidget->getWidth() - (10 + valueSize), 18);
MyGUI::IntCoord coord2(coord1.left + coord1.width, coord1.top, valueSize, coord1.height);
if (!majorSkills.empty())
addSkills(majorSkills, "sSkillClassMajor", "Major Skills", coord1, coord2);
if (!mMajorSkills.empty())
addSkills(mMajorSkills, "sSkillClassMajor", "Major Skills", coord1, coord2);
if (!minorSkills.empty())
addSkills(minorSkills, "sSkillClassMinor", "Minor Skills", coord1, coord2);
if (!mMinorSkills.empty())
addSkills(mMinorSkills, "sSkillClassMinor", "Minor Skills", coord1, coord2);
if (!miscSkills.empty())
addSkills(miscSkills, "sSkillClassMisc", "Misc Skills", coord1, coord2);
if (!mMiscSkills.empty())
addSkills(mMiscSkills, "sSkillClassMisc", "Misc Skills", coord1, coord2);
clientHeight = coord1.top;
mClientHeight = coord1.top;
updateScroller();
}
void ReviewDialog::updateScroller()
{
skillScrollerWidget->setScrollRange(std::max(clientHeight - skillClientWidget->getHeight(), 0));
skillScrollerWidget->setScrollPage(std::max(skillClientWidget->getHeight() - lineHeight, 0));
if (clientHeight != 0)
skillScrollerWidget->setTrackSize( (skillAreaWidget->getHeight() / float(clientHeight)) * skillScrollerWidget->getLineSize() );
mSkillScrollerWidget->setScrollRange(std::max(mClientHeight - mSkillClientWidget->getHeight(), 0));
mSkillScrollerWidget->setScrollPage(std::max(mSkillClientWidget->getHeight() - sLineHeight, 0));
if (mClientHeight != 0)
mSkillScrollerWidget->setTrackSize( (mSkillAreaWidget->getHeight() / float(mClientHeight)) * mSkillScrollerWidget->getLineSize() );
}
// widget controls
@ -399,12 +399,12 @@ void ReviewDialog::onBirthSignClicked(MyGUI::Widget* _sender)
void ReviewDialog::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
if (skillScrollerWidget->getScrollPosition() - _rel*0.3 < 0)
skillScrollerWidget->setScrollPosition(0);
else if (skillScrollerWidget->getScrollPosition() - _rel*0.3 > skillScrollerWidget->getScrollRange()-1)
skillScrollerWidget->setScrollPosition(skillScrollerWidget->getScrollRange()-1);
if (mSkillScrollerWidget->getScrollPosition() - _rel*0.3 < 0)
mSkillScrollerWidget->setScrollPosition(0);
else if (mSkillScrollerWidget->getScrollPosition() - _rel*0.3 > mSkillScrollerWidget->getScrollRange()-1)
mSkillScrollerWidget->setScrollPosition(mSkillScrollerWidget->getScrollRange()-1);
else
skillScrollerWidget->setScrollPosition(skillScrollerWidget->getScrollPosition() - _rel*0.3);
mSkillScrollerWidget->setScrollPosition(mSkillScrollerWidget->getScrollPosition() - _rel*0.3);
onScrollChangePosition(skillScrollerWidget, skillScrollerWidget->getScrollPosition());
onScrollChangePosition(mSkillScrollerWidget, mSkillScrollerWidget->getScrollPosition());
}

26
apps/openmw/mwgui/review.hpp
Unescape Escape View File

@ -82,23 +82,23 @@ namespace MWGui
void onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos);
void onWindowResize(MyGUI::Window* window);
static const int lineHeight;
static const int sLineHeight;
MyGUI::TextBox *nameWidget, *raceWidget, *classWidget, *birthSignWidget;
MyGUI::WidgetPtr skillAreaWidget, skillClientWidget;
MyGUI::ScrollBar* skillScrollerWidget;
int lastPos, clientHeight;
MyGUI::TextBox *mNameWidget, *mRaceWidget, *mClassWidget, *mBirthSignWidget;
MyGUI::WidgetPtr mSkillAreaWidget, mSkillClientWidget;
MyGUI::ScrollBar* mSkillScrollerWidget;
int mLastPos, mClientHeight;
Widgets::MWDynamicStatPtr health, magicka, fatigue;
Widgets::MWDynamicStatPtr mHealth, mMagicka, mFatigue;
std::map<int, Widgets::MWAttributePtr> attributeWidgets;
std::map<int, Widgets::MWAttributePtr> mAttributeWidgets;
SkillList majorSkills, minorSkills, miscSkills;
std::map<int, MWMechanics::Stat<float> > skillValues;
std::map<int, MyGUI::TextBox*> skillWidgetMap;
std::string name, raceId, birthSignId;
ESM::Class klass;
std::vector<MyGUI::WidgetPtr> skillWidgets; //< Skills and other information
SkillList mMajorSkills, mMinorSkills, mMiscSkills;
std::map<int, MWMechanics::Stat<float> > mSkillValues;
std::map<int, MyGUI::TextBox*> mSkillWidgetMap;
std::string mName, mRaceId, mBirthSignId;
ESM::Class mKlass;
std::vector<MyGUI::WidgetPtr> mSkillWidgets; //< Skills and other information
};
}
#endif

202
apps/openmw/mwgui/stats_window.cpp
Unescape Escape View File

@ -19,26 +19,26 @@
using namespace MWGui;
const int StatsWindow::lineHeight = 18;
const int StatsWindow::sLineHeight = 18;
StatsWindow::StatsWindow (WindowManager& parWindowManager)
: WindowPinnableBase("openmw_stats_window.layout", parWindowManager)
, skillAreaWidget(NULL)
, skillClientWidget(NULL)
, skillScrollerWidget(NULL)
, lastPos(0)
, clientHeight(0)
, majorSkills()
, minorSkills()
, miscSkills()
, skillValues()
, skillWidgetMap()
, factionWidgetMap()
, mSkillAreaWidget(NULL)
, mSkillClientWidget(NULL)
, mSkillScrollerWidget(NULL)
, mLastPos(0)
, mClientHeight(0)
, mMajorSkills()
, mMinorSkills()
, mMiscSkills()
, mSkillValues()
, mSkillWidgetMap()
, mFactionWidgetMap()
, mFactions()
, birthSignId()
, reputation(0)
, bounty(0)
, skillWidgets()
, mBirthSignId()
, mReputation(0)
, mBounty(0)
, mSkillWidgets()
, mChanged(true)
{
setCoord(0,0,498, 342);
@ -62,21 +62,21 @@ StatsWindow::StatsWindow (WindowManager& parWindowManager)
setText (names[i][0], store.gameSettings.find (names[i][1])->str);
}
getWidget(skillAreaWidget, "Skills");
getWidget(skillClientWidget, "SkillClient");
getWidget(skillScrollerWidget, "SkillScroller");
getWidget(mSkillAreaWidget, "Skills");
getWidget(mSkillClientWidget, "SkillClient");
getWidget(mSkillScrollerWidget, "SkillScroller");
getWidget(mLeftPane, "LeftPane");
getWidget(mRightPane, "RightPane");
skillClientWidget->eventMouseWheel += MyGUI::newDelegate(this, &StatsWindow::onMouseWheel);
mSkillClientWidget->eventMouseWheel += MyGUI::newDelegate(this, &StatsWindow::onMouseWheel);
skillScrollerWidget->eventScrollChangePosition += MyGUI::newDelegate(this, &StatsWindow::onScrollChangePosition);
mSkillScrollerWidget->eventScrollChangePosition += MyGUI::newDelegate(this, &StatsWindow::onScrollChangePosition);
updateScroller();
for (int i = 0; i < ESM::Skill::Length; ++i)
{
skillValues.insert(std::pair<int, MWMechanics::Stat<float> >(i, MWMechanics::Stat<float>()));
skillWidgetMap.insert(std::pair<int, MyGUI::TextBox*>(i, nullptr));
mSkillValues.insert(std::pair<int, MWMechanics::Stat<float> >(i, MWMechanics::Stat<float>()));
mSkillWidgetMap.insert(std::pair<int, MyGUI::TextBox*>(i, nullptr));
}
MyGUI::WindowPtr t = static_cast<MyGUI::WindowPtr>(mMainWidget);
@ -85,14 +85,14 @@ StatsWindow::StatsWindow (WindowManager& parWindowManager)
void StatsWindow::onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos)
{
int diff = lastPos - pos;
int diff = mLastPos - pos;
// Adjust position of all widget according to difference
if (diff == 0)
return;
lastPos = pos;
mLastPos = pos;
std::vector<MyGUI::WidgetPtr>::const_iterator end = skillWidgets.end();
for (std::vector<MyGUI::WidgetPtr>::const_iterator it = skillWidgets.begin(); it != end; ++it)
std::vector<MyGUI::WidgetPtr>::const_iterator end = mSkillWidgets.end();
for (std::vector<MyGUI::WidgetPtr>::const_iterator it = mSkillWidgets.begin(); it != end; ++it)
{
(*it)->setCoord((*it)->getCoord() + MyGUI::IntPoint(0, diff));
}
@ -100,14 +100,14 @@ void StatsWindow::onScrollChangePosition(MyGUI::ScrollBar* scroller, size_t pos)
void StatsWindow::onMouseWheel(MyGUI::Widget* _sender, int _rel)
{
if (skillScrollerWidget->getScrollPosition() - _rel*0.3 < 0)
skillScrollerWidget->setScrollPosition(0);
else if (skillScrollerWidget->getScrollPosition() - _rel*0.3 > skillScrollerWidget->getScrollRange()-1)
skillScrollerWidget->setScrollPosition(skillScrollerWidget->getScrollRange()-1);
if (mSkillScrollerWidget->getScrollPosition() - _rel*0.3 < 0)
mSkillScrollerWidget->setScrollPosition(0);
else if (mSkillScrollerWidget->getScrollPosition() - _rel*0.3 > mSkillScrollerWidget->getScrollRange()-1)
mSkillScrollerWidget->setScrollPosition(mSkillScrollerWidget->getScrollRange()-1);
else
skillScrollerWidget->setScrollPosition(skillScrollerWidget->getScrollPosition() - _rel*0.3);
mSkillScrollerWidget->setScrollPosition(mSkillScrollerWidget->getScrollPosition() - _rel*0.3);
onScrollChangePosition(skillScrollerWidget, skillScrollerWidget->getScrollPosition());
onScrollChangePosition(mSkillScrollerWidget, mSkillScrollerWidget->getScrollPosition());
}
void StatsWindow::onWindowResize(MyGUI::Window* window)
@ -224,8 +224,8 @@ void StatsWindow::setValue (const std::string& id, int value)
void StatsWindow::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechanics::Stat<float>& value)
{
skillValues[parSkill] = value;
MyGUI::TextBox* widget = skillWidgetMap[(int)parSkill];
mSkillValues[parSkill] = value;
MyGUI::TextBox* widget = mSkillWidgetMap[(int)parSkill];
if (widget)
{
float modified = value.getModified(), base = value.getBase();
@ -243,20 +243,20 @@ void StatsWindow::setValue(const ESM::Skill::SkillEnum parSkill, const MWMechani
void StatsWindow::configureSkills (const std::vector<int>& major, const std::vector<int>& minor)
{
majorSkills = major;
minorSkills = minor;
mMajorSkills = major;
mMinorSkills = minor;
// Update misc skills with the remaining skills not in major or minor
std::set<int> skillSet;
std::copy(major.begin(), major.end(), std::inserter(skillSet, skillSet.begin()));
std::copy(minor.begin(), minor.end(), std::inserter(skillSet, skillSet.begin()));
boost::array<ESM::Skill::SkillEnum, ESM::Skill::Length>::const_iterator end = ESM::Skill::skillIds.end();
miscSkills.clear();
mMiscSkills.clear();
for (boost::array<ESM::Skill::SkillEnum, ESM::Skill::Length>::const_iterator it = ESM::Skill::skillIds.begin(); it != end; ++it)
{
int skill = *it;
if (skillSet.find(skill) == skillSet.end())
miscSkills.push_back(skill);
mMiscSkills.push_back(skill);
}
updateSkillArea();
@ -270,7 +270,7 @@ void StatsWindow::onFrame ()
MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
MWMechanics::NpcStats PCstats = MWWorld::Class::get(player).getNpcStats(player);
setFactions(PCstats.mFactionRank);
setFactions(PCstats.getFactionRanks());
setBirthSign(MWBase::Environment::get().getWorld()->getPlayer().getBirthsign());
@ -289,20 +289,20 @@ void StatsWindow::setFactions (const FactionList& factions)
void StatsWindow::setBirthSign (const std::string& signId)
{
if (signId != birthSignId)
if (signId != mBirthSignId)
{
birthSignId = signId;
mBirthSignId = signId;
mChanged = true;
}
}
void StatsWindow::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::ImageBox* separator = skillClientWidget->createWidget<MyGUI::ImageBox>("MW_HLine",
MyGUI::ImageBox* separator = mSkillClientWidget->createWidget<MyGUI::ImageBox>("MW_HLine",
MyGUI::IntCoord(10, coord1.top, coord1.width + coord2.width - 4, 18),
MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
separator->eventMouseWheel += MyGUI::newDelegate(this, &StatsWindow::onMouseWheel);
skillWidgets.push_back(separator);
mSkillWidgets.push_back(separator);
coord1.top += separator->getHeight();
coord2.top += separator->getHeight();
@ -310,35 +310,35 @@ void StatsWindow::addSeparator(MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
void StatsWindow::addGroup(const std::string &label, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox* groupWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandBrightText",
MyGUI::TextBox* groupWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandBrightText",
MyGUI::IntCoord(0, coord1.top, coord1.width + coord2.width, coord1.height),
MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
groupWidget->setCaption(label);
groupWidget->eventMouseWheel += MyGUI::newDelegate(this, &StatsWindow::onMouseWheel);
skillWidgets.push_back(groupWidget);
mSkillWidgets.push_back(groupWidget);
coord1.top += lineHeight;
coord2.top += lineHeight;
coord1.top += sLineHeight;
coord2.top += sLineHeight;
}
MyGUI::TextBox* StatsWindow::addValueItem(const std::string& text, const std::string &value, const std::string& state, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
MyGUI::TextBox *skillNameWidget, *skillValueWidget;
skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1, MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
skillNameWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1, MyGUI::Align::Left | MyGUI::Align::Top | MyGUI::Align::HStretch);
skillNameWidget->setCaption(text);
skillNameWidget->eventMouseWheel += MyGUI::newDelegate(this, &StatsWindow::onMouseWheel);
skillValueWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandTextRight", coord2, MyGUI::Align::Right | MyGUI::Align::Top);
skillValueWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandTextRight", coord2, MyGUI::Align::Right | MyGUI::Align::Top);
skillValueWidget->setCaption(value);
skillValueWidget->_setWidgetState(state);
skillValueWidget->eventMouseWheel += MyGUI::newDelegate(this, &StatsWindow::onMouseWheel);
skillWidgets.push_back(skillNameWidget);
skillWidgets.push_back(skillValueWidget);
mSkillWidgets.push_back(skillNameWidget);
mSkillWidgets.push_back(skillValueWidget);
coord1.top += lineHeight;
coord2.top += lineHeight;
coord1.top += sLineHeight;
coord2.top += sLineHeight;
return skillValueWidget;
}
@ -347,14 +347,14 @@ MyGUI::Widget* StatsWindow::addItem(const std::string& text, MyGUI::IntCoord &co
{
MyGUI::TextBox* skillNameWidget;
skillNameWidget = skillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
skillNameWidget = mSkillClientWidget->createWidget<MyGUI::TextBox>("SandText", coord1 + MyGUI::IntSize(coord2.width, 0), MyGUI::Align::Default);
skillNameWidget->setCaption(text);
skillNameWidget->eventMouseWheel += MyGUI::newDelegate(this, &StatsWindow::onMouseWheel);
skillWidgets.push_back(skillNameWidget);
mSkillWidgets.push_back(skillNameWidget);
coord1.top += lineHeight;
coord2.top += lineHeight;
coord1.top += sLineHeight;
coord2.top += sLineHeight;
return skillNameWidget;
}
@ -362,7 +362,7 @@ MyGUI::Widget* StatsWindow::addItem(const std::string& text, MyGUI::IntCoord &co
void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId, const std::string &titleDefault, MyGUI::IntCoord &coord1, MyGUI::IntCoord &coord2)
{
// Add a line separator if there are items above
if (!skillWidgets.empty())
if (!mSkillWidgets.empty())
{
addSeparator(coord1, coord2);
}
@ -377,7 +377,7 @@ void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId,
continue;
assert(skillId >= 0 && skillId < ESM::Skill::Length);
const std::string &skillNameId = ESMS::Skill::sSkillNameIds[skillId];
const MWMechanics::Stat<float> &stat = skillValues.find(skillId)->second;
const MWMechanics::Stat<float> &stat = mSkillValues.find(skillId)->second;
float base = stat.getBase();
float modified = stat.getModified();
int progressPercent = (modified - float(static_cast<int>(modified))) * 100;
@ -400,18 +400,18 @@ void StatsWindow::addSkills(const SkillList &skills, const std::string &titleId,
for (int i=0; i<2; ++i)
{
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipType", "Layout");
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipLayout", "SkillToolTip");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillName", "#{"+skillNameId+"}");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillDescription", skill->description);
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillAttribute", "#{sGoverningAttribute}: #{" + attr->name + "}");
skillWidgets[skillWidgets.size()-1-i]->setUserString("ImageTexture_SkillImage", icon);
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_SkillProgressText", boost::lexical_cast<std::string>(progressPercent)+"/100");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Range_SkillProgress", "100");
skillWidgets[skillWidgets.size()-1-i]->setUserString("RangePosition_SkillProgress", boost::lexical_cast<std::string>(progressPercent));
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("ToolTipType", "Layout");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("ToolTipLayout", "SkillToolTip");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("Caption_SkillName", "#{"+skillNameId+"}");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("Caption_SkillDescription", skill->description);
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("Caption_SkillAttribute", "#{sGoverningAttribute}: #{" + attr->name + "}");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("ImageTexture_SkillImage", icon);
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("Caption_SkillProgressText", boost::lexical_cast<std::string>(progressPercent)+"/100");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("Range_SkillProgress", "100");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("RangePosition_SkillProgress", boost::lexical_cast<std::string>(progressPercent));
}
skillWidgetMap[skillId] = widget;
mSkillWidgetMap[skillId] = widget;
}
}
@ -419,28 +419,28 @@ void StatsWindow::updateSkillArea()
{
mChanged = false;
for (std::vector<MyGUI::WidgetPtr>::iterator it = skillWidgets.begin(); it != skillWidgets.end(); ++it)
for (std::vector<MyGUI::WidgetPtr>::iterator it = mSkillWidgets.begin(); it != mSkillWidgets.end(); ++it)
{
MyGUI::Gui::getInstance().destroyWidget(*it);
}
skillWidgets.clear();
mSkillWidgets.clear();
skillScrollerWidget->setScrollPosition(0);
onScrollChangePosition(skillScrollerWidget, 0);
clientHeight = 0;
mSkillScrollerWidget->setScrollPosition(0);
onScrollChangePosition(mSkillScrollerWidget, 0);
mClientHeight = 0;
const int valueSize = 40;
MyGUI::IntCoord coord1(10, 0, skillClientWidget->getWidth() - (10 + valueSize), 18);
MyGUI::IntCoord coord1(10, 0, mSkillClientWidget->getWidth() - (10 + valueSize), 18);
MyGUI::IntCoord coord2(coord1.left + coord1.width, coord1.top, valueSize, coord1.height);
if (!majorSkills.empty())
addSkills(majorSkills, "sSkillClassMajor", "Major Skills", coord1, coord2);
if (!mMajorSkills.empty())
addSkills(mMajorSkills, "sSkillClassMajor", "Major Skills", coord1, coord2);
if (!minorSkills.empty())
addSkills(minorSkills, "sSkillClassMinor", "Minor Skills", coord1, coord2);
if (!mMinorSkills.empty())
addSkills(mMinorSkills, "sSkillClassMinor", "Minor Skills", coord1, coord2);
if (!miscSkills.empty())
addSkills(miscSkills, "sSkillClassMisc", "Misc Skills", coord1, coord2);
if (!mMiscSkills.empty())
addSkills(mMiscSkills, "sSkillClassMisc", "Misc Skills", coord1, coord2);
const ESMS::ESMStore &store = mWindowManager.getStore();
@ -463,7 +463,7 @@ void StatsWindow::updateSkillArea()
if (!mFactions.empty())
{
// Add a line separator if there are items above
if (!skillWidgets.empty())
if (!mSkillWidgets.empty())
addSeparator(coord1, coord2);
addGroup(mWindowManager.getGameSettingString("sFaction", "Faction"), coord1, coord2);
@ -516,53 +516,53 @@ void StatsWindow::updateSkillArea()
}
}
if (!birthSignId.empty())
if (!mBirthSignId.empty())
{
// Add a line separator if there are items above
if (!skillWidgets.empty())
if (!mSkillWidgets.empty())
addSeparator(coord1, coord2);
addGroup(mWindowManager.getGameSettingString("sBirthSign", "Sign"), coord1, coord2);
const ESM::BirthSign *sign = store.birthSigns.find(birthSignId);
const ESM::BirthSign *sign = store.birthSigns.find(mBirthSignId);
MyGUI::Widget* w = addItem(sign->name, coord1, coord2);
ToolTips::createBirthsignToolTip(w, birthSignId);
ToolTips::createBirthsignToolTip(w, mBirthSignId);
}
// Add a line separator if there are items above
if (!skillWidgets.empty())
if (!mSkillWidgets.empty())
addSeparator(coord1, coord2);
addValueItem(mWindowManager.getGameSettingString("sReputation", "Reputation"),
boost::lexical_cast<std::string>(static_cast<int>(reputation)), "normal", coord1, coord2);
boost::lexical_cast<std::string>(static_cast<int>(mReputation)), "normal", coord1, coord2);
for (int i=0; i<2; ++i)
{
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipType", "Layout");
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipLayout", "TextToolTip");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_Text", "#{sSkillsMenuReputationHelp}");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("ToolTipType", "Layout");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("ToolTipLayout", "TextToolTip");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("Caption_Text", "#{sSkillsMenuReputationHelp}");
}
addValueItem(mWindowManager.getGameSettingString("sBounty", "Bounty"),
boost::lexical_cast<std::string>(static_cast<int>(bounty)), "normal", coord1, coord2);
boost::lexical_cast<std::string>(static_cast<int>(mBounty)), "normal", coord1, coord2);
for (int i=0; i<2; ++i)
{
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipType", "Layout");
skillWidgets[skillWidgets.size()-1-i]->setUserString("ToolTipLayout", "TextToolTip");
skillWidgets[skillWidgets.size()-1-i]->setUserString("Caption_Text", "#{sCrimeHelp}");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("ToolTipType", "Layout");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("ToolTipLayout", "TextToolTip");
mSkillWidgets[mSkillWidgets.size()-1-i]->setUserString("Caption_Text", "#{sCrimeHelp}");
}
clientHeight = coord1.top;
mClientHeight = coord1.top;
updateScroller();
}
void StatsWindow::updateScroller()
{
skillScrollerWidget->setScrollRange(std::max(clientHeight - skillClientWidget->getHeight(), 0));
skillScrollerWidget->setScrollPage(std::max(skillClientWidget->getHeight() - lineHeight, 0));
if (clientHeight != 0)
skillScrollerWidget->setTrackSize( (skillAreaWidget->getHeight() / float(clientHeight)) * skillScrollerWidget->getLineSize() );
mSkillScrollerWidget->setScrollRange(std::max(mClientHeight - mSkillClientWidget->getHeight(), 0));
mSkillScrollerWidget->setScrollPage(std::max(mSkillClientWidget->getHeight() - sLineHeight, 0));
if (mClientHeight != 0)
mSkillScrollerWidget->setTrackSize( (mSkillAreaWidget->getHeight() / float(mClientHeight)) * mSkillScrollerWidget->getLineSize() );
}
void StatsWindow::onPinToggled()

26
apps/openmw/mwgui/stats_window.hpp
Unescape Escape View File

@ -38,8 +38,8 @@ namespace MWGui
void setValue(const ESM::Skill::SkillEnum parSkill, const MWMechanics::Stat<float>& value);
void configureSkills (const SkillList& major, const SkillList& minor);
void setReputation (int reputation) { this->reputation = reputation; }
void setBounty (int bounty) { this->bounty = bounty; }
void setReputation (int reputation) { this->mReputation = reputation; }
void setBounty (int bounty) { this->mBounty = bounty; }
void updateSkillArea();
private:
@ -57,23 +57,23 @@ namespace MWGui
void onWindowResize(MyGUI::Window* window);
void onMouseWheel(MyGUI::Widget* _sender, int _rel);
static const int lineHeight;
static const int sLineHeight;
MyGUI::Widget* mLeftPane;
MyGUI::Widget* mRightPane;
MyGUI::WidgetPtr skillAreaWidget, skillClientWidget;
MyGUI::ScrollBar* skillScrollerWidget;
int lastPos, clientHeight;
MyGUI::WidgetPtr mSkillAreaWidget, mSkillClientWidget;
MyGUI::ScrollBar* mSkillScrollerWidget;
int mLastPos, mClientHeight;
SkillList majorSkills, minorSkills, miscSkills;
std::map<int, MWMechanics::Stat<float> > skillValues;
std::map<int, MyGUI::TextBox*> skillWidgetMap;
std::map<std::string, MyGUI::WidgetPtr> factionWidgetMap;
SkillList mMajorSkills, mMinorSkills, mMiscSkills;
std::map<int, MWMechanics::Stat<float> > mSkillValues;
std::map<int, MyGUI::TextBox*> mSkillWidgetMap;
std::map<std::string, MyGUI::WidgetPtr> mFactionWidgetMap;
FactionList mFactions; ///< Stores a list of factions and the current rank
std::string birthSignId;
int reputation, bounty;
std::vector<MyGUI::WidgetPtr> skillWidgets; //< Skills and other information
std::string mBirthSignId;
int mReputation, mBounty;
std::vector<MyGUI::WidgetPtr> mSkillWidgets; //< Skills and other information
bool mChanged;

8
apps/openmw/mwgui/text_input.cpp
Unescape Escape View File

@ -9,15 +9,15 @@ TextInputDialog::TextInputDialog(WindowManager& parWindowManager)
// Centre dialog
center();
getWidget(textEdit, "TextEdit");
textEdit->eventEditSelectAccept += newDelegate(this, &TextInputDialog::onTextAccepted);
getWidget(mTextEdit, "TextEdit");
mTextEdit->eventEditSelectAccept += newDelegate(this, &TextInputDialog::onTextAccepted);
MyGUI::ButtonPtr okButton;
getWidget(okButton, "OKButton");
okButton->eventMouseButtonClick += MyGUI::newDelegate(this, &TextInputDialog::onOkClicked);
// Make sure the edit box has focus
MyGUI::InputManager::getInstance().setKeyFocusWidget(textEdit);
MyGUI::InputManager::getInstance().setKeyFocusWidget(mTextEdit);
}
void TextInputDialog::setNextButtonShow(bool shown)
@ -43,7 +43,7 @@ void TextInputDialog::setTextLabel(const std::string &label)
void TextInputDialog::open()
{
// Make sure the edit box has focus
MyGUI::InputManager::getInstance().setKeyFocusWidget(textEdit);
MyGUI::InputManager::getInstance().setKeyFocusWidget(mTextEdit);
setVisible(true);
}

6
apps/openmw/mwgui/text_input.hpp
Unescape Escape View File

@ -20,8 +20,8 @@ namespace MWGui
public:
TextInputDialog(WindowManager& parWindowManager);
std::string getTextInput() const { return textEdit ? textEdit->getOnlyText() : ""; }
void setTextInput(const std::string &text) { if (textEdit) textEdit->setOnlyText(text); }
std::string getTextInput() const { return mTextEdit ? mTextEdit->getOnlyText() : ""; }
void setTextInput(const std::string &text) { if (mTextEdit) mTextEdit->setOnlyText(text); }
void setNextButtonShow(bool shown);
void setTextLabel(const std::string &label);
@ -32,7 +32,7 @@ namespace MWGui
void onTextAccepted(MyGUI::Edit* _sender);
private:
MyGUI::EditPtr textEdit;
MyGUI::EditPtr mTextEdit;
};
}
#endif

166
apps/openmw/mwgui/widgets.cpp
Unescape Escape View File

@ -27,16 +27,16 @@ void MWGui::Widgets::fixTexturePath(std::string &path)
/* MWSkill */
MWSkill::MWSkill()
: manager(nullptr)
, skillId(ESM::Skill::Length)
, skillNameWidget(nullptr)
, skillValueWidget(nullptr)
: mManager(nullptr)
, mSkillId(ESM::Skill::Length)
, mSkillNameWidget(nullptr)
, mSkillValueWidget(nullptr)
{
}
void MWSkill::setSkillId(ESM::Skill::SkillEnum skill)
{
skillId = skill;
mSkillId = skill;
updateWidgets();
}
@ -50,36 +50,36 @@ void MWSkill::setSkillNumber(int skill)
throw new std::runtime_error("Skill number out of range");
}
void MWSkill::setSkillValue(const SkillValue& value_)
void MWSkill::setSkillValue(const SkillValue& value)
{
value = value_;
mValue = value;
updateWidgets();
}
void MWSkill::updateWidgets()
{
if (skillNameWidget && manager)
if (mSkillNameWidget && mManager)
{
if (skillId == ESM::Skill::Length)
if (mSkillId == ESM::Skill::Length)
{
static_cast<MyGUI::TextBox*>(skillNameWidget)->setCaption("");
static_cast<MyGUI::TextBox*>(mSkillNameWidget)->setCaption("");
}
else
{
const std::string &name = manager->getGameSettingString(ESM::Skill::sSkillNameIds[skillId], "");
static_cast<MyGUI::TextBox*>(skillNameWidget)->setCaption(name);
const std::string &name = mManager->getGameSettingString(ESM::Skill::sSkillNameIds[mSkillId], "");
static_cast<MyGUI::TextBox*>(mSkillNameWidget)->setCaption(name);
}
}
if (skillValueWidget)
if (mSkillValueWidget)
{
SkillValue::Type modified = value.getModified(), base = value.getBase();
static_cast<MyGUI::TextBox*>(skillValueWidget)->setCaption(boost::lexical_cast<std::string>(modified));
SkillValue::Type modified = mValue.getModified(), base = mValue.getBase();
static_cast<MyGUI::TextBox*>(mSkillValueWidget)->setCaption(boost::lexical_cast<std::string>(modified));
if (modified > base)
skillValueWidget->_setWidgetState("increased");
mSkillValueWidget->_setWidgetState("increased");
else if (modified < base)
skillValueWidget->_setWidgetState("decreased");
mSkillValueWidget->_setWidgetState("decreased");
else
skillValueWidget->_setWidgetState("normal");
mSkillValueWidget->_setWidgetState("normal");
}
}
@ -96,14 +96,14 @@ void MWSkill::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(skillNameWidget, "StatName");
assignWidget(skillValueWidget, "StatValue");
assignWidget(mSkillNameWidget, "StatName");
assignWidget(mSkillValueWidget, "StatValue");
MyGUI::ButtonPtr button;
assignWidget(button, "StatNameButton");
if (button)
{
skillNameWidget = button;
mSkillNameWidget = button;
button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWSkill::onClicked);
}
@ -111,7 +111,7 @@ void MWSkill::initialiseOverride()
assignWidget(button, "StatValueButton");
if (button)
{
skillNameWidget = button;
mSkillNameWidget = button;
button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWSkill::onClicked);
}
}
@ -119,22 +119,22 @@ void MWSkill::initialiseOverride()
/* MWAttribute */
MWAttribute::MWAttribute()
: manager(nullptr)
, id(-1)
, attributeNameWidget(nullptr)
, attributeValueWidget(nullptr)
: mManager(nullptr)
, mId(-1)
, mAttributeNameWidget(nullptr)
, mAttributeValueWidget(nullptr)
{
}
void MWAttribute::setAttributeId(int attributeId)
{
id = attributeId;
mId = attributeId;
updateWidgets();
}
void MWAttribute::setAttributeValue(const AttributeValue& value_)
void MWAttribute::setAttributeValue(const AttributeValue& value)
{
value = value_;
mValue = value;
updateWidgets();
}
@ -145,11 +145,11 @@ void MWAttribute::onClicked(MyGUI::Widget* _sender)
void MWAttribute::updateWidgets()
{
if (attributeNameWidget && manager)
if (mAttributeNameWidget && mManager)
{
if (id < 0 || id >= 8)
if (mId < 0 || mId >= 8)
{
static_cast<MyGUI::TextBox*>(attributeNameWidget)->setCaption("");
static_cast<MyGUI::TextBox*>(mAttributeNameWidget)->setCaption("");
}
else
{
@ -163,20 +163,20 @@ void MWAttribute::updateWidgets()
"sAttributePersonality",
"sAttributeLuck"
};
const std::string &name = manager->getGameSettingString(attributes[id], "");
static_cast<MyGUI::TextBox*>(attributeNameWidget)->setCaption(name);
const std::string &name = mManager->getGameSettingString(attributes[mId], "");
static_cast<MyGUI::TextBox*>(mAttributeNameWidget)->setCaption(name);
}
}
if (attributeValueWidget)
if (mAttributeValueWidget)
{
AttributeValue::Type modified = value.getModified(), base = value.getBase();
static_cast<MyGUI::TextBox*>(attributeValueWidget)->setCaption(boost::lexical_cast<std::string>(modified));
AttributeValue::Type modified = mValue.getModified(), base = mValue.getBase();
static_cast<MyGUI::TextBox*>(mAttributeValueWidget)->setCaption(boost::lexical_cast<std::string>(modified));
if (modified > base)
attributeValueWidget->_setWidgetState("increased");
mAttributeValueWidget->_setWidgetState("increased");
else if (modified < base)
attributeValueWidget->_setWidgetState("decreased");
mAttributeValueWidget->_setWidgetState("decreased");
else
attributeValueWidget->_setWidgetState("normal");
mAttributeValueWidget->_setWidgetState("normal");
}
}
@ -188,14 +188,14 @@ void MWAttribute::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(attributeNameWidget, "StatName");
assignWidget(attributeValueWidget, "StatValue");
assignWidget(mAttributeNameWidget, "StatName");
assignWidget(mAttributeValueWidget, "StatValue");
MyGUI::ButtonPtr button;
assignWidget(button, "StatNameButton");
if (button)
{
attributeNameWidget = button;
mAttributeNameWidget = button;
button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWAttribute::onClicked);
}
@ -203,7 +203,7 @@ void MWAttribute::initialiseOverride()
assignWidget(button, "StatValueButton");
if (button)
{
attributeValueWidget = button;
mAttributeValueWidget = button;
button->eventMouseButtonClick += MyGUI::newDelegate(this, &MWAttribute::onClicked);
}
}
@ -212,21 +212,21 @@ void MWAttribute::initialiseOverride()
MWSpell::MWSpell()
: mWindowManager(nullptr)
, spellNameWidget(nullptr)
, mSpellNameWidget(nullptr)
{
}
void MWSpell::setSpellId(const std::string &spellId)
{
id = spellId;
mId = spellId;
updateWidgets();
}
void MWSpell::createEffectWidgets(std::vector<MyGUI::WidgetPtr> &effects, MyGUI::WidgetPtr creator, MyGUI::IntCoord &coord, int flags)
{
const ESMS::ESMStore &store = mWindowManager->getStore();
const ESM::Spell *spell = store.spells.search(id);
MYGUI_ASSERT(spell, "spell with id '" << id << "' not found");
const ESM::Spell *spell = store.spells.search(mId);
MYGUI_ASSERT(spell, "spell with id '" << mId << "' not found");
MWSpellEffectPtr effect = nullptr;
std::vector<ESM::ENAMstruct>::const_iterator end = spell->effects.list.end();
@ -253,14 +253,14 @@ void MWSpell::createEffectWidgets(std::vector<MyGUI::WidgetPtr> &effects, MyGUI:
void MWSpell::updateWidgets()
{
if (spellNameWidget && mWindowManager)
if (mSpellNameWidget && mWindowManager)
{
const ESMS::ESMStore &store = mWindowManager->getStore();
const ESM::Spell *spell = store.spells.search(id);
const ESM::Spell *spell = store.spells.search(mId);
if (spell)
static_cast<MyGUI::TextBox*>(spellNameWidget)->setCaption(spell->name);
static_cast<MyGUI::TextBox*>(mSpellNameWidget)->setCaption(spell->name);
else
static_cast<MyGUI::TextBox*>(spellNameWidget)->setCaption("");
static_cast<MyGUI::TextBox*>(mSpellNameWidget)->setCaption("");
}
}
@ -268,7 +268,7 @@ void MWSpell::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(spellNameWidget, "StatName");
assignWidget(mSpellNameWidget, "StatName");
}
MWSpell::~MWSpell()
@ -367,8 +367,8 @@ SpellEffectList MWEffectList::effectListFromESM(const ESM::EffectList* effects)
MWSpellEffect::MWSpellEffect()
: mWindowManager(nullptr)
, imageWidget(nullptr)
, textWidget(nullptr)
, mImageWidget(nullptr)
, mTextWidget(nullptr)
, mRequestedWidth(0)
{
}
@ -388,7 +388,7 @@ void MWSpellEffect::updateWidgets()
const ESM::MagicEffect *magicEffect = store.magicEffects.search(mEffectParams.mEffectID);
if (!magicEffect)
return;
if (textWidget)
if (mTextWidget)
{
std::string pt = mWindowManager->getGameSettingString("spoint", "");
std::string pts = mWindowManager->getGameSettingString("spoints", "");
@ -448,14 +448,14 @@ void MWSpellEffect::updateWidgets()
}
}
static_cast<MyGUI::TextBox*>(textWidget)->setCaption(spellLine);
mRequestedWidth = textWidget->getTextSize().width + 24;
static_cast<MyGUI::TextBox*>(mTextWidget)->setCaption(spellLine);
mRequestedWidth = mTextWidget->getTextSize().width + 24;
}
if (imageWidget)
if (mImageWidget)
{
std::string path = std::string("icons\\") + magicEffect->icon;
fixTexturePath(path);
imageWidget->setImageTexture(path);
mImageWidget->setImageTexture(path);
}
}
@ -728,49 +728,49 @@ void MWSpellEffect::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(textWidget, "Text");
assignWidget(imageWidget, "Image");
assignWidget(mTextWidget, "Text");
assignWidget(mImageWidget, "Image");
}
/* MWDynamicStat */
MWDynamicStat::MWDynamicStat()
: value(0)
, max(1)
, textWidget(nullptr)
, barWidget(nullptr)
, barTextWidget(nullptr)
: mValue(0)
, mMax(1)
, mTextWidget(nullptr)
, mBarWidget(nullptr)
, mBarTextWidget(nullptr)
{
}
void MWDynamicStat::setValue(int cur, int max_)
void MWDynamicStat::setValue(int cur, int max)
{
value = cur;
max = max_;
mValue = cur;
mMax = max;
if (barWidget)
if (mBarWidget)
{
barWidget->setProgressRange(max);
barWidget->setProgressPosition(value);
mBarWidget->setProgressRange(mMax);
mBarWidget->setProgressPosition(mValue);
}
if (barTextWidget)
if (mBarTextWidget)
{
if (value >= 0 && max > 0)
if (mValue >= 0 && mMax > 0)
{
std::stringstream out;
out << value << "/" << max;
static_cast<MyGUI::TextBox*>(barTextWidget)->setCaption(out.str().c_str());
out << mValue << "/" << mMax;
static_cast<MyGUI::TextBox*>(mBarTextWidget)->setCaption(out.str().c_str());
}
else
static_cast<MyGUI::TextBox*>(barTextWidget)->setCaption("");
static_cast<MyGUI::TextBox*>(mBarTextWidget)->setCaption("");
}
}
void MWDynamicStat::setTitle(const std::string& text)
{
if (textWidget)
static_cast<MyGUI::TextBox*>(textWidget)->setCaption(text);
if (mTextWidget)
static_cast<MyGUI::TextBox*>(mTextWidget)->setCaption(text);
}
MWDynamicStat::~MWDynamicStat()
@ -781,7 +781,7 @@ void MWDynamicStat::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(textWidget, "Text");
assignWidget(barWidget, "Bar");
assignWidget(barTextWidget, "BarText");
assignWidget(mTextWidget, "Text");
assignWidget(mBarWidget, "Bar");
assignWidget(mBarTextWidget, "BarText");
}

66
apps/openmw/mwgui/widgets.hpp
Unescape Escape View File

@ -73,7 +73,7 @@ namespace MWGui
typedef std::vector<SpellEffectParams> SpellEffectList;
class MYGUI_EXPORT MWSkill : public Widget
class MYGUI_EXPORT MWSkill : public MyGUI::Widget
{
MYGUI_RTTI_DERIVED( MWSkill );
public:
@ -81,14 +81,14 @@ namespace MWGui
typedef MWMechanics::Stat<float> SkillValue;
void setWindowManager(WindowManager *m) { manager = m; }
void setWindowManager(WindowManager *m) { mManager = m; }
void setSkillId(ESM::Skill::SkillEnum skillId);
void setSkillNumber(int skillId);
void setSkillValue(const SkillValue& value);
WindowManager *getWindowManager() const { return manager; }
ESM::Skill::SkillEnum getSkillId() const { return skillId; }
const SkillValue& getSkillValue() const { return value; }
WindowManager *getWindowManager() const { return mManager; }
ESM::Skill::SkillEnum getSkillId() const { return mSkillId; }
const SkillValue& getSkillValue() const { return mValue; }
// Events
typedef delegates::CMultiDelegate1<MWSkill*> EventHandle_SkillVoid;
@ -109,14 +109,14 @@ namespace MWGui
void updateWidgets();
WindowManager *manager;
ESM::Skill::SkillEnum skillId;
SkillValue value;
MyGUI::WidgetPtr skillNameWidget, skillValueWidget;
WindowManager *mManager;
ESM::Skill::SkillEnum mSkillId;
SkillValue mValue;
MyGUI::WidgetPtr mSkillNameWidget, mSkillValueWidget;
};
typedef MWSkill* MWSkillPtr;
class MYGUI_EXPORT MWAttribute : public Widget
class MYGUI_EXPORT MWAttribute : public MyGUI::Widget
{
MYGUI_RTTI_DERIVED( MWAttribute );
public:
@ -124,13 +124,13 @@ namespace MWGui
typedef MWMechanics::Stat<int> AttributeValue;
void setWindowManager(WindowManager *m) { manager = m; }
void setWindowManager(WindowManager *m) { mManager = m; }
void setAttributeId(int attributeId);
void setAttributeValue(const AttributeValue& value);
WindowManager *getWindowManager() const { return manager; }
int getAttributeId() const { return id; }
const AttributeValue& getAttributeValue() const { return value; }
WindowManager *getWindowManager() const { return mManager; }
int getAttributeId() const { return mId; }
const AttributeValue& getAttributeValue() const { return mValue; }
// Events
typedef delegates::CMultiDelegate1<MWAttribute*> EventHandle_AttributeVoid;
@ -151,10 +151,10 @@ namespace MWGui
void updateWidgets();
WindowManager *manager;
int id;
AttributeValue value;
MyGUI::WidgetPtr attributeNameWidget, attributeValueWidget;
WindowManager *mManager;
int mId;
AttributeValue mValue;
MyGUI::WidgetPtr mAttributeNameWidget, mAttributeValueWidget;
};
typedef MWAttribute* MWAttributePtr;
@ -162,7 +162,7 @@ namespace MWGui
* @todo remove this class and use MWEffectList instead
*/
class MWSpellEffect;
class MYGUI_EXPORT MWSpell : public Widget
class MYGUI_EXPORT MWSpell : public MyGUI::Widget
{
MYGUI_RTTI_DERIVED( MWSpell );
public:
@ -182,7 +182,7 @@ namespace MWGui
*/
void createEffectWidgets(std::vector<MyGUI::WidgetPtr> &effects, MyGUI::WidgetPtr creator, MyGUI::IntCoord &coord, int flags);
const std::string &getSpellId() const { return id; }
const std::string &getSpellId() const { return mId; }
protected:
virtual ~MWSpell();
@ -193,12 +193,12 @@ namespace MWGui
void updateWidgets();
WindowManager* mWindowManager;
std::string id;
MyGUI::TextBox* spellNameWidget;
std::string mId;
MyGUI::TextBox* mSpellNameWidget;
};
typedef MWSpell* MWSpellPtr;
class MYGUI_EXPORT MWEffectList : public Widget
class MYGUI_EXPORT MWEffectList : public MyGUI::Widget
{
MYGUI_RTTI_DERIVED( MWEffectList );
public:
@ -239,7 +239,7 @@ namespace MWGui
};
typedef MWEffectList* MWEffectListPtr;
class MYGUI_EXPORT MWSpellEffect : public Widget
class MYGUI_EXPORT MWSpellEffect : public MyGUI::Widget
{
MYGUI_RTTI_DERIVED( MWSpellEffect );
public:
@ -269,13 +269,13 @@ namespace MWGui
WindowManager* mWindowManager;
SpellEffectParams mEffectParams;
MyGUI::ImageBox* imageWidget;
MyGUI::TextBox* textWidget;
MyGUI::ImageBox* mImageWidget;
MyGUI::TextBox* mTextWidget;
int mRequestedWidth;
};
typedef MWSpellEffect* MWSpellEffectPtr;
class MYGUI_EXPORT MWDynamicStat : public Widget
class MYGUI_EXPORT MWDynamicStat : public MyGUI::Widget
{
MYGUI_RTTI_DERIVED( MWDynamicStat );
public:
@ -284,8 +284,8 @@ namespace MWGui
void setValue(int value, int max);
void setTitle(const std::string& text);
int getValue() const { return value; }
int getMax() const { return max; }
int getValue() const { return mValue; }
int getMax() const { return mMax; }
protected:
virtual ~MWDynamicStat();
@ -294,10 +294,10 @@ namespace MWGui
private:
int value, max;
MyGUI::TextBox* textWidget;
MyGUI::ProgressPtr barWidget;
MyGUI::TextBox* barTextWidget;
int mValue, mMax;
MyGUI::TextBox* mTextWidget;
MyGUI::ProgressPtr mBarWidget;
MyGUI::TextBox* mBarTextWidget;
};
typedef MWDynamicStat* MWDynamicStatPtr;
}

202
apps/openmw/mwgui/window_manager.cpp
Unescape Escape View File

@ -43,13 +43,13 @@ using namespace MWGui;
WindowManager::WindowManager(
const Compiler::Extensions& extensions, int fpsLevel, bool newGame, OEngine::Render::OgreRenderer *mOgre, const std::string& logpath)
: mGuiManager(NULL)
, hud(NULL)
, map(NULL)
, menu(NULL)
, mHud(NULL)
, mMap(NULL)
, mMenu(NULL)
, mStatsWindow(NULL)
, mToolTips(NULL)
, mMessageBoxManager(NULL)
, console(NULL)
, mConsole(NULL)
, mJournal(NULL)
, mDialogueWindow(NULL)
, mBookWindow(NULL)
@ -61,21 +61,21 @@ WindowManager::WindowManager(
, mAlchemyWindow(NULL)
, mSpellWindow(NULL)
, mCharGen(NULL)
, playerClass()
, playerName()
, playerRaceId()
, playerAttributes()
, playerMajorSkills()
, playerMinorSkills()
, playerSkillValues()
, playerHealth()
, playerMagicka()
, playerFatigue()
, gui(NULL)
, garbageDialogs()
, shown(GW_ALL)
, allowed(newGame ? GW_None : GW_ALL)
, showFPSLevel(fpsLevel)
, mPlayerClass()
, mPlayerName()
, mPlayerRaceId()
, mPlayerAttributes()
, mPlayerMajorSkills()
, mPlayerMinorSkills()
, mPlayerSkillValues()
, mPlayerHealth()
, mPlayerMagicka()
, mPlayerFatigue()
, mGui(NULL)
, mGarbageDialogs()
, mShown(GW_ALL)
, mAllowed(newGame ? GW_None : GW_ALL)
, mShowFPSLevel(fpsLevel)
, mFPS(0.0f)
, mTriangleCount(0)
, mBatchCount(0)
@ -83,7 +83,7 @@ WindowManager::WindowManager(
// Set up the GUI system
mGuiManager = new OEngine::GUI::MyGUIManager(mOgre->getWindow(), mOgre->getScene(), false, logpath);
gui = mGuiManager->getGui();
mGui = mGuiManager->getGui();
//Register own widgets with MyGUI
MyGUI::FactoryManager::getInstance().registerFactory<DialogueHistory>("Widget");
@ -98,11 +98,11 @@ WindowManager::WindowManager(
MyGUI::LanguageManager::getInstance().eventRequestTag = MyGUI::newDelegate(this, &WindowManager::onRetrieveTag);
// Get size info from the Gui object
assert(gui);
assert(mGui);
int w = MyGUI::RenderManager::getInstance().getViewSize().width;
int h = MyGUI::RenderManager::getInstance().getViewSize().height;
MyGUI::Widget* dragAndDropWidget = gui->createWidgetT("Widget","",0,0,w,h,MyGUI::Align::Default,"DragAndDrop","DragAndDropWidget");
MyGUI::Widget* dragAndDropWidget = mGui->createWidgetT("Widget","",0,0,w,h,MyGUI::Align::Default,"DragAndDrop","DragAndDropWidget");
dragAndDropWidget->setVisible(false);
mDragAndDrop = new DragAndDrop();
@ -110,17 +110,17 @@ WindowManager::WindowManager(
mDragAndDrop->mDraggedWidget = 0;
mDragAndDrop->mDragAndDropWidget = dragAndDropWidget;
menu = new MainMenu(w,h);
map = new MapWindow(*this);
mMenu = new MainMenu(w,h);
mMap = new MapWindow(*this);
mStatsWindow = new StatsWindow(*this);
console = new Console(w,h, extensions);
mConsole = new Console(w,h, extensions);
mJournal = new JournalWindow(*this);
mMessageBoxManager = new MessageBoxManager(this);
mInventoryWindow = new InventoryWindow(*this,mDragAndDrop);
mTradeWindow = new TradeWindow(*this);
mDialogueWindow = new DialogueWindow(*this);
mContainerWindow = new ContainerWindow(*this,mDragAndDrop);
hud = new HUD(w,h, showFPSLevel, mDragAndDrop);
mHud = new HUD(w,h, mShowFPSLevel, mDragAndDrop);
mToolTips = new ToolTips(this);
mScrollWindow = new ScrollWindow(*this);
mBookWindow = new BookWindow(*this);
@ -131,19 +131,19 @@ WindowManager::WindowManager(
mSpellWindow = new SpellWindow(*this);
// The HUD is always on
hud->setVisible(true);
mHud->setVisible(true);
mCharGen = new CharacterCreation(this);
// Setup player stats
for (int i = 0; i < ESM::Attribute::Length; ++i)
{
playerAttributes.insert(std::make_pair(ESM::Attribute::attributeIds[i], MWMechanics::Stat<int>()));
mPlayerAttributes.insert(std::make_pair(ESM::Attribute::attributeIds[i], MWMechanics::Stat<int>()));
}
for (int i = 0; i < ESM::Skill::Length; ++i)
{
playerSkillValues.insert(std::make_pair(ESM::Skill::skillIds[i], MWMechanics::Stat<float>()));
mPlayerSkillValues.insert(std::make_pair(ESM::Skill::skillIds[i], MWMechanics::Stat<float>()));
}
unsetSelectedSpell();
@ -156,11 +156,11 @@ WindowManager::WindowManager(
WindowManager::~WindowManager()
{
delete mGuiManager;
delete console;
delete mConsole;
delete mMessageBoxManager;
delete hud;
delete map;
delete menu;
delete mHud;
delete mMap;
delete mMenu;
delete mStatsWindow;
delete mJournal;
delete mDialogueWindow;
@ -183,13 +183,13 @@ WindowManager::~WindowManager()
void WindowManager::cleanupGarbage()
{
// Delete any dialogs which are no longer in use
if (!garbageDialogs.empty())
if (!mGarbageDialogs.empty())
{
for (std::vector<OEngine::GUI::Layout*>::iterator it = garbageDialogs.begin(); it != garbageDialogs.end(); ++it)
for (std::vector<OEngine::GUI::Layout*>::iterator it = mGarbageDialogs.begin(); it != mGarbageDialogs.end(); ++it)
{
delete *it;
}
garbageDialogs.clear();
mGarbageDialogs.clear();
}
}
@ -197,18 +197,18 @@ void WindowManager::update()
{
cleanupGarbage();
hud->setFPS(mFPS);
hud->setTriangleCount(mTriangleCount);
hud->setBatchCount(mBatchCount);
mHud->setFPS(mFPS);
mHud->setTriangleCount(mTriangleCount);
mHud->setBatchCount(mBatchCount);
}
void WindowManager::updateVisible()
{
// Start out by hiding everything except the HUD
map->setVisible(false);
menu->setVisible(false);
mMap->setVisible(false);
mMenu->setVisible(false);
mStatsWindow->setVisible(false);
console->disable();
mConsole->disable();
mJournal->setVisible(false);
mDialogueWindow->setVisible(false);
mContainerWindow->setVisible(false);
@ -230,10 +230,10 @@ void WindowManager::updateVisible()
else
mToolTips->enterGuiMode();
setMinimapVisibility((allowed & GW_Map) && !map->pinned());
setWeaponVisibility((allowed & GW_Inventory) && !mInventoryWindow->pinned());
setSpellVisibility((allowed & GW_Magic) && !mSpellWindow->pinned());
setHMSVisibility((allowed & GW_Stats) && !mStatsWindow->pinned());
setMinimapVisibility((mAllowed & GW_Map) && !mMap->pinned());
setWeaponVisibility((mAllowed & GW_Inventory) && !mInventoryWindow->pinned());
setSpellVisibility((mAllowed & GW_Magic) && !mSpellWindow->pinned());
setHMSVisibility((mAllowed & GW_Stats) && !mStatsWindow->pinned());
// If in game mode, don't show anything.
if (gameMode)
@ -243,13 +243,13 @@ void WindowManager::updateVisible()
switch(mode) {
case GM_MainMenu:
menu->setVisible(true);
mMenu->setVisible(true);
break;
case GM_Settings:
mSettingsWindow->setVisible(true);
break;
case GM_Console:
console->enable();
mConsole->enable();
break;
case GM_Scroll:
mScrollWindow->setVisible(true);
@ -276,10 +276,10 @@ void WindowManager::updateVisible()
// This is controlled both by what windows the
// user has opened/closed (the 'shown' variable) and by what
// windows we are allowed to show (the 'allowed' var.)
int eff = shown & allowed;
int eff = mShown & mAllowed;
// Show the windows we want
map -> setVisible(eff & GW_Map);
mMap ->setVisible(eff & GW_Map);
mStatsWindow ->setVisible(eff & GW_Stats);
mInventoryWindow->setVisible(eff & GW_Inventory);
mSpellWindow ->setVisible(eff & GW_Magic);
@ -333,7 +333,7 @@ void WindowManager::setValue (const std::string& id, const MWMechanics::Stat<int
{
if (id != ids[i])
continue;
playerAttributes[attributes[i]] = value;
mPlayerAttributes[attributes[i]] = value;
break;
}
}
@ -343,27 +343,27 @@ void WindowManager::setValue(const ESM::Skill::SkillEnum parSkill, const MWMecha
{
mStatsWindow->setValue(parSkill, value);
mCharGen->setValue(parSkill, value);
playerSkillValues[parSkill] = value;
mPlayerSkillValues[parSkill] = value;
}
void WindowManager::setValue (const std::string& id, const MWMechanics::DynamicStat<int>& value)
{
mStatsWindow->setValue (id, value);
hud->setValue (id, value);
mHud->setValue (id, value);
mCharGen->setValue(id, value);
if (id == "HBar")
{
playerHealth = value;
mPlayerHealth = value;
mCharGen->setPlayerHealth (value);
}
else if (id == "MBar")
{
playerMagicka = value;
mPlayerMagicka = value;
mCharGen->setPlayerMagicka (value);
}
else if (id == "FBar")
{
playerFatigue = value;
mPlayerFatigue = value;
mCharGen->setPlayerFatigue (value);
}
}
@ -372,11 +372,11 @@ void WindowManager::setValue (const std::string& id, const MWMechanics::DynamicS
MWMechanics::DynamicStat<int> WindowManager::getValue(const std::string& id)
{
if(id == "HBar")
return playerHealth;
return layerHealth;
else if (id == "MBar")
return playerMagicka;
return mPlayerMagicka;
else if (id == "FBar")
return playerFatigue;
return mPlayerFatigue;
}
#endif
@ -384,9 +384,9 @@ void WindowManager::setValue (const std::string& id, const std::string& value)
{
mStatsWindow->setValue (id, value);
if (id=="name")
playerName = value;
mPlayerName = value;
else if (id=="race")
playerRaceId = value;
mPlayerRaceId = value;
}
void WindowManager::setValue (const std::string& id, int value)
@ -396,16 +396,16 @@ void WindowManager::setValue (const std::string& id, int value)
void WindowManager::setPlayerClass (const ESM::Class &class_)
{
playerClass = class_;
mStatsWindow->setValue("class", playerClass.name);
mPlayerClass = class_;
mStatsWindow->setValue("class", mPlayerClass.name);
}
void WindowManager::configureSkills (const SkillList& major, const SkillList& minor)
{
mStatsWindow->configureSkills (major, minor);
mCharGen->configureSkills(major, minor);
playerMajorSkills = major;
playerMinorSkills = minor;
mPlayerMajorSkills = major;
mPlayerMinorSkills = minor;
}
void WindowManager::setReputation (int reputation)
@ -429,7 +429,7 @@ void WindowManager::removeDialog(OEngine::GUI::Layout*dialog)
if (!dialog)
return;
dialog->setVisible(false);
garbageDialogs.push_back(dialog);
mGarbageDialogs.push_back(dialog);
}
void WindowManager::messageBox (const std::string& message, const std::vector<std::string>& buttons)
@ -484,12 +484,12 @@ void WindowManager::onFrame (float frameDuration)
mStatsWindow->onFrame();
hud->onFrame(frameDuration);
mHud->onFrame(frameDuration);
mDialogueWindow->checkReferenceAvailable();
mTradeWindow->checkReferenceAvailable();
mContainerWindow->checkReferenceAvailable();
console->checkReferenceAvailable();
mConsole->checkReferenceAvailable();
}
const ESMS::ESMStore& WindowManager::getStore() const
@ -513,56 +513,56 @@ void WindowManager::changeCell(MWWorld::Ptr::CellStore* cell)
name = getGameSettingString("sDefaultCellname", "Wilderness");
}
map->setCellName( name );
hud->setCellName( name );
mMap->setCellName( name );
mHud->setCellName( name );
map->setCellPrefix("Cell");
hud->setCellPrefix("Cell");
map->setActiveCell( cell->cell->data.gridX, cell->cell->data.gridY );
hud->setActiveCell( cell->cell->data.gridX, cell->cell->data.gridY );
mMap->setCellPrefix("Cell");
mHud->setCellPrefix("Cell");
mMap->setActiveCell( cell->cell->data.gridX, cell->cell->data.gridY );
mHud->setActiveCell( cell->cell->data.gridX, cell->cell->data.gridY );
}
else
{
map->setCellName( cell->cell->name );
hud->setCellName( cell->cell->name );
map->setCellPrefix( cell->cell->name );
hud->setCellPrefix( cell->cell->name );
mMap->setCellName( cell->cell->name );
mHud->setCellName( cell->cell->name );
mMap->setCellPrefix( cell->cell->name );
mHud->setCellPrefix( cell->cell->name );
}
}
void WindowManager::setInteriorMapTexture(const int x, const int y)
{
map->setActiveCell(x,y, true);
hud->setActiveCell(x,y, true);
mMap->setActiveCell(x,y, true);
mHud->setActiveCell(x,y, true);
}
void WindowManager::setPlayerPos(const float x, const float y)
{
map->setPlayerPos(x,y);
hud->setPlayerPos(x,y);
mMap->setPlayerPos(x,y);
mHud->setPlayerPos(x,y);
}
void WindowManager::setPlayerDir(const float x, const float y)
{
map->setPlayerDir(x,y);
hud->setPlayerDir(x,y);
mMap->setPlayerDir(x,y);
mHud->setPlayerDir(x,y);
}
void WindowManager::setHMSVisibility(bool visible)
{
hud->setBottomLeftVisibility(visible, hud->weapBox->getVisible(), hud->spellBox->getVisible());
mHud->setBottomLeftVisibility(visible, mHud->mWeapBox->getVisible(), mHud->mSpellBox->getVisible());
}
void WindowManager::setMinimapVisibility(bool visible)
{
hud->setBottomRightVisibility(hud->effectBox->getVisible(), visible);
mHud->setBottomRightVisibility(mHud->mEffectBox->getVisible(), visible);
}
void WindowManager::toggleFogOfWar()
{
map->toggleFogOfWar();
hud->toggleFogOfWar();
mMap->toggleFogOfWar();
mHud->toggleFogOfWar();
}
void WindowManager::setFocusObject(const MWWorld::Ptr& focus)
@ -587,13 +587,13 @@ bool WindowManager::getFullHelp() const
void WindowManager::setWeaponVisibility(bool visible)
{
hud->setBottomLeftVisibility(hud->health->getVisible(), visible, hud->spellBox->getVisible());
mHud->setBottomLeftVisibility(mHud->health->getVisible(), visible, mHud->mSpellBox->getVisible());
}
void WindowManager::setSpellVisibility(bool visible)
{
hud->setBottomLeftVisibility(hud->health->getVisible(), hud->weapBox->getVisible(), visible);
hud->setBottomRightVisibility(visible, hud->minimapBox->getVisible());
mHud->setBottomLeftVisibility(mHud->health->getVisible(), mHud->mWeapBox->getVisible(), visible);
mHud->setBottomRightVisibility(visible, mHud->mMinimapBox->getVisible());
}
void WindowManager::setMouseVisible(bool visible)
@ -618,7 +618,7 @@ void WindowManager::onRetrieveTag(const MyGUI::UString& _tag, MyGUI::UString& _r
void WindowManager::processChangedSettings(const Settings::CategorySettingVector& changed)
{
hud->setFpsLevel(Settings::Manager::getInt("fps", "HUD"));
mHud->setFpsLevel(Settings::Manager::getInt("fps", "HUD"));
mToolTips->setDelay(Settings::Manager::getFloat("tooltip delay", "GUI"));
bool changeRes = false;
@ -637,8 +637,8 @@ void WindowManager::processChangedSettings(const Settings::CategorySettingVector
{
int x = Settings::Manager::getInt("resolution x", "Video");
int y = Settings::Manager::getInt("resolution y", "Video");
hud->onResChange(x, y);
console->onResChange(x, y);
mHud->onResChange(x, y);
mConsole->onResChange(x, y);
mSettingsWindow->center();
mAlchemyWindow->center();
mScrollWindow->center();
@ -649,7 +649,7 @@ void WindowManager::processChangedSettings(const Settings::CategorySettingVector
void WindowManager::pushGuiMode(GuiMode mode)
{
if (mode==GM_Inventory && allowed==GW_None)
if (mode==GM_Inventory && mAllowed==GW_None)
return;
mGuiModes.push_back(mode);
@ -690,32 +690,32 @@ void WindowManager::removeGuiMode(GuiMode mode)
void WindowManager::setSelectedSpell(const std::string& spellId, int successChancePercent)
{
hud->setSelectedSpell(spellId, successChancePercent);
mHud->setSelectedSpell(spellId, successChancePercent);
const ESM::Spell* spell = MWBase::Environment::get().getWorld()->getStore().spells.find(spellId);
mSpellWindow->setTitle(spell->name);
}
void WindowManager::setSelectedEnchantItem(const MWWorld::Ptr& item, int chargePercent)
{
hud->setSelectedEnchantItem(item, chargePercent);
mHud->setSelectedEnchantItem(item, chargePercent);
mSpellWindow->setTitle(MWWorld::Class::get(item).getName(item));
}
void WindowManager::setSelectedWeapon(const MWWorld::Ptr& item, int durabilityPercent)
{
hud->setSelectedWeapon(item, durabilityPercent);
mHud->setSelectedWeapon(item, durabilityPercent);
mInventoryWindow->setTitle(MWWorld::Class::get(item).getName(item));
}
void WindowManager::unsetSelectedSpell()
{
hud->unsetSelectedSpell();
mHud->unsetSelectedSpell();
mSpellWindow->setTitle("#{sNone}");
}
void WindowManager::unsetSelectedWeapon()
{
hud->unsetSelectedWeapon();
mHud->unsetSelectedWeapon();
mInventoryWindow->setTitle("#{sSkillHandtohand}");
}
@ -738,5 +738,5 @@ void WindowManager::getMousePosition(float &x, float &y)
bool WindowManager::getWorldMouseOver()
{
return hud->getWorldMouseOver();
return mHud->getWorldMouseOver();
}

56
apps/openmw/mwgui/window_manager.hpp
Unescape Escape View File

@ -10,10 +10,6 @@
this class.
**/
#include <string>
#include <vector>
#include <set>
#include "MyGUI_UString.h"
#include <components/esm_store/store.hpp>
@ -123,27 +119,27 @@ namespace MWGui
void toggleVisible(GuiWindow wnd)
{
shown = (shown & wnd) ? (GuiWindow) (shown & ~wnd) : (GuiWindow) (shown | wnd);
mShown = (mShown & wnd) ? (GuiWindow) (mShown & ~wnd) : (GuiWindow) (mShown | wnd);
updateVisible();
}
// Disallow all inventory mode windows
void disallowAll()
{
allowed = GW_None;
mAllowed = GW_None;
updateVisible();
}
// Allow one or more windows
void allow(GuiWindow wnd)
{
allowed = (GuiWindow)(allowed | wnd);
mAllowed = (GuiWindow)(mAllowed | wnd);
updateVisible();
}
bool isAllowed(GuiWindow wnd) const
{
return allowed & wnd;
return mAllowed & wnd;
}
MWGui::DialogueWindow* getDialogueWindow() {return mDialogueWindow;}
@ -155,9 +151,9 @@ namespace MWGui
MWGui::ConfirmationDialog* getConfirmationDialog() {return mConfirmationDialog;}
MWGui::TradeWindow* getTradeWindow() {return mTradeWindow;}
MWGui::SpellWindow* getSpellWindow() {return mSpellWindow;}
MWGui::Console* getConsole() {return console;}
MWGui::Console* getConsole() {return mConsole;}
MyGUI::Gui* getGui() const { return gui; }
MyGUI::Gui* getGui() const { return mGui; }
void wmUpdateFps(float fps, unsigned int triangleCount, unsigned int batchCount)
{
@ -223,10 +219,10 @@ namespace MWGui
void onFrame (float frameDuration);
std::map<ESM::Skill::SkillEnum, MWMechanics::Stat<float> > getPlayerSkillValues() { return playerSkillValues; }
std::map<ESM::Attribute::AttributeID, MWMechanics::Stat<int> > getPlayerAttributeValues() { return playerAttributes; }
SkillList getPlayerMinorSkills() { return playerMinorSkills; }
SkillList getPlayerMajorSkills() { return playerMajorSkills; }
std::map<ESM::Skill::SkillEnum, MWMechanics::Stat<float> > getPlayerSkillValues() { return mPlayerSkillValues; }
std::map<ESM::Attribute::AttributeID, MWMechanics::Stat<int> > getPlayerAttributeValues() { return mPlayerAttributes; }
SkillList getPlayerMinorSkills() { return mPlayerMinorSkills; }
SkillList getPlayerMajorSkills() { return mPlayerMajorSkills; }
/**
* Fetches a GMST string from the store, if there is no setting with the given
@ -243,13 +239,13 @@ namespace MWGui
private:
OEngine::GUI::MyGUIManager *mGuiManager;
HUD *hud;
MapWindow *map;
MainMenu *menu;
HUD *mHud;
MapWindow *mMap;
MainMenu *mMenu;
ToolTips *mToolTips;
StatsWindow *mStatsWindow;
MessageBoxManager *mMessageBoxManager;
Console *console;
Console *mConsole;
JournalWindow* mJournal;
DialogueWindow *mDialogueWindow;
ContainerWindow *mContainerWindow;
@ -267,33 +263,33 @@ namespace MWGui
CharacterCreation* mCharGen;
// Various stats about player as needed by window manager
ESM::Class playerClass;
std::string playerName;
std::string playerRaceId;
std::map<ESM::Attribute::AttributeID, MWMechanics::Stat<int> > playerAttributes;
SkillList playerMajorSkills, playerMinorSkills;
std::map<ESM::Skill::SkillEnum, MWMechanics::Stat<float> > playerSkillValues;
MWMechanics::DynamicStat<int> playerHealth, playerMagicka, playerFatigue;
ESM::Class mPlayerClass;
std::string mPlayerName;
std::string mPlayerRaceId;
std::map<ESM::Attribute::AttributeID, MWMechanics::Stat<int> > mPlayerAttributes;
SkillList mPlayerMajorSkills, mPlayerMinorSkills;
std::map<ESM::Skill::SkillEnum, MWMechanics::Stat<float> > mPlayerSkillValues;
MWMechanics::DynamicStat<int> mPlayerHealth, mPlayerMagicka, mPlayerFatigue;
MyGUI::Gui *gui; // Gui
MyGUI::Gui *mGui; // Gui
std::vector<GuiMode> mGuiModes;
std::vector<OEngine::GUI::Layout*> garbageDialogs;
std::vector<OEngine::GUI::Layout*> mGarbageDialogs;
void cleanupGarbage();
GuiWindow shown; // Currently shown windows in inventory mode
GuiWindow mShown; // Currently shown windows in inventory mode
/* Currently ALLOWED windows in inventory mode. This is used at
the start of the game, when windows are enabled one by one
through script commands. You can manipulate this through using
allow() and disableAll().
*/
GuiWindow allowed;
GuiWindow mAllowed;
void updateVisible(); // Update visibility of all windows based on mode, shown and allowed settings
int showFPSLevel;
int mShowFPSLevel;
float mFPS;
unsigned int mTriangleCount;
unsigned int mBatchCount;

16
apps/openmw/mwinput/inputmanager.cpp
Unescape Escape View File

@ -102,15 +102,15 @@ private:
{
if (windows.isGuiMode()) return;
DrawState state = player.getDrawState();
if (state == DrawState_Weapon || state == DrawState_Nothing)
MWMechanics::DrawState_ state = player.getDrawState();
if (state == MWMechanics::DrawState_Weapon || state == MWMechanics::DrawState_Nothing)
{
player.setDrawState(DrawState_Spell);
player.setDrawState(MWMechanics::DrawState_Spell);
std::cout << "Player has now readied his hands for spellcasting!\n";
}
else
{
player.setDrawState(DrawState_Nothing);
player.setDrawState(MWMechanics::DrawState_Nothing);
std::cout << "Player does not have any kind of attack ready now.\n";
}
}
@ -119,15 +119,15 @@ private:
{
if (windows.isGuiMode()) return;
DrawState state = player.getDrawState();
if (state == DrawState_Spell || state == DrawState_Nothing)
MWMechanics::DrawState_ state = player.getDrawState();
if (state == MWMechanics::DrawState_Spell || state == MWMechanics::DrawState_Nothing)
{
player.setDrawState(DrawState_Weapon);
player.setDrawState(MWMechanics::DrawState_Weapon);
std::cout << "Player is now drawing his weapon.\n";
}
else
{
player.setDrawState(DrawState_Nothing);
player.setDrawState(MWMechanics::DrawState_Nothing);
std::cout << "Player does not have any kind of attack ready now.\n";
}
}

42
apps/openmw/mwmechanics/activespells.cpp
Unescape Escape View File

@ -3,6 +3,9 @@
#include <cstdlib>
#include <components/esm/loadalch.hpp>
#include <components/esm/loadspel.hpp>
#include <components/esm_store/store.hpp>
#include "../mwbase/environment.hpp"
@ -43,14 +46,13 @@ namespace MWMechanics
for (TIterator iter (begin()); iter!=end(); ++iter)
{
const ESM::Spell& spell =
*MWBase::Environment::get().getWorld()->getStore().spells.find (iter->first);
const ESM::EffectList& effects = getEffectList (iter->first);
const MWWorld::TimeStamp& start = iter->second.first;
float magnitude = iter->second.second;
for (std::vector<ESM::ENAMstruct>::const_iterator iter (spell.effects.list.begin());
iter!=spell.effects.list.end(); ++iter)
for (std::vector<ESM::ENAMstruct>::const_iterator iter (effects.list.begin());
iter!=effects.list.end(); ++iter)
{
if (iter->duration)
{
@ -71,18 +73,31 @@ namespace MWMechanics
}
}
const ESM::EffectList& ActiveSpells::getEffectList (const std::string& id) const
{
if (const ESM::Spell *spell =
MWBase::Environment::get().getWorld()->getStore().spells.search (id))
return spell->effects;
if (const ESM::Potion *potion =
MWBase::Environment::get().getWorld()->getStore().potions.search (id))
return potion->effects;
throw std::runtime_error ("ID " + id + " can not produce lasting effects");
}
ActiveSpells::ActiveSpells()
: mSpellsChanged (false), mLastUpdate (MWBase::Environment::get().getWorld()->getTimeStamp())
{}
void ActiveSpells::addSpell (const std::string& id)
bool ActiveSpells::addSpell (const std::string& id)
{
const ESM::Spell& spell = *MWBase::Environment::get().getWorld()->getStore().spells.find (id);
const ESM::EffectList& effects = getEffectList (id);
bool found = false;
for (std::vector<ESM::ENAMstruct>::const_iterator iter (spell.effects.list.begin());
iter!=spell.effects.list.end(); ++iter)
for (std::vector<ESM::ENAMstruct>::const_iterator iter (effects.list.begin());
iter!=effects.list.end(); ++iter)
{
if (iter->duration)
{
@ -92,7 +107,7 @@ namespace MWMechanics
}
if (!found)
return;
return false;
TContainer::iterator iter = mSpells.find (id);
@ -105,6 +120,8 @@ namespace MWMechanics
iter->second = std::make_pair (MWBase::Environment::get().getWorld()->getTimeStamp(), random);
mSpellsChanged = true;
return true;
}
void ActiveSpells::removeSpell (const std::string& id)
@ -138,13 +155,12 @@ namespace MWMechanics
double ActiveSpells::timeToExpire (const TIterator& iterator) const
{
const ESM::Spell& spell =
*MWBase::Environment::get().getWorld()->getStore().spells.find (iterator->first);
const ESM::EffectList& effects = getEffectList (iterator->first);
int duration = 0;
for (std::vector<ESM::ENAMstruct>::const_iterator iter (spell.effects.list.begin());
iter!=spell.effects.list.end(); ++iter)
for (std::vector<ESM::ENAMstruct>::const_iterator iter (effects.list.begin());
iter!=effects.list.end(); ++iter)
{
if (iter->duration>duration)
duration = iter->duration;

10
apps/openmw/mwmechanics/activespells.hpp
Unescape Escape View File

@ -12,11 +12,15 @@
namespace ESM
{
struct Spell;
struct EffectList;
}
namespace MWMechanics
{
/// \brief Lasting spell effects
///
/// \note The name of this class is slightly misleading, since it also handels lasting potion
/// effects.
class ActiveSpells
{
public:
@ -33,13 +37,17 @@ namespace MWMechanics
void update() const;
const ESM::EffectList& getEffectList (const std::string& id) const;
public:
ActiveSpells();
void addSpell (const std::string& id);
bool addSpell (const std::string& id);
///< Overwrites an existing spell with the same ID. If the spell does not have any
/// non-instant effects, it is ignored.
///
/// \return Has the spell been added?
void removeSpell (const std::string& id);

68
apps/openmw/mwmechanics/actors.cpp
Unescape Escape View File

@ -18,22 +18,8 @@ namespace MWMechanics
{
// magic effects
adjustMagicEffects (ptr);
CreatureStats& creatureStats = MWWorld::Class::get (ptr).getCreatureStats (ptr);
// calculate dynamic stats
int strength = creatureStats.mAttributes[0].getBase();
int intelligence = creatureStats.mAttributes[1].getBase();
int willpower = creatureStats.mAttributes[2].getBase();
int agility = creatureStats.mAttributes[3].getBase();
int endurance = creatureStats.mAttributes[5].getBase();
double magickaFactor = creatureStats.mMagicEffects.get (EffectKey (84)).mMagnitude*0.1 + 0.5;
creatureStats.mDynamic[0].setBase (static_cast<int> (0.5 * (strength + endurance)));
creatureStats.mDynamic[1].setBase (static_cast<int> (intelligence +
magickaFactor * intelligence));
creatureStats.mDynamic[2].setBase (strength+willpower+agility+endurance);
calculateCreatureStatModifiers (ptr);
calculateDynamicStats (ptr);
}
void Actors::updateNpc (const MWWorld::Ptr& ptr, float duration, bool paused)
@ -64,6 +50,47 @@ namespace MWMechanics
// TODO apply diff to other stats
}
void Actors::calculateDynamicStats (const MWWorld::Ptr& ptr)
{
CreatureStats& creatureStats = MWWorld::Class::get (ptr).getCreatureStats (ptr);
int strength = creatureStats.mAttributes[0].getBase();
int intelligence = creatureStats.mAttributes[1].getBase();
int willpower = creatureStats.mAttributes[2].getBase();
int agility = creatureStats.mAttributes[3].getBase();
int endurance = creatureStats.mAttributes[5].getBase();
double magickaFactor = creatureStats.mMagicEffects.get (EffectKey (84)).mMagnitude*0.1 + 0.5;
creatureStats.mDynamic[0].setBase (static_cast<int> (0.5 * (strength + endurance)));
creatureStats.mDynamic[1].setBase (static_cast<int> (intelligence +
magickaFactor * intelligence));
creatureStats.mDynamic[2].setBase (strength+willpower+agility+endurance);
}
void Actors::calculateCreatureStatModifiers (const MWWorld::Ptr& ptr)
{
CreatureStats& creatureStats = MWWorld::Class::get (ptr).getCreatureStats (ptr);
// attributes
for (int i=0; i<5; ++i)
{
int modifier = creatureStats.mMagicEffects.get (EffectKey (79, i)).mMagnitude
- creatureStats.mMagicEffects.get (EffectKey (17, i)).mMagnitude;
creatureStats.mAttributes[i].setModifier (modifier);
}
// dynamic stats
for (int i=0; i<3; ++i)
{
int modifier = creatureStats.mMagicEffects.get (EffectKey (80+i)).mMagnitude
- creatureStats.mMagicEffects.get (EffectKey (18+i)).mMagnitude;
creatureStats.mDynamic[i].setModifier (modifier);
}
}
Actors::Actors() : mDuration (0) {}
void Actors::addActor (const MWWorld::Ptr& ptr)
@ -99,15 +126,16 @@ namespace MWMechanics
if (mDuration>=0.25)
{
float totalDuration = mDuration;
mDuration = 0;
for (std::set<MWWorld::Ptr>::iterator iter (mActors.begin()); iter!=mActors.end(); ++iter)
{
updateActor (*iter, mDuration);
updateActor (*iter, totalDuration);
if (iter->getTypeName()==typeid (ESM::NPC).name())
updateNpc (*iter, mDuration, paused);
updateNpc (*iter, totalDuration, paused);
}
mDuration = 0;
}
for (std::set<MWWorld::Ptr>::iterator iter (mActors.begin()); iter!=mActors.end();

4
apps/openmw/mwmechanics/actors.hpp
Unescape Escape View File

@ -27,6 +27,10 @@ namespace MWMechanics
void adjustMagicEffects (const MWWorld::Ptr& creature);
void calculateDynamicStats (const MWWorld::Ptr& ptr);
void calculateCreatureStatModifiers (const MWWorld::Ptr& ptr);
public:
Actors();

8
apps/openmw/mwmechanics/drawstate.hpp
Unescape Escape View File

@ -1,13 +1,15 @@
#ifndef GAME_MWMECHANICS_DRAWSTATE_H
#define GAME_MWMECHANICS_DRAWSTATE_H
#undef DrawState
enum DrawState
namespace MWMechanics
{
/// \note The _ suffix is required to avoid a collision with a Windoze macro. Die, Microsoft! Die!
enum DrawState_
{
DrawState_Weapon = 0,
DrawState_Spell = 1,
DrawState_Nothing = 2,
};
}
#endif

20
apps/openmw/mwmechanics/mechanicsmanager.cpp
Unescape Escape View File

@ -28,7 +28,7 @@ namespace MWMechanics
creatureStats.mMagicEffects = MagicEffects();
for (int i=0; i<27; ++i)
npcStats.mSkill[i].setBase (player->npdt52.skills[i]);
npcStats.getSkill (i).setBase (player->npdt52.skills[i]);
creatureStats.mAttributes[0].setBase (player->npdt52.strength);
creatureStats.mAttributes[1].setBase (player->npdt52.intelligence);
@ -73,8 +73,8 @@ namespace MWMechanics
if (index>=0 && index<27)
{
npcStats.mSkill[index].setBase (
npcStats.mSkill[index].getBase() + race->data.bonus[i].bonus);
npcStats.getSkill (index).setBase (
npcStats.getSkill (index).getBase() + race->data.bonus[i].bonus);
}
}
@ -124,8 +124,8 @@ namespace MWMechanics
if (index>=0 && index<27)
{
npcStats.mSkill[index].setBase (
npcStats.mSkill[index].getBase() + bonus);
npcStats.getSkill (index).setBase (
npcStats.getSkill (index).getBase() + bonus);
}
}
}
@ -141,8 +141,8 @@ namespace MWMechanics
if (index>=0 && index<27)
{
npcStats.mSkill[index].setBase (
npcStats.mSkill[index].getBase() + 5);
npcStats.getSkill (index).setBase (
npcStats.getSkill (index).getBase() + 5);
}
}
}
@ -236,11 +236,11 @@ namespace MWMechanics
//Loop over ESM::Skill::SkillEnum
for(int i = 0; i < 27; ++i)
{
if(npcStats.mSkill[i] != mWatchedNpc.mSkill[i])
if(npcStats.getSkill (i) != mWatchedNpc.getSkill (i))
{
update = true;
mWatchedNpc.mSkill[i] = npcStats.mSkill[i];
MWBase::Environment::get().getWindowManager()->setValue((ESM::Skill::SkillEnum)i, npcStats.mSkill[i]);
mWatchedNpc.getSkill (i) = npcStats.getSkill (i);
MWBase::Environment::get().getWindowManager()->setValue((ESM::Skill::SkillEnum)i, npcStats.getSkill (i));
}
}

140
apps/openmw/mwmechanics/npcstats.cpp
Unescape Escape View File

@ -0,0 +1,140 @@
#include "npcstats.hpp"
#include <cmath>
#include <stdexcept>
#include <components/esm/loadskil.hpp>
#include <components/esm/loadclas.hpp>
#include <components/esm/loadgmst.hpp>
#include <components/esm_store/store.hpp>
#include "../mwbase/environment.hpp"
#include "../mwbase/world.hpp"
MWMechanics::NpcStats::NpcStats()
: mMovementFlags (0), mDrawState (DrawState_Nothing)
{}
MWMechanics::DrawState_ MWMechanics::NpcStats::getDrawState() const
{
return mDrawState;
}
void MWMechanics::NpcStats::setDrawState (DrawState_ state)
{
mDrawState = state;
}
bool MWMechanics::NpcStats::getMovementFlag (Flag flag) const
{
return mMovementFlags & flag;
}
void MWMechanics::NpcStats::setMovementFlag (Flag flag, bool state)
{
if (state)
mMovementFlags |= flag;
else
mMovementFlags &= ~flag;
}
const MWMechanics::Stat<float>& MWMechanics::NpcStats::getSkill (int index) const
{
if (index<0 || index>=27)
throw std::runtime_error ("skill index out of range");
return mSkill[index];
}
MWMechanics::Stat<float>& MWMechanics::NpcStats::getSkill (int index)
{
if (index<0 || index>=27)
throw std::runtime_error ("skill index out of range");
return mSkill[index];
}
std::map<std::string, int>& MWMechanics::NpcStats::getFactionRanks()
{
return mFactionRank;
}
const std::map<std::string, int>& MWMechanics::NpcStats::getFactionRanks() const
{
return mFactionRank;
}
float MWMechanics::NpcStats::getSkillGain (int skillIndex, const ESM::Class& class_, int usageType,
int level) const
{
if (level<0)
level = static_cast<int> (getSkill (skillIndex).getBase());
const ESM::Skill *skill = MWBase::Environment::get().getWorld()->getStore().skills.find (skillIndex);
float skillFactor = 1;
if (usageType>=4)
throw std::runtime_error ("skill usage type out of range");
if (usageType>0)
{
skillFactor = skill->data.useValue[usageType];
if (skillFactor<=0)
throw std::runtime_error ("invalid skill gain factor");
}
float typeFactor =
MWBase::Environment::get().getWorld()->getStore().gameSettings.find ("fMiscSkillBonus")->f;
for (int i=0; i<5; ++i)
if (class_.data.skills[i][0]==skillIndex)
{
typeFactor =
MWBase::Environment::get().getWorld()->getStore().gameSettings.find ("fMinorSkillBonus")->f;
break;
}
for (int i=0; i<5; ++i)
if (class_.data.skills[i][1]==skillIndex)
{
typeFactor =
MWBase::Environment::get().getWorld()->getStore().gameSettings.find ("fMajorSkillBonus")->f;
break;
}
if (typeFactor<=0)
throw std::runtime_error ("invalid skill type factor");
float specialisationFactor = 1;
if (skill->data.specialization==class_.data.specialization)
{
specialisationFactor =
MWBase::Environment::get().getWorld()->getStore().gameSettings.find ("fSpecialSkillBonus")->f;
if (specialisationFactor<=0)
throw std::runtime_error ("invalid skill specialisation factor");
}
return 1.0 / (level +1) * (1.0 / skillFactor) * typeFactor * specialisationFactor;
}
void MWMechanics::NpcStats::useSkill (int skillIndex, const ESM::Class& class_, int usageType)
{
float base = getSkill (skillIndex).getBase();
int level = static_cast<int> (base);
base += getSkillGain (skillIndex, class_, usageType);
if (static_cast<int> (base)!=level)
base = level+1;
getSkill (skillIndex).setBase (base);
}

61
apps/openmw/mwmechanics/npcstats.hpp
Unescape Escape View File

@ -3,10 +3,16 @@
#include <map>
#include <set>
#include <string>
#include "stat.hpp"
#include "drawstate.hpp"
namespace ESM
{
struct Class;
}
namespace MWMechanics
{
/// \brief Additional stats for NPCs
@ -16,24 +22,57 @@ namespace MWMechanics
/// \note For technical reasons the spell list and the currently selected spell is also handled by
/// CreatureStats, even though they are actually NPC stats.
struct NpcStats
class NpcStats
{
public:
enum Flag
{
// NPCs other than the player can only have one faction. But for the sake of consistency
// we use the same data structure for the PC and the NPCs.
Flag_ForceRun = 1,
Flag_ForceSneak = 2,
Flag_Run = 4,
Flag_Sneak = 8
};
private:
/// NPCs other than the player can only have one faction. But for the sake of consistency
/// we use the same data structure for the PC and the NPCs.
/// \note the faction key must be in lowercase
std::map<std::string, int> mFactionRank;
DrawState_ mDrawState;
unsigned int mMovementFlags;
Stat<float> mSkill[27];
bool mForceRun;
bool mForceSneak;
bool mRun;
bool mSneak;
bool mCombat;
DrawState mDrawState;
public:
NpcStats();
DrawState_ getDrawState() const;
void setDrawState (DrawState_ state);
bool getMovementFlag (Flag flag) const;
void setMovementFlag (Flag flag, bool state);
const Stat<float>& getSkill (int index) const;
Stat<float>& getSkill (int index);
std::map<std::string, int>& getFactionRanks();
const std::map<std::string, int>& getFactionRanks() const;
float getSkillGain (int skillIndex, const ESM::Class& class_, int usageType = -1,
int level = -1) const;
///< \param usageType: Usage specific factor, specified in the respective skill record;
/// -1: use a factor of 1.0 instead.
/// \param level Level to base calculation on; -1: use current level.
NpcStats() : mForceRun (false), mForceSneak (false), mRun (false), mSneak (false),
mCombat (false) , mDrawState(DrawState_Nothing) {}
void useSkill (int skillIndex, const ESM::Class& class_, int usageType = -1);
///< Increase skill by usage.
};
}

4
apps/openmw/mwmechanics/spellsuccess.hpp
Unescape Escape View File

@ -41,7 +41,7 @@ namespace MWMechanics
{
const ESM::MagicEffect* effect = MWBase::Environment::get().getWorld()->getStore().magicEffects.find(it->effectID);
int _school = effect->data.school;
int _skillLevel = stats.mSkill[spellSchoolToSkill(_school)].getModified();
int _skillLevel = stats.getSkill (spellSchoolToSkill(_school)).getModified();
if (school == -1)
{
@ -78,7 +78,7 @@ namespace MWMechanics
NpcStats& stats = MWWorld::Class::get(actor).getNpcStats(actor);
CreatureStats& creatureStats = MWWorld::Class::get(actor).getCreatureStats(actor);
int skillLevel = stats.mSkill[getSpellSchool(spellId, actor)].getModified();
int skillLevel = stats.getSkill (getSpellSchool(spellId, actor)).getModified();
// Sound magic effect (reduces spell casting chance)
int soundMagnitude = creatureStats.mMagicEffects.get (MWMechanics::EffectKey (48)).mMagnitude;

19
apps/openmw/mwmechanics/stat.hpp
Unescape Escape View File

@ -31,6 +31,11 @@ namespace MWMechanics
return mModified;
}
T getModifier() const
{
return mModified-mBase;
}
/// Set base and modified to \a value.
void set (const T& value)
{
@ -65,10 +70,9 @@ namespace MWMechanics
mBase += diff;
}
/// Change modified relatively.
void modify (const T& diff)
void setModifier (const T& modifier)
{
mModified += diff;
mModified = mBase + modifier;
}
};
@ -143,7 +147,7 @@ namespace MWMechanics
void modify (const T& diff)
{
mStatic.modify (diff);
modifyCurrent (diff);
setCurrent (getCurrent()+diff);
}
void setCurrent (const T& value)
@ -155,6 +159,13 @@ namespace MWMechanics
else if (mCurrent>getModified())
mCurrent = getModified();
}
void setModifier (const T& modifier)
{
T diff = modifier - mStatic.getModifier();
mStatic.setModifier (modifier);
setCurrent (getCurrent()+diff);
}
};
template<typename T>

10
apps/openmw/mwrender/actors.hpp
Unescape Escape View File

@ -1,18 +1,8 @@
#ifndef _GAME_RENDER_ACTORS_H
#define _GAME_RENDER_ACTORS_H
#include <map>
#include <list>
#include <openengine/ogre/renderer.hpp>
#include "components/nifogre/ogre_nif_loader.hpp"
#include "../mwworld/refdata.hpp"
#include "../mwworld/actiontalk.hpp"
#include "npcanimation.hpp"
#include "creatureanimation.hpp"
#include <openengine/bullet/physic.hpp>
namespace MWWorld
{

281
apps/openmw/mwrender/animation.cpp
Unescape Escape View File

@ -6,25 +6,26 @@
#include <OgreBone.h>
#include <OgreSubMesh.h>
namespace MWRender{
std::map<std::string, int> Animation::mUniqueIDs;
namespace MWRender
{
std::map<std::string, int> Animation::sUniqueIDs;
Animation::Animation(OEngine::Render::OgreRenderer& _rend)
: insert(NULL)
: mInsert(NULL)
, mRend(_rend)
, vecRotPos()
, time(0.0f)
, startTime(0.0f)
, stopTime(0.0f)
, animate(0)
, rindexI()
, tindexI()
, shapeNumber(0)
, shapeIndexI()
, shapes(NULL)
, transformations(NULL)
, textmappings(NULL)
, base(NULL)
, mVecRotPos()
, mTime(0.0f)
, mStartTime(0.0f)
, mStopTime(0.0f)
, mAnimate(0)
, mRindexI()
, mTindexI()
, mShapeNumber(0)
, mShapeIndexI()
, mShapes(NULL)
, mTransformations(NULL)
, mTextmappings(NULL)
, mBase(NULL)
{
}
@ -32,19 +33,24 @@ namespace MWRender{
{
}
std::string Animation::getUniqueID(std::string mesh){
std::string Animation::getUniqueID(std::string mesh)
{
int counter;
std::string copy = mesh;
std::transform(copy.begin(), copy.end(), copy.begin(), ::tolower);
if(mUniqueIDs.find(copy) == mUniqueIDs.end()){
counter = mUniqueIDs[copy] = 0;
if(sUniqueIDs.find(copy) == sUniqueIDs.end())
{
counter = sUniqueIDs[copy] = 0;
}
else{
mUniqueIDs[copy] = mUniqueIDs[copy] + 1;
counter = mUniqueIDs[copy];
else
{
sUniqueIDs[copy] = sUniqueIDs[copy] + 1;
counter = sUniqueIDs[copy];
}
std::stringstream out;
if(counter > 99 && counter < 1000)
out << "0";
else if(counter > 9)
@ -52,98 +58,107 @@ namespace MWRender{
else
out << "000";
out << counter;
return out.str();
}
void Animation::startScript(std::string groupname, int mode, int loops){
void Animation::startScript(std::string groupname, int mode, int loops)
{
//If groupname is recognized set animate to true
//Set the start time and stop time
//How many times to loop
if(groupname == "all"){
animate = loops;
time = startTime;
if(groupname == "all")
{
mAnimate = loops;
mTime = mStartTime;
}
else if(textmappings){
else if(mTextmappings)
{
std::string startName = groupname + ": loop start";
std::string stopName = groupname + ": loop stop";
bool first = false;
if(loops > 1){
if(loops > 1)
{
startName = groupname + ": loop start";
stopName = groupname + ": loop stop";
for(std::map<std::string, float>::iterator iter = textmappings->begin(); iter != textmappings->end(); iter++){
for(std::map<std::string, float>::iterator iter = mTextmappings->begin(); iter != mTextmappings->end(); iter++)
{
std::string current = iter->first.substr(0, startName.size());
std::transform(current.begin(), current.end(), current.begin(), ::tolower);
std::string current2 = iter->first.substr(0, stopName.size());
std::transform(current2.begin(), current2.end(), current2.begin(), ::tolower);
if(current == startName){
startTime = iter->second;
animate = loops;
time = startTime;
if(current == startName)
{
mStartTime = iter->second;
mAnimate = loops;
mTime = mStartTime;
first = true;
}
if(current2 == stopName){
stopTime = iter->second;
if(current2 == stopName)
{
mStopTime = iter->second;
if(first)
break;
}
}
}
if(!first){
if(!first)
{
startName = groupname + ": start";
stopName = groupname + ": stop";
for(std::map<std::string, float>::iterator iter = textmappings->begin(); iter != textmappings->end(); iter++){
for(std::map<std::string, float>::iterator iter = mTextmappings->begin(); iter != mTextmappings->end(); iter++)
{
std::string current = iter->first.substr(0, startName.size());
std::transform(current.begin(), current.end(), current.begin(), ::tolower);
std::string current2 = iter->first.substr(0, stopName.size());
std::transform(current2.begin(), current2.end(), current2.begin(), ::tolower);
if(current == startName){
startTime = iter->second;
animate = loops;
time = startTime;
if(current == startName)
{
mStartTime = iter->second;
mAnimate = loops;
mTime = mStartTime;
first = true;
}
if(current2 == stopName){
stopTime = iter->second;
if(current2 == stopName)
{
mStopTime = iter->second;
if(first)
break;
}
}
}
}
}
void Animation::stopScript(){
animate = 0;
void Animation::stopScript()
{
mAnimate = 0;
}
void Animation::handleShapes(std::vector<Nif::NiTriShapeCopy>* allshapes, Ogre::Entity* creaturemodel, Ogre::SkeletonInstance *skel){
shapeNumber = 0;
void Animation::handleShapes(std::vector<Nif::NiTriShapeCopy>* allshapes, Ogre::Entity* creaturemodel, Ogre::SkeletonInstance *skel)
{
mShapeNumber = 0;
if (allshapes == NULL || creaturemodel == NULL || skel == NULL)
{
return;
}
std::vector<Nif::NiTriShapeCopy>::iterator allshapesiter;
for(allshapesiter = allshapes->begin(); allshapesiter != allshapes->end(); allshapesiter++)
{
//std::map<unsigned short, PosAndRot> vecPosRot;
Nif::NiTriShapeCopy& copy = *allshapesiter;
std::vector<Ogre::Vector3>* allvertices = &copy.vertices;
//std::set<unsigned int> vertices;
//std::set<unsigned int> normals;
//std::vector<Nif::NiSkinData::BoneInfoCopy> boneinfovector = copy.boneinfo;
@ -158,52 +173,51 @@ namespace MWRender{
//Each shape has multiple indices
if(initialVertices.size() )
{
if(copy.vertices.size() == initialVertices.size())
{
//Create if it doesn't already exist
if(shapeIndexI.size() == static_cast<std::size_t> (shapeNumber))
if(mShapeIndexI.size() == static_cast<std::size_t> (mShapeNumber))
{
std::vector<int> vec;
shapeIndexI.push_back(vec);
mShapeIndexI.push_back(vec);
}
if(time >= copy.morph.getStartTime() && time <= copy.morph.getStopTime()){
if(mTime >= copy.morph.getStartTime() && mTime <= copy.morph.getStopTime())
{
float x;
for (unsigned int i = 0; i < copy.morph.getAdditionalVertices().size(); i++){
for (unsigned int i = 0; i < copy.morph.getAdditionalVertices().size(); i++)
{
int j = 0;
if(shapeIndexI[shapeNumber].size() <= i)
shapeIndexI[shapeNumber].push_back(0);
if(mShapeIndexI[mShapeNumber].size() <= i)
mShapeIndexI[mShapeNumber].push_back(0);
if(timeIndex(time,copy.morph.getRelevantTimes()[i],(shapeIndexI[shapeNumber])[i], j, x)){
int indexI = (shapeIndexI[shapeNumber])[i];
if(timeIndex(mTime,copy.morph.getRelevantTimes()[i],(mShapeIndexI[mShapeNumber])[i], j, x))
{
int indexI = (mShapeIndexI[mShapeNumber])[i];
std::vector<Ogre::Vector3> relevantData = (copy.morph.getRelevantData()[i]);
float v1 = relevantData[indexI].x;
float v2 = relevantData[j].x;
float t = v1 + (v2 - v1) * x;
if ( t < 0 ) t = 0;
if ( t > 1 ) t = 1;
if ( t < 0 )
t = 0;
if ( t > 1 )
t = 1;
if( t != 0 && initialVertices.size() == copy.morph.getAdditionalVertices()[i].size())
{
for (unsigned int v = 0; v < initialVertices.size(); v++){
for (unsigned int v = 0; v < initialVertices.size(); v++)
initialVertices[v] += ((copy.morph.getAdditionalVertices()[i])[v]) * t;
}
}
}
}
allvertices = &initialVertices;
}
shapeNumber++;
mShapeNumber++;
}
}
if(verticesToChange->size() > 0){
if(verticesToChange->size() > 0)
{
for(std::map<int, std::vector<Nif::NiSkinData::IndividualWeight> >::iterator iter = verticesToChange->begin();
iter != verticesToChange->end(); iter++)
@ -214,26 +228,25 @@ namespace MWRender{
Nif::NiSkinData::BoneInfoCopy* boneinfocopy = &(allshapesiter->boneinfo[inds[0].boneinfocopyindex]);
Ogre::Bone *bonePtr = 0;
Ogre::Vector3 vecPos;
Ogre::Quaternion vecRot;
std::map<Nif::NiSkinData::BoneInfoCopy*, PosAndRot>::iterator result = vecRotPos.find(boneinfocopy);
std::map<Nif::NiSkinData::BoneInfoCopy*, PosAndRot>::iterator result = mVecRotPos.find(boneinfocopy);
if(result == vecRotPos.end()){
if(result == mVecRotPos.end())
{
bonePtr = skel->getBone(boneinfocopy->bonename);
vecPos = bonePtr->_getDerivedPosition() + bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.trans;
vecRot = bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.rotation;
PosAndRot both;
both.vecPos = vecPos;
both.vecRot = vecRot;
vecRotPos[boneinfocopy] = both;
mVecRotPos[boneinfocopy] = both;
}
else{
else
{
PosAndRot both = result->second;
vecPos = both.vecPos;
vecRot = both.vecRot;
@ -241,14 +254,13 @@ namespace MWRender{
Ogre::Vector3 absVertPos = (vecPos + vecRot * currentVertex) * inds[0].weight;
for(std::size_t i = 1; i < inds.size(); i++){
for(std::size_t i = 1; i < inds.size(); i++)
{
boneinfocopy = &(allshapesiter->boneinfo[inds[i].boneinfocopyindex]);
result = vecRotPos.find(boneinfocopy);
result = mVecRotPos.find(boneinfocopy);
if(result == vecRotPos.end()){
if(result == mVecRotPos.end())
{
bonePtr = skel->getBone(boneinfocopy->bonename);
vecPos = bonePtr->_getDerivedPosition() + bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.trans;
vecRot = bonePtr->_getDerivedOrientation() * boneinfocopy->trafo.rotation;
@ -256,19 +268,18 @@ namespace MWRender{
PosAndRot both;
both.vecPos = vecPos;
both.vecRot = vecRot;
vecRotPos[boneinfocopy] = both;
mVecRotPos[boneinfocopy] = both;
}
else{
else
{
PosAndRot both = result->second;
vecPos = both.vecPos;
vecRot = both.vecRot;
}
absVertPos += (vecPos + vecRot * currentVertex) * inds[i].weight;
}
Ogre::Real* addr = (pReal + 3 * verIndex);
*addr = absVertPos.x;
@ -276,10 +287,6 @@ namespace MWRender{
*(addr+2) = absVertPos.z;
}
}
else
{
@ -292,14 +299,13 @@ namespace MWRender{
Ogre::Vector3 transmult;
Ogre::Quaternion rotmult;
float scale;
if(boneSequence.size() > 0){
if(boneSequence.size() > 0)
{
std::vector<std::string>::iterator boneSequenceIter = boneSequence.begin();
if(skel->hasBone(*boneSequenceIter)){
if(skel->hasBone(*boneSequenceIter))
{
Ogre::Bone *bonePtr = skel->getBone(*boneSequenceIter);
transmult = bonePtr->getPosition();
rotmult = bonePtr->getOrientation();
scale = bonePtr->getScale().x;
@ -307,7 +313,8 @@ namespace MWRender{
for(; boneSequenceIter != boneSequence.end(); boneSequenceIter++)
{
if(skel->hasBone(*boneSequenceIter)){
if(skel->hasBone(*boneSequenceIter))
{
Ogre::Bone *bonePtr = skel->getBone(*boneSequenceIter);
// Computes C = B + AxC*scale
transmult = transmult + rotmult * bonePtr->getPosition();
@ -330,13 +337,11 @@ namespace MWRender{
scale = shapescale;
}
// Computes C = B + AxC*scale
// final_vector = old_vector + old_rotation*new_vector*old_scale/
for(unsigned int i = 0; i < allvertices->size(); i++){
for(unsigned int i = 0; i < allvertices->size(); i++)
{
Ogre::Vector3 current = transmult + rotmult * (*allvertices)[i];
Ogre::Real* addr = pReal + i * 3;
*addr = current.x;
@ -355,11 +360,12 @@ namespace MWRender{
}
vbuf->unlock();
}
}
bool Animation::timeIndex( float time, const std::vector<float> & times, int & i, int & j, float & x ){
bool Animation::timeIndex( float time, const std::vector<float> & times, int & i, int & j, float & x )
{
int count;
if ( (count = times.size()) > 0 )
{
@ -416,11 +422,9 @@ namespace MWRender{
}
void Animation::handleAnimationTransforms(){
Ogre::SkeletonInstance* skel = base->getSkeleton();
void Animation::handleAnimationTransforms()
{
Ogre::SkeletonInstance* skel = mBase->getSkeleton();
Ogre::Bone* b = skel->getRootBone();
b->setOrientation(Ogre::Real(.3),Ogre::Real(.3),Ogre::Real(.3), Ogre::Real(.3)); //This is a trick
@ -428,18 +432,17 @@ namespace MWRender{
skel->_updateTransforms();
//skel->_notifyManualBonesDirty();
base->getAllAnimationStates()->_notifyDirty();
//base->_updateAnimation();
//base->_notifyMoved();
mBase->getAllAnimationStates()->_notifyDirty();
//mBase->_updateAnimation();
//mBase->_notifyMoved();
std::vector<Nif::NiKeyframeData>::iterator iter;
int slot = 0;
if(transformations){
for(iter = transformations->begin(); iter != transformations->end(); iter++){
if(time < iter->getStartTime() || time < startTime || time > iter->getStopTime())
if(mTransformations)
{
for(iter = mTransformations->begin(); iter != mTransformations->end(); iter++)
{
if(mTime < iter->getStartTime() || mTime < mStartTime || mTime > iter->getStopTime())
{
slot++;
continue;
@ -451,52 +454,48 @@ namespace MWRender{
const std::vector<Ogre::Quaternion> & quats = iter->getQuat();
const std::vector<float> & ttime = iter->gettTime();
const std::vector<float> & rtime = iter->getrTime();
int rindexJ = rindexI[slot];
timeIndex(time, rtime, rindexI[slot], rindexJ, x2);
int tindexJ = tindexI[slot];
int rindexJ = mRindexI[slot];
timeIndex(mTime, rtime, mRindexI[slot], rindexJ, x2);
int tindexJ = mTindexI[slot];
const std::vector<Ogre::Vector3> & translist1 = iter->getTranslist1();
timeIndex(time, ttime, tindexI[slot], tindexJ, x);
timeIndex(mTime, ttime, mTindexI[slot], tindexJ, x);
Ogre::Vector3 t;
Ogre::Quaternion r;
bool bTrans = translist1.size() > 0;
bool bQuats = quats.size() > 0;
if(skel->hasBone(iter->getBonename())){
if(skel->hasBone(iter->getBonename()))
{
Ogre::Bone* bone = skel->getBone(iter->getBonename());
if(bTrans){
Ogre::Vector3 v1 = translist1[tindexI[slot]];
if(bTrans)
{
Ogre::Vector3 v1 = translist1[mTindexI[slot]];
Ogre::Vector3 v2 = translist1[tindexJ];
t = (v1 + (v2 - v1) * x);
bone->setPosition(t);
}
if(bQuats){
r = Ogre::Quaternion::Slerp(x2, quats[rindexI[slot]], quats[rindexJ], true);
if(bQuats)
{
r = Ogre::Quaternion::Slerp(x2, quats[mRindexI[slot]], quats[rindexJ], true);
bone->setOrientation(r);
}
}
slot++;
}
skel->_updateTransforms();
base->getAllAnimationStates()->_notifyDirty();
mBase->getAllAnimationStates()->_notifyDirty();
}
}

43
apps/openmw/mwrender/animation.hpp
Unescape Escape View File

@ -1,17 +1,13 @@
#ifndef _GAME_RENDER_ANIMATION_H
#define _GAME_RENDER_ANIMATION_H
#include <components/nif/data.hpp>
#include <openengine/ogre/renderer.hpp>
#include "../mwworld/refdata.hpp"
#include "../mwworld/ptr.hpp"
#include "../mwworld/actiontalk.hpp"
#include <components/nif/node.hpp>
#include <map>
#include <openengine/bullet/physic.hpp>
namespace MWRender{
struct PosAndRot{
@ -22,36 +18,30 @@ struct PosAndRot{
class Animation{
protected:
Ogre::SceneNode* insert;
Ogre::SceneNode* mInsert;
OEngine::Render::OgreRenderer &mRend;
std::map<Nif::NiSkinData::BoneInfoCopy*, PosAndRot> vecRotPos;
static std::map<std::string, int> mUniqueIDs;
std::map<Nif::NiSkinData::BoneInfoCopy*, PosAndRot> mVecRotPos;
static std::map<std::string, int> sUniqueIDs;
float time;
float startTime;
float stopTime;
int animate;
float mTime;
float mStartTime;
float mStopTime;
int mAnimate;
//Represents a rotation index for each bone
std::vector<int>rindexI;
std::vector<int>mRindexI;
//Represents a translation index for each bone
std::vector<int>tindexI;
std::vector<int>mTindexI;
//Only shapes with morphing data will use a shape number
int shapeNumber;
std::vector<std::vector<int> > shapeIndexI;
int mShapeNumber;
std::vector<std::vector<int> > mShapeIndexI;
//Ogre::SkeletonInstance* skel;
std::vector<Nif::NiTriShapeCopy>* shapes; //All the NiTriShapeData for a creature
std::vector<Nif::NiTriShapeCopy>* mShapes; //All the NiTriShapeData for a creature
std::vector<Nif::NiKeyframeData>* transformations;
std::map<std::string,float>* textmappings;
Ogre::Entity* base;
std::vector<Nif::NiKeyframeData>* mTransformations;
std::map<std::string,float>* mTextmappings;
Ogre::Entity* mBase;
void handleShapes(std::vector<Nif::NiTriShapeCopy>* allshapes, Ogre::Entity* creaturemodel, Ogre::SkeletonInstance *skel);
void handleAnimationTransforms();
bool timeIndex( float time, const std::vector<float> & times, int & i, int & j, float & x );
@ -63,7 +53,6 @@ class Animation{
void startScript(std::string groupname, int mode, int loops);
void stopScript();
virtual ~Animation();
};

71
apps/openmw/mwrender/creatureanimation.cpp
Unescape Escape View File

@ -12,26 +12,28 @@ using namespace Ogre;
using namespace NifOgre;
namespace MWRender{
CreatureAnimation::~CreatureAnimation(){
CreatureAnimation::~CreatureAnimation()
{
}
CreatureAnimation::CreatureAnimation(const MWWorld::Ptr& ptr, OEngine::Render::OgreRenderer& _rend): Animation(_rend){
insert = ptr.getRefData().getBaseNode();
MWWorld::LiveCellRef<ESM::Creature> *ref =
ptr.get<ESM::Creature>();
CreatureAnimation::CreatureAnimation(const MWWorld::Ptr& ptr, OEngine::Render::OgreRenderer& _rend): Animation(_rend)
{
mInsert = ptr.getRefData().getBaseNode();
MWWorld::LiveCellRef<ESM::Creature> *ref = ptr.get<ESM::Creature>();
assert (ref->base != NULL);
if(!ref->base->model.empty()){
if(!ref->base->model.empty())
{
const std::string &mesh = "meshes\\" + ref->base->model;
std::string meshNumbered = mesh + getUniqueID(mesh) + ">|";
NifOgre::NIFLoader::load(meshNumbered);
base = mRend.getScene()->createEntity(meshNumbered);
base->setVisibilityFlags(RV_Actors);
mBase = mRend.getScene()->createEntity(meshNumbered);
mBase->setVisibilityFlags(RV_Actors);
bool transparent = false;
for (unsigned int i=0; i<base->getNumSubEntities(); ++i)
for (unsigned int i=0; i < mBase->getNumSubEntities(); ++i)
{
Ogre::MaterialPtr mat = base->getSubEntity(i)->getMaterial();
Ogre::MaterialPtr mat = mBase->getSubEntity(i)->getMaterial();
Ogre::Material::TechniqueIterator techIt = mat->getTechniqueIterator();
while (techIt.hasMoreElements())
{
@ -46,46 +48,51 @@ CreatureAnimation::CreatureAnimation(const MWWorld::Ptr& ptr, OEngine::Render::O
}
}
}
base->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
mBase->setRenderQueueGroup(transparent ? RQG_Alpha : RQG_Main);
std::string meshZero = mesh + "0000>|";
if((transformations = (NIFLoader::getSingletonPtr())->getAnim(meshZero))){
for(std::size_t init = 0; init < transformations->size(); init++){
rindexI.push_back(0);
tindexI.push_back(0);
if((mTransformations = (NIFLoader::getSingletonPtr())->getAnim(meshZero)))
{
for(std::size_t init = 0; init < mTransformations->size(); init++)
{
mRindexI.push_back(0);
mTindexI.push_back(0);
}
stopTime = transformations->begin()->getStopTime();
startTime = transformations->begin()->getStartTime();
shapes = (NIFLoader::getSingletonPtr())->getShapes(meshZero);
mStopTime = mTransformations->begin()->getStopTime();
mStartTime = mTransformations->begin()->getStartTime();
mShapes = (NIFLoader::getSingletonPtr())->getShapes(meshZero);
}
textmappings = NIFLoader::getSingletonPtr()->getTextIndices(meshZero);
insert->attachObject(base);
mTextmappings = NIFLoader::getSingletonPtr()->getTextIndices(meshZero);
mInsert->attachObject(mBase);
}
}
void CreatureAnimation::runAnimation(float timepassed){
vecRotPos.clear();
if(animate > 0){
void CreatureAnimation::runAnimation(float timepassed)
{
mVecRotPos.clear();
if(mAnimate > 0)
{
//Add the amount of time passed to time
//Handle the animation transforms dependent on time
//Handle the shapes dependent on animation transforms
time += timepassed;
if(time >= stopTime){
animate--;
mTime += timepassed;
if(mTime >= mStopTime)
{
mAnimate--;
//std::cout << "Stopping the animation\n";
if(animate == 0)
time = stopTime;
if(mAnimate == 0)
mTime = mStopTime;
else
time = startTime + (time - stopTime);
mTime = mStartTime + (mTime - mStopTime);
}
handleAnimationTransforms();
handleShapes(shapes, base, base->getSkeleton());
handleShapes(mShapes, mBase, mBase->getSkeleton());
}
}
}

5
apps/openmw/mwrender/creatureanimation.hpp
Unescape Escape View File

@ -2,11 +2,7 @@
#define _GAME_RENDER_CREATUREANIMATION_H
#include "animation.hpp"
#include <components/nif/node.hpp>
#include "../mwworld/refdata.hpp"
#include "../mwworld/ptr.hpp"
#include "components/nifogre/ogre_nif_loader.hpp"
@ -19,7 +15,6 @@ class CreatureAnimation: public Animation{
CreatureAnimation(const MWWorld::Ptr& ptr, OEngine::Render::OgreRenderer& _rend);
virtual void runAnimation(float timepassed);
};
}
#endif

585
apps/openmw/mwrender/npcanimation.cpp
View File

File diff suppressed because it is too large Load Diff

35
apps/openmw/mwrender/npcanimation.hpp
Unescape Escape View File

@ -1,41 +1,31 @@
#ifndef _GAME_RENDER_NPCANIMATION_H
#define _GAME_RENDER_NPCANIMATION_H
#include "animation.hpp"
#include <components/nif/data.hpp>
#include <components/nif/node.hpp>
#include <components/nif/property.hpp>
#include <components/nif/controller.hpp>
#include <components/nif/extra.hpp>
#include <utility>
#include "../mwworld/refdata.hpp"
#include "../mwworld/ptr.hpp"
#include "components/nifogre/ogre_nif_loader.hpp"
#include "../mwworld/inventorystore.hpp"
#include "../mwclass/npc.hpp"
#include "../mwworld/containerstore.hpp"
#include "components/esm/loadarmo.hpp"
namespace MWRender{
class NpcAnimation: public Animation{
private:
MWWorld::InventoryStore& inv;
MWWorld::InventoryStore& mInv;
int mStateID;
//Free Parts
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> chest;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> skirt;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> lhand;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> rhand;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> tail;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> lFreeFoot;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> rFreeFoot;
int partslots[27]; //Each part slot is taken by clothing, armor, or is empty
int partpriorities[27];
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> zero;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mChest;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mSkirt;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mLhand;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mRhand;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mTail;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mLFreeFoot;
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mRFreeFoot;
int mPartslots[27]; //Each part slot is taken by clothing, armor, or is empty
int mPartPriorities[27];
std::pair<Ogre::Entity*, std::vector<Nif::NiTriShapeCopy>*> mZero;
//Bounded Parts
Ogre::Entity* lclavicle;
@ -95,7 +85,6 @@ private:
void removePartGroup(int group);
void addPartGroup(int group, int priority, std::vector<ESM::PartReference>& parts);
};
}
#endif

12
apps/openmw/mwrender/renderingmanager.hpp
Unescape Escape View File

@ -1,25 +1,14 @@
#ifndef _GAME_RENDERING_MANAGER_H
#define _GAME_RENDERING_MANAGER_H
#include "sky.hpp"
#include "terrain.hpp"
#include "debugging.hpp"
#include "../mwworld/class.hpp"
#include <OgreWindowEventUtilities.h>
#include <utility>
#include <openengine/ogre/renderer.hpp>
#include <openengine/ogre/fader.hpp>
#include <openengine/bullet/physic.hpp>
#include <components/settings/settings.hpp>
#include <vector>
#include <string>
#include <boost/filesystem.hpp>
#include "renderinginterface.hpp"
@ -50,7 +39,6 @@ namespace sh
namespace MWRender
{
class Shadows;
class LocalMap;
class Water;

58
apps/openmw/mwscript/controlextensions.cpp
Unescape Escape View File

@ -59,54 +59,36 @@ namespace MWScript
};
template<class R>
class OpClearForceRun : public Interpreter::Opcode0
class OpClearMovementFlag : public Interpreter::Opcode0
{
public:
virtual void execute (Interpreter::Runtime& runtime)
{
MWWorld::Ptr ptr = R()(runtime);
MWMechanics::NpcStats::Flag mFlag;
MWWorld::Class::get (ptr).getNpcStats (ptr).mForceRun = false;
}
};
template<class R>
class OpForceRun : public Interpreter::Opcode0
{
public:
virtual void execute (Interpreter::Runtime& runtime)
{
MWWorld::Ptr ptr = R()(runtime);
MWWorld::Class::get (ptr).getNpcStats (ptr).mForceRun = true;
}
};
template<class R>
class OpClearForceSneak : public Interpreter::Opcode0
{
public:
OpClearMovementFlag (MWMechanics::NpcStats::Flag flag) : mFlag (flag) {}
virtual void execute (Interpreter::Runtime& runtime)
{
MWWorld::Ptr ptr = R()(runtime);
MWWorld::Class::get (ptr).getNpcStats (ptr).mForceSneak = false;
MWWorld::Class::get (ptr).getNpcStats (ptr).setMovementFlag (mFlag, false);
}
};
template<class R>
class OpForceSneak : public Interpreter::Opcode0
class OpSetMovementFlag : public Interpreter::Opcode0
{
MWMechanics::NpcStats::Flag mFlag;
public:
OpSetMovementFlag (MWMechanics::NpcStats::Flag flag) : mFlag (flag) {}
virtual void execute (Interpreter::Runtime& runtime)
{
MWWorld::Ptr ptr = R()(runtime);
MWWorld::Class::get (ptr).getNpcStats (ptr).mForceSneak = true;
MWWorld::Class::get (ptr).getNpcStats (ptr).setMovementFlag (mFlag, true);
}
};
@ -165,19 +147,23 @@ namespace MWScript
interpreter.installSegment5 (opcodeToggleCollision, new OpToggleCollision);
interpreter.installSegment5 (opcodeClearForceRun, new OpClearForceRun<ImplicitRef>);
interpreter.installSegment5 (opcodeForceRun, new OpForceRun<ImplicitRef>);
interpreter.installSegment5 (opcodeClearForceSneak, new OpClearForceSneak<ImplicitRef>);
interpreter.installSegment5 (opcodeForceSneak, new OpForceSneak<ImplicitRef>);
interpreter.installSegment5 (opcodeClearForceRun,
new OpClearMovementFlag<ImplicitRef> (MWMechanics::NpcStats::Flag_ForceRun));
interpreter.installSegment5 (opcodeForceRun,
new OpSetMovementFlag<ImplicitRef> (MWMechanics::NpcStats::Flag_ForceRun));
interpreter.installSegment5 (opcodeClearForceSneak,
new OpClearMovementFlag<ImplicitRef> (MWMechanics::NpcStats::Flag_ForceSneak));
interpreter.installSegment5 (opcodeForceSneak,
new OpSetMovementFlag<ImplicitRef> (MWMechanics::NpcStats::Flag_ForceSneak));
interpreter.installSegment5 (opcodeClearForceRunExplicit,
new OpClearForceRun<ExplicitRef>);
new OpClearMovementFlag<ExplicitRef> (MWMechanics::NpcStats::Flag_ForceRun));
interpreter.installSegment5 (opcodeForceRunExplicit,
new OpForceRun<ExplicitRef>);
new OpSetMovementFlag<ExplicitRef> (MWMechanics::NpcStats::Flag_ForceRun));
interpreter.installSegment5 (opcodeClearForceSneakExplicit,
new OpClearForceSneak<ExplicitRef>);
new OpClearMovementFlag<ExplicitRef> (MWMechanics::NpcStats::Flag_ForceSneak));
interpreter.installSegment5 (opcodeForceSneakExplicit,
new OpForceSneak<ExplicitRef>);
new OpSetMovementFlag<ExplicitRef> (MWMechanics::NpcStats::Flag_ForceSneak));
}
}
}

1
apps/openmw/mwscript/scriptmanager.hpp
Unescape Escape View File

@ -2,7 +2,6 @@
#define GAME_SCRIPT_SCRIPTMANAGER_H
#include <map>
#include <vector>
#include <string>
#include <components/compiler/streamerrorhandler.hpp>

63
apps/openmw/mwscript/statsextensions.cpp
Unescape Escape View File

@ -1,8 +1,12 @@
#include "statsextensions.hpp"
#include <cmath>
#include <boost/algorithm/string.hpp>
#include <components/esm/loadnpc.hpp>
#include <components/esm_store/store.hpp>
#include <components/compiler/extensions.hpp>
@ -237,7 +241,7 @@ namespace MWScript
MWWorld::Ptr ptr = R()(runtime);
Interpreter::Type_Integer value =
MWWorld::Class::get (ptr).getNpcStats (ptr).mSkill[mIndex].
MWWorld::Class::get (ptr).getNpcStats (ptr).getSkill (mIndex).
getModified();
runtime.push (value);
@ -260,8 +264,35 @@ namespace MWScript
Interpreter::Type_Integer value = runtime[0].mInteger;
runtime.pop();
MWWorld::Class::get (ptr).getNpcStats (ptr).mSkill[mIndex].
setModified (value, 0);
MWMechanics::NpcStats& stats = MWWorld::Class::get (ptr).getNpcStats (ptr);
MWWorld::LiveCellRef<ESM::NPC> *ref = ptr.get<ESM::NPC>();
assert (ref);
const ESM::Class& class_ =
*MWBase::Environment::get().getWorld()->getStore().classes.find (ref->base->cls);
float level = 0;
float progress = std::modf (stats.getSkill (mIndex).getBase(), &level);
float modifier = stats.getSkill (mIndex).getModifier();
int newLevel = static_cast<int> (value-modifier);
if (newLevel<0)
newLevel = 0;
else if (newLevel>100)
newLevel = 100;
progress = (progress / stats.getSkillGain (mIndex, class_, -1, level))
* stats.getSkillGain (mIndex, class_, -1, newLevel);
if (progress>=1)
progress = 0.999999999;
stats.getSkill (mIndex).set (newLevel + progress);
stats.getSkill (mIndex).setModifier (modifier);
}
};
@ -281,10 +312,10 @@ namespace MWScript
Interpreter::Type_Integer value = runtime[0].mInteger;
runtime.pop();
value += MWWorld::Class::get (ptr).getNpcStats (ptr).mSkill[mIndex].
value += MWWorld::Class::get (ptr).getNpcStats (ptr).getSkill (mIndex).
getModified();
MWWorld::Class::get (ptr).getNpcStats (ptr).mSkill[mIndex].
MWWorld::Class::get (ptr).getNpcStats (ptr).getSkill (mIndex).
setModified (value, 0, 100);
}
};
@ -373,9 +404,9 @@ namespace MWScript
if(factionID != "")
{
MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
if(MWWorld::Class::get(player).getNpcStats(player).mFactionRank.find(factionID) == MWWorld::Class::get(player).getNpcStats(player).mFactionRank.end())
if(MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().find(factionID) == MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().end())
{
MWWorld::Class::get(player).getNpcStats(player).mFactionRank[factionID] = 0;
MWWorld::Class::get(player).getNpcStats(player).getFactionRanks()[factionID] = 0;
}
}
}
@ -402,13 +433,13 @@ namespace MWScript
if(factionID != "")
{
MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
if(MWWorld::Class::get(player).getNpcStats(player).mFactionRank.find(factionID) == MWWorld::Class::get(player).getNpcStats(player).mFactionRank.end())
if(MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().find(factionID) == MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().end())
{
MWWorld::Class::get(player).getNpcStats(player).mFactionRank[factionID] = 0;
MWWorld::Class::get(player).getNpcStats(player).getFactionRanks()[factionID] = 0;
}
else
{
MWWorld::Class::get(player).getNpcStats(player).mFactionRank[factionID] = MWWorld::Class::get(player).getNpcStats(player).mFactionRank[factionID] +1;
MWWorld::Class::get(player).getNpcStats(player).getFactionRanks()[factionID] = MWWorld::Class::get(player).getNpcStats(player).getFactionRanks()[factionID] +1;
}
}
}
@ -435,9 +466,9 @@ namespace MWScript
if(factionID != "")
{
MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
if(MWWorld::Class::get(player).getNpcStats(player).mFactionRank.find(factionID) != MWWorld::Class::get(player).getNpcStats(player).mFactionRank.end())
if(MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().find(factionID) != MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().end())
{
MWWorld::Class::get(player).getNpcStats(player).mFactionRank[factionID] = MWWorld::Class::get(player).getNpcStats(player).mFactionRank[factionID] -1;
MWWorld::Class::get(player).getNpcStats(player).getFactionRanks()[factionID] = MWWorld::Class::get(player).getNpcStats(player).getFactionRanks()[factionID] -1;
}
}
}
@ -460,22 +491,22 @@ namespace MWScript
}
else
{
if(MWWorld::Class::get(ptr).getNpcStats(ptr).mFactionRank.empty())
if(MWWorld::Class::get(ptr).getNpcStats(ptr).getFactionRanks().empty())
{
//throw exception?
}
else
{
factionID = MWWorld::Class::get(ptr).getNpcStats(ptr).mFactionRank.begin()->first;
factionID = MWWorld::Class::get(ptr).getNpcStats(ptr).getFactionRanks().begin()->first;
}
}
boost::algorithm::to_lower(factionID);
MWWorld::Ptr player = MWBase::Environment::get().getWorld()->getPlayer().getPlayer();
if(factionID!="")
{
if(MWWorld::Class::get(player).getNpcStats(player).mFactionRank.find(factionID) != MWWorld::Class::get(player).getNpcStats(player).mFactionRank.end())
if(MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().find(factionID) != MWWorld::Class::get(player).getNpcStats(player).getFactionRanks().end())
{
runtime.push(MWWorld::Class::get(player).getNpcStats(player).mFactionRank[factionID]);
runtime.push(MWWorld::Class::get(player).getNpcStats(player).getFactionRanks()[factionID]);
}
else
{

2
apps/openmw/mwsound/sound.hpp
Unescape Escape View File

@ -3,6 +3,8 @@
#include <OgreVector3.h>
#include "soundmanager.hpp"
namespace MWSound
{
class Sound

2
apps/openmw/mwsound/soundmanager.hpp
Unescape Escape View File

@ -5,6 +5,8 @@
#include <utility>
#include <map>
#include <boost/shared_ptr.hpp>
#include <OgreResourceGroupManager.h>
#include <components/settings/settings.hpp>

28
apps/openmw/mwworld/actionapply.cpp
Unescape Escape View File

@ -0,0 +1,28 @@
#include "actionapply.hpp"
#include "class.hpp"
namespace MWWorld
{
ActionApply::ActionApply (const Ptr& target, const std::string& id, const Ptr& actor)
: mTarget (target), mId (id), mActor (actor)
{}
void ActionApply::execute()
{
MWWorld::Class::get (mTarget).apply (mTarget, mId, mActor);
}
ActionApplyWithSkill::ActionApplyWithSkill (const Ptr& target, const std::string& id,
const Ptr& actor, int skillIndex, int usageType)
: mTarget (target), mId (id), mActor (actor), mSkillIndex (skillIndex), mUsageType (usageType)
{}
void ActionApplyWithSkill::execute()
{
if (MWWorld::Class::get (mTarget).apply (mTarget, mId, mActor) && mUsageType!=-1)
MWWorld::Class::get (mTarget).skillUsageSucceeded (mActor, mSkillIndex, mUsageType);
}
}

42
apps/openmw/mwworld/actionapply.hpp
Unescape Escape View File

@ -0,0 +1,42 @@
#ifndef GAME_MWWORLD_ACTIONAPPLY_H
#define GAME_MWWORLD_ACTIONAPPLY_H
#include <string>
#include "action.hpp"
#include "ptr.hpp"
namespace MWWorld
{
class ActionApply : public Action
{
Ptr mTarget;
std::string mId;
Ptr mActor;
public:
ActionApply (const Ptr& target, const std::string& id, const Ptr& actor);
virtual void execute();
};
class ActionApplyWithSkill : public Action
{
Ptr mTarget;
std::string mId;
Ptr mActor;
int mSkillIndex;
int mUsageType;
public:
ActionApplyWithSkill (const Ptr& target, const std::string& id, const Ptr& actor,
int skillIndex, int usageType);
virtual void execute();
};
}
#endif

4
apps/openmw/mwworld/cells.cpp
Unescape Escape View File

@ -1,9 +1,5 @@
#include "cells.hpp"
#include <cctype>
#include <algorithm>
#include <components/esm_store/store.hpp>
#include "../mwbase/environment.hpp"

3
apps/openmw/mwworld/cellstore.hpp
Unescape Escape View File

@ -4,9 +4,6 @@
#include <components/esm/records.hpp>
#include <list>
#include <string>
#include <vector>
#include <stdexcept>
#include <algorithm>
#include "refdata.hpp"

10
apps/openmw/mwworld/class.cpp
Unescape Escape View File

@ -34,6 +34,16 @@ namespace MWWorld
}
bool Class::apply (const MWWorld::Ptr& ptr, const std::string& id, const MWWorld::Ptr& actor) const
{
return false;
}
void Class::skillUsageSucceeded (const MWWorld::Ptr& ptr, int skill, int usageType) const
{
throw std::runtime_error ("class does not represent an actor");
}
MWMechanics::CreatureStats& Class::getCreatureStats (const Ptr& ptr) const
{
throw std::runtime_error ("class does not have creature stats");

15
apps/openmw/mwworld/class.hpp
Unescape Escape View File

@ -22,7 +22,7 @@ namespace MWRender
namespace MWMechanics
{
struct CreatureStats;
struct NpcStats;
class NpcStats;
struct Movement;
}
@ -165,6 +165,19 @@ namespace MWWorld
/// effects). Throws an exception, if the object can't hold other objects.
/// (default implementation: throws an exception)
virtual bool apply (const MWWorld::Ptr& ptr, const std::string& id,
const MWWorld::Ptr& actor) const;
///< Apply \a id on \a ptr.
/// \param actor Actor that is resposible for the ID being applied to \a ptr.
/// \return Any effect?
///
/// (default implementation: ignore and return false)
virtual void skillUsageSucceeded (const MWWorld::Ptr& ptr, int skill, int usageType) const;
///< Inform actor \a ptr that a skill use has succeeded.
///
/// (default implementations: throws an exception)
static const Class& get (const std::string& key);
///< If there is no class for this \a key, an exception is thrown.

2
apps/openmw/mwworld/containerstore.hpp
Unescape Escape View File

@ -3,8 +3,6 @@
#include <iterator>
#include "cellstore.hpp"
#include "refdata.hpp"
#include "ptr.hpp"
namespace ESM

10
apps/openmw/mwworld/inventorystore.cpp
Unescape Escape View File

@ -148,7 +148,7 @@ void MWWorld::InventoryStore::autoEquip (const MWMechanics::NpcStats& stats)
bool use = false;
if (slots.at (*iter2)==end())
use = true; // slot was empty before -> skill all further checks
use = true; // slot was empty before -> skip all further checks
else
{
Ptr old = *slots.at (*iter2);
@ -159,12 +159,14 @@ void MWWorld::InventoryStore::autoEquip (const MWMechanics::NpcStats& stats)
int oldSkill =
MWWorld::Class::get (old).getEquipmentSkill (old);
if (testSkill!=-1 || oldSkill!=-1 || testSkill!=oldSkill)
if (testSkill!=-1 && oldSkill==-1)
use = true;
else if (testSkill!=-1 && oldSkill!=-1 && testSkill!=oldSkill)
{
if (stats.mSkill[oldSkill].getModified()>stats.mSkill[testSkill].getModified())
if (stats.getSkill (oldSkill).getModified()>stats.getSkill (testSkill).getModified())
continue; // rejected, because old item better matched the NPC's skills.
if (stats.mSkill[oldSkill].getModified()<stats.mSkill[testSkill].getModified())
if (stats.getSkill (oldSkill).getModified()<stats.getSkill (testSkill).getModified())
use = true;
}
}

2
apps/openmw/mwworld/physicssystem.hpp
Unescape Escape View File

@ -1,9 +1,7 @@
#ifndef GAME_MWWORLD_PHYSICSSYSTEM_H
#define GAME_MWWORLD_PHYSICSSYSTEM_H
#include <vector>
#include <openengine/ogre/renderer.hpp>
#include <openengine/bullet/physic.hpp>
#include "ptr.hpp"
#include <openengine/bullet/pmove.h>

8
apps/openmw/mwworld/player.cpp
Unescape Escape View File

@ -56,10 +56,10 @@ namespace MWWorld
mClass = new_class;
}
void Player::setDrawState(const DrawState& value)
void Player::setDrawState (MWMechanics::DrawState_ state)
{
MWWorld::Ptr ptr = getPlayer();
MWWorld::Class::get(ptr).getNpcStats(ptr).mDrawState = value;
MWWorld::Class::get(ptr).getNpcStats(ptr).setDrawState (state);
}
void Player::setAutoMove (bool enable)
@ -111,10 +111,10 @@ namespace MWWorld
MWWorld::Class::get (ptr).setStance (ptr, MWWorld::Class::Run, !running);
}
DrawState Player::getDrawState()
MWMechanics::DrawState_ Player::getDrawState()
{
MWWorld::Ptr ptr = getPlayer();
return MWWorld::Class::get(ptr).getNpcStats(ptr).mDrawState;
return MWWorld::Class::get(ptr).getNpcStats(ptr).getDrawState();
}
}

7
apps/openmw/mwworld/player.hpp
Unescape Escape View File

@ -9,9 +9,6 @@
#include "../mwmechanics/drawstate.hpp"
#undef DrawState // How did this get defined again?
// Maybe it's defined by default in every file for windows?
namespace MWBase
{
class World;
@ -86,7 +83,7 @@ namespace MWWorld
void setClass (const ESM::Class& class_);
void setDrawState(const DrawState& state);
void setDrawState (MWMechanics::DrawState_ state);
std::string getName() const
{
@ -118,7 +115,7 @@ namespace MWWorld
return mAutoMove;
}
DrawState getDrawState();
MWMechanics::DrawState_ getDrawState(); /// \todo constness
void setAutoMove (bool enable);

4
apps/openmw/mwworld/ptr.hpp
Unescape Escape View File

@ -1,12 +1,8 @@
#ifndef GAME_MWWORLD_PTR_H
#define GAME_MWWORLD_PTR_H
#include <cassert>
#include <boost/any.hpp>
#include <components/esm/loadcell.hpp>
#include "cellstore.hpp"
namespace MWWorld

2
apps/openmw/mwworld/refdata.hpp
Unescape Escape View File

@ -1,8 +1,6 @@
#ifndef GAME_MWWORLD_REFDATA_H
#define GAME_MWWORLD_REFDATA_H
#include <string>
#include <components/esm/defs.hpp>
#include "../mwscript/locals.hpp"

2
apps/openmw/mwworld/scene.cpp
Unescape Escape View File

@ -11,9 +11,7 @@
#include "../mwworld/manualref.hpp" /// FIXME
#include "ptr.hpp"
#include "player.hpp"
#include "class.hpp"
#include "localscripts.hpp"
#include "cellfunctors.hpp"

8
apps/openmw/mwworld/scene.hpp
Unescape Escape View File

@ -1,15 +1,7 @@
#ifndef GAME_MWWORLD_SCENE_H
#define GAME_MWWORLD_SCENE_H
#include <vector>
#include <map>
#include <boost/filesystem.hpp>
#include <openengine/bullet/physic.hpp>
#include "../mwrender/renderingmanager.hpp"
#include "../mwrender/renderinginterface.hpp"
#include "physicssystem.hpp"
#include "globals.hpp"

9
apps/openmw/mwworld/worldimp.cpp
Unescape Escape View File

@ -1,8 +1,5 @@
#include "worldimp.hpp"
#include <cmath>
#include <iostream>
#include <components/bsa/bsa_archive.hpp>
#include <components/files/collections.hpp>
@ -17,16 +14,10 @@
#include "../mwgui/window_manager.hpp"
#include "ptr.hpp"
#include "class.hpp"
#include "player.hpp"
#include "weather.hpp"
#include "manualref.hpp"
#include "refdata.hpp"
#include "globals.hpp"
#include "cellfunctors.hpp"
#include <OgreVector3.h>
using namespace Ogre;
namespace

15
apps/openmw/mwworld/worldimp.hpp
Unescape Escape View File

@ -1,32 +1,17 @@
#ifndef GAME_MWWORLD_WORLDIMP_H
#define GAME_MWWORLD_WORLDIMP_H
#include <vector>
#include <map>
#include <boost/filesystem.hpp>
#include <components/esm_store/store.hpp>
#include <components/settings/settings.hpp>
#include "../mwrender/debugging.hpp"
#include "../mwrender/renderingmanager.hpp"
#include "refdata.hpp"
#include "ptr.hpp"
#include "globals.hpp"
#include "scene.hpp"
#include "physicssystem.hpp"
#include "cells.hpp"
#include "localscripts.hpp"
#include "timestamp.hpp"
#include <openengine/bullet/physic.hpp>
#include <openengine/ogre/fader.hpp>
#include <OgreTimer.h>
#include "../mwbase/world.hpp"
namespace Ogre

4
components/bsa/bsa_file.cpp
Unescape Escape View File

@ -24,8 +24,8 @@
#include "bsa_file.hpp"
#include <stdexcept>
#include <stdlib.h>
#include <assert.h>
#include <cstdlib>
#include <cassert>
#include <OgreDataStream.h>

4
components/bsa/tests/bsatool_cmd.c
Unescape Escape View File

@ -13,8 +13,8 @@
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <cstdio>
#include <cstdlib>
#include <string.h>
#ifndef FIX_UNUSED

2
components/bsa/tests/bsatool_cmd.h
Unescape Escape View File

@ -13,7 +13,7 @@
#include "config.h"
#endif
#include <stdio.h> /* for FILE */
#include <cstdio> /* for FILE */
#ifdef __cplusplus
extern "C" {

3
components/compiler/streamerrorhandler.cpp
Unescape Escape View File

@ -35,4 +35,5 @@ namespace Compiler
<< " " << message << std::endl;
}
StreamErrorHandler::StreamErrorHandler (std::ostream& ErrorStream) : mStream (ErrorStream) {}}
StreamErrorHandler::StreamErrorHandler (std::ostream& ErrorStream) : mStream (ErrorStream) {}
}

4
components/esm/esm_reader.cpp
Unescape Escape View File

@ -107,14 +107,14 @@ void ESMReader::open(Ogre::DataStreamPtr _esm, const std::string &name)
void ESMReader::open(const std::string &file)
{
std::ifstream *stream = new std::ifstream(file.c_str(), std::ios_base::binary);
std::ifstream *stream = OGRE_NEW_T(std::ifstream, Ogre::MEMCATEGORY_GENERAL)(file.c_str(), std::ios_base::binary);
// Ogre will delete the stream for us
open(Ogre::DataStreamPtr(new Ogre::FileStreamDataStream(stream)), file);
}
void ESMReader::openRaw(const std::string &file)
{
std::ifstream *stream = new std::ifstream(file.c_str(), std::ios_base::binary);
std::ifstream *stream = OGRE_NEW_T(std::ifstream, Ogre::MEMCATEGORY_GENERAL)(file.c_str(), std::ios_base::binary);
// Ogre will delete the stream for us
openRaw(Ogre::DataStreamPtr(new Ogre::FileStreamDataStream(stream)), file);
}

6
components/esm/esm_reader.hpp
Unescape Escape View File

@ -1,15 +1,11 @@
#ifndef _ESM_READER_H
#define _ESM_READER_H
#include <string.h>
#include <string>
#include <libs/platform/stdint.h>
#include <libs/platform/string.h>
#include <assert.h>
#include <cassert>
#include <vector>
#include <sstream>
#include <stdexcept>
#include <OgreDataStream.h>

4
components/esm/loadalch.cpp
Unescape Escape View File

@ -2,8 +2,10 @@
namespace ESM
{
void Potion::load(ESMReader &esm)
void Potion::load(ESMReader &esm, const std::string& id)
{
mId = id;
model = esm.getHNString("MODL");
icon = esm.getHNOString("TEXT"); // not ITEX here for some reason
script = esm.getHNOString("SCRI");

4
components/esm/loadalch.hpp
Unescape Escape View File

@ -24,7 +24,9 @@ struct Potion
std::string name, model, icon, script;
EffectList effects;
void load(ESMReader &esm);
std::string mId;
void load(ESMReader &esm, const std::string& id);
};
}
#endif

4
components/esm/loadingr.cpp
Unescape Escape View File

@ -3,8 +3,10 @@
namespace ESM
{
void Ingredient::load(ESMReader &esm)
void Ingredient::load(ESMReader &esm, const std::string& id)
{
mId = id;
model = esm.getHNString("MODL");
name = esm.getHNString("FNAM");
esm.getHNT(data, "IRDT", 56);

4
components/esm/loadingr.hpp
Unescape Escape View File

@ -24,7 +24,9 @@ struct Ingredient
IRDTstruct data;
std::string name, model, icon, script;
void load(ESMReader &esm);
std::string mId;
void load(ESMReader &esm, const std::string& id);
};
}
#endif

2
components/esm_store/reclists.hpp
Unescape Escape View File

@ -7,7 +7,7 @@
#include <vector>
#include <algorithm>
#include <cctype>
#include <assert.h>
#include <cassert>
#include <stdexcept>
#include <iterator>
#include <boost/algorithm/string.hpp>

4
components/esm_store/store.hpp
Unescape Escape View File

@ -30,7 +30,7 @@ namespace ESMS
// Each individual list
RecListT<Activator> activators;
RecListT<Potion> potions;
RecListWithIDT<Potion> potions;
RecListT<Apparatus> appas;
RecListT<Armor> armors;
RecListT<BodyPart> bodyParts;
@ -47,7 +47,7 @@ namespace ESMS
RecListT<Enchantment> enchants;
RecListT<Faction> factions;
RecListT<Global> globals;
RecListT<Ingredient> ingreds;
RecListWithIDT<Ingredient> ingreds;
RecListT<CreatureLevList> creatureLists;
RecListT<ItemLevList> itemLists;
RecListT<Light> lights;

2
components/files/collections.hpp
Unescape Escape View File

@ -1,8 +1,6 @@
#ifndef COMPONENTS_FILES_COLLECTION_HPP
#define COMPONENTS_FILES_COLLECTION_HPP
#include <string>
#include <map>
#include <boost/filesystem.hpp>
#include "multidircollection.hpp"

1
components/files/configurationmanager.hpp
Unescape Escape View File

@ -8,7 +8,6 @@
#endif
#include <boost/program_options.hpp>
#include <boost/filesystem.hpp>
#include <components/files/fixedpath.hpp>
#include <components/files/collections.hpp>

2
components/misc/tests/slice_test.cpp
Unescape Escape View File

@ -2,8 +2,6 @@
using namespace std;
#include <assert.h>
#include "../slice_array.hpp"
int main()

2
components/misc/tests/strops_test.cpp
Unescape Escape View File

@ -1,4 +1,4 @@
#include <assert.h>
#include <cassert>
#include "../stringops.hpp"

3
components/nif/nif_file.hpp
Unescape Escape View File

@ -32,8 +32,7 @@
#include <stdexcept>
#include <vector>
#include <string>
#include <assert.h>
#include <cassert>
#include "record.hpp"
#include "nif_types.hpp"

2
components/nifbullet/bullet_nif_loader.cpp
Unescape Escape View File

@ -23,7 +23,7 @@ http://www.gnu.org/licenses/ .
#include "bullet_nif_loader.hpp"
#include <Ogre.h>
#include <stdio.h>
#include <cstdio>
#include "../nif/nif_file.hpp"
#include "../nif/node.hpp"

8
components/nifbullet/bullet_nif_loader.hpp
Unescape Escape View File

@ -25,22 +25,16 @@
#define _BULLET_NIF_LOADER_H_
#include <OgreMesh.h>
#include <assert.h>
#include <cassert>
#include <string>
#include <BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h>
#include <BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h>
#include <btBulletDynamicsCommon.h>
#include <btBulletCollisionCommon.h>
#include "openengine/bullet/BulletShapeLoader.h"
#include <vector>
#include <list>
// For warning messages
#include <iostream>
// float infinity
#include <limits>
namespace Nif
{
class Node;

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save