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 ***************************************************************************/
32 //////////////////////////////////////////////////////////////////////////
34 unsigned Planet::planetScore(int tick) const
36 int ticks = m_Score.size();
43 return m_Score[ticks];
48 //////////////////////////////////////////////////////////////////////////
50 void Planet::setPlanetScore(unsigned number, int tick)
53 int ticks = m_Score.size();
56 earlier = m_Score[ticks - 1];
58 for (int i = ticks; i <= tick; ++i)
60 m_Score.push_back(earlier);
62 m_Score[tick] = number;
65 //////////////////////////////////////////////////////////////////////////
67 void Planet::addPlanetScore(unsigned number, int tick)
70 int ticks = m_Score.size();
73 earlier = m_Score[ticks - 1];
75 for (int i = ticks; i <= tick; ++i)
77 m_Score.push_back(earlier);
79 m_Score[tick] += number;
81 //////////////////////////////////////////////////////////////////////////
83 int Planet::roids(std::string type, int tick) const
85 // const... I would like [] as for const types: int ticks = m_Roids[type].size();
87 vector<int>const* roids = 0;
88 for (RoidList::const_iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
99 int ticks = roids->size();
105 return roids->at(ticks);
106 return roids->at(tick);
109 //////////////////////////////////////////////////////////////////////////
111 void Planet::setRoids(std::string type, int number, int tick)
113 int ticks = m_Roids[type].size();
115 if (m_Roids[type].size() > 0)
116 roids = m_Roids[type][m_Roids[type].size() - 1];
118 for (int i = ticks; i <= tick; ++i )
119 m_Roids[type].push_back(roids);
120 m_Roids[type][tick] = number;
123 //////////////////////////////////////////////////////////////////////////
125 void Planet::takeRoids(std::string type, int number, int tick)
127 int ticks = m_Roids[type].size();
129 if (m_Roids[type].size() > 0)
130 roids = m_Roids[type][m_Roids[type].size() - 1];
132 for (int i = ticks; i <= tick; ++i )
133 m_Roids[type].push_back(roids);
134 m_Roids[type][tick] -= number;
136 if (type != "uninit")
137 addPlanetScore(-1000*number, tick);
142 //////////////////////////////////////////////////////////////////////////
144 void Planet::runBattle(std::vector<Fleet*> friendly, std::vector<Fleet*> hostile)
146 if (hostile.size() == 0)
151 for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
154 for (vector<Fleet*>::iterator i = hostile.begin(); i != hostile.end(); ++i)
159 for(int tick = 1; skipped < 20; ++tick)
161 //See who's in the battle at the current tick
162 vector<Fleet*> friends = calculateSide(friendly, tick);
163 vector<Fleet*> hostiles = calculateSide(hostile, tick);
165 // No idea to calculate anything if noone is there.. ;)
166 if (hostiles.size() == 0)
175 allFriends.addToThis(friends, tick - 1);
177 /*for (RoidList::iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
178 allFriends.setRoids(i->first, roids(i->first, tick));
180 allFriends.setPlanetScore(m_iScore);*/
183 allHostiles.addToThis(hostiles, tick - 1);
185 map<string, map<string, int> > stealfriendly;
186 map<string, map<string, int> > stealhostile;
189 for (RoidList::iterator roid = m_Roids.begin(); roid != m_Roids.end(); ++roid)
191 setRoids(roid->first, roids(roid->first, tick-1), tick);
194 setPlanetScore(planetScore(tick - 1), tick);
197 calcOneTick(&allFriends, &allHostiles, stealfriendly, stealhostile, tick );
199 //allFriends.printFleet();
201 allFriends.distributeLossesGains(friends, tick);
202 allFriends.distributeStolenShips(stealfriendly, friends, tick);
204 allHostiles.distributeLossesGains(hostiles, tick);
205 allHostiles.distributeCappedRoids(hostiles, tick);
206 allHostiles.distributeStolenShips(stealhostile, hostiles, tick);
208 calculateScoreLoss(friends, tick);
210 /* for (RoidList::iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
211 setRoids(i->first, roids(i->first, 1), tick);*/
214 for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
215 (*i)->calculateSalvage();
217 for (RoidList::iterator i = m_Roids.begin(); i != m_Roids.end(); ++i)
219 for (vector<int>::iterator j = i->second.begin(); j != i->second.end(); ++j)
220 cout << i->first << " roids : " << (*j) << endl;
224 //////////////////////////////////////////////////////////////////////////
226 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)
228 if (planetScore(tick - 1) > 0)
229 setCapping(float(planetScore(tick - 1)) / hostile->score() / 10, tick);
233 //FIXME: remove this line later.. map<string, int> pods;
236 //FIXME: Need to change this and allow multiple shiptypes with the same initiative.
237 //FIXME: Looks like I don't have to..
238 map<int, string> unitsinit; // order units after their ininitiative
239 for (UnitList::iterator i = s_Units.begin(); i != s_Units.end(); ++i)
240 unitsinit[i->second.initiative()] = i->first;
244 for (map<int, string>::iterator i = unitsinit.begin(); i != unitsinit.end(); ++i)
246 Fleet* hostiletemp = new Fleet(*hostile);
247 Planet* friendlytemp = new Planet(*friendly);
249 string unittype = i->second;
252 int freefriendly = friendly->freeFleet(unittype, 1);
253 int freehostile = hostile->freeFleet(unittype, 1);
255 if ( freefriendly <= 0 && freehostile <= 0)
258 //cerr << "Initiative: " << s_Units[unittype].initiative() << " with unit: " << unittype << endl;
260 map<string, int> friendlyhits;
261 map<string, int> hostilehits;
263 if (s_Units[unittype].type() == "EMP")
265 hostiletemp->takeEMP(unittype, freefriendly, friendlyhits);
266 friendlytemp->takeEMP(unittype, freehostile, hostilehits);
268 else if (s_Units[unittype].type() == "Steal")
270 hostiletemp->takeShoot(unittype, freefriendly, stealfriendly[unittype]);
271 friendlytemp->takeShoot(unittype, freehostile, stealhostile[unittype]);
273 friendlyhits = stealfriendly[unittype];
274 hostilehits = stealhostile[unittype];
276 friendlytemp->calculateLostStealships(unittype, stealfriendly[unittype], 1);
277 hostiletemp->calculateLostStealships(unittype, stealhostile[unittype], 1);
281 hostiletemp->takeShoot(unittype, freefriendly, friendlyhits);
282 friendlytemp->takeShoot(unittype, freehostile, hostilehits);
286 if (s_Units[unittype].type() == "Pod")
288 //FIXME: Prolly need to recode the whole capping section for r7, due to multiple pods thingy
289 cerr << "Capping is: " << capping(tick) << endl;
291 if (capping(tick) > 0)
293 for (RoidList::iterator roid = m_Roids.begin(); roid != m_Roids.end(); ++roid)
295 int caproids = int(capping(tick) * roids(roid->first, tick - 1));
296 //int freepods = hostiletemp->freeFleet(unittype, 1);
298 cerr << "Possible to steal " << caproids << " " << roid->first << " roids\n";
299 cerr << hostiletemp->freePodGuns(1) << " free pod guns available\n";
301 if (hostiletemp->freePodGuns(1) <= 0)
303 if (hostiletemp->freePodGuns(1) < caproids)
304 caproids = hostiletemp->freePodGuns(1);
306 cerr << caproids << " roids stolen\n";
308 takeRoids(roid->first, caproids, tick);
310 /*FIXME: REMOVE THIS BLOCK LATER
311 //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.
312 hostiletemp->killFleet(unittype, caproids, 1);
313 pods[unittype] += caproids;
314 //int totroids = caproids + hostiletemp->resource(roid->first, 0);
316 hostiletemp->addResource(roid->first, caproids, 1);
317 hostiletemp->usePodGuns(1, caproids);
318 cerr << caproids << " stolen " << roid->first << " roids\n";
322 //FIXME: This is ugly and I want to change this, but as long as pods shoot last it works..
323 *friendly = *friendlytemp;
325 *hostile = *hostiletemp;
330 if (freefriendly > 0)
332 m_Report[tick][init]["Friendly"][unittype] = friendlyhits;
333 m_Report[tick][init]["Friendly"][unittype]["000"] = freefriendly;
337 m_Report[tick][init]["Hostile"][unittype] = hostilehits;
338 m_Report[tick][init]["Hostile"][unittype]["000"] = freehostile;
341 //set the the objects so they point at the modified objects
342 *friendly = *friendlytemp;
344 *hostile = *hostiletemp;
347 //hostile->addFleet(pods, 1);
351 //////////////////////////////////////////////////////////////////////////
353 void Planet::calculateScoreLoss(std::vector<Fleet*> friendly, int tick)
355 for (vector<Fleet*>::iterator i = friendly.begin(); i != friendly.end(); ++i)
357 if ((*i)->name().find("Home") != string::npos)
359 int scorechange = (*i)->score(tick) - (*i)->score(tick - 1);
360 addPlanetScore(scorechange, tick);
365 //////////////////////////////////////////////////////////////////////////
367 float Planet::capping(int tick)
369 int ticks = m_Capping.size();
376 return m_Capping[tick];
379 //////////////////////////////////////////////////////////////////////////
381 void Planet::setCapping(float capping, int tick)
383 int ticks = m_Capping.size();
385 for (int i = ticks; i <= tick; ++i)
387 m_Capping.push_back(0);
390 if (capping <= 0.15 && capping >= 0)
391 m_Capping[tick] = capping;
392 else if (capping >= 0.15)
393 m_Capping[tick] = 0.15;
398 //////////////////////////////////////////////////////////////////////////
400 ReportList Planet::report() const