KSGScriptObj.cpp 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492
  1. #include "KSGScriptObj.h"
  2. #include "../Befehl/KSGSKlasse.h"
  3. #include "../Leser/KSGSLeser.h"
  4. #include <fstream>
  5. #include <iostream>
  6. #include <sstream>
  7. #include <Punkt.h>
  8. #include "../Klassen/KSGSMausEreignis.h"
  9. #include "../Klassen/KSGSTastaturEreignis.h"
  10. #include "../Klassen/KSGSInt.h"
  11. #include "../Klassen/KSGSBild.h"
  12. #include "../Klassen/KSGSDouble.h"
  13. #include "../Error/Error.h"
  14. #include <Bildschirm.h>
  15. #include <Zeit.h>
  16. using namespace KSGScript;
  17. // Inhalt der KSGScript Klasse aus KSGScript.h
  18. // Konstruktor
  19. KSGScriptO::KSGScriptO()
  20. {
  21. pfad = new Text();
  22. wd = new Text();
  23. rParam = 0;
  24. rFunktion = 0;
  25. variablen = new RCArray< KSGSVariable >();
  26. funktionen = new RCArray< KSGSFunktion >();
  27. klassen = new RCArray< KSGSKlasse >();
  28. schrift = 0;
  29. screen = 0;
  30. mainId = 0;
  31. mausId = 0;
  32. tastaturId = 0;
  33. tickId = 0;
  34. renderId = 0;
  35. geladen = 0;
  36. scrId = 0;
  37. mausP = new RCArray< KSGSVariable >();
  38. tastaturP = new RCArray< KSGSVariable >();
  39. tickP = new RCArray< KSGSVariable >();
  40. renderP = new RCArray< KSGSVariable >();
  41. log = 0;
  42. }
  43. // Destruktor
  44. KSGScriptO::~KSGScriptO()
  45. {
  46. if( schrift )
  47. schrift->release();
  48. if( screen )
  49. screen->release();
  50. zurücksetzen();
  51. mausP->release();
  52. tastaturP->release();
  53. tickP->release();
  54. renderP->release();
  55. pfad->release();
  56. wd->release();
  57. variablen->release();
  58. funktionen->release();
  59. klassen->release();
  60. if( log )
  61. log->release();
  62. }
  63. // nicht constant
  64. void KSGScriptO::lock()
  65. {
  66. cs.lock();
  67. }
  68. void KSGScriptO::unlock()
  69. {
  70. cs.unlock();
  71. }
  72. void KSGScriptO::setScriptDatei( const char *pfad )
  73. {
  74. this->pfad->setText( pfad );
  75. this->pfad->ersetzen( '\\', '/' );
  76. int l = this->pfad->hat( '/' ) ? this->pfad->positionVon( '/', this->pfad->anzahlVon( '/' ) - 1 ) + 1 : 0;
  77. if( l )
  78. wd->setText( pfad, l );
  79. }
  80. void KSGScriptO::setScriptDatei( Text * pfad )
  81. {
  82. setScriptDatei( pfad->getText() );
  83. pfad->release();
  84. }
  85. bool KSGScriptO::neuLaden()
  86. {
  87. lock();
  88. ZeitMesser *gzm = new ZeitMesser();
  89. gzm->messungStart();
  90. if( geladen )
  91. zurücksetzen();
  92. scrId++;
  93. KSGSLeser * reader = new KSGSLeser( *pfad, this );
  94. ZeitMesser * zm = new ZeitMesser();
  95. zm->messungStart();
  96. if( !reader->laden() )
  97. {
  98. reader->release();
  99. zm->release();
  100. gzm->release();
  101. unlock();
  102. return 0;
  103. }
  104. zm->messungEnde();
  105. if( log )
  106. {
  107. Text msg = "Reader: Zum lesen benötigte Sekunden: ";
  108. msg += zm->getSekunden();
  109. logNachricht( msg );
  110. }
  111. std::cout << "KSGS Reader: Zum lesen benötigte Sekunden: " << zm->getSekunden() << "\n";
  112. Array< KSGSVariableDef * > *varDefs = new Array< KSGSVariableDef * >();
  113. zm->messungStart();
  114. if( !reader->compile( klassen, funktionen, varDefs ) )
  115. {
  116. varDefs->release();
  117. reader->release();
  118. zm->release();
  119. gzm->release();
  120. unlock();
  121. return 0;
  122. }
  123. mausP->add( new KSGSMausEreignisKlasse( this ) );
  124. tastaturP->add( new KSGSTastaturEreignisKlasse( this ) );
  125. tickP->add( new KSGSDoubleKlasse( this ) );
  126. renderP->add( new KSGSBildKlasse( this ) );
  127. zm->messungEnde();
  128. if( log )
  129. {
  130. Text msg = "Reader: Zum compilieren benötigte Sekunden: ";
  131. msg += zm->getSekunden();
  132. logNachricht( msg );
  133. }
  134. std::cout << "KSGS Reader: Zum compilieren benötigte Sekunden: " << zm->getSekunden() << "\n";
  135. zm->release();
  136. int vAnz = varDefs->getEintragAnzahl();
  137. for( int i = 0; i < vAnz; i++ )
  138. {
  139. KSGSVariable *var = KSGSKlasseInstanz::erstellVariable( this, varDefs->get( i ) );
  140. if( var )
  141. variablen->add( var );
  142. delete varDefs->get( i );
  143. }
  144. varDefs->release();
  145. mainId = reader->getMainFuncId();
  146. mausId = reader->getMausFuncId();
  147. tastaturId = reader->getTastaturFuncId();
  148. tickId = reader->getTickFuncId();
  149. renderId = reader->getRenderFuncId();
  150. reader->release();
  151. int anz = funktionen->getEintragAnzahl();
  152. geladen = 1;
  153. for( int i = 0; i < anz; i++ )
  154. {
  155. if( funktionen->z( i )->getId() == mainId )
  156. {
  157. KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptO *>( getThis() ), 0, 0 );
  158. KSGSVariable *ret = inst->startFunktion();
  159. if( ret )
  160. ret->release();
  161. if( inst->wirdFunktionAusgeführt() )
  162. inst->warteAufFunktion( INFINITE );
  163. inst->release();
  164. break;
  165. }
  166. }
  167. geladen = 2;
  168. gzm->messungEnde();
  169. if( log )
  170. {
  171. Text msg = "Reader: Zum laden benötigte Sekunden: ";
  172. msg += gzm->getSekunden();
  173. logNachricht( msg );
  174. }
  175. std::cout << "KSGS Reader: Zum laden benötigte Sekunden: " << gzm->getSekunden() << "\n";
  176. gzm->release();
  177. unlock();
  178. return 1;
  179. }
  180. void KSGScriptO::zurücksetzen()
  181. {
  182. lock();
  183. geladen = 0;
  184. variablen->leeren();
  185. funktionen->leeren();
  186. klassen->leeren();
  187. mausP->leeren();
  188. tastaturP->leeren();
  189. tickP->leeren();
  190. renderP->leeren();
  191. unlock();
  192. }
  193. void KSGScriptO::setRückrufParam( void *p )
  194. {
  195. rParam = p;
  196. }
  197. void KSGScriptO::setRückrufFunktion( void( *funktion )( void *, RCArray< KSGSVariable > *, KSGSVariable * * ) )
  198. {
  199. rFunktion = funktion;
  200. }
  201. void KSGScriptO::setSchriftZ( Schrift * s )
  202. {
  203. if( schrift )
  204. schrift->release();
  205. schrift = s;
  206. }
  207. void KSGScriptO::setBildschirmZ( Bildschirm * s )
  208. {
  209. if( screen )
  210. screen->release();
  211. screen = s;
  212. }
  213. void KSGScriptO::doMausEreignis( MausEreignis & me )
  214. {
  215. if( geladen != 2 )
  216. return;
  217. lock();
  218. me.mx -= pos.x;
  219. me.my -= pos.y;
  220. int anz = funktionen->getEintragAnzahl();
  221. for( int i = 0; i < anz; i++ )
  222. {
  223. if( funktionen->z( i )->getId() == mausId )
  224. {
  225. ( (KSGSMausEreignisKlasse *)mausP->z( 0 ) )->set( me );
  226. KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptO *>( getThis() ), 0, mausP->getThis() );
  227. KSGSVariable *ret = inst->startFunktion();
  228. if( ret )
  229. {
  230. me.verarbeitet |= ret->getBool();
  231. ret->release();
  232. }
  233. if( inst->wirdFunktionAusgeführt() )
  234. inst->warteAufFunktion( INFINITE );
  235. inst->release();
  236. break;
  237. }
  238. }
  239. me.mx += pos.x;
  240. me.my += pos.y;
  241. unlock();
  242. }
  243. void KSGScriptO::doTastaturEreignis( TastaturEreignis & te )
  244. {
  245. if( geladen != 2 )
  246. return;
  247. lock();
  248. int anz = funktionen->getEintragAnzahl();
  249. for( int i = 0; i < anz; i++ )
  250. {
  251. if( funktionen->z( i )->getId() == tastaturId )
  252. {
  253. ( (KSGSTastaturEreignisKlasse *)tastaturP->z( 0 ) )->set( te );
  254. KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptO *>( getThis() ), 0, tastaturP->getThis() );
  255. KSGSVariable *ret = inst->startFunktion();
  256. if( ret )
  257. {
  258. te.verarbeitet |= ret->getBool();
  259. ret->release();
  260. }
  261. if( inst->wirdFunktionAusgeführt() )
  262. inst->warteAufFunktion( INFINITE );
  263. inst->release();
  264. break;
  265. }
  266. }
  267. unlock();
  268. }
  269. bool KSGScriptO::tick( double zeit )
  270. {
  271. if( geladen != 2 )
  272. return 0;
  273. lock();
  274. int anz = funktionen->getEintragAnzahl();
  275. for( int i = 0; i < anz; i++ )
  276. {
  277. if( funktionen->z( i )->getId() == tickId )
  278. {
  279. ( (KSGSDoubleKlasse *)tickP->z( 0 ) )->set( zeit );
  280. KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptO *>( getThis() ), 0, tickP->getThis() );
  281. KSGSVariable *ret = inst->startFunktion();
  282. bool r = 0;
  283. if( ret )
  284. {
  285. r = ret->getBool();
  286. ret->release();
  287. }
  288. if( inst->wirdFunktionAusgeführt() )
  289. inst->warteAufFunktion( INFINITE );
  290. inst->release();
  291. unlock();
  292. return r;
  293. }
  294. }
  295. unlock();
  296. return 0;
  297. }
  298. void KSGScriptO::render( Bild & zRObj )
  299. {
  300. if( geladen != 2 )
  301. return;
  302. lock();
  303. if( !zRObj.setDrawOptions( pos, gr ) )
  304. {
  305. unlock();
  306. return;
  307. }
  308. int anz = funktionen->getEintragAnzahl();
  309. for( int i = 0; i < anz; i++ )
  310. {
  311. if( funktionen->z( i )->getId() == renderId )
  312. {
  313. ( (KSGSBildKlasse *)renderP->z( 0 ) )->set( zRObj.getThis() );
  314. KSGSFunktionInstanz *inst = funktionen->z( i )->erstellInstanz( dynamic_cast<KSGScriptO *>( getThis() ), 0, renderP->getThis() );
  315. KSGSVariable *ret = inst->startFunktion();
  316. if( ret )
  317. ret->release();
  318. if( inst->wirdFunktionAusgeführt() )
  319. inst->warteAufFunktion( INFINITE );
  320. inst->release();
  321. break;
  322. }
  323. }
  324. zRObj.releaseDrawOptions();
  325. unlock();
  326. }
  327. KSGSVariable *KSGScriptO::startFunktion( int id, RCArray< KSGSVariable > * parameter )
  328. {
  329. if( !funktionen || !funktionen->z( id ) || funktionen->z( id )->getSichtbarkeit() != 0 )
  330. {
  331. error( 19, {}, this );
  332. parameter->release();
  333. return 0;
  334. }
  335. KSGSFunktionInstanz *inst = funktionen->z( id )->erstellInstanz( dynamic_cast<KSGScriptO *>( getThis() ), 0, parameter );
  336. KSGSVariable *ret = inst->startFunktion();
  337. inst->release();
  338. return ret;
  339. }
  340. KSGSVariable *KSGScriptO::erstellKlassenInstanz( int id )
  341. {
  342. int anz = klassen->getEintragAnzahl();
  343. for( int i = 0; i < anz; i++ )
  344. {
  345. if( klassen->z( i ) && klassen->z( i )->getId() == id )
  346. return klassen->z( i )->erstellInstanz( this );
  347. }
  348. error( 2, {}, this );
  349. return 0;
  350. }
  351. void KSGScriptO::setVariable( int id, KSGSVariable * var )
  352. {
  353. variablen->set( var, id );
  354. }
  355. Text *KSGScriptO::convertPfad( char *pf )
  356. {
  357. Text *ret = new Text( pf );
  358. ret->ersetzen( '\\', '/' );
  359. if( ret->getText()[ 0 ] == '/' )
  360. {
  361. ret->remove( 0 );
  362. return ret;
  363. }
  364. ret->insert( 0, wd->getText() );
  365. return ret;
  366. }
  367. void KSGScriptO::setLog( TextFeld * log )
  368. {
  369. lock();
  370. if( this->log )
  371. this->log->release();
  372. this->log = log;
  373. unlock();
  374. }
  375. void KSGScriptO::logNachricht( char *n )
  376. {
  377. if( log )
  378. {
  379. lock();
  380. log->addZeile( n );
  381. unlock();
  382. }
  383. }
  384. // constant
  385. KSGSVariable *KSGScriptO::rückruf( RCArray< KSGSVariable > * parameter ) const
  386. {
  387. if( !rFunktion )
  388. {
  389. parameter->release();
  390. return 0;
  391. }
  392. KSGSVariable *ret = 0;
  393. rFunktion( rParam, parameter, &ret );
  394. parameter->release();
  395. return ret;
  396. }
  397. Text *KSGScriptO::getScriptDateiPfad() const
  398. {
  399. return pfad->getThis();
  400. }
  401. Text *KSGScriptO::zScriptDateiPfad() const
  402. {
  403. return pfad;
  404. }
  405. Schrift *KSGScriptO::getSchrift() const
  406. {
  407. return schrift ? schrift->getThis() : 0;
  408. }
  409. Schrift *KSGScriptO::zSchrift() const
  410. {
  411. return schrift;
  412. }
  413. Bildschirm *KSGScriptO::getBildschirm() const
  414. {
  415. return screen ? screen->getThis() : 0;
  416. }
  417. Bildschirm *KSGScriptO::zBildschirm() const
  418. {
  419. return screen;
  420. }
  421. int KSGScriptO::getScriptId() const
  422. {
  423. return scrId;
  424. }
  425. bool KSGScriptO::istBeendet( int scrId ) const
  426. {
  427. return !geladen || this->scrId != scrId;
  428. }
  429. int KSGScriptO::getFunktionId( const char *name ) const
  430. {
  431. int anz = funktionen->getEintragAnzahl();
  432. for( int i = 0; i < anz; i++ )
  433. {
  434. if( funktionen->z( i )->hatName( name ) )
  435. return i;
  436. }
  437. return -1;
  438. }
  439. KSGSVariable *KSGScriptO::getVariable( int id ) const
  440. {
  441. if( !variablen || !variablen->z( id ) )
  442. {
  443. error( 17, {}, (KSGScriptO *)this );
  444. return 0;
  445. }
  446. return variablen->get( id );
  447. }
  448. // Reference Counting
  449. Zeichnung *KSGScriptO::getThis()
  450. {
  451. return Zeichnung::getThis();
  452. }
  453. Zeichnung *KSGScriptO::release()
  454. {
  455. return Zeichnung::release();
  456. }