API tools faq
paste
Advertisement
orneto

quebracabeça 3x3 :)

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