[FIX] Added a static poll method to Fraction

[FIX] More Arena stuff fleshed out
[FIX] Added priority scripts to Ability and Move
[FIX] A SigmodWrapper pointer is now passed around the containments
[FIX] Config now has templated methods for retrieving values

git-svn-id: https://pokegen.svn.sourceforge.net/svnroot/pokegen/trunk@253 6ecfd1a5-f3ed-3746-8530-beee90d26b22

15 files changed, 198 insertions, 117 deletions

diff --git a/sigbattle/ATBArena.cpp b/sigbattle/ATBArena.cpp
index 693ac4f3..12ca823a 100644
--- a/sigbattle/ATBArena.cpp
+++ b/sigbattle/ATBArena.cpp
@@ -24,8 +24,8 @@
 // Qt includes
 #include <QtCore/QTimer>
 
-Sigbattle::ATBArena::ATBArena(QList<Player*> players, const bool isWild, QObject* parent) :
-        Arena(players, isWild, parent)
+Sigbattle::ATBArena::ATBArena(Sigscript::SigmodWrapper* sigmod, QList<Player*> players, const bool isWild, QObject* parent) :
+        Arena(sigmod, players, isWild, parent)
 {
     setupBattle();
 }
@@ -50,6 +50,10 @@ void Sigbattle::ATBArena::processActions()
             handleAction(action.first, action.second.result());
         }
     }
+    if (numActiveTeams() <= 1)
+    {
+        // TODO: end battle
+    }
 }
 
 void Sigbattle::ATBArena::setupBattle()
diff --git a/sigbattle/ATBArena.h b/sigbattle/ATBArena.h
index 0736ea14..1140e8d0 100644
--- a/sigbattle/ATBArena.h
+++ b/sigbattle/ATBArena.h
@@ -32,7 +32,7 @@ class SIGBATTLE_EXPORT ATBArena : public Arena
     Q_OBJECT
     
     public:
-        ATBArena(QList<Player*> players, const bool isWild, QObject* parent);
+        ATBArena(Sigscript::SigmodWrapper* sigmod, QList<Player*> players, const bool isWild, QObject* parent);
         
         void handleAction(TeamMember* teamMember, TeamMember::Action action);
     signals:
diff --git a/sigbattle/Arena.cpp b/sigbattle/Arena.cpp
index 293619d0..6ede9fba 100644
--- a/sigbattle/Arena.cpp
+++ b/sigbattle/Arena.cpp
@@ -50,9 +50,10 @@ Sigbattle::TeamMember::Action Sigbattle::decision(TeamMember* teamMember)
     return teamMember->requestAction();
 }
 
-Sigbattle::Arena::Arena(QList<Player*> players, const bool isWild, QObject* parent) :
+Sigbattle::Arena::Arena(Sigscript::SigmodWrapper* sigmod, QList<Player*> players, const bool isWild, QObject* parent) :
         Sigscript::Config(parent),
