Fixed Sigmodr widgets to use namespaces in sources

37 files changed, 1179 insertions, 1050 deletions

diff --git a/sigmodr/widgets/AbilityUI.cpp b/sigmodr/widgets/AbilityUI.cpp
index c545f9eb..d6bc1492 100644
--- a/sigmodr/widgets/AbilityUI.cpp
+++ b/sigmodr/widgets/AbilityUI.cpp
@@ -32,13 +32,17 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::AbilityUI::AbilityUI(Sigmod::Ability* ability, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+AbilityUI::AbilityUI(Ability* ability, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(ability, new Sigmod::Ability(*ability));
+    setObjects(ability, new Ability(*ability));
 }
 
-void Sigmodr::Widgets::AbilityUI::initGui()
+void AbilityUI::initGui()
 {
     QFile file(":/gui/ability.ui");
     file.open(QFile::ReadOnly);
@@ -58,59 +62,59 @@ void Sigmodr::Widgets::AbilityUI::initGui()
     connect(ui_priorityScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(priorityScriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::AbilityUI::setGui()
+void AbilityUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Ability*>(modified())->name());
-    ui_priority->setValue(qobject_cast<Sigmod::Ability*>(modified())->priority());
-    ui_description->setText(qobject_cast<Sigmod::Ability*>(modified())->description());
-    ui_battleScript->setValue(qobject_cast<Sigmod::Ability*>(modified())->battleScript());
-    ui_worldScript->setValue(qobject_cast<Sigmod::Ability*>(modified())->worldScript());
-    ui_priorityScript->setValue(qobject_cast<Sigmod::Ability*>(modified())->priorityScript());
+    ui_name->setText(qobject_cast<Ability*>(modified())->name());
+    ui_priority->setValue(qobject_cast<Ability*>(modified())->priority());
+    ui_description->setText(qobject_cast<Ability*>(modified())->description());
+    ui_battleScript->setValue(qobject_cast<Ability*>(modified())->battleScript());
+    ui_worldScript->setValue(qobject_cast<Ability*>(modified())->worldScript());
+    ui_priorityScript->setValue(qobject_cast<Ability*>(modified())->priorityScript());
 }
 
-void Sigmodr::Widgets::AbilityUI::apply()
+void AbilityUI::apply()
 {
-    *qobject_cast<Sigmod::Ability*>(original()) = *qobject_cast<Sigmod::Ability*>(modified());
+    *qobject_cast<Ability*>(original()) = *qobject_cast<Ability*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::AbilityUI::discard()
+void AbilityUI::discard()
 {
-    *qobject_cast<Sigmod::Ability*>(modified()) = *qobject_cast<Sigmod::Ability*>(original());
+    *qobject_cast<Ability*>(modified()) = *qobject_cast<Ability*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::AbilityUI::nameChanged(const QString& name)
+void AbilityUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Ability*>(modified())->setName(name);
+    qobject_cast<Ability*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::AbilityUI::priorityChanged(const int priority)
+void AbilityUI::priorityChanged(const int priority)
 {
-    qobject_cast<Sigmod::Ability*>(modified())->setPriority(priority);
+    qobject_cast<Ability*>(modified())->setPriority(priority);
 }
 
-void Sigmodr::Widgets::AbilityUI::descriptionChanged(const QString& description)
+void AbilityUI::descriptionChanged(const QString& description)
 {
     const int cursor = ui_description->cursorPosition();
-    qobject_cast<Sigmod::Ability*>(modified())->setDescription(description);
+    qobject_cast<Ability*>(modified())->setDescription(description);
     ui_description->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::AbilityUI::battleScriptChanged(const Sigcore::Script& battleScript)
+void AbilityUI::battleScriptChanged(const Script& battleScript)
 {
-    qobject_cast<Sigmod::Ability*>(modified())->setBattleScript(battleScript);
+    qobject_cast<Ability*>(modified())->setBattleScript(battleScript);
 }
 
-void Sigmodr::Widgets::AbilityUI::worldScriptChanged(const Sigcore::Script& worldScript)
+void AbilityUI::worldScriptChanged(const Script& worldScript)
 {
-    qobject_cast<Sigmod::Ability*>(modified())->setWorldScript(worldScript);
+    qobject_cast<Ability*>(modified())->setWorldScript(worldScript);
 }
 
-void Sigmodr::Widgets::AbilityUI::priorityScriptChanged(const Sigcore::Script& priorityScript)
+void AbilityUI::priorityScriptChanged(const Script& priorityScript)
 {
-    qobject_cast<Sigmod::Ability*>(modified())->setPriorityScript(priorityScript);
+    qobject_cast<Ability*>(modified())->setPriorityScript(priorityScript);
 }
diff --git a/sigmodr/widgets/AuthorUI.cpp b/sigmodr/widgets/AuthorUI.cpp
index b0d39f8d..8d13d822 100644
--- a/sigmodr/widgets/AuthorUI.cpp
+++ b/sigmodr/widgets/AuthorUI.cpp
@@ -28,13 +28,16 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::AuthorUI::AuthorUI(Sigmod::Author* author, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+AuthorUI::AuthorUI(Author* author, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(author, new Sigmod::Author(*author));
+    setObjects(author, new Author(*author));
 }
 
-void Sigmodr::Widgets::AuthorUI::initGui()
+void AuthorUI::initGui()
 {
     QFile file(":/gui/author.ui");
     file.open(QFile::ReadOnly);
@@ -48,43 +51,43 @@ void Sigmodr::Widgets::AuthorUI::initGui()
     connect(ui_role, SIGNAL(textChanged(QString)), this, SLOT(roleChanged(QString)));
 }
 
-void Sigmodr::Widgets::AuthorUI::setGui()
+void AuthorUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Author*>(modified())->name());
-    ui_email->setText(qobject_cast<Sigmod::Author*>(modified())->email());
-    ui_role->setText(qobject_cast<Sigmod::Author*>(modified())->role());
+    ui_name->setText(qobject_cast<Author*>(modified())->name());
+    ui_email->setText(qobject_cast<Author*>(modified())->email());
+    ui_role->setText(qobject_cast<Author*>(modified())->role());
 }
 
-void Sigmodr::Widgets::AuthorUI::apply()
+void AuthorUI::apply()
 {
-    *qobject_cast<Sigmod::Author*>(original()) = *qobject_cast<Sigmod::Author*>(modified());
+    *qobject_cast<Author*>(original()) = *qobject_cast<Author*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::AuthorUI::discard()
+void AuthorUI::discard()
 {
-    *qobject_cast<Sigmod::Author*>(modified()) = *qobject_cast<Sigmod::Author*>(original());
+    *qobject_cast<Author*>(modified()) = *qobject_cast<Author*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::AuthorUI::nameChanged(const QString& name)
+void AuthorUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Author*>(modified())->setName(name);
+    qobject_cast<Author*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::AuthorUI::emailChanged(const QString& email)
+void AuthorUI::emailChanged(const QString& email)
 {
     const int cursor = ui_email->cursorPosition();
-    qobject_cast<Sigmod::Author*>(modified())->setEmail(email);
+    qobject_cast<Author*>(modified())->setEmail(email);
     ui_email->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::AuthorUI::roleChanged(const QString& role)
+void AuthorUI::roleChanged(const QString& role)
 {
     const int cursor = ui_role->cursorPosition();
-    qobject_cast<Sigmod::Author*>(modified())->setRole(role);
+    qobject_cast<Author*>(modified())->setRole(role);
     ui_role->setCursorPosition(cursor);
 }
diff --git a/sigmodr/widgets/BadgeUI.cpp b/sigmodr/widgets/BadgeUI.cpp
index 1592eebb..dcd94582 100644
--- a/sigmodr/widgets/BadgeUI.cpp
+++ b/sigmodr/widgets/BadgeUI.cpp
@@ -39,13 +39,17 @@
 #include <QtGui/QTableWidgetItem>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::BadgeUI::BadgeUI(Sigmod::Badge* badge, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+BadgeUI::BadgeUI(Badge* badge, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(badge, new Sigmod::Badge(*badge));
+    setObjects(badge, new Badge(*badge));
 }
 
-void Sigmodr::Widgets::BadgeUI::initGui()
+void BadgeUI::initGui()
 {
     QFile file(":/gui/badge.ui");
     file.open(QFile::ReadOnly);
@@ -66,7 +70,7 @@ void Sigmodr::Widgets::BadgeUI::initGui()
     ui_stat->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
 }
 
-void Sigmodr::Widgets::BadgeUI::refreshGui()
+void BadgeUI::refreshGui()
 {
     int maxHeight = 0;
     int maxWidth = 0;
@@ -77,7 +81,7 @@ void Sigmodr::Widgets::BadgeUI::refreshGui()
     ui_badge->clear();
     for (int i = 0; i < game()->spriteCount(); ++i)
     {
-        const Sigmod::Sprite* sprite = game()->sprite(i);
+        const Sprite* sprite = game()->sprite(i);
         QPixmap icon;
         icon.loadFromData(sprite->sprite());
         maxHeight = qMax(maxHeight, icon.height());
@@ -92,107 +96,107 @@ void Sigmodr::Widgets::BadgeUI::refreshGui()
     ui_badge->setIconSize(maxSize);
     const bool isSplit = game()->rules()->specialSplit();
     ui_stat->clear();
-    ui_stat->setRowCount((isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1);
-    ui_stat->setVerticalHeaderLabels((isSplit ? Sigmod::StatGSCStr : Sigmod::StatRBYStr).mid(Sigmod::ST_Attack, (isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1));
+    ui_stat->setRowCount((isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1);
+    ui_stat->setVerticalHeaderLabels((isSplit ? StatGSCStr : StatRBYStr).mid(ST_Attack, (isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1));
     ui_stat->setColumnCount(1);
     ui_stat->setHorizontalHeaderLabels(QStringList() << "Multiplier");
-    ui_stat->verticalHeaderItem(Sigmod::ST_Attack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Attack));
-    ui_stat->verticalHeaderItem(Sigmod::ST_Defense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Defense));
-    ui_stat->verticalHeaderItem(Sigmod::ST_Speed - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Speed));
+    ui_stat->verticalHeaderItem(ST_Attack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Attack));
+    ui_stat->verticalHeaderItem(ST_Defense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Defense));
+    ui_stat->verticalHeaderItem(ST_Speed - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Speed));
     if (isSplit)
     {
-        ui_stat->verticalHeaderItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialAttack));
-        ui_stat->verticalHeaderItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialDefense));
+        ui_stat->verticalHeaderItem(ST_SpecialAttack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialAttack));
+        ui_stat->verticalHeaderItem(ST_SpecialDefense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialDefense));
     }
     else
-        ui_stat->verticalHeaderItem(Sigmod::ST_Special - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Special));
+        ui_stat->verticalHeaderItem(ST_Special - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Special));
     QTableWidgetItem* item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    ui_stat->setItem(Sigmod::ST_Attack - Sigmod::ST_Attack, 0, item);
+    ui_stat->setItem(ST_Attack - ST_Attack, 0, item);
     ui_stat->setCurrentItem(item);
     item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    ui_stat->setItem(Sigmod::ST_Defense- Sigmod::ST_Attack, 0, item);
+    ui_stat->setItem(ST_Defense- ST_Attack, 0, item);
     item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    ui_stat->setItem(Sigmod::ST_Speed - Sigmod::ST_Attack, 0, item);
+    ui_stat->setItem(ST_Speed - ST_Attack, 0, item);
     if (isSplit)
     {
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        ui_stat->setItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0, item);
+        ui_stat->setItem(ST_SpecialAttack - ST_Attack, 0, item);
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        ui_stat->setItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0, item);
+        ui_stat->setItem(ST_SpecialDefense - ST_Attack, 0, item);
     }
     else
     {
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        ui_stat->setItem(Sigmod::ST_Special - Sigmod::ST_Attack, 0, item);
+        ui_stat->setItem(ST_Special - ST_Attack, 0, item);
     }
 }
 
-void Sigmodr::Widgets::BadgeUI::setGui()
+void BadgeUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Badge*>(modified())->name());
-    ui_obey->setValue(qobject_cast<Sigmod::Badge*>(modified())->obey());
-    ui_face->setCurrentIndex(game()->spriteIndex(qobject_cast<Sigmod::Badge*>(modified())->face()));
-    ui_badge->setCurrentIndex(game()->spriteIndex(qobject_cast<Sigmod::Badge*>(modified())->badge()));
-    ui_stat->item(Sigmod::ST_Attack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Badge*>(modified())->stat(Sigmod::ST_Attack), 'g', 7));
-    ui_stat->item(Sigmod::ST_Defense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Badge*>(modified())->stat(Sigmod::ST_Defense), 'g', 7));
-    ui_stat->item(Sigmod::ST_Speed - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Badge*>(modified())->stat(Sigmod::ST_Speed), 'g', 7));
+    ui_name->setText(qobject_cast<Badge*>(modified())->name());
+    ui_obey->setValue(qobject_cast<Badge*>(modified())->obey());
+    ui_face->setCurrentIndex(game()->spriteIndex(qobject_cast<Badge*>(modified())->face()));
+    ui_badge->setCurrentIndex(game()->spriteIndex(qobject_cast<Badge*>(modified())->badge()));
+    ui_stat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Attack), 'g', 7));
+    ui_stat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Defense), 'g', 7));
+    ui_stat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Speed), 'g', 7));
     if (game()->rules()->specialSplit())
     {
-        ui_stat->item(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Badge*>(modified())->stat(Sigmod::ST_SpecialAttack), 'g', 7));
-        ui_stat->item(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Badge*>(modified())->stat(Sigmod::ST_SpecialDefense), 'g', 7));
+        ui_stat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_SpecialAttack), 'g', 7));
+        ui_stat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_SpecialDefense), 'g', 7));
     }
     else
-        ui_stat->item(Sigmod::ST_Special - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Badge*>(modified())->stat(Sigmod::ST_Special), 'g', 7));
-    ui_statMultiplier->setValue(qobject_cast<Sigmod::Badge*>(modified())->stat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>()));
+        ui_stat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Badge*>(modified())->stat(ST_Special), 'g', 7));
+    ui_statMultiplier->setValue(qobject_cast<Badge*>(modified())->stat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>()));
 }
 
