Trigger.cpp 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291
  1. #include "Trigger.h"
  2. #include "Gegenstand.h"
  3. VarPointer::VarPointer( const char* name, Variable* var )
  4. : ReferenceCounter()
  5. {
  6. this->name = name;
  7. this->var = var;
  8. }
  9. VarPointer::~VarPointer()
  10. {
  11. if( var )
  12. var->release();
  13. }
  14. Text VarPointer::getName() const
  15. {
  16. return name;
  17. }
  18. void VarPointer::setVariable( Variable* var )
  19. {
  20. if( this->var )
  21. this->var->release();
  22. this->var = var;
  23. }
  24. Variable* VarPointer::getVariable() const
  25. {
  26. return var ? dynamic_cast<Variable*>(var->getThis()) : 0;
  27. }
  28. Variable* VarPointer::zVariable() const
  29. {
  30. return var;
  31. }
  32. VarPointer::operator Variable* () const
  33. {
  34. return var;
  35. }
  36. LocalMemory::LocalMemory()
  37. : ReferenceCounter()
  38. {}
  39. LocalMemory::~LocalMemory()
  40. {}
  41. void LocalMemory::setVar( const char* name, Variable* var )
  42. {
  43. for( auto v : vars )
  44. {
  45. if( v->getName().istGleich( name ) )
  46. {
  47. v->setVariable( var );
  48. return;
  49. }
  50. }
  51. vars.add( new VarPointer( name, var ) );
  52. }
  53. Variable* LocalMemory::getVariable( const char* name )
  54. {
  55. for( auto v : vars )
  56. {
  57. if( v->getName().istGleich( name ) )
  58. return v->getVariable();
  59. }
  60. return 0;
  61. }
  62. Variable* LocalMemory::zVariable( const char* name )
  63. {
  64. for( auto v : vars )
  65. {
  66. if( v->getName().istGleich( name ) )
  67. return v->zVariable();
  68. }
  69. return 0;
  70. }
  71. ProgramCounter::ProgramCounter()
  72. : ReferenceCounter()
  73. {
  74. current.add( 0 );
  75. depth = 0;
  76. }
  77. ProgramCounter::~ProgramCounter()
  78. {}
  79. void ProgramCounter::stepIn()
  80. {
  81. depth++;
  82. if( current.getEintragAnzahl() <= depth )
  83. current.add( 0 );
  84. }
  85. void ProgramCounter::count()
  86. {
  87. current.set( current.get( depth ) + 1, depth );
  88. while( depth + 1 < current.getEintragAnzahl() )
  89. current.remove( depth + 1 );
  90. }
  91. void ProgramCounter::stepOut()
  92. {
  93. depth--;
  94. }
  95. Text ProgramCounter::getUniqueString() const
  96. {
  97. Text ret = "__";
  98. for( int i = 0; i < depth; i++ )
  99. ret += Text( current.get( i ) ) + "__";
  100. return ret;
  101. }
  102. int ProgramCounter::currentPosition() const
  103. {
  104. return current.get( depth );
  105. }
  106. Bedingung::Bedingung( Aktion* expression )
  107. : ReferenceCounter()
  108. {
  109. this->expression = expression;
  110. }
  111. Bedingung::~Bedingung()
  112. {
  113. if( expression )
  114. expression->release();
  115. }
  116. void Bedingung::setExpression( Aktion* expr )
  117. {
  118. if( expression )
  119. expression->release();
  120. expression = expr;
  121. }
  122. bool Bedingung::check( Spiel* zSpiel, Ereignis* zEreignis )
  123. {
  124. if( !expression )
  125. return 1;
  126. double wait = 0;
  127. ProgramCounter c;
  128. LocalMemory m;
  129. while( !expression->runNext( zSpiel, zEreignis, &m, &c, wait ) )
  130. wait = 0;
  131. Variable* var = m.zVariable( "__return__" );
  132. return isTrue( var );
  133. }
  134. Trigger::Trigger( int id, const char* name, int ereignisAnzahl, EreignisTyp* ereignisse, RCArray< Bedingung >* bedingungen, RCArray< Aktion >* aktionen )
  135. : Variable( TRIGGER )
  136. {
  137. this->id = id;
  138. this->name = name;
  139. this->ereignisAnzahl = ereignisAnzahl;
  140. this->ereignisse = ereignisse;
  141. this->bedingungen = bedingungen;
  142. this->aktionen = aktionen;
  143. aktiv = 1;
  144. runCount = 0;
  145. }
  146. Trigger::~Trigger()
  147. {
  148. delete[]ereignisse;
  149. bedingungen->release();
  150. aktionen->release();
  151. }
  152. void Trigger::setAktiv( bool aktiv )
  153. {
  154. this->aktiv = aktiv;
  155. }
  156. bool Trigger::hatEreignis( EreignisTyp typ ) const
  157. {
  158. for( int i = 0; i < ereignisAnzahl; i++ )
  159. {
  160. if( ereignisse[ i ] == typ )
  161. return 1;
  162. }
  163. return 0;
  164. }
  165. int Trigger::getAktionAnzahl() const
  166. {
  167. return aktionen->getEintragAnzahl();
  168. }
  169. Aktion* Trigger::zAktion( int index ) const
  170. {
  171. return aktionen->z( index );
  172. }
  173. Aktion* Trigger::getAktion( int index ) const
  174. {
  175. return aktionen->get( index );
  176. }
  177. // return: 0, falls die bedingungen nicht erfüllt sind
  178. TriggerRun* Trigger::runTrigger( Ereignis* e, Spiel* zSpiel )
  179. {
  180. if( !aktiv )
  181. {
  182. e->release();
  183. return 0;
  184. }
  185. for( auto b : *bedingungen )
  186. {
  187. if( !b->check( zSpiel, e ) )
  188. {
  189. e->release();
  190. return 0;
  191. }
  192. }
  193. runCount++;
  194. return new TriggerRun( dynamic_cast<Trigger*>(getThis()), e, zSpiel );
  195. }
  196. int Trigger::getId() const
  197. {
  198. return id;
  199. }
  200. int Trigger::getRuns() const
  201. {
  202. return runCount;
  203. }
  204. const char* Trigger::getName() const
  205. {
  206. return name.getText();
  207. }
  208. bool Trigger::istAktiv() const
  209. {
  210. return aktiv;
  211. }
  212. TriggerRun::TriggerRun( Trigger* trig, Ereignis* e, Spiel* zSpiel )
  213. : ReferenceCounter()
  214. {
  215. trigger = trig;
  216. ereignis = e;
  217. this->zSpiel = zSpiel;
  218. waitCount = 0;
  219. }
  220. TriggerRun::~TriggerRun()
  221. {
  222. trigger->release();
  223. ereignis->release();
  224. }
  225. // gibt 0 zurück, wenn der Auslöser vollständig durchgelaufen ist
  226. bool TriggerRun::runNext( double t )
  227. {
  228. if( waitCount > 0 )
  229. waitCount -= t;
  230. else
  231. {
  232. int current = counter.currentPosition();
  233. if( current >= trigger->getAktionAnzahl() )
  234. return 0;
  235. Aktion* ak = trigger->zAktion( current );
  236. if( !ak || ak->runNext( zSpiel, ereignis, &localMem, &counter, waitCount ) )
  237. counter.count();
  238. if( counter.currentPosition() >= trigger->getAktionAnzahl() )
  239. return 0;
  240. }
  241. return 1;
  242. }
  243. Trigger* TriggerRun::getTrigger() const
  244. {
  245. return dynamic_cast<Trigger*>(trigger->getThis());
  246. }