-                          m_isWild(isWild),
+        m_sigmod(sigmod),
+        m_isWild(isWild),
         m_players(players),
         m_id(QUuid::createUuid())
 {
@@ -85,16 +86,19 @@ int Sigbattle::Arena::numActiveTeams() const
 
 Sigscript::SigmodWrapper* Sigbattle::Arena::sigmod() const
 {
-    // TODO: return sigmod
+    return m_sigmod;
 }
 
 void Sigbattle::Arena::registerScript(const Sigmod::Script& script)
 {
-    Kross::Action* action = new Kross::Action(m_actions, QUuid::createUuid().toString());
-    action->setInterpreter(script.interpreter());
-    action->setCode(script.script().toUtf8());
-    action->addObject(this, "arena");
-    action->trigger();
+    if (!script.script().isEmpty())
+    {
+        Kross::Action* action = new Kross::Action(m_actions, QUuid::createUuid().toString());
+        action->setInterpreter(script.interpreter());
+        action->setCode(script.script().toUtf8());
+        action->addObject(this, "arena");
+        action->trigger();
+    }
 }
 
 void Sigbattle::Arena::cleanUp()
@@ -114,15 +118,18 @@ void Sigbattle::Arena::handleAction(TeamMember* teamMember, TeamMember::Action a
             Sigscript::MoveWrapper* move = sigmod()->move(data.first.toInt());
             if (move)
             {
-                Sigmod::Script script = move->battleScript();
-                Kross::Action* kaction = new Kross::Action(m_actions, QUuid::createUuid().toString());
-                kaction->setInterpreter(script.interpreter());
-                kaction->setCode(script.script().toUtf8());
-                kaction->addObject(this, "arena");
-                kaction->addObject(teamMember, "user");
-                for (int i = 0; i < data.second.size(); ++i)
-                    kaction->addObject(findMember(data.second[i]), QString("target%1").arg(i));
-                kaction->trigger();
+                const Sigmod::Script script = move->battleScript();
+                if (!script.script().isEmpty())
+                {
+                    Kross::Action* kaction = new Kross::Action(m_actions, QUuid::createUuid().toString());
+                    kaction->setInterpreter(script.interpreter());
+                    kaction->setCode(script.script().toUtf8());
+                    kaction->addObject(this, "arena");
+                    kaction->addObject(teamMember, "user");
+                    for (int i = 0; i < data.second.size(); ++i)
+                        kaction->addObject(findMember(data.second[i]), QString("target%1").arg(i));
+                    kaction->trigger();
+                }
             }
             break;
         }
@@ -131,13 +138,16 @@ void Sigbattle::Arena::handleAction(TeamMember* teamMember, TeamMember::Action a
             Sigscript::ItemWrapper* item = sigmod()->item(data.first.toInt());
             if (item)
             {
-                Sigmod::Script script = item->script();
-                Kross::Action* kaction = new Kross::Action(m_actions, QUuid::createUuid().toString());
-                kaction->setInterpreter(script.interpreter());
-                kaction->setCode(script.script().toUtf8());
-                kaction->addObject(this, "arena");
-                kaction->addObject(findMember(data.second[0]), "target");
-                kaction->trigger();
+                const Sigmod::Script script = item->script();
+                if (!script.script().isEmpty())
+                {
+                    Kross::Action* kaction = new Kross::Action(m_actions, QUuid::createUuid().toString());
+                    kaction->setInterpreter(script.interpreter());
+                    kaction->setCode(script.script().toUtf8());
+                    kaction->addObject(this, "arena");
+                    kaction->addObject(findMember(data.second[0]), "target");
+                    kaction->trigger();
+                }
             }
             break;
         }
diff --git a/sigbattle/Arena.h b/sigbattle/Arena.h
index aac9c8ee..0e3e3bcd 100644
--- a/sigbattle/Arena.h
+++ b/sigbattle/Arena.h
@@ -54,7 +54,6 @@ class SIGBATTLE_EXPORT Arena : public Sigscript::Config
     Q_OBJECT
     
     public:
-        Arena(QList<Player*> players, const bool isWild, QObject* parent);
         ~Arena();
         
         QList<TeamMember*> active() const;
@@ -69,14 +68,16 @@ class SIGBATTLE_EXPORT Arena : public Sigscript::Config
     protected slots:
         void cleanUp();
     protected:
+        Arena(Sigscript::SigmodWrapper* sigmod, QList<Player*> players, const bool isWild, QObject* parent);
+        
         virtual void handleAction(TeamMember* teamMember, TeamMember::Action action);
         
         virtual void setupBattle();
         
         TeamMember* findMember(const QUuid& id);
         
-        const bool m_isWild;
         Sigscript::SigmodWrapper* m_sigmod;
+        const bool m_isWild;
         QList<Player*> m_players;
         Kross::ActionCollection* m_actions;
     private:
diff --git a/sigbattle/Containment.cpp b/sigbattle/Containment.cpp
index f9f64d11..6e39b195 100644
--- a/sigbattle/Containment.cpp
+++ b/sigbattle/Containment.cpp
@@ -21,8 +21,13 @@
 // Sigbattle includes
 #include "TeamMember.h"
 
-Sigbattle::Containment::Containment(QObject* parent) :
-        QObject(parent)
+// Sigscript includes
+#include "../sigscript/RulesWrapper.h"
+#include "../sigscript/SigmodWrapper.h"
+
+Sigbattle::Containment::Containment(Sigscript::SigmodWrapper* sigmod, QObject* parent) :
+        QObject(parent),
+        m_sigmod(sigmod)
 {
 }
 
@@ -31,6 +36,17 @@ QList<Sigbattle::TeamMember*> Sigbattle::Containment::members() const
     return m_members;
 }
 