-void Sigmodr::Widgets::BadgeUI::apply()
+void BadgeUI::apply()
 {
-    *qobject_cast<Sigmod::Badge*>(original()) = *qobject_cast<Sigmod::Badge*>(modified());
+    *qobject_cast<Badge*>(original()) = *qobject_cast<Badge*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::BadgeUI::discard()
+void BadgeUI::discard()
 {
-    *qobject_cast<Sigmod::Badge*>(modified()) = *qobject_cast<Sigmod::Badge*>(original());
+    *qobject_cast<Badge*>(modified()) = *qobject_cast<Badge*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::BadgeUI::nameChanged(const QString& name)
+void BadgeUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Badge*>(modified())->setName(name);
+    qobject_cast<Badge*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::BadgeUI::obeyChanged(const int obey)
+void BadgeUI::obeyChanged(const int obey)
 {
-    qobject_cast<Sigmod::Badge*>(modified())->setObey(obey);
+    qobject_cast<Badge*>(modified())->setObey(obey);
 }
 
-void Sigmodr::Widgets::BadgeUI::faceChanged(const int face)
+void BadgeUI::faceChanged(const int face)
 {
-    qobject_cast<Sigmod::Badge*>(modified())->setFace(game()->sprite(face)->id());
+    qobject_cast<Badge*>(modified())->setFace(game()->sprite(face)->id());
 }
 
-void Sigmodr::Widgets::BadgeUI::badgeChanged(const int badge)
+void BadgeUI::badgeChanged(const int badge)
 {
-    qobject_cast<Sigmod::Badge*>(modified())->setBadge(game()->sprite(badge)->id());
+    qobject_cast<Badge*>(modified())->setBadge(game()->sprite(badge)->id());
 }
 
-void Sigmodr::Widgets::BadgeUI::statChanged(const int row)
+void BadgeUI::statChanged(const int row)
 {
-    ui_statMultiplier->setValue(qobject_cast<Sigmod::Badge*>(modified())->stat(ui_stat->verticalHeaderItem(row)->data(Qt::UserRole).value<Sigmod::Stat>()));
+    ui_statMultiplier->setValue(qobject_cast<Badge*>(modified())->stat(ui_stat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void Sigmodr::Widgets::BadgeUI::statMultiplierChanged(const Sigcore::Fraction& multiplier)
+void BadgeUI::statMultiplierChanged(const Fraction& multiplier)
 {
-    qobject_cast<Sigmod::Badge*>(modified())->setStat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>(), multiplier);
+    qobject_cast<Badge*>(modified())->setStat(ui_stat->verticalHeaderItem(ui_stat->currentRow())->data(Qt::UserRole).value<Stat>(), multiplier);
 }
diff --git a/sigmodr/widgets/CoinListItemUI.cpp b/sigmodr/widgets/CoinListItemUI.cpp
index 976c4e84..74678f59 100644
--- a/sigmodr/widgets/CoinListItemUI.cpp
+++ b/sigmodr/widgets/CoinListItemUI.cpp
@@ -34,15 +34,18 @@
 #include <QtGui/QRadioButton>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::CoinListItemUI::CoinListItemUI(Sigmod::CoinListItem* item, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+CoinListItemUI::CoinListItemUI(CoinListItem* item, QWidget* parent) :
         ObjectUI(parent),
         ui_type(new QButtonGroup(this)),
         m_lastType(-1)
 {
-    setObjects(item, new Sigmod::CoinListItem(*item));
+    setObjects(item, new CoinListItem(*item));
 }
 
-void Sigmodr::Widgets::CoinListItemUI::initGui()
+void CoinListItemUI::initGui()
 {
     QFile file(":/gui/coinlistitem.ui");
     file.open(QFile::ReadOnly);
@@ -52,27 +55,27 @@ void Sigmodr::Widgets::CoinListItemUI::initGui()
     QRadioButton* species = formWidget->findChild<QRadioButton*>("varSpecies");
     ui_object = formWidget->findChild<KComboBox*>("varObject");
     ui_cost = formWidget->findChild<KIntNumInput*>("varCost");
-    ui_type->addButton(item, Sigmod::CoinListItem::Item);
-    ui_type->addButton(species, Sigmod::CoinListItem::Species);
+    ui_type->addButton(item, CoinListItem::Item);
+    ui_type->addButton(species, CoinListItem::Species);
     connect(ui_type, SIGNAL(buttonClicked(int)), this, SLOT(typeChanged(int)));
     connect(ui_object, SIGNAL(currentIndexChanged(int)), this, SLOT(objectChanged(int)));
     connect(ui_cost, SIGNAL(valueChanged(int)), this, SLOT(costChanged(int)));
 }
 
-void Sigmodr::Widgets::CoinListItemUI::setGui()
+void CoinListItemUI::setGui()
 {
-    bool resetObjects = (qobject_cast<Sigmod::CoinListItem*>(modified())->type() != m_lastType);
-    ui_type->button(qobject_cast<Sigmod::CoinListItem*>(modified())->type())->setChecked(true);
-    m_lastType = qobject_cast<Sigmod::CoinListItem*>(modified())->type();
+    bool resetObjects = (qobject_cast<CoinListItem*>(modified())->type() != m_lastType);
+    ui_type->button(qobject_cast<CoinListItem*>(modified())->type())->setChecked(true);
+    m_lastType = qobject_cast<CoinListItem*>(modified())->type();
     if (resetObjects)
     {
         const bool blocked = ui_object->blockSignals(true);
         ui_object->clear();
-        if (qobject_cast<Sigmod::CoinListItem*>(modified())->type() == Sigmod::CoinListItem::Item)
+        if (qobject_cast<CoinListItem*>(modified())->type() == CoinListItem::Item)
         {
             for (int i = 0; i < game()->itemCount(); ++i)
             {
-                const Sigmod::Item* item = game()->item(i);
+                const Item* item = game()->item(i);
                 ui_object->addItem(item->name(), item->id());
             }
         }
@@ -80,43 +83,43 @@ void Sigmodr::Widgets::CoinListItemUI::setGui()
         {
             for (int i = 0; i < game()->speciesCount(); ++i)
             {
-                const Sigmod::Species* species = game()->species(i);
+                const Species* species = game()->species(i);
                 ui_object->addItem(species->name(), species->id());
             }
         }
         ui_object->blockSignals(blocked);
     }
-    if (m_lastType == Sigmod::CoinListItem::Item)
-        ui_object->setCurrentIndex(game()->itemIndex(qobject_cast<Sigmod::CoinListItem*>(modified())->object()));
+    if (m_lastType == CoinListItem::Item)
+        ui_object->setCurrentIndex(game()->itemIndex(qobject_cast<CoinListItem*>(modified())->object()));
     else
-        ui_object->setCurrentIndex(game()->speciesIndex(qobject_cast<Sigmod::CoinListItem*>(modified())->object()));
-    ui_cost->setValue(qobject_cast<Sigmod::CoinListItem*>(modified())->cost());
+        ui_object->setCurrentIndex(game()->speciesIndex(qobject_cast<CoinListItem*>(modified())->object()));
+    ui_cost->setValue(qobject_cast<CoinListItem*>(modified())->cost());
 }
 
-void Sigmodr::Widgets::CoinListItemUI::apply()
+void CoinListItemUI::apply()
 {
-    *qobject_cast<Sigmod::CoinListItem*>(original()) = *qobject_cast<Sigmod::CoinListItem*>(modified());
+    *qobject_cast<CoinListItem*>(original()) = *qobject_cast<CoinListItem*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::CoinListItemUI::discard()
+void CoinListItemUI::discard()
 {
-    *qobject_cast<Sigmod::CoinListItem*>(modified()) = *qobject_cast<Sigmod::CoinListItem*>(original());
+    *qobject_cast<CoinListItem*>(modified()) = *qobject_cast<CoinListItem*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::CoinListItemUI::typeChanged(const int type)
+void CoinListItemUI::typeChanged(const int type)
 {
-    qobject_cast<Sigmod::CoinListItem*>(modified())->setType(static_cast<Sigmod::CoinListItem::Type>(type));
+    qobject_cast<CoinListItem*>(modified())->setType(static_cast<CoinListItem::Type>(type));
 }
 
-void Sigmodr::Widgets::CoinListItemUI::objectChanged(const int obey)
+void CoinListItemUI::objectChanged(const int obey)
 {
-    qobject_cast<Sigmod::CoinListItem*>(modified())->setObject(ui_object->itemData(obey).toInt());
+    qobject_cast<CoinListItem*>(modified())->setObject(ui_object->itemData(obey).toInt());
 }
 
-void Sigmodr::Widgets::CoinListItemUI::costChanged(const int cost)
+void CoinListItemUI::costChanged(const int cost)
 {
-    qobject_cast<Sigmod::CoinListItem*>(modified())->setCost(cost);
+    qobject_cast<CoinListItem*>(modified())->setCost(cost);
 }
diff --git a/sigmodr/widgets/CoinListUI.cpp b/sigmodr/widgets/CoinListUI.cpp
index 153214fe..4448a984 100644
--- a/sigmodr/widgets/CoinListUI.cpp
+++ b/sigmodr/widgets/CoinListUI.cpp
@@ -32,13 +32,17 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::CoinListUI::CoinListUI(Sigmod::CoinList* coinList, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+CoinListUI::CoinListUI(CoinList* coinList, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(coinList, new Sigmod::CoinList(*coinList));
+    setObjects(coinList, new CoinList(*coinList));
 }
 
-void Sigmodr::Widgets::CoinListUI::initGui()
+void CoinListUI::initGui()
 {
     QFile file(":/gui/coinlist.ui");
     file.open(QFile::ReadOnly);
@@ -50,33 +54,33 @@ void Sigmodr::Widgets::CoinListUI::initGui()
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::CoinListUI::setGui()
+void CoinListUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::CoinList*>(modified())->name());
-    ui_script->setValue(qobject_cast<Sigmod::CoinList*>(modified())->script());
+    ui_name->setText(qobject_cast<CoinList*>(modified())->name());
+    ui_script->setValue(qobject_cast<CoinList*>(modified())->script());
 }
 
-void Sigmodr::Widgets::CoinListUI::apply()
+void CoinListUI::apply()
 {
-    *qobject_cast<Sigmod::CoinList*>(original()) = *qobject_cast<Sigmod::CoinList*>(modified());
+    *qobject_cast<CoinList*>(original()) = *qobject_cast<CoinList*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::CoinListUI::discard()
+void CoinListUI::discard()
 {
-    *qobject_cast<Sigmod::CoinList*>(modified()) = *qobject_cast<Sigmod::CoinList*>(original());
+    *qobject_cast<CoinList*>(modified()) = *qobject_cast<CoinList*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::CoinListUI::nameChanged(const QString& name)
+void CoinListUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::CoinList*>(modified())->setName(name);
+    qobject_cast<CoinList*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::CoinListUI::scriptChanged(const Sigcore::Script& script)
+void CoinListUI::scriptChanged(const Script& script)
 {
-    qobject_cast<Sigmod::CoinList*>(modified())->setScript(script);
+    qobject_cast<CoinList*>(modified())->setScript(script);
 }
diff --git a/sigmodr/widgets/EggGroupUI.cpp b/sigmodr/widgets/EggGroupUI.cpp
index 200607ed..e2411e47 100644
--- a/sigmodr/widgets/EggGroupUI.cpp
+++ b/sigmodr/widgets/EggGroupUI.cpp
@@ -28,13 +28,16 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::EggGroupUI::EggGroupUI(Sigmod::EggGroup* eggGroup, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+EggGroupUI::EggGroupUI(EggGroup* eggGroup, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(eggGroup, new Sigmod::EggGroup(*eggGroup));
+    setObjects(eggGroup, new EggGroup(*eggGroup));
 }
 
-void Sigmodr::Widgets::EggGroupUI::initGui()
+void EggGroupUI::initGui()
 {
     QFile file(":/gui/egggroup.ui");
     file.open(QFile::ReadOnly);
@@ -44,27 +47,27 @@ void Sigmodr::Widgets::EggGroupUI::initGui()
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
 }
 
-void Sigmodr::Widgets::EggGroupUI::setGui()
+void EggGroupUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::EggGroup*>(modified())->name());
+    ui_name->setText(qobject_cast<EggGroup*>(modified())->name());
 }
 
-void Sigmodr::Widgets::EggGroupUI::apply()
+void EggGroupUI::apply()
 {
-    *qobject_cast<Sigmod::EggGroup*>(original()) = *qobject_cast<Sigmod::EggGroup*>(modified());
+    *qobject_cast<EggGroup*>(original()) = *qobject_cast<EggGroup*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::EggGroupUI::discard()
+void EggGroupUI::discard()
 {
-    *qobject_cast<Sigmod::EggGroup*>(modified()) = *qobject_cast<Sigmod::EggGroup*>(original());
+    *qobject_cast<EggGroup*>(modified()) = *qobject_cast<EggGroup*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::EggGroupUI::nameChanged(const QString& name)
+void EggGroupUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::EggGroup*>(modified())->setName(name);
+    qobject_cast<EggGroup*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
diff --git a/sigmodr/widgets/FractionWidget.cpp b/sigmodr/widgets/FractionWidget.cpp
index 85a1c306..4388661e 100644
--- a/sigmodr/widgets/FractionWidget.cpp
+++ b/sigmodr/widgets/FractionWidget.cpp
@@ -29,7 +29,10 @@
 // C includes
 #include <climits>
 
-Sigmodr::Widgets::FractionWidget::FractionWidget(QWidget* parent, const Sigcore::Fraction& value) :
+using namespace Sigcore;
+using namespace Sigmodr::Widgets;
+
+FractionWidget::FractionWidget(QWidget* parent, const Fraction& value) :
         QWidget(parent),
         m_value(value),
         m_behavior(Any)
@@ -43,29 +46,29 @@ Sigmodr::Widgets::FractionWidget::FractionWidget(QWidget* parent, const Sigcore:
     ui_value = formWidget->findChild<KLineEdit*>("varValue");
     connect(ui_numerator, SIGNAL(valueChanged(int)), this, SLOT(numeratorChanged(int)));
     connect(ui_denominator, SIGNAL(valueChanged(int)), this, SLOT(denominatorChanged(int)));
-    connect(this, SIGNAL(valueChanged(Sigcore::Fraction)), SLOT(updateValue()));
-    connect(this, SIGNAL(valueChanged(Sigcore::Fraction)), SLOT(resetRanges()));
+    connect(this, SIGNAL(valueChanged(Fraction)), SLOT(updateValue()));
+    connect(this, SIGNAL(valueChanged(Fraction)), SLOT(resetRanges()));
     connect(this, SIGNAL(behaviorChanged(Behavior)), SLOT(resetRanges()));
     resetRanges();
 }
 
-Sigmodr::Widgets::FractionWidget::Behavior Sigmodr::Widgets::FractionWidget::behavior() const
+FractionWidget::Behavior FractionWidget::behavior() const
 {
     return m_behavior;
 }
 
-Sigcore::Fraction Sigmodr::Widgets::FractionWidget::value() const
+Fraction FractionWidget::value() const
 {
     return m_value;
 }
 
-void Sigmodr::Widgets::FractionWidget::setBehavior(const Behavior behavior)
+void FractionWidget::setBehavior(const Behavior behavior)
 {
     m_behavior = behavior;
     emit(behaviorChanged(m_behavior));
 }
 
-void Sigmodr::Widgets::FractionWidget::setValue(const Sigcore::Fraction& value)
+void FractionWidget::setValue(const Fraction& value)
 {
     if (!ui_value->text().isEmpty() && (m_value == value))
         return;
@@ -73,24 +76,24 @@ void Sigmodr::Widgets::FractionWidget::setValue(const Sigcore::Fraction& value)
     emit(valueChanged(m_value));
 }
 
-void Sigmodr::Widgets::FractionWidget::updateValue()
+void FractionWidget::updateValue()
 {
     ui_value->setText(QString::number(double(m_value), 'g', 7));
 }
 
-void Sigmodr::Widgets::FractionWidget::numeratorChanged(const int numerator)
+void FractionWidget::numeratorChanged(const int numerator)
 {
     m_value.setNumerator(numerator);
     emit(valueChanged(m_value));
 }
 
-void Sigmodr::Widgets::FractionWidget::denominatorChanged(const int denominator)
+void FractionWidget::denominatorChanged(const int denominator)
 {
     m_value.setDenominator(denominator);
     emit(valueChanged(m_value));
 }
 
-void Sigmodr::Widgets::FractionWidget::resetRanges()
+void FractionWidget::resetRanges()
 {
     ui_numerator->setValue(m_value.numerator());
     ui_denominator->setValue(m_value.denominator());
diff --git a/sigmodr/widgets/GameUI.cpp b/sigmodr/widgets/GameUI.cpp
index 9c427d3e..34960d15 100644
--- a/sigmodr/widgets/GameUI.cpp
+++ b/sigmodr/widgets/GameUI.cpp
@@ -41,14 +41,18 @@
 #include <QtGui/QTableView>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::GameUI::GameUI(Sigmod::Game* game, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+GameUI::GameUI(Game* game, QWidget* parent) :
         ObjectUI(parent),
         m_changingMult(true)
 {
-    setObjects(game, new Sigmod::Game(*game));
+    setObjects(game, new Game(*game));
 }
 
-void Sigmodr::Widgets::GameUI::initGui()
+void GameUI::initGui()
 {
     QFile file(":/gui/game.ui");
     file.open(QFile::ReadOnly);
@@ -71,80 +75,80 @@ void Sigmodr::Widgets::GameUI::initGui()
     connect(ui_effectiveness, SIGNAL(valueChanged(Sigcore::Fraction)), this, SLOT(effectivenessChanged(Sigcore::Fraction)));
 }
 
-void Sigmodr::Widgets::GameUI::refreshGui()
+void GameUI::refreshGui()
 {
     delete ui_typechart->model();
     QStringList types;
-    for (int i = 0; i < qobject_cast<Sigmod::Game*>(original())->typeCount(); ++i)
-        types << qobject_cast<Sigmod::Game*>(original())->type(i)->name();
-    ui_typechart->setModel(new TypechartModel(qobject_cast<Sigmod::Game*>(modified())->typechart(), types));
+    for (int i = 0; i < qobject_cast<Game*>(original())->typeCount(); ++i)
+        types << qobject_cast<Game*>(original())->type(i)->name();
+    ui_typechart->setModel(new TypechartModel(qobject_cast<Game*>(modified())->typechart(), types));
     ui_effectiveness->setEnabled(false);
 }
 
-void Sigmodr::Widgets::GameUI::setGui()
+void GameUI::setGui()
 {
-    ui_title->setText(qobject_cast<Sigmod::Game*>(modified())->title());
-    ui_version->setText(qobject_cast<Sigmod::Game*>(modified())->version());
-    ui_description->setText(qobject_cast<Sigmod::Game*>(modified())->description());
-    ui_singlePlayer->setCheckState(qobject_cast<Sigmod::Game*>(modified())->singlePlayer() ? Qt::Checked : Qt::Unchecked);
-    ui_startScript->setValue(qobject_cast<Sigmod::Game*>(modified())->startScript());
+    ui_title->setText(qobject_cast<Game*>(modified())->title());
+    ui_version->setText(qobject_cast<Game*>(modified())->version());
+    ui_description->setText(qobject_cast<Game*>(modified())->description());
+    ui_singlePlayer->setCheckState(qobject_cast<Game*>(modified())->singlePlayer() ? Qt::Checked : Qt::Unchecked);
+    ui_startScript->setValue(qobject_cast<Game*>(modified())->startScript());
 }
 
-void Sigmodr::Widgets::GameUI::apply()
+void GameUI::apply()
 {
-    *qobject_cast<Sigmod::Game*>(original()) = *qobject_cast<Sigmod::Game*>(modified());
+    *qobject_cast<Game*>(original()) = *qobject_cast<Game*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::GameUI::discard()
+void GameUI::discard()
 {
-    *qobject_cast<Sigmod::Game*>(modified()) = *qobject_cast<Sigmod::Game*>(original());
+    *qobject_cast<Game*>(modified()) = *qobject_cast<Game*>(original());
     setGui();
     qobject_cast<TypechartModel*>(ui_typechart->model())->discarded();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::GameUI::titleChanged(const QString& title)
+void GameUI::titleChanged(const QString& title)
 {
     const int cursor = ui_title->cursorPosition();
-    qobject_cast<Sigmod::Game*>(modified())->setTitle(title);
+    qobject_cast<Game*>(modified())->setTitle(title);
     ui_title->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::GameUI::versionChanged(const QString& version)
+void GameUI::versionChanged(const QString& version)
 {
     const int cursor = ui_version->cursorPosition();
-    qobject_cast<Sigmod::Game*>(modified())->setVersion(version);
+    qobject_cast<Game*>(modified())->setVersion(version);
     ui_version->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::GameUI::descriptionChanged(const QString& description)
+void GameUI::descriptionChanged(const QString& description)
 {
     const int cursor = ui_description->cursorPosition();
-    qobject_cast<Sigmod::Game*>(modified())->setDescription(description);
+    qobject_cast<Game*>(modified())->setDescription(description);
     ui_description->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::GameUI::singlePlayerChanged(const bool singlePlayer)
+void GameUI::singlePlayerChanged(const bool singlePlayer)
 {
-    qobject_cast<Sigmod::Game*>(modified())->setSinglePlayer(singlePlayer);
+    qobject_cast<Game*>(modified())->setSinglePlayer(singlePlayer);
 }
 
-void Sigmodr::Widgets::GameUI::startScriptChanged(const Sigcore::Script& startScript)
+void GameUI::startScriptChanged(const Script& startScript)
 {
-    qobject_cast<Sigmod::Game*>(modified())->setStartScript(startScript);
+    qobject_cast<Game*>(modified())->setStartScript(startScript);
 }
 
-void Sigmodr::Widgets::GameUI::typechartChanged(const QModelIndex& index)
+void GameUI::typechartChanged(const QModelIndex& index)
 {
     m_index = index;
     m_changingMult = true;
     ui_effectiveness->setEnabled(true);
     ui_labelTypes->setText(QString("%1 vs. %2").arg(ui_typechart->model()->headerData(index.row(), Qt::Vertical, Qt::DisplayRole).toString()).arg(ui_typechart->model()->headerData(index.column(), Qt::Horizontal, Qt::DisplayRole).toString()));
-    ui_effectiveness->setValue(ui_typechart->model()->data(m_index, Qt::EditRole).value<Sigcore::Fraction>());
+    ui_effectiveness->setValue(ui_typechart->model()->data(m_index, Qt::EditRole).value<Fraction>());
 }
 
-void Sigmodr::Widgets::GameUI::effectivenessChanged(const Sigcore::Fraction& multiplier)
+void GameUI::effectivenessChanged(const Fraction& multiplier)
 {
     ui_typechart->model()->setData(m_index, QVariant::fromValue(multiplier), Qt::EditRole);
     if (!m_changingMult)
diff --git a/sigmodr/widgets/GlobalScriptUI.cpp b/sigmodr/widgets/GlobalScriptUI.cpp
index 891b8013..c59ccd69 100644
--- a/sigmodr/widgets/GlobalScriptUI.cpp
+++ b/sigmodr/widgets/GlobalScriptUI.cpp
@@ -31,13 +31,17 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::GlobalScriptUI::GlobalScriptUI(Sigmod::GlobalScript* globalScript, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+GlobalScriptUI::GlobalScriptUI(GlobalScript* globalScript, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(globalScript, new Sigmod::GlobalScript(*globalScript));
+    setObjects(globalScript, new GlobalScript(*globalScript));
 }
 
-void Sigmodr::Widgets::GlobalScriptUI::initGui()
+void GlobalScriptUI::initGui()
 {
     QFile file(":/gui/globalscript.ui");
     file.open(QFile::ReadOnly);
@@ -49,33 +53,33 @@ void Sigmodr::Widgets::GlobalScriptUI::initGui()
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::GlobalScriptUI::setGui()
+void GlobalScriptUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::GlobalScript*>(modified())->name());
-    ui_script->setValue(qobject_cast<Sigmod::GlobalScript*>(modified())->script());
+    ui_name->setText(qobject_cast<GlobalScript*>(modified())->name());
+    ui_script->setValue(qobject_cast<GlobalScript*>(modified())->script());
 }
 
-void Sigmodr::Widgets::GlobalScriptUI::apply()
+void GlobalScriptUI::apply()
 {
-    *qobject_cast<Sigmod::GlobalScript*>(original()) = *qobject_cast<Sigmod::GlobalScript*>(modified());
+    *qobject_cast<GlobalScript*>(original()) = *qobject_cast<GlobalScript*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::GlobalScriptUI::discard()
+void GlobalScriptUI::discard()
 {
-    *qobject_cast<Sigmod::GlobalScript*>(modified()) = *qobject_cast<Sigmod::GlobalScript*>(original());
+    *qobject_cast<GlobalScript*>(modified()) = *qobject_cast<GlobalScript*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::GlobalScriptUI::nameChanged(const QString& name)
+void GlobalScriptUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::GlobalScript*>(modified())->setName(name);
+    qobject_cast<GlobalScript*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::GlobalScriptUI::scriptChanged(const Sigcore::Script& script)
+void GlobalScriptUI::scriptChanged(const Script& script)
 {
-    qobject_cast<Sigmod::GlobalScript*>(modified())->setScript(script);
+    qobject_cast<GlobalScript*>(modified())->setScript(script);
 }
diff --git a/sigmodr/widgets/ItemTypeUI.cpp b/sigmodr/widgets/ItemTypeUI.cpp
index c6804265..4bfac8ad 100644
--- a/sigmodr/widgets/ItemTypeUI.cpp
+++ b/sigmodr/widgets/ItemTypeUI.cpp
@@ -32,13 +32,16 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::ItemTypeUI::ItemTypeUI(Sigmod::ItemType* itemType, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+ItemTypeUI::ItemTypeUI(ItemType* itemType, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(itemType, new Sigmod::ItemType(*itemType));
+    setObjects(itemType, new ItemType(*itemType));
 }
 
-void Sigmodr::Widgets::ItemTypeUI::initGui()
+void ItemTypeUI::initGui()
 {
     QFile file(":/gui/itemtype.ui");
     file.open(QFile::ReadOnly);
@@ -55,54 +58,54 @@ void Sigmodr::Widgets::ItemTypeUI::initGui()
     connect(ui_maxWeight, SIGNAL(valueChanged(int)), this, SLOT(maxWeightChanged(int)));
     connect(ui_count, SIGNAL(currentIndexChanged(int)), this, SLOT(countChanged(int)));
     ui_maxWeight->setMaximum(game()->rules()->maxTotalWeight());
-    ui_count->addItems(Sigmod::ItemType::CountStr);
+    ui_count->addItems(ItemType::CountStr);
 }
 
-void Sigmodr::Widgets::ItemTypeUI::setGui()
+void ItemTypeUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::ItemType*>(modified())->name());
-    ui_computer->setValue(qobject_cast<Sigmod::ItemType*>(modified())->computer());
-    ui_player->setValue(qobject_cast<Sigmod::ItemType*>(modified())->player());
-    ui_maxWeight->setValue(qobject_cast<Sigmod::ItemType*>(modified())->maxWeight());
-    ui_count->setCurrentIndex(qobject_cast<Sigmod::ItemType*>(modified())->count());
+    ui_name->setText(qobject_cast<ItemType*>(modified())->name());
+    ui_computer->setValue(qobject_cast<ItemType*>(modified())->computer());
+    ui_player->setValue(qobject_cast<ItemType*>(modified())->player());
+    ui_maxWeight->setValue(qobject_cast<ItemType*>(modified())->maxWeight());
+    ui_count->setCurrentIndex(qobject_cast<ItemType*>(modified())->count());
 }
 
-void Sigmodr::Widgets::ItemTypeUI::apply()
+void ItemTypeUI::apply()
 {
-    *qobject_cast<Sigmod::ItemType*>(original()) = *qobject_cast<Sigmod::ItemType*>(modified());
+    *qobject_cast<ItemType*>(original()) = *qobject_cast<ItemType*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::ItemTypeUI::discard()
+void ItemTypeUI::discard()
 {
-    *qobject_cast<Sigmod::ItemType*>(modified()) = *qobject_cast<Sigmod::ItemType*>(original());
+    *qobject_cast<ItemType*>(modified()) = *qobject_cast<ItemType*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::ItemTypeUI::nameChanged(const QString& name)
+void ItemTypeUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::ItemType*>(modified())->setName(name);
+    qobject_cast<ItemType*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::ItemTypeUI::computerChanged(const int computer)
+void ItemTypeUI::computerChanged(const int computer)
 {
-    qobject_cast<Sigmod::ItemType*>(modified())->setComputer(computer);
+    qobject_cast<ItemType*>(modified())->setComputer(computer);
 }
 
-void Sigmodr::Widgets::ItemTypeUI::playerChanged(const int player)
+void ItemTypeUI::playerChanged(const int player)
 {
-    qobject_cast<Sigmod::ItemType*>(modified())->setPlayer(player);
+    qobject_cast<ItemType*>(modified())->setPlayer(player);
 }
 
-void Sigmodr::Widgets::ItemTypeUI::maxWeightChanged(const int maxWeight)
+void ItemTypeUI::maxWeightChanged(const int maxWeight)
 {
-    qobject_cast<Sigmod::ItemType*>(modified())->setMaxWeight(maxWeight);
+    qobject_cast<ItemType*>(modified())->setMaxWeight(maxWeight);
 }
 
-void Sigmodr::Widgets::ItemTypeUI::countChanged(const int count)
+void ItemTypeUI::countChanged(const int count)
 {
-    qobject_cast<Sigmod::ItemType*>(modified())->setCount(static_cast<Sigmod::ItemType::Count>(count));
+    qobject_cast<ItemType*>(modified())->setCount(static_cast<ItemType::Count>(count));
 }
diff --git a/sigmodr/widgets/ItemUI.cpp b/sigmodr/widgets/ItemUI.cpp
index b344c040..ec0076ef 100644
--- a/sigmodr/widgets/ItemUI.cpp
+++ b/sigmodr/widgets/ItemUI.cpp
@@ -37,14 +37,18 @@
 #include <QtGui/QCheckBox>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::ItemUI::ItemUI(Sigmod::Item* item, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+ItemUI::ItemUI(Item* item, QWidget* parent) :
         ObjectUI(parent),
         m_lastType(-1)
 {
-    setObjects(item, new Sigmod::Item(*item));
+    setObjects(item, new Item(*item));
 }
 
-void Sigmodr::Widgets::ItemUI::initGui()
+void ItemUI::initGui()
 {
     QFile file(":/gui/item.ui");
     file.open(QFile::ReadOnly);
@@ -68,7 +72,7 @@ void Sigmodr::Widgets::ItemUI::initGui()
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::ItemUI::refreshGui()
+void ItemUI::refreshGui()
 {
     const bool blocked = ui_type->blockSignals(true);
     ui_type->clear();
@@ -78,80 +82,80 @@ void Sigmodr::Widgets::ItemUI::refreshGui()
     ui_price->setMaximum(game()->rules()->maxMoney());
 }
 
-void Sigmodr::Widgets::ItemUI::setGui()
+void ItemUI::setGui()
 {
-    const bool resetWeight = (qobject_cast<Sigmod::Item*>(modified())->type() != m_lastType);
-    ui_name->setText(qobject_cast<Sigmod::Item*>(modified())->name());
-    ui_sellable->setCheckState(qobject_cast<Sigmod::Item*>(modified())->sellable() ? Qt::Checked : Qt::Unchecked);
-    ui_type->setCurrentIndex(game()->itemTypeIndex(qobject_cast<Sigmod::Item*>(modified())->type()));
-    m_lastType = qobject_cast<Sigmod::Item*>(modified())->type();
-    ui_price->setValue(qobject_cast<Sigmod::Item*>(modified())->price());
-    ui_sellPrice->setValue(qobject_cast<Sigmod::Item*>(modified())->sellPrice());
-    ui_sellPrice->setEnabled(qobject_cast<Sigmod::Item*>(modified())->sellable());
+    const bool resetWeight = (qobject_cast<Item*>(modified())->type() != m_lastType);
+    ui_name->setText(qobject_cast<Item*>(modified())->name());
+    ui_sellable->setCheckState(qobject_cast<Item*>(modified())->sellable() ? Qt::Checked : Qt::Unchecked);
+    ui_type->setCurrentIndex(game()->itemTypeIndex(qobject_cast<Item*>(modified())->type()));
+    m_lastType = qobject_cast<Item*>(modified())->type();
+    ui_price->setValue(qobject_cast<Item*>(modified())->price());
+    ui_sellPrice->setValue(qobject_cast<Item*>(modified())->sellPrice());
+    ui_sellPrice->setEnabled(qobject_cast<Item*>(modified())->sellable());
     if (resetWeight)
     {
-        const Sigmod::ItemType* itemType = game()->itemTypeById(qobject_cast<Sigmod::Item*>(modified())->type());
+        const ItemType* itemType = game()->itemTypeById(qobject_cast<Item*>(modified())->type());
         if (itemType)
             ui_weight->setMaximum(itemType->maxWeight());
     }
-    ui_weight->setValue(qobject_cast<Sigmod::Item*>(modified())->weight());
-    ui_description->setText(qobject_cast<Sigmod::Item*>(modified())->description());
-    ui_script->setValue(qobject_cast<Sigmod::Item*>(modified())->script());
+    ui_weight->setValue(qobject_cast<Item*>(modified())->weight());
+    ui_description->setText(qobject_cast<Item*>(modified())->description());
+    ui_script->setValue(qobject_cast<Item*>(modified())->script());
 }
 
-void Sigmodr::Widgets::ItemUI::apply()
+void ItemUI::apply()
 {
-    *qobject_cast<Sigmod::Item*>(original()) = *qobject_cast<Sigmod::Item*>(modified());
+    *qobject_cast<Item*>(original()) = *qobject_cast<Item*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::ItemUI::discard()
+void ItemUI::discard()
 {
-    *qobject_cast<Sigmod::Item*>(modified()) = *qobject_cast<Sigmod::Item*>(original());
+    *qobject_cast<Item*>(modified()) = *qobject_cast<Item*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::ItemUI::nameChanged(const QString& name)
+void ItemUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Item*>(modified())->setName(name);
+    qobject_cast<Item*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::ItemUI::sellableChanged(const bool sellable)
+void ItemUI::sellableChanged(const bool sellable)
 {
-    qobject_cast<Sigmod::Item*>(modified())->setSellable(sellable);
+    qobject_cast<Item*>(modified())->setSellable(sellable);
 }
 
-void Sigmodr::Widgets::ItemUI::typeChanged(const int type)
+void ItemUI::typeChanged(const int type)
 {
-    qobject_cast<Sigmod::Item*>(modified())->setType(game()->itemType(type)->id());
+    qobject_cast<Item*>(modified())->setType(game()->itemType(type)->id());
 }
 
-void Sigmodr::Widgets::ItemUI::priceChanged(const int price)
+void ItemUI::priceChanged(const int price)
 {
-    qobject_cast<Sigmod::Item*>(modified())->setPrice(price);
+    qobject_cast<Item*>(modified())->setPrice(price);
 }
 
-void Sigmodr::Widgets::ItemUI::sellPriceChanged(const int sellPrice)
+void ItemUI::sellPriceChanged(const int sellPrice)
 {
-    qobject_cast<Sigmod::Item*>(modified())->setSellPrice(sellPrice);
+    qobject_cast<Item*>(modified())->setSellPrice(sellPrice);
 }
 
-void Sigmodr::Widgets::ItemUI::weightChanged(const int weight)
+void ItemUI::weightChanged(const int weight)
 {
-    qobject_cast<Sigmod::Item*>(modified())->setWeight(weight);
+    qobject_cast<Item*>(modified())->setWeight(weight);
 }
 
-void Sigmodr::Widgets::ItemUI::descriptionChanged(const QString& description)
+void ItemUI::descriptionChanged(const QString& description)
 {
     const int cursor = ui_description->cursorPosition();
-    qobject_cast<Sigmod::Item*>(modified())->setDescription(description);
+    qobject_cast<Item*>(modified())->setDescription(description);
     ui_description->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::ItemUI::scriptChanged(const Sigcore::Script& script)
+void ItemUI::scriptChanged(const Script& script)
 {
-    qobject_cast<Sigmod::Item*>(modified())->setScript(script);
+    qobject_cast<Item*>(modified())->setScript(script);
 }
diff --git a/sigmodr/widgets/MapEffectUI.cpp b/sigmodr/widgets/MapEffectUI.cpp
index 911b189c..e73110b4 100644
--- a/sigmodr/widgets/MapEffectUI.cpp
+++ b/sigmodr/widgets/MapEffectUI.cpp
@@ -24,65 +24,69 @@
 #include <sigmod/MapEffect.h>
 #include <sigmod/Skin.h>
 
-Sigmodr::Widgets::MapEffectUI::MapEffectUI(Sigmod::MapEffect* effect, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MapEffectUI::MapEffectUI(MapEffect* effect, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(effect, new Sigmod::MapEffect(*effect));
+    setObjects(effect, new MapEffect(*effect));
 }
 
-Sigmodr::Widgets::MapEffectUI::~MapEffectUI()
+MapEffectUI::~MapEffectUI()
 {
 }
 
-void Sigmodr::Widgets::MapEffectUI::refreshGui()
+void MapEffectUI::refreshGui()
 {
     for (int i = 0; i < game()->skinCount(); ++i)
     {
-        const Sigmod::Skin* skin = game()->skin(i);
+        const Skin* skin = game()->skin(i);
         varSkin->addItem(skin->name(), skin->id());
     }
 }
 
-void Sigmodr::Widgets::MapEffectUI::setGui()
+void MapEffectUI::setGui()
 {
-    varName->setText(qobject_cast<Sigmod::MapEffect*>(modified())->name());
-    varSkin->setCurrentIndex(varSkin->findData(qobject_cast<Sigmod::MapEffect*>(modified())->skin()));
-    varScript->setValue(qobject_cast<Sigmod::MapEffect*>(modified())->script());
-    varIsGhost->setCheckState(qobject_cast<Sigmod::MapEffect*>(modified())->isGhost() ? Qt::Checked : Qt::Unchecked);
+    varName->setText(qobject_cast<MapEffect*>(modified())->name());
+    varSkin->setCurrentIndex(varSkin->findData(qobject_cast<MapEffect*>(modified())->skin()));
+    varScript->setValue(qobject_cast<MapEffect*>(modified())->script());
+    varIsGhost->setCheckState(qobject_cast<MapEffect*>(modified())->isGhost() ? Qt::Checked : Qt::Unchecked);
 }
 
-void Sigmodr::Widgets::MapEffectUI::apply()
+void MapEffectUI::apply()
 {
-    *qobject_cast<Sigmod::MapEffect*>(original()) = *qobject_cast<Sigmod::MapEffect*>(modified());
+    *qobject_cast<MapEffect*>(original()) = *qobject_cast<MapEffect*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapEffectUI::discard()
+void MapEffectUI::discard()
 {
-    *qobject_cast<Sigmod::MapEffect*>(modified()) = *qobject_cast<Sigmod::MapEffect*>(original());
+    *qobject_cast<MapEffect*>(modified()) = *qobject_cast<MapEffect*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapEffectUI::on_varName_textChanged(const QString& name)
+void MapEffectUI::on_varName_textChanged(const QString& name)
 {
     const int cursor = varName->cursorPosition();
-    qobject_cast<Sigmod::MapEffect*>(modified())->setName(name);
+    qobject_cast<MapEffect*>(modified())->setName(name);
     varName->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::MapEffectUI::on_varSkin_currentIndexChanged(const int skin)
+void MapEffectUI::on_varSkin_currentIndexChanged(const int skin)
 {
-    qobject_cast<Sigmod::MapEffect*>(modified())->setSkin(varSkin->itemData(skin).toInt());
+    qobject_cast<MapEffect*>(modified())->setSkin(varSkin->itemData(skin).toInt());
 }
 
-void Sigmodr::Widgets::MapEffectUI::on_varScript_valueChanged(const Sigcore::Script& script)
+void MapEffectUI::on_varScript_valueChanged(const Script& script)
 {
-    qobject_cast<Sigmod::MapEffect*>(modified())->setScript(script);
+    qobject_cast<MapEffect*>(modified())->setScript(script);
 }
 
-void Sigmodr::Widgets::MapEffectUI::on_varIsGhost_toggled(const bool isGhost)
+void MapEffectUI::on_varIsGhost_toggled(const bool isGhost)
 {
-    qobject_cast<Sigmod::MapEffect*>(modified())->setIsGhost(isGhost);
+    qobject_cast<MapEffect*>(modified())->setIsGhost(isGhost);
 }
diff --git a/sigmodr/widgets/MapTrainerTeamMemberUI.cpp b/sigmodr/widgets/MapTrainerTeamMemberUI.cpp
index 48ac1b4d..c9e57491 100644
--- a/sigmodr/widgets/MapTrainerTeamMemberUI.cpp
+++ b/sigmodr/widgets/MapTrainerTeamMemberUI.cpp
@@ -31,29 +31,32 @@
 // Qt includes
 #include <QtGui/QListWidgetItem>
 
-Sigmodr::Widgets::MapTrainerTeamMemberUI::MapTrainerTeamMemberUI(Sigmod::MapTrainerTeamMember* teamMember, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MapTrainerTeamMemberUI::MapTrainerTeamMemberUI(MapTrainerTeamMember* teamMember, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(teamMember, new Sigmod::MapTrainerTeamMember(*teamMember));
+    setObjects(teamMember, new MapTrainerTeamMember(*teamMember));
 }
 
-Sigmodr::Widgets::MapTrainerTeamMemberUI::~MapTrainerTeamMemberUI()
+MapTrainerTeamMemberUI::~MapTrainerTeamMemberUI()
 {
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::initGui()
+void MapTrainerTeamMemberUI::initGui()
 {
     connect(varItems->selectedListWidget(), SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), this, SLOT(selectedItemChanged(QListWidgetItem*)));
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::refreshGui()
+void MapTrainerTeamMemberUI::refreshGui()
 {
     const bool blockedSpecies = varSpecies->blockSignals(true);
     varSpecies->clear();
     for (int i = 0; i < game()->speciesCount(); ++i)
     {
-        const Sigmod::Species* species = game()->species(i);
+        const Species* species = game()->species(i);
         varSpecies->addItem(species->name(), species->id());
     }
     varSpecies->blockSignals(blockedSpecies);
@@ -63,7 +66,7 @@ void Sigmodr::Widgets::MapTrainerTeamMemberUI::refreshGui()
     varAbilities->selectedListWidget()->clear();
     for (int i = 0; i < game()->abilityCount(); ++i)
     {
-        const Sigmod::Ability* ability = game()->ability(i);
+        const Ability* ability = game()->ability(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(ability->name(), varAbilities->availableListWidget());
         widgetItem->setData(Qt::UserRole, ability->id());
     }
@@ -75,7 +78,7 @@ void Sigmodr::Widgets::MapTrainerTeamMemberUI::refreshGui()
     varItems->selectedListWidget()->clear();
     for (int i = 0; i < game()->itemCount(); ++i)
     {
-        const Sigmod::Item* item = game()->item(i);
+        const Item* item = game()->item(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(item->name(), varItems->availableListWidget());
         widgetItem->setData(Qt::UserRole, item->id());
     }
@@ -87,7 +90,7 @@ void Sigmodr::Widgets::MapTrainerTeamMemberUI::refreshGui()
     varMoves->selectedListWidget()->clear();
     for (int i = 0; i < game()->moveCount(); ++i)
     {
-        const Sigmod::Move* move = game()->move(i);
+        const Move* move = game()->move(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(move->name(), varMoves->availableListWidget());
         widgetItem->setData(Qt::UserRole, move->id());
     }
@@ -98,7 +101,7 @@ void Sigmodr::Widgets::MapTrainerTeamMemberUI::refreshGui()
     varNatures->selectedListWidget()->clear();
     for (int i = 0; i < game()->natureCount(); ++i)
     {
-        const Sigmod::Nature* nature = game()->nature(i);
+        const Nature* nature = game()->nature(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(nature->name(), varNatures->availableListWidget());
         widgetItem->setData(Qt::UserRole, nature->id());
     }
@@ -107,149 +110,149 @@ void Sigmodr::Widgets::MapTrainerTeamMemberUI::refreshGui()
     boxNatures->setEnabled(game()->rules()->maxNatures());
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::setGui()
+void MapTrainerTeamMemberUI::setGui()
 {
-    varSpecies->setCurrentIndex(varSpecies->findData(qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->species()));
-    varLevel->setValue(qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->level());
+    varSpecies->setCurrentIndex(varSpecies->findData(qobject_cast<MapTrainerTeamMember*>(modified())->species()));
+    varLevel->setValue(qobject_cast<MapTrainerTeamMember*>(modified())->level());
     for (int i = 0; i < varAbilities->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varAbilities->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<MapTrainerTeamMember*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
             varAbilities->selectedListWidget()->addItem(varAbilities->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varAbilities->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varAbilities->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<MapTrainerTeamMember*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
             varAbilities->availableListWidget()->addItem(varAbilities->selectedListWidget()->takeItem(i--));
     }
     varAbilities->setButtonsEnabled();
     for (int i = 0; i < varItems->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varItems->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<MapTrainerTeamMember*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
             varItems->selectedListWidget()->addItem(varItems->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varItems->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varItems->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<MapTrainerTeamMember*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
             varItems->availableListWidget()->addItem(varItems->selectedListWidget()->takeItem(i--));
     }
     varItems->setButtonsEnabled();
     QListWidgetItem* selectedItem = varItems->selectedListWidget()->currentItem();
     if (selectedItem)
-        varItemCount->setValue(qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->item(selectedItem->data(Qt::UserRole).toInt()));
+        varItemCount->setValue(qobject_cast<MapTrainerTeamMember*>(modified())->item(selectedItem->data(Qt::UserRole).toInt()));
     for (int i = 0; i < varMoves->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varMoves->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->move(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<MapTrainerTeamMember*>(modified())->move(widgetItem->data(Qt::UserRole).toInt()))
             varMoves->selectedListWidget()->addItem(varMoves->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varMoves->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varMoves->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->move(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<MapTrainerTeamMember*>(modified())->move(widgetItem->data(Qt::UserRole).toInt()))
             varMoves->availableListWidget()->addItem(varMoves->selectedListWidget()->takeItem(i--));
     }
     varMoves->setButtonsEnabled();
     for (int i = 0; i < varNatures->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varNatures->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->nature(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<MapTrainerTeamMember*>(modified())->nature(widgetItem->data(Qt::UserRole).toInt()))
             varNatures->selectedListWidget()->addItem(varNatures->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varNatures->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varNatures->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->nature(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<MapTrainerTeamMember*>(modified())->nature(widgetItem->data(Qt::UserRole).toInt()))
             varNatures->availableListWidget()->addItem(varNatures->selectedListWidget()->takeItem(i--));
     }
     varNatures->setButtonsEnabled();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::apply()
+void MapTrainerTeamMemberUI::apply()
 {
-    *qobject_cast<Sigmod::MapTrainerTeamMember*>(original()) = *qobject_cast<Sigmod::MapTrainerTeamMember*>(modified());
+    *qobject_cast<MapTrainerTeamMember*>(original()) = *qobject_cast<MapTrainerTeamMember*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::discard()
+void MapTrainerTeamMemberUI::discard()
 {
-    *qobject_cast<Sigmod::MapTrainerTeamMember*>(modified()) = *qobject_cast<Sigmod::MapTrainerTeamMember*>(original());
+    *qobject_cast<MapTrainerTeamMember*>(modified()) = *qobject_cast<MapTrainerTeamMember*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varSpecies_activated(const int species)
+void MapTrainerTeamMemberUI::on_varSpecies_activated(const int species)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setSpecies(varSpecies->itemData(species).toInt());
+    qobject_cast<MapTrainerTeamMember*>(modified())->setSpecies(varSpecies->itemData(species).toInt());
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varLevel_valueChanged(const int level)
+void MapTrainerTeamMemberUI::on_varLevel_valueChanged(const int level)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setLevel(level);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setLevel(level);
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varAbilities_added(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varAbilities_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), true);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), true);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varAbilities_removed(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varAbilities_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), false);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), false);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varItems_added(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varItems_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 1);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 1);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varItems_removed(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varItems_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 0);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 0);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::selectedItemChanged(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::selectedItemChanged(QListWidgetItem* item)
 {
     if (item)
-        varItemCount->setValue(qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->item(item->data(Qt::UserRole).toInt()));
+        varItemCount->setValue(qobject_cast<MapTrainerTeamMember*>(modified())->item(item->data(Qt::UserRole).toInt()));
     else
         varItemCount->setEnabled(false);
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varItemCount_valueChanged(const int itemCount)
+void MapTrainerTeamMemberUI::on_varItemCount_valueChanged(const int itemCount)
 {
     QListWidgetItem* item = varItems->selectedListWidget()->currentItem();
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), itemCount);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setItem(item->data(Qt::UserRole).toInt(), itemCount);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varMoves_added(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varMoves_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setMove(item->data(Qt::UserRole).toInt(), true);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setMove(item->data(Qt::UserRole).toInt(), true);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varMoves_removed(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varMoves_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setMove(item->data(Qt::UserRole).toInt(), false);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setMove(item->data(Qt::UserRole).toInt(), false);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varNatures_added(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varNatures_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setNature(item->data(Qt::UserRole).toInt(), true);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setNature(item->data(Qt::UserRole).toInt(), true);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerTeamMemberUI::on_varNatures_removed(QListWidgetItem* item)
+void MapTrainerTeamMemberUI::on_varNatures_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainerTeamMember*>(modified())->setNature(item->data(Qt::UserRole).toInt(), false);
+    qobject_cast<MapTrainerTeamMember*>(modified())->setNature(item->data(Qt::UserRole).toInt(), false);
     setGui();
 }
diff --git a/sigmodr/widgets/MapTrainerUI.cpp b/sigmodr/widgets/MapTrainerUI.cpp
index 455bbfae..4f3bda2f 100644
--- a/sigmodr/widgets/MapTrainerUI.cpp
+++ b/sigmodr/widgets/MapTrainerUI.cpp
@@ -30,24 +30,28 @@
 #include <QtGui/QListWidget>
 #include <QtGui/QListWidgetItem>
 
-Sigmodr::Widgets::MapTrainerUI::MapTrainerUI(Sigmod::MapTrainer* trainer, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MapTrainerUI::MapTrainerUI(MapTrainer* trainer, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(trainer, new Sigmod::MapTrainer(*trainer));
+    setObjects(trainer, new MapTrainer(*trainer));
 }
 
-Sigmodr::Widgets::MapTrainerUI::~MapTrainerUI()
+MapTrainerUI::~MapTrainerUI()
 {
 }
 
-void Sigmodr::Widgets::MapTrainerUI::refreshGui()
+void MapTrainerUI::refreshGui()
 {
     const bool blockedTrainerClass = varTrainerClass->blockSignals(true);
     varTrainerClass->clear();
     for (int i = 0; i < game()->trainerCount(); ++i)
     {
-        const Sigmod::Trainer* trainer = game()->trainer(i);
+        const Trainer* trainer = game()->trainer(i);
         varTrainerClass->addItem(trainer->name(), trainer->id());
     }
     varTrainerClass->blockSignals(blockedTrainerClass);
@@ -55,11 +59,11 @@ void Sigmodr::Widgets::MapTrainerUI::refreshGui()
     const bool blockedLeadTeamMember = varLeadTeamMember->blockSignals(true);
     varLeadTeamMember->availableListWidget()->clear();
     varLeadTeamMember->selectedListWidget()->clear();
-    for (int i = 0; i < qobject_cast<Sigmod::MapTrainer*>(original())->teamMemberCount(); ++i)
+    for (int i = 0; i < qobject_cast<MapTrainer*>(original())->teamMemberCount(); ++i)
     {
         QString speciesName;
-        const Sigmod::MapTrainerTeamMember* teamMember = qobject_cast<Sigmod::MapTrainer*>(original())->teamMember(i);
-        const Sigmod::Species* species = game()->species(teamMember->species());
+        const MapTrainerTeamMember* teamMember = qobject_cast<MapTrainer*>(original())->teamMember(i);
+        const Species* species = game()->species(teamMember->species());
         speciesName = species ? species->name() : "(Invalid)";
         QListWidgetItem* widgetItem = new QListWidgetItem(QString("%1 level %2 (%3)").arg(speciesName, teamMember->level(), i), varLeadTeamMember->availableListWidget());
         widgetItem->setData(Qt::UserRole, teamMember->id());
@@ -68,70 +72,70 @@ void Sigmodr::Widgets::MapTrainerUI::refreshGui()
     varLeadTeamMember->setButtonsEnabled();
 }
 
-void Sigmodr::Widgets::MapTrainerUI::setGui()
+void MapTrainerUI::setGui()
 {
-    varName->setText(qobject_cast<Sigmod::MapTrainer*>(modified())->name());
-    varTrainerClass->setCurrentIndex(varTrainerClass->findData(qobject_cast<Sigmod::MapTrainer*>(modified())->trainerClass()));
-    varNumberFight->setValue(qobject_cast<Sigmod::MapTrainer*>(modified())->numberFight());
-    varScript->setValue(qobject_cast<Sigmod::MapTrainer*>(modified())->script());
+    varName->setText(qobject_cast<MapTrainer*>(modified())->name());
+    varTrainerClass->setCurrentIndex(varTrainerClass->findData(qobject_cast<MapTrainer*>(modified())->trainerClass()));
+    varNumberFight->setValue(qobject_cast<MapTrainer*>(modified())->numberFight());
+    varScript->setValue(qobject_cast<MapTrainer*>(modified())->script());
     for (int i = 0; i < varLeadTeamMember->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varLeadTeamMember->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::MapTrainer*>(modified())->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<MapTrainer*>(modified())->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
             varLeadTeamMember->selectedListWidget()->addItem(varLeadTeamMember->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varLeadTeamMember->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varLeadTeamMember->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::MapTrainer*>(modified())->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<MapTrainer*>(modified())->leadTeamMember(widgetItem->data(Qt::UserRole).toInt()))
             varLeadTeamMember->availableListWidget()->addItem(varLeadTeamMember->selectedListWidget()->takeItem(i--));
     }
     varLeadTeamMember->setButtonsEnabled();
 }
 
-void Sigmodr::Widgets::MapTrainerUI::apply()
+void MapTrainerUI::apply()
 {
-    *qobject_cast<Sigmod::MapTrainer*>(original()) = *qobject_cast<Sigmod::MapTrainer*>(modified());
+    *qobject_cast<MapTrainer*>(original()) = *qobject_cast<MapTrainer*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapTrainerUI::discard()
+void MapTrainerUI::discard()
 {
-    *qobject_cast<Sigmod::MapTrainer*>(modified()) = *qobject_cast<Sigmod::MapTrainer*>(original());
+    *qobject_cast<MapTrainer*>(modified()) = *qobject_cast<MapTrainer*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapTrainerUI::on_varName_textChanged(const QString& name)
+void MapTrainerUI::on_varName_textChanged(const QString& name)
 {
     const int cursor = varName->cursorPosition();
-    qobject_cast<Sigmod::MapTrainer*>(modified())->setName(name);
+    qobject_cast<MapTrainer*>(modified())->setName(name);
     varName->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::MapTrainerUI::on_varTrainerClass_activated(const int trainerClass)
+void MapTrainerUI::on_varTrainerClass_activated(const int trainerClass)
 {
-    qobject_cast<Sigmod::MapTrainer*>(modified())->setTrainerClass(varTrainerClass->itemData(trainerClass).toInt());
+    qobject_cast<MapTrainer*>(modified())->setTrainerClass(varTrainerClass->itemData(trainerClass).toInt());
 }
 
-void Sigmodr::Widgets::MapTrainerUI::on_varNumberFight_valueChanged(const int numberFight)
+void MapTrainerUI::on_varNumberFight_valueChanged(const int numberFight)
 {
-    qobject_cast<Sigmod::MapTrainer*>(modified())->setNumberFight(numberFight);
+    qobject_cast<MapTrainer*>(modified())->setNumberFight(numberFight);
 }
 
-void Sigmodr::Widgets::MapTrainerUI::on_varScript_valueChanged(const Sigcore::Script& script)
+void MapTrainerUI::on_varScript_valueChanged(const Script& script)
 {
-    qobject_cast<Sigmod::MapTrainer*>(modified())->setScript(script);
+    qobject_cast<MapTrainer*>(modified())->setScript(script);
 }
 
-void Sigmodr::Widgets::MapTrainerUI::on_varLeadTeamMember_added(QListWidgetItem* item)
+void MapTrainerUI::on_varLeadTeamMember_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainer*>(modified())->setLeadTeamMember(item->data(Qt::UserRole).toInt(), true);
+    qobject_cast<MapTrainer*>(modified())->setLeadTeamMember(item->data(Qt::UserRole).toInt(), true);
     setGui();
 }
 
-void Sigmodr::Widgets::MapTrainerUI::on_varLeadTeamMember_removed(QListWidgetItem* item)
+void MapTrainerUI::on_varLeadTeamMember_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::MapTrainer*>(modified())->setLeadTeamMember(item->data(Qt::UserRole).toInt(), false);
+    qobject_cast<MapTrainer*>(modified())->setLeadTeamMember(item->data(Qt::UserRole).toInt(), false);
     setGui();
 }
diff --git a/sigmodr/widgets/MapUI.cpp b/sigmodr/widgets/MapUI.cpp
index 21b51317..799c4da8 100644
--- a/sigmodr/widgets/MapUI.cpp
+++ b/sigmodr/widgets/MapUI.cpp
@@ -27,54 +27,57 @@
 
 // FIXME: Update map editing to new collage map
 
-Sigmodr::Widgets::MapUI::MapUI(Sigmod::Map* map, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MapUI::MapUI(Map* map, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(map, new Sigmod::Map(*map));
+    setObjects(map, new Map(*map));
     varMap->setMap(map);
     connect(varMap, SIGNAL(changed()), this, SIGNAL(changed()));
 }
 
-Sigmodr::Widgets::MapUI::~MapUI()
+MapUI::~MapUI()
 {
 }
 
-void Sigmodr::Widgets::MapUI::initGui()
+void MapUI::initGui()
 {
-    varType->addItem(Sigmod::Map::TypeStr[Sigmod::Map::Outdoor], QVariant::fromValue(Sigmod::Map::Outdoor));
-    varType->addItem(Sigmod::Map::TypeStr[Sigmod::Map::Dungeon], QVariant::fromValue(Sigmod::Map::Dungeon));
-    varType->addItem(Sigmod::Map::TypeStr[Sigmod::Map::Building], QVariant::fromValue(Sigmod::Map::Building));
+    varType->addItem(Map::TypeStr[Map::Outdoor], QVariant::fromValue(Map::Outdoor));
+    varType->addItem(Map::TypeStr[Map::Dungeon], QVariant::fromValue(Map::Dungeon));
+    varType->addItem(Map::TypeStr[Map::Building], QVariant::fromValue(Map::Building));
 }
 
-void Sigmodr::Widgets::MapUI::setGui()
+void MapUI::setGui()
 {
-    varName->setText(qobject_cast<Sigmod::Map*>(modified())->name());
-    varType->setCurrentIndex(qobject_cast<Sigmod::Map*>(modified())->type());
+    varName->setText(qobject_cast<Map*>(modified())->name());
+    varType->setCurrentIndex(qobject_cast<Map*>(modified())->type());
     varMap->reset();
 }
 
-void Sigmodr::Widgets::MapUI::apply()
+void MapUI::apply()
 {
-    *qobject_cast<Sigmod::Map*>(original()) = *qobject_cast<Sigmod::Map*>(modified());
+    *qobject_cast<Map*>(original()) = *qobject_cast<Map*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapUI::discard()
+void MapUI::discard()
 {
-    *qobject_cast<Sigmod::Map*>(modified()) = *qobject_cast<Sigmod::Map*>(original());
+    *qobject_cast<Map*>(modified()) = *qobject_cast<Map*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapUI::on_varName_textChanged(const QString& name)
+void MapUI::on_varName_textChanged(const QString& name)
 {
     const int cursor = varName->cursorPosition();
-    qobject_cast<Sigmod::Map*>(modified())->setName(name);
+    qobject_cast<Map*>(modified())->setName(name);
     varName->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::MapUI::on_varType_activated(const int type)
+void MapUI::on_varType_activated(const int type)
 {
-    qobject_cast<Sigmod::Map*>(modified())->setType(varType->itemData(type).value<Sigmod::Map::Type>());
+    qobject_cast<Map*>(modified())->setType(varType->itemData(type).value<Map::Type>());
 }
diff --git a/sigmodr/widgets/MapWarpUI.cpp b/sigmodr/widgets/MapWarpUI.cpp
index fd4ebc5d..008484af 100644
--- a/sigmodr/widgets/MapWarpUI.cpp
+++ b/sigmodr/widgets/MapWarpUI.cpp
@@ -23,100 +23,104 @@
 #include <sigmod/Map.h>
 #include <sigmod/MapWarp.h>
 
-Sigmodr::Widgets::MapWarpUI::MapWarpUI(Sigmod::MapWarp* warp, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MapWarpUI::MapWarpUI(MapWarp* warp, QWidget* parent) :
         ObjectUI(parent),
         m_lastMap(-1)
 {
     setupUi(this);
-    setObjects(warp, new Sigmod::MapWarp(*warp));
+    setObjects(warp, new MapWarp(*warp));
 }
 
-Sigmodr::Widgets::MapWarpUI::~MapWarpUI()
+MapWarpUI::~MapWarpUI()
 {
 }
 
-void Sigmodr::Widgets::MapWarpUI::initGui()
+void MapWarpUI::initGui()
 {
-    varType->addItem(Sigmod::MapWarp::TypeStr[Sigmod::MapWarp::Door], QVariant::fromValue(Sigmod::MapWarp::Door));
-    varType->addItem(Sigmod::MapWarp::TypeStr[Sigmod::MapWarp::Warp], QVariant::fromValue(Sigmod::MapWarp::Warp));
-    varType->addItem(Sigmod::MapWarp::TypeStr[Sigmod::MapWarp::Hole], QVariant::fromValue(Sigmod::MapWarp::Hole));
-    varType->addItem(Sigmod::MapWarp::TypeStr[Sigmod::MapWarp::Boundary], QVariant::fromValue(Sigmod::MapWarp::Boundary));
+    varType->addItem(MapWarp::TypeStr[MapWarp::Door], QVariant::fromValue(MapWarp::Door));
+    varType->addItem(MapWarp::TypeStr[MapWarp::Warp], QVariant::fromValue(MapWarp::Warp));
+    varType->addItem(MapWarp::TypeStr[MapWarp::Hole], QVariant::fromValue(MapWarp::Hole));
+    varType->addItem(MapWarp::TypeStr[MapWarp::Boundary], QVariant::fromValue(MapWarp::Boundary));
 }
 
-void Sigmodr::Widgets::MapWarpUI::refreshGui()
+void MapWarpUI::refreshGui()
 {
     const bool blocked = varToMap->blockSignals(true);
     varToMap->clear();
     for (int i = 0; i < game()->mapCount(); ++i)
     {
-        const Sigmod::Map* map = game()->map(i);
+        const Map* map = game()->map(i);
         varToMap->addItem(map->name(), map->id());
     }
     varToMap->blockSignals(blocked);
 }
 
-void Sigmodr::Widgets::MapWarpUI::setGui()
+void MapWarpUI::setGui()
 {
-    const bool resetWarps = (qobject_cast<Sigmod::MapWarp*>(modified())->toMap() != m_lastMap);
-    varName->setText(qobject_cast<Sigmod::MapWarp*>(modified())->name());
-    varType->setCurrentIndex(qobject_cast<Sigmod::MapWarp*>(modified())->type());
-    varToMap->setCurrentIndex(varToMap->findData(qobject_cast<Sigmod::MapWarp*>(modified())->toMap()));
-    m_lastMap = qobject_cast<Sigmod::MapWarp*>(modified())->toMap();
+    const bool resetWarps = (qobject_cast<MapWarp*>(modified())->toMap() != m_lastMap);
+    varName->setText(qobject_cast<MapWarp*>(modified())->name());
+    varType->setCurrentIndex(qobject_cast<MapWarp*>(modified())->type());
+    varToMap->setCurrentIndex(varToMap->findData(qobject_cast<MapWarp*>(modified())->toMap()));
+    m_lastMap = qobject_cast<MapWarp*>(modified())->toMap();
     if (resetWarps)
     {
         const bool blocked = varToWarp->blockSignals(true);
         varToWarp->clear();
-        const Sigmod::Map* map = game()->mapById(qobject_cast<Sigmod::MapWarp*>(modified())->toMap());
+        const Map* map = game()->mapById(qobject_cast<MapWarp*>(modified())->toMap());
         if (map)
         {
             for (int i = 0; i < map->warpCount(); ++i)
             {
-                const Sigmod::MapWarp* warp = map->warp(i);
+                const MapWarp* warp = map->warp(i);
                 varToWarp->addItem(warp->name(), warp->id());
             }
         }
         varToWarp->blockSignals(blocked);
     }
-    varToWarp->setCurrentIndex(varToMap->findData(qobject_cast<Sigmod::MapWarp*>(modified())->toWarp()));
-    varScript->setValue(qobject_cast<Sigmod::MapWarp*>(modified())->script());
+    varToWarp->setCurrentIndex(varToMap->findData(qobject_cast<MapWarp*>(modified())->toWarp()));
+    varScript->setValue(qobject_cast<MapWarp*>(modified())->script());
 }
 
-void Sigmodr::Widgets::MapWarpUI::apply()
+void MapWarpUI::apply()
 {
-    *qobject_cast<Sigmod::MapWarp*>(original()) = *qobject_cast<Sigmod::MapWarp*>(modified());
+    *qobject_cast<MapWarp*>(original()) = *qobject_cast<MapWarp*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapWarpUI::discard()
+void MapWarpUI::discard()
 {
-    *qobject_cast<Sigmod::MapWarp*>(modified()) = *qobject_cast<Sigmod::MapWarp*>(original());
+    *qobject_cast<MapWarp*>(modified()) = *qobject_cast<MapWarp*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapWarpUI::on_varName_textChanged(const QString& name)
+void MapWarpUI::on_varName_textChanged(const QString& name)
 {
     const int cursor = varName->cursorPosition();
-    qobject_cast<Sigmod::MapWarp*>(modified())->setName(name);
+    qobject_cast<MapWarp*>(modified())->setName(name);
     varName->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::MapWarpUI::on_varType_activated(const int type)
+void MapWarpUI::on_varType_activated(const int type)
 {
-    qobject_cast<Sigmod::MapWarp*>(modified())->setType(varType->itemData(type).value<Sigmod::MapWarp::Type>());
+    qobject_cast<MapWarp*>(modified())->setType(varType->itemData(type).value<MapWarp::Type>());
 }
 
-void Sigmodr::Widgets::MapWarpUI::on_varToMap_activated(const int toMap)
+void MapWarpUI::on_varToMap_activated(const int toMap)
 {
-    qobject_cast<Sigmod::MapWarp*>(modified())->setToMap(toMap);
+    qobject_cast<MapWarp*>(modified())->setToMap(toMap);
 }
 
-void Sigmodr::Widgets::MapWarpUI::on_varToWarp_activated(const int toWarp)
+void MapWarpUI::on_varToWarp_activated(const int toWarp)
 {
-    qobject_cast<Sigmod::MapWarp*>(modified())->setToWarp(toWarp);
+    qobject_cast<MapWarp*>(modified())->setToWarp(toWarp);
 }
 
-void Sigmodr::Widgets::MapWarpUI::on_varScript_valueChanged(const Sigcore::Script& script)
+void MapWarpUI::on_varScript_valueChanged(const Script& script)
 {
-    qobject_cast<Sigmod::MapWarp*>(modified())->setScript(script);
+    qobject_cast<MapWarp*>(modified())->setScript(script);
 }
diff --git a/sigmodr/widgets/MapWildListEncounterUI.cpp b/sigmodr/widgets/MapWildListEncounterUI.cpp
index 8d1073fd..7f11edb3 100644
--- a/sigmodr/widgets/MapWildListEncounterUI.cpp
+++ b/sigmodr/widgets/MapWildListEncounterUI.cpp
@@ -32,13 +32,16 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::MapWildListEncounterUI::MapWildListEncounterUI(Sigmod::MapWildListEncounter* encounter, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MapWildListEncounterUI::MapWildListEncounterUI(MapWildListEncounter* encounter, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(encounter, new Sigmod::MapWildListEncounter(*encounter));
+    setObjects(encounter, new MapWildListEncounter(*encounter));
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::initGui()
+void MapWildListEncounterUI::initGui()
 {
     QFile file(":/gui/mapwildlistencounter.ui");
     file.open(QFile::ReadOnly);
@@ -52,7 +55,7 @@ void Sigmodr::Widgets::MapWildListEncounterUI::initGui()
     connect(ui_weight, SIGNAL(valueChanged(int)), this, SLOT(weightChanged(int)));
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::refreshGui()
+void MapWildListEncounterUI::refreshGui()
 {
     const bool blocked = ui_species->blockSignals(true);
     ui_species->clear();
@@ -62,37 +65,37 @@ void Sigmodr::Widgets::MapWildListEncounterUI::refreshGui()
     ui_level->setMaximum(game()->rules()->maxLevel());
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::setGui()
+void MapWildListEncounterUI::setGui()
 {
-    ui_species->setCurrentIndex(game()->speciesIndex(qobject_cast<Sigmod::MapWildListEncounter*>(modified())->species()));
-    ui_level->setValue(qobject_cast<Sigmod::MapWildListEncounter*>(modified())->level());
-    ui_weight->setValue(qobject_cast<Sigmod::MapWildListEncounter*>(modified())->weight());
+    ui_species->setCurrentIndex(game()->speciesIndex(qobject_cast<MapWildListEncounter*>(modified())->species()));
+    ui_level->setValue(qobject_cast<MapWildListEncounter*>(modified())->level());
+    ui_weight->setValue(qobject_cast<MapWildListEncounter*>(modified())->weight());
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::apply()
+void MapWildListEncounterUI::apply()
 {
-    *qobject_cast<Sigmod::MapWildListEncounter*>(original()) = *qobject_cast<Sigmod::MapWildListEncounter*>(modified());
+    *qobject_cast<MapWildListEncounter*>(original()) = *qobject_cast<MapWildListEncounter*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::discard()
+void MapWildListEncounterUI::discard()
 {
-    *qobject_cast<Sigmod::MapWildListEncounter*>(modified()) = *qobject_cast<Sigmod::MapWildListEncounter*>(original());
+    *qobject_cast<MapWildListEncounter*>(modified()) = *qobject_cast<MapWildListEncounter*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::speciesChanged(const int species)
+void MapWildListEncounterUI::speciesChanged(const int species)
 {
-    qobject_cast<Sigmod::MapWildListEncounter*>(modified())->setSpecies(game()->species(species)->id());
+    qobject_cast<MapWildListEncounter*>(modified())->setSpecies(game()->species(species)->id());
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::levelChanged(const int level)
+void MapWildListEncounterUI::levelChanged(const int level)
 {
-    qobject_cast<Sigmod::MapWildListEncounter*>(modified())->setLevel(level);
+    qobject_cast<MapWildListEncounter*>(modified())->setLevel(level);
 }
 
-void Sigmodr::Widgets::MapWildListEncounterUI::weightChanged(const int weight)
+void MapWildListEncounterUI::weightChanged(const int weight)
 {
-    qobject_cast<Sigmod::MapWildListEncounter*>(modified())->setWeight(weight);
+    qobject_cast<MapWildListEncounter*>(modified())->setWeight(weight);
 }
diff --git a/sigmodr/widgets/MapWildListUI.cpp b/sigmodr/widgets/MapWildListUI.cpp
index 376412b3..11a48151 100644
--- a/sigmodr/widgets/MapWildListUI.cpp
+++ b/sigmodr/widgets/MapWildListUI.cpp
@@ -28,13 +28,16 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::MapWildListUI::MapWildListUI(Sigmod::MapWildList* wildList, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MapWildListUI::MapWildListUI(MapWildList* wildList, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(wildList, new Sigmod::MapWildList(*wildList));
+    setObjects(wildList, new MapWildList(*wildList));
 }
 
-void Sigmodr::Widgets::MapWildListUI::initGui()
+void MapWildListUI::initGui()
 {
     QFile file(":/gui/mapwildlist.ui");
     file.open(QFile::ReadOnly);
@@ -44,27 +47,27 @@ void Sigmodr::Widgets::MapWildListUI::initGui()
     connect(ui_name, SIGNAL(textChanged(QString)), this, SLOT(nameChanged(QString)));
 }
 
-void Sigmodr::Widgets::MapWildListUI::setGui()
+void MapWildListUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::MapWildList*>(modified())->name());
+    ui_name->setText(qobject_cast<MapWildList*>(modified())->name());
 }
 
-void Sigmodr::Widgets::MapWildListUI::apply()
+void MapWildListUI::apply()
 {
-    *qobject_cast<Sigmod::MapWildList*>(original()) = *qobject_cast<Sigmod::MapWildList*>(modified());
+    *qobject_cast<MapWildList*>(original()) = *qobject_cast<MapWildList*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapWildListUI::discard()
+void MapWildListUI::discard()
 {
-    *qobject_cast<Sigmod::MapWildList*>(modified()) = *qobject_cast<Sigmod::MapWildList*>(original());
+    *qobject_cast<MapWildList*>(modified()) = *qobject_cast<MapWildList*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MapWildListUI::nameChanged(const QString& name)
+void MapWildListUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::MapWildList*>(modified())->setName(name);
+    qobject_cast<MapWildList*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
diff --git a/sigmodr/widgets/MoveUI.cpp b/sigmodr/widgets/MoveUI.cpp
index f47ac965..4b0fb72d 100644
--- a/sigmodr/widgets/MoveUI.cpp
+++ b/sigmodr/widgets/MoveUI.cpp
@@ -23,112 +23,116 @@
 #include <sigmod/Move.h>
 #include <sigmod/Type.h>
 
-Sigmodr::Widgets::MoveUI::MoveUI(Sigmod::Move* move, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+MoveUI::MoveUI(Move* move, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(move, new Sigmod::Move(*move));
+    setObjects(move, new Move(*move));
 }
 
-Sigmodr::Widgets::MoveUI::~MoveUI()
+MoveUI::~MoveUI()
 {
 }
 
-void Sigmodr::Widgets::MoveUI::refreshGui()
+void MoveUI::refreshGui()
 {
     const bool blocked = varType->blockSignals(true);
     varType->clear();
     for (int i = 0; i < game()->typeCount(); ++i)
     {
-        const Sigmod::Type* type = game()->type(i);
+        const Type* type = game()->type(i);
         varType->addItem(type->name(), type->id());
     }
     varType->blockSignals(blocked);
 }
 
-void Sigmodr::Widgets::MoveUI::setGui()
+void MoveUI::setGui()
 {
-    varName->setText(qobject_cast<Sigmod::Move*>(modified())->name());
-    varPriority->setValue(qobject_cast<Sigmod::Move*>(modified())->priority());
-    varAccuracy->setValue(qobject_cast<Sigmod::Move*>(modified())->accuracy());
-    varPower->setValue(qobject_cast<Sigmod::Move*>(modified())->power());
-    varType->setCurrentIndex(varType->findData(qobject_cast<Sigmod::Move*>(modified())->type()));
-    varPowerPoints->setValue(qobject_cast<Sigmod::Move*>(modified())->powerPoints());
-    varSpecial->setChecked(qobject_cast<Sigmod::Move*>(modified())->special() ? Qt::Checked : Qt::Unchecked);
-    varDescription->setText(qobject_cast<Sigmod::Move*>(modified())->description());
-    varBattleScript->setValue(qobject_cast<Sigmod::Move*>(modified())->battleScript());
-    varWorldScript->setValue(qobject_cast<Sigmod::Move*>(modified())->worldScript());
-    varPriorityScript->setValue(qobject_cast<Sigmod::Move*>(modified())->priorityScript());
+    varName->setText(qobject_cast<Move*>(modified())->name());
+    varPriority->setValue(qobject_cast<Move*>(modified())->priority());
+    varAccuracy->setValue(qobject_cast<Move*>(modified())->accuracy());
+    varPower->setValue(qobject_cast<Move*>(modified())->power());
+    varType->setCurrentIndex(varType->findData(qobject_cast<Move*>(modified())->type()));
+    varPowerPoints->setValue(qobject_cast<Move*>(modified())->powerPoints());
+    varSpecial->setChecked(qobject_cast<Move*>(modified())->special() ? Qt::Checked : Qt::Unchecked);
+    varDescription->setText(qobject_cast<Move*>(modified())->description());
+    varBattleScript->setValue(qobject_cast<Move*>(modified())->battleScript());
+    varWorldScript->setValue(qobject_cast<Move*>(modified())->worldScript());
+    varPriorityScript->setValue(qobject_cast<Move*>(modified())->priorityScript());
 }
 
-void Sigmodr::Widgets::MoveUI::apply()
+void MoveUI::apply()
 {
-    *qobject_cast<Sigmod::Move*>(original()) = *qobject_cast<Sigmod::Move*>(modified());
+    *qobject_cast<Move*>(original()) = *qobject_cast<Move*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MoveUI::discard()
+void MoveUI::discard()
 {
-    *qobject_cast<Sigmod::Move*>(modified()) = *qobject_cast<Sigmod::Move*>(original());
+    *qobject_cast<Move*>(modified()) = *qobject_cast<Move*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::MoveUI::on_varName_textChanged(const QString& name)
+void MoveUI::on_varName_textChanged(const QString& name)
 {
     const int cursor = varName->cursorPosition();
-    qobject_cast<Sigmod::Move*>(modified())->setName(name);
+    qobject_cast<Move*>(modified())->setName(name);
     varName->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varPriority_valueChanged(const int priority)
+void MoveUI::on_varPriority_valueChanged(const int priority)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setPriority(priority);
+    qobject_cast<Move*>(modified())->setPriority(priority);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varAccuracy_valueChanged(const Sigcore::Fraction& accuracy)
+void MoveUI::on_varAccuracy_valueChanged(const Fraction& accuracy)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setAccuracy(accuracy);
+    qobject_cast<Move*>(modified())->setAccuracy(accuracy);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varPower_valueChanged(const int power)
+void MoveUI::on_varPower_valueChanged(const int power)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setPower(power);
+    qobject_cast<Move*>(modified())->setPower(power);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varType_activated(const int type)
+void MoveUI::on_varType_activated(const int type)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setType(varType->itemData(type).toInt());
+    qobject_cast<Move*>(modified())->setType(varType->itemData(type).toInt());
 }
 
-void Sigmodr::Widgets::MoveUI::on_varPowerPoints_valueChanged(const int powerPoints)
+void MoveUI::on_varPowerPoints_valueChanged(const int powerPoints)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setPowerPoints(powerPoints);
+    qobject_cast<Move*>(modified())->setPowerPoints(powerPoints);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varSpecial_toggled(const bool special)
+void MoveUI::on_varSpecial_toggled(const bool special)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setSpecial(special);
+    qobject_cast<Move*>(modified())->setSpecial(special);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varDescription_textChanged(const QString& description)
+void MoveUI::on_varDescription_textChanged(const QString& description)
 {
     const int cursor = varDescription->cursorPosition();
-    qobject_cast<Sigmod::Move*>(modified())->setDescription(description);
+    qobject_cast<Move*>(modified())->setDescription(description);
     varDescription->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varBattleScript_valueChanged(const Sigcore::Script& battleScript)
+void MoveUI::on_varBattleScript_valueChanged(const Script& battleScript)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setBattleScript(battleScript);
+    qobject_cast<Move*>(modified())->setBattleScript(battleScript);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varWorldScript_valueChanged(const Sigcore::Script& worldScript)
+void MoveUI::on_varWorldScript_valueChanged(const Script& worldScript)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setWorldScript(worldScript);
+    qobject_cast<Move*>(modified())->setWorldScript(worldScript);
 }
 
-void Sigmodr::Widgets::MoveUI::on_varPriorityScript_valueChanged(const Sigcore::Script& priorityScript)
+void MoveUI::on_varPriorityScript_valueChanged(const Script& priorityScript)
 {
-    qobject_cast<Sigmod::Move*>(modified())->setPriorityScript(priorityScript);
+    qobject_cast<Move*>(modified())->setPriorityScript(priorityScript);
 }
diff --git a/sigmodr/widgets/NatureUI.cpp b/sigmodr/widgets/NatureUI.cpp
index 76af2e40..54e6e3de 100644
--- a/sigmodr/widgets/NatureUI.cpp
+++ b/sigmodr/widgets/NatureUI.cpp
@@ -26,125 +26,129 @@
 // Qt includes
 #include <QtGui/QHeaderView>
 
-Sigmodr::Widgets::NatureUI::NatureUI(Sigmod::Nature* nature, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+NatureUI::NatureUI(Nature* nature, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(nature, new Sigmod::Nature(*nature));
+    setObjects(nature, new Nature(*nature));
 }
 
-Sigmodr::Widgets::NatureUI::~NatureUI()
+NatureUI::~NatureUI()
 {
 }
 
-void Sigmodr::Widgets::NatureUI::initGui()
+void NatureUI::initGui()
 {
     varStat->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
 }
 
-void Sigmodr::Widgets::NatureUI::refreshGui()
+void NatureUI::refreshGui()
 {
     const bool isSplit = game()->rules()->specialSplit();
     varStat->clear();
-    varStat->setRowCount((isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1);
-    varStat->setVerticalHeaderLabels((isSplit ? Sigmod::StatGSCStr : Sigmod::StatRBYStr).mid(Sigmod::ST_Attack, (isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1));
+    varStat->setRowCount((isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1);
+    varStat->setVerticalHeaderLabels((isSplit ? StatGSCStr : StatRBYStr).mid(ST_Attack, (isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1));
     varStat->setColumnCount(1);
     varStat->setHorizontalHeaderLabels(QStringList() << "Multiplier");
-    varStat->verticalHeaderItem(Sigmod::ST_Attack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Attack));
-    varStat->verticalHeaderItem(Sigmod::ST_Defense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Defense));
-    varStat->verticalHeaderItem(Sigmod::ST_Speed - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Speed));
+    varStat->verticalHeaderItem(ST_Attack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Attack));
+    varStat->verticalHeaderItem(ST_Defense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Defense));
+    varStat->verticalHeaderItem(ST_Speed - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Speed));
     if (isSplit)
     {
-        varStat->verticalHeaderItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialAttack));
-        varStat->verticalHeaderItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialDefense));
+        varStat->verticalHeaderItem(ST_SpecialAttack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialAttack));
+        varStat->verticalHeaderItem(ST_SpecialDefense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialDefense));
     }
     else
-        varStat->verticalHeaderItem(Sigmod::ST_Special - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Special));
-    varStat->setItem(Sigmod::ST_Attack - Sigmod::ST_Attack, 0, new QTableWidgetItem);
-    varStat->setItem(Sigmod::ST_Defense- Sigmod::ST_Attack, 0, new QTableWidgetItem);
-    varStat->setItem(Sigmod::ST_Speed - Sigmod::ST_Attack, 0, new QTableWidgetItem);
+        varStat->verticalHeaderItem(ST_Special - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Special));
+    varStat->setItem(ST_Attack - ST_Attack, 0, new QTableWidgetItem);
+    varStat->setItem(ST_Defense- ST_Attack, 0, new QTableWidgetItem);
+    varStat->setItem(ST_Speed - ST_Attack, 0, new QTableWidgetItem);
     if (isSplit)
     {
-        varStat->setItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0, new QTableWidgetItem);
-        varStat->setItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0, new QTableWidgetItem);
+        varStat->setItem(ST_SpecialAttack - ST_Attack, 0, new QTableWidgetItem);
+        varStat->setItem(ST_SpecialDefense - ST_Attack, 0, new QTableWidgetItem);
     }
     else
-        varStat->setItem(Sigmod::ST_Special - Sigmod::ST_Attack, 0, new QTableWidgetItem);
+        varStat->setItem(ST_Special - ST_Attack, 0, new QTableWidgetItem);
     QTableWidgetItem* item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    varStat->setItem(Sigmod::ST_Attack - Sigmod::ST_Attack, 0, item);
+    varStat->setItem(ST_Attack - ST_Attack, 0, item);
     varStat->setCurrentItem(item);
     item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    varStat->setItem(Sigmod::ST_Defense- Sigmod::ST_Attack, 0, item);
+    varStat->setItem(ST_Defense- ST_Attack, 0, item);
     item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    varStat->setItem(Sigmod::ST_Speed - Sigmod::ST_Attack, 0, item);
+    varStat->setItem(ST_Speed - ST_Attack, 0, item);
     if (isSplit)
     {
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varStat->setItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0, item);
+        varStat->setItem(ST_SpecialAttack - ST_Attack, 0, item);
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varStat->setItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0, item);
+        varStat->setItem(ST_SpecialDefense - ST_Attack, 0, item);
     }
     else
     {
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varStat->setItem(Sigmod::ST_Special - Sigmod::ST_Attack, 0, item);
+        varStat->setItem(ST_Special - ST_Attack, 0, item);
     }
 }
 
-void Sigmodr::Widgets::NatureUI::setGui()
+void NatureUI::setGui()
 {
-    varName->setText(qobject_cast<Sigmod::Nature*>(modified())->name());
-    varStat->item(Sigmod::ST_Attack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Nature*>(modified())->stat(Sigmod::ST_Attack), 'g', 7));
-    varStat->item(Sigmod::ST_Defense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Nature*>(modified())->stat(Sigmod::ST_Defense), 'g', 7));
-    varStat->item(Sigmod::ST_Speed - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Nature*>(modified())->stat(Sigmod::ST_Speed), 'g', 7));
+    varName->setText(qobject_cast<Nature*>(modified())->name());
+    varStat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Attack), 'g', 7));
+    varStat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Defense), 'g', 7));
+    varStat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Speed), 'g', 7));
     if (game()->rules()->specialSplit())
     {
-        varStat->item(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Nature*>(modified())->stat(Sigmod::ST_SpecialAttack), 'g', 7));
-        varStat->item(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Nature*>(modified())->stat(Sigmod::ST_SpecialDefense), 'g', 7));
+        varStat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_SpecialAttack), 'g', 7));
+        varStat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_SpecialDefense), 'g', 7));
     }
     else
-        varStat->item(Sigmod::ST_Special - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Nature*>(modified())->stat(Sigmod::ST_Special), 'g', 7));
-    varStatMultiplier->setValue(qobject_cast<Sigmod::Nature*>(modified())->stat(varStat->verticalHeaderItem(varStat->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>()));
-    varWeight->setValue(qobject_cast<Sigmod::Nature*>(modified())->weight());
+        varStat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Nature*>(modified())->stat(ST_Special), 'g', 7));
+    varStatMultiplier->setValue(qobject_cast<Nature*>(modified())->stat(varStat->verticalHeaderItem(varStat->currentRow())->data(Qt::UserRole).value<Stat>()));
+    varWeight->setValue(qobject_cast<Nature*>(modified())->weight());
 }
 
-void Sigmodr::Widgets::NatureUI::apply()
+void NatureUI::apply()
 {
-    *qobject_cast<Sigmod::Nature*>(original()) = *qobject_cast<Sigmod::Nature*>(modified());
+    *qobject_cast<Nature*>(original()) = *qobject_cast<Nature*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::NatureUI::discard()
+void NatureUI::discard()
 {
-    *qobject_cast<Sigmod::Nature*>(modified()) = *qobject_cast<Sigmod::Nature*>(original());
+    *qobject_cast<Nature*>(modified()) = *qobject_cast<Nature*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::NatureUI::on_varName_textChanged(const QString& name)
+void NatureUI::on_varName_textChanged(const QString& name)
 {
     const int cursor = varName->cursorPosition();
-    qobject_cast<Sigmod::Nature*>(modified())->setName(name);
+    qobject_cast<Nature*>(modified())->setName(name);
     varName->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::NatureUI::on_varStat_currentCellChanged(const int row)
+void NatureUI::on_varStat_currentCellChanged(const int row)
 {
-    varStatMultiplier->setValue(qobject_cast<Sigmod::Nature*>(modified())->stat(varStat->verticalHeaderItem(row)->data(Qt::UserRole).value<Sigmod::Stat>()));
+    varStatMultiplier->setValue(qobject_cast<Nature*>(modified())->stat(varStat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void Sigmodr::Widgets::NatureUI::on_varStatMultiplier_valueChanged(const Sigcore::Fraction& multiplier)
+void NatureUI::on_varStatMultiplier_valueChanged(const Fraction& multiplier)
 {
-    qobject_cast<Sigmod::Nature*>(modified())->setStat(varStat->verticalHeaderItem(varStat->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>(), multiplier);
+    qobject_cast<Nature*>(modified())->setStat(varStat->verticalHeaderItem(varStat->currentRow())->data(Qt::UserRole).value<Stat>(), multiplier);
 }
 
-void Sigmodr::Widgets::NatureUI::on_varWeight_valueChanged(const int weight)
+void NatureUI::on_varWeight_valueChanged(const int weight)
 {
-    qobject_cast<Sigmod::Nature*>(modified())->setWeight(weight);
+    qobject_cast<Nature*>(modified())->setWeight(weight);
 }
diff --git a/sigmodr/widgets/ObjectUI.cpp b/sigmodr/widgets/ObjectUI.cpp
index 21e1aa6f..59be2321 100644
--- a/sigmodr/widgets/ObjectUI.cpp
+++ b/sigmodr/widgets/ObjectUI.cpp
@@ -31,7 +31,10 @@
 #include <KMenu>
 #include <KMessageBox>
 
-Sigmodr::Widgets::ObjectUI::ObjectUI(QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+ObjectUI::ObjectUI(QWidget* parent) :
         QWidget(parent),
         m_changed(false),
         m_validator(NULL),
@@ -43,48 +46,48 @@ Sigmodr::Widgets::ObjectUI::ObjectUI(QWidget* parent) :
     connect(this, SIGNAL(customContextMenuRequested(QPoint)), SLOT(contextMenu(QPoint)));
 }
 
-Sigmodr::Widgets::ObjectUI::~ObjectUI()
+ObjectUI::~ObjectUI()
 {
     delete m_object_mod;
 }
 
-void Sigmodr::Widgets::ObjectUI::reload()
+void ObjectUI::reload()
 {
     refreshGui();
     setGui();
 }
 
-bool Sigmodr::Widgets::ObjectUI::isChanged() const
+bool ObjectUI::isChanged() const
 {
     return m_changed;
 }
 
-const Sigmod::Game* Sigmodr::Widgets::ObjectUI::game() const
+const Game* ObjectUI::game() const
 {
     return m_object->game();
 }
 
-const Sigmod::Object* Sigmodr::Widgets::ObjectUI::original() const
+const Object* ObjectUI::original() const
 {
     return m_object;
 }
 
-Sigmod::Object* Sigmodr::Widgets::ObjectUI::original()
+Object* ObjectUI::original()
 {
     return m_object;
 }
 
-const Sigmod::Object* Sigmodr::Widgets::ObjectUI::modified() const
+const Object* ObjectUI::modified() const
 {
     return m_object_mod;
 }
 
-Sigmod::Object* Sigmodr::Widgets::ObjectUI::modified()
+Object* ObjectUI::modified()
 {
     return m_object_mod;
 }
 
-void Sigmodr::Widgets::ObjectUI::setObjects(Sigmod::Object* original, Sigmod::Object* modified)
+void ObjectUI::setObjects(Object* original, Object* modified)
 {
     m_object = original;
     m_object_mod = modified;
@@ -99,33 +102,33 @@ void Sigmodr::Widgets::ObjectUI::setObjects(Sigmod::Object* original, Sigmod::Ob
     init();
 }
 
-void Sigmodr::Widgets::ObjectUI::init()
+void ObjectUI::init()
 {
     initGui();
     reload();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::ObjectUI::setChanged(const bool changed)
+void ObjectUI::setChanged(const bool changed)
 {
     m_changed = changed;
 }
 
-void Sigmodr::Widgets::ObjectUI::errorMessage(const QString& message)
+void ObjectUI::errorMessage(const QString& message)
 {
     KMessageBox::error(this, message, "Error");
 }
 
-void Sigmodr::Widgets::ObjectUI::warningMessage(const QString& message)
+void ObjectUI::warningMessage(const QString& message)
 {
     KMessageBox::warningContinueCancel(this, message, "Warning");
 }
 
-void Sigmodr::Widgets::ObjectUI::refreshGui()
+void ObjectUI::refreshGui()
 {
 }
 
-void Sigmodr::Widgets::ObjectUI::contextMenu(const QPoint& pos)
+void ObjectUI::contextMenu(const QPoint& pos)
 {
     KMenu* menu = new KMenu;
     menu->addAction("&Apply", this, SLOT(apply()));
@@ -138,7 +141,7 @@ void Sigmodr::Widgets::ObjectUI::contextMenu(const QPoint& pos)
     menu->popup(mapToGlobal(pos));
 }
 
-void Sigmodr::Widgets::ObjectUI::validate()
+void ObjectUI::validate()
 {
     if (m_changed)
         apply();
diff --git a/sigmodr/widgets/RulesUI.cpp b/sigmodr/widgets/RulesUI.cpp
index 9ad91860..2260813c 100644
--- a/sigmodr/widgets/RulesUI.cpp
+++ b/sigmodr/widgets/RulesUI.cpp
@@ -21,177 +21,180 @@
 // Sigmod includes
 #include <sigmod/Rules.h>
 
-Sigmodr::Widgets::RulesUI::RulesUI(Sigmod::Rules* rules, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+RulesUI::RulesUI(Rules* rules, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(rules, new Sigmod::Rules(*rules));
-}
-
-Sigmodr::Widgets::RulesUI::~RulesUI()
-{
-}
-
-void Sigmodr::Widgets::RulesUI::setGui()
-{
-    varGenders->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->genderAllowed() ? Qt::Checked : Qt::Unchecked);
-    varBreeding->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->breedingAllowed() ? Qt::Checked : Qt::Unchecked);
-    varBreeding->setEnabled(qobject_cast<Sigmod::Rules*>(modified())->genderAllowed());
-    varCriticalDomains->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->criticalDomains() ? Qt::Checked : Qt::Unchecked);
-    varSwitchStyle->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->allowSwitchStyle() ? Qt::Checked : Qt::Unchecked);
-    varUseATB->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->useATB() ? Qt::Checked : Qt::Unchecked);
-    varSplitSpecial->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->specialSplit() ? Qt::Checked : Qt::Unchecked);
-    varSplitSpecialDV->setEnabled(qobject_cast<Sigmod::Rules*>(modified())->specialSplit());
-    varSplitSpecialDV->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->specialDVSplit() ? Qt::Checked : Qt::Unchecked);
-    varEffortValues->setCheckState(qobject_cast<Sigmod::Rules*>(modified())->effortValuesAllowed() ? Qt::Checked : Qt::Unchecked);
-    varMaxEV->setEnabled(qobject_cast<Sigmod::Rules*>(modified())->effortValuesAllowed());
-    varMaxEV->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxTotalEV());
-    varMaxEVPerStat->setEnabled((0 < qobject_cast<Sigmod::Rules*>(modified())->maxTotalEV()) && qobject_cast<Sigmod::Rules*>(modified())->effortValuesAllowed());
-    varMaxEVPerStat->setMaximum(qobject_cast<Sigmod::Rules*>(modified())->maxTotalEV());
-    varMaxEVPerStat->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxEVPerStat());
-    varBoxes->setValue(qobject_cast<Sigmod::Rules*>(modified())->numBoxes());
-    varBoxSize->setEnabled(0 < qobject_cast<Sigmod::Rules*>(modified())->numBoxes());
-    varBoxSize->setValue(qobject_cast<Sigmod::Rules*>(modified())->boxSize());
-    varMaxParty->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxParty());
-    varMaxFight->setMaximum(qobject_cast<Sigmod::Rules*>(modified())->maxParty());
-    varMaxFight->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxFight());
-    varMaxPlayers->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxPlayers());
-    varMaxMoves->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxMoves());
-    varMaxLevel->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxLevel());
-    varMaxHeldItems->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxHeldItems());
-    varMaxNatures->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxNatures());
-    varMaxAbilities->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxAbilities());
-    varMaxStages->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxStages());
-    varMaxMoney->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxMoney());
-    varMaxTotalWeight->setValue(qobject_cast<Sigmod::Rules*>(modified())->maxTotalWeight());
-}
-
-void Sigmodr::Widgets::RulesUI::apply()
-{
-    *qobject_cast<Sigmod::Rules*>(original()) = *qobject_cast<Sigmod::Rules*>(modified());
+    setObjects(rules, new Rules(*rules));
+}
+
+RulesUI::~RulesUI()
+{
+}
+
+void RulesUI::setGui()
+{
+    varGenders->setCheckState(qobject_cast<Rules*>(modified())->genderAllowed() ? Qt::Checked : Qt::Unchecked);
+    varBreeding->setCheckState(qobject_cast<Rules*>(modified())->breedingAllowed() ? Qt::Checked : Qt::Unchecked);
+    varBreeding->setEnabled(qobject_cast<Rules*>(modified())->genderAllowed());
+    varCriticalDomains->setCheckState(qobject_cast<Rules*>(modified())->criticalDomains() ? Qt::Checked : Qt::Unchecked);
+    varSwitchStyle->setCheckState(qobject_cast<Rules*>(modified())->allowSwitchStyle() ? Qt::Checked : Qt::Unchecked);
+    varUseATB->setCheckState(qobject_cast<Rules*>(modified())->useATB() ? Qt::Checked : Qt::Unchecked);
+    varSplitSpecial->setCheckState(qobject_cast<Rules*>(modified())->specialSplit() ? Qt::Checked : Qt::Unchecked);
+    varSplitSpecialDV->setEnabled(qobject_cast<Rules*>(modified())->specialSplit());
+    varSplitSpecialDV->setCheckState(qobject_cast<Rules*>(modified())->specialDVSplit() ? Qt::Checked : Qt::Unchecked);
+    varEffortValues->setCheckState(qobject_cast<Rules*>(modified())->effortValuesAllowed() ? Qt::Checked : Qt::Unchecked);
+    varMaxEV->setEnabled(qobject_cast<Rules*>(modified())->effortValuesAllowed());
+    varMaxEV->setValue(qobject_cast<Rules*>(modified())->maxTotalEV());
+    varMaxEVPerStat->setEnabled((0 < qobject_cast<Rules*>(modified())->maxTotalEV()) && qobject_cast<Rules*>(modified())->effortValuesAllowed());
+    varMaxEVPerStat->setMaximum(qobject_cast<Rules*>(modified())->maxTotalEV());
+    varMaxEVPerStat->setValue(qobject_cast<Rules*>(modified())->maxEVPerStat());
+    varBoxes->setValue(qobject_cast<Rules*>(modified())->numBoxes());
+    varBoxSize->setEnabled(0 < qobject_cast<Rules*>(modified())->numBoxes());
+    varBoxSize->setValue(qobject_cast<Rules*>(modified())->boxSize());
+    varMaxParty->setValue(qobject_cast<Rules*>(modified())->maxParty());
+    varMaxFight->setMaximum(qobject_cast<Rules*>(modified())->maxParty());
+    varMaxFight->setValue(qobject_cast<Rules*>(modified())->maxFight());
+    varMaxPlayers->setValue(qobject_cast<Rules*>(modified())->maxPlayers());
+    varMaxMoves->setValue(qobject_cast<Rules*>(modified())->maxMoves());
+    varMaxLevel->setValue(qobject_cast<Rules*>(modified())->maxLevel());
+    varMaxHeldItems->setValue(qobject_cast<Rules*>(modified())->maxHeldItems());
+    varMaxNatures->setValue(qobject_cast<Rules*>(modified())->maxNatures());
+    varMaxAbilities->setValue(qobject_cast<Rules*>(modified())->maxAbilities());
+    varMaxStages->setValue(qobject_cast<Rules*>(modified())->maxStages());
+    varMaxMoney->setValue(qobject_cast<Rules*>(modified())->maxMoney());
+    varMaxTotalWeight->setValue(qobject_cast<Rules*>(modified())->maxTotalWeight());
+}
+
+void RulesUI::apply()
+{
+    *qobject_cast<Rules*>(original()) = *qobject_cast<Rules*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::RulesUI::discard()
+void RulesUI::discard()
 {
-    *qobject_cast<Sigmod::Rules*>(modified()) = *qobject_cast<Sigmod::Rules*>(original());
+    *qobject_cast<Rules*>(modified()) = *qobject_cast<Rules*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::RulesUI::on_varGenders_toggled(const bool genders)
+void RulesUI::on_varGenders_toggled(const bool genders)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setGenderAllowed(genders);
+    qobject_cast<Rules*>(modified())->setGenderAllowed(genders);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varBreeding_toggled(const bool breeding)
+void RulesUI::on_varBreeding_toggled(const bool breeding)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setBreedingAllowed(breeding);
+    qobject_cast<Rules*>(modified())->setBreedingAllowed(breeding);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varCriticalDomains_toggled(const bool criticalDomains)
+void RulesUI::on_varCriticalDomains_toggled(const bool criticalDomains)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setCriticalDomains(criticalDomains);
+    qobject_cast<Rules*>(modified())->setCriticalDomains(criticalDomains);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varSwitchStyle_toggled(const bool switchStyle)
+void RulesUI::on_varSwitchStyle_toggled(const bool switchStyle)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setAllowSwitchStyle(switchStyle);
+    qobject_cast<Rules*>(modified())->setAllowSwitchStyle(switchStyle);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varUseATB_toggled(const bool useATB)
+void RulesUI::on_varUseATB_toggled(const bool useATB)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setUseATB(useATB);
+    qobject_cast<Rules*>(modified())->setUseATB(useATB);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varSplitSpecial_toggled(const bool splitSpecial)
+void RulesUI::on_varSplitSpecial_toggled(const bool splitSpecial)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setSpecialSplit(splitSpecial);
+    qobject_cast<Rules*>(modified())->setSpecialSplit(splitSpecial);
     if (!splitSpecial)
-        qobject_cast<Sigmod::Rules*>(modified())->setSpecialDVSplit(false);
+        qobject_cast<Rules*>(modified())->setSpecialDVSplit(false);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varSplitSpecialDV_toggled(const bool splitSpecialDV)
+void RulesUI::on_varSplitSpecialDV_toggled(const bool splitSpecialDV)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setSpecialDVSplit(splitSpecialDV);
+    qobject_cast<Rules*>(modified())->setSpecialDVSplit(splitSpecialDV);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varEffortValues_toggled(const bool effortValues)
+void RulesUI::on_varEffortValues_toggled(const bool effortValues)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setEffortValuesAllowed(effortValues);
+    qobject_cast<Rules*>(modified())->setEffortValuesAllowed(effortValues);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxEV_valueChanged(const int maxEV)
+void RulesUI::on_varMaxEV_valueChanged(const int maxEV)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxTotalEV(maxEV);
+    qobject_cast<Rules*>(modified())->setMaxTotalEV(maxEV);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxEVPerStat_valueChanged(const int maxEVPerStat)
+void RulesUI::on_varMaxEVPerStat_valueChanged(const int maxEVPerStat)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxEVPerStat(maxEVPerStat);
+    qobject_cast<Rules*>(modified())->setMaxEVPerStat(maxEVPerStat);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varBoxes_valueChanged(const int boxes)
+void RulesUI::on_varBoxes_valueChanged(const int boxes)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setNumBoxes(boxes);
+    qobject_cast<Rules*>(modified())->setNumBoxes(boxes);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varBoxSize_valueChanged(const int boxSize)
+void RulesUI::on_varBoxSize_valueChanged(const int boxSize)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setBoxSize(boxSize);
+    qobject_cast<Rules*>(modified())->setBoxSize(boxSize);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxParty_valueChanged(const int maxParty)
+void RulesUI::on_varMaxParty_valueChanged(const int maxParty)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxParty(maxParty);
+    qobject_cast<Rules*>(modified())->setMaxParty(maxParty);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxFight_valueChanged(const int maxFight)
+void RulesUI::on_varMaxFight_valueChanged(const int maxFight)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxFight(maxFight);
+    qobject_cast<Rules*>(modified())->setMaxFight(maxFight);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxPlayers_valueChanged(const int maxPlayers)
+void RulesUI::on_varMaxPlayers_valueChanged(const int maxPlayers)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxPlayers(maxPlayers);
+    qobject_cast<Rules*>(modified())->setMaxPlayers(maxPlayers);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxMoves_valueChanged(const int maxMoves)
+void RulesUI::on_varMaxMoves_valueChanged(const int maxMoves)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxMoves(maxMoves);
+    qobject_cast<Rules*>(modified())->setMaxMoves(maxMoves);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxLevel_valueChanged(const int maxLevel)
+void RulesUI::on_varMaxLevel_valueChanged(const int maxLevel)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxLevel(maxLevel);
+    qobject_cast<Rules*>(modified())->setMaxLevel(maxLevel);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxHeldItems_valueChanged(const int maxHeldItems)
+void RulesUI::on_varMaxHeldItems_valueChanged(const int maxHeldItems)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxHeldItems(maxHeldItems);
+    qobject_cast<Rules*>(modified())->setMaxHeldItems(maxHeldItems);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxNatures_valueChanged(const int maxNatures)
+void RulesUI::on_varMaxNatures_valueChanged(const int maxNatures)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxNatures(maxNatures);
+    qobject_cast<Rules*>(modified())->setMaxNatures(maxNatures);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxAbilities_valueChanged(const int maxAbilities)
+void RulesUI::on_varMaxAbilities_valueChanged(const int maxAbilities)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxAbilities(maxAbilities);
+    qobject_cast<Rules*>(modified())->setMaxAbilities(maxAbilities);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxStages_valueChanged(const int maxStages)
+void RulesUI::on_varMaxStages_valueChanged(const int maxStages)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxStages(maxStages);
+    qobject_cast<Rules*>(modified())->setMaxStages(maxStages);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxMoney_valueChanged(const int maxMoney)
+void RulesUI::on_varMaxMoney_valueChanged(const int maxMoney)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxMoney(maxMoney);
+    qobject_cast<Rules*>(modified())->setMaxMoney(maxMoney);
 }
 
-void Sigmodr::Widgets::RulesUI::on_varMaxTotalWeight_valueChanged(const int maxTotalWeight)
+void RulesUI::on_varMaxTotalWeight_valueChanged(const int maxTotalWeight)
 {
-    qobject_cast<Sigmod::Rules*>(modified())->setMaxTotalWeight(maxTotalWeight);
+    qobject_cast<Rules*>(modified())->setMaxTotalWeight(maxTotalWeight);
 }
diff --git a/sigmodr/widgets/ScriptWidget.cpp b/sigmodr/widgets/ScriptWidget.cpp
index 206468ba..f128e796 100644
--- a/sigmodr/widgets/ScriptWidget.cpp
+++ b/sigmodr/widgets/ScriptWidget.cpp
@@ -42,7 +42,10 @@
 #include <QtGui/QLabel>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::ScriptWidget::ScriptWidget(QWidget* parent, const Sigcore::Script& value) :
+using namespace Sigcore;
+using namespace Sigmodr::Widgets;
+
+ScriptWidget::ScriptWidget(QWidget* parent, const Script& value) :
         QWidget(parent),
         m_value(value),
         ui_simpleEdit(NULL),
@@ -116,18 +119,18 @@ Sigmodr::Widgets::ScriptWidget::ScriptWidget(QWidget* parent, const Sigcore::Scr
     setGui();
 }
 
-Sigmodr::Widgets::ScriptWidget::~ScriptWidget()
+ScriptWidget::~ScriptWidget()
 {
     if (m_editor)
         m_editor->writeConfig(NULL);
 }
 
-Sigcore::Script Sigmodr::Widgets::ScriptWidget::value() const
+Script ScriptWidget::value() const
 {
     return m_value;
 }
 
-void Sigmodr::Widgets::ScriptWidget::setGui()
+void ScriptWidget::setGui()
 {
     ui_interpreter->setCurrentIndex(ui_interpreter->findData(m_value.interpreter()));
     if (m_document)
@@ -145,7 +148,7 @@ void Sigmodr::Widgets::ScriptWidget::setGui()
     }
 }
 
-void Sigmodr::Widgets::ScriptWidget::setValue(const Sigcore::Script& value)
+void ScriptWidget::setValue(const Script& value)
 {
     if (m_value != value)
     {
@@ -154,7 +157,7 @@ void Sigmodr::Widgets::ScriptWidget::setValue(const Sigcore::Script& value)
     }
 }
 
-void Sigmodr::Widgets::ScriptWidget::interpreterChanged(const QString& interpreter)
+void ScriptWidget::interpreterChanged(const QString& interpreter)
 {
     m_value.setInterpreter(m_languages[interpreter]);
     if (m_document)
@@ -162,7 +165,7 @@ void Sigmodr::Widgets::ScriptWidget::interpreterChanged(const QString& interpret
     emit(valueChanged(m_value));
 }
 
-void Sigmodr::Widgets::ScriptWidget::scriptChanged()
+void ScriptWidget::scriptChanged()
 {
     if (m_document)
     {
@@ -182,14 +185,14 @@ void Sigmodr::Widgets::ScriptWidget::scriptChanged()
     }
 }
 
-void Sigmodr::Widgets::ScriptWidget::focused(KTextEditor::View* view)
+void ScriptWidget::focused(KTextEditor::View* view)
 {
     KXmlGuiWindow* topLevel = qobject_cast<KXmlGuiWindow*>(KApplication::kApplication()->activeWindow());
     if (topLevel)
         topLevel->guiFactory()->addClient(view);
 }
 
-void Sigmodr::Widgets::ScriptWidget::unfocused(KTextEditor::View* view)
+void ScriptWidget::unfocused(KTextEditor::View* view)
 {
     KXmlGuiWindow* topLevel = qobject_cast<KXmlGuiWindow*>(KApplication::kApplication()->activeWindow());
     QWidget* focused = KApplication::focusWidget();
diff --git a/sigmodr/widgets/SkinUI.cpp b/sigmodr/widgets/SkinUI.cpp
index d9264aab..6be00d38 100644
--- a/sigmodr/widgets/SkinUI.cpp
+++ b/sigmodr/widgets/SkinUI.cpp
@@ -31,13 +31,17 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::SkinUI::SkinUI(Sigmod::Skin* skin, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+SkinUI::SkinUI(Skin* skin, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(skin, new Sigmod::Skin(*skin));
+    setObjects(skin, new Skin(*skin));
 }
 
-void Sigmodr::Widgets::SkinUI::initGui()
+void SkinUI::initGui()
 {
     QFile file(":/gui/skin.ui");
     file.open(QFile::ReadOnly);
@@ -49,33 +53,33 @@ void Sigmodr::Widgets::SkinUI::initGui()
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::SkinUI::setGui()
+void SkinUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Skin*>(modified())->name());
-    ui_script->setValue(qobject_cast<Sigmod::Skin*>(modified())->script());
+    ui_name->setText(qobject_cast<Skin*>(modified())->name());
+    ui_script->setValue(qobject_cast<Skin*>(modified())->script());
 }
 
-void Sigmodr::Widgets::SkinUI::apply()
+void SkinUI::apply()
 {
-    *qobject_cast<Sigmod::Skin*>(original()) = *qobject_cast<Sigmod::Skin*>(modified());
+    *qobject_cast<Skin*>(original()) = *qobject_cast<Skin*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SkinUI::discard()
+void SkinUI::discard()
 {
-    *qobject_cast<Sigmod::Skin*>(modified()) = *qobject_cast<Sigmod::Skin*>(original());
+    *qobject_cast<Skin*>(modified()) = *qobject_cast<Skin*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SkinUI::nameChanged(const QString& name)
+void SkinUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Skin*>(modified())->setName(name);
+    qobject_cast<Skin*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::SkinUI::scriptChanged(const Sigcore::Script& script)
+void SkinUI::scriptChanged(const Script& script)
 {
-    qobject_cast<Sigmod::Skin*>(modified())->setScript(script);
+    qobject_cast<Skin*>(modified())->setScript(script);
 }
diff --git a/sigmodr/widgets/SoundUI.cpp b/sigmodr/widgets/SoundUI.cpp
index 985879e5..a4dd5047 100644
--- a/sigmodr/widgets/SoundUI.cpp
+++ b/sigmodr/widgets/SoundUI.cpp
@@ -42,22 +42,25 @@
 #include <QtGui/QLabel>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::SoundUI::SoundUI(Sigmod::Sound* sound, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+SoundUI::SoundUI(Sound* sound, QWidget* parent) :
         ObjectUI(parent),
         m_output(new Phonon::AudioOutput(Phonon::MusicCategory, this)),
         m_media(new Phonon::MediaObject(this)),
         m_buffer(new QBuffer)
 {
-    setObjects(sound, new Sigmod::Sound(*sound));
+    setObjects(sound, new Sound(*sound));
 }
 
-Sigmodr::Widgets::SoundUI::~SoundUI()
+SoundUI::~SoundUI()
 {
     delete m_media;
     delete m_buffer;
 }
 
-void Sigmodr::Widgets::SoundUI::initGui()
+void SoundUI::initGui()
 {
     QFile file(":/gui/sound.ui");
     file.open(QFile::ReadOnly);
@@ -80,48 +83,48 @@ void Sigmodr::Widgets::SoundUI::initGui()
     buttonBrowse->setIcon(KIcon("document-open"));
 }
 
-void Sigmodr::Widgets::SoundUI::refreshGui()
+void SoundUI::refreshGui()
 {
     resetAudioData();
 }
 
-void Sigmodr::Widgets::SoundUI::setGui()
+void SoundUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Sound*>(modified())->name());
+    ui_name->setText(qobject_cast<Sound*>(modified())->name());
 }
 
-void Sigmodr::Widgets::SoundUI::apply()
+void SoundUI::apply()
 {
-    *qobject_cast<Sigmod::Sound*>(original()) = *qobject_cast<Sigmod::Sound*>(modified());
+    *qobject_cast<Sound*>(original()) = *qobject_cast<Sound*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SoundUI::discard()
+void SoundUI::discard()
 {
-    *qobject_cast<Sigmod::Sound*>(modified()) = *qobject_cast<Sigmod::Sound*>(original());
+    *qobject_cast<Sound*>(modified()) = *qobject_cast<Sound*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SoundUI::nameChanged(const QString& name)
+void SoundUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Sound*>(modified())->setName(name);
+    qobject_cast<Sound*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::SoundUI::browse()
+void SoundUI::browse()
 {
     QFile file(KFileDialog::getOpenFileName(KUrl("kfiledialog:///audio"), "audio/*|Audio files", this));
     if (file.open(QIODevice::ReadOnly))
     {
-        qobject_cast<Sigmod::Sound*>(modified())->setData(file.readAll());
+        qobject_cast<Sound*>(modified())->setData(file.readAll());
         file.close();
         resetAudioData();
     }
 }
 
-void Sigmodr::Widgets::SoundUI::stateChanged(Phonon::State newState)
+void SoundUI::stateChanged(Phonon::State newState)
 {
     switch (newState)
     {
@@ -157,15 +160,15 @@ void Sigmodr::Widgets::SoundUI::stateChanged(Phonon::State newState)
     }
 }
 
-void Sigmodr::Widgets::SoundUI::resetAudioData()
+void SoundUI::resetAudioData()
 {
     m_media->stop();
-    m_buffer->setData(qobject_cast<Sigmod::Sound*>(modified())->data());
+    m_buffer->setData(qobject_cast<Sound*>(modified())->data());
     m_media->setCurrentSource(m_buffer);
     tick(0);
 }
 
-void Sigmodr::Widgets::SoundUI::tick(qint64 time)
+void SoundUI::tick(qint64 time)
 {
     QTime currentTime(0, (time / 60000) % 60, (time / 1000) % 60, time % 1000);
     qint64 total = m_media->totalTime();
diff --git a/sigmodr/widgets/SpeciesMoveUI.cpp b/sigmodr/widgets/SpeciesMoveUI.cpp
index 48cd444b..9ecb57d2 100644
--- a/sigmodr/widgets/SpeciesMoveUI.cpp
+++ b/sigmodr/widgets/SpeciesMoveUI.cpp
@@ -32,13 +32,16 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::SpeciesMoveUI::SpeciesMoveUI(Sigmod::SpeciesMove* move, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+SpeciesMoveUI::SpeciesMoveUI(SpeciesMove* move, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(move, new Sigmod::SpeciesMove(*move));
+    setObjects(move, new SpeciesMove(*move));
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::initGui()
+void SpeciesMoveUI::initGui()
 {
     QFile file(":/gui/speciesmove.ui");
     file.open(QFile::ReadOnly);
@@ -52,7 +55,7 @@ void Sigmodr::Widgets::SpeciesMoveUI::initGui()
     connect(ui_wildLevel, SIGNAL(valueChanged(int)), this, SLOT(wildLevelChanged(int)));
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::refreshGui()
+void SpeciesMoveUI::refreshGui()
 {
     const bool blocked = ui_move->blockSignals(true);
     ui_move->clear();
@@ -63,37 +66,37 @@ void Sigmodr::Widgets::SpeciesMoveUI::refreshGui()
     ui_wildLevel->setMaximum(game()->rules()->maxLevel());
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::setGui()
+void SpeciesMoveUI::setGui()
 {
-    ui_move->setCurrentIndex(game()->moveIndex(qobject_cast<Sigmod::SpeciesMove*>(modified())->move()));
-    ui_level->setValue(qobject_cast<Sigmod::SpeciesMove*>(modified())->level());
-    ui_wildLevel->setValue(qobject_cast<Sigmod::SpeciesMove*>(modified())->wild());
+    ui_move->setCurrentIndex(game()->moveIndex(qobject_cast<SpeciesMove*>(modified())->move()));
+    ui_level->setValue(qobject_cast<SpeciesMove*>(modified())->level());
+    ui_wildLevel->setValue(qobject_cast<SpeciesMove*>(modified())->wild());
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::apply()
+void SpeciesMoveUI::apply()
 {
-    *qobject_cast<Sigmod::SpeciesMove*>(original()) = *qobject_cast<Sigmod::SpeciesMove*>(modified());
+    *qobject_cast<SpeciesMove*>(original()) = *qobject_cast<SpeciesMove*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::discard()
+void SpeciesMoveUI::discard()
 {
-    *qobject_cast<Sigmod::SpeciesMove*>(modified()) = *qobject_cast<Sigmod::SpeciesMove*>(original());
+    *qobject_cast<SpeciesMove*>(modified()) = *qobject_cast<SpeciesMove*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::moveChanged(const int move)
+void SpeciesMoveUI::moveChanged(const int move)
 {
-    qobject_cast<Sigmod::SpeciesMove*>(modified())->setMove(game()->move(move)->id());
+    qobject_cast<SpeciesMove*>(modified())->setMove(game()->move(move)->id());
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::levelChanged(const int level)
+void SpeciesMoveUI::levelChanged(const int level)
 {
-    qobject_cast<Sigmod::SpeciesMove*>(modified())->setLevel(level);
+    qobject_cast<SpeciesMove*>(modified())->setLevel(level);
 }
 
-void Sigmodr::Widgets::SpeciesMoveUI::wildLevelChanged(const int wildLevel)
+void SpeciesMoveUI::wildLevelChanged(const int wildLevel)
 {
-    qobject_cast<Sigmod::SpeciesMove*>(modified())->setWild(wildLevel);
+    qobject_cast<SpeciesMove*>(modified())->setWild(wildLevel);
 }
diff --git a/sigmodr/widgets/SpeciesUI.cpp b/sigmodr/widgets/SpeciesUI.cpp
index f9d28492..c9aa4746 100644
--- a/sigmodr/widgets/SpeciesUI.cpp
+++ b/sigmodr/widgets/SpeciesUI.cpp
@@ -33,115 +33,119 @@
 #include <QtGui/QHeaderView>
 #include <QtGui/QListWidget>
 
-Sigmodr::Widgets::SpeciesUI::SpeciesUI(Sigmod::Species* species, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+SpeciesUI::SpeciesUI(Species* species, QWidget* parent) :
         ObjectUI(parent)
 {
     setupUi(this);
-    setObjects(species, new Sigmod::Species(*species));
+    setObjects(species, new Species(*species));
 }
 
-Sigmodr::Widgets::SpeciesUI::~SpeciesUI()
+SpeciesUI::~SpeciesUI()
 {
 }
 
-void Sigmodr::Widgets::SpeciesUI::initGui()
+void SpeciesUI::initGui()
 {
-    varGrowth->addItem(Sigmod::Species::StyleStr[Sigmod::Species::Fluctuating], QVariant::fromValue(Sigmod::Species::Fluctuating));
-    varGrowth->addItem(Sigmod::Species::StyleStr[Sigmod::Species::Fading], QVariant::fromValue(Sigmod::Species::Fading));
-    varGrowth->addItem(Sigmod::Species::StyleStr[Sigmod::Species::Slow], QVariant::fromValue(Sigmod::Species::Slow));
-    varGrowth->addItem(Sigmod::Species::StyleStr[Sigmod::Species::Normal], QVariant::fromValue(Sigmod::Species::Normal));
-    varGrowth->addItem(Sigmod::Species::StyleStr[Sigmod::Species::Fast], QVariant::fromValue(Sigmod::Species::Fast));
-    varGrowth->addItem(Sigmod::Species::StyleStr[Sigmod::Species::Erratic], QVariant::fromValue(Sigmod::Species::Erratic));
+    varGrowth->addItem(Species::StyleStr[Species::Fluctuating], QVariant::fromValue(Species::Fluctuating));
+    varGrowth->addItem(Species::StyleStr[Species::Fading], QVariant::fromValue(Species::Fading));
+    varGrowth->addItem(Species::StyleStr[Species::Slow], QVariant::fromValue(Species::Slow));
+    varGrowth->addItem(Species::StyleStr[Species::Normal], QVariant::fromValue(Species::Normal));
+    varGrowth->addItem(Species::StyleStr[Species::Fast], QVariant::fromValue(Species::Fast));
+    varGrowth->addItem(Species::StyleStr[Species::Erratic], QVariant::fromValue(Species::Erratic));
     varBaseStat->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
     varEffortValue->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
     connect(varAbilities->selectedListWidget(), SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), this, SLOT(selectedAbilityChanged(QListWidgetItem*)));
     connect(varItems->selectedListWidget(), SIGNAL(currentItemChanged(QListWidgetItem*, QListWidgetItem*)), this, SLOT(selectedItemChanged(QListWidgetItem*)));
 }
 
-void Sigmodr::Widgets::SpeciesUI::refreshGui()
+void SpeciesUI::refreshGui()
 {
     const bool isSplit = game()->rules()->specialSplit();
     varBaseStat->clear();
-    varBaseStat->setRowCount((isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1);
-    varBaseStat->setVerticalHeaderLabels((isSplit ? Sigmod::StatGSCStr : Sigmod::StatRBYStr).mid(Sigmod::ST_Attack, (isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1));
+    varBaseStat->setRowCount((isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1);
+    varBaseStat->setVerticalHeaderLabels((isSplit ? StatGSCStr : StatRBYStr).mid(ST_Attack, (isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1));
     varBaseStat->setColumnCount(1);
     varBaseStat->setHorizontalHeaderLabels(QStringList() << "Value");
-    varBaseStat->verticalHeaderItem(Sigmod::ST_Attack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Attack));
-    varBaseStat->verticalHeaderItem(Sigmod::ST_Defense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Defense));
-    varBaseStat->verticalHeaderItem(Sigmod::ST_Speed - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Speed));
+    varBaseStat->verticalHeaderItem(ST_Attack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Attack));
+    varBaseStat->verticalHeaderItem(ST_Defense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Defense));
+    varBaseStat->verticalHeaderItem(ST_Speed - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Speed));
     if (isSplit)
     {
-        varBaseStat->verticalHeaderItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialAttack));
-        varBaseStat->verticalHeaderItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialDefense));
+        varBaseStat->verticalHeaderItem(ST_SpecialAttack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialAttack));
+        varBaseStat->verticalHeaderItem(ST_SpecialDefense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialDefense));
     }
     else
-        varBaseStat->verticalHeaderItem(Sigmod::ST_Special - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Special));
+        varBaseStat->verticalHeaderItem(ST_Special - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Special));
     QTableWidgetItem* item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    varBaseStat->setItem(Sigmod::ST_Attack - Sigmod::ST_Attack, 0, item);
+    varBaseStat->setItem(ST_Attack - ST_Attack, 0, item);
     varBaseStat->setCurrentItem(item);
     item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    varBaseStat->setItem(Sigmod::ST_Defense- Sigmod::ST_Attack, 0, item);
+    varBaseStat->setItem(ST_Defense- ST_Attack, 0, item);
     item = new QTableWidgetItem;
     item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-    varBaseStat->setItem(Sigmod::ST_Speed - Sigmod::ST_Attack, 0, item);
+    varBaseStat->setItem(ST_Speed - ST_Attack, 0, item);
     if (isSplit)
     {
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varBaseStat->setItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0, item);
+        varBaseStat->setItem(ST_SpecialAttack - ST_Attack, 0, item);
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varBaseStat->setItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0, item);
+        varBaseStat->setItem(ST_SpecialDefense - ST_Attack, 0, item);
     }
     else
     {
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varBaseStat->setItem(Sigmod::ST_Special - Sigmod::ST_Attack, 0, item);
+        varBaseStat->setItem(ST_Special - ST_Attack, 0, item);
     }
     if (game()->rules()->effortValuesAllowed())
     {
         varEffortValue->clear();
-        varEffortValue->setRowCount((isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1);
-        varEffortValue->setVerticalHeaderLabels((isSplit ? Sigmod::StatGSCStr : Sigmod::StatRBYStr).mid(Sigmod::ST_Attack, (isSplit ? Sigmod::ST_SpecialDefense : Sigmod::ST_Special) - Sigmod::ST_Attack + 1));
+        varEffortValue->setRowCount((isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1);
+        varEffortValue->setVerticalHeaderLabels((isSplit ? StatGSCStr : StatRBYStr).mid(ST_Attack, (isSplit ? ST_SpecialDefense : ST_Special) - ST_Attack + 1));
         varEffortValue->setColumnCount(1);
         varEffortValue->setHorizontalHeaderLabels(QStringList() << "Value");
-        varEffortValue->verticalHeaderItem(Sigmod::ST_Attack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Attack));
-        varEffortValue->verticalHeaderItem(Sigmod::ST_Defense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Defense));
-        varEffortValue->verticalHeaderItem(Sigmod::ST_Speed - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Speed));
+        varEffortValue->verticalHeaderItem(ST_Attack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Attack));
+        varEffortValue->verticalHeaderItem(ST_Defense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Defense));
+        varEffortValue->verticalHeaderItem(ST_Speed - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Speed));
         if (isSplit)
         {
-            varEffortValue->verticalHeaderItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialAttack));
-            varEffortValue->verticalHeaderItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_SpecialDefense));
+            varEffortValue->verticalHeaderItem(ST_SpecialAttack - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialAttack));
+            varEffortValue->verticalHeaderItem(ST_SpecialDefense - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_SpecialDefense));
         }
         else
-            varEffortValue->verticalHeaderItem(Sigmod::ST_Special - Sigmod::ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(Sigmod::ST_Special));
+            varEffortValue->verticalHeaderItem(ST_Special - ST_Attack)->setData(Qt::UserRole, QVariant::fromValue(ST_Special));
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varEffortValue->setItem(Sigmod::ST_Attack - Sigmod::ST_Attack, 0, item);
+        varEffortValue->setItem(ST_Attack - ST_Attack, 0, item);
         varEffortValue->setCurrentItem(item);
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varEffortValue->setItem(Sigmod::ST_Defense- Sigmod::ST_Attack, 0, item);
+        varEffortValue->setItem(ST_Defense- ST_Attack, 0, item);
         item = new QTableWidgetItem;
         item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        varEffortValue->setItem(Sigmod::ST_Speed - Sigmod::ST_Attack, 0, item);
+        varEffortValue->setItem(ST_Speed - ST_Attack, 0, item);
         if (isSplit)
         {
             item = new QTableWidgetItem;
             item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-            varEffortValue->setItem(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0, item);
+            varEffortValue->setItem(ST_SpecialAttack - ST_Attack, 0, item);
             item = new QTableWidgetItem;
             item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-            varEffortValue->setItem(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0, item);
+            varEffortValue->setItem(ST_SpecialDefense - ST_Attack, 0, item);
         }
         else
         {
             item = new QTableWidgetItem;
             item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-            varEffortValue->setItem(Sigmod::ST_Special - Sigmod::ST_Attack, 0, item);
+            varEffortValue->setItem(ST_Special - ST_Attack, 0, item);
         }
     }
     else
@@ -160,7 +164,7 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     varFemaleBack->clear();
     for (int i = 0; i < game()->spriteCount(); ++i)
     {
-        const Sigmod::Sprite* sprite = game()->sprite(i);
+        const Sprite* sprite = game()->sprite(i);
         QPixmap icon;
         icon.loadFromData(sprite->sprite());
         maxHeight = qMax(maxHeight, icon.height());
@@ -185,7 +189,7 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     varSkin->clear();
     for (int i = 0; i < game()->skinCount(); ++i)
     {
-        const Sigmod::Skin* skin = game()->skin(i);
+        const Skin* skin = game()->skin(i);
         varSkin->addItem(skin->name(), skin->id());
     }
     varSkin->blockSignals(blockedSkin);
@@ -193,7 +197,7 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     varEggSpecies->clear();
     for (int i = 0; i < game()->speciesCount(); ++i)
     {
-        const Sigmod::Species* species = game()->species(i);
+        const Species* species = game()->species(i);
         varEggSpecies->addItem(species->name(), species->id());
     }
     varEggSpecies->blockSignals(blockedEggSpecies);
@@ -204,7 +208,7 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     varEggGroups->selectedListWidget()->clear();
     for (int i = 0; i < game()->eggGroupCount(); ++i)
     {
-        const Sigmod::EggGroup* eggGroup = game()->eggGroup(i);
+        const EggGroup* eggGroup = game()->eggGroup(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(eggGroup->name(), varEggGroups->availableListWidget());
         widgetItem->setData(Qt::UserRole, eggGroup->id());
     }
@@ -217,7 +221,7 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     varTypes->selectedListWidget()->clear();
     for (int i = 0; i < game()->typeCount(); ++i)
     {
-        const Sigmod::Type* type = game()->type(i);
+        const Type* type = game()->type(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(type->name(), varTypes->selectedListWidget());
         widgetItem->setData(Qt::UserRole, type->id());
     }
@@ -228,7 +232,7 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     varAbilities->selectedListWidget()->clear();
     for (int i = 0; i < game()->abilityCount(); ++i)
     {
-        const Sigmod::Ability* ability = game()->ability(i);
+        const Ability* ability = game()->ability(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(ability->name(), varAbilities->availableListWidget());
         widgetItem->setData(Qt::UserRole, ability->id());
     }
@@ -240,7 +244,7 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     varItems->selectedListWidget()->clear();
     for (int i = 0; i < game()->itemCount(); ++i)
     {
-        const Sigmod::Item* item = game()->item(i);
+        const Item* item = game()->item(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(item->name(), varItems->availableListWidget());
         widgetItem->setData(Qt::UserRole, item->id());
     }
@@ -249,335 +253,335 @@ void Sigmodr::Widgets::SpeciesUI::refreshGui()
     boxItems->setEnabled(game()->rules()->maxHeldItems());
 }
 
-void Sigmodr::Widgets::SpeciesUI::setGui()
+void SpeciesUI::setGui()
 {
-    varName->setText(qobject_cast<Sigmod::Species*>(modified())->name());
-    varBaseStat->item(Sigmod::ST_Attack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->baseStat(Sigmod::ST_Attack)));
-    varBaseStat->item(Sigmod::ST_Defense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->baseStat(Sigmod::ST_Defense)));
-    varBaseStat->item(Sigmod::ST_Speed - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->baseStat(Sigmod::ST_Speed)));
+    varName->setText(qobject_cast<Species*>(modified())->name());
+    varBaseStat->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Attack)));
+    varBaseStat->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Defense)));
+    varBaseStat->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Speed)));
     if (game()->rules()->specialSplit())
     {
-        varBaseStat->item(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->baseStat(Sigmod::ST_SpecialAttack)));
-        varBaseStat->item(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->baseStat(Sigmod::ST_SpecialDefense)));
+        varBaseStat->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_SpecialAttack)));
+        varBaseStat->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_SpecialDefense)));
     }
     else
