Spieler.cpp 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948
  1. #include "Spieler.h"
  2. #include "Spiel.h"
  3. #include "BosheitRune.h"
  4. #include "Enterhaken.h"
  5. #include "Geist.h"
  6. #include "Leben.h"
  7. #include "LebenRune.h"
  8. #include "Rolle.h"
  9. #include "Schild.h"
  10. #include "Schuh.h"
  11. #include "StrengthRune.h"
  12. #include "Sturm.h"
  13. #include "TempoRune.h"
  14. Inventar::Inventar()
  15. {
  16. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  17. {
  18. slots[ i ] = KEIN_GEGENSTAND;
  19. anzahl[ i ] = 0;
  20. abklingzeit[ i ] = 0;
  21. }
  22. selected = 0;
  23. }
  24. void Inventar::addItem( GegenstandTyp typ, int anzahl )
  25. {
  26. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  27. {
  28. if( slots[ i ] == typ )
  29. {
  30. this->anzahl[ i ] += anzahl;
  31. return;
  32. }
  33. }
  34. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  35. {
  36. if( slots[ i ] == KEIN_GEGENSTAND )
  37. {
  38. slots[ i ] = typ;
  39. this->anzahl[ i ] = consumable( typ ) ? anzahl : 1;
  40. return;
  41. }
  42. }
  43. }
  44. void Inventar::setSelected( int slot )
  45. {
  46. selected = slot;
  47. if( selected >= INVENTORY_SLOTS )
  48. selected = INVENTORY_SLOTS - 1;
  49. }
  50. bool Inventar::hatAbklingzeit( GegenstandTyp typ ) const
  51. {
  52. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  53. if( slots[ i ] == typ && abklingzeit[ i ] > 0 )
  54. return 1;
  55. return 0;
  56. }
  57. GegenstandTyp Inventar::useItem()
  58. {
  59. if( slots[ selected ] != KEIN_GEGENSTAND && abklingzeit[ selected ] <= 0 )
  60. {
  61. if( consumable( slots[ selected ] ) )
  62. {
  63. if( !--anzahl[ selected ] )
  64. {
  65. GegenstandTyp typ = slots[ selected ];
  66. slots[ selected ] = KEIN_GEGENSTAND;
  67. return typ;
  68. }
  69. }
  70. abklingzeit[ selected ] = ::abklingzeit( slots[ selected ] );
  71. return slots[ selected ];
  72. }
  73. return KEIN_GEGENSTAND;
  74. }
  75. void Inventar::tick( double zeit )
  76. {
  77. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  78. {
  79. if( slots[ i ] != KEIN_GEGENSTAND && abklingzeit[ i ] > 0 )
  80. {
  81. abklingzeit[ i ] -= (float)zeit;
  82. if( abklingzeit[ i ] < 0 )
  83. abklingzeit[ i ] = 0;
  84. }
  85. }
  86. }
  87. bool Inventar::canAddItem( GegenstandTyp typ ) const
  88. {
  89. if( !consumable( typ ) )
  90. {
  91. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  92. {
  93. if( slots[ i ] == typ )
  94. return 0;
  95. }
  96. }
  97. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  98. {
  99. if( slots[ i ] == KEIN_GEGENSTAND || ( slots[ i ] == typ && consumable( typ ) ) )
  100. return 1;
  101. }
  102. return 0;
  103. }
  104. GegenstandTyp Inventar::selectedItem() const
  105. {
  106. return slots[ selected ];
  107. }
  108. int Inventar::getItemAnzahl() const
  109. {
  110. int sum = 0;
  111. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  112. sum += anzahl[ i ];
  113. return sum;
  114. }
  115. int Inventar::getItemAnzahl( GegenstandTyp typ ) const
  116. {
  117. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  118. {
  119. if( slots[ i ] == typ )
  120. return anzahl[ i ];
  121. }
  122. return 0;
  123. }
  124. GegenstandTyp Inventar::getItemTyp( int index ) const
  125. {
  126. if( index < 0 || index >= INVENTORY_SLOTS )
  127. return KEIN_GEGENSTAND;
  128. return slots[ index ];
  129. }
  130. void Inventar::removeItem( GegenstandTyp typ, int anzahl )
  131. {
  132. for( int i = 0; i < INVENTORY_SLOTS; i++ )
  133. {
  134. if( slots[ i ] == typ )
  135. {
  136. this->anzahl[ i ] -= anzahl;
  137. if( this->anzahl[ i ] < 0 )
  138. {
  139. slots[ i ] = KEIN_GEGENSTAND;
  140. abklingzeit[ i ] = 0;
  141. }
  142. }
  143. }
  144. }
  145. Spieler::Spieler( int id, Team *team, int spawnX, int spawnY, int farbe )
  146. : GameObject( SPIELER, spawnX, spawnY, 40, 50 )
  147. {
  148. klient = 0;
  149. accountId = 0;
  150. spielerNummer = id;
  151. this->team = team;
  152. amLeben = 1;
  153. maxWiederbelebungsZeit = 2;
  154. wiederbelebungsZeit = 0;
  155. zuletztAufgehoben = KEIN_GEGENSTAND;
  156. zuletztAktiviert = KEIN_GEGENSTAND;
  157. this->leben = 300;
  158. this->maxLeben = 300;
  159. level = 1;
  160. erfahrung = 0;
  161. maxErfahrung = 5;
  162. this->spawnX = spawnX;
  163. this->spawnY = spawnY;
  164. laufTempo = 30;
  165. geschossTempo = 100;
  166. armor = 0;
  167. schadensBonus = 0;
  168. lebensraub = 0;
  169. lebensRegeneration = 1;
  170. abklingZeitVerringerung = 0;
  171. color = farbe;
  172. kills = 0;
  173. tode = 0;
  174. treffer = 0;
  175. getroffen = 0;
  176. schadenGenommen = 0;
  177. schadenGemacht = 0;
  178. lebenGeheilt = 0;
  179. erhalteneErfahrung = 0;
  180. itemsAufgehoben = 0;
  181. itemsVerwendet = 0;
  182. tunnelBenutzt = 0;
  183. schalterAktiviert = 0;
  184. geschosseGeschossen = 0;
  185. for( int i = 0; i < 256; i++ )
  186. tastenStand[ i ] = 0;
  187. ausrichtung = MITTE;
  188. }
  189. Spieler::~Spieler()
  190. {
  191. if( klient )
  192. klient->release();
  193. if( team )
  194. team->release();
  195. }
  196. bool Spieler::setTastenStand( unsigned char taste, bool pressed )
  197. {
  198. bool ret = tastenStand[ (int)taste ] != pressed;
  199. tastenStand[ (int)taste ] = pressed;
  200. if( pressed )
  201. {
  202. if( taste == 'w' )
  203. ausrichtung = OBEN;
  204. if( taste == 'a' )
  205. ausrichtung = LINKS;
  206. if( taste == 's' )
  207. ausrichtung = UNTEN;
  208. if( taste == 'd' )
  209. ausrichtung = RECHTS;
  210. if( taste >= '1' && taste <= '8' )
  211. inv.setSelected( taste - '1' );
  212. }
  213. else
  214. {
  215. if( !tastenStand[ 'w' ] && !tastenStand[ 'a' ] && !tastenStand[ 's' ] && !tastenStand[ 'd' ] )
  216. ausrichtung = MITTE;
  217. else
  218. {
  219. if( ( ausrichtung == OBEN && taste == 'w' ) ||
  220. ( ausrichtung == LINKS && taste == 'a' ) ||
  221. ( ausrichtung == UNTEN && taste == 's' ) ||
  222. ( ausrichtung == RECHTS && taste == 'd' ) )
  223. {
  224. if( tastenStand[ 'w' ] )
  225. ausrichtung = OBEN;
  226. if( tastenStand[ 'a' ] )
  227. ausrichtung = LINKS;
  228. if( tastenStand[ 's' ] )
  229. ausrichtung = UNTEN;
  230. if( tastenStand[ 'd' ] )
  231. ausrichtung = RECHTS;
  232. }
  233. }
  234. }
  235. return ret;
  236. }
  237. void Spieler::setTeam( Team *team )
  238. {
  239. if( this->team )
  240. this->team->removeSpieler();
  241. this->team->release();
  242. this->team = team;
  243. if( this->team )
  244. this->team->addSpieler();
  245. }
  246. void Spieler::setAccount( int id )
  247. {
  248. this->accountId = id;
  249. }
  250. void Spieler::setKlient( Klient *klient )
  251. {
  252. if( this->klient )
  253. this->klient->release();
  254. this->klient = klient;
  255. }
  256. void Spieler::addEffekt( Effect *e )
  257. {
  258. effekte.add( e );
  259. }
  260. void Spieler::setLaufTempo( float pps )
  261. {
  262. laufTempo = pps;
  263. }
  264. void Spieler::addErfahrung( float anz, Spiel *zSpiel )
  265. {
  266. erfahrung += anz;
  267. zSpiel->setSpielerZuletztErfahrungBekommen( (Spieler *)getThis() );
  268. Ereignis *e = new Ereignis( SPIELER_BEKOMMT_ERFAHRUNG );
  269. e->addParameter( "Betroffener Spieler", getThis() );
  270. e->addParameter( "Wert", new Float( anz ) );
  271. zSpiel->throwEvent( e );
  272. while( erfahrung > maxErfahrung )
  273. levelUp( zSpiel );
  274. while( erfahrung < 0 )
  275. levelDown( zSpiel );
  276. }
  277. void Spieler::levelUp( Spiel *zSpiel )
  278. {
  279. level++;
  280. erfahrung -= (float)maxErfahrung;
  281. maxErfahrung += ( maxErfahrung / level ) + 2;
  282. maxLeben += 20;
  283. heilung( 20, zSpiel );
  284. if( level <= 10 )
  285. {
  286. laufTempo += 2;
  287. geschossTempo += 2;
  288. }
  289. if( level <= 50 )
  290. {
  291. armor += 1;
  292. abklingZeitVerringerung += 1;
  293. }
  294. if( level <= 75 )
  295. {
  296. schadensBonus += 1;
  297. lebensraub += 1;
  298. }
  299. if( level <= 100 )
  300. lebensRegeneration += 0.25f;
  301. zSpiel->setSpielerZuletztLevelUp( (Spieler *)getThis() );
  302. Ereignis *e = new Ereignis( SPIELER_LEVEL_UP );
  303. e->addParameter( "Betroffener Spieler", getThis() );
  304. zSpiel->throwEvent( e );
  305. }
  306. void Spieler::levelDown( Spiel *zSpiel )
  307. {
  308. if( level <= 100 )
  309. lebensRegeneration -= 0.25f;
  310. if( level <= 75 )
  311. {
  312. schadensBonus -= 1;
  313. lebensraub -= 1;
  314. }
  315. if( level <= 50 )
  316. {
  317. armor -= 1;
  318. abklingZeitVerringerung -= 1;
  319. }
  320. if( level <= 10 )
  321. {
  322. laufTempo -= 2;
  323. geschossTempo -= 2;
  324. }
  325. maxLeben -= 20;
  326. maxErfahrung -= ( maxErfahrung / level ) + 2;
  327. erfahrung += (float)maxErfahrung;
  328. level--;
  329. }
  330. void Spieler::addTunnelBenutzung( Spiel *zSpiel )
  331. {
  332. tunnelBenutzt++;
  333. zSpiel->setSpielerZuletztTunnelBenutzt( (Spieler *)getThis() );
  334. }
  335. void Spieler::addSchalterBenutzung( Spiel *zSpiel )
  336. {
  337. schalterAktiviert++;
  338. zSpiel->setSpielerZuletztSchalterAktiviert( (Spieler *)getThis() );
  339. }
  340. // aktualisiert auch die team statistik
  341. void Spieler::addKill()
  342. {
  343. team->addKill();
  344. kills++;
  345. }
  346. void Spieler::addTreffer( Spiel *zSpiel )
  347. {
  348. addErfahrung( 2, zSpiel );
  349. treffer++;
  350. }
  351. void Spieler::addGetroffen()
  352. {
  353. getroffen++;
  354. }
  355. void Spieler::move( double zeit )
  356. {
  357. if( istAmLeben() )
  358. {
  359. if( tastenStand[ 'w' ] && istBeweglich( OBEN ) )
  360. y -= laufTempo * (float)zeit;
  361. if( tastenStand[ 'a' ] && istBeweglich( LINKS ) )
  362. x -= laufTempo * (float)zeit;
  363. if( tastenStand[ 's' ] && istBeweglich( UNTEN ) )
  364. y += laufTempo * (float)zeit;
  365. if( tastenStand[ 'd' ] && istBeweglich( RECHTS ) )
  366. x += laufTempo * (float)zeit;
  367. for( auto e = effekte.getIterator(); e; e++ )
  368. e->move( zeit );
  369. }
  370. }
  371. void Spieler::wiederbelebung( Spiel *zSpiel )
  372. {
  373. amLeben = 1;
  374. leben = (float)maxLeben;
  375. zSpiel->setSpielerZuletztWiederbelebt( (Spieler *)getThis() );
  376. Ereignis *e = new Ereignis( SPIELER_WIEDERBELEBT );
  377. e->addParameter( "Betroffener Spieler", getThis() );
  378. zSpiel->throwEvent( e );
  379. }
  380. void Spieler::tick( double zeit, Spiel *zSpiel )
  381. {
  382. if( istAmLeben() )
  383. {
  384. for( int i = 0; i < effekte.getEintragAnzahl(); i++ )
  385. {
  386. if( effekte.z( i )->tick( zeit, zSpiel ) && istAmLeben() )
  387. {
  388. effekte.remove( i );
  389. i--;
  390. }
  391. if( !istAmLeben() )
  392. break;
  393. }
  394. if( tastenStand[ ' ' ] )
  395. useItem( zSpiel );
  396. if( tastenStand[ 'e' ] )
  397. zSpiel->spielerActivate( this );
  398. heilung( lebensRegeneration * (float)zeit, zSpiel );
  399. }
  400. else
  401. {
  402. effekte.leeren();
  403. wiederbelebungsZeit -= (float)zeit;
  404. if( wiederbelebungsZeit <= 0 )
  405. {
  406. wiederbelebung( zSpiel );
  407. }
  408. }
  409. inv.tick( zeit );
  410. }
  411. void Spieler::useItem( Spiel *zSpiel )
  412. {
  413. if( istAmLeben() && inv.selectedItem() != KEIN_GEGENSTAND && istGegenstandErlaubt( inv.selectedItem() ) )
  414. {
  415. zSpiel->setSpielerZuletztGegenstandAktiviert( (Spieler *)getThis() );
  416. itemsVerwendet++;
  417. GegenstandTyp typ = inv.useItem();
  418. zSpiel->setItemZuletztAktiviert( typ );
  419. switch( typ )
  420. {
  421. case PFEIL:
  422. geschosseGeschossen++;
  423. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  424. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_PFEIL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
  425. break;
  426. case LEBEN:
  427. addEffekt( new LebenEffect( this ) );
  428. break;
  429. case SCHILD:
  430. addEffekt( new SchildEffect( this ) );
  431. break;
  432. case SCHUH:
  433. addEffekt( new SchuhEffect( this ) );
  434. break;
  435. case GEIST:
  436. addEffekt( new GeistEffect( this ) );
  437. break;
  438. case KUGEL:
  439. geschosseGeschossen++;
  440. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  441. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
  442. break;
  443. case ROLLE:
  444. addEffekt( new RolleEffect( this, getAusrichtung() ) );
  445. break;
  446. case STURM:
  447. addEffekt( new SturmEffect( this, getAusrichtung() ) );
  448. break;
  449. case DRACHENAUGE:
  450. geschosseGeschossen++;
  451. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  452. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_DRACHENAUGE, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
  453. break;
  454. case FEUERBALL:
  455. geschosseGeschossen++;
  456. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  457. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x, (int)y, (Spieler *)getThis() ) );
  458. break;
  459. case ENTERHAKEN:
  460. addEffekt( new EnterhakenEffect( this, getAusrichtung() ) );
  461. break;
  462. case MINE:
  463. geschosseGeschossen++;
  464. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  465. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), 0, GESCHOSS_MINE, MITTE, (int)x, (int)y, (Spieler *)getThis() ) );
  466. break;
  467. default:
  468. break;
  469. }
  470. Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
  471. e->addParameter( "Betroffener Spieler", getThis() );
  472. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  473. zSpiel->throwEvent( e );
  474. }
  475. }
  476. bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
  477. {
  478. if( storable( typ ) )
  479. {
  480. if( inv.canAddItem( typ ) )
  481. {
  482. zSpiel->setItemZuletztAufgehoben( typ );
  483. zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
  484. itemsAufgehoben += anz;
  485. inv.addItem( typ, anz );
  486. Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
  487. e->addParameter( "Betroffener Spieler", getThis() );
  488. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  489. e->addParameter( "Anzahl", new Integer( anz ) );
  490. zSpiel->throwEvent( e );
  491. return 1;
  492. }
  493. }
  494. else
  495. {
  496. zSpiel->setItemZuletztAufgehoben( typ );
  497. zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
  498. itemsAufgehoben += anz;
  499. Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
  500. e->addParameter( "Betroffener Spieler", getThis() );
  501. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  502. e->addParameter( "Anzahl", new Integer( anz ) );
  503. zSpiel->throwEvent( e );
  504. for( int i = 0; i < anz; i++ )
  505. {
  506. Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
  507. e->addParameter( "Betroffener Spieler", getThis() );
  508. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  509. zSpiel->throwEvent( e );
  510. itemsVerwendet++;
  511. switch( typ )
  512. {
  513. case RWEISHEIT:
  514. addErfahrung( 2, zSpiel );
  515. break;
  516. case RSTRENGTH:
  517. addEffekt( new StrengthRuneEffect( this ) );
  518. break;
  519. case RBOSHEIT:
  520. addEffekt( new BosheitRuneEffect( this ) );
  521. break;
  522. case RLEBEN:
  523. addEffekt( new LebenRuneEffect( this ) );
  524. break;
  525. case RTEMPO:
  526. addEffekt( new TempoRuneEffect( this ) );
  527. break;
  528. default:
  529. break;
  530. }
  531. }
  532. }
  533. return 0;
  534. }
  535. // heilt auch um den lebensraub prozentsatz
  536. void Spieler::addGemachterSchaden( float schaden, Spiel *zSpiel )
  537. {
  538. zSpiel->setSpielerZuletztSchadenGemacht( (Spieler *)getThis() );
  539. schadenGemacht += schaden;
  540. heilung( schaden / 100 * lebensraub, zSpiel );
  541. Ereignis *e = new Ereignis( SPIELER_MACHT_SCHADEN );
  542. e->addParameter( "Betroffener Spieler", getThis() );
  543. e->addParameter( "Wert", new Float( schaden ) );
  544. zSpiel->throwEvent( e );
  545. }
  546. // zieht die rüstung ab
  547. void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spiel *zSpiel )
  548. {
  549. if( !isVerwundbar( r ) || !istAmLeben() )
  550. return;
  551. if( zVerursacher )
  552. schaden += schaden / 100 * zVerursacher->getSchadenBonus();
  553. schaden -= schaden / 100 * armor;
  554. schaden = leben < schaden ? leben : schaden;
  555. schadenGenommen += schaden;
  556. leben -= schaden;
  557. zSpiel->setSpielerZuletztSchadenGenommen( (Spieler *)getThis() );
  558. if( zVerursacher )
  559. zVerursacher->addGemachterSchaden( schaden, zSpiel );
  560. Ereignis *e = new Ereignis( SPIELER_NIMMT_SCHADEN );
  561. e->addParameter( "Betroffener Spieler", getThis() );
  562. e->addParameter( "Wert", new Float( schaden ) );
  563. zSpiel->throwEvent( e );
  564. if( leben == 0 )
  565. {
  566. wiederbelebungsZeit = (float)( (float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
  567. wiederbelebungsZeit -= wiederbelebungsZeit / 100 * abklingZeitVerringerung;
  568. team->addTod();
  569. amLeben = 0;
  570. tode++;
  571. zSpiel->setSpielerZuletztGestorben( (Spieler *)getThis() );
  572. if( zVerursacher )
  573. zVerursacher->addKill();
  574. Ereignis *e = new Ereignis( SPIELER_STIRBT );
  575. e->addParameter( "Betroffener Spieler", getThis() );
  576. zSpiel->throwEvent( e );
  577. }
  578. }
  579. void Spieler::heilung( float heal, Spiel *zSpiel )
  580. {
  581. if( istAmLeben() )
  582. {
  583. lebenGeheilt += heal;
  584. leben += heal;
  585. zSpiel->setSpielerZuletztGeheilt( (Spieler *)getThis() );
  586. Ereignis *e = new Ereignis( SPIELER_WIRD_GEHEILT );
  587. e->addParameter( "Betroffener Spieler", getThis() );
  588. e->addParameter( "Wert", new Float( heal ) );
  589. zSpiel->throwEvent( e );
  590. }
  591. }
  592. void Spieler::setSchadenBonus( float bonus )
  593. {
  594. schadensBonus = bonus;
  595. }
  596. void Spieler::setLebensRaub( float raub )
  597. {
  598. lebensraub = raub;
  599. }
  600. void Spieler::setGeschossTempo( float tempo )
  601. {
  602. geschossTempo = tempo;
  603. }
  604. void Spieler::setArmor( float armor )
  605. {
  606. this->armor = armor;
  607. }
  608. void Spieler::setLebensRegeneration( float reg )
  609. {
  610. lebensRegeneration = reg;
  611. }
  612. void Spieler::setName( const char *name )
  613. {
  614. this->name = name;
  615. }
  616. void Spieler::setLevel( int level, Spiel *zSpiel )
  617. {
  618. if( level < 0 || level > 100 )
  619. return;
  620. while( level > this->level )
  621. levelUp( zSpiel );
  622. while( level < this->level )
  623. levelDown( zSpiel );
  624. erfahrung = 0;
  625. }
  626. void Spieler::removeItem( GegenstandTyp typ, int anzahl )
  627. {
  628. inv.removeItem( typ, anzahl );
  629. }
  630. void Spieler::setLeben( float leben )
  631. {
  632. this->leben = leben;
  633. if( this->leben < 0 )
  634. {
  635. this->leben = 0;
  636. // the player is now undead :D
  637. }
  638. if( this->leben > maxLeben )
  639. this->leben = (float)maxLeben;
  640. }
  641. void Spieler::setMaxLeben( int leben )
  642. {
  643. maxLeben = leben;
  644. if( maxLeben < 1 )
  645. maxLeben = 1;
  646. if( this->leben > maxLeben )
  647. this->leben = (float)maxLeben;
  648. }
  649. void Spieler::setErfahrung( float erf, Spiel *zSpiel )
  650. {
  651. erfahrung = erf;
  652. while( erfahrung < 0 )
  653. levelDown( zSpiel );
  654. while( erfahrung >= maxErfahrung )
  655. levelUp( zSpiel );
  656. }
  657. void Spieler::setMaxErfahrung( int erf )
  658. {
  659. this->maxErfahrung = erf;
  660. }
  661. void Spieler::setAbklingZeitVerringerung( float verringerung )
  662. {
  663. abklingZeitVerringerung = verringerung;
  664. }
  665. float Spieler::getLebensRegenneration() const
  666. {
  667. return lebensRegeneration;
  668. }
  669. float Spieler::getArmor() const
  670. {
  671. return armor;
  672. }
  673. float Spieler::getGeschossTempo() const
  674. {
  675. return geschossTempo;
  676. }
  677. float Spieler::getLebensRaub() const
  678. {
  679. return lebensraub;
  680. }
  681. float Spieler::getSchadenBonus() const
  682. {
  683. return schadensBonus;
  684. }
  685. Klient *Spieler::zKlient() const
  686. {
  687. return klient;
  688. }
  689. Team *Spieler::zTeam() const
  690. {
  691. return team;
  692. }
  693. Team *Spieler::getTeam() const
  694. {
  695. return team ? (Team *)team->getThis() : 0;
  696. }
  697. int Spieler::getFarbe() const
  698. {
  699. return color;
  700. }
  701. int Spieler::getAccountId() const
  702. {
  703. return accountId;
  704. }
  705. int Spieler::getPunkte() const
  706. {
  707. return kills - tode + ( treffer - getroffen ) / 2;
  708. }
  709. bool Spieler::istAmLeben() const
  710. {
  711. return amLeben && accountId;
  712. }
  713. float Spieler::getLaufTempo() const
  714. {
  715. return laufTempo;
  716. }
  717. bool Spieler::isVerwundbar( Richtung r ) const
  718. {
  719. bool verwundbar = 1;
  720. for( auto e = effekte.getIterator(); e; e++ )
  721. {
  722. verwundbar &= e->istSpielerVerwundbar( r );
  723. if( !verwundbar )
  724. return 0;
  725. }
  726. return 1;
  727. }
  728. bool Spieler::istBeweglich( Richtung r ) const
  729. {
  730. bool beweglich = 1;
  731. for( auto e = effekte.getIterator(); e; e++ )
  732. {
  733. beweglich &= e->istSpielerBeweglich( r );
  734. if( !beweglich )
  735. return 0;
  736. }
  737. return 1;
  738. }
  739. bool Spieler::istSichtbar( Team *zTeam ) const
  740. {
  741. bool sichtbar = 1;
  742. for( auto e = effekte.getIterator(); e; e++ )
  743. {
  744. sichtbar &= e->istSpielerSichtbar( zTeam );
  745. if( !sichtbar )
  746. return 0;
  747. }
  748. return 1;
  749. }
  750. bool Spieler::istGegenstandErlaubt( GegenstandTyp typ ) const
  751. {
  752. bool erlaubt = !brauchtRichtung( typ ) || ausrichtung != MITTE;
  753. for( auto e = effekte.getIterator(); e; e++ )
  754. {
  755. erlaubt &= e->istGegenstandErlaubt( typ );
  756. if( !erlaubt )
  757. return 0;
  758. }
  759. return !inv.hatAbklingzeit( typ );
  760. }
  761. Richtung Spieler::getAusrichtung() const
  762. {
  763. return ausrichtung;
  764. }
  765. float Spieler::getAbklingZeitVerringerung() const
  766. {
  767. return abklingZeitVerringerung;
  768. }
  769. int Spieler::getId() const
  770. {
  771. return spielerNummer;
  772. }
  773. int Spieler::getLevel() const
  774. {
  775. return level;
  776. }
  777. float Spieler::getLeben() const
  778. {
  779. return leben;
  780. }
  781. int Spieler::getMaxLeben() const
  782. {
  783. return maxLeben;
  784. }
  785. float Spieler::getErfahrung() const
  786. {
  787. return erfahrung;
  788. }
  789. int Spieler::getMaxErfahrung() const
  790. {
  791. return maxErfahrung;
  792. }
  793. int Spieler::getTode() const
  794. {
  795. return tode;
  796. }
  797. int Spieler::getKills() const
  798. {
  799. return kills;
  800. }
  801. int Spieler::getTreffer() const
  802. {
  803. return treffer;
  804. }
  805. int Spieler::getGetroffen() const
  806. {
  807. return getroffen;
  808. }
  809. float Spieler::getErlittenerSchaden() const
  810. {
  811. return schadenGenommen;
  812. }
  813. float Spieler::getGemachterSchaden() const
  814. {
  815. return schadenGemacht;
  816. }
  817. float Spieler::getGeheiltesLeben() const
  818. {
  819. return lebenGeheilt;
  820. }
  821. int Spieler::getItemsAufgehoben() const
  822. {
  823. return itemsAufgehoben;
  824. }
  825. int Spieler::getItemsVerwendet() const
  826. {
  827. return itemsVerwendet;
  828. }
  829. int Spieler::getItemsInInventory() const
  830. {
  831. return inv.getItemAnzahl();
  832. }
  833. int Spieler::getItemsInInventory( GegenstandTyp typ ) const
  834. {
  835. return inv.getItemAnzahl( typ );
  836. }
  837. int Spieler::getTunnelBenutzt() const
  838. {
  839. return tunnelBenutzt;
  840. }
  841. int Spieler::getSchalterAktiviert() const
  842. {
  843. return schalterAktiviert;
  844. }
  845. int Spieler::getGeschossen() const
  846. {
  847. return geschosseGeschossen;
  848. }
  849. GegenstandTyp Spieler::getInventorySlot( int index ) const
  850. {
  851. return inv.getItemTyp( index );
  852. }
  853. const char *Spieler::getName() const
  854. {
  855. return name;
  856. }