API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 21st, 2019
85
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 9.50 KB | None | 0 0
raw download clone embed print report
  1. #include "Behavior.hpp"
  2. #include <iostream>
  3.  
  4. namespace ChessCore
  5. {
  6.  
  7. Behavior::Behavior()
  8. {
  9.  
  10. }
  11.  
  12. Behavior::~Behavior()
  13. {
  14.  
  15.  
  16.  
  17. }
  18.  
  19. void Behavior::mySwap(Figure &a, Figure &b)
  20. {
  21. std::swap(a, b);
  22. sf::Vector2f _pos1 = a.m_sprite.m_sprite.getPosition();
  23. sf::Vector2f _pos2 = b.m_sprite.m_sprite.getPosition();
  24. a.m_sprite.m_sprite.setPosition(_pos2);
  25. b.m_sprite.m_sprite.setPosition(_pos1);
  26. FigureCoordinates f_crd_a = a.getFieldCoords();
  27. FigureCoordinates f_crd_b = b.getFieldCoords();
  28. a.setFieldCoords(f_crd_b);
  29. b.setFieldCoords(f_crd_a);
  30.  
  31. FigureCoordinates crd_a = a.getCoords();
  32. FigureCoordinates crd_b = b.getCoords();
  33. a.setCoords(crd_b);
  34. b.setCoords(crd_a);
  35.  
  36. }
  37.  
  38. bool Behavior::check(Figure &a, Figure &b, Board &brd)
  39. {
  40. int ax, ay, bx,by, i,j, mini, maxi, dx, dy, minix, maxix, miniy, maxiy;
  41. FigureCoordinates coordsa,coordsb;
  42. int direction = (a.getPlayer() == Player_1) ? 1 : -1;
  43. int flag = false;
  44. FigureType fig = a.getType();
  45. FigureCoordinates crd_a = a.getCoords();
  46. FigureCoordinates crd_b = b.getCoords();
  47. switch(a.getType()){
  48. case PAWN:
  49. if((crd_b.x - crd_a.x) == direction &&
  50. (crd_b.y - crd_a.y) == 0)
  51. flag = true;
  52. break;
  53.  
  54. case ROOK:
  55. flag = true;
  56. if((crd_a.x == crd_b.x) || (crd_a.y == crd_b.y))
  57. {
  58. if (crd_a.x == crd_b.x)
  59. {
  60. if(crd_b.y < crd_a.y)
  61. {
  62. mini = crd_b.y + 1;
  63. maxi = crd_a.y;
  64. }
  65. else
  66. {
  67. maxi = crd_b.y;
  68. mini = crd_a.y + 1;
  69. }
  70. for(int i = mini; i< maxi; i++)
  71. {
  72. if(brd.m_board[crd_a.x][i].getType() != EMPTY)
  73. {
  74. flag = false;
  75. }
  76. }
  77. }
  78. else
  79. {
  80. if(crd_b.x < crd_a.x)
  81. {
  82. mini = crd_b.x + 1;
  83. maxi = crd_a.x;
  84. }
  85. else
  86. {
  87. maxi = crd_b.x;
  88. mini = crd_a.x + 1;
  89. }
  90. for(int i = mini; i< maxi; i++)
  91. {
  92. if(brd.m_board[i][crd_a.y].getType() != EMPTY)
  93. {
  94. flag = false;
  95. }
  96. }
  97. }
  98. }
  99. else{
  100. flag = false;
  101. }
  102. break;
  103.  
  104. case KNIGHT:
  105. if (((fabs(crd_b.x - crd_a.x) == 2) && (fabs(crd_b.y - crd_a.y) ==1)) || ((fabs(crd_b.y - crd_a.y) == 2) && (fabs(crd_b.x - crd_a.x) ==1))){
  106. return true;
  107. }
  108. else{
  109. return false;
  110. }
  111. break;
  112.  
  113. case BISHOP:
  114. flag = true;
  115. if(fabs(crd_a.x - crd_b.x) == fabs(crd_a.y - crd_b.y)){
  116. if((crd_a.x - crd_b.x) == (crd_a.y - crd_b.y)){
  117. if(crd_a.x < crd_b.x) {
  118. minix = crd_a.x + 1;
  119. maxix = crd_b.x;
  120. miniy = crd_a.y + 1;
  121. }
  122. else {
  123. minix = crd_b.x + 1;
  124. maxix = crd_a.x;
  125. miniy = crd_b.y + 1;
  126. }
  127. j = miniy;
  128. for (int i = minix; i< maxix; i++){
  129. if(brd.m_board[i][j].getType() != EMPTY) {
  130. flag = false;
  131. }
  132. j++;
  133. }
  134. }
  135. else{
  136. if(crd_a.x < crd_b.x) {
  137. minix = crd_a.x + 1;
  138. maxix = crd_b.x;
  139. maxiy = crd_a.y - 1;
  140. }
  141. else {
  142. minix = crd_b.x + 1;
  143. maxix = crd_a.x;
  144. maxiy = crd_b.y - 1;
  145. }
  146. j = maxiy;
  147. for (int i = minix; i< maxix; i++){
  148. if(brd.m_board[i][j].getType() != EMPTY) {
  149. flag = false;
  150. }
  151. j--;
  152. }
  153. }
  154. }
  155. break;
  156.  
  157. case QUEEN:
  158. flag = true;
  159. if((crd_a.x == crd_b.x) || (crd_a.y == crd_b.y))
  160. {
  161. if (crd_a.x == crd_b.x)
  162. {
  163. if(crd_b.y < crd_a.y)
  164. {
  165. mini = crd_b.y + 1;
  166. maxi = crd_a.y;
  167. }
  168. else
  169. {
  170. maxi = crd_b.y;
  171. mini = crd_a.y + 1;
  172. }
  173. for(int i = mini; i< maxi; i++)
  174. {
  175. if(brd.m_board[crd_a.x][i].getType() != EMPTY)
  176. {
  177. flag = false;
  178. }
  179. }
  180. }
  181. else
  182. {
  183. if(crd_b.x < crd_a.x)
  184. {
  185. mini = crd_b.x + 1;
  186. maxi = crd_a.x;
  187. }
  188. else
  189. {
  190. maxi = crd_b.x;
  191. mini = crd_a.x + 1;
  192. }
  193. for(int i = mini; i< maxi; i++)
  194. {
  195. if(brd.m_board[i][crd_a.y].getType() != EMPTY)
  196. {
  197. flag = false;
  198. }
  199. }
  200. }
  201. }
  202. else if(fabs(crd_a.x - crd_b.x) == fabs(crd_a.y - crd_b.y)){
  203. if((crd_a.x - crd_b.x) == (crd_a.y - crd_b.y)){
  204. if(crd_a.x < crd_b.x) {
  205. minix = crd_a.x + 1;
  206. maxix = crd_b.x;
  207. miniy = crd_a.y + 1;
  208. }
  209. else {
  210. minix = crd_b.x + 1;
  211. maxix = crd_a.x;
  212. miniy = crd_b.y + 1;
  213. }
  214. j = miniy;
  215. for (int i = minix; i< maxix; i++){
  216. if(brd.m_board[i][j].getType() != EMPTY) {
  217. flag = false;
  218. }
  219. j++;
  220. }
  221. }
  222. else{
  223. if(crd_a.x < crd_b.x) {
  224. minix = crd_a.x + 1;
  225. maxix = crd_b.x;
  226. maxiy = crd_a.y - 1;
  227. }
  228. else {
  229. minix = crd_b.x + 1;
  230. maxix = crd_a.x;
  231. maxiy = crd_b.y - 1;
  232. }
  233. j = maxiy;
  234. for (int i = minix; i< maxix; i++){
  235. if(brd.m_board[i][j].getType() != EMPTY) {
  236. flag = false;
  237. }
  238. j--;
  239. }
  240. }
  241. }
  242. else{
  243. return false;
  244. }
  245. break;
  246. }
  247. return flag;
  248. }
  249.  
  250. bool Behavior::canEat(Figure &a, Figure &b, Board &brd)
  251. {
  252. int i, j, maxi, mini, minix, maxix, miniy, maxiy;
  253. int direction = (a.getPlayer() == Player_1) ? 1 : -1;
  254. int flag = false;
  255.  
  256. FigureType fig = a.getType();
  257. FigureCoordinates crd_a = a.getCoords();
  258. FigureCoordinates crd_b = b.getCoords();
  259. switch(a.getType()){
  260. case PAWN:
  261. if((crd_b.x - crd_a.x) == direction &&
  262. std::abs(crd_b.y - crd_a.y) == 1 &&
  263. b.getType() != KING)
  264. flag = true;
  265. break;
  266. case ROOK:
  267. flag = true;
  268. if((crd_a.x == crd_b.x) || (crd_a.y == crd_b.y))
  269. {
  270. if (crd_a.x == crd_b.x)
  271. {
  272. if(crd_b.y < crd_a.y)
  273. {
  274. mini = crd_b.y + 1;
  275. maxi = crd_a.y;
  276. }
  277. else
  278. {
  279. maxi = crd_b.y;
  280. mini = crd_a.y + 1;
  281. }
  282. for(int i = mini; i< maxi; i++)
  283. {
  284. if(brd.m_board[crd_a.x][i].getType() != EMPTY)
  285. {
  286. flag = false;
  287. }
  288. }
  289. }
  290. else
  291. {
  292. if(crd_b.x < crd_a.x)
  293. {
  294. mini = crd_b.x + 1;
  295. maxi = crd_a.x;
  296. }
  297. else
  298. {
  299. maxi = crd_b.x;
  300. mini = crd_a.x + 1;
  301. }
  302. for(int i = mini; i< maxi; i++)
  303. {
  304. if(brd.m_board[i][crd_a.y].getType() != EMPTY)
  305. {
  306. flag = false;
  307. }
  308. }
  309. }
  310. }
  311. else{
  312. flag = false;
  313. }
  314. break;
  315.  
  316. case KNIGHT:
  317. if (((fabs(crd_b.x - crd_a.x) == 2) && (fabs(crd_b.y - crd_a.y) ==1)) || ((fabs(crd_b.y - crd_a.y) == 2) && (fabs(crd_b.x - crd_a.x) ==1))){
  318. return true;
  319. }
  320. else{
  321. return false;
  322. }
  323. break;
  324.  
  325. case BISHOP:
  326. flag = true;
  327. if(fabs(crd_a.x - crd_b.x) == fabs(crd_a.y - crd_b.y)){
  328. if((crd_a.x - crd_b.x) == (crd_a.y - crd_b.y)){
  329. if(crd_a.x < crd_b.x) {
  330. minix = crd_a.x + 1;
  331. maxix = crd_b.x;
  332. miniy = crd_a.y + 1;
  333. }
  334. else {
  335. minix = crd_b.x + 1;
  336. maxix = crd_a.x;
  337. miniy = crd_b.y + 1;
  338. }
  339. j = miniy;
  340. for (int i = minix; i< maxix; i++){
  341. if(brd.m_board[i][j].getType() != EMPTY) {
  342. flag = false;
  343. }
  344. j++;
  345. }
  346. }
  347. else{
  348. if(crd_a.x < crd_b.x) {
  349. minix = crd_a.x + 1;
  350. maxix = crd_b.x;
  351. maxiy = crd_a.y - 1;
  352. }
  353. else {
  354. minix = crd_b.x + 1;
  355. maxix = crd_a.x;
  356. maxiy = crd_b.y - 1;
  357. }
  358. j = maxiy;
  359. for (int i = minix; i< maxix; i++){
  360. if(brd.m_board[i][j].getType() != EMPTY) {
  361. flag = false;
  362. }
  363. j--;
  364. }
  365. }
  366. }
  367. break;
  368.  
  369.  
  370. case QUEEN:
  371. flag = true;
  372. if((crd_a.x == crd_b.x) || (crd_a.y == crd_b.y))
  373. {
  374. if (crd_a.x == crd_b.x)
  375. {
  376. if(crd_b.y < crd_a.y)
  377. {
  378. mini = crd_b.y + 1;
  379. maxi = crd_a.y;
  380. }
  381. else
  382. {
  383. maxi = crd_b.y;
  384. mini = crd_a.y + 1;
  385. }
  386. for(int i = mini; i< maxi; i++)
  387. {
  388. if(brd.m_board[crd_a.x][i].getType() != EMPTY)
  389. {
  390. flag = false;
  391. }
  392. }
  393. }
  394. else
  395. {
  396. if(crd_b.x < crd_a.x)
  397. {
  398. mini = crd_b.x + 1;
  399. maxi = crd_a.x;
  400. }
  401. else
  402. {
  403. maxi = crd_b.x;
  404. mini = crd_a.x + 1;
  405. }
  406. for(int i = mini; i< maxi; i++)
  407. {
  408. if(brd.m_board[i][crd_a.y].getType() != EMPTY)
  409. {
  410. flag = false;
  411. }
  412. }
  413. }
  414. }
  415. else if(fabs(crd_a.x - crd_b.x) == fabs(crd_a.y - crd_b.y)){
  416. if((crd_a.x - crd_b.x) == (crd_a.y - crd_b.y)){
  417. if(crd_a.x < crd_b.x) {
  418. minix = crd_a.x + 1;
  419. maxix = crd_b.x;
  420. miniy = crd_a.y + 1;
  421. }
  422. else {
  423. minix = crd_b.x + 1;
  424. maxix = crd_a.x;
  425. miniy = crd_b.y + 1;
  426. }
  427. j = miniy;
  428. for (int i = minix; i< maxix; i++){
  429. if(brd.m_board[i][j].getType() != EMPTY) {
  430. flag = false;
  431. }
  432. j++;
  433. }
  434. }
  435. else{
  436. if(crd_a.x < crd_b.x) {
  437. minix = crd_a.x + 1;
  438. maxix = crd_b.x;
  439. maxiy = crd_a.y - 1;
  440. }
  441. else {
  442. minix = crd_b.x + 1;
  443. maxix = crd_a.x;
  444. maxiy = crd_b.y - 1;
  445. }
  446. j = maxiy;
  447. for (int i = minix; i< maxix; i++){
  448. if(brd.m_board[i][j].getType() != EMPTY) {
  449. flag = false;
  450. }
  451. j--;
  452. }
  453. }
  454. }
  455. else{
  456. return false;
  457. }
  458. break;
  459. }
  460.  
  461. if (a.getPlayer() == b.getPlayer())
  462. {
  463. flag = false;
  464. }
  465.  
  466. return flag;
  467. }
  468. void Behavior::deleteFigure(Figure &a, MySprite sprite)
  469. {
  470. sf::Vector2f _pos1 = a.m_sprite.m_sprite.getPosition();
  471. a.m_sprite = sprite;
  472. a.m_sprite.m_sprite.setPosition(_pos1);
  473. a.setType(EMPTY);
  474. a.setPlayer(None_player);
  475. }
  476.  
  477. }
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!