Objekt.cpp 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398
  1. #include "Objekt.h"
  2. #include "MausEreignis.h"
  3. #include "TastaturEreignis.h"
  4. #include "Punkt.h"
  5. #include <Windows.h>
  6. using namespace Framework;
  7. // Inhalt der Objekt Klasse aus Objekt.h
  8. // Konstruktor
  9. Objekt::Objekt()
  10. {
  11. Mak = 0;
  12. Tak = 0;
  13. pos = new Punkt( 0, 0 );
  14. gr = new Punkt( 0, 0 );
  15. InitializeCriticalSection( &Thread_Save );
  16. mausIn = 0;
  17. }
  18. // Destruktor
  19. Objekt::~Objekt()
  20. {
  21. pos->release();
  22. gr->release();
  23. DeleteCriticalSection( &Thread_Save );
  24. }
  25. // nicht constant
  26. void Objekt::lockObjekt()
  27. {
  28. EnterCriticalSection( &Thread_Save );
  29. }
  30. void Objekt::unlockObjekt()
  31. {
  32. LeaveCriticalSection( &Thread_Save );
  33. }
  34. void Objekt::setMausEreignis( bool (*ak)( void *, MausEreignis ) ) // setzt das Maus Ereignis
  35. {
  36. lockObjekt();
  37. Mak = ak;
  38. unlockObjekt();
  39. }
  40. void Objekt::setTastaturEreignis( bool (*ak)( void *, TastaturEreignis ) ) // setzt das TastaturEreignis
  41. {
  42. lockObjekt();
  43. Tak = ak;
  44. unlockObjekt();
  45. }
  46. void Objekt::doMausEreignis( MausEreignis *me ) // ruft Mak auf
  47. {
  48. if( me->verarbeitet || ( !( me->mx >= pos->x && me->mx <= pos->x + gr->x && me->my >= pos->y && me->my <= pos->y + gr->y ) && me->id != ME_Verlässt ) )
  49. {
  50. if( mausIn )
  51. {
  52. mausIn = 0;
  53. MausEreignis me2;
  54. me2.id = ME_Verlässt;
  55. me2.mx = me->mx;
  56. me2.my = me->my;
  57. me2.verarbeitet = 0;
  58. doMausEreignis( &me2 );
  59. }
  60. return;
  61. }
  62. if( !mausIn && me->id != ME_Verlässt )
  63. {
  64. mausIn = 1;
  65. MausEreignis me2;
  66. me2.id = ME_Betritt;
  67. me2.mx = me->mx;
  68. me2.my = me->my;
  69. me2.verarbeitet = 0;
  70. doMausEreignis( &me2 );
  71. }
  72. if( Mak != 0 )
  73. {
  74. me->verarbeitet |= Mak( this, *me );
  75. return;
  76. }
  77. }
  78. void Objekt::doTastaturEreignis( TastaturEreignis *te ) // ruft Tak auf
  79. {
  80. if( te->verarbeitet )
  81. return;
  82. if( Tak != 0 )
  83. {
  84. unlockObjekt();
  85. te->verarbeitet |= Tak( this, *te );
  86. }
  87. }
  88. void Objekt::setPosition( Punkt *pos ) // setzt die position
  89. {
  90. lockObjekt();
  91. this->pos->setP( pos->getX(), pos->getY() );
  92. pos->release();
  93. unlockObjekt();
  94. }
  95. void Objekt::setPositionZ( Punkt *pos )
  96. {
  97. lockObjekt();
  98. if( this->pos )
  99. this->pos->release();
  100. this->pos = pos;
  101. unlockObjekt();
  102. }
  103. void Objekt::setGröße( Punkt *gr ) // setzt die Größe
  104. {
  105. lockObjekt();
  106. this->gr->setP( gr->getX(), gr->getY() );
  107. gr->release();
  108. unlockObjekt();
  109. }
  110. void Objekt::setGrößeZ( Punkt *gr )
  111. {
  112. lockObjekt();
  113. if( this->gr )
  114. this->gr->release();
  115. this->gr = gr;
  116. unlockObjekt();
  117. }
  118. void Objekt::setPosition( int x, int y ) // setzt die position
  119. {
  120. lockObjekt();
  121. this->pos->setP( x, y );
  122. unlockObjekt();
  123. }
  124. void Objekt::setGröße( int x, int y ) // setzt die Größe
  125. {
  126. lockObjekt();
  127. this->gr->setP( x, y );
  128. unlockObjekt();
  129. }
  130. void Objekt::tick( double tickval )
  131. {
  132. }
  133. void Objekt::render( Bild *rObj )
  134. {
  135. }
  136. void Objekt::render( int xOff, int yOff, int bOff, int hOff, Bild *rObj )
  137. {
  138. }
  139. // constant
  140. bool Objekt::hatMausEreignis() const // prüft, ob Mak gesetzt ist
  141. {
  142. return Mak != 0;
  143. }
  144. bool Objekt::hatTastaturEreignis() const // prüft, ob Tak gesetzt ist
  145. {
  146. return Tak != 0;
  147. }
  148. Punkt *Objekt::getPosition() const // gibt die Position zurück
  149. {
  150. return pos->getThis();
  151. }
  152. Punkt *Objekt::getGröße() const // gibt die Größe zurück
  153. {
  154. return gr->getThis();
  155. }
  156. int Objekt::getBreite() const // gibt die Breite zurück
  157. {
  158. return gr->getX();
  159. }
  160. int Objekt::getHöhe() const // gibt die Höhe zurück
  161. {
  162. return gr->getY();
  163. }
  164. int Objekt::getX() const // gibt X zurück
  165. {
  166. return pos->getX();
  167. }
  168. int Objekt::getY() const // gibt Y zurück
  169. {
  170. return pos->getY();
  171. }
  172. // Inhalt der ObjektArray Klasse aus Objekt.h
  173. // Konstruktor
  174. ObjektArray::ObjektArray()
  175. {
  176. next = 0;
  177. This = 0;
  178. }
  179. // Destruktor
  180. ObjektArray::~ObjektArray()
  181. {
  182. if( next )
  183. delete next;
  184. }
  185. // nicht const
  186. bool ObjektArray::addObjekt( Objekt *obj ) // Fügt ein Objekt hinzu
  187. {
  188. if( obj == This )
  189. return 0;
  190. if( !This )
  191. {
  192. This = obj;
  193. return 1;
  194. }
  195. if( !next )
  196. next = new ObjektArray();
  197. return next->addObjekt( obj );
  198. }
  199. bool ObjektArray::removeObjekt( Objekt *obj ) // Entfernt ein Objekt
  200. {
  201. if( obj == This )
  202. {
  203. if( index == 0 )
  204. {
  205. if( next )
  206. {
  207. This = next->getObjekt();
  208. ObjektArray *tmp = next->getNext();
  209. next->setNext0();
  210. delete next;
  211. next = tmp;
  212. }
  213. else
  214. This = 0;
  215. return 0;
  216. }
  217. return 1;
  218. }
  219. if( !next )
  220. return 0;
  221. if( next->removeObjekt( obj ) )
  222. {
  223. ObjektArray *tmp = next->getNext();
  224. next->setNext0();
  225. delete next;
  226. next = tmp;
  227. }
  228. return 0;
  229. }
  230. bool ObjektArray::removeObjekt( int i ) // Entfernt das von diesem aus i-te Objekt
  231. {
  232. if( i == index )
  233. {
  234. if( index == 0 )
  235. {
  236. This = next->getObjekt();
  237. ObjektArray *tmp = next->getNext();
  238. next->setNext0();
  239. delete next;
  240. next = tmp;
  241. return 0;
  242. }
  243. return 1;
  244. }
  245. if( !next )
  246. return 0;
  247. if( next->removeObjekt( i ) )
  248. {
  249. ObjektArray *tmp = next->getNext();
  250. next->setNext0();
  251. delete next;
  252. next = tmp;
  253. }
  254. return 0;
  255. }
  256. void ObjektArray::setNext0() // Setzt das nächste Objekt zu 0
  257. {
  258. next = 0;
  259. }
  260. void ObjektArray::updateIndex( int i ) // aktualisiert die Index variable
  261. {
  262. index = i;
  263. if( next )
  264. next->updateIndex( i + 1 );
  265. }
  266. // constant
  267. ObjektArray *ObjektArray::getNext() const // gibt das nächste Objekt zurück
  268. {
  269. return next;
  270. }
  271. Objekt *ObjektArray::getObjekt( int i ) const // gibt das von diesem aus i-te Objekt zurück
  272. {
  273. if( i == index )
  274. return This;
  275. if( !next )
  276. return 0;
  277. return next->getObjekt( i );
  278. }
  279. Objekt *ObjektArray::getObjekt() const // gibt das von diesem aus i-te Objekt zurück
  280. {
  281. return This;
  282. }
  283. int ObjektArray::getIndex() const // Gibt den Index zurück
  284. {
  285. return index;
  286. }
  287. void ObjektArray::sendMausAll( MausEreignis *me ) const // sendet me an alle volgenden Objekte
  288. {
  289. if( next )
  290. next->sendMausAll( me );
  291. if( This )
  292. This->doMausEreignis( me );
  293. }
  294. void ObjektArray::sendTastaturAll( TastaturEreignis *te ) const // sendet te an alle volgenden Objekte
  295. {
  296. if( next )
  297. next->sendTastaturAll( te );
  298. if( This )
  299. This->doTastaturEreignis( te );
  300. }
  301. void ObjektArray::sendMaus( MausEreignis *me ) const // sendet me an dieses Objekt
  302. {
  303. This->doMausEreignis( me );
  304. }
  305. void ObjektArray::sendTastatur( TastaturEreignis *te ) const // sendet te an dieses Objekt
  306. {
  307. This->doTastaturEreignis( te );
  308. }
  309. void ObjektArray::sendMaus( int i, MausEreignis *me ) const // sendet me an das von diesem aus i-te Objekt
  310. {
  311. if( index == 1 )
  312. {
  313. This->doMausEreignis( me );
  314. return;
  315. }
  316. if( next )
  317. next->sendMaus( i, me );
  318. }
  319. void ObjektArray::sendTastatur( int i, TastaturEreignis *te ) const // sendet te an das von diesem aus i-te Objekt
  320. {
  321. if( index == 1 )
  322. {
  323. This->doTastaturEreignis( te );
  324. return;
  325. }
  326. if( next )
  327. next->sendTastatur( i, te );
  328. }
  329. void ObjektArray::render( Bild *rObj )
  330. {
  331. if( This )
  332. This->render( rObj );
  333. if( next )
  334. next->render( rObj );
  335. }
  336. void ObjektArray::render( int xOff, int yOff, int bOff, int hOff, Bild *rObj )
  337. {
  338. if( This )
  339. This->render( xOff, yOff, bOff, hOff, rObj );
  340. if( next )
  341. next->render( xOff, yOff, bOff, hOff, rObj );
  342. }
  343. void ObjektArray::tick( double tickval )
  344. {
  345. if( This )
  346. This->tick( tickval );
  347. if( next )
  348. next->tick( tickval );
  349. }