Spieler.cpp 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453
  1. #include "Spieler.h"
  2. #include <math.h>
  3. #ifdef WIN32
  4. #include <random>
  5. #else
  6. #include <stdlib.h>
  7. #endif
  8. // Inhalt der Spieler Klasse aus Spieler.h
  9. // Konstruktor
  10. Spieler::Spieler()
  11. {
  12. accountId = 0;
  13. sNum = 0;
  14. team = 0;
  15. spielerFarbe = 0;
  16. teamFarbe = 0;
  17. xPos = 0;
  18. yPos = 0;
  19. xSpeed = 0;
  20. ySpeed = 0;
  21. kurve = 0;
  22. radius = 1;
  23. amLeben = 1;
  24. lKurve = 0;
  25. rKurve = 0;
  26. klient = 0;
  27. spielZeit = 0;
  28. todesZeit = -1;
  29. linieUnterbrochen = 1;
  30. nLUChange = 3;
  31. lUStrength = 0.3;
  32. punkte = 0;
  33. rundenGewonnen = 0;
  34. linienLength = 0;
  35. zeitAmLeben = 0;
  36. zeitTod = 0;
  37. kills = 0;
  38. tode = 0;
  39. killFarbe = 0;
  40. rundenLinienLength = new Array< int >();
  41. rundenLinienLength->set( 0, 0 );
  42. rundenKills = new Array< int >();
  43. rundenKills->set( 0, 0 );
  44. rundenTodesZeit = new Array< int >();
  45. rundenTodesZeit->set( 0, 0 );
  46. rundenNummer = 0;
  47. ref = 1;
  48. }
  49. // Destruktor
  50. Spieler::~Spieler()
  51. {
  52. if( klient )
  53. klient->release();
  54. rundenLinienLength->release();
  55. rundenKills->release();
  56. rundenTodesZeit->release();
  57. }
  58. // nicht constant
  59. void Spieler::offline()
  60. {
  61. klient->offline();
  62. }
  63. void Spieler::online( SSKlientV *zKlient )
  64. {
  65. klient->online( zKlient );
  66. }
  67. void Spieler::neuRunde( bool amLeben )
  68. {
  69. if( this->amLeben )
  70. rundenGewonnen++;
  71. killFarbe = 0;
  72. xPos = 0;
  73. yPos = 0;
  74. xSpeed = 0;
  75. ySpeed = 0;
  76. kurve = 0;
  77. radius = 1;
  78. this->amLeben = amLeben;
  79. lKurve = 0;
  80. rKurve = 0;
  81. spielZeit = 0;
  82. todesZeit = -1;
  83. linieUnterbrochen = 1;
  84. nLUChange = 3;
  85. lUStrength = 0.3;
  86. rundenNummer++;
  87. rundenLinienLength->set( 0, rundenNummer );
  88. rundenKills->set( 0, rundenNummer );
  89. rundenTodesZeit->set( 0, rundenNummer );
  90. }
  91. void Spieler::setAccountId( int id )
  92. {
  93. accountId = id;
  94. }
  95. void Spieler::setSpielerNummer( int sNum )
  96. {
  97. this->sNum = sNum;
  98. }
  99. void Spieler::setTeam( int team )
  100. {
  101. this->team = team;
  102. }
  103. void Spieler::setSpielerFarbe( int farbe )
  104. {
  105. spielerFarbe = farbe;
  106. }
  107. void Spieler::setTeamFarbe( int farbe )
  108. {
  109. teamFarbe = farbe;
  110. }
  111. void Spieler::setGeschwindigkeit( double xSpeed, double ySpeed )
  112. {
  113. this->xSpeed = xSpeed;
  114. this->ySpeed = ySpeed;
  115. }
  116. void Spieler::setPosition( double x, double y )
  117. {
  118. xPos = x;
  119. yPos = y;
  120. }
  121. void Spieler::setWendigkeit( double kurve )
  122. {
  123. this->kurve = kurve;
  124. }
  125. void Spieler::setSize( int radius )
  126. {
  127. this->radius = radius;
  128. }
  129. void Spieler::setKlient( Klient *klient )
  130. {
  131. if( this->klient )
  132. this->klient->release();
  133. this->klient = klient;
  134. }
  135. void Spieler::setLKurve( bool lK )
  136. {
  137. lKurve = lK;
  138. }
  139. void Spieler::setRKurve( bool rK )
  140. {
  141. rKurve = rK;
  142. }
  143. void Spieler::setLinienUnterbrechungsStrength( double uS )
  144. {
  145. lUStrength = uS;
  146. }
  147. void Spieler::addPunkte( int p )
  148. {
  149. punkte += p;
  150. }
  151. void Spieler::addKill()
  152. {
  153. kills++;
  154. if( rundenKills->hat( rundenNummer ) )
  155. rundenKills->set( rundenKills->get( rundenNummer ) + 1, rundenNummer );
  156. }
  157. void Spieler::tick( Bild *zMap, double zeit )
  158. {
  159. spielZeit += zeit;
  160. if( amLeben )
  161. {
  162. zeitAmLeben += zeit;
  163. if( lKurve || rKurve )
  164. {
  165. double grad = kurve * zeit;
  166. if( lKurve )
  167. grad = -grad;
  168. double cs = cos( grad );
  169. double sn = sin( grad );
  170. double tmpX = ( xSpeed * cs - ySpeed * sn );
  171. double tmpY = ( xSpeed * sn + ySpeed * cs );
  172. xSpeed = tmpX;
  173. ySpeed = tmpY;
  174. }
  175. if( zMap && !linieUnterbrochen )
  176. {
  177. int x1 = (int)( xPos + 0.5 );
  178. int y1 = (int)( yPos + 0.5 );
  179. int x2 = (int)( xPos + xSpeed * zeit + 0.5 );
  180. int y2 = (int)( yPos + ySpeed * zeit + 0.5 );
  181. int *buff = zMap->getBuffer();
  182. int dpx = 0;
  183. int dpy = 0;
  184. int dgx = zMap->getBreite();
  185. int dgy = zMap->getHeight();
  186. int xlen = x2 - x1, axlen = abs( xlen );
  187. int ylen = y2 - y1, aylen = abs( ylen );
  188. double xf = (double)xlen / ( aylen ? aylen : 1 );
  189. double yf = (double)ylen / ( axlen ? axlen : 1 );
  190. if( axlen > aylen )
  191. xf = xf < 0 ? -1 : 1;
  192. else
  193. yf = yf < 0 ? -1 : 1;
  194. double x = (double)x1, y = (double)y1;
  195. int maxP = (int)( sqrt( (double)( xlen * xlen + ylen * ylen ) ) + 0.5 );
  196. int count = 0;
  197. int lastX = (int)( x + 0.5 ), lastY = (int)( y + 0.5 );
  198. while( !( (int)( x + 0.5 ) == x2 && (int)( y + 0.5 ) == y2 ) && count < maxP )
  199. {
  200. if( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy )
  201. {
  202. if( !rundenTodesZeit->hat( rundenNummer ) || !rundenTodesZeit->get( rundenNummer ) )
  203. tode++;
  204. xPos = x;
  205. yPos = y;
  206. todesZeit = spielZeit;
  207. rundenTodesZeit->set( (int)todesZeit, rundenNummer );
  208. amLeben = 0;
  209. killFarbe = 0;
  210. break;
  211. }
  212. if( buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] )
  213. {
  214. killFarbe = buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ];
  215. if( killFarbe == spielerFarbe )
  216. killFarbe = 0;
  217. if( !rundenTodesZeit->hat( rundenNummer ) || !rundenTodesZeit->get( rundenNummer ) )
  218. tode++;
  219. xPos = x;
  220. yPos = y;
  221. todesZeit = spielZeit;
  222. rundenTodesZeit->set( (int)todesZeit, rundenNummer );
  223. amLeben = 0;
  224. break;
  225. }
  226. buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
  227. x += xf, y += yf;
  228. if( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy )
  229. {
  230. if( !rundenTodesZeit->hat( rundenNummer ) || !rundenTodesZeit->get( rundenNummer ) )
  231. tode++;
  232. xPos = x;
  233. yPos = y;
  234. todesZeit = spielZeit;
  235. rundenTodesZeit->set( (int)todesZeit, rundenNummer );
  236. amLeben = 0;
  237. killFarbe = 0;
  238. break;
  239. }
  240. if( ( lastX != (int)( x + 0.5 ) || lastY != (int)( y + 0.5 ) ) && !buff[ (int)( x + 0.5 ) + (int)( y + 0.5 ) * zMap->getBreite() ] )
  241. {
  242. linienLength++;
  243. if( rundenLinienLength->hat( rundenNummer ) )
  244. rundenLinienLength->set( rundenLinienLength->get( rundenNummer ) + 1, rundenNummer );
  245. }
  246. if( lastX != (int)( x + 0.5 ) && lastY != (int)( yf + 0.5 ) )
  247. {
  248. if( (int)xf )
  249. {
  250. if( !( lastX < dpx || lastX >= dgx || (int)( y + 0.5 ) < dpy || (int)( y + 0.5 ) >= dgy ) )
  251. buff[ lastX + (int)( y + 0.5 ) * zMap->getBreite() ] = spielerFarbe;
  252. }
  253. else
  254. {
  255. if( !( (int)( x + 0.5 ) < dpx || (int)( x + 0.5 ) >= dgx || lastY < dpy || lastY >= dgy ) )
  256. buff[ (int)( x + 0.5 ) + lastY * zMap->getBreite() ] = spielerFarbe;
  257. }
  258. }
  259. lastX = (int)( x + 0.5 );
  260. lastY = (int)( y + 0.5 );
  261. count++;
  262. }
  263. }
  264. if( amLeben )
  265. {
  266. xPos += xSpeed * zeit;
  267. yPos += ySpeed * zeit;
  268. nLUChange -= zeit;
  269. if( nLUChange <= 0 )
  270. {
  271. linieUnterbrochen = !linieUnterbrochen;
  272. if( linieUnterbrochen )
  273. nLUChange = lUStrength;
  274. else
  275. nLUChange = 1 / lUStrength + ( ( rand() % (int)( 1 / lUStrength ) ) - ( ( 1 / lUStrength ) / 2 ) );
  276. }
  277. }
  278. }
  279. else
  280. zeitTod += zeit;
  281. }
  282. // constant
  283. Klient *Spieler::zKlient() const
  284. {
  285. return klient;
  286. }
  287. int Spieler::getSpielerNummer() const
  288. {
  289. return sNum;
  290. }
  291. int Spieler::getSpielerFarbe() const
  292. {
  293. return spielerFarbe;
  294. }
  295. int Spieler::getSpielerTeam() const
  296. {
  297. return team;
  298. }
  299. int Spieler::getTeamFarbe() const
  300. {
  301. return teamFarbe;
  302. }
  303. double Spieler::getX() const
  304. {
  305. return xPos;
  306. }
  307. double Spieler::getY() const
  308. {
  309. return yPos;
  310. }
  311. double Spieler::getSpeedX() const
  312. {
  313. return xSpeed;
  314. }
  315. double Spieler::getSpeedY() const
  316. {
  317. return ySpeed;
  318. }
  319. double Spieler::getKurve() const
  320. {
  321. return kurve;
  322. }
  323. bool Spieler::istAmLeben() const
  324. {
  325. return amLeben;
  326. }
  327. int Spieler::getAccountId() const
  328. {
  329. return accountId;
  330. }
  331. double Spieler::getTodesZeit() const
  332. {
  333. return todesZeit;
  334. }
  335. bool Spieler::linieIstUnterbrochen() const
  336. {
  337. return linieUnterbrochen;
  338. }
  339. int Spieler::getPunkte() const
  340. {
  341. return punkte;
  342. }
  343. bool Spieler::istOnline() const
  344. {
  345. return klient ? klient->istOnline() : 0;
  346. }
  347. int Spieler::getKillFarbe() const
  348. {
  349. return killFarbe;
  350. }
  351. int Spieler::getRundenGewonnen() const
  352. {
  353. return rundenGewonnen + amLeben;
  354. }
  355. int Spieler::getLinienLength() const
  356. {
  357. return linienLength;
  358. }
  359. int Spieler::getZeitAmLeben() const
  360. {
  361. return (int)zeitAmLeben;
  362. }
  363. int Spieler::getZeitTod() const
  364. {
  365. return (int)zeitTod;
  366. }
  367. int Spieler::getKills() const
  368. {
  369. return kills;
  370. }
  371. int Spieler::getTode() const
  372. {
  373. return tode;
  374. }
  375. int Spieler::getLinienLength( int runde ) const
  376. {
  377. return rundenLinienLength->hat( runde ) ? rundenLinienLength->get( runde ) : 0;
  378. }
  379. int Spieler::getKills( int runde ) const
  380. {
  381. return rundenKills->hat( runde ) ? rundenKills->get( runde ) : 0;
  382. }
  383. int Spieler::getTodesZeit( int runde ) const
  384. {
  385. return rundenTodesZeit->hat( runde ) ? rundenTodesZeit->get( runde ) : 0;
  386. }
  387. bool Spieler::machtKurve( bool rechts ) const
  388. {
  389. return ( rechts && rKurve ) || ( !rechts && lKurve );
  390. }
  391. // Reference Counting
  392. Spieler *Spieler::getThis()
  393. {
  394. ref++;
  395. return this;
  396. }
  397. Spieler *Spieler::release()
  398. {
  399. ref--;
  400. if( !ref )
  401. delete this;
  402. return 0;
  403. }