[FIX] Slimmed up main() for pokemodr

[FIX] Cleaned up initializing TeamMember
[FIX] Hat fixed up
[ADD] Added ActionQueue (thread-safe QQueue)
[FIX] Arena classes fleshed out a bit
[ADD] ATBTimer class added to mediate the ATB counters

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

4 files changed, 98 insertions, 29 deletions

diff --git a/pokemod/Fraction.cpp b/pokemod/Fraction.cpp
index 26e114f9..0d69a889 100644
--- a/pokemod/Fraction.cpp
+++ b/pokemod/Fraction.cpp
@@ -22,6 +22,8 @@ void Pokemod::Fraction::reduce()
 {
     int i = m_numerator;
     int j = m_denominator;
+    if (i < 0)
+        i = -i;
     while (i - j)
         (i > j) ? (i -= j) : (j -= i);
     m_numerator /= i;
diff --git a/pokemod/Fraction.h b/pokemod/Fraction.h
index fce2aa34..c074ecbc 100644
--- a/pokemod/Fraction.h
+++ b/pokemod/Fraction.h
@@ -29,8 +29,7 @@ namespace Pokemod
 class POKEMOD_EXPORT Fraction
 {
     public:
-        Fraction();
-        Fraction(const int numerator, const int denominator);
+        Fraction(const int numerator = 1, const int denominator = 1);
         
         void set(const int numerator, const int denominator);
         void setNumerator(const int numerator);
@@ -42,21 +41,27 @@ class POKEMOD_EXPORT Fraction
         void reduce();
         bool poll() const;
         
+        Fraction& operator=(const Fraction& rhs);
         operator double() const;
+        Fraction operator+(const Fraction& rhs) const;
+        Fraction operator-(const Fraction& rhs) const;
         Fraction operator*(const Fraction& rhs) const;
-        Fraction& operator=(const Fraction& rhs);
+        Fraction operator/(const Fraction& rhs) const;
+        Fraction operator%(const Fraction& rhs) const;
+        Fraction& operator+=(const Fraction& rhs);
+        Fraction& operator-=(const Fraction& rhs);
+        Fraction& operator*=(const Fraction& rhs);
+        Fraction& operator/=(const Fraction& rhs);
+        Fraction& operator%=(const Fraction& rhs);
         bool operator==(const Fraction& rhs) const;
         bool operator!=(const Fraction& rhs) const;
+    protected:
+        void normalize();
     private:
         int m_numerator;
         int m_denominator;
 };
 
-inline Fraction::Fraction()
-{
-    set(1, 1);
-}
-
 inline Fraction::Fraction(const int numerator, const int denominator)
 {
     set(numerator, denominator);
@@ -66,6 +71,7 @@ inline void Fraction::set(const int numerator, const int denominator)
 {
     m_numerator = numerator;
     m_denominator = denominator;
+    normalize();
 }
 
 inline void Fraction::setNumerator(const int numerator)
@@ -93,23 +99,58 @@ inline bool Fraction::poll() const
     return (qrand() % m_denominator) < m_numerator;
 }
 
+inline Fraction& Fraction::operator=(const Fraction& rhs)
+{
+    if (this == &rhs)
+        return *this;
+    m_numerator = rhs.m_numerator;
+    m_denominator = rhs.m_denominator;
+    return *this;
+}
+
 inline Fraction::operator double() const
 {
     return (double(m_numerator) / m_denominator);
 }
 
+inline Fraction Fraction::operator+(const Fraction& rhs) const
+{
+    return Fraction((m_numerator * rhs.m_denominator) + (m_denominator * rhs.m_numerator), m_denominator * rhs.m_denominator);
+}
+
+inline Fraction Fraction::operator-(const Fraction& rhs) const
+{
+    return Fraction((m_numerator * rhs.m_denominator) - (m_denominator * rhs.m_numerator), m_denominator * rhs.m_denominator);
+}
+
 inline Fraction Fraction::operator*(const Fraction& rhs) const
 {
     return Fraction(m_numerator * rhs.m_numerator, m_denominator * rhs.m_denominator);
 }
 
-inline Fraction& Fraction::operator=(const Fraction& rhs)
+inline Fraction Fraction::operator/(const Fraction& rhs) const
 {
-    if (this == &rhs)
-        return *this;
-    m_numerator = rhs.m_numerator;
-    m_denominator = rhs.m_denominator;
-    return *this;
+    return Fraction(m_numerator * rhs.m_denominator, m_denominator * rhs.m_numerator);
+}
+
+inline Fraction& Fraction::operator+=(const Fraction& rhs)
+{
+    return *this = *this + rhs;
+}
+
+inline Fraction& Fraction::operator-=(const Fraction& rhs)
+{
+    return *this = *this - rhs;
+}
+
+inline Fraction& Fraction::operator*=(const Fraction& rhs)
+{
+    return *this = *this * rhs;
+}
+
+inline Fraction& Fraction::operator/=(const Fraction& rhs)
+{
+    return *this = *this / rhs;
 }
 
 inline bool Fraction::operator==(const Fraction& rhs) const
@@ -122,6 +163,16 @@ inline bool Fraction::operator!=(const Fraction& rhs) const
     return !(*this == rhs);
 }
 
