commited the r7 stats..

[hbs.git] / bs / planet.cpp

diff --git a/bs/planet.cpp b/bs/planet.cpp
index d62bf579996a1f0d583a66302fce706531c9ac59..935c65d33fc228c3ab8c271e0a01708a435bcda9 100644 (file)
--- a/bs/planet.cpp
+++ b/bs/planet.cpp
@@ -31,7 +31,7 @@ Planet::~Planet(){
 
 //////////////////////////////////////////////////////////////////////////
 //
-unsigned Planet::planetScore(int tick = 0) const
+unsigned Planet::planetScore(int tick) const
 {
        int ticks = m_Score.size();
        if (ticks == 0)
@@ -47,7 +47,7 @@ unsigned Planet::planetScore(int tick = 0) const
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::setPlanetScore(unsigned number, int tick = 0)
+void Planet::setPlanetScore(unsigned number, int tick)
 {
        int earlier = 0;
        int ticks = m_Score.size();
@@ -64,7 +64,7 @@ void Planet::setPlanetScore(unsigned number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::addPlanetScore(unsigned number, int tick = 0)
+void Planet::addPlanetScore(unsigned number, int tick)
 {
        int earlier = 0;
        int ticks = m_Score.size();
@@ -80,7 +80,7 @@ void Planet::addPlanetScore(unsigned number, int tick = 0)
 }
 //////////////////////////////////////////////////////////////////////////
 //
-int Planet::roids(std::string type, int tick = 0) const
+int Planet::roids(std::string type, int tick) const
 {
        // const... I would like [] as for const types: int ticks = m_Roids[type].size();
        
@@ -108,7 +108,7 @@ int Planet::roids(std::string type, int tick = 0) const
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::setRoids(std::string type, int number, int tick = 0)
+void Planet::setRoids(std::string type, int number, int tick)
 {
        int ticks = m_Roids[type].size();
        int roids = 0;
@@ -122,7 +122,7 @@ void Planet::setRoids(std::string type, int number, int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::takeRoids(std::string type, int number, int tick = 0)
+void Planet::takeRoids(std::string type, int number, int tick)
 {
        int ticks = m_Roids[type].size();
        int roids = 0;
@@ -149,10 +149,10 @@ void Planet::runBattle(std::vector<Fleet*> friendly, std::vector<Fleet*> hostile
        int skipped = 0;
 
        for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
-               (*i)->resetResources();
+               (*i)->resetTicks();
 
        for (vector<Fleet*>::iterator i = hostile.begin(); i != hostile.end(); ++i)
-               (*i)->resetResources();
+               (*i)->resetTicks();
 
        for(int tick = 1; skipped < 20; ++tick)
        {
@@ -197,9 +197,11 @@ void Planet::runBattle(std::vector<Fleet*> friendly, std::vector<Fleet*> hostile
                //allFriends.printFleet();
 
                allFriends.distributeLossesGains(friends, tick);
+               allFriends.distributeStolenShips(stealfriendly, friends, tick);
 
                allHostiles.distributeLossesGains(hostiles, tick);
                allHostiles.distributeCappedRoids(hostiles, tick);
+               allHostiles.distributeStolenShips(stealhostile, hostiles, tick);
 
                calculateScoreLoss(friends, tick);
 
@@ -207,6 +209,9 @@ void Planet::runBattle(std::vector<Fleet*> friendly, std::vector<Fleet*> hostile
                        setRoids(i->first, roids(i->first, 1), tick);*/
        }
 
+       for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
+               (*i)->calculateSalvage();
+
        for (RoidList::iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
        {
                for (vector<int>::iterator j = i->second.begin(); j != i->second.end(); ++j)
@@ -216,7 +221,7 @@ void Planet::runBattle(std::vector<Fleet*> friendly, std::vector<Fleet*> hostile
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::calcOneTick(Planet* friendly, Fleet* hostile, std::map<std::string, std::map<std::string, int> >& stealfriendly, std::map<std::string, std::map<std::string, int> >&  stealhostile, int tick = 1)
+void Planet::calcOneTick(Planet* friendly, Fleet* hostile, std::map<std::string, std::map<std::string, int> >& stealfriendly, std::map<std::string, std::map<std::string, int> >&  stealhostile, int tick)
 {
        if (planetScore(tick - 1) > 0)
                setCapping(float(planetScore(tick - 1)) / hostile->score() /  10, tick);
@@ -307,7 +312,7 @@ void Planet::calcOneTick(Planet* friendly, Fleet* hostile, std::map<std::string,
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick = 1)
+void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick)
 {
        for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
        {
@@ -321,7 +326,7 @@ void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick = 1)
 
 //////////////////////////////////////////////////////////////////////////
 //
-float Planet::capping(int tick = 0)
+float Planet::capping(int tick)
 {
        int ticks = m_Capping.size();
 
@@ -335,7 +340,7 @@ float Planet::capping(int tick = 0)
 
 //////////////////////////////////////////////////////////////////////////
 //
-void Planet::setCapping(float capping, int tick = 0)
+void Planet::setCapping(float capping, int tick)
 {
        int ticks = m_Capping.size();
 
@@ -346,6 +351,8 @@ void Planet::setCapping(float capping, int tick = 0)
 
        if (capping <= 0.15 && capping >= 0)
                m_Capping[tick] = capping;
-       else
+       else if (capping >= 0.15)
                m_Capping[tick] = 0.15;
+       else
+               m_Capping[tick] = 0;
 }