Guest User

Untitled

a guest
Jul 19th, 2018
80
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.35 KB | None | 0 0
  1. 1: #include <iostream>
  2. 2: #include <string>
  3. 3: #include <vector>
  4. 4: using namespace std;
  5. 5: //Laaja Ohjelmointi 1
  6. 6: //Harjoitustyö
  7. 7: //"EinStein würfelt nicht"
  8. 8:
  9. 9: int arpa ()
  10. 10: {
  11. 11: const int RMAX = RAND_MAX + 1;
  12. 12: double luku = rand ();
  13. 13: luku = luku * 6;
  14. 14: luku = luku / RMAX;
  15. 15: luku = luku + 1;
  16. 16: return static_cast<int>(luku);
  17. 17: }
  18. 18:
  19. 19: void kysySiemenluku ()
  20. 20: {
  21. 21: int siemenluku=0;
  22. 22: cout << "Anna siemenluku" << endl << "> ";
  23. 23: cin >> siemenluku;
  24. 24: srand(siemenluku);
  25. 25: }
  26. 26:
  27. 27: enum Pelaaja
  28. 28: {
  29. 29: Musta,
  30. 30: Valkea
  31. 31: };
  32. 32:
  33. 33: struct Kivi
  34. 34: {
  35. 35: bool vari;
  36. 36: int luku;
  37. 37: };
  38. 38:
  39. 39: struct Ruutu
  40. 40: {
  41. 41: int kivi;
  42. 42: bool tyhja;
  43. 43: };
  44. 44:
  45. 45: bool onkoElossa(vector<vector<Ruutu> > pelilauta, int kivinro)
  46. 46: {
  47. 47: for (int y = 0; y < 5; ++y)
  48. 48: {
  49. 49: for (int x = 0; x < 5; ++x)
  50. 50: {
  51. 51: if(pelilauta.at(y).at(x).kivi == kivinro)
  52. 52: {
  53. 53: return true;
  54. 54: }
  55. 55:
  56. 56: }
  57. 57: }
  58. 58: return false;
  59. 59: }
  60. 60:
  61. 61: vector<vector<Ruutu> > muodostaAlkuasetelma()
  62. 62: {
  63. 63: Ruutu kivi = {0, false};
  64. 64: vector<Ruutu> rivi;
  65. 65: vector<vector<Ruutu> > pelilauta;
  66. 66: bool vuoro;
  67. 67: int kivinro = arpa();
  68. 68:
  69. 69: for (int i = 0; i <= 4; ++i)
  70. 70: {
  71. 71: rivi.push_back(kivi);
  72. 72: }
  73. 73:
  74. 74: for(int j = 0; j <= 4; ++j)
  75. 75: {
  76. 76: pelilauta.push_back(rivi);
  77. 77: }
  78. 78:
  79. 79:
  80. 80: //koordinaatit(y,x)
  81. 81:
  82. 82: while(onkoElossa(pelilauta, kivinro) == true)
  83. 83: {
  84. 84: kivinro = arpa();
  85. 85: }
  86. 86:
  87. 87: pelilauta.at(0).at(0).kivi = kivinro;
  88. 88: pelilauta.at(4).at(4).kivi = -kivinro;
  89. 89:
  90. 90: while(onkoElossa(pelilauta, kivinro) == true)
  91. 91: {
  92. 92: kivinro = arpa();
  93. 93: }
  94. 94:
  95. 95: pelilauta.at(0).at(1).kivi = kivinro;
  96. 96: pelilauta.at(4).at(3).kivi = -kivinro;
  97. 97:
  98. 98: while(onkoElossa(pelilauta, kivinro) == true)
  99. 99: {
  100. 100: kivinro = arpa();
  101. 101: }
  102. 102:
  103. 103: pelilauta.at(0).at(2).kivi = kivinro;
  104. 104: pelilauta.at(4).at(2).kivi = -kivinro;
  105. 105:
  106. 106: while(onkoElossa(pelilauta, kivinro) == true)
  107. 107: {
  108. 108: kivinro = arpa();
  109. 109: }
  110. 110:
  111. 111: pelilauta.at(1).at(0).kivi = kivinro;
  112. 112: pelilauta.at(3).at(4).kivi = -kivinro;
  113. 113:
  114. 114: while(onkoElossa(pelilauta, kivinro) == true)
  115. 115: {
  116. 116: kivinro = arpa();
  117. 117: }
  118. 118:
  119. 119: pelilauta.at(1).at(1).kivi = kivinro;
  120. 120: pelilauta.at(3).at(3).kivi = -kivinro;
  121. 121:
  122. 122: while (onkoElossa(pelilauta, kivinro) == true)
  123. 123: {
  124. 124: kivinro = arpa();
  125. 125: }
  126. 126:
  127. 127: pelilauta.at(2).at(0).kivi = kivinro;
  128. 128: pelilauta.at(2).at(4).kivi = -kivinro;
  129. 129:
  130. 130: //(0,0),(0,1),(0,2)
  131. 131: //(1,0),(1,1)
  132. 132: //(2,0)
  133. 133: //(2,4)
  134. 134: //(3,4),(3,3)
  135. 135: //(4,4),(4,3),(4,2)
  136. 136:
  137. 137:
  138. 138: return pelilauta;
  139. 139:
  140. 140: }
  141. 141:
  142. 142: vector<vector<Ruutu> > tulostaPelilauta(vector<vector<Ruutu> > pelilauta);
  143. 143: {
  144. 144:
  145. 145: vector<vector<Ruutu> > pelilauta = muodostaAlkuasetelma();
  146. 146: for (int k = 0; k < 25; ++k)
  147. 147: {
  148. 148: }
  149. 149:
  150. 150: }
  151. 151:
  152. 152: enum Liike
  153. 153: {
  154. 154: //Mustan liikkeet
  155. 155: ita,
  156. 156: etela,
  157. 157: kaakko,
  158. 158: //Valkean liikkeet
  159. 159: lansi,
  160. 160: pohjoinen,
  161. 161: luode
  162. 162: };
  163. 163:
  164. 164: void siirto(vector<vector<Ruutu> > pelilauta);
  165. 165: {
  166. 166: int siirto = 0;
  167. 167: Pelaaja pelaaja;
  168. 168: int numero = 0;
  169. 169: //if (vuoro=true)
  170. 170: //kivi=kivi.numero
  171. 171: //if (vuoro=false)
  172. 172: //kivi=kivi.vari
  173. 173: //int liike = kiven vanha koordinaatti
  174. 174:
  175. 175: //tulostaPelilauta();
  176. 176: cout << pelaaja << " pelaaja, siirrä kiveä " << numero << endl << "> ";
  177. 177: cin >> siirto;
  178. 178:
  179. 179: switch (siirto)
  180. 180: {
  181. 181:
  182. 182: case 6:
  183. 183: // liike=pelilauta.at(y+1).at(x).kivi;
  184. 184: break;
  185. 185: case 2:
  186. 186: // liike=pelilauta.at(y).at(x+1).kivi;
  187. 187: break;
  188. 188: case 3:
  189. 189: // liike=pelilauta.at(y+1).at(x+1).kivi;
  190. 190: break;
  191. 191: case 4:
  192. 192: // liike=pelilauta.at(y).at(x-1).kivi;
  193. 193: break;
  194. 194: case 8:
  195. 195: // liike=pelilauta.at(y-1).at(x).kivi;
  196. 196: break;
  197. 197: case 9:
  198. 198: // liike=pelilauta.at(y-1).at(x-1).kivi;
  199. 199: break;
  200. 200: default:
  201. 201: cout << "VIRHE: Virheellinen suunta." << endl;
  202. 202: siirto(pelilauta);
  203. 203: }
  204. 204:
  205. 205: //if (laiton siirto)
  206. 206: //jos kivi.vari == musta
  207. 207: //laittomat siirrot
  208. 208: //4, 8, 7, 1, 9
  209. 209: //if (kivi.vari == valkea)
  210. 210: //6, 2, 3, 1, 9
  211. 211: {
  212. 212: cout << "VIRHE: Virheellinen suunta." << endl;
  213. 213: siirto(pelilauta);
  214. 214: }
  215. 215:
  216. 216: //if (OOB)
  217. 217: //if liike < ulompi.size tai liike > ulompi.size
  218. 218: //tai liike < sisempi.size tai liike > sisempi.size
  219. 219: //joka siirron tarkistu: on pysyttävä annettujen koordinaattien joukossa
  220. 220: //tarkistetaan vaan jos ollaan reunaruudussa
  221. 221: //tietyistä koordinaateista ei saa siirtyä tiettyyn suuntaan
  222. 222: {
  223. 223: cout << "VIRHE: Yritit siirtyä ulos laudalta." << endl;
  224. 224: siirto(pelilauta);
  225. 225: }
  226. 226:
  227. 227: }
  228. 228:
  229. 229: bool voittoasema(Pelaaja pelaaja)
  230. 230: {
  231. 231: if (pelaaja==Musta)
  232. 232: {
  233. 233: //pelilauta.at(4).at(4).kivi == musta;
  234. 234: //laudan läpikäynti, etsitään valkoisia kiviä
  235. 235: //jos on, return false
  236. 236: }
  237. 237:
  238. 238: if (pelaaja==Valkea)
  239. 239: {
  240. 240: //pelilauta.at(0).at(0).kivi == valkea;
  241. 241: //laudan läpikäynti, etsitään mustia
  242. 242: //jos on, return false
  243. 243:
  244. 244: }
  245. 245:
  246. 246: }
  247. 247:
  248. 248:
  249. 249: int main ()
  250. 250: {
  251. 251: Pelaaja pelaaja;
  252. 252: pelaaja = Musta;
  253. 253: kysySiemenluku ();
  254. 254:
  255. 255: muodostaAlkuasetelma ();
  256. 256:
  257. 257: while(true)
  258. 258: {
  259. 259:
  260. 260: arpa();
  261. 261: //tulostetaan vuorossa oleva kivi
  262. 262: //jos arvottua kiveä ei ole, etsitään siitä seuraavat kivet ja
  263. 263: //pyydetään valitsemaan ylempi tai alempi
  264. 264:
  265. 265: siirto();
  266. 266:
  267. 267:
  268. 268:
  269. 269:
  270. 270:
  271. 271:
  272. 272:
  273. 273:
  274. 274: if (voittoasema()==true)
  275. 275: {
  276. 276: cout << pelaaja << " pelaaja voitti pelin!" << endl;
  277. 277: }
  278. 278:
  279. 279: if (pelaaja == Musta)
  280. 280: {
  281. 281: pelaaja = Valkea;
  282. 282: }
  283. 283: else
  284. 284: {
  285. 285: pelaaja = Musta;
  286. 286: }
  287. 287:
  288. 288: }
  289. 289:
  290. 290:
  291. 291:
  292. 292:
  293. 293:
  294. 294:
  295. 295: return EXIT_SUCCESS;
  296. 296: }
Add Comment
Please, Sign In to add comment