SpielLaden.cpp 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589
  1. #include "SpielLaden.h"
  2. #include "..\..\..\Global\Variablen.h"
  3. #include "..\..\..\Global\Initialisierung.h"
  4. #include "..\..\..\Leser\KartenLeser.h"
  5. #include <DateiSystem.h>
  6. #include <Rahmen.h>
  7. #include <AlphaFeld.h>
  8. #include <Punkt.h>
  9. // Inhalt der SpielLadenListeSpieler Klasse aus SpielLaden.h
  10. // Konstruktor
  11. SpielLadenListeSpieler::SpielLadenListeSpieler( int accountId, Schrift *zSchrift )
  12. {
  13. rahmen = new LRahmen();
  14. rahmen->setSize( 862, 22 );
  15. rahmen->setRamenBreite( 1 );
  16. rahmen->setFarbe( 0xFFFFFFFF );
  17. this->accountId = accountId;
  18. Text *n = infoClient->getSpielerName( accountId );
  19. name = initTextFeld( 1, 1, 149, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, n->getText() );
  20. n->release();
  21. team = initTextFeld( 230, 1, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "0" );
  22. ping = initTextFeld( 410, 1, 50, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "0" );
  23. fortschritt = new FBalken();
  24. fortschritt->setStyle( FBalken::Style::Hintergrund | FBalken::Style::HBild | FBalken::Style::L_R | FBalken::Style::FBild | FBalken::Style::Prozent | FBalken::Style::Sichtbar );
  25. fortschritt->setSchriftZ( zSchrift->getThis() );
  26. fortschritt->setSFarbe( 0xFFFFFFFF );
  27. fortschritt->setSSize( 12 );
  28. fortschritt->setPosition( 461, 1 );
  29. fortschritt->setSize( 400, 20 );
  30. fortschritt->reset();
  31. fortschritt->setAktionAnzahl( 100 );
  32. Bild *fbhb = bilder->get( "system.ltdb/fortschritt lehr.png" );
  33. if( !fbhb )
  34. {
  35. LTDBDatei *datei = new LTDBDatei();
  36. datei->setDatei( new Text( "data/bilder/system.ltdb" ) );
  37. datei->leseDaten( 0 );
  38. fbhb = datei->laden( 0, new Text( "fortschrittleh" ) );
  39. datei->release();
  40. bilder->add( "system.ltdb/fortschritt lehr.png", fbhb->getThis() );
  41. }
  42. Bild *fbfhb = bilder->get( "system.ltdb/fortschritt voll.png" );
  43. if( !fbfhb )
  44. {
  45. LTDBDatei *datei = new LTDBDatei();
  46. datei->setDatei( new Text( "data/bilder/system.ltdb" ) );
  47. datei->leseDaten( 0 );
  48. fbfhb = datei->laden( 0, new Text( "fortschrittvol" ) );
  49. datei->release();
  50. bilder->add( "system.ltdb/fortschritt voll.png", fbfhb->getThis() );
  51. }
  52. fortschritt->setHintergrundBildZ( fbhb );
  53. fortschritt->setFBgBildZ( fbfhb );
  54. spielerFarbe = 0;
  55. teamFarbe = 0;
  56. p = 0;
  57. teamName = new Text( "" );
  58. rend = 0;
  59. ref = 1;
  60. }
  61. // Destruktor
  62. SpielLadenListeSpieler::~SpielLadenListeSpieler()
  63. {
  64. rahmen->release();
  65. name->release();
  66. team->release();
  67. ping->release();
  68. fortschritt->release();
  69. teamName->release();
  70. }
  71. // nicht constant
  72. void SpielLadenListeSpieler::setFortschritt( int prozent )
  73. {
  74. fortschritt->aktionPlus( prozent - fortschritt->getAktion() );
  75. rend = 1;
  76. }
  77. void SpielLadenListeSpieler::setPing( int ping )
  78. {
  79. p = ping;
  80. rend = 1;
  81. }
  82. void SpielLadenListeSpieler::setTeamName( Text *zName )
  83. {
  84. teamName->setText( zName->getText() );
  85. rend = 1;
  86. }
  87. void SpielLadenListeSpieler::setSpielerFarbe( int farbe )
  88. {
  89. spielerFarbe = farbe;
  90. rend = 1;
  91. }
  92. void SpielLadenListeSpieler::setTeamFarbe( int farbe )
  93. {
  94. teamFarbe = farbe;
  95. rend = 1;
  96. }
  97. bool SpielLadenListeSpieler::tick( double tickVal )
  98. {
  99. if( !team->zText()->istGleich( teamName->getText() ) )
  100. {
  101. team->setText( teamName->getText() );
  102. rend = 1;
  103. }
  104. if( TextZuInt( ping->zText()->getText(), 10 ) != p )
  105. {
  106. ping->setText( "" );
  107. ping->zText()->append( p );
  108. rend = 1;
  109. }
  110. bool ret = rend;
  111. rend = 0;
  112. return ret;
  113. }
  114. void SpielLadenListeSpieler::render( int y, Bild &zRObj )
  115. {
  116. if( !zRObj.setDrawOptions( 0, y, 862, 22 ) )
  117. return;
  118. rahmen->render( zRObj );
  119. name->render( zRObj );
  120. zRObj.alphaRegion( 170, 1, 40, 20, spielerFarbe );
  121. team->render( zRObj );
  122. zRObj.alphaRegion( 350, 1, 40, 20, teamFarbe );
  123. ping->render( zRObj );
  124. fortschritt->render( zRObj );
  125. zRObj.releaseDrawOptions();
  126. }
  127. // constant
  128. int SpielLadenListeSpieler::getAccountId() const
  129. {
  130. return accountId;
  131. }
  132. // Reference Counting
  133. SpielLadenListeSpieler *SpielLadenListeSpieler::getThis()
  134. {
  135. ref++;
  136. return this;
  137. }
  138. SpielLadenListeSpieler *SpielLadenListeSpieler::release()
  139. {
  140. ref--;
  141. if( !ref )
  142. delete this;
  143. return 0;
  144. }
  145. // Inhalt der SpielLadenListe Klasse aus SpielLaden.h
  146. // Konstruktor
  147. SpielLadenListe::SpielLadenListe( Schrift *zSchrift )
  148. {
  149. bildschirmGröße = BildschirmGröße();
  150. spielerAnzahl = 0;
  151. höhe = 0;
  152. breite = 0;
  153. tickVal = 0;
  154. spielerName = initTextFeld( 1, 1, 149, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Spieler Name" );
  155. spielerFarbe = initTextFeld( 150, 1, 90, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Spieler Farbe" );
  156. teamName = initTextFeld( 230, 1, 100, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Team Name" );
  157. teamFarbe = initTextFeld( 330, 1, 80, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Team Farbe" );
  158. ping = initTextFeld( 410, 1, 50, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Ping" );
  159. fortschritt = initTextFeld( 460, 1, 400, 20, zSchrift, TextFeld::Style::Text | TextFeld::Style::Center, "Fortschritt" );
  160. rahmen = new LRahmen();
  161. rahmen->setFarbe( 0xFFFFFFFF );
  162. rahmen->setRamenBreite( 1 );
  163. titel = new AlphaFeld();
  164. titel->setFarbe( 0x1000FF00 );
  165. titel->setStrength( -15 );
  166. spieler = new RCArray < SpielLadenListeSpieler >();
  167. sts = 0;
  168. schrift = zSchrift->getThis();
  169. alpha = 0;
  170. animation = 0;
  171. rend = 0;
  172. ref = 1;
  173. }
  174. // Destruktor
  175. SpielLadenListe::~SpielLadenListe()
  176. {
  177. spielerName->release();
  178. spielerFarbe->release();
  179. teamName->release();
  180. teamFarbe->release();
  181. ping->release();
  182. fortschritt->release();
  183. rahmen->release();
  184. titel->release();
  185. spieler->release();
  186. schrift->release();
  187. if( sts )
  188. sts->release();
  189. }
  190. // nicht constant
  191. void SpielLadenListe::setSTS( SpielerTeamStruktur *sts )
  192. {
  193. if( this->sts )
  194. this->sts->release();
  195. this->sts = sts;
  196. rend = 1;
  197. }
  198. void SpielLadenListe::setSichtbar( bool sichtbar )
  199. {
  200. animation = sichtbar ? 1 : 3;
  201. }
  202. void SpielLadenListe::addSpieler( int accountId, int spielerNummer )
  203. {
  204. SpielLadenListeSpieler *tmp = new SpielLadenListeSpieler( accountId, schrift );
  205. int team = 0;
  206. int max = 0;
  207. int min = 0;
  208. for( int i = 0; i < sts->teamAnzahl; i++ )
  209. {
  210. min = max;
  211. max += sts->teamSize->get( i );
  212. if( spielerNummer >= min && spielerNummer < max )
  213. {
  214. team = i;
  215. break;
  216. }
  217. }
  218. tmp->setSpielerFarbe( sts->spielerFarbe->hat( spielerNummer ) ? sts->spielerFarbe->get( spielerNummer ) : 0 );
  219. tmp->setTeamFarbe( sts->teamFarbe->hat( team ) ? sts->teamFarbe->get( team ) : 0 );
  220. tmp->setTeamName( sts->teamName->z( team ) );
  221. spieler->set( tmp, spielerAnzahl );
  222. spielerAnzahl++;
  223. rend = 1;
  224. }
  225. void SpielLadenListe::setSpielerFortschritt( int accountId, int prozent )
  226. {
  227. for( int i = 0; i < spielerAnzahl; i++ )
  228. {
  229. if( spieler->z( i )->getAccountId() == accountId )
  230. {
  231. spieler->z( i )->setFortschritt( prozent );
  232. break;
  233. }
  234. }
  235. }
  236. void SpielLadenListe::setSpielerPing( int accountId, int ping )
  237. {
  238. for( int i = 0; i < spielerAnzahl; i++ )
  239. {
  240. if( spieler->z( i )->getAccountId() == accountId )
  241. {
  242. spieler->z( i )->setPing( ping );
  243. break;
  244. }
  245. }
  246. }
  247. bool SpielLadenListe::tick( double tickVal )
  248. {
  249. for( int i = 0; i < spielerAnzahl; i++ )
  250. rend |= spieler->z( i )->tick( tickVal );
  251. this->tickVal += tickVal * 500;
  252. int val = ( int )this->tickVal;
  253. if( !val )
  254. {
  255. bool ret = rend;
  256. rend = 0;
  257. return ret;
  258. }
  259. this->tickVal -= val;
  260. if( breite && animation != 4 && höhe != spielerAnzahl * 22 + 23 )
  261. {
  262. höhe += val / 2;
  263. if( höhe > spielerAnzahl * 22 + 23 )
  264. höhe = spielerAnzahl * 22 + 23;
  265. rend = 1;
  266. }
  267. switch( animation )
  268. {
  269. case 1: // größe ++
  270. breite += val;
  271. if( breite >= 864 )
  272. {
  273. breite = 864;
  274. animation = 2;
  275. }
  276. rend = 1;
  277. break;
  278. case 2: // alpha ++
  279. if( alpha + val > 255 )
  280. {
  281. alpha = 255;
  282. animation = 0;
  283. }
  284. else
  285. alpha += val;
  286. rend = 1;
  287. break;
  288. case 3: // alpha --
  289. if( alpha - val < 0 )
  290. {
  291. alpha = 0;
  292. animation = 4;
  293. }
  294. else
  295. alpha -= val;
  296. rend = 1;
  297. break;
  298. case 4: // größe --
  299. breite -= val;
  300. if( breite <= 0 )
  301. {
  302. breite = 0;
  303. höhe = 0;
  304. animation = 0;
  305. }
  306. else if( breite < spielerAnzahl * 22 + 23 )
  307. höhe = breite;
  308. rend = 1;
  309. break;
  310. }
  311. bool ret = rend;
  312. rend = 0;
  313. return ret;
  314. }
  315. void SpielLadenListe::render( Bild &zRObj )
  316. {
  317. if( !breite )
  318. return;
  319. int x = bildschirmGröße.x / 2 - breite / 2;
  320. int y = bildschirmGröße.y / 2 - höhe / 2;
  321. if( !zRObj.setDrawOptions( x, y, breite, höhe ) )
  322. return;
  323. rahmen->setSize( breite, höhe );
  324. rahmen->render( zRObj );
  325. zRObj.setAlpha( alpha );
  326. titel->setPosition( 1, 1 );
  327. titel->setSize( breite - 2, 20 );
  328. titel->render( zRObj );
  329. spielerName->render( zRObj );
  330. spielerFarbe->render( zRObj );
  331. spielerName->render( zRObj );
  332. teamFarbe->render( zRObj );
  333. ping->render( zRObj );
  334. fortschritt->render( zRObj );
  335. zRObj.releaseAlpha();
  336. zRObj.drawLinieH( 1, 21, breite - 2, 0xFFFFFFFF );
  337. if( höhe > 22 )
  338. {
  339. if( !zRObj.setDrawOptions( 1, 22, breite - 2, höhe - 2 ) )
  340. {
  341. zRObj.releaseDrawOptions();
  342. return;
  343. }
  344. zRObj.alphaRegion( 0, 0, breite - 2, höhe - 23, 0x50000000 );
  345. zRObj.setAlpha( alpha );
  346. for( int i = 0; i < spielerAnzahl; i++ )
  347. spieler->z( i )->render( i * 22, zRObj );
  348. zRObj.releaseAlpha();
  349. zRObj.releaseDrawOptions();
  350. }
  351. zRObj.releaseDrawOptions();
  352. }
  353. // constant
  354. int SpielLadenListe::getHeight() const
  355. {
  356. return höhe;
  357. }
  358. int SpielLadenListe::getAlpha() const
  359. {
  360. return (int)alpha;
  361. }
  362. // Reference Counting
  363. SpielLadenListe *SpielLadenListe::getThis()
  364. {
  365. ref++;
  366. return this;
  367. }
  368. SpielLadenListe *SpielLadenListe::release()
  369. {
  370. ref--;
  371. if( !ref )
  372. delete this;
  373. return 0;
  374. }
  375. // Inhalt der SpielLaden Klasse aus SpielLaden.h
  376. // Konstruktor
  377. SpielLaden::SpielLaden( Schrift *zSchrift )
  378. : Thread()
  379. {
  380. karteId = 0;
  381. bildschirmGröße = BildschirmGröße();
  382. hintergrundBild = 0;
  383. ladenAlpha = 0;
  384. hintergrundAlpha = 0;
  385. ladenBild = 0;
  386. tickVal = 0;
  387. geladen = 0;
  388. liste = new SpielLadenListe( zSchrift );
  389. animation = 0;
  390. ende = 0;
  391. rend = 0;
  392. }
  393. // Destruktor
  394. SpielLaden::~SpielLaden()
  395. {
  396. warteAufThread( 1000 );
  397. if( geladen )
  398. hintergrundBild->release();
  399. liste->release();
  400. }
  401. // nicht constant
  402. void SpielLaden::setSpielerTeamStruktur( SpielerTeamStruktur *sts )
  403. {
  404. liste->setSTS( sts );
  405. rend = 1;
  406. }
  407. void SpielLaden::setKarte( int karteId )
  408. {
  409. this->karteId = karteId;
  410. start();
  411. rend = 1;
  412. }
  413. void SpielLaden::setSichtbar( bool sichtbar )
  414. {
  415. animation = sichtbar ? 1 : 4;
  416. }
  417. void SpielLaden::thread()
  418. {
  419. KartenLeser *reader = KartenLeser::getInstance();
  420. reader->lock();
  421. reader->setKarteId( karteId );
  422. hintergrundBild = reader->getLadeBild();
  423. reader->unlock();
  424. reader->release();
  425. if( hintergrundBild )
  426. geladen = 1;
  427. else
  428. run = 0;
  429. }
  430. void SpielLaden::addSpieler( int accountId, int spielerNummer )
  431. {
  432. liste->addSpieler( accountId, spielerNummer );
  433. }
  434. void SpielLaden::setSpielerFortschritt( int accountId, int prozent )
  435. {
  436. liste->setSpielerFortschritt( accountId, prozent );
  437. }
  438. void SpielLaden::setSpielerPing( int accountId, int ping )
  439. {
  440. liste->setSpielerPing( accountId, ping );
  441. }
  442. bool SpielLaden::tick( double tickVal )
  443. {
  444. if( ende )
  445. return 0;
  446. rend |= liste->tick( tickVal );
  447. if( ladenAlpha )
  448. rend = 1;
  449. ladenBild++;
  450. if( ladenBild >= ladeAnimation->zAnimationData()->getBildAnzahl() )
  451. ladenBild = 0;
  452. if( !animation && geladen && ladenAlpha && !ende )
  453. animation = 2;
  454. this->tickVal += tickVal * 150;
  455. int val = ( int )this->tickVal;
  456. if( !val )
  457. {
  458. bool ret = rend;
  459. rend = 0;
  460. return ret;
  461. }
  462. this->tickVal -= val;
  463. switch( animation )
  464. { // ------- Beginne zu laden -------
  465. case 1: // Sichtbar machen der Ladeanimation
  466. if( ladenAlpha + val >= 255 )
  467. {
  468. ladenAlpha = 255;
  469. animation = 0;
  470. if( geladen )
  471. animation = 2;
  472. }
  473. else
  474. ladenAlpha += val;
  475. rend = 1;
  476. break;
  477. case 2: // Sichtbar machen des Hintergrund Bildes
  478. if( hintergrundAlpha + val > 255 )
  479. {
  480. hintergrundAlpha = 255;
  481. animation = 3;
  482. }
  483. else
  484. hintergrundAlpha += val;
  485. rend = 1;
  486. break;
  487. case 3: // Unsichtbar machen der Lade Animation
  488. if( ladenAlpha == 255 )
  489. liste->setSichtbar( 1 ); // während dessen die Liste sichtbar machen
  490. if( ladenAlpha - val < 0 )
  491. {
  492. ladenAlpha = 0;
  493. animation = 0;
  494. }
  495. else
  496. ladenAlpha -= val;
  497. rend = 1;
  498. break;
  499. // ------- Laden beenden -------
  500. case 4: // Ladeanimation sichtbar machen
  501. if( !ladenAlpha && liste->getAlpha() == 255 )
  502. liste->setSichtbar( 0 ); // während dessen die Liste unsichtbar machen
  503. if( ladenAlpha + val > 255 )
  504. {
  505. ladenAlpha = 255;
  506. animation = 5;
  507. }
  508. else
  509. ladenAlpha += val;
  510. rend = 1;
  511. break;
  512. case 5: // Hintergrund Bild mit Lade Animation unsichtbar machen
  513. if( hintergrundAlpha - val < 0 )
  514. {
  515. hintergrundAlpha = 0;
  516. ladenAlpha = 0;
  517. ende = 1;
  518. animation = 0;
  519. spielClient->bereitZumSpiel();
  520. }
  521. else
  522. {
  523. hintergrundAlpha -= val;
  524. ladenAlpha -= val;
  525. }
  526. rend = 1;
  527. break;
  528. }
  529. bool ret = rend;
  530. rend = 0;
  531. return ret;
  532. }
  533. void SpielLaden::render( Bild &zRObj )
  534. {
  535. zRObj.setAlpha( hintergrundAlpha );
  536. if( hintergrundBild )
  537. {
  538. zRObj.drawBild( bildschirmGröße.x / 2 - hintergrundBild->getBreite() / 2, bildschirmGröße.y / 2 - hintergrundBild->getHeight() / 2,
  539. hintergrundBild->getBreite(), hintergrundBild->getHeight(), *hintergrundBild );
  540. }
  541. zRObj.releaseAlpha();
  542. liste->render( zRObj );
  543. zRObj.setAlpha( ladenAlpha );
  544. Bild *zLadenBild = ladeAnimation->zAnimationData()->zBild( ladenBild );
  545. zRObj.drawBild( bildschirmGröße.x / 2 - 25, bildschirmGröße.y / 2 - 25, zLadenBild->getBreite(), zLadenBild->getHeight(), *zLadenBild );
  546. zRObj.releaseAlpha();
  547. }
  548. // constant
  549. int SpielLaden::getAlpha() const
  550. {
  551. return hintergrundAlpha;
  552. }