1 /***************************************************************************
2 planet.cpp - description
5 copyright : (C) 2002 by Michael Andreen
7 ***************************************************************************/
9 /***************************************************************************
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 ***************************************************************************/
31 //////////////////////////////////////////////////////////////////////////
33 unsigned Planet::planetScore(int tick = 0) const
35 int ticks = m_Score.size();
42 return m_Score[ticks];
47 //////////////////////////////////////////////////////////////////////////
49 void Planet::setPlanetScore(unsigned number, int tick = 0)
52 int ticks = m_Score.size();
55 earlier = m_Score[ticks - 1];
57 for (int i = ticks; i <= tick; ++i)
59 m_Score.push_back(earlier);
61 m_Score[tick] = number;
64 //////////////////////////////////////////////////////////////////////////
66 void Planet::addPlanetScore(unsigned number, int tick = 0)
69 int ticks = m_Score.size();
72 earlier = m_Score[ticks - 1];
74 for (int i = ticks; i <= tick; ++i)
76 m_Score.push_back(earlier);
78 m_Score[tick] += number;
80 //////////////////////////////////////////////////////////////////////////
82 int Planet::roids(std::string type, int tick = 0) const
84 // const... I would like [] as for const types: int ticks = m_Roids[type].size();
86 vector<int>const* roids = 0;
87 for (RoidList::const_iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
98 int ticks = roids->size();
104 return roids->at(ticks);
105 return roids->at(tick);
108 //////////////////////////////////////////////////////////////////////////
110 void Planet::setRoids(std::string type, int number, int tick = 0)
112 int ticks = m_Roids[type].size();
114 if (m_Roids[type].size() > 0)
115 roids = m_Roids[type][m_Roids[type].size() - 1];
117 for (int i = ticks; i <= tick; ++i )
118 m_Roids[type].push_back(roids);
119 m_Roids[type][tick] = number;
122 //////////////////////////////////////////////////////////////////////////
124 void Planet::takeRoids(std::string type, int number, int tick = 0)
126 int ticks = m_Roids[type].size();
128 if (m_Roids[type].size() > 0)
129 roids = m_Roids[type][m_Roids[type].size() - 1];
131 for (int i = ticks; i <= tick; ++i )
132 m_Roids[type].push_back(roids);
133 m_Roids[type][tick] -= number;
135 if (type != "uninit")
136 addPlanetScore(-3000*number, tick);
141 //////////////////////////////////////////////////////////////////////////
143 void Planet::runBattle(std::vector<Fleet*> friendly, std::vector<Fleet*> hostile)
145 if (hostile.size() == 0)
149 for(int tick = 1; skipped < 20; ++tick)
151 //See who's in the battle at the current tick
152 vector<Fleet*> friends = calculateSide(friendly, 6, tick);
153 vector<Fleet*> hostiles = calculateSide(hostile, 3, tick);
155 // No idea to calculate anything if noone is there.. ;)
156 if (hostiles.size() == 0)
165 allFriends.addToThis(friends, tick - 1);
167 /*for (RoidList::iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
168 allFriends.setRoids(i->first, roids(i->first, tick));
170 allFriends.setPlanetScore(m_iScore);*/
173 allHostiles.addToThis(hostiles, tick - 1);
175 map<string, map<string, int> > stealfriendly;
176 map<string, map<string, int> > stealhostile;
179 for (RoidList::iterator roid = m_Roids.begin(); roid != m_Roids.end(); ++roid)
180 setRoids(roid->first, roids(roid->first, tick-1), tick);
182 setPlanetScore(planetScore(tick - 1), tick);
185 calcOneTick(&allFriends, &allHostiles, stealfriendly, stealhostile, tick );
187 //allFriends.printFleet();
189 allFriends.distributeLossesGains(friends, tick);
191 allHostiles.addPodsForLostRoids();
192 allHostiles.distributeLossesGains(hostiles, tick);
193 allHostiles.distributeCappedRoids(hostiles, tick);
195 calculateScoreLoss(friends, tick);
197 /* for (RoidList::iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
198 setRoids(i->first, roids(i->first, 1), tick);*/
201 for (RoidList::iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
203 for (vector<int>::iterator j = i->second.begin(); j != i->second.end(); ++j)
204 cout << i->first << " roids : " << (*j) << endl;
208 //////////////////////////////////////////////////////////////////////////
210 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)
212 map<int, string> unitsinit; // order units after their ininitiative
213 for (UnitList::iterator i = s_Units.begin(); i != s_Units.end(); ++i)
214 unitsinit[i->second.initiative()] = i->first;
216 for (map<int, string>::iterator i = unitsinit.begin(); i != unitsinit.end(); ++i)
218 Fleet* hostiletemp = new Fleet(*hostile);
219 Planet* friendlytemp = new Planet(*friendly);
221 string unittype = i->second;
223 //cerr << "Initiative: " << s_Units[unittype].initiative() << " with unit: " << unittype << endl;
225 if (s_Units[unittype].type() == "EMP")
227 hostiletemp->takeEMP(unittype, friendly->freeFleet(unittype, 1));
228 friendlytemp->takeEMP(unittype, hostile->freeFleet(unittype, 1));
230 else if (s_Units[unittype].type() == "Steal")
232 hostiletemp->takeShoot(unittype, friendly->freeFleet(unittype, 1), stealfriendly[unittype]);
233 friendlytemp->takeShoot(unittype, hostile->freeFleet(unittype, 1), stealhostile[unittype]);
237 map<string, int> temp;
238 hostiletemp->takeShoot(unittype, friendly->freeFleet(unittype, 1), temp);
239 friendlytemp->takeShoot(unittype, hostile->freeFleet(unittype, 1), temp);
242 if (s_Units[unittype].type() == "Pod")
244 if (planetScore(tick - 1) > 0)
246 setCapping(float(planetScore(tick - 1)) / hostile->score() / 10, tick);
248 cerr << "Capping is: " << capping(tick) << endl;
250 if (capping(tick) > 0)
252 for (RoidList::iterator roid = m_Roids.begin(); roid != m_Roids.end(); ++roid)
254 int caproids = capping(tick) * roids(roid->first, tick - 1);
255 int freepods = hostiletemp->freeFleet(unittype, 1);
257 cerr << "Possible to steal " << caproids << " " << roid->first << " roids\n";
258 cerr << freepods << " free pods available\n";
262 if (freepods < caproids)
265 cerr << caproids << " roids stolen\n";
267 takeRoids(roid->first, caproids, tick);
269 //FIXME: Going to move this to the distribute roids section instead.. Not really move, I'll keep this, but "regenerate" the pods in the distribute ships function.
270 hostiletemp->killFleet(unittype, caproids, 1);
271 //int totroids = caproids + hostiletemp->resource(roid->first, 0);
272 hostiletemp->addResource(roid->first, caproids, 1);
274 cerr << caproids << " stolen " << roid->first << " roids\n";
280 //set the the objects so they point at the modified objects
281 *friendly = *friendlytemp;
283 *hostile = *hostiletemp;
288 //////////////////////////////////////////////////////////////////////////
290 void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick = 1)
292 for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
294 if ((*i)->name().find("Home") != string::npos)
296 int scorechange = (*i)->score(tick) - (*i)->score(tick - 1);
297 addPlanetScore(scorechange, tick);
302 //////////////////////////////////////////////////////////////////////////
304 float Planet::capping(int tick = 0)
306 int ticks = m_Capping.size();
313 return m_Capping[tick];
316 //////////////////////////////////////////////////////////////////////////
318 void Planet::setCapping(float capping, int tick = 0)
320 int ticks = m_Capping.size();
322 for (int i = ticks; i <= tick; ++i)
324 m_Capping.push_back(0);
327 if (capping <= 0.15 && capping >= 0)
328 m_Capping[tick] = capping;
330 m_Capping[tick] = 0.15;