Spieler.cpp 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957
  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( Richtung r, double zeit )
  356. {
  357. if( istAmLeben() )
  358. {
  359. if( istBeweglich( r ) )
  360. {
  361. if( tastenStand[ 'w' ] && r == OBEN )
  362. y -= laufTempo * (float)zeit;
  363. if( tastenStand[ 'a' ] && r == LINKS )
  364. x -= laufTempo * (float)zeit;
  365. if( tastenStand[ 's' ] && r == UNTEN )
  366. y += laufTempo * (float)zeit;
  367. if( tastenStand[ 'd' ] && r == RECHTS )
  368. x += laufTempo * (float)zeit;
  369. }
  370. for( auto e = effekte.getIterator(); e; e++ )
  371. e->move( r, zeit );
  372. }
  373. }
  374. void Spieler::wiederbelebung( Spiel *zSpiel )
  375. {
  376. amLeben = 1;
  377. leben = (float)maxLeben;
  378. zSpiel->setSpielerZuletztWiederbelebt( (Spieler *)getThis() );
  379. Ereignis *e = new Ereignis( SPIELER_WIEDERBELEBT );
  380. e->addParameter( "Betroffener Spieler", getThis() );
  381. zSpiel->throwEvent( e );
  382. }
  383. void Spieler::tick( double zeit, Spiel *zSpiel )
  384. {
  385. if( istAmLeben() )
  386. {
  387. intersectable = 1;
  388. for( int i = 0; i < effekte.getEintragAnzahl(); i++ )
  389. {
  390. intersectable &= effekte.z( i )->istIntersectable();
  391. if( effekte.z( i )->tick( zeit, zSpiel ) && istAmLeben() )
  392. {
  393. effekte.remove( i );
  394. i--;
  395. }
  396. if( !istAmLeben() )
  397. break;
  398. }
  399. if( tastenStand[ ' ' ] )
  400. useItem( zSpiel );
  401. if( tastenStand[ 'e' ] )
  402. zSpiel->spielerActivate( this );
  403. heilung( lebensRegeneration * (float)zeit, zSpiel );
  404. }
  405. else
  406. {
  407. intersectable = 0;
  408. effekte.leeren();
  409. wiederbelebungsZeit -= (float)zeit;
  410. if( wiederbelebungsZeit <= 0 )
  411. {
  412. wiederbelebung( zSpiel );
  413. }
  414. }
  415. inv.tick( zeit );
  416. }
  417. void Spieler::useItem( Spiel *zSpiel )
  418. {
  419. if( istAmLeben() && inv.selectedItem() != KEIN_GEGENSTAND && istGegenstandErlaubt( inv.selectedItem() ) )
  420. {
  421. zSpiel->setSpielerZuletztGegenstandAktiviert( (Spieler *)getThis() );
  422. itemsVerwendet++;
  423. GegenstandTyp typ = inv.useItem();
  424. zSpiel->setItemZuletztAktiviert( typ );
  425. switch( typ )
  426. {
  427. case PFEIL:
  428. geschosseGeschossen++;
  429. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  430. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_PFEIL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, (Spieler *)getThis() ) );
  431. break;
  432. case LEBEN:
  433. addEffekt( new LebenEffect( this ) );
  434. break;
  435. case SCHILD:
  436. addEffekt( new SchildEffect( this ) );
  437. break;
  438. case SCHUH:
  439. addEffekt( new SchuhEffect( this ) );
  440. break;
  441. case GEIST:
  442. addEffekt( new GeistEffect( this ) );
  443. break;
  444. case KUGEL:
  445. geschosseGeschossen++;
  446. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  447. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_KUGEL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, (Spieler *)getThis() ) );
  448. break;
  449. case ROLLE:
  450. addEffekt( new RolleEffect( this, getAusrichtung() ) );
  451. break;
  452. case STURM:
  453. addEffekt( new SturmEffect( this, getAusrichtung() ) );
  454. break;
  455. case DRACHENAUGE:
  456. geschosseGeschossen++;
  457. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  458. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_DRACHENAUGE, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, (Spieler *)getThis() ) );
  459. break;
  460. case FEUERBALL:
  461. geschosseGeschossen++;
  462. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  463. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), geschossTempo, GESCHOSS_FEUERBALL, getAusrichtung(), (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, (Spieler *)getThis() ) );
  464. break;
  465. case ENTERHAKEN:
  466. addEffekt( new EnterhakenEffect( this, getAusrichtung() ) );
  467. break;
  468. case MINE:
  469. geschosseGeschossen++;
  470. zSpiel->setSpielerZuletztGeschossen( (Spieler *)getThis() );
  471. zSpiel->addGeschoss( new Geschoss( zSpiel->getNextId(), 0, GESCHOSS_MINE, MITTE, (int)x + (int)getWidth() / 2, (int)y + (int)getHeight() / 2, (Spieler *)getThis() ) );
  472. break;
  473. default:
  474. break;
  475. }
  476. Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
  477. e->addParameter( "Betroffener Spieler", getThis() );
  478. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  479. zSpiel->throwEvent( e );
  480. }
  481. }
  482. bool Spieler::addItem( GegenstandTyp typ, int anz, Spiel *zSpiel )
  483. {
  484. if( storable( typ ) )
  485. {
  486. if( inv.canAddItem( typ ) )
  487. {
  488. zSpiel->setItemZuletztAufgehoben( typ );
  489. zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
  490. itemsAufgehoben += anz;
  491. inv.addItem( typ, anz );
  492. Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
  493. e->addParameter( "Betroffener Spieler", getThis() );
  494. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  495. e->addParameter( "Anzahl", new Integer( anz ) );
  496. zSpiel->throwEvent( e );
  497. return 1;
  498. }
  499. else
  500. return 0;
  501. }
  502. else
  503. {
  504. zSpiel->setItemZuletztAufgehoben( typ );
  505. zSpiel->setSpielerZuletztGegenstandAufgehoben( (Spieler *)getThis() );
  506. itemsAufgehoben += anz;
  507. Ereignis *e = new Ereignis( SPIELER_BEKOMMT_GEGENSTAND );
  508. e->addParameter( "Betroffener Spieler", getThis() );
  509. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  510. e->addParameter( "Anzahl", new Integer( anz ) );
  511. zSpiel->throwEvent( e );
  512. for( int i = 0; i < anz; i++ )
  513. {
  514. Ereignis *e = new Ereignis( SPIELER_BENUTZT_GEGENSTAND );
  515. e->addParameter( "Betroffener Spieler", getThis() );
  516. e->addParameter( "Betroffener Gegenstand", new GegenstandTypVar( typ ) );
  517. zSpiel->throwEvent( e );
  518. itemsVerwendet++;
  519. switch( typ )
  520. {
  521. case RWEISHEIT:
  522. addErfahrung( 2, zSpiel );
  523. break;
  524. case RSTRENGTH:
  525. addEffekt( new StrengthRuneEffect( this ) );
  526. break;
  527. case RBOSHEIT:
  528. addEffekt( new BosheitRuneEffect( this ) );
  529. break;
  530. case RLEBEN:
  531. addEffekt( new LebenRuneEffect( this ) );
  532. break;
  533. case RTEMPO:
  534. addEffekt( new TempoRuneEffect( this ) );
  535. break;
  536. default:
  537. break;
  538. }
  539. }
  540. return 1;
  541. }
  542. }
  543. // heilt auch um den lebensraub prozentsatz
  544. void Spieler::addGemachterSchaden( float schaden, Spiel *zSpiel )
  545. {
  546. zSpiel->setSpielerZuletztSchadenGemacht( (Spieler *)getThis() );
  547. schadenGemacht += schaden;
  548. heilung( schaden / 100 * lebensraub, zSpiel );
  549. Ereignis *e = new Ereignis( SPIELER_MACHT_SCHADEN );
  550. e->addParameter( "Betroffener Spieler", getThis() );
  551. e->addParameter( "Wert", new Float( schaden ) );
  552. zSpiel->throwEvent( e );
  553. }
  554. // zieht die rüstung ab
  555. void Spieler::nimmSchaden( float schaden, Spieler *zVerursacher, Richtung r, Spiel *zSpiel )
  556. {
  557. if( !isVerwundbar( r ) || !istAmLeben() )
  558. return;
  559. if( zVerursacher )
  560. schaden += schaden / 100 * zVerursacher->getSchadenBonus();
  561. schaden -= schaden / 100 * armor;
  562. schaden = leben < schaden ? leben : schaden;
  563. schadenGenommen += schaden;
  564. leben -= schaden;
  565. zSpiel->setSpielerZuletztSchadenGenommen( (Spieler *)getThis() );
  566. if( zVerursacher )
  567. zVerursacher->addGemachterSchaden( schaden, zSpiel );
  568. Ereignis *e = new Ereignis( SPIELER_NIMMT_SCHADEN );
  569. e->addParameter( "Betroffener Spieler", getThis() );
  570. e->addParameter( "Wert", new Float( schaden ) );
  571. zSpiel->throwEvent( e );
  572. if( leben == 0 )
  573. {
  574. wiederbelebungsZeit = (float)( (float)maxWiederbelebungsZeit + team->getMaxWiederbelebungsZeit() );
  575. wiederbelebungsZeit -= wiederbelebungsZeit / 100 * abklingZeitVerringerung;
  576. team->addTod();
  577. amLeben = 0;
  578. tode++;
  579. zSpiel->setSpielerZuletztGestorben( (Spieler *)getThis() );
  580. if( zVerursacher )
  581. zVerursacher->addKill();
  582. Ereignis *e = new Ereignis( SPIELER_STIRBT );
  583. e->addParameter( "Betroffener Spieler", getThis() );
  584. zSpiel->throwEvent( e );
  585. }
  586. }
  587. void Spieler::heilung( float heal, Spiel *zSpiel )
  588. {
  589. if( istAmLeben() )
  590. {
  591. heal = heal + leben > maxLeben ? (float)maxLeben - leben : heal;
  592. lebenGeheilt += heal;
  593. leben += heal;
  594. zSpiel->setSpielerZuletztGeheilt( (Spieler *)getThis() );
  595. Ereignis *e = new Ereignis( SPIELER_WIRD_GEHEILT );
  596. e->addParameter( "Betroffener Spieler", getThis() );
  597. e->addParameter( "Wert", new Float( heal ) );
  598. zSpiel->throwEvent( e );
  599. }
  600. }
  601. void Spieler::setSchadenBonus( float bonus )
  602. {
  603. schadensBonus = bonus;
  604. }
  605. void Spieler::setLebensRaub( float raub )
  606. {
  607. lebensraub = raub;
  608. }
  609. void Spieler::setGeschossTempo( float tempo )
  610. {
  611. geschossTempo = tempo;
  612. }
  613. void Spieler::setArmor( float armor )
  614. {
  615. this->armor = armor;
  616. }
  617. void Spieler::setLebensRegeneration( float reg )
  618. {
  619. lebensRegeneration = reg;
  620. }
  621. void Spieler::setName( const char *name )
  622. {
  623. this->name = name;
  624. }
  625. void Spieler::setLevel( int level, Spiel *zSpiel )
  626. {
  627. if( level < 0 || level > 100 )
  628. return;
  629. while( level > this->level )
  630. levelUp( zSpiel );
  631. while( level < this->level )
  632. levelDown( zSpiel );
  633. erfahrung = 0;
  634. }
  635. void Spieler::removeItem( GegenstandTyp typ, int anzahl )
  636. {
  637. inv.removeItem( typ, anzahl );
  638. }
  639. void Spieler::setLeben( float leben )
  640. {
  641. this->leben = leben;
  642. if( this->leben < 0 )
  643. {
  644. this->leben = 0;
  645. // the player is now undead :D
  646. }
  647. if( this->leben > maxLeben )
  648. this->leben = (float)maxLeben;
  649. }
  650. void Spieler::setMaxLeben( int leben )
  651. {
  652. maxLeben = leben;
  653. if( maxLeben < 1 )
  654. maxLeben = 1;
  655. if( this->leben > maxLeben )
  656. this->leben = (float)maxLeben;
  657. }
  658. void Spieler::setErfahrung( float erf, Spiel *zSpiel )
  659. {
  660. erfahrung = erf;
  661. while( erfahrung < 0 )
  662. levelDown( zSpiel );
  663. while( erfahrung >= maxErfahrung )
  664. levelUp( zSpiel );
  665. }
  666. void Spieler::setMaxErfahrung( int erf )
  667. {
  668. this->maxErfahrung = erf;
  669. }
  670. void Spieler::setAbklingZeitVerringerung( float verringerung )
  671. {
  672. abklingZeitVerringerung = verringerung;
  673. }
  674. float Spieler::getLebensRegenneration() const
  675. {
  676. return lebensRegeneration;
  677. }
  678. float Spieler::getArmor() const
  679. {
  680. return armor;
  681. }
  682. float Spieler::getGeschossTempo() const
  683. {
  684. return geschossTempo;
  685. }
  686. float Spieler::getLebensRaub() const
  687. {
  688. return lebensraub;
  689. }
  690. float Spieler::getSchadenBonus() const
  691. {
  692. return schadensBonus;
  693. }
  694. Klient *Spieler::zKlient() const
  695. {
  696. return klient;
  697. }
  698. Team *Spieler::zTeam() const
  699. {
  700. return team;
  701. }
  702. Team *Spieler::getTeam() const
  703. {
  704. return team ? (Team *)team->getThis() : 0;
  705. }
  706. int Spieler::getFarbe() const
  707. {
  708. return color;
  709. }
  710. int Spieler::getAccountId() const
  711. {
  712. return accountId;
  713. }
  714. int Spieler::getPunkte() const
  715. {
  716. return kills - tode + ( treffer - getroffen ) / 2;
  717. }
  718. bool Spieler::istAmLeben() const
  719. {
  720. return amLeben && accountId;
  721. }
  722. float Spieler::getLaufTempo() const
  723. {
  724. return laufTempo;
  725. }
  726. bool Spieler::isVerwundbar( Richtung r ) const
  727. {
  728. bool verwundbar = 1;
  729. for( auto e = effekte.getIterator(); e; e++ )
  730. {
  731. verwundbar &= e->istSpielerVerwundbar( r );
  732. if( !verwundbar )
  733. return 0;
  734. }
  735. return 1;
  736. }
  737. bool Spieler::istBeweglich( Richtung r ) const
  738. {
  739. bool beweglich = 1;
  740. for( auto e = effekte.getIterator(); e; e++ )
  741. {
  742. beweglich &= e->istSpielerBeweglich( r );
  743. if( !beweglich )
  744. return 0;
  745. }
  746. return 1;
  747. }
  748. bool Spieler::istSichtbar( Team *zTeam ) const
  749. {
  750. bool sichtbar = 1;
  751. for( auto e = effekte.getIterator(); e; e++ )
  752. {
  753. sichtbar &= e->istSpielerSichtbar( zTeam );
  754. if( !sichtbar )
  755. return 0;
  756. }
  757. return 1;
  758. }
  759. bool Spieler::istGegenstandErlaubt( GegenstandTyp typ ) const
  760. {
  761. bool erlaubt = !brauchtRichtung( typ ) || ausrichtung != MITTE;
  762. for( auto e = effekte.getIterator(); e; e++ )
  763. {
  764. erlaubt &= e->istGegenstandErlaubt( typ );
  765. if( !erlaubt )
  766. return 0;
  767. }
  768. return !inv.hatAbklingzeit( typ );
  769. }
  770. Richtung Spieler::getAusrichtung() const
  771. {
  772. return ausrichtung;
  773. }
  774. float Spieler::getAbklingZeitVerringerung() const
  775. {
  776. return abklingZeitVerringerung;
  777. }
  778. int Spieler::getId() const
  779. {
  780. return spielerNummer;
  781. }
  782. int Spieler::getLevel() const
  783. {
  784. return level;
  785. }
  786. float Spieler::getLeben() const
  787. {
  788. return leben;
  789. }
  790. int Spieler::getMaxLeben() const
  791. {
  792. return maxLeben;
  793. }
  794. float Spieler::getErfahrung() const
  795. {
  796. return erfahrung;
  797. }
  798. int Spieler::getMaxErfahrung() const
  799. {
  800. return maxErfahrung;
  801. }
  802. int Spieler::getTode() const
  803. {
  804. return tode;
  805. }
  806. int Spieler::getKills() const
  807. {
  808. return kills;
  809. }
  810. int Spieler::getTreffer() const
  811. {
  812. return treffer;
  813. }
  814. int Spieler::getGetroffen() const
  815. {
  816. return getroffen;
  817. }
  818. float Spieler::getErlittenerSchaden() const
  819. {
  820. return schadenGenommen;
  821. }
  822. float Spieler::getGemachterSchaden() const
  823. {
  824. return schadenGemacht;
  825. }
  826. float Spieler::getGeheiltesLeben() const
  827. {
  828. return lebenGeheilt;
  829. }
  830. int Spieler::getItemsAufgehoben() const
  831. {
  832. return itemsAufgehoben;
  833. }
  834. int Spieler::getItemsVerwendet() const
  835. {
  836. return itemsVerwendet;
  837. }
  838. int Spieler::getItemsInInventory() const
  839. {
  840. return inv.getItemAnzahl();
  841. }
  842. int Spieler::getItemsInInventory( GegenstandTyp typ ) const
  843. {
  844. return inv.getItemAnzahl( typ );
  845. }
  846. int Spieler::getTunnelBenutzt() const
  847. {
  848. return tunnelBenutzt;
  849. }
  850. int Spieler::getSchalterAktiviert() const
  851. {
  852. return schalterAktiviert;
  853. }
  854. int Spieler::getGeschossen() const
  855. {
  856. return geschosseGeschossen;
  857. }
  858. GegenstandTyp Spieler::getInventorySlot( int index ) const
  859. {
  860. return inv.getItemTyp( index );
  861. }
  862. const char *Spieler::getName() const
  863. {
  864. return name;
  865. }