API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 23rd, 2014
34
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 28.29 KB | None | 0 0
raw download clone embed print report
  1. package boggle.pkg11;
  2.  
  3.  
  4. import java.util.ArrayList;
  5.  
  6. /**
  7. *
  8. */
  9. public class Raster {
  10.  
  11. /*
  12. Constanten die moeten ingesteld worden in door spel menu.
  13. */
  14. public int aantalMensen;
  15. public int aantalBots;
  16. public int totaalAantalSpelers;
  17. public String[] naamSpelers;
  18. public float niveauBot;
  19.  
  20. /*
  21. De lijsten met alle spelers
  22. */
  23. ArrayList<Speler> spelers;
  24. Speler currentSpeler;
  25. int currentSpelerNumber;
  26.  
  27. /*
  28. Constante verhoudingen die gebruikt worden in de updateWindowSize() methode.
  29. */
  30. public final static float SIZE_WIDTH_VERHOUDING = 0.125f;
  31. public final static float SIZE_HEIGHT_VERHOUDING = 0.15f;
  32. public final static float SIZE_BETWEEN_VERHOUDING = 0.3f;
  33. public final static float SIZE_TEXTSIZE_VERHOUDING = 0.5f;
  34. public final static float RASTER_XOFFSET_VERHOUDING = 0.166f;
  35.  
  36. /*
  37. Het main object van het spel
  38. */
  39. BoggleApp game;
  40.  
  41. /*
  42.  
  43. */
  44. String woord; //Het woord at momenteel gevormd word
  45. int punten; //Aantal totale punten van de speler
  46. Blok lastBlokDragged; //Het blok die het laatste aangeklikt werd
  47. boolean waitNextPlayer;//Ofdat het spel moet wachten op de volgende speler
  48. private int aantalClicks;
  49.  
  50. /*
  51. Waarden voor de afmetingen en positie van het raster
  52. */
  53. private float size;
  54. private float between;
  55. private float xOffset;
  56. private float yOffset;
  57. private float textSize;
  58. private float textSize2;
  59. private int width1;
  60. private int height1;
  61.  
  62. /*
  63.  
  64. */
  65. ArrayList<Blok> blokken; //Alle blokken die op het scherm staan
  66. ArrayList<String> correctWords; //Alle woorden die al gevonden zijn door de speler
  67. ArrayList<String> woorden; //Alle woorden die bestaan in de nederlandse
  68. ArrayList<Blok> blokkenUsed; //Alle blokken die momenteel gebruikt worden om het woord te maken
  69. ArrayList<Effect> effecten; //Alle effecten die ooit gebruikt werden
  70.  
  71. /**
  72. * De constructor van Raster
  73. */
  74. public Raster() {
  75. game = BoggleApp.game;
  76. woord = "";
  77. waitNextPlayer = true;
  78. aantalClicks = 0;
  79.  
  80. /*
  81. Het aanmaken van de arraylisten
  82. */
  83. woorden = new ArrayList();
  84. correctWords = new ArrayList();
  85. blokkenUsed = new ArrayList();
  86. effecten = new ArrayList();
  87. blokken = new ArrayList();
  88. spelers = new ArrayList();
  89.  
  90. String[] Woorden = game.loadStrings("NL.txt");
  91. for(int i = 0; i<Woorden.length;i++){
  92. woorden.add(Woorden[i]);
  93. }
  94. /*
  95. Het inlezen van het bestand NL.txt, en al deze woorden in "woorden" opslaan
  96. Source: http://stackoverflow.com/questions/8330695/java-scanner-not-going-through-entire-file
  97. */
  98. // BufferedReader br = null;
  99. // try {
  100. // br = new BufferedReader(new FileReader(new File("NL.txt")));
  101. // String lijn;
  102. // while ((lijn = br.readLine()) != null) {
  103. // woorden.add(lijn);
  104. // }
  105. // } catch (FileNotFoundException e) {
  106. // e.printStackTrace();
  107. // } catch (IOException e) {
  108. // e.printStackTrace();
  109. // } finally {
  110. // if (br != null) {
  111. // try {
  112. // br.close();
  113. // } catch (IOException e) {
  114. // e.printStackTrace();
  115. // }
  116. // }
  117. // }
  118.  
  119. //Begin waarde geven
  120. char[] test = {'a', 'a', 'a', 'a', 'a', 'a'};
  121. lastBlokDragged = new Blok(test, -20);
  122.  
  123. //Zetten van de afmetingen van het raster
  124. updateWindowSize();
  125.  
  126. //Het aanmaken van de blokken die op het scherm staan
  127. char[] blok1 = {'R', 'E', 'S', 'I', 'H', 'N'};
  128. char[] blok2 = {'W', 'L', 'U', 'R', 'G', 'E'};
  129. char[] blok3 = {'A', 'P', 'D', 'E', 'C', 'M'};
  130. char[] blok4 = {'N', 'B', 'I', 'T', 'L', 'A'};
  131. char[] blok5 = {'T', 'O', 'N', 'E', 'D', 'S'};
  132. char[] blok6 = {'T', 'E', 'N', 'I', 'G', 'V'};
  133. char[] blok7 = {'M', 'B', 'D', 'J', 'Q', 'O'};
  134. char[] blok8 = {'Z', 'K', 'O', 'N', 'E', 'T'};
  135. char[] blok9 = {'A', 'M', 'I', 'R', 'O', 'S'};
  136. char[] blok10 = {'A', 'A', 'I', 'E', 'O', 'W'};
  137. char[] blok11 = {'N', 'Z', 'E', 'V', 'A', 'D'};
  138. char[] blok12 = {'S', 'R', 'A', 'H', 'C', 'E'};
  139. char[] blok13 = {'R', 'K', 'X', 'A', 'F', 'I'};
  140. char[] blok14 = {'H', 'I', 'S', 'E', 'E', 'F'};
  141. char[] blok15 = {'U', 'N', 'Y', 'J', 'G', 'E'};
  142. char[] blok16 = {'P', 'U', 'N', 'E', 'T', 'L'};
  143. blokken.add(new Blok(blok1, 0));
  144. blokken.add(new Blok(blok2, 1));
  145. blokken.add(new Blok(blok3, 2));
  146. blokken.add(new Blok(blok4, 3));
  147. blokken.add(new Blok(blok5, 4));
  148. blokken.add(new Blok(blok6, 5));
  149. blokken.add(new Blok(blok7, 6));
  150. blokken.add(new Blok(blok8, 7));
  151. blokken.add(new Blok(blok9, 8));
  152. blokken.add(new Blok(blok10, 9));
  153. blokken.add(new Blok(blok11, 10));
  154. blokken.add(new Blok(blok12, 11));
  155. blokken.add(new Blok(blok13, 12));
  156. blokken.add(new Blok(blok14, 13));
  157. blokken.add(new Blok(blok15, 14));
  158. blokken.add(new Blok(blok16, 15));
  159.  
  160.  
  161.  
  162. }
  163.  
  164. /**
  165. * De functie die alles tekent op het scherm
  166. */
  167. public void draw() {
  168.  
  169. //Indien het grote van het kader veranderd is, alle afmetingen aanpassen
  170. updateWindowSize();
  171. //Het tekenen van het scorebord
  172. scorebord();
  173.  
  174. //Het tekenen van alle blokken
  175. for (int i = 0; i < 4; i++) {
  176. for (int j = 0; j < 4; j++) {
  177.  
  178. game.stroke(5);
  179. game.strokeWeight(2);
  180. game.fill(243, 239, 224);
  181. float posX = xOffset + i * (size + between);
  182. float posY = yOffset + j * (size + between);
  183. game.rect(posX, posY, size, size, 15);
  184. }
  185. }
  186.  
  187. //Het tekenen van alle blokken in een andere kleur die al gebruikt zijn in het woord
  188. for (int x = 0; x < blokkenUsed.size(); x++) {
  189. int j = blokkenUsed.get(x).getID() % 4;
  190. int i = (blokkenUsed.get(x).getID() - j) / 4;
  191. float posX = xOffset + i * (size + between);
  192. float posY = yOffset + j * (size + between);
  193.  
  194. game.fill(150, 150, 150);
  195. game.rect(posX, posY, size, size, 15);
  196.  
  197. }
  198.  
  199. //Het tekenen van alle letters in de blokken
  200. game.textSize(textSize);
  201. game.noStroke();
  202. game.fill(100);
  203. for (int i = 0; i < 4; i++) {
  204. for (int j = 0; j < 4; j++) {
  205. float letterPosX = xOffset + i * (size + between) + ((size / 2) - (game.textWidth(blokken.get(i * 4 + j).getLetter()) / 2));
  206. float letterPosY = yOffset + j * (size + between) + ((size / 2) + (textSize / 2));
  207.  
  208. game.text(blokken.get(i * 4 + j).getLetter(), letterPosX, letterPosY);
  209. }
  210. }
  211.  
  212. //Het tekenen van het woord die momenteel gevormd wordt
  213. game.textSize(20);
  214. game.fill(0);
  215. game.text(woord, 100, 80);
  216.  
  217. //Het tekenen van score
  218. game.text("Punten: " + punten, 100, 20);
  219.  
  220. //Het tekenen van de woorden die al gevonden werden
  221. float woordX = xOffset + 4 * size + 4 * between + 20;
  222. float woordY = yOffset + 50;
  223. for (int x = 0; correctWords.size() > x; x++) {
  224. game.text(correctWords.get(x), woordX, woordY);
  225. woordY = woordY + 25;
  226. }
  227.  
  228. //Het tekenen van alle effecten die nog niet ten einde zijn
  229. for (int x = 0; effecten.size() > x; x++) {
  230. if (!effecten.get(x).isFinished()) {
  231. effecten.get(x).draw();
  232. }
  233. }
  234.  
  235. //Tekenen van de naam van de speler
  236. game.fill(245);
  237. game.stroke(5);
  238. game.strokeWeight(2);
  239. game.text(currentSpeler.getNaam(), (xOffset + 4 * size + 4 * between + (2 * xOffset - game.textWidth("Gevonden Woorden") / 2)), yOffset + (textSize / 2) - 40);
  240. if (waitNextPlayer) {
  241. textSize2 = textSize * 1f;
  242. game.textSize(textSize2);
  243. game.noStroke();
  244. game.fill(150, 200);
  245. game.rect(0, 0, game.width, game.height);
  246. game.stroke(5);
  247. game.strokeWeight(2);
  248. game.fill(50);
  249. game.text("Klik twee maal om te spelen.", xOffset + 10, yOffset + textSize2);
  250. game.text("Het is aan speler " + currentSpeler.getAlleenNaam(), xOffset + 10, textSize2 + yOffset + textSize2);
  251. game.text("Succes!", xOffset + 10, textSize2 + yOffset + (2f * textSize2));
  252. }
  253. }
  254.  
  255. /**
  256. * Indien de gebruiken het scherm aanpast, zullen alle afmetingen ook
  257. * aangepast worden
  258. */
  259. public final void updateWindowSize() {
  260. yOffset = 100;
  261. if (width1 != game.width || height1 != game.height) {
  262. size = game.width * SIZE_WIDTH_VERHOUDING;
  263.  
  264. if (4 * size + 3 * between + yOffset > game.height) {
  265. size = game.height * SIZE_HEIGHT_VERHOUDING;
  266. }
  267.  
  268. between = size * SIZE_BETWEEN_VERHOUDING;
  269. textSize = size * SIZE_TEXTSIZE_VERHOUDING;
  270. xOffset = (game.width - 4 * size - 3 * between) * RASTER_XOFFSET_VERHOUDING;
  271.  
  272. }
  273.  
  274. width1 = game.width;
  275. height1 = game.height;
  276. }
  277.  
  278. /**
  279. * Het tekenen van het scorebord
  280. */
  281. public void scorebord() {
  282.  
  283. game.textSize(textSize / 3);
  284. game.fill(72, 91, 93);
  285. game.stroke(5);
  286. game.strokeWeight(2);
  287. game.rect((xOffset + 4 * size + 4 * between), yOffset, 4 * xOffset, (4 * size + 3 * between));
  288. game.fill(245);
  289. game.text("Gevonden Woorden", (xOffset + 4 * size + 4 * between + (2 * xOffset - game.textWidth("Gevonden Woorden") / 2)), yOffset + (textSize / 2));
  290. }
  291.  
  292. /**
  293. * De functie die opgeroepen word wanneer de muis ingedrukt verplaatst wordt
  294. */
  295. public void mouseDragged() {
  296. if (waitNextPlayer) {
  297. return;
  298. }
  299. Blok myBlok = getBlockAtMouseOffset();
  300. if (myBlok != null) {
  301.  
  302. int idc = myBlok.getID();
  303. int id = lastBlokDragged.getID();
  304. System.out.println("Current Block (idc) ID: " + idc + " Last Block (id) ID: " + id + ".");
  305. // if (idc != id) {
  306. // if ((idc + 1) == id || (idc - 1) == id
  307. // || (idc + 4) == id || (idc - 4) == id
  308. // || (idc + 5) == id || (idc - 5) == id
  309. // || (idc + 3) == id || (idc - 3) == id
  310. // || id == -20) {
  311. // if (!alreadyUsed(myBlok)) {
  312. // woord = woord + myBlok.getLetter();
  313. // blokkenUsed.add(myBlok);
  314. // lastBlokDragged = myBlok;
  315. // }
  316. // }
  317.  
  318. // Een alternatieve methode zodat het foutloos zou werken. (nog niet af)
  319. if (idc != id) {
  320. switch (idc) {
  321. //Elk hoek punt
  322. case 0:
  323. if (id == 1 || id == 5 || id == 4 || id == -20) {
  324. if (!alreadyUsed(myBlok)) {
  325. woord = woord + myBlok.getLetter();
  326. blokkenUsed.add(myBlok);
  327. lastBlokDragged = myBlok;
  328. }
  329. }
  330. break;
  331. // switch (idc) {
  332. case 1:
  333. if(id == 0 || id == 4 || id == 5 || id == 6 || id == 2 || id == -20)
  334. {
  335. if (!alreadyUsed(myBlok)) {
  336. woord = woord + myBlok.getLetter();
  337. blokkenUsed.add(myBlok);
  338. lastBlokDragged = myBlok;
  339. }
  340. }
  341. break;
  342.  
  343. // switch (idc) {
  344. case 2:
  345. if(id == 1 || id == 5 || id == 6 || id == 7 || id == 3 || id == -20){
  346. if (!alreadyUsed(myBlok)) {
  347. woord = woord + myBlok.getLetter();
  348. blokkenUsed.add(myBlok);
  349. lastBlokDragged = myBlok;
  350. }
  351. }
  352. break;
  353. // switch (idc) {
  354. case 3:
  355. if(id == 2 || id == 6 || id == 7 || id ==-20){
  356. if (!alreadyUsed(myBlok)) {
  357. woord = woord + myBlok.getLetter();
  358. blokkenUsed.add(myBlok);
  359. lastBlokDragged = myBlok;
  360. }
  361. }
  362. break;
  363. // switch (idc) {
  364. case 4:
  365. if(id == 0 || id == 1 || id == 5 || id == 9 || id == 8 || id == -20){
  366. if (!alreadyUsed(myBlok)) {
  367. woord = woord + myBlok.getLetter();
  368. blokkenUsed.add(myBlok);
  369. lastBlokDragged = myBlok;
  370. }
  371. }
  372. break;
  373. case 5:
  374. if(id == 0 || id == 1 || id == 2 || id == 6 || id == 10 || id == 8 || id == 9 || id == 4 || id == -20){
  375. if (!alreadyUsed(myBlok)) {
  376. woord = woord + myBlok.getLetter();
  377. blokkenUsed.add(myBlok);
  378. lastBlokDragged = myBlok;
  379. }
  380. }
  381. break;
  382. case 6:
  383. if(id == 1 || id == 2 || id == 3 || id == 7 || id == 11 || id == 10 || id == 9 || id == 5 || id == -20){
  384. if (!alreadyUsed(myBlok)) {
  385. woord = woord + myBlok.getLetter();
  386. blokkenUsed.add(myBlok);
  387. lastBlokDragged = myBlok;
  388. }
  389. }
  390. break;
  391. case 7:
  392. if(id == 3 || id == 2 || id == 6 || id == 10 ||id == 11 || id == -20){
  393. if (!alreadyUsed(myBlok)) {
  394. woord = woord + myBlok.getLetter();
  395. blokkenUsed.add(myBlok);
  396. lastBlokDragged = myBlok;
  397. }
  398. }
  399. break;
  400. case 8:
  401. if ( id == 4 || id == 5 || id == 9 || id == 13 || id == 12 || id == -20){
  402. if (!alreadyUsed(myBlok)) {
  403. woord = woord + myBlok.getLetter();
  404. blokkenUsed.add(myBlok);
  405. lastBlokDragged = myBlok;
  406. }
  407. }
  408. break;
  409. case 9:
  410. if (id == 4 || id == 5 || id == 6 || id == 10 || id == 14 || id == 13 || id == 12 || id == 8 || id == -20){
  411. if (!alreadyUsed(myBlok)) {
  412. woord = woord + myBlok.getLetter();
  413. blokkenUsed.add(myBlok);
  414. lastBlokDragged = myBlok;
  415. }
  416. }
  417. break;
  418. case 10:
  419. if (id == 5 || id == 6 || id == 7 || id == 11 || id == 15 || id == 14 || id == 13 || id == 9 || id == -20){
  420. if (!alreadyUsed(myBlok)) {
  421. woord = woord + myBlok.getLetter();
  422. blokkenUsed.add(myBlok);
  423. lastBlokDragged = myBlok;
  424. }
  425. }
  426. break;
  427. case 11:
  428. if(id == 7 || id == 6 || id == 10 || id == 14 || id == 15 || id == -20){
  429. if (!alreadyUsed(myBlok)) {
  430. woord = woord + myBlok.getLetter();
  431. blokkenUsed.add(myBlok);
  432. lastBlokDragged = myBlok;
  433. }
  434. }
  435.  
  436. break;
  437. case 12:
  438. if ( id == 8 || id == 9 || id == 13 || id == -20){
  439. if (!alreadyUsed(myBlok)) {
  440. woord = woord + myBlok.getLetter();
  441. blokkenUsed.add(myBlok);
  442. lastBlokDragged = myBlok;
  443. }
  444. }
  445. break;
  446. case 13 :
  447. if( id == 12 || id == 8 || id == 9 || id == 10 || id == 14 || id == -20){
  448. if (!alreadyUsed(myBlok)) {
  449. woord = woord + myBlok.getLetter();
  450. blokkenUsed.add(myBlok);
  451. lastBlokDragged = myBlok;
  452. }
  453. }
  454. break;
  455. case 14:
  456. if ( id == 13 || id == 9 || id == 10 || id == 11 || id == 15 || id == -20){
  457. if (!alreadyUsed(myBlok)) {
  458. woord = woord + myBlok.getLetter();
  459. blokkenUsed.add(myBlok);
  460. lastBlokDragged = myBlok;
  461. }
  462. }
  463. break;
  464. case 15:
  465. if( id == 11 || id == 10 ||id == 14 || id == -20){
  466. if (!alreadyUsed(myBlok)) {
  467. woord = woord + myBlok.getLetter();
  468. blokkenUsed.add(myBlok);
  469. lastBlokDragged = myBlok;
  470. }
  471. }
  472. break;
  473. }
  474. }
  475. {{
  476. // case 3:
  477. // if (!alreadyUsed(myBlok)) {
  478. // woord = woord + myBlok.getLetter();
  479. // blokkenUsed.add(myBlok);
  480. // lastBlokDragged = myBlok;
  481. // }
  482. // }
  483. // break;
  484. // case 12:
  485. // if ((idc - 1) == id || (idc + 4) == id || (idc + 5) == id || id == -20) {
  486. // if (!alreadyUsed(myBlok)) {
  487. // woord = woord + myBlok.getLetter();
  488. // blokkenUsed.add(myBlok);
  489. // lastBlokDragged = myBlok;
  490. // }
  491. // }
  492. // break;
  493. // case 15:
  494. // if ((idc + 1) == id || (idc + 4) == id || (idc + 5) == id || id == -20) {
  495. // if (!alreadyUsed(myBlok)) {
  496. // woord = woord + myBlok.getLetter();
  497. // blokkenUsed.add(myBlok);
  498. // lastBlokDragged = myBlok;
  499. // }
  500. // }
  501. // break;
  502. //
  503. // // Middelste 2 rijen
  504. // case 1:
  505. // case 2:
  506. // case 5:
  507. // case 6:
  508. // case 9:
  509. // case 10:
  510. // case 13:
  511. // case 14:
  512. // if ((idc + 1) == id || (idc - 1) == id || (idc + 4) == id || (idc - 4) == id || (idc + 5) == id || (idc - 5) == id || (idc + 3) == id || (idc - 3) == id || id == -20) {
  513. // if (!alreadyUsed(myBlok)) {
  514. // woord = woord + myBlok.getLetter();
  515. // blokkenUsed.add(myBlok);
  516. // lastBlokDragged = myBlok;
  517. // }
  518. // }
  519. // break;
  520. //
  521. // //2 middelste blokken van bovenste en onderste rij
  522. // case 4:
  523. // case 8:
  524. // if ((idc - 1) == id || (idc + 4) == id || (idc - 4) == id || (idc + 3) == id || (idc - 3) == id || id == -20) {
  525. // if (!alreadyUsed(myBlok)) {
  526. // woord = woord + myBlok.getLetter();
  527. // blokkenUsed.add(myBlok);
  528. // lastBlokDragged = myBlok;
  529. // }
  530. // }
  531. // break;
  532. // case 7:
  533. // case 11:
  534. // if ((idc + 1) == id || (idc + 4) == id || (idc - 4) == id || (idc + 3) == id || (idc - 3) == id || id == -20) {
  535. // if (!alreadyUsed(myBlok)) {
  536. // woord = woord + myBlok.getLetter();
  537. // blokkenUsed.add(myBlok);
  538. // lastBlokDragged = myBlok;
  539. // }
  540. // }
  541. // break;
  542.  
  543.  
  544. }
  545. }
  546. }}
  547.  
  548. /**
  549. * Kijkt of het gegeven blok al gebruikt word in het woord dat momenteel
  550. * gemaakt wordt
  551. */
  552. public boolean alreadyUsed(Blok myBlok) {
  553. for (int x = 0; x < blokkenUsed.size(); x++) {
  554. if (myBlok.getID() == blokkenUsed.get(x).getID()) {
  555. return true;
  556. }
  557. }
  558. return false;
  559. }
  560.  
  561. /**
  562. * De functie die gecalled word wanneer de muis los gelaten wordt
  563. */
  564. public void mouseReleased() {
  565. if (waitNextPlayer) {
  566. return;
  567. }
  568. if (wordExist(woord) && woord.length() > 2) {
  569. boolean algebruikt = false;
  570. for (int x = 0; x < correctWords.size(); x++) {
  571. if (correctWords.get(x).equals(woord)) {
  572. algebruikt = true;
  573. }
  574. }
  575. if (!algebruikt) {
  576. System.out.println("Het woord \"" + woord + "\" was nog niet gebruikt.");
  577. Effect effect = new Effect(between, size, xOffset, yOffset, blokkenUsed);
  578. effecten.add(effect);
  579. correctWords.add(woord);
  580. currentSpeler.addWoord(woord);
  581. currentSpeler.addScore(punten(woord));
  582. punten(woord);
  583. }
  584. }
  585. woord = "";
  586. char[] test = {'a', 'a', 'a', 'a', 'a', 'a'};
  587. lastBlokDragged = new Blok(test, -20);
  588. blokkenUsed.clear();
  589. }
  590.  
  591. public void mouseClicked() {
  592. if (waitNextPlayer) {
  593. if (++aantalClicks > 1) {
  594. waitNextPlayer = false;
  595. aantalClicks = 0;
  596. }
  597. }
  598. }
  599.  
  600. /**
  601. * Het toevoegen van de score aan de hand van de lengte van het gevormde
  602. * woord
  603. */
  604. public int punten(String w) {
  605.  
  606. if (w.length() >= 8) {
  607. punten = punten + 11;
  608. return 11;
  609. } else if (w.length() == 7) {
  610. punten = punten + 5;
  611. return 5;
  612. } else if (w.length() == 6) {
  613. punten = punten + 3;
  614. return 3;
  615. } else if (w.length() == 5) {
  616. punten = punten + 2;
  617. return 2;
  618. } else if (w.length() >= 3) {
  619. punten = punten + 1;
  620. return 1;
  621. }
  622. return 0;
  623. }
  624.  
  625. /**
  626. * Kijkt ofdat het gegeven woord in de lijst staat
  627. */
  628. public boolean wordExist(String word) {
  629. for (int i = 0; i < woorden.size(); i++) {
  630. if (woorden.get(i).equalsIgnoreCase(word)) {
  631. System.out.println("Het woord \"" + woord + "\" bestaat.");
  632. return true;
  633. }
  634. }
  635. System.out.println("Het woord \"" + woord + "\" bestaat niet.");
  636. return false;
  637.  
  638. }
  639.  
  640. /**
  641. * Geeft de blok waarop de muis momenteel staat
  642. */
  643. public Blok getBlockAtMouseOffset() {
  644.  
  645. for (int i = 0; i < 4; i++) {
  646. for (int j = 0; j < 4; j++) {
  647. float posX = xOffset + i * (size + between);
  648. float posY = yOffset + j * (size + between);
  649.  
  650. if (game.mouseX > posX && game.mouseX < posX + size && game.mouseY > posY && game.mouseY < posY + size) {
  651. return blokken.get(i * 4 + j);
  652. }
  653. }
  654. }
  655.  
  656. return null;
  657. }
  658.  
  659. public float getSizeOfBlocks() {
  660. return size;
  661. }
  662.  
  663. public float getSpaceBetweenBlocks() {
  664. return between;
  665. }
  666.  
  667. public float getRasterX() {
  668. return xOffset;
  669. }
  670.  
  671. public float getRasterY() {
  672. return yOffset;
  673. }
  674.  
  675. public final void setSpeelWaarden(int aantalMensen, String[] naamSpelers, float niveauBot) {
  676. this.aantalMensen = aantalMensen;
  677. this.aantalBots = 4 - aantalMensen;
  678. this.totaalAantalSpelers = 4;
  679. this.naamSpelers = naamSpelers;
  680. this.niveauBot = niveauBot;
  681. }
  682.  
  683. public final void maakSpelers() {
  684. spelers = new ArrayList();
  685.  
  686. for (int x = 0; x < aantalMensen; x++) {
  687. spelers.add(new SpelerMens(naamSpelers[x]));
  688. }
  689. for (int x = 0; x < aantalBots; x++) {
  690. spelers.add(new SpelerBot(niveauBot));
  691. }
  692. currentSpelerNumber = 0;
  693. currentSpeler = spelers.get(currentSpelerNumber);
  694. }
  695.  
  696. public void eindeTimer() {
  697. if (!(currentSpelerNumber + 1 == spelers.size())) {
  698. if (!(spelers.get(++currentSpelerNumber) instanceof SpelerBot)) {
  699. System.out.println("VOLGENDE SPELER");
  700. currentSpeler = spelers.get(++currentSpelerNumber);
  701. correctWords = new ArrayList();
  702. punten = 0;
  703. game.timer.resetTimer(20000);
  704. waitNextPlayer = true;
  705. } else {
  706.  
  707. }
  708. } else {
  709. game.displayNummer = BoggleApp.RESULT_SCREEN;
  710. }
  711. }
  712.  
  713. public ArrayList<Speler> getSpelers() {
  714. return spelers;
  715. }
  716.  
  717. public boolean isWaitingNextPlayer() {
  718. return waitNextPlayer;
  719. }
  720. public float getTextSize() {
  721. return textSize;
  722. }
  723.  
  724. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!