Minigames.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436
  1. #include "MiniGames.h"
  2. #include <Punkt.h>
  3. #include <Rahmen.h>
  4. #include <Datei.h>
  5. #include <InitDatei.h>
  6. #include <KSGTDatei.h>
  7. #include <KSGNetwork.h>
  8. class MSCWrapper : public KSGClient::MinigameServerClient
  9. {
  10. private:
  11. int ref;
  12. public:
  13. MSCWrapper() noexcept
  14. {
  15. ref = 1;
  16. }
  17. // verbindet sich mit dem zugewiesenen Minigame Server
  18. // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
  19. bool verbinde()
  20. {
  21. return 1;
  22. }
  23. // Gibt die Id des aktuell spielenden Accounts zurück
  24. int getAccountId()
  25. {
  26. return 2;
  27. }
  28. // Gibt den Anzeigenamen eines bestimmten Accounts zurück
  29. // id: Die id des Accounts
  30. Text *getAccountName( int id )
  31. {
  32. return new Text( "Test" );
  33. }
  34. // Gibt eine geheime zeichenkette die nur der client kennt zurück (ist bei spielstart)
  35. Text *getSecret()
  36. {
  37. return new Text( "ec6e2d97b2a32423082c6385699ace1067c3a3719debe6f761b5aff1159c9342b6eeba932b2ea3db8d48c0e53e0e8dcefa56723de7488d49e9bccd197d334276" );
  38. }
  39. // Ermittelt die liste mit allen Optionen zu einem Minigame zurück, zu denen es Welt beste Scores gibt
  40. // mName: Der Name des Minigames
  41. // zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen
  42. // Gibt die Anzahl der Optionen zurück
  43. int getMinigameOptionList( char *mName, Framework::RCArray< Framework::Text > *zOptionList )
  44. {
  45. return 0;
  46. }
  47. // Ermittelt eine Liste mit den Weltbesten Scores zurück
  48. // mName: Der Name des Minigames
  49. // zScore: Enthält nach erfolgreichem Aufruf eine Liste mit Scores
  50. // zPlayerList: Enthält nach erfolgreichem Aufruf eine Liste mit angezeigten Account Namen, die die Scores erreicht haben.
  51. // zOptionList: Enthält nach erfolgreichem Aufruf eine Liste mit Optionen, die beim erreichen der Scores aktiv waren.
  52. // Gibt die Anzahl der Bestscores zurück
  53. int getMinigameBestscoreList( char *mName, Framework::Array< int > *zScore, Framework::RCArray< Framework::Text > *zPlayerList, Framework::RCArray< Framework::Text > *zOptionList )
  54. {
  55. return 0;
  56. }
  57. // Gibt den Welt bestscore zu einem Bestimmten Minigame mit bestimmten Optionen zurück.
  58. // mName: Der Name des Minigames
  59. // oName: Die Optionen
  60. // zPlayer: Enthält nach erfolgreichem Aufruf den Angezeigten Namen des Accounts, der den Score erreicht hat
  61. int getMinigameOptionBestscore( char *mName, char *oName, Framework::Text *zPlayer )
  62. {
  63. return 0;
  64. }
  65. // Meldet die Beendigung eines Minigames
  66. // mName: Der Name des Minigames
  67. // oName: Die Optionen mit denen gespielt wurde
  68. // score: Der Erreichte Score
  69. // zCapture: Ein Zeiger auf eine Datei mit der Spielaufzeichnung
  70. // Gibt 0 zurück wenn eines Fehler aufgetreten ist, 1 wenn der Forgang erfolgreich war
  71. bool reportEndOfGame( char *mName, char *oName, int score, Framework::Datei *zCapture )
  72. {
  73. return 1;
  74. }
  75. // Lädt ein Game Capture herunter und speichert sie unter data/tmp/minigames/wb.mgc
  76. // mName: Der Name des Minigames
  77. // oName: Die Optionen
  78. // Gibt die Datei mit dem Capture zurück
  79. Framework::Datei *downloadGameCapture( char *mName, char *oName )
  80. {
  81. return 0;
  82. }
  83. // Erhält die Verbindung aufrecht
  84. // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
  85. // Sollte während einer bestehenden Verbindung etwa einmal alle 60 Sekunden aufgerufen werden, da sonst der Router die Verbindung automatisch trennt
  86. bool keepAlive()
  87. {
  88. return 1;
  89. }
  90. // Trennt die Verbindung zum Server
  91. // Gibt 1 zurück, falls der Vorgang erfolgreich ist, 0 sonnst
  92. // Sollte erst nach einem erfolgreichen Aufruf von verbinde aufgerufen werden
  93. bool trenne( bool abmelden )
  94. {
  95. return 1;
  96. }
  97. // Gibt 1 zurück, falls der Client verbunden ist, 0 sonst
  98. bool istVerbunden() const
  99. {
  100. return 1;
  101. }
  102. // gibt den Letzten Fehlertext zuück
  103. // sollte erst aufgerufen werden, nachdem eine andere aufgerufene Methode fehlgeschlagen ist
  104. char *getLetzterFehler() const
  105. {
  106. return "";
  107. }
  108. // Erhöht den Reference Counter um 1 un gibt this zurück
  109. MinigameServerClient *getThis()
  110. {
  111. ref++;
  112. return this;
  113. }
  114. // Verringert den Reference Counter um 1 und gibt 0 zurück.
  115. // Falls der Reference Counter nach dem Aufruf auf 0 ist löscht sich das Objekt selbst
  116. MinigameServerClient *release()
  117. {
  118. if( !--ref )
  119. delete this;
  120. return 0;
  121. }
  122. };
  123. typedef MiniGameV *( *GetMiniGame )( );
  124. // Inhalt der MGLaden Klasse aus MiniGames.h
  125. // Konstruktor
  126. MGSuchen::MGSuchen( MiniGames *mGames )
  127. : Thread()
  128. {
  129. this->mGames = mGames;
  130. start();
  131. }
  132. // Destruktor
  133. MGSuchen::~MGSuchen()
  134. {
  135. mGames->release();
  136. }
  137. // nicht constant
  138. void MGSuchen::thread()
  139. {
  140. Datei *d = new Datei();
  141. d->setDatei( "data/Minigames" );
  142. if( !d->existiert() )
  143. DateiPfadErstellen( "data/MiniGames/" );
  144. RCArray< Text > *list = d->getDateiListe();
  145. if( list )
  146. {
  147. for( int i = 0; i < list->getEintragAnzahl(); i++ )
  148. {
  149. MiniGame *mg = new MiniGame( list->z( i )->getText() );
  150. if( !mg->istOk() )
  151. {
  152. mg->release();
  153. continue;
  154. }
  155. mGames->addMiniGame( mg );
  156. }
  157. list->release();
  158. }
  159. d->release();
  160. release();
  161. }
  162. // Inhalt der MGLaden Klasse aus MiniGameV.h
  163. // Konstruktor
  164. MGLaden::MGLaden( char *name, DLLDateien *zDLLs, API *api )
  165. : Thread()
  166. {
  167. this->api = api;
  168. this->name = new Text( name );
  169. game = 0;
  170. dLLs = zDLLs->getThis();
  171. start();
  172. }
  173. // Destruktor
  174. MGLaden::~MGLaden()
  175. {
  176. if( game )
  177. {
  178. game->release();
  179. dLLs->releaseDLL( name->getText() );
  180. }
  181. name->release();
  182. dLLs->release();
  183. }
  184. // nicht constant
  185. void MGLaden::thread()
  186. {
  187. Text *pfad = new Text( "data/Minigames/" );
  188. pfad->append( name->getText() );
  189. if( !DateiExistiert( pfad->getThis() ) )
  190. {
  191. pfad->release();
  192. return;
  193. }
  194. pfad->append( "/mg.ini" );
  195. if( !DateiExistiert( pfad->getThis() ) )
  196. {
  197. pfad->release();
  198. return;
  199. }
  200. InitDatei *mgIni = new InitDatei( pfad );
  201. if( !mgIni->laden() )
  202. {
  203. mgIni->release();
  204. return;
  205. }
  206. if( !mgIni->wertExistiert( "DllPfad" ) )
  207. {
  208. mgIni->release();
  209. return;
  210. }
  211. Text *dllPfad = new Text( "data/Minigames/" );
  212. dllPfad->append( name->getText() );
  213. dllPfad->append( "/" );
  214. dllPfad->append( mgIni->zWert( "DllPfad" )->getText() );
  215. mgIni->release();
  216. if( !DateiExistiert( dllPfad->getThis() ) )
  217. {
  218. dllPfad->release();
  219. return;
  220. }
  221. HMODULE dll = dLLs->ladeDLL( name->getText(), dllPfad->getText() );
  222. dllPfad->release();
  223. if( !dll )
  224. return;
  225. GetMiniGame getMiniGame = (GetMiniGame)GetProcAddress( dll, "GetMiniGame" );
  226. if( !getMiniGame )
  227. {
  228. dLLs->releaseDLL( name->getText() );
  229. return;
  230. }
  231. game = getMiniGame();
  232. if( !game )
  233. {
  234. dLLs->releaseDLL( name->getText() );
  235. return;
  236. }
  237. game->setMinigameClientZ( new MSCWrapper() );
  238. game->setMinigameAPI( api );
  239. if( !game->laden() )
  240. {
  241. game = game->release();
  242. dLLs->releaseDLL( name->getText() );
  243. }
  244. }
  245. // constant
  246. bool MGLaden::fertig() const
  247. {
  248. return !isRunning();
  249. }
  250. MiniGameV *MGLaden::zGame() const
  251. {
  252. return game;
  253. }
  254. // Inhalt der MiniGames Klasse aus MiniGames.h
  255. // Konstruktor
  256. MiniGames::MiniGames( Schrift *zSchrift, DLLDateien *zDLLs, Bildschirm *screen, API *api )
  257. : Zeichnung()
  258. {
  259. this->api = api;
  260. this->screen = screen;
  261. dLLs = zDLLs->getThis();
  262. schrift = zSchrift->getThis();
  263. bildschirmGröße = BildschirmGröße();
  264. rahmen = new LRahmen();
  265. setSize( 800, 500 );
  266. rahmen->setFarbe( 0xFFFFFFFF );
  267. alpha2 = 0;
  268. tickVal = 0;
  269. games = new RCArray< MiniGame >();
  270. mgl = 0;
  271. mgInitialized = 0;
  272. new MGSuchen( (MiniGames*)getThis() );
  273. }
  274. // Destruktor
  275. MiniGames::~MiniGames()
  276. {
  277. if( schrift )
  278. schrift->release();
  279. rahmen->release();
  280. games->release();
  281. if( mgl )
  282. mgl->release();
  283. dLLs->release();
  284. }
  285. // nicht constant
  286. void MiniGames::addMiniGame( MiniGame *mg )
  287. {
  288. games->add( mg );
  289. int i = games->getEintragAnzahl() - 1;
  290. games->z( i )->setPosition( 10 + 10 * ( i % 3 ) + 250 * ( i % 3 ), 50 + 10 * ( i / 3 ) + 100 * ( i / 3 ) );
  291. int anz = games->getEintragAnzahl();
  292. bool *fertig = new bool[ anz ];
  293. for( int i = 0; i < anz; i++ )
  294. fertig[ i ] = 0;
  295. for( int i = 0; i < anz; i++ )
  296. {
  297. int p = -1;
  298. for( int j = 0; j < anz; j++ )
  299. {
  300. if( !fertig[ j ] )
  301. {
  302. p = j;
  303. games->z( j )->setSichtbar( 1 );
  304. }
  305. }
  306. if( p < 0 )
  307. break;
  308. fertig[ p ] = 1;
  309. games->z( p )->setPosition( 10 + 10 * ( i % 3 ) + 250 * ( i % 3 ), 50 + 10 * ( i / 3 ) + 100 * ( i / 3 ) );
  310. }
  311. delete[] fertig;
  312. }
  313. void MiniGames::doMausEreignis( MausEreignis &me )
  314. {
  315. me.mx -= pos.x;
  316. me.my -= pos.y;
  317. if( alpha2 )
  318. {
  319. int anz = games->getEintragAnzahl();
  320. for( int i = 0; i < anz; i++ )
  321. {
  322. bool vera = me.verarbeitet;
  323. games->z( i )->doMausEreignis( me );
  324. if( !vera && me.verarbeitet && me.id == ME_RLinks )
  325. { // spiel starten
  326. if( mgl )
  327. mgl = (MGLaden*)mgl->release();
  328. mgInitialized = 0;
  329. mgl = new MGLaden( games->z( i )->zName()->getText(), dLLs, api );
  330. }
  331. }
  332. }
  333. if( mgl && mgl->zGame() )
  334. mgl->zGame()->doMausEreignis( me );
  335. me.mx += pos.x;
  336. me.my += pos.y;
  337. }
  338. void MiniGames::doTastaturEreignis( TastaturEreignis &te )
  339. {
  340. if( mgl && mgl->zGame() )
  341. mgl->zGame()->doTastaturEreignis( te );
  342. }
  343. bool MiniGames::tick( double z )
  344. {
  345. if( mgl && mgl->fertig() )
  346. {
  347. if( !mgl->zGame() )
  348. {
  349. mgl = (MGLaden*)mgl->release();
  350. mgInitialized = 0;
  351. }
  352. else if( !mgInitialized )
  353. {
  354. mgl->zGame()->setSchriftZ( schrift->getThis() );
  355. mgl->zGame()->setBildschirmZ( screen );
  356. mgInitialized = 1;
  357. }
  358. }
  359. if( mgl && mgl->zGame() && !alpha2 )
  360. {
  361. rend |= mgl->zGame()->tick( z );
  362. if( mgl->zGame()->istEnde() )
  363. {
  364. mgl = (MGLaden *)mgl->release();
  365. mgInitialized = 0;
  366. }
  367. }
  368. if( alpha2 )
  369. {
  370. int anz = games->getEintragAnzahl();
  371. for( int i = 0; i < anz; i++ )
  372. rend |= games->z( i )->tick( z );
  373. }
  374. tickVal += z * 150;
  375. int val = (int)tickVal;
  376. if( val < 1 )
  377. {
  378. bool ret = rend;
  379. rend = 0;
  380. return ret;
  381. }
  382. tickVal -= val;
  383. if( mgl && alpha2 )
  384. {
  385. alpha2 -= val;
  386. if( alpha2 < 0 )
  387. alpha2 = 0;
  388. rend = 1;
  389. }
  390. if( !mgl && alpha2 != 255 )
  391. {
  392. alpha2 += val;
  393. if( alpha2 > 255 )
  394. alpha2 = 255;
  395. rend = 1;
  396. }
  397. bool ret = rend;
  398. rend = 0;
  399. return 1;
  400. }
  401. void MiniGames::render( Bild &zRObj )
  402. {
  403. rahmen->setPosition( pos );
  404. rahmen->setSize( gr );
  405. rahmen->render( zRObj );
  406. if( !zRObj.setDrawOptions( pos.x + 1, pos.y + 1, gr.x - 2, gr.y - 2 ) )
  407. return;
  408. int rbr = rahmen->getRBreite();
  409. zRObj.setAlpha( (unsigned char)alpha2 );
  410. int anz = games->getEintragAnzahl();
  411. for( int i = 0; i < anz; i++ )
  412. games->z( i )->render( zRObj );
  413. zRObj.releaseAlpha();
  414. zRObj.releaseDrawOptions();
  415. if( mgl && mgl->fertig() && mgl->zGame() )
  416. mgl->zGame()->render( zRObj );
  417. }