Fix up the timer for ATBArena to be a lot cleaner

4 files changed, 47 insertions, 63 deletions

diff --git a/sigencore/plugins/arenas/atb/ATBArena.cpp b/sigencore/plugins/arenas/atb/ATBArena.cpp
index 034b05f7..e3e75bbf 100644
--- a/sigencore/plugins/arenas/atb/ATBArena.cpp
+++ b/sigencore/plugins/arenas/atb/ATBArena.cpp
@@ -30,9 +30,9 @@ using namespace Sigencore;
 
 ATBArena::ATBArena(GameWrapper* sigmod, Config* parent) :
         Arena(sigmod, parent),
-        m_atbTimer(NULL),
-        m_processTicker(NULL)
+        m_atbTimer(new ATBTimer(this, m_decisions))
 {
+    connect(m_atbTimer, SIGNAL(actionReady(Sigencore::TeamMember*)), this, SLOT(processAction(Sigencore::TeamMember*)));
     setupBattle();
 }
 
@@ -65,24 +65,13 @@ void ATBArena::handleAction(TeamMember* teamMember, TeamMember::Action action)
 
 void ATBArena::setupBattle()
 {
-    m_atbTimer = new ATBTimer(this, m_decisions);
-    m_processTicker = new QTimer(this);
-    m_processTicker->setInterval(100);
-    connect(m_processTicker, SIGNAL(timeout()), this, SLOT(processActions()));
-    connect(this, SIGNAL(battleStarted()), m_processTicker, SLOT(start()));
     Arena::setupBattle();
 }
 
-void ATBArena::processActions()
+void ATBArena::processAction(TeamMember* teamMember)
 {
-    if (!m_decisions.isEmpty())
-    {
-//         while (m_decisions.head().second.isFinished())
-//         {
-//             TeamMember::RequestedAction action = m_decisions.dequeue();
-//             handleAction(action.first, action.second.result());
-//         }
-    }
+    handleAction(teamMember, m_decisions[teamMember].second);
+    m_decisions.remove(teamMember);
 }
 
 void ATBArena::cleanUp()
diff --git a/sigencore/plugins/arenas/atb/ATBArena.h b/sigencore/plugins/arenas/atb/ATBArena.h
index 1b3ec9af..6e781ab1 100644
--- a/sigencore/plugins/arenas/atb/ATBArena.h
+++ b/sigencore/plugins/arenas/atb/ATBArena.h
@@ -51,7 +51,7 @@ class ATBArena : public Sigencore::Arena
         
         Kross::ActionCollection* m_priorityScripts;
     protected slots:
-        void processActions();
+        void processAction(Sigencore::TeamMember* teamMember);
         
         virtual void registerScript(const Sigcore::Script& script);
         
@@ -59,7 +59,6 @@ class ATBArena : public Sigencore::Arena
     private:
         ActionMap m_decisions;
         ATBTimer* m_atbTimer;
-        QTimer* m_processTicker;
 };
 
 #endif
diff --git a/sigencore/plugins/arenas/atb/ATBTimer.cpp b/sigencore/plugins/arenas/atb/ATBTimer.cpp
index faf93786..6f32d312 100644
--- a/sigencore/plugins/arenas/atb/ATBTimer.cpp
+++ b/sigencore/plugins/arenas/atb/ATBTimer.cpp
@@ -27,15 +27,48 @@
 #include <sigscript/RulesWrapper.h>
 
 // Qt includes
-#include <QtCore/QtAlgorithms>
 #include <QtCore/QtConcurrentFilter>
-#include <QtCore/QtConcurrentMap>
 #include <QtCore/QFuture>
 #include <QtCore/QSignalMapper>
 #include <QtCore/QTimerEvent>
 
 using namespace Sigencore;
 