-        varBaseStat->item(Sigmod::ST_Special - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->baseStat(Sigmod::ST_Special)));
-    varBaseStatValue->setValue(qobject_cast<Sigmod::Species*>(modified())->baseStat(varBaseStat->verticalHeaderItem(varBaseStat->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>()));
+        varBaseStat->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->baseStat(ST_Special)));
+    varBaseStatValue->setValue(qobject_cast<Species*>(modified())->baseStat(varBaseStat->verticalHeaderItem(varBaseStat->currentRow())->data(Qt::UserRole).value<Stat>()));
     if (game()->rules()->effortValuesAllowed())
     {
-        varEffortValue->item(Sigmod::ST_Attack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->effortValue(Sigmod::ST_Attack)));
-        varEffortValue->item(Sigmod::ST_Defense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->effortValue(Sigmod::ST_Defense)));
-        varEffortValue->item(Sigmod::ST_Speed - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->effortValue(Sigmod::ST_Speed)));
+        varEffortValue->item(ST_Attack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Attack)));
+        varEffortValue->item(ST_Defense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Defense)));
+        varEffortValue->item(ST_Speed - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Speed)));
         if (game()->rules()->specialSplit())
         {
-            varEffortValue->item(Sigmod::ST_SpecialAttack - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->effortValue(Sigmod::ST_SpecialAttack)));
-            varEffortValue->item(Sigmod::ST_SpecialDefense - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->effortValue(Sigmod::ST_SpecialDefense)));
+            varEffortValue->item(ST_SpecialAttack - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_SpecialAttack)));
+            varEffortValue->item(ST_SpecialDefense - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_SpecialDefense)));
         }
         else
