Spieler.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775
  1. #include "Spieler.h"
  2. #include "Team.h"
  3. #include "Laser.h"
  4. #include "Karte.h"
  5. #include "SSKlient.h"
  6. #include <iostream>
  7. // Inhalt der Spieler Klasse aus Spieler.h
  8. // Konstruktor
  9. Spieler::Spieler( SpielerStr *zStr )
  10. : Model2DObject()
  11. {
  12. activeSkills = new RCArray< ActiveSkill >();
  13. accountId = 0;
  14. sNum = zStr->id;
  15. farbe = 0;
  16. team = 0;
  17. klient = 0;
  18. level = 1;
  19. for( int i = 0; i < T_MAX; i++ )
  20. tastatur[ i ] = 0;
  21. amLeben = 1;
  22. schussAbk = 0;
  23. energieAbk = 0;
  24. repAbk = 0;
  25. reinkAbk = 0;
  26. maxReinkAbk = 5;
  27. startPos = zStr->pos;
  28. setPosition( startPos );
  29. setDrehung( (float)zStr->rot );
  30. beschleunigung = zStr->beschleunigung;
  31. energie = zStr->maxEnergie;
  32. stability = zStr->maxStability;
  33. reparatur = zStr->reparatur;
  34. laserIntensity = zStr->laserIntensity;
  35. laserEffizienz = zStr->laserEffizienz;
  36. akkuLeistung = zStr->akkuLeistung;
  37. maxEnergie = zStr->maxEnergie;
  38. maxStability = zStr->maxStability;
  39. laserTempo = zStr->laserTempo;
  40. netzwerk = zStr->netzwerk;
  41. wendigkeit = zStr->wendigkeit;
  42. antriebEffizienz = zStr->antriebEffizienz;
  43. energieSchild = zStr->energieSchild;
  44. energieSchildEffizienz = zStr->energieSchildEffizienz;
  45. skillPunkte = zStr->skillPunkte;
  46. schadenBekommen = 0;
  47. schadenGemacht = 0;
  48. treibstoffVerbraucht = 0;
  49. shots = 0;
  50. treffer = 0;
  51. punkte = 0;
  52. kills = 0;
  53. tode = 0;
  54. zeitAmLeben = 0;
  55. zeitTod = 0;
  56. ep = 0;
  57. nextSkillEp = 80;
  58. needWiederbelebung = 0;
  59. }
  60. // Destruktor
  61. Spieler::~Spieler()
  62. {
  63. if( team )
  64. team->release();
  65. if( klient )
  66. klient->release();
  67. activeSkills->release();
  68. }
  69. double Spieler::calculateBeschleunigung()
  70. {
  71. double factor = 1;
  72. double bonus = 0;
  73. for( auto s = activeSkills->getIterator(); s; s++ )
  74. {
  75. factor *= s->getBeschleunigungFactor();
  76. bonus += s->getBeschleunigungBonus();
  77. }
  78. return ( beschleunigung + team->beschleunigung ) * factor + bonus;
  79. }
  80. double Spieler::calculateReparatur()
  81. {
  82. double factor = 1;
  83. double bonus = 0;
  84. for( auto s = activeSkills->getIterator(); s; s++ )
  85. {
  86. factor *= s->getReparaturFactor();
  87. bonus += s->getReparaturBonus();
  88. }
  89. return ( reparatur + team->reparatur ) * factor + bonus;
  90. }
  91. double Spieler::calculateLaserIntensity()
  92. {
  93. double factor = 1;
  94. double bonus = 0;
  95. for( auto s = activeSkills->getIterator(); s; s++ )
  96. {
  97. factor *= s->getLaserIntensityFactor();
  98. bonus += s->getLaserIntensityBonus();
  99. }
  100. return ( laserIntensity + team->laserIntensity ) * factor + bonus;
  101. }
  102. double Spieler::calculateLaserEffizienz()
  103. {
  104. double factor = 1;
  105. double bonus = 0;
  106. for( auto s = activeSkills->getIterator(); s; s++ )
  107. {
  108. factor *= s->getLaserEffizienzFactor();
  109. bonus += s->getLaserEffizienzBonus();
  110. }
  111. return ( laserEffizienz + team->laserEffizienz ) * factor + bonus;
  112. }
  113. double Spieler::calculateAkkuLeistung()
  114. {
  115. double factor = 1;
  116. double bonus = 0;
  117. for( auto s = activeSkills->getIterator(); s; s++ )
  118. {
  119. factor *= s->getAkkuLeistungFactor();
  120. bonus += s->getAkkuLeistungBonus();
  121. }
  122. return ( akkuLeistung + team->akkuLeistung ) * factor + bonus;
  123. }
  124. double Spieler::calculateMaxEnergie()
  125. {
  126. double factor = 1;
  127. double bonus = 0;
  128. for( auto s = activeSkills->getIterator(); s; s++ )
  129. {
  130. factor *= s->getMaxEnergieFactor();
  131. bonus += s->getMaxEnergieBonus();
  132. }
  133. return ( maxEnergie + team->maxEnergie ) * factor + bonus;
  134. }
  135. double Spieler::calculateMaxStability()
  136. {
  137. double factor = 1;
  138. double bonus = 0;
  139. for( auto s = activeSkills->getIterator(); s; s++ )
  140. {
  141. factor *= s->getMaxStabilityFactor();
  142. bonus += s->getMaxStabilityBonus();
  143. }
  144. return ( maxStability + team->maxStability ) * factor + bonus;
  145. }
  146. double Spieler::calculateLaserTempo()
  147. {
  148. double factor = 1;
  149. double bonus = 0;
  150. for( auto s = activeSkills->getIterator(); s; s++ )
  151. {
  152. factor *= s->getLaserTempoFactor();
  153. bonus += s->getLaserTempoBonus();
  154. }
  155. return ( laserTempo + team->laserTempo ) * factor + bonus;
  156. }
  157. double Spieler::calculateWendigkeit()
  158. {
  159. double factor = 1;
  160. double bonus = 0;
  161. for( auto s = activeSkills->getIterator(); s; s++ )
  162. {
  163. factor *= s->getWendigkeitFactor();
  164. bonus += s->getWendigkeitBonus();
  165. }
  166. return ( wendigkeit + team->wendigkeit ) * factor + bonus;
  167. }
  168. double Spieler::calculateAntriebEffizienz()
  169. {
  170. double factor = 1;
  171. double bonus = 0;
  172. for( auto s = activeSkills->getIterator(); s; s++ )
  173. {
  174. factor *= s->getAntriebEffizienzFactor();
  175. bonus += s->getAntriebEffizienzBonus();
  176. }
  177. return ( antriebEffizienz + team->antriebEffizienz ) * factor + bonus;
  178. }
  179. double Spieler::calculateEnergieSchild()
  180. {
  181. double factor = 1;
  182. double bonus = 0;
  183. for( auto s = activeSkills->getIterator(); s; s++ )
  184. {
  185. factor *= s->getEnergieSchildFactor();
  186. bonus += s->getEnergieSchildBonus();
  187. }
  188. return ( energieSchild + team->energieSchild ) * factor + bonus;
  189. }
  190. double Spieler::calculateEnergieSchildEffizienz()
  191. {
  192. double factor = 1;
  193. double bonus = 0;
  194. for( auto s = activeSkills->getIterator(); s; s++ )
  195. {
  196. factor *= s->getEnergieSchildEffizienzFactor();
  197. bonus += s->getEnergieSchildEffizienzBonus();
  198. }
  199. return ( energieSchildEffizienz + team->energieSchildEffizienz ) * factor + bonus;
  200. }
  201. // nicht constant
  202. void Spieler::addSkill( ActiveSkill *skill )
  203. {
  204. activeSkills->add( skill );
  205. }
  206. void Spieler::useSkill( int id )
  207. {
  208. if( activeSkills->z( id ) )
  209. activeSkills->z( id )->activate();
  210. }
  211. void Spieler::offline()
  212. {
  213. klient->offline();
  214. }
  215. void Spieler::online( SSKlientV *zKlient )
  216. {
  217. klient->online( zKlient );
  218. }
  219. void Spieler::setModelData( Model2DData *data )
  220. {
  221. for( auto i = data->polygons->getIterator(); i; i++ )
  222. {
  223. if( i._.name->istGleich( "engine_l" ) )
  224. {
  225. stL = *i._.schwerpunkt;
  226. Vertex l, r;
  227. for( int j = 0; j < 4; j++ )
  228. {
  229. if( i._.tKordinaten->get( j ).y == 1.f )
  230. {
  231. if( i._.tKordinaten->get( j ).x == 0.f )
  232. l = i._.vertex->get( j );
  233. if( i._.tKordinaten->get( j ).x == 1.f )
  234. r = i._.vertex->get( j );
  235. }
  236. }
  237. kL = ( ( l + ( r - l ) * 0.5 ) - stL );
  238. }
  239. if( i._.name->istGleich( "engine_r" ) )
  240. {
  241. stR = *i._.schwerpunkt;
  242. Vertex l, r;
  243. for( int j = 0; j < 4; j++ )
  244. {
  245. if( i._.tKordinaten->get( j ).y == 1.f )
  246. {
  247. if( i._.tKordinaten->get( j ).x == 0.f )
  248. l = i._.vertex->get( j );
  249. if( i._.tKordinaten->get( j ).x == 1.f )
  250. r = i._.vertex->get( j );
  251. }
  252. }
  253. kR = ( ( l + ( r - l ) * 0.5 ) - stR );
  254. }
  255. if( i._.name->istGleich( "engine_m" ) )
  256. {
  257. stM = *i._.schwerpunkt;
  258. Vertex l, r;
  259. for( int j = 0; j < 4; j++ )
  260. {
  261. if( i._.tKordinaten->get( j ).y == 1.f )
  262. {
  263. if( i._.tKordinaten->get( j ).x == 0.f )
  264. l = i._.vertex->get( j );
  265. if( i._.tKordinaten->get( j ).x == 1.f )
  266. r = i._.vertex->get( j );
  267. }
  268. }
  269. kM = ( ( l + ( r - l ) * 0.5 ) - stM );
  270. }
  271. }
  272. kL.normalize();
  273. kR.normalize();
  274. kM.normalize();
  275. setModel( data );
  276. }
  277. void Spieler::setAccountId( int id )
  278. {
  279. accountId = id;
  280. }
  281. void Spieler::setTeam( Team *team )
  282. {
  283. if( this->team )
  284. this->team->release();
  285. this->team = team;
  286. }
  287. void Spieler::setSpielerFarbe( int farbe )
  288. {
  289. this->farbe = farbe;
  290. }
  291. void Spieler::setKlient( Klient *klient )
  292. {
  293. if( this->klient )
  294. this->klient->release();
  295. this->klient = klient;
  296. }
  297. bool Spieler::setTastataturStatus( TastaturStatus ts, bool aktiv )
  298. {
  299. if( tastatur[ ts ] == aktiv || !amLeben )
  300. return 0;
  301. tastatur[ ts ] = aktiv;
  302. return 1;
  303. }
  304. bool Spieler::tick( const WeltInfo &info, double zeit )
  305. {
  306. wInfo = info;
  307. if( !team )
  308. return 0;
  309. reinkAbk -= zeit;
  310. if( reinkAbk < 0 )
  311. reinkAbk = 0;
  312. if( !reinkAbk && !amLeben )
  313. { // Wiederbelebung
  314. needWiederbelebung = 1;
  315. return 0;
  316. }
  317. if( amLeben )
  318. {
  319. for( auto s = activeSkills->getIterator(); s; s++ )
  320. s->tick( zeit );
  321. schussAbk -= zeit;
  322. energieAbk -= zeit;
  323. if( schussAbk < 0 )
  324. schussAbk = 0;
  325. if( energieAbk < 0 )
  326. energieAbk = 0;
  327. repAbk -= zeit;
  328. if( repAbk < 0 )
  329. repAbk = 0;
  330. if( tastatur[ T_GAS ] )
  331. {
  332. double treibstoff = 0.5 * ( calculateBeschleunigung() / 15 )
  333. * zeit * ( 100 / calculateAntriebEffizienz() );
  334. treibstoffVerbraucht += treibstoff;
  335. float factor = 1;
  336. if( treibstoff > energie )
  337. factor = (float)( energie / treibstoff );
  338. if( factor > 0 )
  339. impuls( getWorldPos( stM ), getWorldDir( kM ) * (float)zeit * (float)calculateBeschleunigung() * factor );
  340. energie -= treibstoff * factor;
  341. }
  342. if( tastatur[ T_ROT_R ] )
  343. {
  344. double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
  345. * zeit * ( 100 / calculateAntriebEffizienz() );
  346. treibstoffVerbraucht += treibstoff;
  347. float factor = 1;
  348. if( treibstoff > energie )
  349. factor = (float)( energie / treibstoff );
  350. if( factor > 0 )
  351. impuls( getWorldPos( stL ), getWorldDir( kL ) * (float)zeit * (float)calculateWendigkeit() * factor );
  352. energie -= treibstoff * factor;
  353. }
  354. if( tastatur[ T_ROT_L ] )
  355. {
  356. double treibstoff = 0.25 * ( calculateWendigkeit() / 15 )
  357. * zeit * ( 100 / calculateAntriebEffizienz() );
  358. treibstoffVerbraucht += treibstoff;
  359. float factor = 1;
  360. if( treibstoff > energie )
  361. factor = (float)( energie / treibstoff );
  362. if( factor > 0 )
  363. impuls( getWorldPos( stR ), getWorldDir( kR ) * (float)zeit * (float)calculateWendigkeit() * factor );
  364. energie -= treibstoff * factor;
  365. }
  366. Model2DObject::tick( info, zeit );
  367. if( !energieAbk )
  368. {
  369. energie += calculateAkkuLeistung() * zeit;
  370. if( energie > calculateMaxEnergie() )
  371. energie = calculateMaxEnergie();
  372. }
  373. if( !repAbk )
  374. {
  375. stability += calculateReparatur() * zeit;
  376. if( stability > calculateMaxStability() )
  377. stability = calculateMaxStability();
  378. }
  379. zeitAmLeben += zeit;
  380. }
  381. else
  382. zeitTod += zeit;
  383. return 0;
  384. }
  385. bool Spieler::setSkill( int art )
  386. {
  387. if( !skillPunkte )
  388. return 0;
  389. skillPunkte--;
  390. switch( art )
  391. {
  392. case 0: // Max Stabilität
  393. maxStability += 10;
  394. stability += 10;
  395. team->maxStability = team->getMaxStabilityBonus();
  396. break;
  397. case 1: // Max Energie
  398. maxEnergie += 10;
  399. team->maxEnergie = team->getMaxEnergieBonus();
  400. break;
  401. case 2: // Reparatur
  402. reparatur += 0.15;
  403. team->reparatur = team->getReperaturBonus();
  404. break;
  405. case 3: // Laser Intensität
  406. laserIntensity += 4;
  407. team->laserIntensity = team->getLaserIntensityBonus();
  408. break;
  409. case 4: // Laser Effizienz
  410. laserEffizienz += 1.5;
  411. team->laserEffizienz = team->getLaserEffizienzBonus();
  412. break;
  413. case 5: // Laser Tempo
  414. laserTempo += 15;
  415. team->laserTempo = team->getLaserTempoBonus();
  416. break;
  417. case 6: // Beschleunigung
  418. beschleunigung += 10;
  419. team->beschleunigung = team->getBeschleunigungBonus();
  420. break;
  421. case 7: // Wendigkeit
  422. wendigkeit += 2.5;
  423. team->wendigkeit = team->getWendigkeitBonus();
  424. break;
  425. case 8: // Netzwerk
  426. netzwerk += 1;
  427. team->maxStability = team->getMaxStabilityBonus();
  428. team->maxEnergie = team->getMaxEnergieBonus();
  429. team->reparatur = team->getReperaturBonus();
  430. team->laserIntensity = team->getLaserIntensityBonus();
  431. team->laserEffizienz = team->getLaserEffizienzBonus();
  432. team->laserTempo = team->getLaserTempoBonus();
  433. team->beschleunigung = team->getBeschleunigungBonus();
  434. team->wendigkeit = team->getWendigkeitBonus();
  435. team->akkuLeistung = team->getAkkuLeistungBonus();
  436. team->antriebEffizienz = team->getAntriebEffizienzBonus();
  437. team->energieSchild = team->getEnergieSchildBonus();
  438. team->energieSchildEffizienz = team->getEnergieSchildEffizienzBonus();
  439. break;
  440. case 9: // Akkuleistung
  441. akkuLeistung += 0.12;
  442. team->akkuLeistung = team->getAkkuLeistungBonus();
  443. break;
  444. case 10: // Akkuleistung
  445. antriebEffizienz += 10;
  446. team->antriebEffizienz = team->getAntriebEffizienzBonus();
  447. break;
  448. case 11: // Energie Schild
  449. energieSchild += 0.075;
  450. team->energieSchild = team->getEnergieSchildBonus();
  451. break;
  452. case 12: // Energie Schild Effizienz
  453. energieSchildEffizienz += 10;
  454. team->energieSchildEffizienz = team->getEnergieSchildEffizienzBonus();
  455. break;
  456. }
  457. return 1;
  458. }
  459. Laser *Spieler::getLaser( int sId )
  460. {
  461. if( !amLeben || !tastatur[ T_FEUER ] || schussAbk || !team )
  462. return 0;
  463. double kosten = ( calculateLaserIntensity() / 2 +
  464. calculateLaserTempo() / 9 ) *
  465. ( 1 / ( calculateLaserEffizienz() / 25 ) );
  466. if( kosten < 1 )
  467. kosten = 1;
  468. if( kosten > energie )
  469. return 0;
  470. energie -= kosten;
  471. schussAbk = 1;
  472. energieAbk = 1.5;
  473. shots++;
  474. Vertex sSpeed = ( Vertex( lowPrecisionCos( rotation ), lowPrecisionSin( rotation ) ) * (float)calculateLaserTempo() );
  475. sSpeed += speed;
  476. return new Laser( sId, getPosition(), sSpeed, sNum, calculateLaserIntensity() );
  477. }
  478. bool Spieler::nimmSchaden( double &intensity, int sLevel )
  479. {
  480. double originalIntens = intensity;
  481. double schieldVal = intensity - intensity / calculateEnergieSchild();
  482. double schieldEVal = schieldVal / ( calculateEnergieSchildEffizienz() / 100 );
  483. if( schieldEVal > energie )
  484. {
  485. schieldEVal = energie;
  486. schieldVal = schieldEVal * ( calculateEnergieSchildEffizienz() / 100 );
  487. }
  488. intensity -= schieldVal;
  489. energie -= schieldEVal;
  490. stability -= intensity;
  491. schadenBekommen += intensity;
  492. energieAbk = 1.5;
  493. repAbk = 2;
  494. if( stability <= 0 )
  495. {
  496. amLeben = 0;
  497. setCollision( 0 );
  498. tode++;
  499. stability = 0;
  500. reinkAbk += maxReinkAbk;
  501. maxReinkAbk++;
  502. punkte--;
  503. }
  504. else
  505. {
  506. float levelFactor = (float)sLevel / (float)level;
  507. addEp( ( (float)originalIntens / 20 ) * levelFactor );
  508. }
  509. return stability == 0;
  510. }
  511. void Spieler::machSchaden( double intensity, int sLevel, bool erf )
  512. {
  513. schadenGemacht += intensity;
  514. addTreffer( (float)intensity, sLevel, erf );
  515. }
  516. void Spieler::addKill( int sLevel, bool erf )
  517. {
  518. float levelFactor = (float)sLevel / (float)level;
  519. if( erf )
  520. addEp( 80 * levelFactor );
  521. kills++;
  522. punkte++;
  523. maxReinkAbk--;
  524. if( maxReinkAbk < 5 )
  525. maxReinkAbk = 5;
  526. }
  527. void Spieler::addTreffer( float intensity, int sLevel, bool erf )
  528. {
  529. treffer++;
  530. float levelFactor = (float)sLevel / (float)level;
  531. if( erf )
  532. addEp( ( intensity / 10 ) * levelFactor );
  533. }
  534. void Spieler::wiederbeleben()
  535. {
  536. for( auto s = activeSkills->getIterator(); s; s++ )
  537. s->reset();
  538. needWiederbelebung = 0;
  539. setPosition( startPos );
  540. reinkAbk = maxReinkAbk * 2;
  541. energie = calculateMaxEnergie();
  542. stability = calculateMaxStability();
  543. schussAbk = 0;
  544. energieAbk = 0;
  545. repAbk = 0;
  546. setSpeed( 0, 0 );
  547. setDrehung( 0 );
  548. setDrehungSpeed( 0 );
  549. for( int i = 0; i < T_MAX; i++ )
  550. tastatur[ i ] = 0;
  551. amLeben = 1;
  552. setCollision( 1 );
  553. }
  554. void Spieler::addEp( float ep )
  555. {
  556. this->ep += ep;
  557. while( this->ep >= nextSkillEp )
  558. {
  559. level++;
  560. skillPunkte++;
  561. this->ep -= nextSkillEp;
  562. nextSkillEp *= 1.025f;
  563. }
  564. }
  565. // constant
  566. int Spieler::getAccountId() const
  567. {
  568. return accountId;
  569. }
  570. bool Spieler::istOnline() const
  571. {
  572. return klient ? klient->istOnline() : 0;
  573. }
  574. Klient *Spieler::zKlient() const
  575. {
  576. return klient;
  577. }
  578. bool Spieler::istTreffer( Vec2< float > pos ) const
  579. {
  580. if( !amLeben )
  581. return 0;
  582. return istPunktInnen( pos ) || istPunktInnen( pos + wInfo.size ) || istPunktInnen( pos + Punkt( wInfo.size.x, 0 ) ) || istPunktInnen( pos + Punkt( 0, wInfo.size.y ) ) ||
  583. istPunktInnen( pos + -wInfo.size ) || istPunktInnen( pos + Punkt( -wInfo.size.x, 0 ) ) || istPunktInnen( pos + Punkt( 0, -wInfo.size.y ) ) ||
  584. istPunktInnen( pos + Punkt( -wInfo.size.x, wInfo.size.y ) ) || istPunktInnen( pos + Punkt( wInfo.size.x, -wInfo.size.y ) );
  585. }
  586. // Raumschiff Eigenschaften
  587. double Spieler::getTeamMaxEnergieBonus() const
  588. {
  589. return maxEnergie / 100 * netzwerk;
  590. }
  591. double Spieler::getTeamMaxStabilityBonus() const
  592. {
  593. return maxStability / 100 * netzwerk;
  594. }
  595. double Spieler::getTeamReparaturBonus() const
  596. {
  597. return reparatur / 100 * netzwerk;
  598. }
  599. double Spieler::getTeamLaserIntensityBonus() const
  600. {
  601. return laserIntensity / 100 * netzwerk;
  602. }
  603. double Spieler::getTeamLaserEffizienzBonus() const
  604. {
  605. return laserEffizienz / 100 * netzwerk;
  606. }
  607. double Spieler::getTeamAkkuLeistungBonus() const
  608. {
  609. return akkuLeistung / 100 * netzwerk;
  610. }
  611. double Spieler::getTeamLaserTempoBonus() const
  612. {
  613. return laserTempo / 100 * netzwerk;
  614. }
  615. double Spieler::getTeamBeschleunigungBonus() const
  616. {
  617. return beschleunigung / 100 * netzwerk;
  618. }
  619. double Spieler::getTeamWendigkeitBonus() const
  620. {
  621. return wendigkeit / 100 * netzwerk;
  622. }
  623. double Spieler::getTeamAntriebEffizienzBonus() const
  624. {
  625. return antriebEffizienz / 100 * netzwerk;
  626. }
  627. double Spieler::getTeamEnergieSchildBonus() const
  628. {
  629. return energieSchild / 100 * netzwerk;
  630. }
  631. double Spieler::getTeamEnergieSchildEffizienzBonus() const
  632. {
  633. return energieSchildEffizienz / 100 * netzwerk;
  634. }
  635. bool Spieler::istAmLeben() const
  636. {
  637. return amLeben;
  638. }
  639. // Statistik Werte
  640. int Spieler::getSpielerNummer() const
  641. {
  642. return sNum;
  643. }
  644. Team *Spieler::zTeam() const
  645. {
  646. return team;
  647. }
  648. int Spieler::getSpielerFarbe() const
  649. {
  650. return farbe;
  651. }
  652. int Spieler::getSchadenBekommen() const
  653. {
  654. return (int)schadenBekommen;
  655. }
  656. int Spieler::getSchadenGemacht() const
  657. {
  658. return (int)schadenGemacht;
  659. }
  660. int Spieler::getTreibstoffVerbraucht() const
  661. {
  662. return (int)treibstoffVerbraucht;
  663. }
  664. int Spieler::getShots() const
  665. {
  666. return shots;
  667. }
  668. int Spieler::getTreffer() const
  669. {
  670. return treffer;
  671. }
  672. int Spieler::getPunkte() const
  673. {
  674. return punkte;
  675. }
  676. int Spieler::getKills() const
  677. {
  678. return kills;
  679. }
  680. int Spieler::getTode() const
  681. {
  682. return tode;
  683. }
  684. int Spieler::getZeitAmLeben() const
  685. {
  686. return (int)zeitAmLeben;
  687. }
  688. int Spieler::getZeitTod() const
  689. {
  690. return (int)zeitTod;
  691. }
  692. bool Spieler::doNeedWiederbelebung() const
  693. {
  694. return needWiederbelebung;
  695. }
  696. float Spieler::getEp() const
  697. {
  698. return ep;
  699. }
  700. int Spieler::getSkillP() const
  701. {
  702. return skillPunkte;
  703. }
  704. int Spieler::getLevel() const
  705. {
  706. return level;
  707. }