+bool Sigbattle::Containment::addMember(TeamMember* member)
+{
+    if (m_members.size() < sigmod()->rules()->maxParty())
+    {
+        m_members.append(member);
+//         member->reparent(this);
+        return true;
+    }
+    return false;
+}
+
 Sigbattle::TeamMember* Sigbattle::Containment::findMember(const QUuid& id) const
 {
     foreach (TeamMember* member, m_members)
@@ -43,5 +59,5 @@ Sigbattle::TeamMember* Sigbattle::Containment::findMember(const QUuid& id) const
 
 Sigscript::SigmodWrapper* Sigbattle::Containment::sigmod() const
 {
-    // TODO: return SigmodWrapper
+    return m_sigmod;
 }
diff --git a/sigbattle/Containment.h b/sigbattle/Containment.h
index 4c683049..fcec1ca2 100644
--- a/sigbattle/Containment.h
+++ b/sigbattle/Containment.h
@@ -41,9 +41,10 @@ class SIGBATTLE_EXPORT Containment : public QObject
     Q_OBJECT
     
     public:
-        Containment(QObject* parent);
+        Containment(Sigscript::SigmodWrapper* sigmod, QObject* parent);
         
         QList<TeamMember*> members() const;
+        bool addMember(TeamMember* member);
         
         virtual bool isMutable() const = 0;
         
@@ -54,6 +55,7 @@ class SIGBATTLE_EXPORT Containment : public QObject
     public slots:
     protected slots:
     protected:
+        Sigscript::SigmodWrapper* m_sigmod;
         QList<TeamMember*> m_members;
 };
 }
diff --git a/sigbattle/Player.cpp b/sigbattle/Player.cpp
index b759e6d1..8fff4b74 100644
--- a/sigbattle/Player.cpp
+++ b/sigbattle/Player.cpp
@@ -22,8 +22,8 @@
 #include "../sigscript/RulesWrapper.h"
 #include "../sigscript/SigmodWrapper.h"
 
-Sigbattle::Player::Player(QObject* parent) :
-        Team(parent),
+Sigbattle::Player::Player(Sigscript::SigmodWrapper* sigmod, QObject* parent) :
+        Team(sigmod, parent),
         m_arena(NULL)
 {
 }
@@ -31,33 +31,32 @@ Sigbattle::Player::Player(QObject* parent) :
 void Sigbattle::Player::enterArena(Arena* arena)
 {
     m_arena = arena;
-    QList<TeamMember*> activeMembers = active();
-    foreach (TeamMember* member, activeMembers)
+    for (int i = 0; (m_active.size() < sigmod()->rules()->maxFight()) && (i < m_members.size()); ++i)
+    {
+        if (m_members[i]->currentHp())
+            m_active.append(m_members[i]);
+    }
+    foreach (TeamMember* member, m_active)
         member->makeActive(arena);
 }
 
 QList<Sigbattle::TeamMember*> Sigbattle::Player::active()
 {
-    // TODO: There are edge cases not considered here
-    QList<TeamMember*> activeMembers;
-    for (int i = 0; (i < sigmod()->rules()->maxFight()) && (i < m_members.size()); ++i)
-    {
-        if (m_members[i]->currentHp())
-            activeMembers.append(m_members[i]);
-    }
-    return activeMembers;
+    return m_active;
 }
 
 void Sigbattle::Player::switchOut(TeamMember* oldActive, TeamMember* newActive)
 {
-    oldActive->makeActive(m_arena);
-    // TODO: Update active table
+    oldActive->leaveArena();
+    newActive->makeActive(m_arena);
+    m_active.removeAll(oldActive);
+    m_active.append(newActive);
 }
 
 void Sigbattle::Player::exitArena()
 {
-    QList<TeamMember*> activeMembers = active();
-    foreach (TeamMember* member, activeMembers)
+    foreach (TeamMember* member, m_active)
         member->leaveArena();
+    m_active.clear();
     m_arena = NULL;
 }