-            varEffortValue->item(Sigmod::ST_Special - Sigmod::ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Sigmod::Species*>(modified())->effortValue(Sigmod::ST_Special)));
-        varEffortValueValue->setValue(qobject_cast<Sigmod::Species*>(modified())->effortValue(varEffortValue->verticalHeaderItem(varEffortValue->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>()));
+            varEffortValue->item(ST_Special - ST_Attack, 0)->setData(Qt::DisplayRole, QString::number(qobject_cast<Species*>(modified())->effortValue(ST_Special)));
+        varEffortValueValue->setValue(qobject_cast<Species*>(modified())->effortValue(varEffortValue->verticalHeaderItem(varEffortValue->currentRow())->data(Qt::UserRole).value<Stat>()));
     }
-    varGrowth->setCurrentIndex(qobject_cast<Sigmod::Species*>(modified())->growth());
-    varExperienceValue->setValue(qobject_cast<Sigmod::Species*>(modified())->experienceValue());
-    varCatchValue->setValue(qobject_cast<Sigmod::Species*>(modified())->catchValue());
-    varMaxHoldWeight->setValue(qobject_cast<Sigmod::Species*>(modified())->maxHoldWeight());
-    varRunChance->setValue(qobject_cast<Sigmod::Species*>(modified())->runChance());
-    varItemChance->setValue(qobject_cast<Sigmod::Species*>(modified())->itemChance());
-    varEncyclopediaNumber->setValue(qobject_cast<Sigmod::Species*>(modified())->encyclopediaNumber());
-    varWeight->setValue(qobject_cast<Sigmod::Species*>(modified())->weight());
-    varHeight->setValue(qobject_cast<Sigmod::Species*>(modified())->height());
-    varEncyclopediaEntry->setText(qobject_cast<Sigmod::Species*>(modified())->encyclopediaEntry());
-    varMaleFront->setCurrentIndex(varMaleFront->findData(qobject_cast<Sigmod::Species*>(modified())->frontMaleSprite()));
-    varMaleBack->setCurrentIndex(varMaleBack->findData(qobject_cast<Sigmod::Species*>(modified())->backMaleSprite()));
-    varMaleFront->setEnabled(qobject_cast<Sigmod::Species*>(modified())->genderFactor() < 1);
-    varMaleBack->setEnabled(qobject_cast<Sigmod::Species*>(modified())->genderFactor() < 1);
+    varGrowth->setCurrentIndex(qobject_cast<Species*>(modified())->growth());
+    varExperienceValue->setValue(qobject_cast<Species*>(modified())->experienceValue());
+    varCatchValue->setValue(qobject_cast<Species*>(modified())->catchValue());
+    varMaxHoldWeight->setValue(qobject_cast<Species*>(modified())->maxHoldWeight());
+    varRunChance->setValue(qobject_cast<Species*>(modified())->runChance());
+    varItemChance->setValue(qobject_cast<Species*>(modified())->itemChance());
+    varEncyclopediaNumber->setValue(qobject_cast<Species*>(modified())->encyclopediaNumber());
+    varWeight->setValue(qobject_cast<Species*>(modified())->weight());
+    varHeight->setValue(qobject_cast<Species*>(modified())->height());
+    varEncyclopediaEntry->setText(qobject_cast<Species*>(modified())->encyclopediaEntry());
+    varMaleFront->setCurrentIndex(varMaleFront->findData(qobject_cast<Species*>(modified())->frontMaleSprite()));
+    varMaleBack->setCurrentIndex(varMaleBack->findData(qobject_cast<Species*>(modified())->backMaleSprite()));
+    varMaleFront->setEnabled(qobject_cast<Species*>(modified())->genderFactor() < 1);
+    varMaleBack->setEnabled(qobject_cast<Species*>(modified())->genderFactor() < 1);
     if (game()->rules()->genderAllowed())
     {
-        varFemaleFront->setCurrentIndex(varFemaleFront->findData(qobject_cast<Sigmod::Species*>(modified())->frontFemaleSprite()));
-        varFemaleBack->setCurrentIndex(varFemaleBack->findData(qobject_cast<Sigmod::Species*>(modified())->backFemaleSprite()));
-        varFemaleFront->setEnabled(0 < qobject_cast<Sigmod::Species*>(modified())->genderFactor());
-        varFemaleBack->setEnabled(0 < qobject_cast<Sigmod::Species*>(modified())->genderFactor());
+        varFemaleFront->setCurrentIndex(varFemaleFront->findData(qobject_cast<Species*>(modified())->frontFemaleSprite()));
+        varFemaleBack->setCurrentIndex(varFemaleBack->findData(qobject_cast<Species*>(modified())->backFemaleSprite()));
+        varFemaleFront->setEnabled(0 < qobject_cast<Species*>(modified())->genderFactor());
+        varFemaleBack->setEnabled(0 < qobject_cast<Species*>(modified())->genderFactor());
     }
