API tools faq
paste
Guest User

TetrisKoreaWinpra

a guest
Apr 11th, 2015
395
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 32.59 KB | None | 0 0
raw download clone embed print report
  1. 파일분할된거 걍 한군데다 복붙해논거임
  2.  
  3.  
  4. 게임오버만 구현 안돼있음
  5.  
  6.  
  7.  
  8.  
  9. #ifndef __HEADER_H__
  10. #define __HEADER_H__
  11.  
  12. #define _CRT_SECURE_NO_WARNINGS
  13. #include<stdio.h>
  14. #include<stdlib.h>
  15. #include<conio.h>
  16. #include<Windows.h>
  17. #include<string.h>
  18. #include<stdlib.h>
  19. #include<time.h>
  20.  
  21. #define LEFT   75      // 좌측방향키
  22. #define RIGHT  77      // 우측방향키
  23. #define UP     72      // 위쪽방향키
  24. #define DOWN   80      // 아래방향키
  25. #define SPACE  32      // 스페이스바
  26.  
  27. #define DELAY  300
  28.  
  29. #define X (p->x)
  30. #define Y (p->y)
  31.  
  32. #define RIGHT_BOUND 11
  33. #define FLOOR_BOUND 20
  34.  
  35. int pix[22][12];
  36.  
  37. typedef struct
  38. {
  39.     int x, y;
  40. }XYPOS;
  41.  
  42. typedef struct
  43. {
  44.     int **block;//2원배열 블록 동적할당을 위함.
  45.     int Xlen;
  46.     int Ylen;
  47. }Block;
  48.  
  49. #endif
  50.  
  51. #ifndef __CHECK_SHOCK_H__
  52. #define __CHECK_SHOCK_H__
  53.  
  54. int CheckShockLeft(XYPOS *, Block);
  55. int CheckShockRight(XYPOS *, Block);
  56. int CheckShockDown(XYPOS *, Block);
  57. int CheckShockSuperDown(XYPOS *, Block);
  58. int CheckShockTurn(XYPOS *, Block);
  59. int CheckShockLeftTurn(XYPOS *, Block);
  60. int CheckShockRightTurn(XYPOS *, Block);
  61. int CheckShock4dLeftTurn(XYPOS *, Block);
  62. int CheckShock4dRightTurn(XYPOS *, Block);
  63.  
  64. #endif
  65.  
  66. #ifndef __MAKING_BLOCK_H__
  67. #define __MAKING_BLOCK_H__
  68.  
  69. void MakeCrossBlock(void);
  70. void MakeSquareBlock(void);
  71. void MakeStickBlock(void);
  72. void MakeNNBlock(void);
  73. void MakeRNBlock(void);
  74. void MakeLLBlock(void);
  75. void MakeRLBlock(void);
  76.  
  77. #endif
  78.  
  79. #ifndef __MOVING_H__
  80. #define __MOVING_H__
  81.  
  82. void MoveSuperDown(XYPOS*, Block);
  83. void MoveDown(XYPOS*, Block);
  84. void MoveLeft(XYPOS*, Block);
  85. void MoveRight(XYPOS*, Block);
  86. void Move3dTurn(XYPOS*, Block);
  87. void Move3dTurnSwap(XYPOS*, Block, int*);
  88. void Move4dTurn(XYPOS*, Block);
  89. void Move4dTurnSwap(XYPOS*, Block, int*);
  90.  
  91. #endif
  92.  
  93. #ifndef __PRINT_FUNCTION_H__
  94. #define __PRINT_FUNCTION_H__
  95.  
  96. void InitializeScreen(void);
  97. void PrintAllScreen(void);
  98. void DeleteLine(void);
  99.  
  100. #endif
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107. #include "Header.h"
  108. #include "CheckShock.h"
  109. #include "MakingBlock.h"
  110. #include "Moving.h"
  111. #include "Printfunc.h"
  112.  
  113. int main(void)
  114. {
  115.     int selectBlock;
  116.  
  117.     InitializeScreen();
  118.     PrintAllScreen();
  119.  
  120.     while (!_kbhit())
  121.     {
  122.         if (_getch())
  123.             break;
  124.     }
  125.  
  126.     while (1)
  127.     {
  128.         srand((int)time(NULL));
  129.         switch (selectBlock = rand() % 7)
  130.         {
  131.         case 1:
  132.             MakeSquareBlock();
  133.             break;
  134.         case 2:
  135.             MakeCrossBlock();
  136.             break;
  137.         case 3:
  138.             MakeStickBlock();
  139.             break;
  140.         case 4:
  141.             MakeNNBlock();
  142.             break;
  143.         case 5:
  144.             MakeRNBlock();
  145.             break;
  146.         case 6:
  147.             MakeLLBlock();
  148.             break;
  149.         case 0:
  150.             MakeRLBlock();
  151.             break;
  152.         }
  153.         DeleteLine();
  154.     }
  155.  
  156.     putchar('\n');
  157.     return 0;
  158. }
  159.  
  160.  
  161.  
  162.  
  163.  
  164.  
  165.  
  166. #include "Header.h"
  167. #include "Printfunc.h"
  168. #include "Moving.h"
  169. #include "CheckShock.h"
  170.  
  171. void MakeCrossBlock(void)
  172. {
  173.     int i, j;
  174.     XYPOS * p = (XYPOS*)malloc(sizeof(XYPOS) * 1);
  175.     X = -2;
  176.     Y = 4; //좌표초기화
  177.  
  178.     Block c;
  179.     c.block = (int**)malloc(sizeof(int) * 3);
  180.     c.block[0] = (int*)malloc(sizeof(int) * 3);
  181.     c.block[1] = (int*)malloc(sizeof(int) * 3);
  182.     c.block[2] = (int*)malloc(sizeof(int) * 3);//배열할당
  183.  
  184.     c.block[0][0] = 0; c.block[0][1] = 1; c.block[0][2] = 0;
  185.     c.block[1][0] = 1; c.block[1][1] = 1; c.block[1][2] = 1;
  186.     c.block[2][0] = 0; c.block[2][1] = 0; c.block[2][2] = 0;
  187.     c.Xlen = 3;
  188.     c.Ylen = 3;
  189.     //  {0,1,0}
  190.     //  {1,1,1}
  191.     //  {0,0,0}
  192.     //블록 형태지정 및 배열길이정보 입력
  193.  
  194.     for (i = 0; i < c.Xlen; i++)
  195.     {
  196.         for (j = 0; j < c.Ylen; j++)
  197.         {
  198.             if (pix[X + i][Y + j] >= 0)
  199.                 pix[X + i][Y + j] = c.block[i][j];
  200.         }
  201.     }//블록의 형태를 좌표에 삽입
  202.  
  203.     system("cls");
  204.     PrintAllScreen();
  205.  
  206.  
  207.  
  208.     for (; X < DOWN;)
  209.     {
  210.         if (_kbhit())
  211.         {
  212.             switch (_getch())
  213.             {
  214.             case DOWN:
  215.                 MoveDown(p, c);
  216.                 break;
  217.             case LEFT:
  218.                 MoveLeft(p, c);
  219.                 break;
  220.             case RIGHT:
  221.                 MoveRight(p, c);
  222.                 break;
  223.             case UP:
  224.                 Move3dTurn(p, c);
  225.                 break;
  226.             case SPACE:
  227.                 MoveSuperDown(p, c);
  228.                 break;
  229.             }
  230.         }
  231.  
  232.  
  233.         else if (CheckShockDown(p, c) == 1)     //바닥충돌검사 & 중력
  234.         {
  235.             for (i = 0; i < c.Xlen; i++)
  236.             {
  237.                 for (j = 0; j < c.Ylen; j++)
  238.                 {
  239.                     if (pix[X + i][Y + j] >= 0)
  240.                         pix[X + i][Y + j] = 0;
  241.                 }
  242.             }//블록 제거
  243.  
  244.             X++;
  245.  
  246.             for (i = 0; i < c.Xlen; i++)
  247.             {
  248.                 for (j = 0; j < c.Ylen; j++)
  249.                 {
  250.                     if (pix[X + i][Y + j] >= 0)
  251.                         pix[X + i][Y + j] = c.block[i][j];
  252.                 }
  253.             }//블록 한칸아래 생성
  254.  
  255.             Sleep(DELAY);//중력 딜레이
  256.             system("cls");
  257.             PrintAllScreen();
  258.         }
  259.         else
  260.         {
  261.             for (i = 0; i < c.Xlen; i++)
  262.             {
  263.                 for (j = 0; j < c.Ylen; j++)
  264.                 {
  265.                     if (pix[X + i][Y + j] == 1)
  266.                         pix[X + i][Y + j] = -2;
  267.                 }
  268.             }//블록 고정
  269.             break;
  270.         }
  271.     }//중력
  272.  
  273.     free(c.block[0]);
  274.     free(c.block[1]);
  275.     free(c.block[2]);
  276.     free(c.block);
  277.     free(p);
  278. }
  279. void MakeSquareBlock(void)
  280. {
  281.     int i, j;
  282.     XYPOS * p = (XYPOS*)malloc(sizeof(XYPOS) * 1);
  283.     X = -2;
  284.     Y = 5; //좌표초기화
  285.  
  286.     Block c;
  287.     c.block = (int**)malloc(sizeof(int) * 2);
  288.     c.block[0] = (int*)malloc(sizeof(int) * 2);
  289.     c.block[1] = (int*)malloc(sizeof(int) * 2);
  290.     //배열할당
  291.  
  292.     c.block[0][0] = 1; c.block[0][1] = 1;
  293.     c.block[1][0] = 1; c.block[1][1] = 1;
  294.  
  295.     c.Xlen = 2;
  296.     c.Ylen = 2;
  297.     //  {0,1,0}
  298.     //  {1,1,1}
  299.     //  {0,0,0}
  300.     //블록 형태지정 및 배열길이정보 입력
  301.  
  302.     for (i = 0; i < c.Xlen; i++)
  303.     {
  304.         for (j = 0; j < c.Ylen; j++)
  305.         {
  306.             if (pix[X + i][Y + j] >= 0)
  307.                 pix[X + i][Y + j] = c.block[i][j];
  308.         }
  309.     }//블록의 형태를 좌표에 삽입
  310.  
  311.     system("cls");
  312.     PrintAllScreen();
  313.  
  314.  
  315.  
  316.     for (; X < DOWN;)
  317.     {
  318.         if (_kbhit())
  319.         {
  320.             switch (_getch())
  321.             {
  322.             case DOWN:
  323.                 MoveDown(p, c);
  324.                 break;
  325.             case LEFT:
  326.                 MoveLeft(p, c);
  327.                 break;
  328.             case RIGHT:
  329.                 MoveRight(p, c);
  330.                 break;
  331.             case SPACE:
  332.                 MoveSuperDown(p, c);
  333.                 break;
  334.             }
  335.         }
  336.  
  337.  
  338.         else if (CheckShockDown(p, c) == 1)     //바닥충돌검사 & 중력
  339.         {
  340.             for (i = 0; i < c.Xlen; i++)
  341.             {
  342.                 for (j = 0; j < c.Ylen; j++)
  343.                 {
  344.                     if (pix[X + i][Y + j] >= 0)
  345.                         pix[X + i][Y + j] = 0;
  346.                 }
  347.             }//블록 제거
  348.  
  349.             X++;
  350.  
  351.             for (i = 0; i < c.Xlen; i++)
  352.             {
  353.                 for (j = 0; j < c.Ylen; j++)
  354.                 {
  355.                     if (pix[X + i][Y + j] >= 0)
  356.                         pix[X + i][Y + j] = c.block[i][j];
  357.                 }
  358.             }//블록 한칸아래 생성
  359.  
  360.             Sleep(DELAY);//중력 딜레이
  361.             system("cls");
  362.             PrintAllScreen();
  363.         }
  364.         else
  365.         {
  366.             for (i = 0; i < c.Xlen; i++)
  367.             {
  368.                 for (j = 0; j < c.Ylen; j++)
  369.                 {
  370.                     if (pix[X + i][Y + j] == 1)
  371.                         pix[X + i][Y + j] = -2;
  372.                 }
  373.             }//블록 고정
  374.             break;
  375.         }
  376.     }//중력
  377.  
  378.     free(c.block[0]);
  379.     free(c.block[1]);
  380.     free(c.block);
  381.     free(p);
  382. }
  383. void MakeNNBlock(void)
  384. {
  385.     int i, j;
  386.     int turnSwap = 0;
  387.     XYPOS * p = (XYPOS*)malloc(sizeof(XYPOS) * 1);
  388.  
  389.     X = -3;
  390.     Y = 5; //좌표초기화
  391.  
  392.     Block c;
  393.     c.block = (int**)malloc(sizeof(int) * 3);
  394.     c.block[0] = (int*)malloc(sizeof(int) * 3);
  395.     c.block[1] = (int*)malloc(sizeof(int) * 3);
  396.     c.block[2] = (int*)malloc(sizeof(int) * 3);//배열할당
  397.  
  398.     c.block[0][0] = 1; c.block[0][1] = 0; c.block[0][2] = 0;
  399.     c.block[1][0] = 1; c.block[1][1] = 1; c.block[1][2] = 0;
  400.     c.block[2][0] = 0; c.block[2][1] = 1; c.block[2][2] = 0;
  401.  
  402.     c.Xlen = 3;
  403.     c.Ylen = 3;
  404.     //  {1,0,0}
  405.     //  {1,1,0}
  406.     //  {0,1,0}
  407.     //블록 형태지정 및 배열길이정보 입력
  408.  
  409.     for (i = 0; i < c.Xlen; i++)
  410.     {
  411.         for (j = 0; j < c.Ylen; j++)
  412.         {
  413.             if (pix[X + i][Y + j] >= 0)
  414.                 pix[X + i][Y + j] = c.block[i][j];
  415.         }
  416.     }//블록의 형태를 좌표에 삽입
  417.  
  418.     system("cls");
  419.     PrintAllScreen();
  420.  
  421.  
  422.  
  423.     for (; X < DOWN;)
  424.     {
  425.         if (_kbhit())
  426.         {
  427.             switch (_getch())
  428.             {
  429.             case DOWN:
  430.                 MoveDown(p, c);
  431.                 break;
  432.             case LEFT:
  433.                 MoveLeft(p, c);
  434.                 break;
  435.             case RIGHT:
  436.                 MoveRight(p, c);
  437.                 break;
  438.             case UP:
  439.                 Move3dTurnSwap(p, c, &turnSwap);
  440.                 break;
  441.             case SPACE:
  442.                 MoveSuperDown(p, c);
  443.                 break;
  444.             }
  445.         }
  446.  
  447.  
  448.         else if (CheckShockDown(p, c) == 1)     //바닥충돌검사 & 중력
  449.         {
  450.             for (i = 0; i < c.Xlen; i++)
  451.             {
  452.                 for (j = 0; j < c.Ylen; j++)
  453.                 {
  454.                     if (pix[X + i][Y + j] >= 0)
  455.                         pix[X + i][Y + j] = 0;
  456.                 }
  457.             }//블록 제거
  458.  
  459.             X++;
  460.  
  461.             for (i = 0; i < c.Xlen; i++)
  462.             {
  463.                 for (j = 0; j < c.Ylen; j++)
  464.                 {
  465.                     if (pix[X + i][Y + j] >= 0)
  466.                         pix[X + i][Y + j] = c.block[i][j];
  467.                 }
  468.             }//블록 한칸아래 생성
  469.  
  470.             Sleep(DELAY);//중력 딜레이
  471.             system("cls");
  472.             PrintAllScreen();
  473.         }
  474.         else
  475.         {
  476.             for (i = 0; i < c.Xlen; i++)
  477.             {
  478.                 for (j = 0; j < c.Ylen; j++)
  479.                 {
  480.                     if (pix[X + i][Y + j] == 1)
  481.                         pix[X + i][Y + j] = -2;
  482.                 }
  483.             }//블록 고정
  484.             break;
  485.         }
  486.     }//중력
  487.  
  488.     free(c.block[0]);
  489.     free(c.block[1]);
  490.     free(c.block[2]);
  491.     free(c.block);
  492.     free(p);
  493. }
  494. void MakeRNBlock(void)
  495. {
  496.     int i, j;
  497.     int turnSwap = 0;
  498.     XYPOS * p = (XYPOS*)malloc(sizeof(XYPOS) * 1);
  499.  
  500.     X = -3;
  501.     Y = 4; //좌표초기화
  502.  
  503.     Block c;
  504.     c.block = (int**)malloc(sizeof(int) * 3);
  505.     c.block[0] = (int*)malloc(sizeof(int) * 3);
  506.     c.block[1] = (int*)malloc(sizeof(int) * 3);
  507.     c.block[2] = (int*)malloc(sizeof(int) * 3);//배열할당
  508.  
  509.     c.block[0][0] = 0; c.block[0][1] = 0; c.block[0][2] = 1;
  510.     c.block[1][0] = 0; c.block[1][1] = 1; c.block[1][2] = 1;
  511.     c.block[2][0] = 0; c.block[2][1] = 1; c.block[2][2] = 0;
  512.  
  513.     c.Xlen = 3;
  514.     c.Ylen = 3;
  515.     //  {0,0,1}
  516.     //  {0,1,1}
  517.     //  {0,1,0}
  518.     //블록 형태지정 및 배열길이정보 입력
  519.  
  520.     for (i = 0; i < c.Xlen; i++)
  521.     {
  522.         for (j = 0; j < c.Ylen; j++)
  523.         {
  524.             if (pix[X + i][Y + j] >= 0)
  525.                 pix[X + i][Y + j] = c.block[i][j];
  526.         }
  527.     }//블록의 형태를 좌표에 삽입
  528.  
  529.     system("cls");
  530.     PrintAllScreen();
  531.  
  532.  
  533.  
  534.     for (; X < DOWN;)
  535.     {
  536.         if (_kbhit())
  537.         {
  538.             switch (_getch())
  539.             {
  540.             case DOWN:
  541.                 MoveDown(p, c);
  542.                 break;
  543.             case LEFT:
  544.                 MoveLeft(p, c);
  545.                 break;
  546.             case RIGHT:
  547.                 MoveRight(p, c);
  548.                 break;
  549.             case UP:
  550.                 Move3dTurnSwap(p, c, &turnSwap);
  551.                 break;
  552.             case SPACE:
  553.                 MoveSuperDown(p, c);
  554.                 break;
  555.             }
  556.         }
  557.  
  558.  
  559.         else if (CheckShockDown(p, c) == 1)     //바닥충돌검사 & 중력
  560.         {
  561.             for (i = 0; i < c.Xlen; i++)
  562.             {
  563.                 for (j = 0; j < c.Ylen; j++)
  564.                 {
  565.                     if (pix[X + i][Y + j] >= 0)
  566.                         pix[X + i][Y + j] = 0;
  567.                 }
  568.             }//블록 제거
  569.  
  570.             X++;
  571.  
  572.             for (i = 0; i < c.Xlen; i++)
  573.             {
  574.                 for (j = 0; j < c.Ylen; j++)
  575.                 {
  576.                     if (pix[X + i][Y + j] >= 0)
  577.                         pix[X + i][Y + j] = c.block[i][j];
  578.                 }
  579.             }//블록 한칸아래 생성
  580.  
  581.             Sleep(DELAY);//중력 딜레이
  582.             system("cls");
  583.             PrintAllScreen();
  584.         }
  585.         else
  586.         {
  587.             for (i = 0; i < c.Xlen; i++)
  588.             {
  589.                 for (j = 0; j < c.Ylen; j++)
  590.                 {
  591.                     if (pix[X + i][Y + j] == 1)
  592.                         pix[X + i][Y + j] = -2;
  593.                 }
  594.             }//블록 고정
  595.             break;
  596.         }
  597.     }//중력
  598.  
  599.     free(c.block[0]);
  600.     free(c.block[1]);
  601.     free(c.block[2]);
  602.     free(c.block);
  603.     free(p);
  604. }
  605. void MakeLLBlock(void)
  606. {
  607.     int i, j;
  608.     XYPOS * p = (XYPOS*)malloc(sizeof(XYPOS) * 1);
  609.  
  610.     X = -3;
  611.     Y = 4; //좌표초기화
  612.  
  613.     Block c;
  614.     c.block = (int**)malloc(sizeof(int) * 4);
  615.     c.block[0] = (int*)malloc(sizeof(int) * 4);
  616.     c.block[1] = (int*)malloc(sizeof(int) * 4);
  617.     c.block[2] = (int*)malloc(sizeof(int) * 4);
  618.     c.block[3] = (int*)malloc(sizeof(int) * 4);//배열할당
  619.  
  620.     c.block[0][0] = 0; c.block[0][1] = 1; c.block[0][2] = 0; c.block[0][3] = 0;
  621.     c.block[1][0] = 0; c.block[1][1] = 1; c.block[1][2] = 0; c.block[1][3] = 0;
  622.     c.block[2][0] = 0; c.block[2][1] = 1; c.block[2][2] = 1; c.block[2][3] = 0;
  623.     c.block[3][0] = 0; c.block[3][1] = 0; c.block[3][2] = 0; c.block[3][3] = 0;
  624.     c.Xlen = 4;
  625.     c.Ylen = 4;
  626.     //  {0,1,0,0}
  627.     //  {0,1,0,0}
  628.     //  {0,1,1,0}
  629.     //  {0,0,0,0}
  630.     //블록 형태지정 및 배열길이정보 입력
  631.  
  632.     for (i = 0; i < c.Xlen; i++)
  633.     {
  634.         for (j = 0; j < c.Ylen; j++)
  635.         {
  636.             if (pix[X + i][Y + j] >= 0)
  637.                 pix[X + i][Y + j] = c.block[i][j];
  638.         }
  639.     }//블록의 형태를 좌표에 삽입
  640.  
  641.     system("cls");
  642.     PrintAllScreen();
  643.  
  644.  
  645.  
  646.     for (; X < DOWN;)
  647.     {
  648.         if (_kbhit())
  649.         {
  650.             switch (_getch())
  651.             {
  652.             case DOWN:
  653.                 MoveDown(p, c);
  654.                 break;
  655.             case LEFT:
  656.                 MoveLeft(p, c);
  657.                 break;
  658.             case RIGHT:
  659.                 MoveRight(p, c);
  660.                 break;
  661.             case UP:
  662.                 Move4dTurn(p, c);
  663.                 break;
  664.             case SPACE:
  665.                 MoveSuperDown(p, c);
  666.                 break;
  667.             }
  668.         }
  669.  
  670.  
  671.         else if (CheckShockDown(p, c) == 1)     //바닥충돌검사 & 중력
  672.         {
  673.             for (i = 0; i < c.Xlen; i++)
  674.             {
  675.                 for (j = 0; j < c.Ylen; j++)
  676.                 {
  677.                     if (pix[X + i][Y + j] >= 0)
  678.                         pix[X + i][Y + j] = 0;
  679.                 }
  680.             }//블록 제거
  681.  
  682.             X++;
  683.  
  684.             for (i = 0; i < c.Xlen; i++)
  685.             {
  686.                 for (j = 0; j < c.Ylen; j++)
  687.                 {
  688.                     if (pix[X + i][Y + j] >= 0)
  689.                         pix[X + i][Y + j] = c.block[i][j];
  690.                 }
  691.             }//블록 한칸아래 생성
  692.  
  693.             Sleep(DELAY);//중력 딜레이
  694.             system("cls");
  695.             PrintAllScreen();
  696.         }
  697.         else
  698.         {
  699.             for (i = 0; i < c.Xlen; i++)
  700.             {
  701.                 for (j = 0; j < c.Ylen; j++)
  702.                 {
  703.                     if (pix[X + i][Y + j] == 1)
  704.                         pix[X + i][Y + j] = -2;
  705.                 }
  706.             }//블록 고정
  707.             break;
  708.         }
  709.     }//중력
  710.  
  711.     free(c.block[0]);
  712.     free(c.block[1]);
  713.     free(c.block[2]);
  714.     free(c.block[3]);
  715.     free(c.block);
  716.     free(p);
  717. }
  718. void MakeRLBlock(void)
  719. {
  720.     int i, j;
  721.     XYPOS * p = (XYPOS*)malloc(sizeof(XYPOS) * 1);
  722.  
  723.     X = -3;
  724.     Y = 4; //좌표초기화
  725.  
  726.     Block c;
  727.     c.block = (int**)malloc(sizeof(int) * 4);
  728.     c.block[0] = (int*)malloc(sizeof(int) * 4);
  729.     c.block[1] = (int*)malloc(sizeof(int) * 4);
  730.     c.block[2] = (int*)malloc(sizeof(int) * 4);
  731.     c.block[3] = (int*)malloc(sizeof(int) * 4);//배열할당
  732.  
  733.     c.block[0][0] = 0; c.block[0][1] = 0; c.block[0][2] = 1; c.block[0][3] = 0;
  734.     c.block[1][0] = 0; c.block[1][1] = 0; c.block[1][2] = 1; c.block[1][3] = 0;
  735.     c.block[2][0] = 0; c.block[2][1] = 1; c.block[2][2] = 1; c.block[2][3] = 0;
  736.     c.block[3][0] = 0; c.block[3][1] = 0; c.block[3][2] = 0; c.block[3][3] = 0;
  737.     c.Xlen = 4;
  738.     c.Ylen = 4;
  739.     //  {0,0,1,0}
  740.     //  {0,0,1,0}
  741.     //  {0,1,1,0}
  742.     //  {0,0,0,0}
  743.     //블록 형태지정 및 배열길이정보 입력
  744.  
  745.     for (i = 0; i < c.Xlen; i++)
  746.     {
  747.         for (j = 0; j < c.Ylen; j++)
  748.         {
  749.             if (pix[X + i][Y + j] >= 0)
  750.                 pix[X + i][Y + j] = c.block[i][j];
  751.         }
  752.     }//블록의 형태를 좌표에 삽입
  753.  
  754.     system("cls");
  755.     PrintAllScreen();
  756.  
  757.  
  758.  
  759.     for (; X < DOWN;)
  760.     {
  761.         if (_kbhit())
  762.         {
  763.             switch (_getch())
  764.             {
  765.             case DOWN:
  766.                 MoveDown(p, c);
  767.                 break;
  768.             case LEFT:
  769.                 MoveLeft(p, c);
  770.                 break;
  771.             case RIGHT:
  772.                 MoveRight(p, c);
  773.                 break;
  774.             case UP:
  775.                 Move4dTurn(p, c);
  776.                 break;
  777.             case SPACE:
  778.                 MoveSuperDown(p, c);
  779.                 break;
  780.             }
  781.         }
  782.  
  783.  
  784.         else if (CheckShockDown(p, c) == 1)     //바닥충돌검사 & 중력
  785.         {
  786.             for (i = 0; i < c.Xlen; i++)
  787.             {
  788.                 for (j = 0; j < c.Ylen; j++)
  789.                 {
  790.                     if (pix[X + i][Y + j] >= 0)
  791.                         pix[X + i][Y + j] = 0;
  792.                 }
  793.             }//블록 제거
  794.  
  795.             X++;
  796.  
  797.             for (i = 0; i < c.Xlen; i++)
  798.             {
  799.                 for (j = 0; j < c.Ylen; j++)
  800.                 {
  801.                     if (pix[X + i][Y + j] >= 0)
  802.                         pix[X + i][Y + j] = c.block[i][j];
  803.                 }
  804.             }//블록 한칸아래 생성
  805.  
  806.             Sleep(DELAY);//중력 딜레이
  807.             system("cls");
  808.             PrintAllScreen();
  809.         }
  810.         else
  811.         {
  812.             for (i = 0; i < c.Xlen; i++)
  813.             {
  814.                 for (j = 0; j < c.Ylen; j++)
  815.                 {
  816.                     if (pix[X + i][Y + j] == 1)
  817.                         pix[X + i][Y + j] = -2;
  818.                 }
  819.             }//블록 고정
  820.             break;
  821.         }
  822.     }//중력
  823.  
  824.     free(c.block[0]);
  825.     free(c.block[1]);
  826.     free(c.block[2]);
  827.     free(c.block[3]);
  828.     free(c.block);
  829.     free(p);
  830. }
  831. void MakeStickBlock(void)
  832. {
  833.     int i, j;
  834.     int turnSwap = 0;
  835.     XYPOS * p = (XYPOS*)malloc(sizeof(XYPOS) * 1);
  836.  
  837.     X = -4;
  838.     Y = 4; //좌표초기화
  839.  
  840.     Block c;
  841.     c.block = (int**)malloc(sizeof(int) * 4);
  842.     c.block[0] = (int*)malloc(sizeof(int) * 4);
  843.     c.block[1] = (int*)malloc(sizeof(int) * 4);
  844.     c.block[2] = (int*)malloc(sizeof(int) * 4);
  845.     c.block[3] = (int*)malloc(sizeof(int) * 4);//배열할당
  846.  
  847.     c.block[0][0] = 0; c.block[0][1] = 1; c.block[0][2] = 0; c.block[0][3] = 0;
  848.     c.block[1][0] = 0; c.block[1][1] = 1; c.block[1][2] = 0; c.block[1][3] = 0;
  849.     c.block[2][0] = 0; c.block[2][1] = 1; c.block[2][2] = 0; c.block[2][3] = 0;
  850.     c.block[3][0] = 0; c.block[3][1] = 1; c.block[3][2] = 0; c.block[3][3] = 0;
  851.     c.Xlen = 4;
  852.     c.Ylen = 4;
  853.     //  {0,1,0,0}
  854.     //  {0,1,0,0}
  855.     //  {0,1,0,0}
  856.     //  {0,1,0,0}
  857.     //블록 형태지정 및 배열길이정보 입력
  858.  
  859.     for (i = 0; i < c.Xlen; i++)
  860.     {
  861.         for (j = 0; j < c.Ylen; j++)
  862.         {
  863.             if (pix[X + i][Y + j] >= 0)
  864.                 pix[X + i][Y + j] = c.block[i][j];
  865.         }
  866.     }//블록의 형태를 좌표에 삽입
  867.  
  868.     system("cls");
  869.     PrintAllScreen();
  870.  
  871.  
  872.  
  873.     for (; X < DOWN;)
  874.     {
  875.         if (_kbhit())
  876.         {
  877.             switch (_getch())
  878.             {
  879.             case DOWN:
  880.                 MoveDown(p, c);
  881.                 break;
  882.             case LEFT:
  883.                 MoveLeft(p, c);
  884.                 break;
  885.             case RIGHT:
  886.                 MoveRight(p, c);
  887.                 break;
  888.             case UP:
  889.                 Move4dTurnSwap(p, c, &turnSwap);
  890.                 break;
  891.             case SPACE:
  892.                 MoveSuperDown(p, c);
  893.                 break;
  894.             }
  895.         }
  896.  
  897.  
  898.         else if (CheckShockDown(p, c) == 1)     //바닥충돌검사 & 중력
  899.         {
  900.             for (i = 0; i < c.Xlen; i++)
  901.             {
  902.                 for (j = 0; j < c.Ylen; j++)
  903.                 {
  904.                     if (pix[X + i][Y + j] >= 0)
  905.                         pix[X + i][Y + j] = 0;
  906.                 }
  907.             }//블록 제거
  908.  
  909.             X++;
  910.  
  911.             for (i = 0; i < c.Xlen; i++)
  912.             {
  913.                 for (j = 0; j < c.Ylen; j++)
  914.                 {
  915.                     if (pix[X + i][Y + j] >= 0)
  916.                         pix[X + i][Y + j] = c.block[i][j];
  917.                 }
  918.             }//블록 한칸아래 생성
  919.  
  920.             Sleep(DELAY);//중력 딜레이
  921.             system("cls");
  922.             PrintAllScreen();
  923.         }
  924.         else
  925.         {
  926.             for (i = 0; i < c.Xlen; i++)
  927.             {
  928.                 for (j = 0; j < c.Ylen; j++)
  929.                 {
  930.                     if (pix[X + i][Y + j] == 1)
  931.                         pix[X + i][Y + j] = -2;
  932.                 }
  933.             }//블록 고정
  934.             break;
  935.         }
  936.     }//중력
  937.  
  938.     free(c.block[0]);
  939.     free(c.block[1]);
  940.     free(c.block[2]);
  941.     free(c.block[3]);
  942.     free(c.block);
  943.     free(p);
  944. }
  945.  
  946.  
  947.  
  948.  
  949.  
  950. #include "Header.h"
  951. #include "Printfunc.h"
  952. #include "CheckShock.h"
  953.  
  954. void MoveSuperDown(XYPOS* p, Block block)
  955. {
  956.     int downPoint = CheckShockSuperDown(p, block);
  957.     int i, j;
  958.  
  959.     if (downPoint > 0)
  960.     {
  961.         for (i = 0; i < block.Xlen; i++)
  962.         {
  963.             for (j = 0; j < block.Ylen; j++)
  964.             {
  965.                 if (pix[X + i][Y + j] >= 0)
  966.                     pix[X + i][Y + j] = 0;
  967.             }
  968.         }//블록 제거
  969.  
  970.         X += downPoint;
  971.  
  972.         for (i = 0; i < block.Xlen; i++)
  973.         {
  974.             for (j = 0; j < block.Ylen; j++)
  975.             {
  976.                 if (pix[X + i][Y + j] >= 0)
  977.                     pix[X + i][Y + j] = block.block[i][j];
  978.             }
  979.         }//블록 완전 낙하
  980.     }
  981.     else
  982.         return;
  983.  
  984.     system("cls");
  985.     PrintAllScreen();
  986.     return;
  987. }
  988. void MoveDown(XYPOS* p, Block block)
  989. {
  990.     if (CheckShockDown(p, block) == 1)
  991.     {
  992.         int i, j;
  993.         for (i = 0; i < block.Xlen; i++)
  994.         {
  995.             for (j = 0; j < block.Ylen; j++)
  996.             {
  997.                 if (pix[X + i][Y + j] >= 0)
  998.                     pix[X + i][Y + j] = 0;
  999.             }
  1000.         }//블록 제거
  1001.  
  1002.         X++;
  1003.  
  1004.         for (i = 0; i < block.Xlen; i++)
  1005.         {
  1006.             for (j = 0; j < block.Ylen; j++)
  1007.             {
  1008.                 if (pix[X + i][Y + j] >= 0)
  1009.                     pix[X + i][Y + j] = block.block[i][j];
  1010.             }
  1011.         }//블록 한칸아래 생성
  1012.     }
  1013.     else
  1014.         return;
  1015.  
  1016.     system("cls");
  1017.     PrintAllScreen();
  1018.     return;
  1019. }
  1020. void MoveLeft(XYPOS* p, Block block)
  1021. {
  1022.     int i, j;
  1023.  
  1024.     if (CheckShockLeft(p, block) == 1)
  1025.     {
  1026.         for (i = 0; i < block.Xlen; i++)
  1027.         {
  1028.             for (j = 0; j < block.Ylen; j++)
  1029.             {
  1030.                 if (pix[X + i][Y + j] >= 0)
  1031.                     pix[X + i][Y + j] = 0;
  1032.             }
  1033.         }//블록 제거
  1034.  
  1035.         Y--;
  1036.  
  1037.         for (i = 0; i < block.Xlen; i++)
  1038.         {
  1039.             for (j = 0; j < block.Ylen; j++)
  1040.             {
  1041.                 if (pix[X + i][Y + j] >= 0)
  1042.                     pix[X + i][Y + j] = block.block[i][j];
  1043.             }
  1044.         }//블록 한칸아래 생성
  1045.     }
  1046.     else
  1047.         return;
  1048.  
  1049.     system("cls");
  1050.     PrintAllScreen();
  1051.     return;
  1052. }
  1053. void MoveRight(XYPOS* p, Block block)
  1054. {
  1055.     int i, j;
  1056.  
  1057.     if (CheckShockRight(p, block) == 1)
  1058.     {
  1059.         for (i = 0; i < block.Xlen; i++)
  1060.         {
  1061.             for (j = 0; j < block.Ylen; j++)
  1062.             {
  1063.                 if (pix[X + i][Y + j] >= 0)
  1064.                     pix[X + i][Y + j] = 0;
  1065.             }
  1066.         }//블록 제거
  1067.  
  1068.         Y++;
  1069.  
  1070.         for (i = 0; i < block.Xlen; i++)
  1071.         {
  1072.             for (j = 0; j < block.Ylen; j++)
  1073.             {
  1074.                 if (pix[X + i][Y + j] >= 0)
  1075.                     pix[X + i][Y + j] = block.block[i][j];
  1076.             }
  1077.         }//블록 한칸아래 생성
  1078.     }
  1079.     else
  1080.         return;
  1081.  
  1082.     system("cls");
  1083.     PrintAllScreen();
  1084.     return;
  1085. }
  1086. void Move3dTurn(XYPOS* p, Block block)
  1087. {
  1088.     int i, j;
  1089.     int temp[3][3];
  1090.  
  1091.     //임시블록 생성
  1092.  
  1093.     if (CheckShockTurn(p, block) == 1)
  1094.     {
  1095.         for (i = 0; i < block.Xlen; i++)
  1096.         {
  1097.             for (j = 0; j < block.Ylen; j++)
  1098.             {
  1099.                 if (pix[X + i][Y + j] >= 0)
  1100.                     pix[X + i][Y + j] = 0;
  1101.             }
  1102.         }//블록 제거
  1103.  
  1104.         for (i = 0; i < block.Xlen; i++)
  1105.         {
  1106.             for (j = 0; j < block.Ylen; j++)
  1107.             {
  1108.                 temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1109.             }
  1110.         }
  1111.         for (i = 0; i < block.Xlen; i++)
  1112.         {
  1113.             for (j = 0; j < block.Ylen; j++)
  1114.             {
  1115.                 block.block[i][j] = temp[i][j];
  1116.                 if (pix[X + i][Y + j] >= 0)
  1117.                     pix[X + i][Y + j] = block.block[i][j];
  1118.             }
  1119.         }//블록 회전
  1120.     }
  1121.     else if (CheckShockLeftTurn(p, block) == 1) //왼쪽으로 이동후 회전가능한가?
  1122.     {
  1123.         for (i = 0; i < block.Xlen; i++)
  1124.         {
  1125.             for (j = 0; j < block.Ylen; j++)
  1126.             {
  1127.                 if (pix[X + i][Y + j] >= 0)
  1128.                     pix[X + i][Y + j] = 0;
  1129.             }
  1130.         }//블록 제거
  1131.  
  1132.         for (i = 0; i < block.Xlen; i++)
  1133.         {
  1134.             for (j = 0; j < block.Ylen; j++)
  1135.             {
  1136.                 temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1137.             }
  1138.         }
  1139.         for (i = 0; i < block.Xlen; i++)
  1140.         {
  1141.             for (j = 0; j < block.Ylen; j++)
  1142.             {
  1143.                 block.block[i][j] = temp[i][j];
  1144.                 if (pix[X + i][Y + j] >= 0)
  1145.                     pix[X + i][Y + j] = block.block[i][j];
  1146.             }
  1147.         }//블록 회전
  1148.     }
  1149.  
  1150.     else if (CheckShockRightTurn(p, block) == 1)//오른쪽으로 이동후 회전가능한가?
  1151.     {
  1152.         for (i = 0; i < block.Xlen; i++)
  1153.         {
  1154.             for (j = 0; j < block.Ylen; j++)
  1155.             {
  1156.                 if (pix[X + i][Y + j] >= 0)
  1157.                     pix[X + i][Y + j] = 0;
  1158.             }
  1159.         }//블록 제거
  1160.  
  1161.         for (i = 0; i < block.Xlen; i++)
  1162.         {
  1163.             for (j = 0; j < block.Ylen; j++)
  1164.             {
  1165.                 temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1166.             }
  1167.         }
  1168.         for (i = 0; i < block.Xlen; i++)
  1169.         {
  1170.             for (j = 0; j < block.Ylen; j++)
  1171.             {
  1172.                 block.block[i][j] = temp[i][j];
  1173.                 if (pix[X + i][Y + j] >= 0)
  1174.                     pix[X + i][Y + j] = block.block[i][j];
  1175.             }
  1176.         }//블록 회전
  1177.     }
  1178.     else
  1179.         return;
  1180.  
  1181.     system("cls");
  1182.     PrintAllScreen();
  1183.     return;
  1184. }
  1185. void Move3dTurnSwap(XYPOS* p, Block block, int* swap)
  1186. {
  1187.     int i, j;
  1188.     int temp[3][3];
  1189.  
  1190.     //임시블록 생성
  1191.  
  1192.     if (CheckShockTurn(p, block) == 1)
  1193.     {
  1194.         for (i = 0; i < block.Xlen; i++)
  1195.         {
  1196.             for (j = 0; j < block.Ylen; j++)
  1197.             {
  1198.                 if (pix[X + i][Y + j] >= 0)
  1199.                     pix[X + i][Y + j] = 0;
  1200.             }
  1201.         }//블록 제거
  1202.  
  1203.         if (*swap == 0)//값이 0이면 시계방향 회전
  1204.         {
  1205.             for (i = 0; i < block.Xlen; i++)
  1206.             {
  1207.                 for (j = 0; j < block.Ylen; j++)
  1208.                 {
  1209.                     temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1210.                 }
  1211.             }
  1212.             for (i = 0; i < block.Xlen; i++)
  1213.             {
  1214.                 for (j = 0; j < block.Ylen; j++)
  1215.                 {
  1216.                     block.block[i][j] = temp[i][j];
  1217.                     if (pix[X + i][Y + j] >= 0)
  1218.                         pix[X + i][Y + j] = block.block[i][j];
  1219.                 }
  1220.             }
  1221.             *swap = 1;//회전 후 스왑해줌
  1222.         }//블록 회전
  1223.  
  1224.         else//swap!=0이면 반시계 회전
  1225.         {
  1226.             for (i = 0; i < block.Xlen; i++)
  1227.             {
  1228.                 for (j = 0; j < block.Ylen; j++)
  1229.                 {
  1230.                     temp[j][i] = block.block[i][(block.Xlen - 1) - j];
  1231.                 }
  1232.             }
  1233.             for (i = 0; i < block.Xlen; i++)
  1234.             {
  1235.                 for (j = 0; j < block.Ylen; j++)
  1236.                 {
  1237.                     block.block[i][j] = temp[i][j];
  1238.                     if (pix[X + i][Y + j] >= 0)
  1239.                         pix[X + i][Y + j] = block.block[i][j];
  1240.                 }
  1241.             }
  1242.             *swap = 0;//회전 후 스왑해줌
  1243.         }
  1244.     }
  1245.     else if (CheckShockLeftTurn(p, block) == 1) //왼쪽으로 이동후 회전가능한가?
  1246.     {
  1247.         for (i = 0; i < block.Xlen; i++)
  1248.         {
  1249.             for (j = 0; j < block.Ylen; j++)
  1250.             {
  1251.                 if (pix[X + i][Y + j] >= 0)
  1252.                     pix[X + i][Y + j] = 0;
  1253.             }
  1254.         }//블록 제거
  1255.  
  1256.         if (*swap == 0)//값이 0이면 시계방향 회전
  1257.         {
  1258.             for (i = 0; i < block.Xlen; i++)
  1259.             {
  1260.                 for (j = 0; j < block.Ylen; j++)
  1261.                 {
  1262.                     temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1263.                 }
  1264.             }
  1265.             for (i = 0; i < block.Xlen; i++)
  1266.             {
  1267.                 for (j = 0; j < block.Ylen; j++)
  1268.                 {
  1269.                     block.block[i][j] = temp[i][j];
  1270.                     if (pix[X + i][Y + j] >= 0)
  1271.                         pix[X + i][Y + j] = block.block[i][j];
  1272.                 }
  1273.             }
  1274.             *swap = 1;//회전 후 스왑해줌
  1275.         }//블록 회전
  1276.  
  1277.         else//swap!=0이면 반시계 회전
  1278.         {
  1279.             for (i = 0; i < block.Xlen; i++)
  1280.             {
  1281.                 for (j = 0; j < block.Ylen; j++)
  1282.                 {
  1283.                     temp[j][i] = block.block[i][(block.Xlen - 1) - j];
  1284.                 }
  1285.             }
  1286.             for (i = 0; i < block.Xlen; i++)
  1287.             {
  1288.                 for (j = 0; j < block.Ylen; j++)
  1289.                 {
  1290.                     block.block[i][j] = temp[i][j];
  1291.                     if (pix[X + i][Y + j] >= 0)
  1292.                         pix[X + i][Y + j] = block.block[i][j];
  1293.                 }
  1294.             }
  1295.             *swap = 0;//회전 후 스왑해줌
  1296.         }
  1297.     }
  1298.  
  1299.     else if (CheckShockRightTurn(p, block) == 1)//오른쪽으로 이동후 회전가능한가?
  1300.     {
  1301.         for (i = 0; i < block.Xlen; i++)
  1302.         {
  1303.             for (j = 0; j < block.Ylen; j++)
  1304.             {
  1305.                 if (pix[X + i][Y + j] >= 0)
  1306.                     pix[X + i][Y + j] = 0;
  1307.             }
  1308.         }//블록 제거
  1309.  
  1310.         if (*swap == 0)//값이 0이면 시계방향 회전
  1311.         {
  1312.             for (i = 0; i < block.Xlen; i++)
  1313.             {
  1314.                 for (j = 0; j < block.Ylen; j++)
  1315.                 {
  1316.                     temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1317.                 }
  1318.             }
  1319.             for (i = 0; i < block.Xlen; i++)
  1320.             {
  1321.                 for (j = 0; j < block.Ylen; j++)
  1322.                 {
  1323.                     block.block[i][j] = temp[i][j];
  1324.                     if (pix[X + i][Y + j] >= 0)
  1325.                         pix[X + i][Y + j] = block.block[i][j];
  1326.                 }
  1327.             }
  1328.             *swap = 1;//회전 후 스왑해줌
  1329.         }//블록 회전
  1330.  
  1331.         else//swap!=0이면 반시계 회전
  1332.         {
  1333.             for (i = 0; i < block.Xlen; i++)
  1334.             {
  1335.                 for (j = 0; j < block.Ylen; j++)
  1336.                 {
  1337.                     temp[j][i] = block.block[i][(block.Xlen - 1) - j];
  1338.                 }
  1339.             }
  1340.             for (i = 0; i < block.Xlen; i++)
  1341.             {
  1342.                 for (j = 0; j < block.Ylen; j++)
  1343.                 {
  1344.                     block.block[i][j] = temp[i][j];
  1345.                     if (pix[X + i][Y + j] >= 0)
  1346.                         pix[X + i][Y + j] = block.block[i][j];
  1347.                 }
  1348.             }
  1349.             *swap = 0;//회전 후 스왑해줌
  1350.         }
  1351.     }
  1352.     else
  1353.         return;
  1354.  
  1355.     system("cls");
  1356.     PrintAllScreen();
  1357.     return;
  1358. }
  1359. void Move4dTurn(XYPOS* p, Block block)
  1360. {
  1361.     int i, j;
  1362.     int temp[4][4];
  1363.     int movePoint;
  1364.  
  1365.     //임시블록 생성
  1366.  
  1367.     if (CheckShockTurn(p, block) == 1)
  1368.     {
  1369.         for (i = 0; i < block.Xlen; i++)
  1370.         {
  1371.             for (j = 0; j < block.Ylen; j++)
  1372.             {
  1373.                 if (pix[X + i][Y + j] >= 0)
  1374.                     pix[X + i][Y + j] = 0;
  1375.             }
  1376.         }//블록 제거
  1377.  
  1378.         for (i = 0; i < block.Xlen; i++)
  1379.         {
  1380.             for (j = 0; j < block.Ylen; j++)
  1381.             {
  1382.                 temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1383.             }
  1384.         }
  1385.         for (i = 0; i < block.Xlen; i++)
  1386.         {
  1387.             for (j = 0; j < block.Ylen; j++)
  1388.             {
  1389.                 block.block[i][j] = temp[i][j];
  1390.                 if (pix[X + i][Y + j] >= 0)
  1391.                     pix[X + i][Y + j] = block.block[i][j];
  1392.             }
  1393.         }//회전
  1394.     }
  1395.     else if ((movePoint = CheckShock4dLeftTurn(p, block)) > 0) //왼쪽으로 이동후 회전가능한가?
  1396.     {
  1397.         for (i = 0; i < block.Xlen; i++)
  1398.         {
  1399.             for (j = 0; j < block.Ylen; j++)
  1400.             {
  1401.                 if (pix[X + i][Y + j] >= 0)
  1402.                     pix[X + i][Y + j] = 0;
  1403.             }
  1404.         }//블록 제거
  1405.  
  1406.         Y -= movePoint;
  1407.  
  1408.         for (i = 0; i < block.Xlen; i++)
  1409.         {
  1410.             for (j = 0; j < block.Ylen; j++)
  1411.             {
  1412.                 temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1413.             }
  1414.         }
  1415.         for (i = 0; i < block.Xlen; i++)
  1416.         {
  1417.             for (j = 0; j < block.Ylen; j++)
  1418.             {
  1419.                 block.block[i][j] = temp[i][j];
  1420.                 if (pix[X + i][Y + j] >= 0)
  1421.                     pix[X + i][Y + j] = block.block[i][j];
  1422.             }
  1423.         }//회전
  1424.     }
  1425.  
  1426.     else if ((movePoint = CheckShock4dRightTurn(p, block)) > 0) //왼쪽으로 이동후 회전가능한가?
  1427.     {
  1428.         for (i = 0; i < block.Xlen; i++)
  1429.         {
  1430.             for (j = 0; j < block.Ylen; j++)
  1431.             {
  1432.                 if (pix[X + i][Y + j] >= 0)
  1433.                     pix[X + i][Y + j] = 0;
  1434.             }
  1435.         }//블록 제거
  1436.  
  1437.         Y += movePoint;
  1438.  
  1439.         for (i = 0; i < block.Xlen; i++)
  1440.         {
  1441.             for (j = 0; j < block.Ylen; j++)
  1442.             {
  1443.                 temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1444.             }
  1445.         }
  1446.         for (i = 0; i < block.Xlen; i++)
  1447.         {
  1448.             for (j = 0; j < block.Ylen; j++)
  1449.             {
  1450.                 block.block[i][j] = temp[i][j];
  1451.                 if (pix[X + i][Y + j] >= 0)
  1452.                     pix[X + i][Y + j] = block.block[i][j];
  1453.             }
  1454.         }//회전
  1455.     }
  1456.     else
  1457.         return;
  1458.  
  1459.     system("cls");
  1460.     PrintAllScreen();
  1461.     return;
  1462. }
  1463. void Move4dTurnSwap(XYPOS* p, Block block, int* swap)
  1464. {
  1465.     int i, j;
  1466.     int temp[4][4];
  1467.     int movePoint;
  1468.  
  1469.     //임시블록 생성
  1470.  
  1471.     if (CheckShockTurn(p, block) == 1)
  1472.     {
  1473.         for (i = 0; i < block.Xlen; i++)
  1474.         {
  1475.             for (j = 0; j < block.Ylen; j++)
  1476.             {
  1477.                 if (pix[X + i][Y + j] >= 0)
  1478.                     pix[X + i][Y + j] = 0;
  1479.             }
  1480.         }//블록 제거
  1481.  
  1482.         if (*swap == 0)//값이 0이면 시계방향 회전
  1483.         {
  1484.             for (i = 0; i < block.Xlen; i++)
  1485.             {
  1486.                 for (j = 0; j < block.Ylen; j++)
  1487.                 {
  1488.                     temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1489.                 }
  1490.             }
  1491.             for (i = 0; i < block.Xlen; i++)
  1492.             {
  1493.                 for (j = 0; j < block.Ylen; j++)
  1494.                 {
  1495.                     block.block[i][j] = temp[i][j];
  1496.                     if (pix[X + i][Y + j] >= 0)
  1497.                         pix[X + i][Y + j] = block.block[i][j];
  1498.                 }
  1499.             }
  1500.             *swap = 1;//회전 후 스왑해줌
  1501.         }//블록 회전
  1502.  
  1503.         else//swap!=0이면 반시계 회전
  1504.         {
  1505.             for (i = 0; i < block.Xlen; i++)
  1506.             {
  1507.                 for (j = 0; j < block.Ylen; j++)
  1508.                 {
  1509.                     temp[j][i] = block.block[i][(block.Xlen - 1) - j];
  1510.                 }
  1511.             }
  1512.             for (i = 0; i < block.Xlen; i++)
  1513.             {
  1514.                 for (j = 0; j < block.Ylen; j++)
  1515.                 {
  1516.                     block.block[i][j] = temp[i][j];
  1517.                     if (pix[X + i][Y + j] >= 0)
  1518.                         pix[X + i][Y + j] = block.block[i][j];
  1519.                 }
  1520.             }
  1521.             *swap = 0;//회전 후 스왑해줌
  1522.         }
  1523.     }
  1524.     else if ((movePoint = CheckShock4dLeftTurn(p, block)) > 0) //왼쪽으로 이동후 회전가능한가?
  1525.     {
  1526.         for (i = 0; i < block.Xlen; i++)
  1527.         {
  1528.             for (j = 0; j < block.Ylen; j++)
  1529.             {
  1530.                 if (pix[X + i][Y + j] >= 0)
  1531.                     pix[X + i][Y + j] = 0;
  1532.             }
  1533.         }//블록 제거
  1534.  
  1535.         Y -= movePoint;
  1536.  
  1537.         if (*swap == 0)//값이 0이면 시계방향 회전
  1538.         {
  1539.             for (i = 0; i < block.Xlen; i++)
  1540.             {
  1541.                 for (j = 0; j < block.Ylen; j++)
  1542.                 {
  1543.                     temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1544.                 }
  1545.             }
  1546.             for (i = 0; i < block.Xlen; i++)
  1547.             {
  1548.                 for (j = 0; j < block.Ylen; j++)
  1549.                 {
  1550.                     block.block[i][j] = temp[i][j];
  1551.                     if (pix[X + i][Y + j] >= 0)
  1552.                         pix[X + i][Y + j] = block.block[i][j];
  1553.                 }
  1554.             }
  1555.             *swap = 1;//회전 후 스왑해줌
  1556.         }//블록 회전
  1557.  
  1558.         else//swap!=0이면 반시계 회전
  1559.         {
  1560.             for (i = 0; i < block.Xlen; i++)
  1561.             {
  1562.                 for (j = 0; j < block.Ylen; j++)
  1563.                 {
  1564.                     temp[j][i] = block.block[i][(block.Xlen - 1) - j];
  1565.                 }
  1566.             }
  1567.             for (i = 0; i < block.Xlen; i++)
  1568.             {
  1569.                 for (j = 0; j < block.Ylen; j++)
  1570.                 {
  1571.                     block.block[i][j] = temp[i][j];
  1572.                     if (pix[X + i][Y + j] >= 0)
  1573.                         pix[X + i][Y + j] = block.block[i][j];
  1574.                 }
  1575.             }
  1576.             *swap = 0;//회전 후 스왑해줌
  1577.         }
  1578.     }
  1579.  
  1580.     else if ((movePoint = CheckShock4dRightTurn(p, block)) > 0) //왼쪽으로 이동후 회전가능한가?
  1581.     {
  1582.         for (i = 0; i < block.Xlen; i++)
  1583.         {
  1584.             for (j = 0; j < block.Ylen; j++)
  1585.             {
  1586.                 if (pix[X + i][Y + j] >= 0)
  1587.                     pix[X + i][Y + j] = 0;
  1588.             }
  1589.         }//블록 제거
  1590.  
  1591.         Y += movePoint;
  1592.  
  1593.         if (*swap == 0)//값이 0이면 시계방향 회전
  1594.         {
  1595.             for (i = 0; i < block.Xlen; i++)
  1596.             {
  1597.                 for (j = 0; j < block.Ylen; j++)
  1598.                 {
  1599.                     temp[j][i] = block.block[(block.Xlen - 1) - i][j];
  1600.                 }
  1601.             }
  1602.             for (i = 0; i < block.Xlen; i++)
  1603.             {
  1604.                 for (j = 0; j < block.Ylen; j++)
  1605.                 {
  1606.                     block.block[i][j] = temp[i][j];
  1607.                     if (pix[X + i][Y + j] >= 0)
  1608.                         pix[X + i][Y + j] = block.block[i][j];
  1609.                 }
  1610.             }
  1611.             *swap = 1;//회전 후 스왑해줌
  1612.         }//블록 회전
  1613.  
  1614.         else//swap!=0이면 반시계 회전
  1615.         {
  1616.             for (i = 0; i < block.Xlen; i++)
  1617.             {
  1618.                 for (j = 0; j < block.Ylen; j++)
  1619.                 {
  1620.                     temp[j][i] = block.block[i][(block.Xlen - 1) - j];
  1621.                 }
  1622.             }
  1623.             for (i = 0; i < block.Xlen; i++)
  1624.             {
  1625.                 for (j = 0; j < block.Ylen; j++)
  1626.                 {
  1627.                     block.block[i][j] = temp[i][j];
  1628.                     if (pix[X + i][Y + j] >= 0)
  1629.                         pix[X + i][Y + j] = block.block[i][j];
  1630.                 }
  1631.             }
  1632.             *swap = 0;//회전 후 스왑해줌
  1633.         }
  1634.     }
  1635.     else
  1636.         return;
  1637.  
  1638.     system("cls");
  1639.     PrintAllScreen();
  1640.     return;
  1641. }
  1642.  
  1643.  
  1644.  
  1645. #include "Header.h"
  1646.  
  1647. void InitializeScreen(void)
  1648. {
  1649.     int i, j;
  1650.     for (i = 0; i < 22; i++)
  1651.     {
  1652.         for (j = 0; j < 12; j++)
  1653.         {
  1654.             pix[i][j] = -1;
  1655.         }
  1656.     }
  1657.  
  1658.     for (i = 0; i < 20; i++)
  1659.     {
  1660.         for (j = 1; j < 11; j++)
  1661.         {
  1662.             pix[i][j] = 0;
  1663.         }
  1664.     }
  1665. }
  1666. void PrintAllScreen(void)
  1667. {
  1668.     int i, j;
  1669.     for (i = 0; i < 22; i++)
  1670.     {
  1671.         for (j = 0; j < 12; j++)
  1672.         {
  1673.             switch (pix[i][j])
  1674.             {
  1675.             case -2:
  1676.                 fputs("■", stdout);
  1677.                 break;
  1678.             case -1:
  1679.                 fputs("▩", stdout);
  1680.                 break;
  1681.             case 0:
  1682.                 fputs("　", stdout);
  1683.                 break;
  1684.             case 1:
  1685.                 fputs("▣", stdout);
  1686.                 break;
  1687.             }
  1688.         }
  1689.         putchar('\n');
  1690.     }
  1691. }
  1692. void DeleteLine(void)
  1693. {
  1694.     int i, j;
  1695.     int ILimit;
  1696.  
  1697.     for (i = 0; i < FLOOR_BOUND; i++)
  1698.     {
  1699.         if (pix[i][1] < 0 && pix[i][2] < 0 && pix[i][3] < 0 && pix[i][4] < 0 && pix[i][5] < 0 &&
  1700.             pix[i][6] < 0 && pix[i][7] < 0 && pix[i][8] < 0 && pix[i][9] < 0 && pix[i][10] < 0)
  1701.         {
  1702.             ILimit = i;
  1703.  
  1704.             for (i = ILimit - 1; i >= 0; i--)
  1705.             {
  1706.                 for (j = 1; j < RIGHT_BOUND; j++)
  1707.                 {
  1708.                     pix[i + 1][j] = pix[i][j];
  1709.                 }
  1710.             }
  1711.  
  1712.             for (j = 1; j < RIGHT_BOUND; j++)
  1713.                 pix[0][j] = 0;
  1714.         }
  1715.     }//라인이 전부 마이너스값(블록이 있는공간)인지 확인
  1716. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!