Menü.cpp 33 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145
  1. #include "Menü.h"
  2. #include "Initialisierung.h"
  3. #include <MausEreignis.h>
  4. #include <Textfeld.h>
  5. #include <InitDatei.h>
  6. #include <Text.h>
  7. #include <Datei.h>
  8. #include <TastaturEreignis.h>
  9. #include <KSGTDatei.h>
  10. #include <Schrift.h>
  11. #include <DateiSystem.h>
  12. #include <Rahmen.h>
  13. #include <AsynchronCall.h>
  14. #include <Bildschirm.h>
  15. // Inhalt der MenüVerloren Klasse aus Menü.h
  16. // Kontruktor
  17. MenüVerloren::MenüVerloren( Schrift *zSchrift )
  18. {
  19. ram = new LRahmen();
  20. ram->setSize( 160, 100 );
  21. ram->setPosition( 320, 200 );
  22. ram->setFarbe( 0xFFFFFFFF );
  23. verloren = initTextFeld( 325, 210, 150, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Du hast verloren." );
  24. neu = initKnopf( 350, 240, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Neues Spiel" );
  25. beenden = initKnopf( 350, 270, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Zurück" );
  26. ref = 1;
  27. }
  28. // Destruktor
  29. MenüVerloren::~MenüVerloren()
  30. {
  31. verloren->release();
  32. neu->release();
  33. beenden->release();
  34. ram->release();
  35. }
  36. // nicht constant
  37. int MenüVerloren::doMausEreignis( MausEreignis &me )
  38. {
  39. bool vera = me.verarbeitet;
  40. int ret = 0;
  41. neu->doMausEreignis( me );
  42. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  43. ret = 1;
  44. beenden->doMausEreignis( me );
  45. if( !vera && me.verarbeitet && !ret && me.id == ME_RLinks )
  46. ret = 2;
  47. return ret;
  48. }
  49. bool MenüVerloren::tick( double tickVal )
  50. {
  51. bool ret = verloren->tick( tickVal );
  52. ret |= neu->tick( tickVal );
  53. ret |= beenden->tick( tickVal );
  54. return ret;
  55. }
  56. void MenüVerloren::render( Bild &zRObj )
  57. {
  58. zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
  59. verloren->render( zRObj );
  60. neu->render( zRObj );
  61. beenden->render( zRObj );
  62. ram->render( zRObj );
  63. }
  64. // Reference Counting
  65. MenüVerloren *MenüVerloren::getThis()
  66. {
  67. ref++;
  68. return this;
  69. }
  70. MenüVerloren *MenüVerloren::release()
  71. {
  72. ref--;
  73. if( !ref )
  74. delete this;
  75. return 0;
  76. }
  77. // Inhalt der MenüSpiel Klasse aus Menü.h
  78. // Konstruktor
  79. MenüSpiel::MenüSpiel( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient )
  80. {
  81. scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
  82. beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
  83. map = new Map( klient );
  84. verloren = new MenüVerloren( zSchrift );
  85. beendet = 0;
  86. timePuffer = 0;
  87. ref = 1;
  88. }
  89. // Destruktor
  90. MenüSpiel::~MenüSpiel()
  91. {
  92. scoreT->release();
  93. beenden->release();
  94. map->release();
  95. verloren->release();
  96. }
  97. // nicht constant
  98. void MenüSpiel::reset()
  99. {
  100. InitDatei *opd = new InitDatei( "data/Minigames/tetris/data/optionen.ini" );
  101. if( !opd->laden() )
  102. DateiPfadErstellen( "data/Minigames/Tetris/data/optionen.ini" );
  103. Text optionen = "Width=";
  104. if( opd->wertExistiert( "Breite" ) )
  105. optionen += (int)*opd->zWert( "Breite" );
  106. else
  107. {
  108. opd->addWert( "Breite", "15" );
  109. optionen += 15;
  110. }
  111. optionen += ",Height=";
  112. if( opd->wertExistiert( "Höhe" ) )
  113. optionen += (int)*opd->zWert( "Höhe" );
  114. else
  115. {
  116. opd->addWert( "Höhe", "25" );
  117. optionen += 25;
  118. }
  119. optionen += ",NSpeed=";
  120. if( opd->wertExistiert( "+Geschwindigkeit" ) )
  121. optionen += (int)*opd->zWert( "+Geschwindigkeit" );
  122. else
  123. {
  124. opd->addWert( "+Geschwindigkeit", "50" );
  125. optionen += 50;
  126. }
  127. optionen += ",Speed=";
  128. if( opd->wertExistiert( "Geschwindigkeit" ) )
  129. optionen += (int)*opd->zWert( "Geschwindigkeit" );
  130. else
  131. {
  132. opd->addWert( "Geschwindigkeit", "1000" );
  133. optionen += 1000;
  134. }
  135. optionen += ",Fortsetzen=";
  136. if( opd->wertExistiert( "Fortsetzen" ) )
  137. optionen += (int)*opd->zWert( "Fortsetzen" ) != 0;
  138. else
  139. {
  140. opd->addWert( "Fortsetzen", "0" );
  141. optionen += 0;
  142. }
  143. opd->speichern();
  144. opd->release();
  145. optionen += ",Seed=0";
  146. map->reset( &optionen );
  147. beendet = 0;
  148. scoreT->setText( "Score: " );
  149. scoreT->zText()->append( map->getScore() );
  150. }
  151. void MenüSpiel::doMausEreignis( MausEreignis &me )
  152. {
  153. bool vera = me.verarbeitet;
  154. beenden->doMausEreignis( me );
  155. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  156. {
  157. map->speichern();
  158. beendet = 1;
  159. }
  160. map->doMausEreignis( me );
  161. if( map->istBeendet() )
  162. {
  163. int ak = verloren->doMausEreignis( me );
  164. if( ak == 1 )
  165. reset();
  166. if( ak == 2 )
  167. beendet = 1;
  168. }
  169. }
  170. void MenüSpiel::doTastaturEreignis( TastaturEreignis &te )
  171. {
  172. if( map->istBeendet() )
  173. {
  174. if( te.id == TE_Release && te.taste == T_Enter )
  175. reset();
  176. if( te.id == TE_Release && te.taste == T_BackSpace )
  177. beendet = 1;
  178. return;
  179. }
  180. map->doTastaturEreignis( te );
  181. }
  182. bool MenüSpiel::tick( double tickVal )
  183. {
  184. timePuffer += tickVal;
  185. bool ret = beenden->tick( tickVal );
  186. while( timePuffer >= 0.01 )
  187. {
  188. ret |= map->tick( 0.01 );
  189. timePuffer -= 0.01;
  190. }
  191. scoreT->setText( "Score: " );
  192. scoreT->zText()->append( map->getScore() );
  193. if( map->istBeendet() )
  194. ret |= verloren->tick( tickVal );
  195. return ret;
  196. }
  197. void MenüSpiel::render( Bild &zRObj )
  198. {
  199. map->render( zRObj );
  200. scoreT->render( zRObj );
  201. beenden->render( zRObj );
  202. if( map->istBeendet() )
  203. verloren->render( zRObj );
  204. }
  205. // constant
  206. bool MenüSpiel::istBeendet() const
  207. {
  208. return beendet;
  209. }
  210. // Reference Counting
  211. MenüSpiel *MenüSpiel::getThis()
  212. {
  213. ref++;
  214. return this;
  215. }
  216. MenüSpiel *MenüSpiel::release()
  217. {
  218. ref--;
  219. if( !ref )
  220. delete this;
  221. return 0;
  222. }
  223. // Inhalt der MenüWiederhohlung Klasse
  224. // Konstruktor
  225. MenüWiederhohlung::MenüWiederhohlung( Schrift *zSchrift, Bildschirm *zScreen, Datei *datei, Text *zOptionen )
  226. {
  227. scoreT = initTextFeld( 690, 10, 100, 20, zSchrift, TextFeld::Style::Text, "Score: 0" );
  228. beenden = initKnopf( 690, 40, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
  229. this->datei = datei;
  230. if( !datei->istOffen() )
  231. datei->open( Datei::Style::lesen );
  232. __int64 seed;
  233. datei->lese( (char*)&seed, 8 );
  234. zOptionen->append( ",Fortsetzen=0,Seed=" );
  235. zOptionen->append( seed );
  236. map = new Map( 0 );
  237. map->reset( zOptionen );
  238. beendet = 0;
  239. nowTime = 0;
  240. nextTime = 0;
  241. datei->lese( (char*)&nextTime, 8 );
  242. timePuffer = 0;
  243. ref = 1;
  244. }
  245. // Destruktor
  246. MenüWiederhohlung::~MenüWiederhohlung()
  247. {
  248. scoreT->release();
  249. beenden->release();
  250. map->release();
  251. datei->close();
  252. datei->release();
  253. }
  254. // nicht constant
  255. void MenüWiederhohlung::doMausEreignis( MausEreignis &me )
  256. {
  257. bool vera = me.verarbeitet;
  258. beenden->doMausEreignis( me );
  259. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  260. beendet = 1;
  261. if( map->istBeendet() )
  262. beendet = 1;
  263. }
  264. void MenüWiederhohlung::doTastaturEreignis( TastaturEreignis &te )
  265. {}
  266. bool MenüWiederhohlung::tick( double tickVal )
  267. {
  268. bool ret = beenden->tick( tickVal );
  269. // TODO Replay Activity
  270. while( nextTime >= 0 && nowTime + tickVal >= nextTime )
  271. {
  272. while( nowTime < nextTime )
  273. {
  274. ret |= map->tick( 0.01 );
  275. tickVal -= 0.01;
  276. nowTime += 0.01;
  277. }
  278. char taste;
  279. datei->lese( &taste, 1 );
  280. if( datei->istEnde() )
  281. nextTime = -1;
  282. else
  283. datei->lese( (char*)&nextTime, 8 );
  284. TastaturEreignis te;
  285. te.verarbeitet = 0;
  286. te.taste = taste;
  287. te.id = TE_Press;
  288. map->doTastaturEreignis( te );
  289. }
  290. timePuffer += tickVal;
  291. while( timePuffer > 0 )
  292. {
  293. ret |= map->tick( 0.01 );
  294. nowTime += 0.01;
  295. timePuffer -= 0.01;
  296. }
  297. scoreT->setText( "Score: " );
  298. scoreT->zText()->append( map->getScore() );
  299. return ret;
  300. }
  301. void MenüWiederhohlung::render( Bild &zRObj )
  302. {
  303. map->render( zRObj );
  304. scoreT->render( zRObj );
  305. beenden->render( zRObj );
  306. }
  307. // constant
  308. bool MenüWiederhohlung::istBeendet() const
  309. {
  310. return beendet;
  311. }
  312. // Reference Counting
  313. MenüWiederhohlung *MenüWiederhohlung::getThis()
  314. {
  315. ref++;
  316. return this;
  317. }
  318. MenüWiederhohlung *MenüWiederhohlung::release()
  319. {
  320. if( !--ref )
  321. delete this;
  322. return 0;
  323. }
  324. // Inhalt der MenüStatistik Klasse aus Menü.h
  325. // Konstruktor
  326. MenüStatistik::MenüStatistik( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient )
  327. {
  328. this->klient = klient;
  329. wiederH = 0;
  330. screen = zScreen->getThis();
  331. ansichtT = initTextFeld( 245, 10, 50, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Ansicht:" );
  332. ansicht = initAuswahlBox( 295, 10, 120, 20, zSchrift, AuswahlBox::Style::Normal | AuswahlBox::Style::Hintergrund, { "Tabelle", "Diagramm" } );
  333. optionen = initKontrollKnopf( 425, 10, 130, 20, zSchrift, KontrollKnopf::Style::Normal, "Optionen beachten" );
  334. worldBestT = initObjTabelle( 150, 40, 500, 120, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 60, 0, 0 },{ "Spieler", 100, 0, 0 },{ "Ansehen", 55, 0, 0 },{ "Breite", 70, 0, 0 },{ "Höhe", 70, 0, 0 },{ "+Tempo", 60, 0, 0 },{ "Tempo", 65, 0, 0 } }, 20 );
  335. gesammtT = initObjTabelle( 150, 170, 500, 290, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Höhe", 70, 0, 0 }, { "+Tempo", 60, 0, 0 }, { "Tempo", 65, 0, 0 } }, 20 );
  336. optionenT = initObjTabelle( 150, 170, 500, 290, zSchrift, ObjTabelle::Style::normal | ObjTabelle::Style::VScroll, { { "Score", 70, 0, 0 }, { "Datum", 145, 0, 0 }, { "Breite", 70, 0, 0 }, { "Höhe", 70, 0, 0 }, { "+Tempo", 60, 0, 0 }, { "Tempo", 65, 0, 0 } }, 20 );
  337. gesammtD = initLinienDiagramm( 100, 170, 600, 290, zSchrift, LDiag::Style::DatenRahmen, 0 );
  338. optionenD = initLinienDiagramm( 100, 170, 600, 290, zSchrift, LDiag::Style::DatenRahmen, 0 );
  339. removen = initKnopf( 10, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurücksetzen" );
  340. zurück = initKnopf( 350, 470, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Zurück" );
  341. schrift = zSchrift->getThis();
  342. asyncFinished = 1;
  343. }
  344. // Destruktor
  345. MenüStatistik::~MenüStatistik()
  346. {
  347. int anz = gesammtT->getZeilenAnzahl();
  348. for( int i = 0; i < anz; i++ )
  349. {
  350. for( int j = 0; j < 6; j++ )
  351. ( (TextFeld*)gesammtT->zZeichnung( j, 0 ) )->release();
  352. gesammtT->removeZeile( 0 );
  353. }
  354. for( int j = 0; j < 6; j++ )
  355. ( (TextFeld*)optionenT->zZeichnung( j, 0 ) )->release();
  356. while( !asyncFinished )
  357. {
  358. Sleep( 100 );
  359. }
  360. anz = worldBestT->getZeilenAnzahl();
  361. for( int i = 0; i < anz; i++ )
  362. {
  363. for( int j = 0; j < 7; j++ )
  364. {
  365. if( j == 2 )
  366. ( (Knopf*)worldBestT->zZeichnung( j, 0 ) )->release();
  367. else
  368. ( (TextFeld*)worldBestT->zZeichnung( j, 0 ) )->release();
  369. }
  370. worldBestT->removeZeile( 0 );
  371. }
  372. worldBestT->release();
  373. ansichtT->release();
  374. ansicht->release();
  375. optionen->release();
  376. gesammtT->release();
  377. optionenT->release();
  378. gesammtD->release();
  379. optionenD->release();
  380. removen->release();
  381. zurück->release();
  382. schrift->release();
  383. klient->release();
  384. if( wiederH )
  385. wiederH->release();
  386. screen->release();
  387. }
  388. // nicht constant
  389. void MenüStatistik::reset()
  390. {
  391. if( wiederH )
  392. wiederH = wiederH->release();
  393. int anz = gesammtT->getZeilenAnzahl();
  394. for( int i = 1; i < anz; i++ )
  395. {
  396. for( int j = 0; j < 6; j++ )
  397. ( (TextFeld*)gesammtT->zZeichnung( j, 1 ) )->release();
  398. gesammtT->removeZeile( 1 );
  399. }
  400. anz = optionenT->getZeilenAnzahl();
  401. for( int i = 1; i < anz; i++ )
  402. optionenT->removeZeile( 1 );
  403. anz = worldBestT->getZeilenAnzahl();
  404. for( int i = 1; i < anz; i++ )
  405. {
  406. for( int j = 0; j < 7; j++ )
  407. {
  408. if( j == 2 )
  409. ( (Knopf*)worldBestT->zZeichnung( j, 1 ) )->release();
  410. else
  411. ( (TextFeld*)worldBestT->zZeichnung( j, 1 ) )->release();
  412. }
  413. worldBestT->removeZeile( 1 );
  414. }
  415. ObjTabelle *tmpWBT = worldBestT->getThis();
  416. MinigameKlientV *tmpKlient = klient->getThis();
  417. Schrift *tmpSchrift = schrift->getThis();
  418. asyncFinished = 0;
  419. new AsynchronCall( [ this, tmpWBT, tmpKlient, tmpSchrift ]()
  420. {
  421. Array< int > score;
  422. RCArray< Text > player;
  423. RCArray< Text > option;
  424. int anz = tmpKlient->getMinigameBestscoreList( "Tetris", &score, &player, &option );
  425. for( int i = 0; i < anz; i++ )
  426. {
  427. TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, Text( score.get( i ) ) );
  428. TextFeld *spielerT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, player.z( i )->getText() );
  429. Text optionen = option.z( i )->getText();
  430. Text *breite = optionen.getTeilText( optionen.positionVon( '=' ) + 1, optionen.positionVon( ',' ) );
  431. Text *höhe = optionen.getTeilText( optionen.positionVon( '=', 1 ) + 1, optionen.positionVon( ',', 1 ) );
  432. Text *nTempo = optionen.getTeilText( optionen.positionVon( '=', 2 ) + 1, optionen.positionVon( ',', 2 ) );
  433. Text *tempo = optionen.getTeilText( optionen.positionVon( '=', 3 ) + 1 );
  434. TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, breite->getText() );
  435. breite->release();
  436. TextFeld *höheT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, höhe->getText() );
  437. höhe->release();
  438. TextFeld *nTempoT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, nTempo->getText() );
  439. nTempo->release();
  440. TextFeld *tempoT = initTextFeld( 0, 0, 0, 0, tmpSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, tempo->getText() );
  441. tempo->release();
  442. Knopf *ansehenK = initKnopf( 0, 0, 0, 0, tmpSchrift, Knopf::Style::Normal, "Ansehen" );
  443. ansehenK->setMausEreignis( [ this, optionen ]( void *p, void *obj, MausEreignis me ) -> bool
  444. {
  445. if( me.id == ME_RLinks && !me.verarbeitet )
  446. {
  447. ( (Knopf*)obj )->removeStyle( Knopf::Style::Erlaubt );
  448. getThis();
  449. new AsynchronCall( [ this, optionen, obj ]()
  450. {
  451. Datei *d = klient->downloadGameCapture( "Tetris", optionen );
  452. ( (Knopf*)obj )->addStyle( Knopf::Style::Erlaubt );
  453. if( wiederH )
  454. wiederH = wiederH->release();
  455. Text options = optionen.getText();
  456. wiederH = new MenüWiederhohlung( schrift, screen, d, &options );
  457. release();
  458. } );
  459. }
  460. return 1;
  461. } );
  462. tmpWBT->addZeile( optionen.getText() );
  463. tmpWBT->setZeichnungZ( 0, i + 1, scoreT );
  464. tmpWBT->setZeichnungZ( 1, i + 1, spielerT );
  465. tmpWBT->setZeichnungZ( 2, i + 1, ansehenK );
  466. tmpWBT->setZeichnungZ( 3, i + 1, breiteT );
  467. tmpWBT->setZeichnungZ( 4, i + 1, höheT );
  468. tmpWBT->setZeichnungZ( 5, i + 1, nTempoT );
  469. tmpWBT->setZeichnungZ( 6, i + 1, tempoT );
  470. }
  471. tmpKlient->release();
  472. tmpWBT->release();
  473. tmpSchrift->release();
  474. }, &asyncFinished );
  475. InitDatei *opd = new InitDatei( "data/Minigames/Tetris/data/optionen.ini" );
  476. opd->laden();
  477. if( !opd->wertExistiert( "Breite" ) )
  478. opd->addWert( "Breite", "15" );
  479. if( !opd->wertExistiert( "Höhe" ) )
  480. opd->addWert( "Höhe", "25" );
  481. if( !opd->wertExistiert( "+Geschwindigkeit" ) )
  482. opd->addWert( "+Geschwindigkeit", "50" );
  483. if( !opd->wertExistiert( "Geschwindigkeit" ) )
  484. opd->addWert( "Geschwindigkeit", "1000" );
  485. if( !opd->wertExistiert( "Fortsetzen" ) )
  486. opd->addWert( "Fortsetzen", "0" );
  487. opd->speichern();
  488. KSGTDatei *stb = new KSGTDatei( "data/Minigames/Tetris/data/score.ksgt" );
  489. stb->laden();
  490. anz = stb->getZeilenAnzahl();
  491. bool *fertig = new bool[ anz ];
  492. ZeroMemory( fertig, anz );
  493. int mS = 0;
  494. int omS = 0;
  495. int oAnz = 0;
  496. for( int i = 0; i < anz; i++ )
  497. {
  498. int maxScore = -1;
  499. int p = -1;
  500. for( int j = 0; j < anz; j++ )
  501. {
  502. if( !fertig[ j ] && maxScore < (int)*stb->zFeld( j, 1 ) )
  503. {
  504. p = j;
  505. maxScore = (int)*stb->zFeld( j, 1 );
  506. }
  507. }
  508. if( p >= 0 )
  509. {
  510. fertig[ p ] = 1;
  511. TextFeld *scoreT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 1 )->getText() );
  512. TextFeld *datumT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 0 )->getText() );
  513. TextFeld *breiteT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 2 )->getText() );
  514. TextFeld *höheT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 3 )->getText() );
  515. TextFeld *schnellerT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 5 )->getText() );
  516. TextFeld *tempoT = initTextFeld( 0, 0, 0, 0, schrift, TextFeld::Style::Text | TextFeld::Style::VCenter, stb->zFeld( p, 4 )->getText() );
  517. gesammtT->addZeile( Text() += p );
  518. gesammtT->setZeichnungZ( 0, i + 1, scoreT );
  519. gesammtT->setZeichnungZ( 1, i + 1, datumT );
  520. gesammtT->setZeichnungZ( 2, i + 1, breiteT );
  521. gesammtT->setZeichnungZ( 3, i + 1, höheT );
  522. gesammtT->setZeichnungZ( 4, i + 1, schnellerT );
  523. gesammtT->setZeichnungZ( 5, i + 1, tempoT );
  524. if( breiteT->zText()->istGleich( opd->zWert( "Breite" )->getText() ) &&
  525. höheT->zText()->istGleich( opd->zWert( "Höhe" )->getText() ) &&
  526. schnellerT->zText()->istGleich( opd->zWert( "+Geschwindigkeit" )->getText() ) &&
  527. tempoT->zText()->istGleich( opd->zWert( "Geschwindigkeit" )->getText() ) )
  528. {
  529. optionenT->addZeile( Text() += p );
  530. int n = optionenT->getZeilenNummer( Text() += p );
  531. optionenT->setZeichnungZ( 0, n, scoreT );
  532. optionenT->setZeichnungZ( 1, n, datumT );
  533. optionenT->setZeichnungZ( 2, n, breiteT );
  534. optionenT->setZeichnungZ( 3, n, höheT );
  535. optionenT->setZeichnungZ( 4, n, schnellerT );
  536. optionenT->setZeichnungZ( 5, n, tempoT );
  537. if( !omS )
  538. omS = maxScore;
  539. oAnz++;
  540. }
  541. }
  542. if( !mS )
  543. mS = maxScore;
  544. }
  545. delete[] fertig;
  546. DiagDaten *gd = new DiagDaten();
  547. gd->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
  548. gd->hIntervallFarbe = 0xFFFFFFFF;
  549. gd->hIntervallName->setText( "Spiel" );
  550. gd->rasterDicke = 1;
  551. gd->rasterFarbe = 0xFF505050;
  552. gd->vIntervallFarbe = 0xFFFFFFFF;
  553. gd->vIntervallName->setText( "Score" );
  554. gesammtD->setDiagDatenZ( gd );
  555. gesammtD->addVIntervallText( mS + 1, Text() += ( mS + 1 ) );
  556. gesammtD->addVIntervallText( 0, "0" );
  557. gesammtD->addHIntervallText( 0, "1" );
  558. if( anz > 1 )
  559. gesammtD->addHIntervallText( anz - 1, Text() += anz );
  560. gesammtD->addWert( "Score" );
  561. gesammtD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
  562. gesammtD->setWertFarbe( 0, 0xFF00FF00 );
  563. gesammtD->zDiagWert( 0 )->hintergrund = 0xFF205050;
  564. DiagDaten *od = new DiagDaten();
  565. od->style = DiagDaten::Style::autoIntervall | DiagDaten::Style::autoRaster | DiagDaten::Style::intervalle | DiagDaten::Style::intervallTexte | DiagDaten::Style::Sichtbar;
  566. od->hIntervallFarbe = 0xFFFFFFFF;
  567. od->hIntervallName->setText( "Spiel" );
  568. od->rasterDicke = 1;
  569. od->rasterFarbe = 0xFF505050;
  570. od->vIntervallFarbe = 0xFFFFFFFF;
  571. od->vIntervallName->setText( "Score" );
  572. optionenD->setDiagDatenZ( od );
  573. optionenD->addVIntervallText( omS + 1, Text() += ( omS + 1 ) );
  574. optionenD->addVIntervallText( 0, "0" );
  575. optionenD->addHIntervallText( 0, "1" );
  576. if( oAnz > 1 )
  577. optionenD->addHIntervallText( oAnz - 1, Text() += oAnz );
  578. optionenD->addWert( "Score" );
  579. optionenD->setWertStyle( 0, DiagWert::Style::Sichtbar | DiagWert::Style::Hintergrund );
  580. optionenD->setWertFarbe( 0, 0xFF00FF00 );
  581. optionenD->zDiagWert( 0 )->hintergrund = 0xFF205050;
  582. int j = 0;
  583. for( int i = 0; i < anz; i++ )
  584. {
  585. gesammtD->addPunkt( 0, i, (int)*stb->zFeld( i, 1 ) );
  586. if( (int)*stb->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
  587. (int)*stb->zFeld( i, 3 ) == (int)*opd->zWert( "Höhe" ) &&
  588. (int)*stb->zFeld( i, 5 ) == (int)*opd->zWert( "+Geschwindigkeit" ) &&
  589. (int)*stb->zFeld( i, 4 ) == (int)*opd->zWert( "Geschwindigkeit" ) )
  590. {
  591. optionenD->addPunkt( 0, j, (int)*stb->zFeld( i, 1 ) );
  592. j++;
  593. }
  594. }
  595. stb->release();
  596. opd->release();
  597. beendet = 0;
  598. }
  599. void MenüStatistik::doMausEreignis( MausEreignis &me )
  600. {
  601. if( wiederH )
  602. {
  603. wiederH->doMausEreignis( me );
  604. return;
  605. }
  606. ansicht->doMausEreignis( me );
  607. optionen->doMausEreignis( me );
  608. gesammtT->doMausEreignis( me );
  609. optionenT->doMausEreignis( me );
  610. worldBestT->doMausEreignis( me );
  611. bool vera = me.verarbeitet;
  612. removen->doMausEreignis( me );
  613. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  614. { // Statistik removen
  615. if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
  616. { // nur bestimmte Statistik removen
  617. InitDatei *opd = new InitDatei( "data/Minigames/Tetris/data/optionen.ini" );
  618. opd->laden();
  619. KSGTDatei *score = new KSGTDatei( "data/Minigames/Tetris/data/score.ksgt" );
  620. score->laden();
  621. int zeilen = score->getZeilenAnzahl();
  622. for( int i = 0; i < zeilen; i++ )
  623. {
  624. if( (int)*score->zFeld( i, 2 ) == (int)*opd->zWert( "Breite" ) &&
  625. (int)*score->zFeld( i, 3 ) == (int)*opd->zWert( "Höhe" ) &&
  626. (int)*score->zFeld( i, 5 ) == (int)*opd->zWert( "+Geschwindigkeit" ) &&
  627. (int)*score->zFeld( i, 4 ) == (int)*opd->zWert( "Geschwindigkeit" ) )
  628. {
  629. score->removeZeile( i );
  630. i--;
  631. zeilen--;
  632. }
  633. }
  634. score->speichern();
  635. score->release();
  636. opd->release();
  637. }
  638. else // alles removen
  639. DateiRemove( "data/Minigames/Tetris/data/score.ksgt" );
  640. reset();
  641. }
  642. vera = me.verarbeitet;
  643. zurück->doMausEreignis( me );
  644. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  645. beendet = 1;
  646. }
  647. bool MenüStatistik::tick( double tickVal )
  648. {
  649. if( wiederH )
  650. {
  651. bool ret = wiederH->tick( tickVal );
  652. if( wiederH->istBeendet() )
  653. wiederH = wiederH->release();
  654. return ret;
  655. }
  656. bool ret = ansicht->tick( tickVal );
  657. ret |= optionen->tick( tickVal );
  658. ret |= removen->tick( tickVal );
  659. ret |= zurück->tick( tickVal );
  660. ret |= gesammtT->tick( tickVal );
  661. ret |= optionenT->tick( tickVal );
  662. ret |= gesammtD->tick( tickVal );
  663. ret |= optionenD->tick( tickVal );
  664. ret |= worldBestT->tick( tickVal );
  665. return ret;
  666. }
  667. void MenüStatistik::render( Bild &zRObj )
  668. {
  669. if( wiederH )
  670. {
  671. wiederH->render( zRObj );
  672. return;
  673. }
  674. schrift->setSchriftSize( 12 );
  675. Text weltScore = "Welt Score:";
  676. schrift->setDrawPosition( 10, 40 );
  677. schrift->renderText( &weltScore, zRObj, 0xFFFFFFFF );
  678. Text localScore = "Dein Score:";
  679. schrift->setDrawPosition( 10, 170 );
  680. schrift->renderText( &localScore, zRObj, 0xFFFFFFFF );
  681. worldBestT->render( zRObj );
  682. if( !ansicht->getAuswahl() )
  683. {
  684. if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
  685. optionenT->render( zRObj );
  686. else
  687. gesammtT->render( zRObj );
  688. }
  689. else
  690. {
  691. if( optionen->hatStyle( KontrollKnopf::Style::Selected ) )
  692. optionenD->render( zRObj );
  693. else
  694. gesammtD->render( zRObj );
  695. }
  696. ansichtT->render( zRObj );
  697. ansicht->render( zRObj );
  698. optionen->render( zRObj );
  699. removen->render( zRObj );
  700. zurück->render( zRObj );
  701. }
  702. // constant
  703. bool MenüStatistik::istBeendet() const
  704. {
  705. return beendet;
  706. }
  707. bool MenüStatistik::istWiederhohlung() const
  708. {
  709. return wiederH != 0;
  710. }
  711. // Reference Counting
  712. MenüStatistik *MenüStatistik::getThis()
  713. {
  714. ref++;
  715. return this;
  716. }
  717. MenüStatistik *MenüStatistik::release()
  718. {
  719. ref--;
  720. if( !ref )
  721. delete this;
  722. return 0;
  723. }
  724. // Inhalt der MenüOptionen aus Menü.h
  725. // Konstruktor
  726. MenüOptionen::MenüOptionen( Schrift *zSchrift, Bildschirm *zScreen )
  727. {
  728. breiteT = initTextFeld( 310, 140, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Breite:" );
  729. breite = initTextFeld( 440, 140, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  730. breite->setTastaturEreignis( _nurNummernTE );
  731. höheT = initTextFeld( 310, 180, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Spielfeld Höhe:" );
  732. höhe = initTextFeld( 440, 180, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  733. höhe->setTastaturEreignis( _nurNummernTE );
  734. neuTempoT = initTextFeld( 310, 220, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Verschnellerung:" );
  735. neuTempo = initTextFeld( 440, 220, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  736. neuTempo->setTastaturEreignis( _nurNummernTE );
  737. tempoT = initTextFeld( 310, 260, 130, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::VCenter, "Zeit Abstände:" );
  738. tempo = initTextFeld( 440, 260, 50, 20, zSchrift, TextFeld::Style::TextFeld, "" );
  739. tempo->setTastaturEreignis( _nurNummernTE );
  740. fortsetzen = initKontrollKnopf( 310, 300, 180, 20, zSchrift, KontrollKnopf::Style::Normal, "Letztes Spiel fortsetzen" );
  741. fortsetzen->setMausEreignis( _ret1ME );
  742. abbrechen = initKnopf( 310, 340, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Abbrechen" );
  743. ok = initKnopf( 405, 340, 85, 20, zSchrift, Knopf::Style::Sichtbar, "Ok" );
  744. beendet = 0;
  745. ref = 1;
  746. }
  747. // Destruktor
  748. MenüOptionen::~MenüOptionen()
  749. {
  750. breiteT->release();
  751. breite->release();
  752. höheT->release();
  753. höhe->release();
  754. neuTempoT->release();
  755. neuTempo->release();
  756. tempoT->release();
  757. tempo->release();
  758. fortsetzen->release();
  759. abbrechen->release();
  760. ok->release();
  761. }
  762. // nicht constant
  763. void MenüOptionen::reset()
  764. {
  765. InitDatei *opd = new InitDatei( "data/Minigames/Tetris/data/optionen.ini" );
  766. if( !opd->laden() )
  767. DateiPfadErstellen( "data/Minigames/Tetris/data/optionen.ini" );
  768. breite->setText( "15" );
  769. if( opd->wertExistiert( "Breite" ) )
  770. breite->setText( Text() += (int)*opd->zWert( "Breite" ) );
  771. else
  772. opd->addWert( "Breite", "15" );
  773. höhe->setText( "25" );
  774. if( opd->wertExistiert( "Höhe" ) )
  775. höhe->setText( Text() += (int)*opd->zWert( "Höhe" ) );
  776. else
  777. opd->addWert( "Höhe", "25" );
  778. neuTempo->setText( "50" );
  779. if( opd->wertExistiert( "+Geschwindigkeit" ) )
  780. neuTempo->setText( Text() += (int)*opd->zWert( "+Geschwindigkeit" ) );
  781. else
  782. opd->addWert( "+Geschwindigkeit", "50" );
  783. tempo->setText( "1000" );
  784. if( opd->wertExistiert( "Geschwindigkeit" ) )
  785. tempo->setText( Text() += (int)*opd->zWert( "Geschwindigkeit" ) );
  786. else
  787. opd->addWert( "Geschwindigkeit", "1000" );
  788. fortsetzen->removeStyle( KontrollKnopf::Style::Selected );
  789. if( opd->wertExistiert( "Fortsetzen" ) )
  790. fortsetzen->setStyle( KontrollKnopf::Style::Selected, (int)*opd->zWert( "Fortsetzen" ) != 0 );
  791. else
  792. opd->addWert( "Fortsetzen", "0" );
  793. beendet = 0;
  794. opd->speichern();
  795. opd->release();
  796. }
  797. void MenüOptionen::doMausEreignis( MausEreignis &me )
  798. {
  799. breite->doMausEreignis( me );
  800. höhe->doMausEreignis( me );
  801. neuTempo->doMausEreignis( me );
  802. tempo->doMausEreignis( me );
  803. fortsetzen->doMausEreignis( me );
  804. bool vera = me.verarbeitet;
  805. abbrechen->doMausEreignis( me );
  806. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  807. beendet = 1;
  808. vera = me.verarbeitet;
  809. ok->doMausEreignis( me );
  810. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  811. {
  812. InitDatei *opd = new InitDatei( "data/Minigames/Tetris/data/optionen.ini" );
  813. if( !opd->laden() )
  814. DateiPfadErstellen( "data/Minigames/tetris/data/optionen.ini" );
  815. if( (int)*breite->zText() > 100 )
  816. breite->setText( "100" );
  817. if( (int)*breite->zText() < 5 )
  818. breite->setText( "5" );
  819. if( opd->wertExistiert( "Breite" ) )
  820. opd->setWert( "Breite", Text() += (int)*breite->zText() );
  821. else
  822. opd->addWert( "Breite", Text() += (int)*breite->zText() );
  823. if( (int)*höhe->zText() > 100 )
  824. höhe->setText( "100" );
  825. if( (int)*höhe->zText() < 10 )
  826. höhe->setText( "10" );
  827. if( opd->wertExistiert( "Höhe" ) )
  828. opd->setWert( "Höhe", Text() += (int)*höhe->zText() );
  829. else
  830. opd->addWert( "Höhe", Text() += (int)*höhe->zText() );
  831. if( (int)*neuTempo->zText() > (int)*tempo->zText() )
  832. neuTempo->setText( *tempo->zText() );
  833. if( (int)*neuTempo->zText() < 0 )
  834. neuTempo->setText( "0" );
  835. if( opd->wertExistiert( "+Geschwindigkeit" ) )
  836. opd->setWert( "+Geschwindigkeit", Text() += (int)*neuTempo->zText() );
  837. else
  838. opd->addWert( "+Geschwindigkeit", Text() += (int)*neuTempo->zText() );
  839. if( (int)*tempo->zText() < 100 )
  840. tempo->setText( "100" );
  841. if( opd->wertExistiert( "Geschwindigkeit" ) )
  842. opd->setWert( "Geschwindigkeit", Text() += (int)*tempo->zText() );
  843. else
  844. opd->addWert( "Geschwindigkeit", Text() += (int)*tempo->zText() );
  845. if( opd->wertExistiert( "Fortsetzen" ) )
  846. opd->setWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
  847. else
  848. opd->addWert( "Fortsetzen", Text() += (int)fortsetzen->hatStyle( KontrollKnopf::Style::Selected ) );
  849. opd->speichern();
  850. opd->release();
  851. beendet = 1;
  852. }
  853. }
  854. void MenüOptionen::doTastaturEreignis( TastaturEreignis &te )
  855. {
  856. breite->doTastaturEreignis( te );
  857. höhe->doTastaturEreignis( te );
  858. neuTempo->doTastaturEreignis( te );
  859. tempo->doTastaturEreignis( te );
  860. }
  861. bool MenüOptionen::tick( double tickVal )
  862. {
  863. bool ret = breite->tick( tickVal );
  864. ret |= höhe->tick( tickVal );
  865. ret |= neuTempo->tick( tickVal );
  866. ret |= tempo->tick( tickVal );
  867. ret |= fortsetzen->tick( tickVal );
  868. ret |= abbrechen->tick( tickVal );
  869. ret |= ok->tick( tickVal );
  870. return ret;
  871. }
  872. void MenüOptionen::render( Bild &zRObj )
  873. {
  874. breiteT->render( zRObj );
  875. breite->render( zRObj );
  876. höheT->render( zRObj );
  877. höhe->render( zRObj );
  878. neuTempoT->render( zRObj );
  879. neuTempo->render( zRObj );
  880. tempoT->render( zRObj );
  881. tempo->render( zRObj );
  882. fortsetzen->render( zRObj );
  883. abbrechen->render( zRObj );
  884. ok->render( zRObj );
  885. }
  886. // constant
  887. bool MenüOptionen::istBeendet() const
  888. {
  889. return beendet;
  890. }
  891. // Reference Counting
  892. MenüOptionen *MenüOptionen::getThis()
  893. {
  894. ref++;
  895. return this;
  896. }
  897. MenüOptionen *MenüOptionen::release()
  898. {
  899. ref--;
  900. if( !ref )
  901. delete this;
  902. return 0;
  903. }
  904. // Inhalt der Menü Klasse aus Menü.h
  905. // Konstruktor
  906. Menü::Menü( Schrift *zSchrift, Bildschirm *zScreen, MinigameKlientV *klient )
  907. {
  908. spielen = initKnopf( 350, 180, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Spielen" );
  909. spielenF = new MenüSpiel( zSchrift, zScreen, klient->getThis() );
  910. optionen = initKnopf( 350, 220, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Optionen" );
  911. optionenF = new MenüOptionen( zSchrift, zScreen );
  912. statistik = initKnopf( 350, 260, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Statistik" );
  913. statistikF = new MenüStatistik( zSchrift, zScreen, klient );
  914. beenden = initKnopf( 350, 300, 100, 20, zSchrift, Knopf::Style::Sichtbar, "Beenden" );
  915. ram = new LRahmen();
  916. ram->setFarbe( 0xFFFFFFFF );
  917. beendet = 0;
  918. status = 0;
  919. LTDBDatei *bgd = new LTDBDatei();
  920. bgd->setDatei( new Text( "data/Minigames/Tetris/bilder/hintergrund.ltdb" ) );
  921. bgd->leseDaten( 0 );
  922. hintergrund = bgd->laden( 0, new Text( "bg.jpg" ) );
  923. bgd->release();
  924. ref = 1;
  925. }
  926. // Destruktor
  927. Menü::~Menü()
  928. {
  929. spielen->release();
  930. spielenF->release();
  931. optionen->release();
  932. optionenF->release();
  933. statistik->release();
  934. statistikF->release();
  935. beenden->release();
  936. if( hintergrund )
  937. hintergrund->release();
  938. ram->release();
  939. }
  940. // nicht constant
  941. void Menü::reset()
  942. {
  943. status = 0;
  944. beendet = 0;
  945. }
  946. void Menü::doMausEreignis( MausEreignis &me )
  947. {
  948. switch( status )
  949. {
  950. case 0:
  951. if( 1 )
  952. {
  953. bool vera = me.verarbeitet;
  954. spielen->doMausEreignis( me );
  955. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  956. {
  957. spielenF->reset();
  958. status = 3;
  959. }
  960. vera = me.verarbeitet;
  961. optionen->doMausEreignis( me );
  962. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  963. {
  964. optionenF->reset();
  965. status = 1;
  966. }
  967. vera = me.verarbeitet;
  968. statistik->doMausEreignis( me );
  969. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  970. {
  971. statistikF->reset();
  972. status = 2;
  973. }
  974. vera = me.verarbeitet;
  975. beenden->doMausEreignis( me );
  976. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  977. beendet = 1;
  978. }
  979. break;
  980. case 1:
  981. optionenF->doMausEreignis( me );
  982. break;
  983. case 2:
  984. statistikF->doMausEreignis( me );
  985. break;
  986. case 3:
  987. spielenF->doMausEreignis( me );
  988. }
  989. }
  990. void Menü::doTastaturEreignis( TastaturEreignis &te )
  991. {
  992. if( status == 1 )
  993. optionenF->doTastaturEreignis( te );
  994. if( status == 3 )
  995. spielenF->doTastaturEreignis( te );
  996. }
  997. bool Menü::tick( double z )
  998. {
  999. switch( status )
  1000. {
  1001. case 0:
  1002. if( 1 )
  1003. {
  1004. bool ret = spielen->tick( z );
  1005. ret |= statistik->tick( z );
  1006. ret |= optionen->tick( z );
  1007. ret |= beenden->tick( z );
  1008. return ret;
  1009. }
  1010. case 1:
  1011. if( optionenF->istBeendet() )
  1012. {
  1013. status = 0;
  1014. return 1;
  1015. }
  1016. return optionenF->tick( z );
  1017. case 2:
  1018. if( statistikF->istBeendet() )
  1019. {
  1020. status = 0;
  1021. return 1;
  1022. }
  1023. return statistikF->tick( z );
  1024. case 3:
  1025. if( spielenF->istBeendet() )
  1026. {
  1027. status = 0;
  1028. return 1;
  1029. }
  1030. return spielenF->tick( z );
  1031. }
  1032. return 0;
  1033. }
  1034. void Menü::render( Bild &zRObj )
  1035. {
  1036. if( status != 3 && hintergrund && ( status != 2 || !statistikF->istWiederhohlung() ) )
  1037. zRObj.drawBild( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), *hintergrund );
  1038. switch( status )
  1039. {
  1040. case 0:
  1041. ram->setPosition( 300, 170 );
  1042. ram->setSize( 200, 160 );
  1043. zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
  1044. ram->render( zRObj );
  1045. spielen->render( zRObj );
  1046. statistik->render( zRObj );
  1047. optionen->render( zRObj );
  1048. beenden->render( zRObj );
  1049. break;
  1050. case 1:
  1051. ram->setPosition( 300, 130 );
  1052. ram->setSize( 200, 240 );
  1053. zRObj.alphaRegion( ram->getX(), ram->getY(), ram->getBreite(), ram->getHeight(), 0xD0000000 );
  1054. ram->render( zRObj );
  1055. optionenF->render( zRObj );
  1056. break;
  1057. case 2:
  1058. if( hintergrund && !statistikF->istWiederhohlung() )
  1059. zRObj.alphaRegion( 0, 0, hintergrund->getBreite(), hintergrund->getHeight(), 0xD0000000 );
  1060. statistikF->render( zRObj );
  1061. break;
  1062. case 3:
  1063. spielenF->render( zRObj );
  1064. }
  1065. }
  1066. // constant
  1067. bool Menü::istBeendet() const
  1068. {
  1069. return beendet;
  1070. }
  1071. // Reference Counting
  1072. Menü *Menü::getThis()
  1073. {
  1074. ref++;
  1075. return this;
  1076. }
  1077. Menü *Menü::release()
  1078. {
  1079. ref--;
  1080. if( !ref )
  1081. delete this;
  1082. return 0;
  1083. }