-    varSkin->setCurrentIndex(varSkin->findData(qobject_cast<Sigmod::Species*>(modified())->skin()));
-    varHasGender->setCheckState((qobject_cast<Sigmod::Species*>(modified())->genderFactor() < 0) ? Qt::Checked : Qt::Unchecked);
-    varGenderChance->setValue(qobject_cast<Sigmod::Species*>(modified())->genderFactor());
-    varEggSpecies->setCurrentIndex(varEggSpecies->findData(qobject_cast<Sigmod::Species*>(modified())->eggSpecies()));
-    varEggSteps->setValue(qobject_cast<Sigmod::Species*>(modified())->eggSteps());
-    varEvolution->setValue(qobject_cast<Sigmod::Species*>(modified())->evolution());
+    varSkin->setCurrentIndex(varSkin->findData(qobject_cast<Species*>(modified())->skin()));
+    varHasGender->setCheckState((qobject_cast<Species*>(modified())->genderFactor() < 0) ? Qt::Checked : Qt::Unchecked);
+    varGenderChance->setValue(qobject_cast<Species*>(modified())->genderFactor());
+    varEggSpecies->setCurrentIndex(varEggSpecies->findData(qobject_cast<Species*>(modified())->eggSpecies()));
+    varEggSteps->setValue(qobject_cast<Species*>(modified())->eggSteps());
+    varEvolution->setValue(qobject_cast<Species*>(modified())->evolution());
     for (int i = 0; i < varTypes->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varTypes->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::Species*>(modified())->type(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<Species*>(modified())->type(widgetItem->data(Qt::UserRole).toInt()))
             varTypes->selectedListWidget()->addItem(varTypes->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varTypes->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varTypes->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::Species*>(modified())->type(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<Species*>(modified())->type(widgetItem->data(Qt::UserRole).toInt()))
             varTypes->availableListWidget()->addItem(varTypes->selectedListWidget()->takeItem(i--));
     }
     varTypes->setButtonsEnabled();
     for (int i = 0; i < varEggGroups->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varEggGroups->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::Species*>(modified())->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<Species*>(modified())->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
             varEggGroups->selectedListWidget()->addItem(varEggGroups->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varEggGroups->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varEggGroups->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::Species*>(modified())->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<Species*>(modified())->eggGroup(widgetItem->data(Qt::UserRole).toInt()))
             varEggGroups->availableListWidget()->addItem(varEggGroups->selectedListWidget()->takeItem(i--));
     }
     varEggGroups->setButtonsEnabled();
     for (int i = 0; i < varAbilities->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varAbilities->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::Species*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<Species*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
             varAbilities->selectedListWidget()->addItem(varAbilities->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varAbilities->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varAbilities->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::Species*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<Species*>(modified())->ability(widgetItem->data(Qt::UserRole).toInt()))
             varAbilities->availableListWidget()->addItem(varAbilities->selectedListWidget()->takeItem(i--));
     }
     varAbilities->setButtonsEnabled();
     QListWidgetItem* selectedAbility= varAbilities->selectedListWidget()->currentItem();
     if (selectedAbility)
-        varAbilityWeight->setValue(qobject_cast<Sigmod::Species*>(modified())->ability(selectedAbility->data(Qt::UserRole).toInt()));
+        varAbilityWeight->setValue(qobject_cast<Species*>(modified())->ability(selectedAbility->data(Qt::UserRole).toInt()));
     for (int i = 0; i < varItems->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varItems->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::Species*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<Species*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
             varItems->selectedListWidget()->addItem(varItems->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < varItems->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = varItems->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::Species*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<Species*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
             varItems->availableListWidget()->addItem(varItems->selectedListWidget()->takeItem(i--));
     }
     varItems->setButtonsEnabled();
     QListWidgetItem* selectedItem = varItems->selectedListWidget()->currentItem();
     if (selectedItem)
-        varItemWeight->setValue(qobject_cast<Sigmod::Species*>(modified())->ability(selectedItem->data(Qt::UserRole).toInt()));
+        varItemWeight->setValue(qobject_cast<Species*>(modified())->ability(selectedItem->data(Qt::UserRole).toInt()));
 }
 
-void Sigmodr::Widgets::SpeciesUI::apply()
+void SpeciesUI::apply()
 {
-    *qobject_cast<Sigmod::Species*>(original()) = *qobject_cast<Sigmod::Species*>(modified());
+    *qobject_cast<Species*>(original()) = *qobject_cast<Species*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SpeciesUI::discard()
+void SpeciesUI::discard()
 {
-    *qobject_cast<Sigmod::Species*>(modified()) = *qobject_cast<Sigmod::Species*>(original());
+    *qobject_cast<Species*>(modified()) = *qobject_cast<Species*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varName_textChanged(const QString& name)
+void SpeciesUI::on_varName_textChanged(const QString& name)
 {
     const int cursor = varName->cursorPosition();
-    qobject_cast<Sigmod::Species*>(modified())->setName(name);
+    qobject_cast<Species*>(modified())->setName(name);
     varName->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varBaseStat_currentCellChanged(const int row)
+void SpeciesUI::on_varBaseStat_currentCellChanged(const int row)
 {
-    varBaseStatValue->setValue(qobject_cast<Sigmod::Species*>(modified())->baseStat(varBaseStat->verticalHeaderItem(row)->data(Qt::UserRole).value<Sigmod::Stat>()));
+    varBaseStatValue->setValue(qobject_cast<Species*>(modified())->baseStat(varBaseStat->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varBaseStatValue_valueChanged(const int baseStat)
+void SpeciesUI::on_varBaseStatValue_valueChanged(const int baseStat)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setBaseStat(varBaseStat->verticalHeaderItem(varBaseStat->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>(), baseStat);
+    qobject_cast<Species*>(modified())->setBaseStat(varBaseStat->verticalHeaderItem(varBaseStat->currentRow())->data(Qt::UserRole).value<Stat>(), baseStat);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEffortValue_currentCellChanged(const int row)
+void SpeciesUI::on_varEffortValue_currentCellChanged(const int row)
 {
-    varEffortValueValue->setValue(qobject_cast<Sigmod::Species*>(modified())->effortValue(varEffortValue->verticalHeaderItem(row)->data(Qt::UserRole).value<Sigmod::Stat>()));
+    varEffortValueValue->setValue(qobject_cast<Species*>(modified())->effortValue(varEffortValue->verticalHeaderItem(row)->data(Qt::UserRole).value<Stat>()));
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEffortValueValue_valueChanged(const int effortValue)
+void SpeciesUI::on_varEffortValueValue_valueChanged(const int effortValue)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEffortValue(varEffortValue->verticalHeaderItem(varEffortValue->currentRow())->data(Qt::UserRole).value<Sigmod::Stat>(), effortValue);
+    qobject_cast<Species*>(modified())->setEffortValue(varEffortValue->verticalHeaderItem(varEffortValue->currentRow())->data(Qt::UserRole).value<Stat>(), effortValue);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varGrowth_activated(const int growth)
+void SpeciesUI::on_varGrowth_activated(const int growth)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setGrowth(QVariant(growth).value<Sigmod::Species::Style>());
+    qobject_cast<Species*>(modified())->setGrowth(QVariant(growth).value<Species::Style>());
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varExperienceValue_valueChanged(const int experienceValue)
+void SpeciesUI::on_varExperienceValue_valueChanged(const int experienceValue)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setExperienceValue(experienceValue);
+    qobject_cast<Species*>(modified())->setExperienceValue(experienceValue);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varCatchValue_valueChanged(const int catchValue)
+void SpeciesUI::on_varCatchValue_valueChanged(const int catchValue)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setCatchValue(catchValue);
+    qobject_cast<Species*>(modified())->setCatchValue(catchValue);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varMaxHoldWeight_valueChanged(const int maxHoldWeight)
+void SpeciesUI::on_varMaxHoldWeight_valueChanged(const int maxHoldWeight)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setMaxHoldWeight(maxHoldWeight);
+    qobject_cast<Species*>(modified())->setMaxHoldWeight(maxHoldWeight);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varRunChance_valueChanged(const Sigcore::Fraction& runChance)
+void SpeciesUI::on_varRunChance_valueChanged(const Fraction& runChance)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setRunChance(runChance);
+    qobject_cast<Species*>(modified())->setRunChance(runChance);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varItemChance_valueChanged(const Sigcore::Fraction& itemChance)
+void SpeciesUI::on_varItemChance_valueChanged(const Fraction& itemChance)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setItemChance(itemChance);
+    qobject_cast<Species*>(modified())->setItemChance(itemChance);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEncyclopediaNumber_valueChanged(const int encyclopediaNumber)
+void SpeciesUI::on_varEncyclopediaNumber_valueChanged(const int encyclopediaNumber)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEncyclopediaNumber(encyclopediaNumber);
+    qobject_cast<Species*>(modified())->setEncyclopediaNumber(encyclopediaNumber);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varWeight_valueChanged(const int weight)
+void SpeciesUI::on_varWeight_valueChanged(const int weight)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setWeight(weight);
+    qobject_cast<Species*>(modified())->setWeight(weight);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varHeight_valueChanged(const int height)
+void SpeciesUI::on_varHeight_valueChanged(const int height)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setHeight(height);
+    qobject_cast<Species*>(modified())->setHeight(height);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEncyclopediaEntry_textChanged(const QString& encyclopediaEntry)
+void SpeciesUI::on_varEncyclopediaEntry_textChanged(const QString& encyclopediaEntry)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEncyclopediaEntry(encyclopediaEntry);
+    qobject_cast<Species*>(modified())->setEncyclopediaEntry(encyclopediaEntry);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varMaleFront_currentIndexChanged(const int maleFront)
+void SpeciesUI::on_varMaleFront_currentIndexChanged(const int maleFront)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setFrontMaleSprite(varMaleFront->itemData(maleFront).toInt());
+    qobject_cast<Species*>(modified())->setFrontMaleSprite(varMaleFront->itemData(maleFront).toInt());
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varMaleBack_currentIndexChanged(const int maleBack)
+void SpeciesUI::on_varMaleBack_currentIndexChanged(const int maleBack)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setBackMaleSprite(varMaleBack->itemData(maleBack).toInt());
+    qobject_cast<Species*>(modified())->setBackMaleSprite(varMaleBack->itemData(maleBack).toInt());
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varFemaleFront_currentIndexChanged(const int femaleFront)
+void SpeciesUI::on_varFemaleFront_currentIndexChanged(const int femaleFront)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setFrontFemaleSprite(varFemaleFront->itemData(femaleFront).toInt());
+    qobject_cast<Species*>(modified())->setFrontFemaleSprite(varFemaleFront->itemData(femaleFront).toInt());
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varFemaleBack_currentIndexChanged(const int femaleBack)
+void SpeciesUI::on_varFemaleBack_currentIndexChanged(const int femaleBack)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setBackFemaleSprite(varFemaleBack->itemData(femaleBack).toInt());
+    qobject_cast<Species*>(modified())->setBackFemaleSprite(varFemaleBack->itemData(femaleBack).toInt());
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varSkin_currentIndexChanged(const int skin)
+void SpeciesUI::on_varSkin_currentIndexChanged(const int skin)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setSkin(varSkin->itemData(skin).toInt());
+    qobject_cast<Species*>(modified())->setSkin(varSkin->itemData(skin).toInt());
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varHasGender_toggled(const bool hasGender)
+void SpeciesUI::on_varHasGender_toggled(const bool hasGender)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setGenderFactor(Sigcore::Fraction((hasGender ? 1 : -1), 1));
+    qobject_cast<Species*>(modified())->setGenderFactor(Fraction((hasGender ? 1 : -1), 1));
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varGenderChance_valueChanged(const Sigcore::Fraction& genderChance)
+void SpeciesUI::on_varGenderChance_valueChanged(const Fraction& genderChance)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setGenderFactor(genderChance);
+    qobject_cast<Species*>(modified())->setGenderFactor(genderChance);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEggSpecies_activated(const int eggSpecies)
+void SpeciesUI::on_varEggSpecies_activated(const int eggSpecies)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEggSpecies(varEggSpecies->itemData(eggSpecies).toInt());
+    qobject_cast<Species*>(modified())->setEggSpecies(varEggSpecies->itemData(eggSpecies).toInt());
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEggSteps_valueChanged(const int eggSteps)
+void SpeciesUI::on_varEggSteps_valueChanged(const int eggSteps)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEggSteps(eggSteps);
+    qobject_cast<Species*>(modified())->setEggSteps(eggSteps);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEvolution_valueChanged(const Sigcore::Script& evolution)
+void SpeciesUI::on_varEvolution_valueChanged(const Script& evolution)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEvolution(evolution);
+    qobject_cast<Species*>(modified())->setEvolution(evolution);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varTypes_added(QListWidgetItem* item)
+void SpeciesUI::on_varTypes_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setType(item->data(Qt::UserRole).toInt(), true);
+    qobject_cast<Species*>(modified())->setType(item->data(Qt::UserRole).toInt(), true);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varTypes_removed(QListWidgetItem* item)
+void SpeciesUI::on_varTypes_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setType(item->data(Qt::UserRole).toInt(), false);
+    qobject_cast<Species*>(modified())->setType(item->data(Qt::UserRole).toInt(), false);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEggGroups_added(QListWidgetItem* item)
+void SpeciesUI::on_varEggGroups_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEggGroup(item->data(Qt::UserRole).toInt(), true);
+    qobject_cast<Species*>(modified())->setEggGroup(item->data(Qt::UserRole).toInt(), true);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varEggGroups_removed(QListWidgetItem* item)
+void SpeciesUI::on_varEggGroups_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setEggGroup(item->data(Qt::UserRole).toInt(), false);
+    qobject_cast<Species*>(modified())->setEggGroup(item->data(Qt::UserRole).toInt(), false);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varAbilities_added(QListWidgetItem* item)
+void SpeciesUI::on_varAbilities_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), 1);
+    qobject_cast<Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), 1);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varAbilities_removed(QListWidgetItem* item)
+void SpeciesUI::on_varAbilities_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), 0);
+    qobject_cast<Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), 0);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::selectedAbilityChanged(QListWidgetItem* item)
+void SpeciesUI::selectedAbilityChanged(QListWidgetItem* item)
 {
     if (item)
-        varAbilityWeight->setValue(qobject_cast<Sigmod::Species*>(modified())->ability(item->data(Qt::UserRole).toInt()));
+        varAbilityWeight->setValue(qobject_cast<Species*>(modified())->ability(item->data(Qt::UserRole).toInt()));
     else
         varAbilityWeight->setEnabled(false);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varAbilityWeight_valueChanged(const int abilityWeight)
+void SpeciesUI::on_varAbilityWeight_valueChanged(const int abilityWeight)
 {
     QListWidgetItem* item = varAbilities->selectedListWidget()->currentItem();
-    qobject_cast<Sigmod::Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), abilityWeight);
+    qobject_cast<Species*>(modified())->setAbility(item->data(Qt::UserRole).toInt(), abilityWeight);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varItems_added(QListWidgetItem* item)
+void SpeciesUI::on_varItems_added(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 1);
+    qobject_cast<Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 1);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varItems_removed(QListWidgetItem* item)
+void SpeciesUI::on_varItems_removed(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 0);
+    qobject_cast<Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), 0);
     setGui();
 }
 