+struct ATBTimer::TimerIncrementFunctor
+{
+    TimerIncrementFunctor(ATBTimer* timer) :
+            m_timer(timer)
+    {
+    }
+    
+    typedef bool result_type;
+    
+    bool operator()(TeamMember* teamMember)
+    {
+        double factor = .1;
+        m_timer->m_arena->valueOfType("meter-factor", &factor);
+        if (!m_timer->m_actions.contains(teamMember))
+        {
+            m_timer->m_timers[teamMember] += teamMember->statValue(Sigmod::ST_Speed) * factor;
+            int threshold = 1000;
+            m_timer->m_arena->valueOfType("meter-threshold", &threshold);
+            if (threshold <= m_timer->m_timers[teamMember])
+            {
+                QFutureWatcher<TeamMember::Action>* watcher = new QFutureWatcher<TeamMember::Action>(m_timer);
+                TeamMember::RequestedAction action = requestDecision(teamMember);
+                watcher->setFuture(action.second);
+                m_timer->connect(watcher, SIGNAL(finished()), m_timer->m_actionMapper, SLOT(map()));
+                m_timer->connect(watcher, SIGNAL(finished()), SLOT(deleteLater()));
+                m_timer->m_actionMapper->setMapping(watcher, teamMember);
+                m_timer->m_actions.set(teamMember, action);
+            }
+        }
+        return false;
+    }
+    
+    ATBTimer* m_timer;
+};
+
 ATBTimer::ATBTimer(ATBArena* arena, ActionMap& actions) :
         QThread(arena),
         m_arena(arena),
@@ -55,46 +88,7 @@ void ATBTimer::run()
 
 void ATBTimer::timerEvent(QTimerEvent* event)
 {
-    // TODO: Rewrite this
     Q_UNUSED(event)
     const QList<TeamMember*> active = m_arena->active(Arena::Fighters);
-    QList<TeamMember::RequestedAction> actions;
-//     QtConcurrent::blockingMap(active, increaseMeter);
-//     QList<TeamMember*> overflow = QtConcurrent::blockingFiltered(active, isOverflowed);
-//     qSort(overflow.begin(), overflow.end(), compareTimers);
-//     foreach (TeamMember* teamMember, overflow)
-//     {
-//         TeamMember::RequestedAction action = requestDecision(teamMember);
-//         m_actions.enqueue(action);
-//         if (m_arena->sigmod()->rules()->pausedATB())
-//             actions.append(action);
-//     }
-//     if (m_arena->sigmod()->rules()->pausedATB())
-//     {
-//         killTimer(event->timerId());
-//         for (QMutableListIterator<TeamMember::RequestedAction> i(actions); i.hasNext(); i.next())
-//             i.value().second.waitForFinished();
-//         startTimer(50);
-//     }
-}
-
-void ATBTimer::increaseMeter(TeamMember* teamMember)
-{
-    double factor = .1;
-    m_arena->valueOfType("meter-factor", &factor);
-    if (!m_actions.contains(teamMember))
-    {
-        m_timers[teamMember] += teamMember->statValue(Sigmod::ST_Speed) * factor;
-        int threshold = 1000;
-        m_arena->valueOfType("meter-threshold", &threshold);
-        if (threshold <= m_timers[teamMember])
-        {
-            QFutureWatcher<TeamMember::Action>* watcher = new QFutureWatcher<TeamMember::Action>(this);
-            TeamMember::RequestedAction action = requestDecision(teamMember);
-            watcher->setFuture(action.second);
-            connect(watcher, SIGNAL(finished()), m_signalMapper, SLOT(map()));
-            m_signalMapper->setMapping(watcher, teamMember);
-            m_actions.set(teamMember, action);
-        }
-    }
+    QtConcurrent::blockingFiltered(active, TimerIncrementFunctor(this));
 }
diff --git a/sigencore/plugins/arenas/atb/ATBTimer.h b/sigencore/plugins/arenas/atb/ATBTimer.h
index bad0b8f8..61cbe5a1 100644
--- a/sigencore/plugins/arenas/atb/ATBTimer.h
+++ b/sigencore/plugins/arenas/atb/ATBTimer.h
@@ -38,17 +38,19 @@ class ATBTimer : public QThread
     public:
         ATBTimer(ATBArena* arena, ActionMap& actions);
         ~ATBTimer();
+    signals:
+        void actionReady(Sigencore::TeamMember* teamMember);
     protected:
         void run();
         
         void timerEvent(QTimerEvent* event);
     protected slots:
-        void increaseMeter(Sigencore::TeamMember* teamMember);
     private:
+        struct TimerIncrementFunctor;
+        
         ATBArena* m_arena;
-        QSignalMapper* m_signalMapper;
+        QSignalMapper* m_actionMapper;
         QMap<Sigencore::TeamMember*, int> m_timers;
-        QList<QFutureWatcher<Sigencore::TeamMember::Action> > m_watchers;
         ActionMap& m_actions;
 };