Spiel.cpp 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924
  1. #include "Spiel.h"
  2. #include "DrachenAuge.h"
  3. #include "Brand.h"
  4. #define TICK 0.03333333
  5. // Konstruktor
  6. Spiel::Spiel()
  7. {
  8. nextId = 0;
  9. isRunning = 0;
  10. log = 0;
  11. spielerAnzahl = 0;
  12. zAccounts = 0;
  13. spielId = 0;
  14. karteId = 0;
  15. pause = 0;
  16. gameTicks = 0;
  17. ende = 1;
  18. stat = new Statistik();
  19. ref = 1;
  20. }
  21. // Destruktor
  22. Spiel::~Spiel()
  23. {
  24. stat->release();
  25. if( psqldb )
  26. psqldb->release();
  27. }
  28. // nicht constant
  29. void Spiel::setPSQLK( SSDatenbankV *psqldb )
  30. {
  31. if( this->psqldb )
  32. this->psqldb->release();
  33. this->psqldb = psqldb;
  34. stat->setPSQLDB( psqldb->getThis() );
  35. }
  36. // call 1
  37. void Spiel::setSpielId( int id )
  38. {
  39. spielId = id;
  40. stat->setSpielId( id );
  41. }
  42. // call 2
  43. void Spiel::setKarteId( int karteId )
  44. {
  45. this->karteId = karteId;
  46. stat->setKarteId( karteId );
  47. }
  48. // call 3
  49. void Spiel::setTempPfad( char *pfad )
  50. {
  51. mapPfad = pfad;
  52. mapPfad += "/";
  53. }
  54. // call 3.5
  55. void Spiel::setAccounts( int anzahl, Array< int > *zAccounts )
  56. {
  57. this->zAccounts = zAccounts->getThis();
  58. spielerAnzahl = anzahl;
  59. }
  60. // call 4
  61. void Spiel::setKlients( int anzahl, RCArray< SSKlientV > *zKlients )
  62. {
  63. this->zKlients = zKlients->getThis();
  64. }
  65. // call 5
  66. void Spiel::setSpielerNummern( int anzahl, Array< int > *spielerNummern )
  67. {
  68. MapReader *reader = new MapReader( karteId, psqldb->getThis(), mapPfad );
  69. reader->ladeKarte( this );
  70. reader->release();
  71. for( int i = 0; i < anzahl; i++ )
  72. {
  73. for( auto s = spieler.getIterator(); s; s++ )
  74. {
  75. if( s->getSpielerNummer() == spielerNummern->get( i ) )
  76. {
  77. s->setAccount( zAccounts->get( i ) );
  78. s->setKlient( new Klient( zKlients->get( i ) ) );
  79. break;
  80. }
  81. }
  82. }
  83. zAccounts = zAccounts->release();
  84. zKlients = zKlients->release();
  85. stat->setTeams( spielerAnzahl, &teams );
  86. stat->setSpieler( spielerAnzahl, &spieler );
  87. }
  88. // call 6
  89. void Spiel::run()
  90. {
  91. log = new Datei();
  92. Text *pfad = new Text( "../spiel log/" );
  93. pfad->append( spielId );
  94. pfad->append( "/verlauf.ksggl" );
  95. log->setDatei( pfad );
  96. log->remove();
  97. log->erstellen();
  98. log->open( Datei::Style::schreiben );
  99. time_t t;
  100. time( &t );
  101. srand( (unsigned int)t );
  102. log->schreibe( (char *)& spielerAnzahl, 4 );
  103. for( int i = 0; i < spielerAnzahl; i++ )
  104. {
  105. Spieler *tmp = spieler.z( i );
  106. if( tmp && tmp->zKlient() )
  107. {
  108. tmp->zKlient()->sendeInit( &spieler, -1 );
  109. log->schreibe( (char *)& i, 4 );
  110. int sNum = tmp->getSpielerNummer();
  111. log->schreibe( (char *)& sNum, 4 );
  112. tmp->zKlient()->sendeSpielerNummer( sNum, -1 );
  113. Text * name = psqldb->getAccountRufName( tmp->getAccountId() );
  114. char len = (char)( name ? name->getLength() : 0 );
  115. log->schreibe( &len, 1 );
  116. if( len )
  117. log->schreibe( name->getText(), len );
  118. if( name )
  119. name->release();
  120. }
  121. }
  122. __int64 randSeed = randG.getSeed();
  123. log->schreibe( (char *)& randSeed, 8 );
  124. Array< char > spielerStatus;
  125. ZeitMesser * zeit = new ZeitMesser();
  126. zeit->messungStart();
  127. isRunning = 1;
  128. ende = 0;
  129. double ausgleich = 0;
  130. double sZ = 0;
  131. gameTicks = -1;
  132. for( int i = 0; i < spielerAnzahl; i++ )
  133. {
  134. Spieler *tmp = spieler.z( i );
  135. if( tmp && tmp->zKlient() )
  136. tmp->zKlient()->sendeStart( gameTicks );
  137. }
  138. throwEvent( new Ereignis( INITIALISIERUNG ) );
  139. double rZeit = 0;
  140. while( !ende )
  141. {
  142. zeit->messungEnde();
  143. zeit->messungStart();
  144. double z = zeit->getSekunden();
  145. ausgleich += TICK - z;
  146. if( ausgleich > 0 )
  147. Sleep( (int)( ausgleich * 1000 ) );
  148. rZeit += z;
  149. while( sZ + TICK < rZeit && !ende )
  150. {
  151. c.lock();
  152. sZ += TICK;
  153. gameTicks++;
  154. char ch = 0;
  155. log->schreibe( &ch, 1 );
  156. tick( TICK );
  157. c.unlock();
  158. }
  159. }
  160. zeit->messungEnde();
  161. zeit->release();
  162. for( int i = 0; i < spielerAnzahl; i++ )
  163. {
  164. if( spieler.z( i ) && spieler.z( i )->zKlient() )
  165. {
  166. if( !spieler.z( i )->zTeam()->getPunkte() )
  167. {
  168. spielerStatus.set( 1, i ); // Datenbank Verloren
  169. spieler.z( i )->zKlient()->sendeSpielEnde( 0, 0 );
  170. }
  171. else
  172. {
  173. spielerStatus.set( 2, i ); // Datenbank Gewonnen
  174. spieler.z( i )->zKlient()->sendeSpielEnde( 1, 0 );
  175. }
  176. }
  177. if( spieler.z( i ) && ( !spieler.z( i )->zKlient() || !spieler.z( i )->zKlient()->istOnline() ) )
  178. spielerStatus.set( 3, i );
  179. }
  180. psqldb->setSpielStatusBeendet( spielId, 5 );
  181. for( int i = 0; i < spielerAnzahl; i++ )
  182. {
  183. Spieler *tmp = spieler.z( i );
  184. if( tmp )
  185. {
  186. psqldb->setSpielSpielerStatus( spielId, tmp->getAccountId(), tmp->getPunkte(), spielerStatus.get( i ) );
  187. psqldb->addSpielerStatistik( tmp->getAccountId(), spielId );
  188. }
  189. }
  190. log->close();
  191. log = log->release();
  192. isRunning = 0;
  193. }
  194. // call 7
  195. void Spiel::klientOffline( int accountId )
  196. {
  197. for( int i = 0; i < spielerAnzahl; i++ )
  198. {
  199. if( spieler.z( i )->getAccountId() == accountId )
  200. spieler.z( i )->zKlient()->offline();
  201. }
  202. }
  203. void Spiel::klientOnline( int accountId, SSKlientV * zKlient )
  204. {
  205. for( int i = 0; i < spielerAnzahl; i++ )
  206. {
  207. if( spieler.z( i )->getAccountId() == accountId )
  208. {
  209. c.lock();
  210. Spieler *s = spieler.z( i );
  211. Klient *tmp = s->zKlient();
  212. tmp->online( zKlient );
  213. tmp->sendeSpielerNummer( s->getSpielerNummer(), 0 );
  214. //--------------------------
  215. c.unlock();
  216. }
  217. }
  218. }
  219. void Spiel::nachricht( int accountId, int len, char *bytes )
  220. {
  221. if( !isRunning )
  222. return;
  223. c.lock();
  224. if( ende )
  225. {
  226. c.unlock();
  227. return;
  228. }
  229. char *msgBeg = bytes;
  230. int msgLen = len;
  231. int msgAccount = accountId;
  232. bool saveMSG = 1;
  233. len--;
  234. switch( *bytes )
  235. {
  236. case 0: // key press
  237. bytes++;
  238. len--;
  239. for( int i = 0; i < spielerAnzahl; i++ )
  240. {
  241. Spieler *tmp = spieler.z( i );
  242. if( tmp && tmp->getAccountId() == accountId )
  243. {
  244. if( !tmp->setTastenStand( *bytes, 1 ) )
  245. {
  246. saveMSG = 0;
  247. break;
  248. }
  249. Ereignis *e = new Ereignis( SPIELER_KEY_PRESSED );
  250. char buff[] = { *bytes, 0 };
  251. e->addParameter( "Betroffene Taste", new String( buff ) );
  252. e->addParameter( "Ausführender Spieler", tmp->getThis() );
  253. throwEvent( e );
  254. for( int j = 0; j < spielerAnzahl; j++ )
  255. {
  256. Spieler *s = spieler.z( j );
  257. if( s && s->zKlient() )
  258. s->zKlient()->sendeTastaturStatus( tmp->getSpielerNummer(), *bytes, 1, gameTicks );
  259. }
  260. break;
  261. }
  262. }
  263. break;
  264. case 1: // key release
  265. bytes++;
  266. len--;
  267. for( int i = 0; i < spielerAnzahl; i++ )
  268. {
  269. Spieler *tmp = spieler.z( i );
  270. if( tmp && tmp->getAccountId() == accountId )
  271. {
  272. if( !tmp->setTastenStand( (unsigned char)*bytes, 0 ) )
  273. {
  274. saveMSG = 0;
  275. break;
  276. }
  277. Ereignis *e = new Ereignis( SPIELER_KEY_RELEASED );
  278. char buff[] = { *bytes, 0 };
  279. e->addParameter( "Betroffene Taste", new String( buff ) );
  280. e->addParameter( "Ausführender Spieler", tmp->getThis() );
  281. throwEvent( e );
  282. for( int j = 0; j < spielerAnzahl; j++ )
  283. {
  284. Spieler *s = spieler.z( j );
  285. if( s && s->zKlient() )
  286. s->zKlient()->sendeTastaturStatus( tmp->getSpielerNummer(), *bytes, 0, gameTicks );
  287. }
  288. break;
  289. }
  290. }
  291. break;
  292. case 3: // chat Nachricht
  293. if( 1 )
  294. {
  295. bytes++;
  296. Text *txt = psqldb->getAccountRufName( accountId );
  297. txt->append( ": " );
  298. txt->append( bytes, len );
  299. for( int i = 0; i < spielerAnzahl; i++ )
  300. {
  301. Spieler *tmp = spieler.z( i );
  302. if( tmp && tmp->zKlient() )
  303. tmp->zKlient()->sendeChatNachricht( txt->getText(), gameTicks );
  304. }
  305. txt->release();
  306. len = 0;
  307. }
  308. break;
  309. default:
  310. saveMSG = 0;
  311. }
  312. if( len )
  313. {
  314. // error
  315. }
  316. if( log && log->istOffen() && saveMSG )
  317. {
  318. char c = 1;
  319. log->schreibe( &c, 1 );
  320. int spielerNum = 0;
  321. for( int i = 0; i < spielerAnzahl; i++ )
  322. {
  323. Spieler *tmp = spieler.z( i );
  324. if( tmp && tmp->getAccountId() == msgAccount )
  325. {
  326. spielerNum = tmp->getSpielerNummer();
  327. break;
  328. }
  329. }
  330. log->schreibe( (char *)& spielerNum, 4 );
  331. short l = (short)msgLen;
  332. log->schreibe( (char *)& l, 2 );
  333. log->schreibe( msgBeg, l );
  334. }
  335. c.unlock();
  336. }
  337. void Spiel::setMapSize( int width, int height )
  338. {
  339. mapSize = Punkt( width, height );
  340. }
  341. void Spiel::setPausiert( bool pausiert )
  342. {
  343. this->pause = pausiert;
  344. }
  345. void Spiel::tick( double zeit )
  346. {
  347. if( pause )
  348. zeit = 0;
  349. // spieler bewegungen
  350. for( auto s = spieler.getIterator(); s; s++ )
  351. {
  352. s->move( zeit );
  353. if( s->getX() < 0 || s->getY() < 0 || s->getX() + s->getWidth() >= mapSize.x || s->getY() + s->getHeight() >= mapSize.y )
  354. s->move( -zeit );
  355. else
  356. {
  357. for( auto b = barieren.getIterator(); b; b++ )
  358. { // spieler - bariere intersection
  359. if( b->hatStyle( Bariere::Style::Aktiv ) && ( b->zTeam() != s->zTeam() ) && b->intersectsWith( s ) )
  360. s->move( -zeit );
  361. }
  362. }
  363. }
  364. for( auto s = spieler.getIterator(); s; s++ )
  365. s->tick( zeit, this );
  366. // barieren bewegung
  367. for( auto b = barieren.getIterator(); b; b++ )
  368. b->tick( zeit, this );
  369. // geschoss bewegung
  370. for( int i = 0; i < shots.getEintragAnzahl(); i++ )
  371. {
  372. Geschoss *g = shots.z( i );
  373. g->tick( zeit );
  374. bool removed = 0;
  375. // geschoss - bariere intersection
  376. bool intersectsWithBariere = 0;
  377. for( auto b = barieren.getIterator(); b; b++ )
  378. {
  379. if( b->hatStyle( Bariere::Style::Aktiv ) && b->intersectsWith( g ) )
  380. {
  381. intersectsWithBariere = 1;
  382. break;
  383. }
  384. }
  385. if( intersectsWithBariere || g->getX() < 0 || g->getY() < 0 || g->getX() + g->getWidth() >= mapSize.x || g->getY() + g->getHeight() >= mapSize.y )
  386. {
  387. g->tick( -zeit );
  388. switch( g->getTyp() )
  389. {
  390. case GESCHOSS_PFEIL:
  391. shots.remove( i );
  392. i--;
  393. removed = 1;
  394. break;
  395. case GESCHOSS_KUGEL:
  396. case GESCHOSS_DRACHENAUGE:
  397. g->invertDirection();
  398. break;
  399. case GESCHOSS_FEUERBALL:
  400. if( intersectsWithBariere )
  401. {
  402. feuer.add( new FeuerballTreffer( ++nextId, (int)g->getX() - 70, (int)g->getY() - 70, g->getBesitzer(), 10 ) );
  403. shots.remove( i );
  404. i--;
  405. removed = 1;
  406. }
  407. else
  408. g->invertDirection();
  409. break;
  410. case GESCHOSS_MINE:
  411. for( auto s = spieler.getIterator(); s; s++ )
  412. {
  413. if( s->abstandZu( g ) < 50 )
  414. {
  415. s->nimmSchaden( 100 - s->abstandZu( g ), g->zBesitzer(), MITTE, this );
  416. if( g->zBesitzer() )
  417. g->zBesitzer()->addTreffer( this );
  418. s->addGetroffen();
  419. }
  420. }
  421. shots.remove( i );
  422. i--;
  423. removed = 1;
  424. break;
  425. }
  426. }
  427. if( !removed )
  428. { // geschoss - tunnel intersection
  429. for( auto t = tunnel.getIterator(); t; t++ )
  430. {
  431. if( t->istAktiv() && t->intersectsWith( g ) )
  432. {
  433. g->setX( g->getX() + (float)t->getZielX() - t->getX() );
  434. g->setY( g->getY() + (float)t->getZielY() - t->getY() );
  435. g->addTunnel();
  436. Ereignis *e = new Ereignis( TUNNEL_BENUTZT );
  437. e->addParameter( "Betroffes Geschoss", g->getThis() );
  438. e->addParameter( "Betroffer Tunnel", t->getThis() );
  439. throwEvent( e );
  440. }
  441. }
  442. // geschoss - schalter intersection
  443. if( g->getTyp() == GESCHOSS_PFEIL )
  444. {
  445. for( auto s = schalter.getIterator(); s; s++ )
  446. {
  447. if( s->isAktive() && s->intersectsWith( g ) )
  448. {
  449. shots.remove( i );
  450. i--;
  451. removed = 1;
  452. g->addSchalter();
  453. activateShalter( s->getId() );
  454. }
  455. }
  456. }
  457. if( !removed )
  458. {
  459. // geschoss - umlenkung intersection
  460. if( g->getTyp() != GESCHOSS_PFEIL )
  461. {
  462. for( auto u = umlenkungen.getIterator(); u; u++ )
  463. {
  464. if( u->isAktive() && !u->hatAbklingzeit() && g->getTyp() != GESCHOSS_PFEIL && u->intersectsWith( g ) )
  465. {
  466. g->setRichtung( u->getRichtung() );
  467. g->addUmlenkung();
  468. u->addBenutzt();
  469. Ereignis *e = new Ereignis( UMLENKUNG_LENKT_UM );
  470. e->addParameter( "Betroffes Geschoss", g->getThis() );
  471. e->addParameter( "Betroffe Umlenkung", u->getThis() );
  472. throwEvent( e );
  473. }
  474. }
  475. }
  476. // geschoss - geschoss intersection
  477. if( g->getTyp() == GESCHOSS_PFEIL )
  478. {
  479. for( int j = 0; j < shots.getEintragAnzahl(); j++ )
  480. {
  481. if( i == j )
  482. continue;
  483. Geschoss *g2 = shots.z( j );
  484. if( g2->intersectsWith( g ) )
  485. {
  486. if( g2->getTyp() == GESCHOSS_PFEIL )
  487. removed = 1;
  488. g->addGeschossTreffer();
  489. if( j < i )
  490. i--;
  491. shots.remove( j );
  492. }
  493. }
  494. }
  495. if( !removed )
  496. {
  497. // geschoss - spieler intersection
  498. for( auto s = spieler.getIterator(); s; s++ )
  499. {
  500. if( s->istAmLeben() && s != g->zBesitzer() && g->intersectsWith( s ) )
  501. {
  502. switch( g->getTyp() )
  503. {
  504. case GESCHOSS_PFEIL:
  505. {
  506. s->nimmSchaden( PFEIL_DAMAGE, g->zBesitzer(), invert( g->getRichtung() ), this );
  507. break;
  508. }
  509. case GESCHOSS_KUGEL:
  510. {
  511. s->nimmSchaden( KUGEL_DAMAGE, g->zBesitzer(), invert( g->getRichtung() ), this );
  512. break;
  513. }
  514. case GESCHOSS_DRACHENAUGE:
  515. s->addEffekt( new DrachenAugeEffect( g->zBesitzer(), s._ ) );
  516. break;
  517. case GESCHOSS_FEUERBALL:
  518. feuer.add( new FeuerballTreffer( ++nextId, (int)g->getX() - 70, (int)g->getY() - 70, g->getBesitzer(), 10 ) );
  519. break;
  520. case GESCHOSS_MINE:
  521. for( auto s2 = spieler.getIterator(); s2; s2++ )
  522. {
  523. if( s2->abstandZu( g ) < 50 )
  524. {
  525. s2->nimmSchaden( 100 - s->abstandZu( g ), g->zBesitzer(), MITTE, this );
  526. if( g->zBesitzer() )
  527. g->zBesitzer()->addTreffer( this );
  528. s->addGetroffen();
  529. }
  530. }
  531. break;
  532. }
  533. if( g->getTyp() != GESCHOSS_MINE )
  534. {
  535. if( g->zBesitzer() )
  536. g->zBesitzer()->addTreffer( this );
  537. s->addGetroffen();
  538. }
  539. shots.remove( i );
  540. i--;
  541. removed = 1;
  542. }
  543. }
  544. }
  545. }
  546. }
  547. }
  548. // Feuer Ticks
  549. for( int i = 0; i < feuer.getEintragAnzahl(); i++ )
  550. {
  551. FeuerballTreffer *f = feuer.z( i );
  552. f->tick( zeit );
  553. if( f->isOver() )
  554. {
  555. feuer.remove( i );
  556. i--;
  557. continue;
  558. }
  559. if( f->makeDamage() )
  560. {
  561. for( auto s = spieler.getIterator(); s; s++ )
  562. {
  563. if( s->abstandZu( f ) < f->getWidth() / 2 )
  564. s->addEffekt( new BrandEffekt( f->zVerursacher(), s ) );
  565. }
  566. }
  567. }
  568. // Drop Ticks
  569. for( auto d = drops.getIterator(); d; d++ )
  570. d->tick( zeit, this );
  571. // Timer Ticks
  572. for( auto t = timer.getIterator(); t; t++ )
  573. t->tick( zeit, this );
  574. // Umlenkung Ticks
  575. for( auto u = umlenkungen.getIterator(); u; u++ )
  576. u->tick( zeit );
  577. // Base Ticks
  578. for( auto b = basen.getIterator(); b; b++ )
  579. b->tick( zeit, this );
  580. // aktive trigger Ticks
  581. for( int i = 0; i < triggerRuns.getEintragAnzahl(); i++ )
  582. {
  583. if( !triggerRuns.z( i )->runNext( zeit ) )
  584. {
  585. Ereignis *e = new Ereignis( AUSLOESER_RUNNED );
  586. e->addParameter( "Betroffener Auslöser", triggerRuns.z( i )->getTrigger() );
  587. throwEvent( e );
  588. triggerRuns.remove( i );
  589. i--;
  590. }
  591. }
  592. }
  593. void Spiel::addVariable( const char *name, Variable * var )
  594. {
  595. bool found = 0;
  596. for( auto v = variablen.getIterator(); v; v++ )
  597. {
  598. if( v->getName().istGleich( name ) )
  599. {
  600. found = 1;
  601. break;
  602. }
  603. }
  604. if( !found )
  605. variablen.add( new VarPointer( name, var ) );
  606. else
  607. var->release();
  608. }
  609. void Spiel::setVariable( const char *name, Variable * var )
  610. {
  611. bool found = 0;
  612. for( auto v = variablen.getIterator(); v; v++ )
  613. {
  614. if( v->getName().istGleich( name ) )
  615. {
  616. v->setVariable( var );
  617. break;
  618. }
  619. }
  620. if( !found )
  621. var->release();
  622. }
  623. void Spiel::addTeam( Team * team )
  624. {
  625. teams.add( team );
  626. }
  627. void Spiel::addSpieler( Spieler * spieler )
  628. {
  629. this->spieler.add( spieler );
  630. }
  631. void Spiel::addBariere( Bariere * bariere )
  632. {
  633. barieren.add( bariere );
  634. }
  635. void Spiel::addBase( Base * base )
  636. {
  637. basen.add( base );
  638. }
  639. void Spiel::addDrop( Drop * drop )
  640. {
  641. drops.add( drop );
  642. }
  643. void Spiel::addGegenstand( Gegenstand * gegenstand )
  644. {
  645. items.add( gegenstand );
  646. Ereignis *e = new Ereignis( GEGENSTAND_DROPED );
  647. e->addParameter( "Betroffener Gegenstand", gegenstand->getThis() );
  648. throwEvent( e );
  649. }
  650. void Spiel::addGeschoss( Geschoss * geschoss )
  651. {
  652. shots.add( geschoss );
  653. }
  654. void Spiel::addSchalter( Schalter * schalter )
  655. {
  656. this->schalter.add( schalter );
  657. }
  658. void Spiel::addSchiene( Schiene * schiene )
  659. {
  660. schienen.add( schiene );
  661. }
  662. void Spiel::addTimer( Timer * timer )
  663. {
  664. this->timer.add( timer );
  665. }
  666. void Spiel::addTunnel( Tunnel * tunnel )
  667. {
  668. this->tunnel.add( tunnel );
  669. }
  670. void Spiel::addUmlenkung( Umlenkung * umlenkung )
  671. {
  672. umlenkungen.add( umlenkung );
  673. }
  674. void Spiel::addTrigger( Trigger * trigger )
  675. {
  676. this->trigger.add( trigger );
  677. }
  678. void Spiel::addTriggerRun( TriggerRun * tRun )
  679. {
  680. if( tRun )
  681. triggerRuns.add( tRun );
  682. }
  683. Team *Spiel::getTeam( int id ) const
  684. {
  685. for( auto t = teams.getIterator(); t; t++ )
  686. {
  687. if( t->getTeamNummer() == id )
  688. return (Team *)t->getThis();
  689. }
  690. return 0;
  691. }
  692. Spieler *Spiel::getSpieler( int id ) const
  693. {
  694. for( auto s = spieler.getIterator(); s; s++ )
  695. {
  696. if( s->getId() == id )
  697. return (Spieler*)s->getThis();
  698. }
  699. return 0;
  700. }
  701. Iterator<Spieler *> Spiel::getSpieler() const
  702. {
  703. return spieler.getIterator();
  704. }
  705. Iterator<Bariere *> Spiel::getBarieren() const
  706. {
  707. return barieren.getIterator();
  708. }
  709. Bariere *Spiel::getBariere( int id ) const
  710. {
  711. for( auto b = barieren.getIterator(); b; b++ )
  712. {
  713. if( b->getId() == id )
  714. return (Bariere *)b->getThis();
  715. }
  716. return 0;
  717. }
  718. Base *Spiel::getBase( int id ) const
  719. {
  720. for( auto b = basen.getIterator(); b; b++ )
  721. {
  722. if( b->getId() == id )
  723. return (Base *)b->getThis();
  724. }
  725. return 0;
  726. }
  727. Drop *Spiel::getDrop( int id ) const
  728. {
  729. for( auto d = drops.getIterator(); d; d++ )
  730. {
  731. if( d->getId() == id )
  732. return (Drop *)d->getThis();
  733. }
  734. return 0;
  735. }
  736. Schalter *Spiel::getSchalter( int id ) const
  737. {
  738. for( auto s = schalter.getIterator(); s; s++ )
  739. {
  740. if( s->getId() == id )
  741. return (Schalter *)s->getThis();
  742. }
  743. return 0;
  744. }
  745. Schiene *Spiel::getSchiene( int id ) const
  746. {
  747. for( auto s = schienen.getIterator(); s; s++ )
  748. {
  749. if( s->getId() == id )
  750. return (Schiene *)s->getThis();
  751. }
  752. return 0;
  753. }
  754. Timer *Spiel::getTimer( int id ) const
  755. {
  756. for( auto t = timer.getIterator(); t; t++ )
  757. {
  758. if( t->getId() == id )
  759. return (Timer *)t->getThis();
  760. }
  761. return 0;
  762. }
  763. Tunnel *Spiel::getTunnel( int id ) const
  764. {
  765. for( auto t = tunnel.getIterator(); t; t++ )
  766. {
  767. if( t->getId() == id )
  768. return (Tunnel *)t->getThis();
  769. }
  770. return 0;
  771. }
  772. Umlenkung *Spiel::getUmlenkung( int id ) const
  773. {
  774. for( auto u = umlenkungen.getIterator(); u; u++ )
  775. {
  776. if( u->getId() == id )
  777. return (Umlenkung *)u->getThis();
  778. }
  779. return 0;
  780. }
  781. Trigger *Spiel::getTrigger( int id ) const
  782. {
  783. for( auto t = trigger.getIterator(); t; t++ )
  784. {
  785. if( t->getId() == id )
  786. return (Trigger *)t->getThis();
  787. }
  788. return 0;
  789. }
  790. Variable *Spiel::getVariable( const char *name ) const
  791. {
  792. for( auto v = variablen.getIterator(); v; v++ )
  793. {
  794. if( v->getName().istGleich( name ) )
  795. return v->getVariable();
  796. }
  797. return 0;
  798. }
  799. Variable *Spiel::zVariable( const char *name ) const
  800. {
  801. for( auto v = variablen.getIterator(); v; v++ )
  802. {
  803. if( v->getName().istGleich( name ) )
  804. return v->zVariable();
  805. }
  806. return 0;
  807. }
  808. bool Spiel::istPausiert() const
  809. {
  810. return pause;
  811. }
  812. void Spiel::activateShalter( int id )
  813. {
  814. for( auto s = schalter.getIterator(); s; s++ )
  815. {
  816. if( s->getId() == id )
  817. {
  818. s->press();
  819. Ereignis *e = new Ereignis( SCHALTER_AKTIVIERT );
  820. e->addParameter( "Betroffener Schalter", s->getThis() );
  821. throwEvent( e );
  822. }
  823. }
  824. }
  825. void Spiel::throwEvent( Ereignis *e )
  826. {
  827. for( auto t = trigger.getIterator(); t; t++ )
  828. {
  829. if( t->hatEreignis( e->getTyp() ) )
  830. {
  831. TriggerRun *tr = t->runTrigger( e->getThis(), this );
  832. if( tr )
  833. triggerRuns.add( tr );
  834. }
  835. }
  836. e->release();
  837. }
  838. bool Spiel::needEvent( EreignisTyp typ ) const
  839. {
  840. for( auto t = trigger.getIterator(); t; t++ )
  841. {
  842. if( t->hatEreignis( typ ) )
  843. return 1;
  844. }
  845. return 0;
  846. }
  847. int Spiel::getNextId()
  848. {
  849. return ++nextId;
  850. }
  851. double Spiel::getRand()
  852. {
  853. return randG.rand();
  854. }
  855. int Spiel::getTickCount() const
  856. {
  857. return gameTicks;
  858. }
  859. StatistikV *Spiel::getStatistik() const
  860. {
  861. return stat->getThis();
  862. }
  863. // Reference Counting
  864. SpielKlasse *Spiel::getThis()
  865. {
  866. ref++;
  867. return this;
  868. }
  869. SpielKlasse *Spiel::release()
  870. {
  871. if( !--ref )
  872. delete this;
  873. return 0;
  874. }