-void Sigmodr::Widgets::SpeciesUI::selectedItemChanged(QListWidgetItem* item)
+void SpeciesUI::selectedItemChanged(QListWidgetItem* item)
 {
     if (item)
-        varItemWeight->setValue(qobject_cast<Sigmod::Species*>(modified())->item(item->data(Qt::UserRole).toInt()));
+        varItemWeight->setValue(qobject_cast<Species*>(modified())->item(item->data(Qt::UserRole).toInt()));
     else
         varItemWeight->setEnabled(false);
 }
 
-void Sigmodr::Widgets::SpeciesUI::on_varItemWeight_valueChanged(const int itemWeight)
+void SpeciesUI::on_varItemWeight_valueChanged(const int itemWeight)
 {
     QListWidgetItem* item = varItems->selectedListWidget()->currentItem();
-    qobject_cast<Sigmod::Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), itemWeight);
+    qobject_cast<Species*>(modified())->setItem(item->data(Qt::UserRole).toInt(), itemWeight);
     setGui();
 }
diff --git a/sigmodr/widgets/SpriteUI.cpp b/sigmodr/widgets/SpriteUI.cpp
index bd02aea3..ed45faf1 100644
--- a/sigmodr/widgets/SpriteUI.cpp
+++ b/sigmodr/widgets/SpriteUI.cpp
@@ -35,13 +35,16 @@
 #include <QtGui/QLabel>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::SpriteUI::SpriteUI(Sigmod::Sprite* sprite, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+SpriteUI::SpriteUI(Sprite* sprite, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(sprite, new Sigmod::Sprite(*sprite));
