API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 23rd, 2016
77
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.23 KB | None | 0 0
raw download clone embed print report
  1. #define COL 2
  2. #define ROW 2
  3. #define MAX 6
  4.  
  5.  
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8.  
  9. int sze_getline(char s[], int lim) {
  10. int i, c;
  11. for (i = 0; i<lim && (c = getchar()) != EOF && c != '\n'; ++i) s[i] = c;
  12. s[i] = '\0';
  13. while (c != EOF && c != '\n') c = getchar();
  14. return i;
  15. }
  16.  
  17. int sze_atoi(char s[]) {
  18. int i, n = 0;
  19. for (i = 0; s[i] >= '0' && s[i] <= '9'; ++i)
  20. n = 10 * n + s[i] - '0';
  21. return n;
  22. }
  23.  
  24. void main() {
  25. char p1[3], p2[3], mezo[MAX + 1];
  26. int i, j, rowCount, colCount, map[ROW * 2 + 2][COL * 2 + 2], playerchanger, vege, mezoOk, sor = 0, oszlop = 0;
  27.  
  28.  
  29. printf("Hello! Please enter the initials of the first player. (e.g. \"AT\" for Alan Turing)\n");
  30. sze_getline(p1, 3);
  31.  
  32. printf("Please enter the initials of the second player.\n");
  33. sze_getline(p2, 3);
  34.  
  35. printf("1. jatekos: %s\n", p1);
  36. printf("2. jatekos: %s\n", p2);
  37.  
  38. colCount = 1;
  39. rowCount = 65;
  40. //mapgenerator
  41. for (i = 0; i < ROW * 2 + 2; i++) { //sorok
  42. for (j = 0; j < COL * 2 + 2; j++) { //sorok elemei
  43. if (i == 0) {
  44. if (j == 0) {
  45. map[i][j] = 32;
  46. }
  47. else if (j % 2 == 0) {
  48. map[i][j] = colCount;
  49. colCount++;
  50. }
  51. else map[i][j] = 32;
  52. }
  53. else if (j == 0) {
  54. if (i % 2 == 0) {
  55. map[i][j] = rowCount;
  56. rowCount++;
  57. }
  58. else map[i][j] = 32;
  59. }
  60. else if (i % 2 == 1 && j % 2 == 1) {
  61. map[i][j] = 43;
  62. }
  63. else map[i][j] = 32;
  64. }
  65. printf("\n");
  66. }
  67. printf("\n");
  68.  
  69.  
  70.  
  71.  
  72. vege = 0;
  73. playerchanger = 0;
  74. do {
  75. //maprajz
  76. for (i = 0; i < ROW * 2 + 2; i++) {
  77. for (j = 0; j < COL * 2 + 2; j++) {
  78.  
  79. if (j == 0 && i == 0) { //bal felső térköz
  80. printf("%c", map[i][j]);
  81. }
  82. else if (i == 0 && j % 2 == 0) { // oszlopok sorszámai
  83. printf("%c%d", 32, map[i][j]);
  84. }
  85. else if (j == 0 && i % 2 == 0) { // sorok betüjelei
  86. printf("%c%c", map[i][j], 32);
  87. }
  88. else if (i % 2 == 1 && j % 2 == 0) { //vízszintes falak
  89. printf("%c%c", map[i][j], map[i][j]);
  90. }
  91. else if (i != 0 && i % 2 == 0 && j % 2 == 0) { //Mezők ahol a játékos nevek lesznek
  92. if (map[i][j] == 32) {
  93. printf("%c%c", map[i][j], map[i][j]); //ha üres, 2 szóköz
  94. }
  95. else printf("%s", map[i][j]); //ha foglalt, p1 v. p2
  96. }
  97. else printf("%c", map[i][j]);
  98. }
  99. printf("\n");
  100. }
  101.  
  102. if (playerchanger == 0) { // Ha p1 jön
  103.  
  104. do {
  105. printf("%s, please give a row, column and direction separated by spaces.\n", p1);
  106. sze_getline(mezo, MAX+1); // Lépés bekérése
  107.  
  108. //lépés helyességének ellenőrzése
  109. mezoOk = 1; //alap esetben jó a mező
  110. if (mezo[3] == 32 && mezo[1] == 32) { // ha az oszlop index 1 jegyű
  111. if (mezo[0] > 64 && mezo[0] < 91) { //első karakter (sor index) nagybetű-e
  112. sor = (mezo[0] - 64) * 2; // átalakítás sorszámmá
  113. if (sor > ROW * 2 + 1 || sor < 1) { //ha a megadott szám a pálya tartományán kívűl esik
  114. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  115. mezoOk = 0; //nem megfelelő lépés
  116. }
  117. }
  118. else {
  119. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  120. mezoOk = 0;
  121. }
  122.  
  123. if ((mezo[2] > 48) && (mezo[2] <= 48 + COL)) { //ha eddig jó a bekérés és az oszlop indexe 0 és 9 között van
  124. oszlop = (mezo[2] - 48) * 2;
  125. }
  126. else {
  127. printf("The column must be a number between 1 and %d.\n", COL);
  128. mezoOk = 0;
  129.  
  130. }
  131.  
  132. switch (mezo[4]) {
  133. case 68: sor++;
  134. break;
  135. case 76: oszlop--;
  136. break;
  137. case 82: oszlop++;
  138. break;
  139. case 85: sor--;
  140. break;
  141. default: mezoOk = 0;
  142. printf("The direction should be the first (uppercase) letter of Left, Right, Up or Down.");
  143. }
  144.  
  145.  
  146. }
  147. else if (mezo[1] == 32 && mezo[4]) { // ha kétjegyű az oszlop index
  148. if (mezo[0] > 64 && mezo[0] < 91) { //első karakter (sor index) nagybetű-e
  149. sor = (mezo[0] - 64) * 2; // átalakítás sorszámmá
  150. if (sor > ROW * 2 + 1 || sor < 1) { //ha a megadott szám a pálya tartományán kívűl esik
  151. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  152. mezoOk = 0; //nem megfelelő lépés
  153. }
  154. }
  155. else {
  156. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  157. mezoOk = 0;
  158. }
  159.  
  160. if ((mezo[2] > 48) && (mezo[2] <= 48 + COL) && (mezo[3] >= 48) && (mezo[3] <= 48 + COL)) { //ha eddig jó a bekérés és az oszlop indexé
  161. oszlop = (((mezo[2] - 48) * 10) + (mezo[3] - 48)) * 2;
  162. if (oszlop > COL * 2 + 1) {
  163. printf("The column must be a number between 1 and %d.\n", COL);
  164. mezoOk = 0;
  165. }
  166. }
  167. else {
  168. printf("The column must be a number between 1 and %d.\n", COL);
  169. mezoOk = 0;
  170.  
  171. }
  172.  
  173.  
  174. switch (mezo[5]) {
  175. case 68: sor++;
  176. break;
  177. case 76: oszlop--;
  178. break;
  179. case 82: oszlop++;
  180. break;
  181. case 85: sor--;
  182. break;
  183. default: mezoOk = 0;
  184. printf("The direction should be the first (uppercase) letter of Left, Right, Up or Down.");
  185. }
  186. }
  187.  
  188.  
  189.  
  190. if (sor < 1 || oszlop < 1) {
  191. printf("Bad input\n");
  192. mezoOk = 0;
  193.  
  194. }
  195. else if ((oszlop <= COL * 2 + 1) && (sor <= ROW * 2 + 1) && (map[sor][oszlop] != 32)) {
  196. mezoOk = 0;
  197. printf("The specified wall is already there.\n");
  198. }
  199. else {
  200. if (sor % 2 == 1 && oszlop % 2 == 0) { //ha vízszintes
  201. if (sor == 1) { // ha vízszintes legfelső
  202. if ((map[sor + 2][oszlop] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  203. printf("Nice move! It's your turn again.\n");
  204. map[sor + 1][oszlop] = p1;
  205. }
  206. else playerchanger = 1; //nincs bekerített rész, másik játékos jön
  207. }
  208. else if (sor == ROW * 2 + 1) { //ha vízszintes legalsó
  209. if ((map[sor - 2][oszlop] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor - 1][oszlop + 1] != 32)) {
  210. printf("Nice move! It's your turn again.\n");
  211. map[sor - 1][oszlop] = p1;
  212. }
  213. else playerchanger = 1; //nincs bekerített rész, másik játékos jön
  214. }
  215. else { // ha a kettő között
  216. //ha felfele és lefele is meg vannak a falak
  217. if ((map[sor - 2][oszlop] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor - 1][oszlop + 1] != 32) && (map[sor + 2][oszlop] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  218. printf("Nice move! It's your turn again.\n");
  219. map[sor - 1][oszlop] = p1;
  220. map[sor + 1][oszlop] = p1;
  221. }
  222. //ha csak lefele vannak meg a falak
  223. else if ((map[sor + 2][oszlop] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  224. printf("Nice move! It's your turn again.\n");
  225. map[sor + 1][oszlop] = p1;
  226. }
  227. //ha csak felfele vannak meg a falak
  228. else if ((map[sor - 2][oszlop] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor - 1][oszlop + 1] != 32)) {
  229. printf("Nice move! It's your turn again.\n");
  230. map[sor - 1][oszlop] = p1;
  231. }
  232. else playerchanger = 1; //nincs bekerített rész, másik játékos jön
  233. }
  234. }
  235. else if (sor % 2 == 0 && oszlop % 2 == 1) { //ha függőleges
  236.  
  237. if (oszlop == 1) { // ha függőleges a tábla baloldalán baloldali
  238. if ((map[sor][oszlop + 2] != 32) && (map[sor + 1][oszlop + 1] != 32) && (map[sor - 1][oszlop + 1] != 32)) {
  239. printf("Nice move! It's your turn again.\n");
  240. map[sor][oszlop + 1] = p1;
  241. }
  242. else playerchanger = 1; //nincs bekerített rész, másik játékos jön
  243. }
  244. else if (oszlop == COL * 2 + 1) { //ha függőleges a tábla jobboldalán jobboldali
  245. if ((map[sor][oszlop - 2] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor + 1][oszlop - 1] != 32)) {
  246. printf("Nice move! It's your turn again.\n");
  247. map[sor][oszlop - 1] = p1;
  248. }
  249. else playerchanger = 1; //nincs bekerített rész, másik játékos jön
  250. }
  251. else { // ha a kettő között
  252. //ha jobbra és balra is megvan minden fal
  253. if ((map[sor][oszlop - 2] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor][oszlop + 2] != 32) && (map[sor - 1][oszlop + 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  254. printf("Nice move! It's your turn again.\n");
  255. map[sor][oszlop - 1] = p1;
  256. map[sor][oszlop + 1] = p1;
  257. }
  258. //ha csak balra vannak meg a falak
  259. else if ((map[sor][oszlop - 2] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor + 1][oszlop - 1] != 32)) {
  260. printf("Nice move! It's your turn again.\n");
  261. map[sor][oszlop - 1] = p1;
  262. }
  263. //ha csak jobbra vannak meg a falak
  264. else if ((map[sor][oszlop + 2] != 32) && (map[sor - 1][oszlop + 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  265. printf("Nice move! It's your turn again.\n");
  266. map[sor][oszlop + 1] = p1;
  267. }
  268. else playerchanger = 1; //nincs bekerített rész, másik játékos jön
  269. }
  270.  
  271. }
  272. }
  273.  
  274. } while (mezoOk == 0);
  275. if (sor > 0 && sor % 2 == 1) {
  276. map[sor][oszlop] = 45;
  277. }
  278. else map[sor][oszlop] = 124;
  279.  
  280.  
  281. }
  282. else { //2. játékos.
  283.  
  284. do {
  285. printf("%s, please give a row, column and direction separated by spaces.\n", p2);
  286. sze_getline(mezo, MAX+1); // Lépés bekérése
  287.  
  288. //lépés helyességének ellenőrzése
  289. mezoOk = 1; //alap esetben jó a mező
  290. if (mezo[3] == 32 && mezo[1] == 32) { // ha az oszlop index 1 jegyű
  291. if (mezo[0] > 64 && mezo[0] < 91) { //első karakter (sor index) nagybetű-e
  292. sor = (mezo[0] - 64) * 2; // átalakítás sorszámmá
  293. if (sor > ROW * 2 + 1 || sor < 1) { //ha a megadott szám a pálya tartományán kívűl esik
  294. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  295. mezoOk = 0; //nem megfelelő lépés
  296. }
  297. }
  298. else {
  299. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  300. mezoOk = 0;
  301. }
  302.  
  303. if ((mezo[2] > 48) && (mezo[2] <= 48 + COL)) { //ha eddig jó a bekérés és az oszlop indexe 0 és 9 között van
  304. oszlop = (mezo[2] - 48) * 2;
  305. }
  306. else {
  307. printf("The column must be a number between 1 and %d.\n", COL);
  308. mezoOk = 0;
  309.  
  310. }
  311.  
  312. switch (mezo[4]) {
  313. case 68: sor++;
  314. break;
  315. case 76: oszlop--;
  316. break;
  317. case 82: oszlop++;
  318. break;
  319. case 85: sor--;
  320. break;
  321. default: mezoOk = 0;
  322. printf("The direction should be the first (uppercase) letter of Left, Right, Up or Down.");
  323. }
  324.  
  325.  
  326. }
  327. else if (mezo[1] == 32 && mezo[4]) { // ha kétjegyű az oszlop index
  328. if (mezo[0] > 64 && mezo[0] < 91) { //első karakter (sor index) nagybetű-e
  329. sor = (mezo[0] - 64) * 2; // átalakítás sorszámmá
  330. if (sor > ROW * 2 + 1 || sor < 1) { //ha a megadott szám a pálya tartományán kívűl esik
  331. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  332. mezoOk = 0; //nem megfelelő lépés
  333. }
  334. }
  335. else {
  336. printf("The row must be an uppercase letter between A and %c\n", ROW + 64);
  337. mezoOk = 0;
  338. }
  339.  
  340. if ((mezo[2] > 48) && (mezo[2] <= 48 + COL) && (mezo[3] >= 48) && (mezo[3] <= 48 + COL)) { //ha eddig jó a bekérés és az oszlop indexé
  341. oszlop = (((mezo[2] - 48) * 10) + (mezo[3] - 48)) * 2;
  342. if (oszlop > COL * 2 + 1) {
  343. printf("The column must be a number between 1 and %d.\n", COL);
  344. mezoOk = 0;
  345. }
  346. }
  347. else {
  348. printf("The column must be a number between 1 and %d.\n", COL);
  349. mezoOk = 0;
  350.  
  351. }
  352.  
  353.  
  354. switch (mezo[5]) {
  355. case 68: sor++;
  356. break;
  357. case 76: oszlop--;
  358. break;
  359. case 82: oszlop++;
  360. break;
  361. case 85: sor--;
  362. break;
  363. default: mezoOk = 0;
  364. printf("The direction should be the first (uppercase) letter of Left, Right, Up or Down.");
  365. }
  366. }
  367.  
  368.  
  369.  
  370. if (sor < 1 || oszlop < 1) {
  371. printf("Bad input\n");
  372. }
  373. else if ((oszlop <= COL * 2 + 1) && (sor <= ROW * 2 + 1) && (map[sor][oszlop] != 32)) {
  374. mezoOk = 0;
  375. printf("The specified wall is already there.\n");
  376. }
  377. else {
  378. if (sor % 2 == 1 && oszlop % 2 == 0) { //ha vízszintes
  379. if (sor == 1) { // ha vízszintes legfelső
  380. if ((map[sor + 2][oszlop] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  381. printf("Nice move! It's your turn again.\n");
  382. map[sor + 1][oszlop] = p2;
  383. }
  384. else playerchanger = 0; //nincs bekerített rész, másik játékos jön
  385. }
  386. else if (sor == ROW * 2 + 1) { //ha vízszintes legalsó
  387. if ((map[sor - 2][oszlop] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor - 1][oszlop + 1] != 32)) {
  388. printf("Nice move! It's your turn again.\n");
  389. map[sor - 1][oszlop] = p2;
  390. }
  391. else playerchanger = 0; //nincs bekerített rész, másik játékos jön
  392. }
  393. else { // ha a kettő között
  394. //ha felfele és lefele is meg vannak a falak
  395. if ((map[sor - 2][oszlop] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor - 1][oszlop + 1] != 32) && (map[sor + 2][oszlop] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  396. printf("Nice move! It's your turn again.\n");
  397. map[sor - 1][oszlop] = p2;
  398. map[sor + 1][oszlop] = p2;
  399. }
  400. //ha csak lefele vannak meg a falak
  401. else if ((map[sor + 2][oszlop] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  402. printf("Nice move! It's your turn again.\n");
  403. map[sor + 1][oszlop] = p2;
  404. }
  405. //ha csak felfele vannak meg a falak
  406. else if ((map[sor - 2][oszlop] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor - 1][oszlop + 1] != 32)) {
  407. printf("Nice move! It's your turn again.\n");
  408. map[sor - 1][oszlop] = p2;
  409. }
  410. else playerchanger = 0; //nincs bekerített rész, másik játékos jön
  411. }
  412. }
  413. else if (sor % 2 == 0 && oszlop % 2 == 1) { //ha függőleges
  414.  
  415. if (oszlop == 1) { // ha függőleges a tábla baloldalán baloldali
  416. if ((map[sor][oszlop + 2] != 32) && (map[sor + 1][oszlop + 1] != 32) && (map[sor - 1][oszlop + 1] != 32)) {
  417. printf("Nice move! It's your turn again.\n");
  418. map[sor][oszlop + 1] = p2;
  419. }
  420. else playerchanger = 0; //nincs bekerített rész, másik játékos jön
  421. }
  422. else if (oszlop == COL * 2 + 1) { //ha függőleges a tábla jobboldalán jobboldali
  423. if ((map[sor][oszlop - 2] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor + 1][oszlop - 1] != 32)) {
  424. printf("Nice move! It's your turn again.\n");
  425. map[sor][oszlop - 1] = p2;
  426. }
  427. else playerchanger = 0; //nincs bekerített rész, másik játékos jön
  428. }
  429. else { // ha a kettő között
  430. //ha jobbra és balra is megvan minden fal
  431. if ((map[sor][oszlop - 2] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor + 1][oszlop - 1] != 32) && (map[sor][oszlop + 2] != 32) && (map[sor - 1][oszlop + 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  432. printf("Nice move! It's your turn again.\n");
  433. map[sor][oszlop - 1] = p2;
  434. map[sor][oszlop + 1] = p2;
  435. }
  436. //ha csak balra vannak meg a falak
  437. else if ((map[sor][oszlop - 2] != 32) && (map[sor - 1][oszlop - 1] != 32) && (map[sor + 1][oszlop - 1] != 32)) {
  438. printf("Nice move! It's your turn again.\n");
  439. map[sor][oszlop - 1] = p2;
  440. }
  441. //ha csak jobbra vannak meg a falak
  442. else if ((map[sor][oszlop + 2] != 32) && (map[sor - 1][oszlop + 1] != 32) && (map[sor + 1][oszlop + 1] != 32)) {
  443. printf("Nice move! It's your turn again.\n");
  444. map[sor][oszlop + 1] = p2;
  445. }
  446. else playerchanger = 0; //nincs bekerített rész, másik játékos jön
  447. }
  448.  
  449. }
  450. }
  451.  
  452. } while (mezoOk == 0);
  453.  
  454.  
  455. if (sor > 0 && sor % 2 == 1) {
  456. map[sor][oszlop] = 45;
  457. }
  458. else map[sor][oszlop] = 124;
  459.  
  460.  
  461. }
  462.  
  463. //pálya ellenörző
  464.  
  465.  
  466.  
  467. } while (vege == 0);
  468.  
  469. printf("kileptem\n");
  470.  
  471. getchar();
  472. }
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!