API tools faq
paste
Advertisement
orneto

quebracabeça 3x3 :)

orneto
Oct 30th, 2018
197
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.48 KB | None | 0 0
raw download clone embed print report
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <windows.h>
  4. #include <conio.h>
  5. #include <string.h>
  6.  
  7. #define cima 72
  8. #define baixo 80
  9. #define esquerda 75
  10. #define direita 77
  11.  
  12. void gotoxy(int lin, int col){
  13.     HANDLE Saida;
  14.  
  15.     COORD Posicao;
  16.  
  17.     Saida = GetStdHandle(STD_OUTPUT_HANDLE);
  18.  
  19.     Posicao.X = col;
  20.     Posicao.Y = lin;
  21.  
  22.     SetConsoleCursorPosition(Saida, Posicao);
  23.  
  24. }
  25. int controle()
  26. {
  27.     int c = 224;
  28.     while(c>5)
  29.     {
  30.         while(c==224){
  31.             c=getch();
  32.         }
  33.         switch(c) {
  34.         case cima: //seta para cima
  35.             c = 1;
  36.             break;
  37.         case baixo: //seta para baixo
  38.             c = 2;
  39.             break;
  40.         case esquerda: //seta para esquerda
  41.             c = 3;
  42.             break;
  43.         case direita: // seta para direita
  44.             c = 4;
  45.             break;
  46.         default:
  47.             gotoxy(12,7);
  48.             printf("use as setas!      ");
  49.             c=224;
  50.             break;
  51.         }
  52.     }
  53.     return c;
  54. }
  55.  
  56. void acha_peca(int &l, int &c, char valor[3][3]){
  57.     int i=0, a, b;
  58.     for (a = 0; a<3; a++){
  59.         for(b = 0; b < 3; b++){
  60.             if(valor[a][b] == ' '){
  61.                 l = a;
  62.                 c = b;
  63.             }
  64.         }
  65.     }
  66. }
  67. int checkagem(char var[3][3]){
  68.     int a, b, d = 0, pontos=0;
  69.     char correto[9] = {'1','2','3','4','5','6','7','8',' '};
  70.     for (a=0; a<3; a++){
  71.         for(b=0; b <3; b++){
  72.             if(var[a][b] == correto[d]){
  73.                 pontos++;
  74.             }
  75.             d++;
  76.         }
  77.     }
  78.     if(pontos==9){
  79.         a=1;
  80.     }
  81.     else{
  82.         a=0;
  83.     }
  84.     return a;
  85. }
  86. void preencher_tabuleiro(char (&var)[3][3]){
  87.     int a, b, d = 0;
  88.     char fase[9] = {'3','2','6','5','1','7','8',' ','4'};
  89.     for (a=0; a<3; a++){
  90.         for(b=0; b <3; b++){
  91.             var[a][b] = fase[d];
  92.             d++;
  93.         }
  94.     }
  95. }
  96. void mover_peca(char (&tabuleiro)[3][3], int i, int j){
  97.     int a, b=0;
  98.     char aux1, aux2;
  99.     while(b==0){
  100.         if(i==0 and j==0){
  101.                 a=controle();
  102.                 switch(a){
  103.                     case 2:
  104.                         aux1=tabuleiro[i][j];
  105.                         aux2=tabuleiro[i+1][j];
  106.                         tabuleiro[i][j]=aux2;
  107.                         tabuleiro[i+1][j]=aux1;
  108.                         gotoxy(12,7);
  109.                         printf("                    ");
  110.                         b=1;
  111.                         break;
  112.                     case 4:
  113.                         aux1=tabuleiro[i][j];
  114.                         aux2=tabuleiro[i][j+1];
  115.                         tabuleiro[i][j]=aux2;
  116.                         tabuleiro[i][j+1]=aux1;
  117.                         gotoxy(12,7);
  118.                         printf(" ");
  119.                         b=1;
  120.                         break;
  121.                     default:
  122.                         gotoxy(12,7);
  123.                         printf("movimento invalido!");
  124.                         break;
  125.                 }
  126.         }
  127.         if(i==0 and j==2){
  128.                 a=controle();
  129.                 switch(a){
  130.                     case 2:
  131.                         aux1=tabuleiro[i][j];
  132.                         aux2=tabuleiro[i+1][j];
  133.                         tabuleiro[i][j]=aux2;
  134.                         tabuleiro[i+1][j]=aux1;
  135.                         gotoxy(12,7);
  136.                         printf("                    ");
  137.                         b=1;
  138.                         break;
  139.                     case 3:
  140.                         aux1=tabuleiro[i][j];
  141.                         aux2=tabuleiro[i][j-1];
  142.                         tabuleiro[i][j]=aux2;
  143.                         tabuleiro[i][j-1]=aux1;
  144.                         gotoxy(12,7);
  145.                         printf("                    ");
  146.                         b=1;
  147.                         break;
  148.                     default:
  149.                         gotoxy(12,7);
  150.                         printf("movimento invalido!");
  151.                         break;
  152.                 }
  153.         }
  154.         if(i==2 and j==2){
  155.                 a=controle();
  156.                 switch(a){
  157.                     case 1:
  158.                         aux1=tabuleiro[i][j];
  159.                         aux2=tabuleiro[i-1][j];
  160.                         tabuleiro[i][j]=aux2;
  161.                         tabuleiro[i-1][j]=aux1;
  162.                         gotoxy(12,7);
  163.                         printf("                    ");
  164.                         b=1;
  165.                         break;
  166.                     case 3:
  167.                         aux1=tabuleiro[i][j];
  168.                         aux2=tabuleiro[i][j-1];
  169.                         tabuleiro[i][j]=aux2;
  170.                         tabuleiro[i][j-1]=aux1;
  171.                         gotoxy(12,7);
  172.                         printf("                    ");
  173.                         b=1;
  174.                         break;
  175.                     default:
  176.                         gotoxy(12,7);
  177.                         printf("movimento invalido!");
  178.                         break;
  179.                 }
  180.         }
  181.         if(i==2 and j==0){
  182.                 a=controle();
  183.                 switch(a){
  184.                     case 1:
  185.                         aux1=tabuleiro[i][j];
  186.                         aux2=tabuleiro[i-1][j];
  187.                         tabuleiro[i][j]=aux2;
  188.                         tabuleiro[i-1][j]=aux1;
  189.                         gotoxy(12,7);
  190.                         printf("                    ");
  191.                         b=1;
  192.                         break;
  193.                     case 4:
  194.                         aux1=tabuleiro[i][j];
  195.                         aux2=tabuleiro[i][j+1];
  196.                         tabuleiro[i][j]=aux2;
  197.                         tabuleiro[i][j+1]=aux1;
  198.                         gotoxy(12,7);
  199.                         printf("                    ");
  200.                         b=1;
  201.                         break;
  202.                     default:
  203.                         gotoxy(12,7);
  204.                         printf("movimento invalido!");
  205.                         break;
  206.                 }
  207.         }
  208.         if(i==0 and j==1){
  209.                 a=controle();
  210.                 switch(a){
  211.                     case 2:
  212.                         aux1=tabuleiro[i][j];
  213.                         aux2=tabuleiro[i+1][j];
  214.                         tabuleiro[i][j]=aux2;
  215.                         tabuleiro[i+1][j]=aux1;
  216.                         gotoxy(12,7);
  217.                         printf("                    ");
  218.                         b=1;
  219.                         break;
  220.                     case 3:
  221.                         aux1=tabuleiro[i][j];
  222.                         aux2=tabuleiro[i][j-1];
  223.                         tabuleiro[i][j]=aux2;
  224.                         tabuleiro[i][j-1]=aux1;
  225.                         gotoxy(12,7);
  226.                         printf("                    ");
  227.                         b=1;
  228.                         break;
  229.                     case 4:
  230.                         aux1=tabuleiro[i][j];
  231.                         aux2=tabuleiro[i][j+1];
  232.                         tabuleiro[i][j]=aux2;
  233.                         tabuleiro[i][j+1]=aux1;
  234.                         gotoxy(12,7);
  235.                         printf("                    ");
  236.                         b=1;
  237.                         break;
  238.                     default:
  239.                         gotoxy(12,7);
  240.                         printf("movimento invalido!");
  241.                         break;
  242.                 }
  243.         }
  244.         if(i==2 and j==1){
  245.                 a=controle();
  246.                 switch(a){
  247.                     case 1:
  248.                         aux1=tabuleiro[i][j];
  249.                         aux2=tabuleiro[i-1][j];
  250.                         tabuleiro[i][j]=aux2;
  251.                         tabuleiro[i-1][j]=aux1;
  252.                         gotoxy(12,7);
  253.                         printf("                    ");
  254.                         b=1;
  255.                         break;
  256.                     case 3:
  257.                         aux1=tabuleiro[i][j];
  258.                         aux2=tabuleiro[i][j-1];
  259.                         tabuleiro[i][j]=aux2;
  260.                         tabuleiro[i][j-1]=aux1;
  261.                         gotoxy(12,7);
  262.                         printf("                    ");
  263.                         b=1;
  264.                         break;
  265.                     case 4:
  266.                         aux1=tabuleiro[i][j];
  267.                         aux2=tabuleiro[i][j+1];
  268.                         tabuleiro[i][j]=aux2;
  269.                         tabuleiro[i][j+1]=aux1;
  270.                         gotoxy(12,7);
  271.                         printf("                    ");
  272.                         b=1;
  273.                         break;
  274.                     default:
  275.                         gotoxy(12,7);
  276.                         printf("movimento invalido!");
  277.                         break;
  278.                 }
  279.         }
  280.         if(i==1 and j==0){
  281.                 a=controle();
  282.                 switch(a){
  283.                     case 1:
  284.                         aux1=tabuleiro[i][j];
  285.                         aux2=tabuleiro[i-1][j];
  286.                         tabuleiro[i][j]=aux2;
  287.                         tabuleiro[i-1][j]=aux1;
  288.                         gotoxy(12,7);
  289.                         printf("                    ");
  290.                         b=1;
  291.                         break;
  292.                     case 2:
  293.                         aux1=tabuleiro[i][j];
  294.                         aux2=tabuleiro[i+1][j];
  295.                         tabuleiro[i][j]=aux2;
  296.                         tabuleiro[i+1][j]=aux1;
  297.                         gotoxy(12,7);
  298.                         printf("                    ");
  299.                         b=1;
  300.                         break;
  301.                     case 4:
  302.                         aux1=tabuleiro[i][j];
  303.                         aux2=tabuleiro[i][j+1];
  304.                         tabuleiro[i][j]=aux2;
  305.                         tabuleiro[i][j+1]=aux1;
  306.                         gotoxy(12,7);
  307.                         printf("                    ");
  308.                         b=1;
  309.                         break;
  310.                     default:
  311.                         gotoxy(12,7);
  312.                         printf("movimento invalido!");
  313.                         break;
  314.                 }
  315.         }
  316.         if(i==1 and j==2){
  317.                 a=controle();
  318.                 switch(a){
  319.                     case 1:
  320.                         aux1=tabuleiro[i][j];
  321.                         aux2=tabuleiro[i-1][j];
  322.                         tabuleiro[i][j]=aux2;
  323.                         tabuleiro[i-1][j]=aux1;
  324.                         gotoxy(12,7);
  325.                         printf("                    ");
  326.                         b=1;
  327.                         break;
  328.                     case 2:
  329.                         aux1=tabuleiro[i][j];
  330.                         aux2=tabuleiro[i+1][j];
  331.                         tabuleiro[i][j]=aux2;
  332.                         tabuleiro[i+1][j]=aux1;
  333.                         gotoxy(12,7);
  334.                         printf("                    ");
  335.                         b=1;
  336.                         break;
  337.                     case 3:
  338.                         aux1=tabuleiro[i][j];
  339.                         aux2=tabuleiro[i][j-1];
  340.                         tabuleiro[i][j]=aux2;
  341.                         tabuleiro[i][j-1]=aux1;
  342.                         gotoxy(12,7);
  343.                         printf("                    ");
  344.                         b=1;
  345.                         break;
  346.                     default:
  347.                         gotoxy(12,7);
  348.                         printf("movimento invalido!");
  349.                         break;
  350.                 }
  351.         }
  352.         if(i==1 and j==1){
  353.             a=controle();
  354.                 switch(a){
  355.                     case 1:
  356.                         aux1=tabuleiro[i][j];
  357.                         aux2=tabuleiro[i-1][j];
  358.                         tabuleiro[i][j]=aux2;
  359.                         tabuleiro[i-1][j]=aux1;
  360.                         gotoxy(12,7);
  361.                         printf("                    ");
  362.                         b=1;
  363.                         break;
  364.                     case 2:
  365.                         aux1=tabuleiro[i][j];
  366.                         aux2=tabuleiro[i+1][j];
  367.                         tabuleiro[i][j]=aux2;
  368.                         tabuleiro[i+1][j]=aux1;
  369.                         gotoxy(12,7);
  370.                         printf("                    ");
  371.                         b=1;
  372.                         break;
  373.                     case 3:
  374.                         aux1=tabuleiro[i][j];
  375.                         aux2=tabuleiro[i][j-1];
  376.                         tabuleiro[i][j]=aux2;
  377.                         tabuleiro[i][j-1]=aux1;
  378.                         gotoxy(12,7);
  379.                         printf("                    ");
  380.                         b=1;
  381.                         break;
  382.                     case 4:
  383.                         aux1=tabuleiro[i][j];
  384.                         aux2=tabuleiro[i][j+1];
  385.                         tabuleiro[i][j]=aux2;
  386.                         tabuleiro[i][j+1]=aux1;
  387.                         gotoxy(12,7);
  388.                         printf("                    ");
  389.                         b=1;
  390.                         break;
  391.                 }
  392.  
  393.         }
  394.     }
  395. }
  396. void desenha_tabuleiro(int linha_inicial, int col_inicial, char val[3][3])// para o jogo QC8
  397. {
  398.     int l = linha_inicial;
  399.     int c = col_inicial;
  400.  
  401.     //desenha quadro
  402.     gotoxy(l,c);
  403.     printf("\332\304\304\304\302\304\304\304\302\304\304\304\277");
  404.     gotoxy(l+1,c);
  405.     printf("\263 %c \263 %c \263 %c \263", val[0][0], val[0][1], val[0][2]);
  406.     gotoxy(l+2,c);
  407.     printf("\303\304\304\304\305\304\304\304\305\304\304\304\264");
  408.     gotoxy(l+3,c);
  409.     printf("\263 %c \263 %c \263 %c \263", val[1][0], val[1][1], val[1][2]);
  410.     gotoxy(l+4,c);
  411.     printf("\303\304\304\304\305\304\304\304\305\304\304\304\264");
  412.     gotoxy(l+5,c);
  413.     printf("\263 %c \263 %c \263 %c \263", val[2][0], val[2][1], val[2][2]);
  414.     gotoxy(l+6,c);
  415.     printf("\300\304\304\304\301\304\304\304\301\304\304\304\331");
  416.  
  417. }
  418. int menu(){
  419.     char resposta;
  420.     int valor, repete=0;
  421.     gotoxy(2,3);
  422.     printf("Parabens Voce venceu! Jogar novamente(s/n): ");
  423.     while(repete==0){
  424.         resposta = getch();
  425.         switch(resposta){
  426.             case 's':
  427.                 valor=0;
  428.                 repete=1;
  429.                 gotoxy(2,3);
  430.                 printf("                                                ");
  431.                 gotoxy(3,5);
  432.                 printf("                                                ");
  433.                 break;
  434.             case 'n':
  435.                 valor=1;
  436.                 repete=1;
  437.                 break;
  438.             default:
  439.                 gotoxy(3,5);
  440.                 printf("responda com s ou n");
  441.         }
  442.     }
  443.     return valor;
  444. }
  445. void desenha_resultado(int linha_inicial, int col_inicial)// para o jogo QC8
  446. {
  447.     int l = linha_inicial;
  448.     int c = col_inicial;
  449.     int a, b, d = 0;
  450.     char val[3][3];
  451.     char vitoria[9] = {'1','2','3','4','5','6','7','8',' '};
  452.     for (a=0; a<3; a++){
  453.         for(b=0; b <3; b++){
  454.             val[a][b] = vitoria[d];
  455.             d++;
  456.         }
  457.     }
  458.     //desenha quadro
  459.     gotoxy(l,c);
  460.     printf("\332\304\304\304\302\304\304\304\302\304\304\304\277");
  461.     gotoxy(l+1,c);
  462.     printf("\263 %c \263 %c \263 %c \263", val[0][0], val[0][1], val[0][2]);
  463.     gotoxy(l+2,c);
  464.     printf("\303\304\304\304\305\304\304\304\305\304\304\304\264");
  465.     gotoxy(l+3,c);
  466.     printf("\263 %c \263 %c \263 %c \263", val[1][0], val[1][1], val[1][2]);
  467.     gotoxy(l+4,c);
  468.     printf("\303\304\304\304\305\304\304\304\305\304\304\304\264");
  469.     gotoxy(l+5,c);
  470.     printf("\263 %c \263 %c \263 %c \263", val[2][0], val[2][1], val[2][2]);
  471.     gotoxy(l+6,c);
  472.     printf("\300\304\304\304\301\304\304\304\301\304\304\304\331");
  473.  
  474. }
  475. int main()
  476. {
  477.     char num[3][3], resposta;
  478.     int coluna_0=0, linha_0=0;
  479.     char (*p)[3][3];
  480.     int *coluna_ponteiro;
  481.     int *linha_ponteiro;
  482.     int flag = 0;
  483.     p = &num;
  484.     int a, b, i = 0, jogar_novamente = 0;
  485.     coluna_ponteiro = &coluna_0;
  486.     linha_ponteiro = &linha_0;
  487.     while(jogar_novamente==0){
  488.     desenha_resultado(4,30);
  489.     preencher_tabuleiro((*p));
  490.     desenha_tabuleiro(4,10, num);
  491.         while(flag==0){
  492.             acha_peca(*linha_ponteiro, *coluna_ponteiro, num);
  493.             mover_peca(num, linha_0, coluna_0);
  494.             desenha_tabuleiro(4,10, num);
  495.             flag = checkagem(num);
  496.         }
  497.         jogar_novamente=menu();
  498.         coluna_0=0;
  499.         linha_0=0;
  500.         i = 0;
  501.         flag=0;
  502.     }
  503.     return 0;
  504. }
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!