+    setObjects(sprite, new Sprite(*sprite));
 }
 
-void Sigmodr::Widgets::SpriteUI::initGui()
+void SpriteUI::initGui()
 {
     QFile file(":/gui/sprite.ui");
     file.open(QFile::ReadOnly);
@@ -55,35 +58,35 @@ void Sigmodr::Widgets::SpriteUI::initGui()
     buttonBrowse->setIcon(KIcon("document-open"));
 }
 
-void Sigmodr::Widgets::SpriteUI::setGui()
+void SpriteUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Sprite*>(modified())->name());
+    ui_name->setText(qobject_cast<Sprite*>(modified())->name());
     QPixmap icon;
-    icon.loadFromData(qobject_cast<Sigmod::Sprite*>(modified())->sprite());
+    icon.loadFromData(qobject_cast<Sprite*>(modified())->sprite());
     ui_sprite->setPixmap(icon);
 }
 
-void Sigmodr::Widgets::SpriteUI::apply()
+void SpriteUI::apply()
 {
-    *qobject_cast<Sigmod::Sprite*>(original()) = *qobject_cast<Sigmod::Sprite*>(modified());
+    *qobject_cast<Sprite*>(original()) = *qobject_cast<Sprite*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SpriteUI::discard()
+void SpriteUI::discard()
 {
-    *qobject_cast<Sigmod::Sprite*>(modified()) = *qobject_cast<Sigmod::Sprite*>(original());
+    *qobject_cast<Sprite*>(modified()) = *qobject_cast<Sprite*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::SpriteUI::nameChanged(const QString& name)
+void SpriteUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Sprite*>(modified())->setName(name);
+    qobject_cast<Sprite*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::SpriteUI::browse()
+void SpriteUI::browse()
 {
     KFileDialog* dialog = new KFileDialog(KUrl("kfiledialog:///image"), "image/png image/jpeg image/tiff image/bmp image/gif", this);
     dialog->setCaption("Use Image File");
@@ -116,7 +119,7 @@ void Sigmodr::Widgets::SpriteUI::browse()
                 QBuffer buffer(&bytes);
                 buffer.open(QIODevice::WriteOnly);
                 image.save(&buffer);
-                qobject_cast<Sigmod::Sprite*>(modified())->setSprite(bytes);
+                qobject_cast<Sprite*>(modified())->setSprite(bytes);
                 setGui();
             }
             if (removeTempFile)
diff --git a/sigmodr/widgets/StatusUI.cpp b/sigmodr/widgets/StatusUI.cpp
index f4b2ae22..bb4b19d0 100644
--- a/sigmodr/widgets/StatusUI.cpp
+++ b/sigmodr/widgets/StatusUI.cpp
@@ -31,13 +31,17 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::StatusUI::StatusUI(Sigmod::Status* status, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+StatusUI::StatusUI(Status* status, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(status, new Sigmod::Status(*status));
+    setObjects(status, new Status(*status));
 }
 
-void Sigmodr::Widgets::StatusUI::initGui()
+void StatusUI::initGui()
 {
     QFile file(":/gui/status.ui");
     file.open(QFile::ReadOnly);
@@ -51,39 +55,39 @@ void Sigmodr::Widgets::StatusUI::initGui()
     connect(ui_worldScript, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(worldScriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::StatusUI::setGui()
+void StatusUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Status*>(modified())->name());
-    ui_battleScript->setValue(qobject_cast<Sigmod::Status*>(modified())->battleScript());
-    ui_worldScript->setValue(qobject_cast<Sigmod::Status*>(modified())->worldScript());
+    ui_name->setText(qobject_cast<Status*>(modified())->name());
+    ui_battleScript->setValue(qobject_cast<Status*>(modified())->battleScript());
+    ui_worldScript->setValue(qobject_cast<Status*>(modified())->worldScript());
 }
 
-void Sigmodr::Widgets::StatusUI::apply()
+void StatusUI::apply()
 {
-    *qobject_cast<Sigmod::Status*>(original()) = *qobject_cast<Sigmod::Status*>(modified());
+    *qobject_cast<Status*>(original()) = *qobject_cast<Status*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::StatusUI::discard()
+void StatusUI::discard()
 {
-    *qobject_cast<Sigmod::Status*>(modified()) = *qobject_cast<Sigmod::Status*>(original());
+    *qobject_cast<Status*>(modified()) = *qobject_cast<Status*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::StatusUI::nameChanged(const QString& name)
+void StatusUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Status*>(modified())->setName(name);
+    qobject_cast<Status*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::StatusUI::battleScriptChanged(const Sigcore::Script& battleScript)
+void StatusUI::battleScriptChanged(const Script& battleScript)
 {
-    qobject_cast<Sigmod::Status*>(modified())->setBattleScript(battleScript);
+    qobject_cast<Status*>(modified())->setBattleScript(battleScript);
 }
 
-void Sigmodr::Widgets::StatusUI::worldScriptChanged(const Sigcore::Script& worldScript)
+void StatusUI::worldScriptChanged(const Script& worldScript)
 {
-    qobject_cast<Sigmod::Status*>(modified())->setWorldScript(worldScript);
+    qobject_cast<Status*>(modified())->setWorldScript(worldScript);
 }
diff --git a/sigmodr/widgets/StoreUI.cpp b/sigmodr/widgets/StoreUI.cpp
index e06efd19..2a0cf763 100644
--- a/sigmodr/widgets/StoreUI.cpp
+++ b/sigmodr/widgets/StoreUI.cpp
@@ -32,13 +32,16 @@
 #include <QtGui/QListWidgetItem>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::StoreUI::StoreUI(Sigmod::Store* store, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+StoreUI::StoreUI(Store* store, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(store, new Sigmod::Store(*store));
+    setObjects(store, new Store(*store));
 }
 
-void Sigmodr::Widgets::StoreUI::initGui()
+void StoreUI::initGui()
 {
     QFile file(":/gui/store.ui");
     file.open(QFile::ReadOnly);
@@ -51,14 +54,14 @@ void Sigmodr::Widgets::StoreUI::initGui()
     connect(ui_items, SIGNAL(removed(QListWidgetItem*)), this, SLOT(itemRemoved(QListWidgetItem*)));
 }
 
-void Sigmodr::Widgets::StoreUI::refreshGui()
+void StoreUI::refreshGui()
 {
     const bool blockedItems = ui_items->blockSignals(true);
     ui_items->availableListWidget()->clear();
     ui_items->selectedListWidget()->clear();
     for (int i = 0; i < game()->itemCount(); ++i)
     {
-        const Sigmod::Item* item = game()->item(i);
+        const Item* item = game()->item(i);
         QListWidgetItem* widgetItem = new QListWidgetItem(item->name(), ui_items->availableListWidget());
         widgetItem->setData(Qt::UserRole, item->id());
     }
@@ -66,53 +69,53 @@ void Sigmodr::Widgets::StoreUI::refreshGui()
     ui_items->setButtonsEnabled();
 }
 
-void Sigmodr::Widgets::StoreUI::setGui()
+void StoreUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Store*>(modified())->name());
+    ui_name->setText(qobject_cast<Store*>(modified())->name());
     for (int i = 0; i < ui_items->availableListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->availableListWidget()->item(i);
-        if (qobject_cast<Sigmod::Store*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (qobject_cast<Store*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->selectedListWidget()->addItem(ui_items->availableListWidget()->takeItem(i--));
     }
     for (int i = 0; i < ui_items->selectedListWidget()->count(); ++i)
     {
         QListWidgetItem* widgetItem = ui_items->selectedListWidget()->item(i);
-        if (!qobject_cast<Sigmod::Store*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
+        if (!qobject_cast<Store*>(modified())->item(widgetItem->data(Qt::UserRole).toInt()))
             ui_items->availableListWidget()->addItem(ui_items->selectedListWidget()->takeItem(i--));
     }
     ui_items->setButtonsEnabled();
 }
 
-void Sigmodr::Widgets::StoreUI::apply()
+void StoreUI::apply()
 {
-    *qobject_cast<Sigmod::Store*>(original()) = *qobject_cast<Sigmod::Store*>(modified());
+    *qobject_cast<Store*>(original()) = *qobject_cast<Store*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::StoreUI::discard()
+void StoreUI::discard()
 {
-    *qobject_cast<Sigmod::Store*>(modified()) = *qobject_cast<Sigmod::Store*>(original());
+    *qobject_cast<Store*>(modified()) = *qobject_cast<Store*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::StoreUI::nameChanged(const QString& name)
+void StoreUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Store*>(modified())->setName(name);
+    qobject_cast<Store*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::StoreUI::itemAdded(QListWidgetItem* item)
+void StoreUI::itemAdded(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Store*>(modified())->setItem(item->data(Qt::UserRole).toInt(), true);
+    qobject_cast<Store*>(modified())->setItem(item->data(Qt::UserRole).toInt(), true);
     setGui();
 }
 
-void Sigmodr::Widgets::StoreUI::itemRemoved(QListWidgetItem* item)
+void StoreUI::itemRemoved(QListWidgetItem* item)
 {
-    qobject_cast<Sigmod::Store*>(modified())->setItem(item->data(Qt::UserRole).toInt(), false);
+    qobject_cast<Store*>(modified())->setItem(item->data(Qt::UserRole).toInt(), false);
     setGui();
 }
 
diff --git a/sigmodr/widgets/TileUI.cpp b/sigmodr/widgets/TileUI.cpp
index 4a457602..59c176e9 100644
--- a/sigmodr/widgets/TileUI.cpp
+++ b/sigmodr/widgets/TileUI.cpp
@@ -34,13 +34,17 @@
 #include <QtGui/QCheckBox>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::TileUI::TileUI(Sigmod::Tile* tile, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+TileUI::TileUI(Tile* tile, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(tile, new Sigmod::Tile(*tile));
+    setObjects(tile, new Tile(*tile));
 }
 
-void Sigmodr::Widgets::TileUI::initGui()
+void TileUI::initGui()
 {
     QFile file(":/gui/tile.ui");
     file.open(QFile::ReadOnly);
@@ -54,39 +58,39 @@ void Sigmodr::Widgets::TileUI::initGui()
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::TileUI::setGui()
+void TileUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Tile*>(modified())->name());
-    ui_walkable->setChecked(qobject_cast<Sigmod::Tile*>(modified())->walkable());
-    ui_script->setValue(qobject_cast<Sigmod::Tile*>(modified())->script());
+    ui_name->setText(qobject_cast<Tile*>(modified())->name());
+    ui_walkable->setChecked(qobject_cast<Tile*>(modified())->walkable());
+    ui_script->setValue(qobject_cast<Tile*>(modified())->script());
 }
 
-void Sigmodr::Widgets::TileUI::apply()
+void TileUI::apply()
 {
-    *qobject_cast<Sigmod::Tile*>(original()) = *qobject_cast<Sigmod::Tile*>(modified());
+    *qobject_cast<Tile*>(original()) = *qobject_cast<Tile*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TileUI::discard()
+void TileUI::discard()
 {
-    *qobject_cast<Sigmod::Tile*>(modified()) = *qobject_cast<Sigmod::Tile*>(original());
+    *qobject_cast<Tile*>(modified()) = *qobject_cast<Tile*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TileUI::nameChanged(const QString& name)
+void TileUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Tile*>(modified())->setName(name);
+    qobject_cast<Tile*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::TileUI::walkableChanged(const bool walkable)
+void TileUI::walkableChanged(const bool walkable)
 {
-    qobject_cast<Sigmod::Tile*>(modified())->setWalkable(walkable);
+    qobject_cast<Tile*>(modified())->setWalkable(walkable);
 }
 
-void Sigmodr::Widgets::TileUI::scriptChanged(const Sigcore::Script& script)
+void TileUI::scriptChanged(const Script& script)
 {
-    qobject_cast<Sigmod::Tile*>(modified())->setScript(script);
+    qobject_cast<Tile*>(modified())->setScript(script);
 }
diff --git a/sigmodr/widgets/TimeUI.cpp b/sigmodr/widgets/TimeUI.cpp
index 928c8cea..3793b5b0 100644
--- a/sigmodr/widgets/TimeUI.cpp
+++ b/sigmodr/widgets/TimeUI.cpp
@@ -32,13 +32,17 @@
 #include <QtGui/QTimeEdit>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::TimeUI::TimeUI(Sigmod::Time* time, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+TimeUI::TimeUI(Time* time, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(time, new Sigmod::Time(*time));
+    setObjects(time, new Time(*time));
 }
 
-void Sigmodr::Widgets::TimeUI::initGui()
+void TimeUI::initGui()
 {
     QFile file(":/gui/time.ui");
     file.open(QFile::ReadOnly);
@@ -52,40 +56,40 @@ void Sigmodr::Widgets::TimeUI::initGui()
     connect(ui_script, SIGNAL(valueChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::TimeUI::setGui()
+void TimeUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Time*>(modified())->name());
-    ui_time->setTime(QTime(qobject_cast<Sigmod::Time*>(modified())->hour(), qobject_cast<Sigmod::Time*>(modified())->minute()));
-    ui_script->setValue(qobject_cast<Sigmod::Time*>(modified())->script());
+    ui_name->setText(qobject_cast<Time*>(modified())->name());
+    ui_time->setTime(QTime(qobject_cast<Time*>(modified())->hour(), qobject_cast<Time*>(modified())->minute()));
+    ui_script->setValue(qobject_cast<Time*>(modified())->script());
 }
 
-void Sigmodr::Widgets::TimeUI::apply()
+void TimeUI::apply()
 {
-    *qobject_cast<Sigmod::Time*>(original()) = *qobject_cast<Sigmod::Time*>(modified());
+    *qobject_cast<Time*>(original()) = *qobject_cast<Time*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TimeUI::discard()
+void TimeUI::discard()
 {
-    *qobject_cast<Sigmod::Time*>(modified()) = *qobject_cast<Sigmod::Time*>(original());
+    *qobject_cast<Time*>(modified()) = *qobject_cast<Time*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TimeUI::nameChanged(const QString& name)
+void TimeUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Time*>(modified())->setName(name);
+    qobject_cast<Time*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::TimeUI::timeChanged(const QTime& time)
+void TimeUI::timeChanged(const QTime& time)
 {
-    qobject_cast<Sigmod::Time*>(modified())->setHour(time.hour());
-    qobject_cast<Sigmod::Time*>(modified())->setMinute(time.minute());
+    qobject_cast<Time*>(modified())->setHour(time.hour());
+    qobject_cast<Time*>(modified())->setMinute(time.minute());
 }
 
-void Sigmodr::Widgets::TimeUI::scriptChanged(const Sigcore::Script& script)
+void TimeUI::scriptChanged(const Script& script)
 {
-    qobject_cast<Sigmod::Time*>(modified())->setScript(script);
+    qobject_cast<Time*>(modified())->setScript(script);
 }
diff --git a/sigmodr/widgets/TrainerUI.cpp b/sigmodr/widgets/TrainerUI.cpp
index 565f6b3f..75e48033 100644
--- a/sigmodr/widgets/TrainerUI.cpp
+++ b/sigmodr/widgets/TrainerUI.cpp
@@ -33,13 +33,16 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::TrainerUI::TrainerUI(Sigmod::Trainer* trainer, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+TrainerUI::TrainerUI(Trainer* trainer, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(trainer, new Sigmod::Trainer(*trainer));
+    setObjects(trainer, new Trainer(*trainer));
 }
 
-void Sigmodr::Widgets::TrainerUI::initGui()
+void TrainerUI::initGui()
 {
     QFile file(":/gui/trainer.ui");
     file.open(QFile::ReadOnly);
@@ -63,14 +66,14 @@ void Sigmodr::Widgets::TrainerUI::initGui()
     connect(ui_itemIntel, SIGNAL(currentIndexChanged(int)), this, SLOT(itemIntelChanged(int)));
     connect(ui_abilityIntel, SIGNAL(currentIndexChanged(int)), this, SLOT(abilityIntelChanged(int)));
     connect(ui_statIntel, SIGNAL(currentIndexChanged(int)), this, SLOT(statIntelChanged(int)));
-    ui_teamIntel->addItems(Sigmod::Trainer::IntelligenceStr);
-    ui_moveIntel->addItems(Sigmod::Trainer::IntelligenceStr);
-    ui_itemIntel->addItems(Sigmod::Trainer::IntelligenceStr);
-    ui_abilityIntel->addItems(Sigmod::Trainer::IntelligenceStr);
-    ui_statIntel->addItems(Sigmod::Trainer::IntelligenceStr);
+    ui_teamIntel->addItems(Trainer::IntelligenceStr);
+    ui_moveIntel->addItems(Trainer::IntelligenceStr);
+    ui_itemIntel->addItems(Trainer::IntelligenceStr);
+    ui_abilityIntel->addItems(Trainer::IntelligenceStr);
+    ui_statIntel->addItems(Trainer::IntelligenceStr);
 }
 
-void Sigmodr::Widgets::TrainerUI::refreshGui()
+void TrainerUI::refreshGui()
 {
     for (int i = 0; i < game()->skinCount(); ++i)
         ui_skin->addItem(game()->skin(i)->name());
@@ -78,74 +81,74 @@ void Sigmodr::Widgets::TrainerUI::refreshGui()
     ui_abilityIntel->setEnabled(game()->rules()->maxAbilities());
 }
 
-void Sigmodr::Widgets::TrainerUI::setGui()
+void TrainerUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Trainer*>(modified())->name());
-    ui_moneyFactor->setValue(qobject_cast<Sigmod::Trainer*>(modified())->moneyFactor());
-    ui_skin->setCurrentIndex(game()->skinIndex(qobject_cast<Sigmod::Trainer*>(modified())->skin()));
-    ui_depth->setValue(qobject_cast<Sigmod::Trainer*>(modified())->depth());
-    ui_teamIntel->setCurrentIndex(qobject_cast<Sigmod::Trainer*>(modified())->teamIntel());
-    ui_moveIntel->setCurrentIndex(qobject_cast<Sigmod::Trainer*>(modified())->moveIntel());
-    ui_itemIntel->setCurrentIndex(qobject_cast<Sigmod::Trainer*>(modified())->itemIntel());
-    ui_abilityIntel->setCurrentIndex(qobject_cast<Sigmod::Trainer*>(modified())->abilityIntel());
-    ui_statIntel->setCurrentIndex(qobject_cast<Sigmod::Trainer*>(modified())->statIntel());
+    ui_name->setText(qobject_cast<Trainer*>(modified())->name());
+    ui_moneyFactor->setValue(qobject_cast<Trainer*>(modified())->moneyFactor());
+    ui_skin->setCurrentIndex(game()->skinIndex(qobject_cast<Trainer*>(modified())->skin()));
+    ui_depth->setValue(qobject_cast<Trainer*>(modified())->depth());
+    ui_teamIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->teamIntel());
+    ui_moveIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->moveIntel());
+    ui_itemIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->itemIntel());
+    ui_abilityIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->abilityIntel());
+    ui_statIntel->setCurrentIndex(qobject_cast<Trainer*>(modified())->statIntel());
 }
 
-void Sigmodr::Widgets::TrainerUI::apply()
+void TrainerUI::apply()
 {
-    *qobject_cast<Sigmod::Trainer*>(original()) = *qobject_cast<Sigmod::Trainer*>(modified());
+    *qobject_cast<Trainer*>(original()) = *qobject_cast<Trainer*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TrainerUI::discard()
+void TrainerUI::discard()
 {
-    *qobject_cast<Sigmod::Trainer*>(modified()) = *qobject_cast<Sigmod::Trainer*>(original());
+    *qobject_cast<Trainer*>(modified()) = *qobject_cast<Trainer*>(original());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TrainerUI::nameChanged(const QString& name)
+void TrainerUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Trainer*>(modified())->setName(name);
+    qobject_cast<Trainer*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::TrainerUI::moneyFactorChanged(const int moneyFactor)
+void TrainerUI::moneyFactorChanged(const int moneyFactor)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setMoneyFactor(moneyFactor);
+    qobject_cast<Trainer*>(modified())->setMoneyFactor(moneyFactor);
 }
 
-void Sigmodr::Widgets::TrainerUI::skinChanged(const int skin)
+void TrainerUI::skinChanged(const int skin)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setSkin(game()->skin(skin)->id());
+    qobject_cast<Trainer*>(modified())->setSkin(game()->skin(skin)->id());
 }
 
-void Sigmodr::Widgets::TrainerUI::depthChanged(const int depth)
+void TrainerUI::depthChanged(const int depth)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setDepth(depth);
+    qobject_cast<Trainer*>(modified())->setDepth(depth);
 }
 
-void Sigmodr::Widgets::TrainerUI::teamIntelChanged(const int teamIntel)
+void TrainerUI::teamIntelChanged(const int teamIntel)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setTeamIntel(static_cast<Sigmod::Trainer::Intelligence>(teamIntel));
+    qobject_cast<Trainer*>(modified())->setTeamIntel(static_cast<Trainer::Intelligence>(teamIntel));
 }
 
-void Sigmodr::Widgets::TrainerUI::moveIntelChanged(const int moveIntel)
+void TrainerUI::moveIntelChanged(const int moveIntel)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setMoveIntel(static_cast<Sigmod::Trainer::Intelligence>(moveIntel));
+    qobject_cast<Trainer*>(modified())->setMoveIntel(static_cast<Trainer::Intelligence>(moveIntel));
 }
 
-void Sigmodr::Widgets::TrainerUI::itemIntelChanged(const int itemIntel)
+void TrainerUI::itemIntelChanged(const int itemIntel)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setItemIntel(static_cast<Sigmod::Trainer::Intelligence>(itemIntel));
+    qobject_cast<Trainer*>(modified())->setItemIntel(static_cast<Trainer::Intelligence>(itemIntel));
 }
 
-void Sigmodr::Widgets::TrainerUI::abilityIntelChanged(const int abilityIntel)
+void TrainerUI::abilityIntelChanged(const int abilityIntel)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setAbilityIntel(static_cast<Sigmod::Trainer::Intelligence>(abilityIntel));
+    qobject_cast<Trainer*>(modified())->setAbilityIntel(static_cast<Trainer::Intelligence>(abilityIntel));
 }
 
