bs/fleet.cpp

   1 /***************************************************************************
   2                           fleet.cpp  -  description
   3                              -------------------
   4     begin                : Tue Jan 22 2002
   5     copyright            : (C) 2002 by Michael Andreen
   6     email                : whale@linux.nu
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  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.                                   *
  15  *                                                                         *
  16  ***************************************************************************/
  17
  18 #include "fleet.h"
  19
  20 #include <iostream>
  21 #include <cstdlib>
  22 using namespace std;
  23
  24 //Static variables
  25 map<string, vector<int> > Fleet::s_Races;
  26 UnitList Fleet::s_Units;
  27
  28 Fleet::Fleet()
  29 {
  30         m_iETA = 0;
  31         m_sRace = "Cathaar";
  32 }
  33
  34 Fleet::~Fleet(){
  35 }
  36
  37 //////////////////////////////////////////////////////////////////////////
  38 //
  39 void Fleet::setName(string sName)
  40 {
  41         m_sName = sName;
  42 }
  43
  44 //////////////////////////////////////////////////////////////////////////
  45 //
  46 string Fleet::name() const
  47 {
  48         return m_sName;
  49 }
  50
  51 //////////////////////////////////////////////////////////////////////////
  52 //
  53 /** This function first sets the race, then it iterates through the the
  54  * s_Races and checks if it finds the race it returns true, if it reaches
  55  * the end without finding it it returns false.
  56  */
  57 bool Fleet::setRace(string sRace)
  58 {
  59         m_sRace = sRace;
  60         for (map<string, vector<int> >::iterator i = s_Races.begin(); i != s_Races.end(); i++)
  61         {
  62                 if (m_sRace == (*i).first)
  63                         return true;
  64         }
  65         return false;
  66 }
  67
  68 //////////////////////////////////////////////////////////////////////////
  69 //
  70 string Fleet::race() const
  71 {
  72         return m_sRace;
  73 }
  74
  75 //////////////////////////////////////////////////////////////////////////
  76 //
  77 /** This function iterates through m_Fleet and adds all numbers together to
  78  * produce a total.
  79  */
  80 int Fleet::numberOfShips() const
  81 {
  82         int total = 0;
  83
  84         for (map<string, vector<int> >::const_iterator i = m_Fleet.begin(); i != m_Fleet.end(); ++i)
  85         {
  86                 if (i->second.size() != 0)
  87                         total += i->second[0];
  88         }
  89
  90         return total;
  91 }
  92
  93 //////////////////////////////////////////////////////////////////////////
  94 //
  95 void Fleet::setETA(int eta)
  96 {
  97         m_iETA = eta;
  98 }
  99
 100 //////////////////////////////////////////////////////////////////////////
 101 //
 102 int  Fleet::ETA() const
 103 {
 104         return m_iETA;
 105 }
 106
 107 //////////////////////////////////////////////////////////////////////////
 108 //
 109 void Fleet::setRaces(map<string, vector<int> >& races)
 110 {
 111         s_Races = races;
 112 }
 113
 114 //////////////////////////////////////////////////////////////////////////
 115 //
 116 void Fleet::setUnits(UnitList& units)
 117 {
 118         s_Units = units;
 119
 120
 121 /*
 122         for (UnitList::iterator i = s_Units.begin(); i != s_Units.end(); i++)
 123         {
 124                 cerr << s_Units[(*i).first].Name() << "\t\t"
 125                         << s_Units[(*i).first].race() <<"\t"
 126                         << s_Units[(*i).first].unitClass() << "\t"
 127                         << s_Units[(*i).first].target(0) << "\t"
 128                         << s_Units[(*i).first].target(1) << "\t"
 129                         << s_Units[(*i).first].target(2) << "\t"
 130                         << s_Units[(*i).first].initiative() << "\t"
 131                         << s_Units[(*i).first].agility() << "\t"
 132                         << s_Units[(*i).first].weaponSpeed() << "\t"
 133                         << s_Units[(*i).first].guns() << "\t"
 134                         << s_Units[(*i).first].power() << "\t"
 135                         << s_Units[(*i).first].armor() << "\t"
 136                         << s_Units[(*i).first].EMP() << "\t"
 137                         << s_Units[(*i).first].totRes() << "\t"
 138                         << s_Units[(*i).first].fuel() << "\t"
 139                         << s_Units[(*i).first].ETA() << "\t"
 140                         << s_Units[(*i).first].type() << endl;
 141         }
 142
 143         */
 144 }
 145
 146 //////////////////////////////////////////////////////////////////////////
 147 //
 148 const map<string, vector<int> >& Fleet::Races()
 149 {
 150         return s_Races;
 151 }
 152
 153 //////////////////////////////////////////////////////////////////////////
 154 //
 155 const UnitList& Fleet::Units()
 156 {
 157         return s_Units;
 158 }
 159
 160 //////////////////////////////////////////////////////////////////////////
 161 //
 162 vector<int> Fleet::RacesAllowed() const
 163 {
 164         return s_Races[m_sRace];
 165 }
 166
 167 //////////////////////////////////////////////////////////////////////////
 168 //
 169 unsigned Fleet::score(int tick = 0) const
 170 {
 171         unsigned tot_score = 0;
 172
 173         for (FleetList::const_iterator i = m_Fleet.begin(); i != m_Fleet.end(); ++i)
 174         {
 175                   if (i->second.size() >= tick)
 176                                 break;
 177                         tot_score += i->second[tick] * s_Units[i->first].totRes() / 10;
 178         }
 179
 180         return tot_score;
 181 }
 182
 183 //////////////////////////////////////////////////////////////////////////
 184 //
 185 void Fleet::setFleet(string unittype, int number, int tick = 0)
 186 {
 187         int earlier = 0;
 188         int ticks = m_Fleet[unittype].size();
 189
 190         if (ticks != 0)
 191                 earlier = m_Fleet[unittype][ticks - 1];
 192
 193         for (int i = ticks; i <= tick; ++i)
 194         {
 195                 m_Fleet[unittype].push_back(earlier);
 196         }
 197         m_Fleet[unittype][tick] = number;
 198 }
 199
 200 //////////////////////////////////////////////////////////////////////////
 201 //
 202 int      Fleet::fleet(string unittype, int tick = 0)
 203 {
 204         int ticks = m_Fleet[unittype].size();
 205         if (ticks == 0)
 206                 return 0;
 207
 208         --ticks;
 209
 210         if (ticks < tick)
 211                 return m_Fleet[unittype][ticks];
 212
 213         return m_Fleet[unittype][tick];
 214 }
 215
 216 //////////////////////////////////////////////////////////////////////////
 217 //FIXME
 218 void Fleet::addToThis(std::vector<Fleet*> fleets, int tick = 0)
 219 {
 220         for (UnitList::iterator i = s_Units.begin();  i != s_Units.end(); ++i)
 221         {
 222                 if (m_Fleet[i->first].size() == 0)
 223                                 m_Fleet[i->first].push_back(0);
 224
 225                 for (vector<Fleet*>::iterator j = fleets.begin(); j != fleets.end(); ++j)
 226                 {
 227                         int num = (*j)->fleet(i->first, tick);
 228                         m_Fleet[i->first][0] += num;
 229                         if (num > 0)
 230                                 cerr << (*j)->name() <<  " adding " << num << " units of type " << i->first << endl;
 231                 }
 232         }
 233 }
 234
 235 //////////////////////////////////////////////////////////////////////////
 236 //
 237 void Fleet::distributeLossesGains(std::vector<Fleet*> fleets, int tick = 0)
 238 {
 239         for (UnitList::iterator i = s_Units.begin(); i != s_Units.end(); ++i)
 240         {
 241                 string unittype = i->first;
 242
 243
 244                 if (m_Fleet[unittype].size() < 1)
 245                         continue;
 246                 if (m_Fleet[unittype][0] == 0)
 247                         continue;
 248
 249
 250                 int totallost = fleet(unittype,1) - fleet(unittype, 0);
 251
 252
 253                 cerr << "Distributing type: " << unittype << " with a total loss of " << totallost << " units" << endl;
 254
 255                 cerr << "Total number of units before: " << fleet(unittype, 0)  << " and after : " << fleet(unittype, 1) << endl;
 256
 257                 for (vector<Fleet*>::iterator j = fleets.begin(); j != fleets.end(); ++j)
 258                 {
 259                         int fl1 = (*j)->fleet(unittype, tick - 1);
 260                         float part = float(fl1) / fleet(unittype, 0) ;
 261                         int lost =  totallost * part;
 262                         cerr << (*j)->name() << " gaining " << lost << " " << unittype  << " since it's " << part * 100 << "% of the whole fleet, and it had : " << fl1 << " units last tick.." <<  endl;
 263                         (*j)->setFleet(unittype, (*j)->fleet(unittype, tick - 1) + lost, tick);
 264                 }
 265         }
 266 }
 267
 268 //////////////////////////////////////////////////////////////////////////
 269 //
 270 std::vector<Fleet*> Fleet::calculateSide(std::vector<Fleet*> fleets, int stays = 0, int tick = 0)
 271 {
 272         vector<Fleet*> fl;
 273         for (vector<Fleet*>::iterator i = fleets.begin(); i != fleets.end(); ++i)
 274         {
 275                 if (( tick - (*i)->ETA()) >= 0 && (tick - (*i)->ETA()) < stays)
 276                 {
 277                         fl.push_back((*i));
 278                         cerr << "Using fleet " << (*i)->name() << " for tick " << tick << endl;
 279                 }
 280                 else if ((*i)->name() == "Home Planet")
 281                         fl.push_back((*i));
 282         }
 283         return fl;
 284 }
 285
 286 //////////////////////////////////////////////////////////////////////////
 287 //
 288 int Fleet::freeFleet(std:: string unittype, int tick = 0)
 289 {
 290         int bticks = m_BlockedFleet[unittype].size();
 291
 292         --bticks;
 293
 294         if (bticks < tick)
 295                 return fleet(unittype, tick);
 296
 297
 298         int free = fleet(unittype,tick) - m_BlockedFleet[unittype][tick];
 299         if (free < 0)
 300                 return 0;
 301         return free;
 302 }
 303
 304
 305 //////////////////////////////////////////////////////////////////////////
 306 //
 307 void Fleet::takeShoot(std::string unittype, int number, std::map<std::string, int>& hitunits)
 308 {
 309
 310         float guns = s_Units[unittype].guns() * number;
 311
 312         cerr << number << " " << unittype << ": with " << guns << " guns\n";
 313
 314         if (guns == 0)
 315                 return;
 316
 317         cerr << unittype << ": with " << guns << " guns\n";
 318
 319         float gunsleft = guns;
 320         for (int count = 0; count < 3; ++count)//vector<string>::iterator i = s_Units[unittype].target().begin(); i != s_Units[unittype].target().end(); ++i)
 321         {
 322                 string ta = s_Units[unittype].target(count);
 323         cerr << "Shooting at target class: " << ta << endl;
 324                 while (gunsleft > 0)
 325                 {
 326
 327                         map<string, int*> targets;
 328
 329                         for (UnitList::iterator j = s_Units.begin(); j != s_Units.end(); ++j)
 330                         {
 331
 332                                 if (m_Fleet[j->first].size() == 0)
 333                                         continue;
 334
 335                                 if (m_Fleet[j->first].size() == 1)
 336                                         m_Fleet[j->first].push_back(m_Fleet[j->first][0]);
 337
 338                                 //cerr << "Target is class: " << j->second.type() << endl;
 339
 340                                 if (m_Fleet[j->first][1] > 0  && ( ta == j->second.unitClass() || ta == "All"))
 341                                 {
 342
 343                                 //      cerr << "Looking at target: " << j->first << endl;
 344                                         targets[j->first] = &m_Fleet[j->first][1];
 345                                 }
 346
 347                         }
 348
 349                         if (targets.size() == 0)
 350                                 break;
 351
 352                         int total = 0;
 353                         for (map<string, int*>::iterator j = targets.begin(); j != targets.end(); ++j)
 354                                 total += (*j->second);
 355
 356                         for (map<string, int*>::iterator j = targets.begin(); j != targets.end(); ++j)
 357                         {
 358                                 float maxguns = float((*j->second))/total * guns;
 359                                 //cerr << "Now shooting at target: " << j->first << endl;
 360
 361                                 if (m_Armor[j->first] <= 0 || m_Armor[j->first] > s_Units[j->first].armor())
 362                                         m_Armor[j->first] = s_Units[j->first].armor();
 363                                 double k = maxguns;
 364
 365                                 //cerr << "Targets agility: " << s_Units[j->first].agility() << endl;
 366                                 //cerr << "Weaponspeed: " << s_Units[unittype].weaponSpeed() << endl;
 367                                 while (k > 0)
 368                                 {
 369
 370                                         if (*(j->second) <= 0)
 371                                                 break;
 372
 373                                         int wpsp = s_Units[unittype].weaponSpeed();
 374                                         int agil = s_Units[j->first].agility();
 375
 376                                         k -= float(100)/(25 + wpsp - agil);
 377                                         //cout << "Used " << blaha << " guns to hit with one shot.\n";
 378                                         //cout << "WPSP: " << wpsp << "\nAgil: " << agil << endl;
 379
 380                                         m_Armor[j->first] -= s_Units[unittype].power();
 381                                         if (m_Armor[j->first] <= 0)
 382                                         {
 383                                                 m_Armor[j->first] = s_Units[j->first].armor();
 384                                                 (*j->second)--;
 385                                                 hitunits[j->first]++;
 386
 387                                                 //There is a chance that we're hitting a blocked ship.
 388                                                 if (m_BlockedFleet[j->first].size() >= 1)
 389                                                 {
 390                                                         int test = rand() % m_BlockedFleet[j->first][0];
 391                                                         if (test == 1
 392                                                                 && m_BlockedFleet[j->first][0] > 0)
 393                                                         {
 394                                                                 if (m_BlockedFleet[j->first].size() == 1)
 395                                                                         m_BlockedFleet[j->first].push_back(m_BlockedFleet[j->first][0] - 1);
 396                                                                 else if (m_BlockedFleet[j->first][1] > 0)
 397                                                                         m_BlockedFleet[j->first][1]--;
 398                                                         }
 399                                                 }
 400                                         }
 401
 402                                 }
 403
 404                                 cerr << hitunits[j->first] << " units of type: " << j->first << "killed\n";
 405                                 if (k <= 0)
 406                                         gunsleft -= maxguns;
 407                                 else
 408                                         gunsleft -= maxguns - k;
 409                         }
 410                 }
 411         }
 412 }
 413
 414 //////////////////////////////////////////////////////////////////////////
 415 //
 416 void Fleet::takeEMP(std::string unittype, int number)
 417 {
 418         int guns = s_Units[unittype].guns() * number;
 419         if (guns == 0)
 420                 return;
 421
 422         cerr << unittype << ": with " << guns << " guns\n";
 423
 424         float gunsleft = guns;
 425         for (int count = 0; count < 3; ++count)//vector<string>::iterator i = s_Units[unittype].target().begin(); i != s_Units[unittype].target().end(); ++i)
 426         {
 427                 string ta = s_Units[unittype].target(count);
 428         cerr << "Shooting at target class: " << ta << endl;
 429                 while (gunsleft > 0)
 430                 {
 431
 432                         map<string, int*> targets;
 433
 434                         for (UnitList::iterator j = s_Units.begin(); j != s_Units.end(); ++j)
 435                         {
 436                                 if (j->second.type() == "PDS")
 437                                         continue;
 438
 439                                 if (m_Fleet[j->first].size() == 0)
 440                                         continue;
 441
 442                                 if (m_Fleet[j->first].size() == 1)
 443                                         m_Fleet[j->first].push_back(m_Fleet[j->first][0]);
 444
 445                                 //cerr << "Target is class: " << j->second.type() << endl;
 446
 447                                 if (m_Fleet[j->first][1] > 0  && ( ta == j->second.unitClass() || ta == "All"))
 448                                 {
 449
 450                                 //      cerr << "Looking at target: " << j->first << endl;
 451                                         targets[j->first] = &m_Fleet[j->first][1];
 452                                 }
 453
 454                         }
 455
 456                         if (targets.size() == 0)
 457                                 break;
 458
 459                         int total = 0;
 460                         for (map<string, int*>::iterator j = targets.begin(); j != targets.end(); ++j)
 461                                 total += (*j->second);
 462
 463                         for (map<string, int*>::iterator j = targets.begin(); j != targets.end(); ++j)
 464                         {
 465                                 int maxguns = (*j->second)/total * guns;
 466                                 cerr << "Now shooting at target: " << j->first << endl;
 467
 468                                 double k = maxguns;
 469
 470                                 int hits = 0;
 471
 472                                 while (k > 0)
 473                                 {
 474
 475                                         if (*(j->second) <= 0)
 476                                                 break;
 477
 478                                         int eres = s_Units[j->first].EMP();
 479
 480                                         k -= float(100)/(100-eres);
 481                                         hits++;
 482                                         blockFleet(j->first, 1);
 483                                 }
 484
 485                                 cerr << hits << " units of type: " << j->first << " blocked\n";
 486                                 if (k <= 0)
 487                                         gunsleft -= maxguns;
 488                                 else
 489                                         gunsleft -= maxguns - k;
 490                         }
 491                 }
 492         }
 493 }
 494
 495 //////////////////////////////////////////////////////////////////////////
 496 //
 497 void Fleet::killFleet(std::string unittype, int number, int tick = 0)
 498 {
 499         int earlier = 0;
 500         int ticks = m_Fleet[unittype].size();
 501
 502         if (ticks != 0)
 503                 earlier = m_Fleet[unittype][ticks - 1];
 504
 505         for (int i = ticks; i <= tick; ++i)
 506         {
 507                 m_Fleet[unittype].push_back(earlier);
 508         }
 509         m_Fleet[unittype][tick] -= number;
 510 }
 511
 512 //////////////////////////////////////////////////////////////////////////
 513 //
 514 void Fleet::setResource(std::string type, int number, int tick = 0)
 515 {
 516
 517         if (m_Resources[type].size() <= tick)
 518                 m_Resources[type].push_back(number);
 519         m_Resources[type][tick] = number;
 520 }
 521
 522 //////////////////////////////////////////////////////////////////////////
 523 //
 524 int Fleet::resource(std::string type, int tick = 0) const
 525 {
 526         vector<int>const* resource = 0;
 527         for (ResourceList::const_iterator i = m_Resources.begin(); i != m_Resources.end(); ++i)
 528         {
 529                 if (i->first == type)
 530                 {
 531                         resource = &i->second;
 532                         break;
 533                 }
 534         }
 535         if (resource == 0)
 536                 return 0;
 537
 538         int ticks = resource->size();
 539
 540         if( ticks == 0)
 541                 return 0;
 542
 543         --ticks;
 544
 545         if (ticks < tick)
 546                 return resource->at(ticks);
 547         return resource->at(tick);
 548 }
 549
 550 //////////////////////////////////////////////////////////////////////////
 551 //
 552 void Fleet::printFleet()
 553 {
 554         for (UnitList::iterator i = s_Units.begin(); i != s_Units.end(); ++i)
 555         {
 556                 for (int tick = 0; tick < 5 ;++tick)
 557                 {
 558                         int num = fleet(i->first, tick);
 559
 560                         if (num <= 0)
 561                                 break;
 562                         cerr << num << " " << i->first << " during tick: " << tick << endl;
 563                 }
 564         }
 565 }
 566
 567 //////////////////////////////////////////////////////////////////////////
 568 //
 569 void Fleet::blockFleet(std::string unittype, int number, int tick = 0)
 570 {
 571         if (m_BlockedFleet[unittype].size() >= 1)
 572         {
 573                 m_BlockedFleet[unittype][0] += number;
 574                 if (m_BlockedFleet[unittype].size() > 1)
 575                         m_BlockedFleet[unittype][1] += number;
 576                 else
 577                         m_BlockedFleet[unittype].push_back(m_BlockedFleet[unittype][0]);
 578         }
 579         else
 580         {
 581                 m_BlockedFleet[unittype].push_back(number);
 582                 m_BlockedFleet[unittype].push_back(number);
 583         }
 584 }