+inline void Fraction::normalize()
+{
+    if (m_denominator < 0)
+    {
+        m_denominator = -m_denominator;
+        m_numerator = -m_numerator;
+    }
+    reduce();
+}
+
 }
 Q_DECLARE_METATYPE(Pokemod::Fraction)
 
diff --git a/pokemod/Hat.h b/pokemod/Hat.h
index 03511028..9fa1a71b 100644
--- a/pokemod/Hat.h
+++ b/pokemod/Hat.h
@@ -34,24 +34,26 @@ template<class T> class Hat
         
         T pick() const;
         T take();
+        T takeAndClear();
         void setCount(const T& key, const int weight);
         void add(const T& key, const int weight);
-        unsigned count() const;
-        unsigned count(const T& key) const;
+        int distinctCount() const;
+        int count() const;
+        int count(const T& key) const;
         double chance(const T& key) const;
         
-        unsigned operator[](const T& key) const;
+        int operator[](const T& key) const;
     private:
-        QMap<T, unsigned> m_objects;
+        QMap<T, int> m_objects;
         int m_count;
 };
 
-template<class T> Hat<T>::Hat() :
+template<class T> inline Hat<T>::Hat() :
         m_count(0)
 {
 }
 
-template<class T> T Hat<T>::pick() const
+template<class T> inline T Hat<T>::pick() const
 {
     int choice = qrand() % m_count;
     foreach (T key, m_objects.keys())
@@ -63,16 +65,24 @@ template<class T> T Hat<T>::pick() const
     return T();
 }
 
-template<class T> T Hat<T>::take()
+template<class T> inline T Hat<T>::take()
 {
     T chosen = pick();
     if (!(--m_objects[chosen]))
-        m_objects.erase(chosen);
+        m_objects.remove(chosen);
     --m_count;
     return chosen;
 }
 
-template<class T> void Hat<T>::setCount(const T& key, const int weight)
+template<class T> inline T Hat<T>::takeAndClear()
+{
+    T chosen = pick();
+    m_count -= m_objects[chosen];
+    m_objects.remove(chosen);
+    return chosen;
+}
+
+template<class T> inline void Hat<T>::setCount(const T& key, const int weight)
 {
     if (m_objects.contains(key))
         m_count -= m_objects[key];
@@ -85,30 +95,36 @@ template<class T> void Hat<T>::setCount(const T& key, const int weight)
         m_objects.remove(key);
 }
 
-template<class T> void Hat<T>::add(const T& key, const int weight)
+template<class T> inline void Hat<T>::add(const T& key, const int weight)
 {
+    Q_ASSERT(0 < weight);
     m_objects[key] += weight;
     m_count += weight;
 }
 
-template<class T> unsigned Hat<T>::count() const
+template<class T> inline int Hat<T>::distinctCount() const
+{
+    return m_objects.size();
+}
+
+template<class T> inline int Hat<T>::count() const
 {
     return m_count;
 }
 
-template<class T> unsigned Hat<T>::count(const T& key) const
+template<class T> inline int Hat<T>::count(const T& key) const
 {
     if (m_objects.contains(key))
         return m_objects[key];
     return 0;
 }
 
-template<class T> double Hat<T>::chance(const T& key) const
+template<class T> inline double Hat<T>::chance(const T& key) const
 {
     return (double(count(key)) / m_count);
 }
 
-template<class T> unsigned Hat<T>::operator[](const T& key) const
+template<class T> inline int Hat<T>::operator[](const T& key) const
 {
     return count(key);
 }
diff --git a/pokemod/SpeciesMove.cpp b/pokemod/SpeciesMove.cpp
index 9c98f63b..0ae8401b 100644
--- a/pokemod/SpeciesMove.cpp
+++ b/pokemod/SpeciesMove.cpp
@@ -99,7 +99,7 @@ void Pokemod::SpeciesMove::setLevel(const int level)
 
 void Pokemod::SpeciesMove::setWild(const int wild)
 {
-    if (qobject_cast<const Pokemod*>(pokemod())->rules()->maxLevel() <= wild)
+    if (!wild || (qobject_cast<const Pokemod*>(pokemod())->rules()->maxLevel() <= wild))
     {
         emit(error(bounds("wild")));
         return;