diff --git a/sigbattle/Player.h b/sigbattle/Player.h
index f46ea2ed..69d85bd7 100644
--- a/sigbattle/Player.h
+++ b/sigbattle/Player.h
@@ -41,7 +41,7 @@ class SIGBATTLE_EXPORT Player : public Team
     Q_OBJECT
     
     public:
-        Player(QObject* parent);
+        Player(Sigscript::SigmodWrapper* sigmod, QObject* parent);
         
         void enterArena(Arena* arena);
         
@@ -55,6 +55,7 @@ class SIGBATTLE_EXPORT Player : public Team
         virtual TeamMember::Action requestAction(const TeamMember* teamMember) const = 0;
     protected slots:
     protected:
+        QList<TeamMember*> m_active;
         Arena* m_arena;
 };
 }
diff --git a/sigbattle/TODO b/sigbattle/TODO
index b9357c4b..317f7489 100644
--- a/sigbattle/TODO
+++ b/sigbattle/TODO
@@ -1 +1,3 @@
 Put global scripts into requesting for things
+
+Put in signals where necessary
diff --git a/sigbattle/Team.cpp b/sigbattle/Team.cpp
index 91aea643..9338b3c8 100644
--- a/sigbattle/Team.cpp
+++ b/sigbattle/Team.cpp
@@ -18,8 +18,8 @@
 // Header include
 #include "Team.h"
 
-Sigbattle::Team::Team(QObject* parent) :
-        Containment(parent)
+Sigbattle::Team::Team(Sigscript::SigmodWrapper* sigmod, QObject* parent) :
+        Containment(sigmod, parent)
 {
     // TODO: construct
 }
diff --git a/sigbattle/Team.h b/sigbattle/Team.h
index fdb359eb..9522a44f 100644
--- a/sigbattle/Team.h
+++ b/sigbattle/Team.h
@@ -31,7 +31,7 @@ class SIGBATTLE_EXPORT Team : public Containment
     Q_OBJECT
     
     public:
-        Team(QObject* parent);
+        Team(Sigscript::SigmodWrapper* sigmod, QObject* parent);
         
         virtual bool isMutable() const;
     signals:
diff --git a/sigbattle/TeamMember.cpp b/sigbattle/TeamMember.cpp
index 2669dd6c..c8e3042a 100644
--- a/sigbattle/TeamMember.cpp
+++ b/sigbattle/TeamMember.cpp
@@ -51,15 +51,14 @@
 // C includes
 #include <cmath>
 