-void Sigmodr::Widgets::TrainerUI::statIntelChanged(const int statIntel)
+void TrainerUI::statIntelChanged(const int statIntel)
 {
-    qobject_cast<Sigmod::Trainer*>(modified())->setStatIntel(static_cast<Sigmod::Trainer::Intelligence>(statIntel));
+    qobject_cast<Trainer*>(modified())->setStatIntel(static_cast<Trainer::Intelligence>(statIntel));
 }
diff --git a/sigmodr/widgets/TypeUI.cpp b/sigmodr/widgets/TypeUI.cpp
index 966516f4..2b0e8a39 100644
--- a/sigmodr/widgets/TypeUI.cpp
+++ b/sigmodr/widgets/TypeUI.cpp
@@ -31,13 +31,17 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::TypeUI::TypeUI(Sigmod::Type* type, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+TypeUI::TypeUI(Type* type, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(type, new Sigmod::Type(*type));
+    setObjects(type, new Type(*type));
 }
 
-void Sigmodr::Widgets::TypeUI::initGui()
+void TypeUI::initGui()
 {
     QFile file(":/gui/type.ui");
     file.open(QFile::ReadOnly);
@@ -49,33 +53,33 @@ void Sigmodr::Widgets::TypeUI::initGui()
     connect(ui_stab, SIGNAL(valueChanged(Sigcore::Fraction)), this, SLOT(stabChanged(Sigcore::Fraction)));
 }
 
-void Sigmodr::Widgets::TypeUI::setGui()
+void TypeUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Type*>(modified())->name());
-    ui_stab->setValue(qobject_cast<Sigmod::Type*>(modified())->stab());
+    ui_name->setText(qobject_cast<Type*>(modified())->name());
+    ui_stab->setValue(qobject_cast<Type*>(modified())->stab());
 }
 
-void Sigmodr::Widgets::TypeUI::apply()
+void TypeUI::apply()
 {
-    *qobject_cast<Sigmod::Type*>(original()) = *qobject_cast<Sigmod::Type*>(modified());
+    *qobject_cast<Type*>(original()) = *qobject_cast<Type*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TypeUI::discard()
+void TypeUI::discard()
 {
-    *qobject_cast<Sigmod::Type*>(modified()) = *qobject_cast<Sigmod::Type*>(original());
+    *qobject_cast<Type*>(modified()) = *qobject_cast<Type*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::TypeUI::nameChanged(const QString& name)
+void TypeUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Type*>(modified())->setName(name);
+    qobject_cast<Type*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::TypeUI::stabChanged(const Sigcore::Fraction& stab)
+void TypeUI::stabChanged(const Fraction& stab)
 {
-    qobject_cast<Sigmod::Type*>(modified())->setStab(stab);
+    qobject_cast<Type*>(modified())->setStab(stab);
 }
diff --git a/sigmodr/widgets/TypechartModel.cpp b/sigmodr/widgets/TypechartModel.cpp
index 822cc92e..07d61a2b 100644
--- a/sigmodr/widgets/TypechartModel.cpp
+++ b/sigmodr/widgets/TypechartModel.cpp
@@ -21,14 +21,17 @@
 // KDE includes
 #include <KColorScheme>
 
-Sigmodr::Widgets::TypechartModel::TypechartModel(Sigcore::Matrix<Sigcore::Fraction>* typechart, const QStringList& types) :
+using namespace Sigcore;
+using namespace Sigmodr::Widgets;
+
+TypechartModel::TypechartModel(Matrix<Fraction>* typechart, const QStringList& types) :
         QAbstractTableModel(),
         m_typechart(*typechart),
         m_types(types)
 {
 }
 
-QVariant Sigmodr::Widgets::TypechartModel::data(const QModelIndex& index, int role) const
+QVariant TypechartModel::data(const QModelIndex& index, int role) const
 {
     if (!index.isValid())
         return QVariant();
@@ -49,7 +52,7 @@ QVariant Sigmodr::Widgets::TypechartModel::data(const QModelIndex& index, int ro
     return QVariant();
 }
 
-QVariant Sigmodr::Widgets::TypechartModel::headerData(int section, Qt::Orientation orientation, int role) const
+QVariant TypechartModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
     Q_UNUSED(orientation)
     if (role == Qt::DisplayRole)
@@ -57,34 +60,34 @@ QVariant Sigmodr::Widgets::TypechartModel::headerData(int section, Qt::Orientati
     return QVariant();
 }
 
-int Sigmodr::Widgets::TypechartModel::rowCount(const QModelIndex& parent) const
+int TypechartModel::rowCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent)
     return m_typechart.height();
 }
 
-int Sigmodr::Widgets::TypechartModel::columnCount(const QModelIndex& parent) const
+int TypechartModel::columnCount(const QModelIndex& parent) const
 {
     Q_UNUSED(parent)
     return m_typechart.width();
 }
 
-Qt::ItemFlags Sigmodr::Widgets::TypechartModel::flags(const QModelIndex& index) const
+Qt::ItemFlags TypechartModel::flags(const QModelIndex& index) const
 {
     if (!index.isValid())
         return 0;
     return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 }
 
-bool Sigmodr::Widgets::TypechartModel::setData(const QModelIndex& index, const QVariant& value, int role)
+bool TypechartModel::setData(const QModelIndex& index, const QVariant& value, int role)
 {
     if (!index.isValid())
         return false;
     if (role == Qt::EditRole)
     {
-        if (value.canConvert<Sigcore::Fraction>())
+        if (value.canConvert<Fraction>())
         {
-            m_typechart(index.row(), index.column()) = value.value<Sigcore::Fraction>();
+            m_typechart(index.row(), index.column()) = value.value<Fraction>();
             emit(dataChanged(index, index));
             return true;
         }
@@ -92,7 +95,7 @@ bool Sigmodr::Widgets::TypechartModel::setData(const QModelIndex& index, const Q
     return false;
 }
 
-void Sigmodr::Widgets::TypechartModel::discarded()
+void TypechartModel::discarded()
 {
     emit(reset());
 }
diff --git a/sigmodr/widgets/ValidationDialog.cpp b/sigmodr/widgets/ValidationDialog.cpp
index d2dcc308..02d9ea82 100644
--- a/sigmodr/widgets/ValidationDialog.cpp
+++ b/sigmodr/widgets/ValidationDialog.cpp
@@ -31,7 +31,10 @@
 #include <QtGui/QTreeWidget>
 #include <QtGui/QVBoxLayout>
 
-Sigmodr::Widgets::ValidationDialog::ValidationDialog(Sigmod::Object* object, QWidget* parent) :
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+ValidationDialog::ValidationDialog(Object* object, QWidget* parent) :
         QWidget(parent),
         m_processed(false),
         m_object(object),
@@ -40,17 +43,17 @@ Sigmodr::Widgets::ValidationDialog::ValidationDialog(Sigmod::Object* object, QWi
     connect(m_object, SIGNAL(changed()), this, SLOT(objectChanged()));
 }
 
-int Sigmodr::Widgets::ValidationDialog::errors() const
+int ValidationDialog::errors() const
 {
     return m_errors;
 }
 
-int Sigmodr::Widgets::ValidationDialog::warnings() const
+int ValidationDialog::warnings() const
 {
     return m_warnings;
 }
 
-void Sigmodr::Widgets::ValidationDialog::process()
+void ValidationDialog::process()
 {
     if (!m_processed)
     {
@@ -78,7 +81,7 @@ void Sigmodr::Widgets::ValidationDialog::process()
     m_processed = true;
 }
 
-void Sigmodr::Widgets::ValidationDialog::show()
+void ValidationDialog::show()
 {
     if (!m_processed)
         process();
@@ -101,14 +104,14 @@ void Sigmodr::Widgets::ValidationDialog::show()
         KMessageBox::information(this, "No messages", "Validation");
 }
 
-void Sigmodr::Widgets::ValidationDialog::insertMessage(const QString& msg, const QBrush& brush)
+void ValidationDialog::insertMessage(const QString& msg, const QBrush& brush)
 {
     ++m_parents.top().second;
     QTreeWidgetItem* item = new QTreeWidgetItem(m_parents.top().first, QStringList(msg));
     item->setBackground(0, brush);
 }
 
-void Sigmodr::Widgets::ValidationDialog::addMessage(const QString& msg)
+void ValidationDialog::addMessage(const QString& msg)
 {
     if (msg.startsWith(QString("++")))
         m_parents.push(ObjectErrorCount(new QTreeWidgetItem(QStringList(msg.mid(2))), 0));
@@ -125,19 +128,19 @@ void Sigmodr::Widgets::ValidationDialog::addMessage(const QString& msg)
         insertMessage(msg, KStatefulBrush(KColorScheme::View, KColorScheme::PositiveBackground).brush(QPalette::Normal));
 }
 
-void Sigmodr::Widgets::ValidationDialog::addError(const QString& msg)
+void ValidationDialog::addError(const QString& msg)
 {
     insertMessage(msg, KStatefulBrush(KColorScheme::View, KColorScheme::NegativeBackground).brush(QPalette::Normal));
     ++m_errors;
 }
 
-void Sigmodr::Widgets::ValidationDialog::addWarning(const QString& msg)
+void ValidationDialog::addWarning(const QString& msg)
 {
     insertMessage(msg, KStatefulBrush(KColorScheme::View, KColorScheme::NeutralBackground).brush(QPalette::Normal));
     ++m_warnings;
 }
 
-void Sigmodr::Widgets::ValidationDialog::objectChanged()
+void ValidationDialog::objectChanged()
 {
     m_processed = false;
 }
diff --git a/sigmodr/widgets/WeatherUI.cpp b/sigmodr/widgets/WeatherUI.cpp
index 38ab41a8..537477a8 100644
--- a/sigmodr/widgets/WeatherUI.cpp
+++ b/sigmodr/widgets/WeatherUI.cpp
@@ -31,13 +31,17 @@
 #include <QtCore/QFile>
 #include <QtUiTools/QUiLoader>
 
-Sigmodr::Widgets::WeatherUI::WeatherUI(Sigmod::Weather* weather, QWidget* parent) :
+using namespace Sigcore;
+using namespace Sigmod;
+using namespace Sigmodr::Widgets;
+
+WeatherUI::WeatherUI(Weather* weather, QWidget* parent) :
         ObjectUI(parent)
 {
-    setObjects(weather, new Sigmod::Weather(*weather));
+    setObjects(weather, new Weather(*weather));
 }
 
-void Sigmodr::Widgets::WeatherUI::initGui()
+void WeatherUI::initGui()
 {
     QFile file(":/gui/weather.ui");
     file.open(QFile::ReadOnly);
@@ -49,33 +53,33 @@ void Sigmodr::Widgets::WeatherUI::initGui()
     connect(ui_script, SIGNAL(scriptChanged(Sigcore::Script)), this, SLOT(scriptChanged(Sigcore::Script)));
 }
 
-void Sigmodr::Widgets::WeatherUI::setGui()
+void WeatherUI::setGui()
 {
-    ui_name->setText(qobject_cast<Sigmod::Weather*>(modified())->name());
-    ui_script->setValue(qobject_cast<Sigmod::Weather*>(modified())->script());
+    ui_name->setText(qobject_cast<Weather*>(modified())->name());
+    ui_script->setValue(qobject_cast<Weather*>(modified())->script());
 }
 
-void Sigmodr::Widgets::WeatherUI::apply()
+void WeatherUI::apply()
 {
-    *qobject_cast<Sigmod::Weather*>(original()) = *qobject_cast<Sigmod::Weather*>(modified());
+    *qobject_cast<Weather*>(original()) = *qobject_cast<Weather*>(modified());
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::WeatherUI::discard()
+void WeatherUI::discard()
 {
-    *qobject_cast<Sigmod::Weather*>(modified()) = *qobject_cast<Sigmod::Weather*>(original());
+    *qobject_cast<Weather*>(modified()) = *qobject_cast<Weather*>(original());
     setGui();
     emit(changed(false));
 }
 
-void Sigmodr::Widgets::WeatherUI::nameChanged(const QString& name)
+void WeatherUI::nameChanged(const QString& name)
 {
     const int cursor = ui_name->cursorPosition();
-    qobject_cast<Sigmod::Weather*>(modified())->setName(name);
+    qobject_cast<Weather*>(modified())->setName(name);
     ui_name->setCursorPosition(cursor);
 }
 
-void Sigmodr::Widgets::WeatherUI::scriptChanged(const Sigcore::Script& script)
+void WeatherUI::scriptChanged(const Script& script)
 {
-    qobject_cast<Sigmod::Weather*>(modified())->setScript(script);
+    qobject_cast<Weather*>(modified())->setScript(script);
 }