-// TODO: Current HP
-// TODO: Script cleanup (battle)
-
 int Sigbattle::actionPriority(const TeamMember* teamMember, const TeamMember::Action& action)
 {
     int priority = INT_MAX;
     switch (action.first)
     {
         case TeamMember::Attack:
+            if (teamMember->hasValueOfType<int>("priority"))
+                
             priority = teamMember->sigmod()->move(action.second.first.toString())->priority();
             break;
         case TeamMember::Item:
@@ -111,11 +110,14 @@ Sigbattle::TeamMember::TeamMember(const int speciesId, const QString& name, cons
     if (m_containment->isMutable())
     {
         const Sigmod::Script script = m_species->evolution();
-        Kross::Action* evolution = new Kross::Action(Kross::Manager::self().actionCollection()->collection("evolutions"), QString("evolution-%1").arg(QUuid::createUuid().toString()));
-        evolution->setInterpreter(script.interpreter());
-        evolution->setCode(script.script().toUtf8());
-        evolution->addObject(this, "owner", Kross::ChildrenInterface::AutoConnectSignals);
-        evolution->trigger();
+        if (!script.script().isEmpty())
+        {
+            Kross::Action* evolution = new Kross::Action(Kross::Manager::self().actionCollection()->collection("evolutions"), QUuid::createUuid().toString());
+            evolution->setInterpreter(script.interpreter());
+            evolution->setCode(script.script().toUtf8());
+            evolution->addObject(this, "owner");
+            evolution->trigger();
+        }
     }
     m_currentHp = statValue(Sigmod::ST_HP);
 }
@@ -155,8 +157,8 @@ QUuid Sigbattle::TeamMember::id() const
 
 QString Sigbattle::TeamMember::name() const
 {
-    if (value("name").canConvert<QString>())
-        return value("name").toString();
+    if (hasValueOfType<QString>("name"))
+        return valueOfType<QString>("name");
     return m_name;
 }
 
@@ -167,8 +169,8 @@ long long Sigbattle::TeamMember::currentHp() const
 
 Sigscript::SpeciesWrapper* Sigbattle::TeamMember::species() const
 {
-    if (value("species").canConvert<Sigscript::SpeciesWrapper*>())
-        return value("species").value<Sigscript::SpeciesWrapper*>();
+    if (hasValueOfType<Sigscript::SpeciesWrapper*>("species"))
+        return valueOfType<Sigscript::SpeciesWrapper*>("species");
     return m_species;
 }
 
@@ -179,21 +181,21 @@ int Sigbattle::TeamMember::level() const
 
 Sigbattle::TeamMember::Gender Sigbattle::TeamMember::gender() const
 {
-    if (value("gender").canConvert<Gender>())
-        return value("gender").value<Gender>();
+    if (hasValueOfType<Gender>("gender"))
+        return valueOfType<Gender>("gender");
     return m_gender;
 }
 
 long long Sigbattle::TeamMember::levelExperience() const
 {
-    if (value("levelExperience").canConvert<long long>())
-        return value("levelExperience").toLongLong();
+    if (hasValueOfType<long long>("levelExperience"))
+        return valueOfType<long long>("levelExperience");
     return m_levelExp;
 }
 
 int Sigbattle::TeamMember::baseStat(const Sigmod::Stat stat) const
 {
-    if (value("overrideBaseStats").canConvert<bool>() && value("overrideBaseStats").toBool())
+    if (hasValueOfType<bool>("overrideBaseStats") && valueOfType<bool>("overrideBaseStats"))
         return species()->baseStat(stat);
     return m_species->baseStat(stat);
 }
@@ -201,17 +203,17 @@ int Sigbattle::TeamMember::baseStat(const Sigmod::Stat stat) const
 long long Sigbattle::TeamMember::statExperience(const Sigmod::Stat stat) const
 {
     const QString valueName = QString("statExperience-%1").arg((sigmod()->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[stat]);
-    if (value(valueName).canConvert<long long>())
-        return value(valueName).toLongLong();
+    if (hasValueOfType<long long>(valueName))
+        return valueOfType<long long>(valueName);
     return m_statExp[stat];
 }
 
 int Sigbattle::TeamMember::dv(const Sigmod::Stat stat) const
 {
     const QString valueName = QString("dv-%1").arg((sigmod()->rules()->specialSplit() ? Sigmod::StatGSCStr : Sigmod::StatRBYStr)[stat]);
-    if (value(valueName).canConvert<int>())
+    if (hasValueOfType<int>(valueName))
     {
-        const int dv = value(valueName).toInt();
+        const int dv = valueOfType<int>(valueName);
         if (dv < (sigmod()->rules()->specialDVSplit() ? 32 : 16))
             return dv;
     }
@@ -396,17 +398,19 @@ void Sigbattle::TeamMember::cureStatus(Sigscript::StatusWrapper* status)
 
 void Sigbattle::TeamMember::giveStatus(Sigscript::StatusWrapper* status)
 {
-    Q_ASSERT(sigmod()->statusIndex(status) != INT_MAX);
     if (!m_status.contains(status))
     {
         const Sigmod::Script script = status->worldScript();
-        Kross::Action* statusAction = new Kross::Action(Kross::Manager::self().actionCollection()->collection("status"), QString("status-%1").arg(QUuid::createUuid().toString()));
-        statusAction->setInterpreter(script.interpreter());
-        statusAction->setCode(script.script().toUtf8());
-        statusAction->addObject(this, "owner", Kross::ChildrenInterface::AutoConnectSignals);
-        statusAction->trigger();
-        m_status.insert(status, statusAction);
-        emit(statusInflicted(status));
+        if (!script.script().isEmpty())
+        {
+            Kross::Action* statusAction = new Kross::Action(Kross::Manager::self().actionCollection()->collection("status"), QUuid::createUuid().toString());
+            statusAction->setInterpreter(script.interpreter());
+            statusAction->setCode(script.script().toUtf8());
+            statusAction->addObject(this, "owner");
+            statusAction->trigger();
+            m_status.insert(status, statusAction);
+            emit(statusInflicted(status));
+        }
     }
 }
 
@@ -499,9 +503,17 @@ void Sigbattle::TeamMember::teachMove(Sigscript::MoveWrapper* move)
     emit(unlearnableMove(move));
 }
 
-Sigbattle::TeamMember::Action Sigbattle::TeamMember::requestAction() const
+Sigbattle::TeamMember::Action Sigbattle::TeamMember::requestAction()
 {
     Player* player = qobject_cast<Player*>(m_containment);
+    m_lastAction = player ? player->requestAction(this) :  Action(Invalid, ActionData());
+    return m_lastAction;
+}
+
+Sigbattle::TeamMember::Action Sigbattle::TeamMember::latestAction() const
+{
+    return m_lastAction;
+    Player* player = qobject_cast<Player*>(m_containment);
     if (player)
         return player->requestAction(this);
     return Action(Invalid, ActionData());
@@ -509,36 +521,47 @@ Sigbattle::TeamMember::Action Sigbattle::TeamMember::requestAction() const
 
 void Sigbattle::TeamMember::makeActive(Arena* arena)
 {
-    // TODO: not everything is done here...
+    m_timer = 0;
     QList<Sigscript::StatusWrapper*> statuses = m_status.uniqueKeys();
     foreach (Sigscript::StatusWrapper* status, statuses)
     {
         const Sigmod::Script script = status->battleScript();
-        Kross::Action* statusScript = new Kross::Action(Kross::Manager::self().actionCollection()->collection("status"), QString("status-%1").arg(QUuid::createUuid().toString()));
-        statusScript->setInterpreter(script.interpreter());
-        statusScript->setCode(script.script().toUtf8());
-        statusScript->addObject(arena, "arena", Kross::ChildrenInterface::AutoConnectSignals);
-        statusScript->addObject(this, "owner", Kross::ChildrenInterface::AutoConnectSignals);
-        statusScript->trigger();
-        m_statusBattleScripts.append(statusScript);
+        if (!script.script().isEmpty())
+        {
+            Kross::Action* action = new Kross::Action(Kross::Manager::self().actionCollection()->collection("status"), QUuid::createUuid().toString());
+            action->setInterpreter(script.interpreter());
+            action->setCode(script.script().toUtf8());
+            action->addObject(arena, "arena");
+            action->addObject(this, "owner");
+            action->trigger();
+            m_statusBattleScripts.append(action);
+        }
     }
     QList<Sigscript::AbilityWrapper*> abilities = m_abilities.keys();
     foreach (Sigscript::AbilityWrapper* ability, abilities)
     {
         const Sigmod::Script script = ability->battleScript();
-        Kross::Action* abilityScript = new Kross::Action(Kross::Manager::self().actionCollection()->collection("ability"), QString("ability-%1").arg(QUuid::createUuid().toString()));
-        abilityScript->setInterpreter(script.interpreter());
-        abilityScript->setCode(script.script().toUtf8());
-        abilityScript->addObject(arena, "arena", Kross::ChildrenInterface::AutoConnectSignals);
-        abilityScript->addObject(this, "owner", Kross::ChildrenInterface::AutoConnectSignals);
-        abilityScript->trigger();
-        m_abilityBattleScripts.append(abilityScript);
+        if (!script.script().isEmpty())
+        {
+            Kross::Action* action = new Kross::Action(Kross::Manager::self().actionCollection()->collection("ability"), QUuid::createUuid().toString());
+            action->setInterpreter(script.interpreter());
+            action->setCode(script.script().toUtf8());
+            action->addObject(arena, "arena");
+            action->addObject(this, "owner");
+            action->trigger();
+            m_abilityBattleScripts.append(action);
+        }
     }
 }
 
 void Sigbattle::TeamMember::leaveArena()
 {
-    // TODO: leave the arena
+    Kross::ActionCollection* collection = Kross::Manager::self().actionCollection()->collection("status");
+    foreach (Kross::Action* action, m_statusBattleScripts)
+        collection->removeAction(action);
+    collection = Kross::Manager::self().actionCollection()->collection("ability");
+    foreach (Kross::Action* action, m_abilityBattleScripts)
+        collection->removeAction(action);
 }
 
 void Sigbattle::TeamMember::advanceTimer(const long long jump)
@@ -588,12 +611,15 @@ void Sigbattle::TeamMember::makeConnections()
 void Sigbattle::TeamMember::initAbility(Sigscript::AbilityWrapper* ability)
 {
     const Sigmod::Script script = ability->battleScript();
-    Kross::Action* abilityScript = new Kross::Action(Kross::Manager::self().actionCollection()->collection("ability"), QString("ability-%1").arg(QUuid::createUuid().toString()));
-    abilityScript->setInterpreter(script.interpreter());
-    abilityScript->setCode(script.script().toUtf8());
-    abilityScript->addObject(this, "owner", Kross::ChildrenInterface::AutoConnectSignals);
-    abilityScript->trigger();
-    m_abilities[ability] = abilityScript;
+    if (!script.script().isEmpty())
+    {
+        Kross::Action* action = new Kross::Action(Kross::Manager::self().actionCollection()->collection("ability"), QUuid::createUuid().toString());
+        action->setInterpreter(script.interpreter());
+        action->setCode(script.script().toUtf8());
+        action->addObject(this, "owner", Kross::ChildrenInterface::AutoConnectSignals);
+        action->trigger();
+        m_abilities[ability] = action;
+    }
 }
 
 void Sigbattle::TeamMember::initItems()
diff --git a/sigbattle/TeamMember.h b/sigbattle/TeamMember.h
index fdb172e9..e6511ca3 100644
--- a/sigbattle/TeamMember.h
+++ b/sigbattle/TeamMember.h
@@ -154,7 +154,8 @@ class SIGBATTLE_EXPORT TeamMember : public Sigscript::Config
         void forgetMove(Sigscript::MoveWrapper* move);
         void teachMove(Sigscript::MoveWrapper* move);
         
-        Action requestAction() const;
+        Action requestAction();
+        Action latestAction() const;
         
         void makeActive(Arena* arena);
         void leaveArena();
@@ -187,6 +188,7 @@ class SIGBATTLE_EXPORT TeamMember : public Sigscript::Config
         QList<Sigscript::NatureWrapper*> m_natures;
         
         long long m_timer;
+        Action m_lastAction;
         
         QList<Kross::Action*> m_abilityBattleScripts;
         QList<Kross::Action*> m_statusBattleScripts;
diff --git a/sigbattle/TurnArena.cpp b/sigbattle/TurnArena.cpp
index 3d65f881..34e586cd 100644
--- a/sigbattle/TurnArena.cpp
+++ b/sigbattle/TurnArena.cpp
@@ -21,12 +21,20 @@
 // Sigmod includes
 #include "../sigmod/Fraction.h"
 
+// Sigscript includes
+#include "../sigscript/MoveWrapper.h"
+#include "../sigscript/SigmodWrapper.h"
+
 // Qt includes
 #include <QtAlgorithms>
 #include <QtCore/QtConcurrentMap>
 #include <QtCore/QFuture>
 #include <QtCore/QTimer>
 
+// KDE includes
+#include <kross/core/action.h>
+#include <kross/core/actioncollection.h>
+
 bool Sigbattle::sortActions(const TeamMember::RequestedAction& reqAction1, const TeamMember::RequestedAction& reqAction2)
 {
     TeamMember::Action action1 = reqAction1.second.isFinished() ? reqAction1.second : TeamMember::Action(TeamMember::Timeout, TeamMember::ActionData());
@@ -42,13 +50,13 @@ bool Sigbattle::sortActions(const TeamMember::RequestedAction& reqAction1, const
         if (speed1 < speed2)
             return true;
         else if (speed1 == speed2)
-            return Sigmod::Fraction(1, 2).poll();
+            return Sigmod::Fraction::poll(1, 2);
     }
     return false;
 }
 
-Sigbattle::TurnArena::TurnArena(QList<Player*> players, const bool isWild, QObject* parent) :
-        Arena(players, isWild, parent),
+Sigbattle::TurnArena::TurnArena(Sigscript::SigmodWrapper* sigmod, QList<Player*> players, const bool isWild, QObject* parent) :
+        Arena(sigmod, players, isWild, parent),
         m_watcher(new QFutureWatcher<TeamMember::RequestedAction>(this)),
         m_timer(new QTimer(this))
 {
@@ -68,19 +76,29 @@ void Sigbattle::TurnArena::processRound()
     m_timer->stop();
     QList<TeamMember::RequestedAction> actions = reqActions.results();
     qStableSort(actions.begin(), actions.end(), sortActions);
-    for (int i = 0; i < actions.size(); ++i)
+    for (int i = 1; i < actions.size(); ++i)
     {
-        for (int j = 0; j < i; ++j)
+        TeamMember::Action action = actions[i].second;
+        if (action.first == TeamMember::Attack)
         {
-            
-            // TODO: Notify scripts of the moves before it and of its targets
+            Sigscript::MoveWrapper* move = sigmod()->move(action.second.first.toInt());
+            const Sigmod::Script script = move->priorityScript();
+            if (!script.script().isEmpty())
+            {
+                Kross::Action* kaction = new Kross::Action(m_actions, QUuid::createUuid().toString());
+                kaction->setInterpreter(script.interpreter());
+                kaction->setCode(script.script().toUtf8());
+                kaction->addObject(this, "arena");
+                kaction->addObject(actions[i].first, "user");
+                for (int j = 0; j < i; ++j)
+                    kaction->addObject(actions[j].first, QString("fighter%1").arg(j));
+                kaction->trigger();
+            }
         }
     }
-    // TODO: notify all attacks of what is going on in order (they can change priorities as needed)
     qStableSort(actions.begin(), actions.end(), sortActions);
     foreach (TeamMember::RequestedAction action, actions)
     {
-        // TODO: Handle when the target switches or is knocked out
         if (action.first->currentHp())
             handleAction(action.first, action.second);
     }
@@ -88,7 +106,7 @@ void Sigbattle::TurnArena::processRound()
     emit(roundEnd());
     if (numActiveTeams() <= 1)
     {
-        // TODO: End Round
+        // TODO: End Battle
     }
     else
         processRound();
diff --git a/sigbattle/TurnArena.h b/sigbattle/TurnArena.h
index 2c81931d..41b8e296 100644
--- a/sigbattle/TurnArena.h
+++ b/sigbattle/TurnArena.h
@@ -35,7 +35,7 @@ class SIGBATTLE_EXPORT TurnArena : public Arena
     Q_OBJECT
     
     public:
-        TurnArena(QList<Player*> players, const bool isWild, QObject* parent);
+        TurnArena(Sigscript::SigmodWrapper* sigmod, QList<Player*> players, const bool isWild, QObject* parent);
     signals:
         void roundAboutToStart();
         void roundStart();