/*
 * Jogo Paciência v0.1a
 *
 * Changes:
 *   v0.1a (30/05/2002): Primeira release.
 *
 * por:
 *      Fabiano (fabiano@seng.com.br)
 *
 * Borland Turbo C++ v3.0
 *
 * Controles:
 * Seta para esquerda -> Movimenta a posição para esquerda
 *  Seta para direita -> Movimenta a posição para direita
 *     Seta para cima -> Movimenta a posição para cima
 *    Seta para baixo -> Movimenta a posição para baixo
 *              ENTER -> Seleciona a carta / Insere a carta selecionada
 *    Barra de espaco -> Muda a carta do baralho principal
 *                TAB -> Seleciona a carta do baralho principal
 *                ESC -> Desmarca carta selecionada
 *                  1 -> Joga a carta selecionada para a 1¦ pilha principal
 *                  2 -> Joga a carta selecionada para a 2¦ pilha principal
 *                  3 -> Joga a carta selecionada para a 3¦ pilha principal
 *                  4 -> Joga a carta selecionada para a 4¦ pilha principal
 *              ALT+1 -> Seleciona a carta da 1§ pilha principal
 *              ALT+2 -> Seleciona a carta da 2§ pilha principal
 *              ALT+3 -> Seleciona a carta da 3§ pilha principal
 *              ALT+4 -> Seleciona a carta da 4§ pilha principal
 *                 F1 -> Ajuda !!!
 *                 F2 -> Inicia novo jogo!
 *             ALT+F4 -> Fecha o jogo
 */

#include <stdio.h>    // standard input/output
#include <stdlib.h>   // standard lib
#include <conio.h>    // console input/output
#include <graphics.h> // biblioteca grafica
#include <time.h>     // biblioteca time :>
#define TAM 51

int     ouro[169] = {15,15,15,15,15,15, 4,15,15,15,15,15,15,
                     15,15,15,15,15, 4, 4, 4,15,15,15,15,15,
                     15,15,15,15, 4, 4, 4, 4, 4,15,15,15,15,
                     15,15,15, 4, 4, 4, 4, 4, 4, 4,15,15,15,
                     15,15, 4, 4, 4, 4, 4, 4, 4, 4, 4,15,15,
                     15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,15,
                      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
                     15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,15,
                     15,15, 4, 4, 4, 4, 4, 4, 4, 4, 4,15,15,
                     15,15,15, 4, 4, 4, 4, 4, 4, 4,15,15,15,
                     15,15,15,15, 4, 4, 4, 4, 4,15,15,15,15,
                     15,15,15,15,15, 4, 4, 4,15,15,15,15,15,
                     15,15,15,15,15,15, 4,15,15,15,15,15,15},

        copa[169] = {15,15, 4, 4, 4,15,15,15, 4, 4, 4,15,15,
                     15, 4, 4, 4, 4, 4,15, 4, 4, 4, 4, 4,15,
                      4, 4, 4, 4, 4, 4,15, 4, 4, 4, 4, 4, 4,
                      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
                      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
                      4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
                     15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,15,
                     15, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,15,
                     15,15, 4, 4, 4, 4, 4, 4, 4, 4, 4,15,15,
                     15,15,15, 4, 4, 4, 4, 4, 4, 4,15,15,15,
                     15,15,15,15, 4, 4, 4, 4, 4,15,15,15,15,
                     15,15,15,15,15, 4, 4, 4,15,15,15,15,15,
                     15,15,15,15,15,15, 4,15,15,15,15,15,15},

      espada[169] = {15,15,15,15,15,15, 0,15,15,15,15,15,15,
                     15,15,15,15,15, 0, 0, 0,15,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15,
                     15,15,15, 0, 0, 0, 0, 0, 0, 0,15,15,15,
                     15,15, 0, 0, 0, 0, 0, 0, 0, 0, 0,15,15,
                     15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,15,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                     15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,15,
                     15,15, 0, 0,15, 0, 0, 0,15, 0, 0,15,15,
                     15,15,15,15,15, 0, 0, 0,15,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15},

        paus[169] = {15,15,15,15,15, 0, 0, 0,15,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15,
                     15,15,15,15,15, 0, 0, 0,15,15,15,15,15,
                     15, 0, 0,15, 0, 0, 0, 0, 0,15, 0, 0,15,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                     15, 0, 0, 0,15, 0, 0, 0,15, 0, 0, 0,15,
                     15,15,15,15,15, 0, 0, 0,15,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15,
                     15,15,15,15, 0, 0, 0, 0, 0,15,15,15,15};

enum bool {FALSE = 0,TRUE = 1};

struct items {
 int  naipe,   // naipe da carta
      carta,   // numero da carta
     mostra;
};

struct pilha {           // x.top -> topo da pilha
 int top,                // x.max -> maximo de elementos da pilha
     max;                // x.item[x].naipe  -> naipe da carta
 struct items item[TAM]; // x.item[x].carta -> numero da carta
};

// Funções
void   criabaralho(struct pilha *);                 // Cria um baralho com 52 cartas.
void     embaralha(struct pilha *);                 // Embaralha o baralho.
void     distribui(struct pilha *, struct pilha *); // Distribui as cartas do baralho para as pilhas.
void       imprime(int, int, int, int,
                   struct pilha *);                 // Imprime a pilha.
void         carta(int, int, int, struct items);    // Imprime a carta.
void         naipe(int, int, int [169]);            // Desenha naipe.
void     in_graphs();                               // Inicializa modo grafico.
void   desenhatela();                               // Desenha Tela.
void      quadrado(int, int, int, int, int, int);   // Desenha um quadrado.
void        relevo(int, int, int, int);             // Desenha um quadrado com relevo.
void        insere(int, int, struct pilha *,
                   struct pilha *);                 // Insere a ultima carta da pilha 1 na 2
void         limpa(int, int, int, int);             // Limpa uma coluna
void         ajuda(struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                                   struct pilha *); // Tela de ajuda
void    iniciajogo(struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *); // Inicia o Jogo
void        ganhou(struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *,
                   struct pilha *, struct pilha *); // Verifica termino
void adiciona(int, int, struct pilha *,
                        struct pilha *);            // Adiciona a posicao da pilha 1 no final da pilha 2
void cartaanima(int, int, struct items);            // Animacao

struct pilha * ret_pilha(int, struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *,
                              struct pilha *);      // Retorna a pilha

void main() {
 int viTecla = 0, // Contera o numero da tecla
         viX = 0, // Coluna
         viY = 0, // Linha
         viP = 0, // Controla a pilha
       viCor = 0, // Cor
   viPSelect = 0, // Controla a pilha selecionada
  viPPosicao = 0, // Guarda a partir de qual posicao ele vai inserir
    viSelect = 0, // Controla a partir de qual posicao foi selecianado
      viCont = 0; // Controla indice do baralho principal

 struct pilha  b, // baralho - contem 52 cartas e depois de distribuido ficara com 24
              p1, // pilha 1 - contem 1 carta
              p2, // pilha 2 - contem 2 cartas
              p3, // pilha 3 - contem 3 cartas
              p4, // pilha 4 - contem 4 cartas
              p5, // pilha 5 - contem 5 cartas
              p6, // pilha 6 - contem 6 cartas
              p7, // pilha 7 - contem 7 cartas
             pP1, // pilha principal 1 - contera 13 cartas
             pP2, // pilha principal 2 - contera 13 cartas
             pP3, // pilha principal 3 - contera 13 cartas
             pP4; // pilha principal 4 - contera 13 cartas

 in_graphs();
 iniciajogo(&b, &p1, &p2, &p3, &p4, &p5, &p6, &p7, &pP1, &pP2, &pP3, &pP4);

 viX      = 40;
 viY      = 110;
 viCor    = 7;
 viSelect = 0;
 viCont   = 0;
 imprime(viX,viY,viCor,p1.top,&p1);

 while ((viTecla = getch()) != 107) { // ALT+F4
  switch(viTecla) {
   // Seta para esquerda
   case 75 : viP = viX / 40; viSelect = 0;
             imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
             if (viX > 40)  { viX -= 80; }
             break;
   // Seta para direita
   case 77 : viP = viX / 40; viSelect = 0;
             imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
             if (viX < 520) { viX += 80; }
             break;
   // Seta para cima
   case 72 : viP = viX / 40;
             imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
             viSelect++;
             if(ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->item[ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top - viSelect].mostra != TRUE) { viSelect--; }
             break;
   // Seta para baixo
   case 80 : viP = viX / 40;
             imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
             if(viSelect > 0) { viSelect--; }
             break;
   // Enter
   case 13 : if ((viCor == 7) &&
                 (ret_pilha(viX/40,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top > -1)) {
              viCor = 9;
              viPSelect  = viX / 40;
              viPPosicao = viSelect;
             } else {
              viP = viX / 40;
              insere(viPPosicao,viPSelect,ret_pilha(viPSelect,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4),ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
              imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
              if(viPSelect < 15) {
               limpa(viPSelect*40,viY,(viPSelect*40)+50,viY+(getmaxy()-20));
               imprime(viPSelect*40,viY,15,ret_pilha(viPSelect,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viPSelect,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
              } else if (viPSelect == 15) {
               viCont++; if(viCont > b.top) { viCont = 0; }
               if (b.top >= 0) { carta(120,30,15,b.item[viCont]); }
                          else { quadrado(120, 30,170,100,2,INTERLEAVE_FILL); }
              } else if (viPSelect == 17) {
               if (pP1.top >= 0) { carta(280,30,15,pP1.item[pP1.top]); }
                            else { quadrado(280, 30,330,100,2,INTERLEAVE_FILL); }
              } else if (viPSelect == 19) {
               if (pP2.top >= 0) { carta(360,30,15,pP2.item[pP2.top]); }
                            else { quadrado(360, 30,410,100,2,INTERLEAVE_FILL); }
              } else if (viPSelect == 21) {
               if (pP3.top >= 0) { carta(440,30,15,pP3.item[pP3.top]); }
                            else { quadrado(440, 30,490,100,2,INTERLEAVE_FILL); }
              } else if (viPSelect == 23) {
               if (pP4.top >= 0) { carta(520,30,15,pP4.item[pP4.top]); }
                            else { quadrado(520, 30,570,100,2,INTERLEAVE_FILL); }
              }
              viCor = 7;
             }
             break;
   // ESC
   case 27 : viCor = 7;
             break;
   // F1
   case 59 : ajuda(&p1, &p2, &p3, &p4, &p5, &p6, &p7);
             break;
   // F2
   case 60 : iniciajogo(&b, &p1, &p2, &p3, &p4, &p5, &p6, &p7, &pP1, &pP2, &pP3, &pP4);
             viX = 40;
             viY = 110;
             viCor = 7;
             viSelect = 0;
             viCont = 0;
             imprime(viX,viY,viCor,p1.top,&p1);
             break;
   // Barra de espaco
   case 32 : viCont++; if(viCont > b.top) { viCont = 0; }
             if (b.top >= 0) { carta(120,30,15,b.item[viCont]); }
                        else { quadrado(120, 30,170,100,2,INTERLEAVE_FILL); }
             break;
   // TAB
   case  9 : if ((viCor != 9) &&
                 (b.top > -1)) {
              viCor = 9;
              viPPosicao = viCont;
              viPSelect  = 15;
             }
             break;
   // ALT+1
   case 120: if ((viCor != 9) &&
                 (pP1.top > -1)) {
              viCor = 9;
              viPPosicao = pP1.top;
              viPSelect  = 17;
             }
             break;
   // ALT+2
   case 121: if ((viCor != 9) &&
                 (pP2.top > -1)) {
              viCor = 9;
              viPPosicao = pP2.top;
              viPSelect  = 19;
             }
             break;
   // ALT+3
   case 122: if ((viCor != 9) &&
                 (pP3.top > -1)) {
              viCor = 9;
              viPPosicao = pP3.top;
              viPSelect  = 21;
             }
             break;
   // ALT+4
   case 123: if ((viCor != 9) &&
                 (pP4.top > -1)) {
              viCor = 9;
              viPPosicao = pP4.top;
              viPSelect  = 23;
             }
             break;
   // 1
   case 49 : if (viCor == 9) {
              viP = viX / 40;
              insere(viPPosicao,viPSelect,ret_pilha(viPSelect,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4),&pP1);
              limpa(viX,viY,viX+50,viY+(getmaxy()-20));
              imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
              if (pP1.top >= 0) { carta(280,30,15,pP1.item[pP1.top]); }
              if (viPSelect == 15) {
               viCont++; if(viCont > b.top) { viCont = 0; }
               carta(120,30,15,b.item[viCont]);
              }
              viCor = 7;
              //viX = 40;
             }
             break;
   // 2
   case 50 : if (viCor == 9) {
              viP = viX / 40;
              insere(viPPosicao,viPSelect,ret_pilha(viPSelect,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4),&pP2);
              limpa(viX,viY,viX+50,viY+(getmaxy()-20));
              imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
              if (pP2.top >= 0) { carta(360,30,15,pP2.item[pP2.top]); }
              if (viPSelect == 15) {
               viCont++; if(viCont > b.top) { viCont = 0; }
               carta(120,30,15,b.item[viCont]);
              }
              viCor = 7;
              //viX = 40;
             }
             break;
   // 3
   case 51 : if (viCor == 9) {
              viP = viX / 40;
              insere(viPPosicao,viPSelect,ret_pilha(viPSelect,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4),&pP3);
              limpa(viX,viY,viX+50,viY+(getmaxy()-20));
              imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
              if (pP3.top >= 0) { carta(440,30,15,pP3.item[pP3.top]); }
              if (viPSelect == 15) {
               viCont++; if(viCont > b.top) { viCont = 0; }
               carta(120,30,15,b.item[viCont]);
              }
              viCor = 7;
              //viX = 40;
             }
             break;
   // 4
   case 52 : if (viCor == 9) {
              viP = viX / 40;
              insere(viPPosicao,viPSelect,ret_pilha(viPSelect,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4),&pP4);
              limpa(viX,viY,viX+50,viY+(getmaxy()-20));
              imprime(viX,viY,15,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
              if (pP4.top >= 0) { carta(520,30,15,pP4.item[pP4.top]); }
              if (viPSelect == 15) {
               viCont++; if(viCont > b.top) { viCont = 0; }
               carta(120,30,15,b.item[viCont]);
              }
              viCor = 7;
              //viX = 40;
             }
            break;
//        default : printf("%i\n",viTecla);
  }
  viP = viX / 40;
  imprime(viX,viY,viCor,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4)->top - viSelect,ret_pilha(viP,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&b,&pP1,&pP2,&pP3,&pP4));
  ganhou(&b,&p1,&p2,&p3,&p4,&p5,&p6,&p7,&pP1,&pP2,&pP3,&pP4);
 }

 closegraph();
}

void ganhou(b, p1, p2, p3, p4, p5, p6, p7, pP1, pP2, pP3, pP4)
            struct pilha  *b, *p1,  *p2,  *p3,  *p4,  *p5,
                         *p6, *p7, *pP1, *pP2, *pP3, *pP4; {
 int vii = 0;

 if (( b->top < 0) &&
     (p1->top < 0) &&
     (p2->top < 0) &&
     (p3->top < 0) &&
     (p4->top < 0) &&
     (p5->top < 0) &&
     (p6->top < 0) &&
     (p7->top < 0)) {
  settextstyle(2,0,4);
  setcolor(0);
  vii = 0;
  while(!kbhit()) {
   cartaanima(280,30,pP1->item[pP1->top-vii]);
   delay(15);
   cartaanima(360,30,pP2->item[pP2->top-vii]);
   delay(15);
   cartaanima(440,30,pP3->item[pP3->top-vii]);
   delay(15);
   cartaanima(520,30,pP4->item[pP4->top-vii]);
   vii++;
   if (vii > 12) { break; }
  }
  while (!kbhit()) { }
  iniciajogo(b, p1, p2, p3, p4, p5, p6, p7, pP1, pP2, pP3, pP4);
 }
}

void cartaanima(int x, int y, struct items pCarta) {
 while ((!kbhit()) &&
        (x < getmaxx()-50) &&
        (y < getmaxy()-70)) {
  carta(x,y,15,pCarta);
  x -= 3;
  y += 4;
  delay(3);
 }
}

void iniciajogo(b, p1, p2, p3, p4, p5, p6, p7, pP1, pP2, pP3, pP4)
                struct pilha   *b,  *p1,  *p2,  *p3, *p4, *p5, *p6, *p7,
                             *pP1, *pP2, *pP3, *pP4; {

 // Define tamanho das pilhas
  p1->top  = -1; p1->max = 0;  // p1 contera 1 carta
  p2->top  = -1; p2->max = 1;  // p2 contera 2 cartas
  p3->top  = -1; p3->max = 2;  // p3 contera 3 cartas
  p4->top  = -1; p4->max = 3;  // p4 contera 4 cartas
  p5->top  = -1; p5->max = 4;  // p5 contera 5 cartas
  p6->top  = -1; p6->max = 5;  // p6 contera 6 cartas
  p7->top  = -1; p7->max = 6;  // p7 contera 7 cartas
   b->top  = -1;  b->max = 23; // b contera 24 cartas
 pP1->top  = -1;pP1->max = 12; // pP1 contera 13 cartas
 pP2->top  = -1;pP2->max = 12; // pP2 contera 13 cartas
 pP3->top  = -1;pP3->max = 12; // pP3 contera 13 cartas
 pP4->top  = -1;pP4->max = 12; // pP4 contera 13 cartas

 criabaralho(b);

 embaralha(b);

 // Distribui as cartas conforme ajustado o tamanho das pilhas.
 distribui(b,p1);
 distribui(b,p2);
 distribui(b,p3);
 distribui(b,p4);
 distribui(b,p5);
 distribui(b,p6);
 distribui(b,p7);

 cleardevice();

 desenhatela();

 // Imprime as pilhas nas posições corretas.
 imprime( 40,110,15,p1->top,p1);
 imprime(120,110,15,p2->top,p2);
 imprime(200,110,15,p3->top,p3);
 imprime(280,110,15,p4->top,p4);
 imprime(360,110,15,p5->top,p5);
 imprime(440,110,15,p6->top,p6);
 imprime(520,110,15,p7->top,p7);

 // Baralho Principal
 carta(120,30,15,b->item[0]);
}

void ajuda(p1, p2, p3, p4, p5, p6, p7) struct pilha *p1, *p2, *p3, *p4,
                                                         *p5, *p6, *p7; {
 setcolor(0);
 quadrado(getmaxx()-240,getmaxy()-155,getmaxx()-20,getmaxy()-7,7,SOLID_FILL);
 setcolor(8);
 line(getmaxx()-240,getmaxy()-7  ,getmaxx()-20 ,getmaxy()-7);
 line(getmaxx()-20 ,getmaxy()-155,getmaxx()-20 ,getmaxy()-7);
 setcolor(15);
 line(getmaxx()-240,getmaxy()-155,getmaxx()-20 ,getmaxy()-155);
 line(getmaxx()-240,getmaxy()-155,getmaxx()-240,getmaxy()-7);
 setcolor(8);
 line(getmaxx()-235,getmaxy()-142,getmaxx()-25,getmaxy()-142);
// rectangle(getmaxx()-500,getmaxy()-180,getmaxx()-20,getmaxy()-7);
 setcolor(8);
 outtextxy(getmaxx()-235,getmaxy()-154,"AJUDA");
 setcolor(0);
 outtextxy(getmaxx()-235,getmaxy()-135,"   -    Setas:                     ");
 outtextxy(getmaxx()-235,getmaxy()-125," - 0 -  contrala a carta           ");
 outtextxy(getmaxx()-235,getmaxy()-115,"   -    selecionada                ");
 outtextxy(getmaxx()-235,getmaxy()-100,"     <ENTER> seleciona ou insere   ");
 outtextxy(getmaxx()-235,getmaxy()- 85," <BAR SPACE> muda a carta          ");
 outtextxy(getmaxx()-235,getmaxy()- 70,"       <TAB> seleciona             ");
 outtextxy(getmaxx()-235,getmaxy()- 55,"       <ESC> desmarca              ");
 outtextxy(getmaxx()-235,getmaxy()- 40,"     <1>..<4> insere conforme n§    ");
 outtextxy(getmaxx()-235,getmaxy()- 25," ALT+<1>..<4> seleciona conforme n§ ");
 getch();
 limpa(getmaxx()-500,getmaxy()-180,getmaxx()-20,getmaxy()-7);
 imprime( 40,110,15,p1->top,p1);
 imprime(120,110,15,p2->top,p2);
 imprime(200,110,15,p3->top,p3);
 imprime(280,110,15,p4->top,p4);
 imprime(360,110,15,p5->top,p5);
 imprime(440,110,15,p6->top,p6);
 imprime(520,110,15,p7->top,p7);
}

struct pilha * ret_pilha(int x, struct pilha *p1, struct pilha *p2,
                                struct pilha *p3, struct pilha *p4,
                                struct pilha *p5, struct pilha *p6,
                                struct pilha *p7, struct pilha *b ,
                                struct pilha *pP1,struct pilha *pP2,
                                struct pilha *pP3,struct pilha *pP4) {
      if(x == 1)  return(p1);
 else if(x == 3)  return(p2);
 else if(x == 5)  return(p3);
 else if(x == 7)  return(p4);
 else if(x == 9)  return(p5);
 else if(x == 11) return(p6);
 else if(x == 13) return(p7);
 else if(x == 15) return(b);
 else if(x == 17) return(pP1);
 else if(x == 19) return(pP2);
 else if(x == 21) return(pP3);
 else if(x == 23) return(pP4);
}

void limpa(int x1, int y1, int x2, int y2) {
 quadrado(x1,y1,x2,y2,2,SOLID_FILL);
}

void adiciona(int pos, int retirar, struct pilha *p1, struct pilha *p2) {
 // pos     == posicao da pilha 1
 // retirar == retirar elemento da pilha 1 ?
 p2->top++;
 p2->item[p2->top].carta  = p1->item[pos].carta;
 p2->item[p2->top].naipe  = p1->item[pos].naipe;
 p2->item[p2->top].mostra = p1->item[pos].mostra;
 if (retirar) {
  p1->item[pos].carta   = p1->item[p1->top].carta;
  p1->item[pos].naipe   = p1->item[p1->top].naipe;
  p1->item[pos].mostra  = p1->item[p1->top].mostra;
  p1->top--;
 }
}

void insere(int pos, int pilha, struct pilha *p1, struct pilha *p2) {
 int viAux = 0;

 if(p2->top == -1) {
  if(pilha == 15) {
   if ((p1->item[pos].carta == 13) &&
       (p2->max != 12)) {
    adiciona(pos,TRUE,p1,p2);
   } else if ((p1->item[pos].carta == 1) &&
              (p2->max == 12)) {
    adiciona(pos,TRUE,p1,p2);
   }
  } else if (pilha > 16) {
   if ((p1->item[pos].carta == 13) &&
       (p2->max == 12)) {
    adiciona(pos,TRUE,p1,p2);
   }
  } else {
   if ((p1->item[p1->top - pos].carta ==  13) &&
       (p2->max != 12)) {
    viAux = pos;
    while(viAux >= 0) {
     adiciona(p1->top - viAux,FALSE,p1,p2);
     if(p2->top > 0) { p2->item[p2->top-1].mostra = TRUE; }
     viAux--;
    }
    p1->top -= pos + 1;
   } else if ((p1->item[p1->top].carta == 1) &&
              (p2->max == 12)) {
    adiciona(p1->top,TRUE,p1,p2);
   }
  }
 } else {
  if(pilha == 15) {
   if ((p1->item[pos].carta      ==  p2->item[p2->top].carta - 1) &&
      ((p1->item[pos].naipe % 2) != (p2->item[p2->top].naipe % 2)) &&
       (p2->max != 12)) {
    adiciona(pos,TRUE,p1,p2);
    p2->item[p2->top-1].mostra = TRUE;
   } else if ((p1->item[pos].carta  == p2->item[p2->top].carta + 1) &&
              (p1->item[pos].naipe  == p2->item[p2->top].naipe)      &&
              (p2->max == 12)) {
    adiciona(pos,TRUE,p1,p2);
   }
  } else if (pilha > 16) {
   if ((p1->item[pos].carta      ==  p2->item[p2->top].carta - 1) &&
      ((p1->item[pos].naipe % 2) != (p2->item[p2->top].naipe % 2)) &&
       (p2->max != 12)) {
    adiciona(pos,TRUE,p1,p2);
    p2->item[p2->top-1].mostra = TRUE;
   }
  } else {
   if ((p1->item[p1->top - pos].carta      ==  p2->item[p2->top].carta - 1) &&
      ((p1->item[p1->top - pos].naipe % 2) != (p2->item[p2->top].naipe % 2)) &&
       (p2->max != 12)) {
    viAux = pos;
    while(viAux >= 0) {
     adiciona(p1->top - viAux,FALSE,p1,p2);
     p2->item[p2->top-1].mostra = TRUE;
     viAux--;
    }
    p1->top -= pos + 1;
   } else if ((p1->item[p1->top].carta == p2->item[p2->top].carta + 1) &&
              (p1->item[p1->top].naipe == p2->item[p2->top].naipe)      &&
              (p2->max == 12)) {
    adiciona(p1->top,TRUE,p1,p2);
   }
  }
 }
}

void relevo(int x1, int y1, int x2, int y2) {
 quadrado(x1,y1,x2,y2,6,SOLID_FILL);
 setcolor(0);
 line(x1,y2,x2,y2);
 line(x2,y1,x2,y2);
 setcolor(7);
 line(x1,y1,x2,y1);
 line(x1,y1,x1,y2);
}

void quadrado(int x1, int y1, int x2, int y2, int cor, int fundo) {
 setfillstyle(fundo, cor);
 bar(x1,y1,x2,y2);
}

void desenhatela() {
 // Fundo
 quadrado(0,0,getmaxx(),getmaxy(),2,SOLID_FILL);

 // Baralho
 relevo(40,30,90,100);
 relevo(42,32,92,102);
 relevo(44,34,94,104);

 // Pilhas Ordenadas
 quadrado(280, 30,330,100,2,INTERLEAVE_FILL); // 1
 quadrado(360, 30,410,100,2,INTERLEAVE_FILL); // 2
 quadrado(440, 30,490,100,2,INTERLEAVE_FILL); // 3
 quadrado(520, 30,570,100,2,INTERLEAVE_FILL); // 4

 // Titulo das pilhas principais
 setcolor(0);
 settextstyle(2,0,0);
 outtextxy(303,18,"1");
 outtextxy(383,18,"2");
 outtextxy(463,18,"3");
 outtextxy(543,18,"4");

 outtextxy(420,0,"help? F1 - new? F2 - close? ALT+F4");
}

void criabaralho(b) struct pilha *b; {
 int     vii = 0, // posicao do vetor
         vij = 0, // numero da carta
         vik = 0; // naipe da carta

 for (vij = 1;vij <= 13;vij++) {
  for (vik = 1;vik <= 4;vik++) {
   b->item[vii].carta  = vij;
   b->item[vii].naipe  = vik;
   b->item[vii].mostra = FALSE;
   vii++;
   b->top++;
  }
 }
// b->item[51].naipe = 4; // Estou setando o valor quatro na ultima posicao pq
                        // por um motivo desconhecido ele fica com o naipe = 5
                        // no final do for.
}


void embaralha(b) struct pilha *b; {
 int viPosicao = 0, // Posicao sortiada
  vii = 0; // Indice
 struct items aux;

 randomize();
 for(vii = 0;vii < 52;vii++) {
  viPosicao  = random(b->top);
  aux.naipe  = b->item[viPosicao].naipe;
  aux.carta  = b->item[viPosicao].carta;
  aux.mostra = b->item[viPosicao].mostra;
  b->item[viPosicao].naipe  = b->item[b->top - viPosicao].naipe;
  b->item[viPosicao].carta  = b->item[b->top - viPosicao].carta;
  b->item[viPosicao].mostra = b->item[b->top - viPosicao].mostra;
  b->item[b->top - viPosicao].naipe  = aux.naipe;
  b->item[b->top - viPosicao].carta  = aux.carta;
  b->item[b->top - viPosicao].mostra = aux.mostra;
 }
}

void distribui(b, p) struct pilha *b, *p; {
 int viPosicao = 0; // Posicao sortiada

 randomize();
 while (p->top < p->max) {
  viPosicao = random(b->top);
  p->top++;
  p->item[p->top].naipe     = b->item[viPosicao].naipe;
  p->item[p->top].carta     = b->item[viPosicao].carta;
  p->item[p->top].mostra    = b->item[viPosicao].mostra;
  b->item[viPosicao].naipe  = b->item[b->top].naipe;
  b->item[viPosicao].carta  = b->item[b->top].carta;
  b->item[viPosicao].mostra = b->item[b->top].mostra;
  b->top--;
 }
}

void imprime(int x, int y, int cor, int posicao, struct pilha *p) {
 int viCont = 0; // Indice

 if (p->top < 0) {
  if(cor == 15) { cor = 2; }
   quadrado(x, y,x+50,y+70,cor,INTERLEAVE_FILL);
 } else {
  if(p->top == 0) {
   carta(x,y,cor,p->item[p->top]);
  } else {
   for(viCont = 0;viCont <= p->top;viCont++) {
    if (viCont != p->top) {
     if(p->item[viCont].mostra == TRUE) {
      if(viCont > 0) { if(p->item[viCont-1].mostra == TRUE) { y += 15; } }
      if(viCont == posicao) { carta(x,y,cor,p->item[viCont]); }
                       else { carta(x,y,15,p->item[viCont]);  }
     } else {
      relevo(x,y,x+50,y+70);
     }
    } else {
     if (p->item[viCont-1].mostra == TRUE) { y += 15; }
     carta(x,y,cor,p->item[viCont]);
    }
    y += 4;
   }
  }
 }
}

void carta(int x1, int y1, int cor, struct items valor) {
 quadrado(x1,y1,x1+50,y1+70,cor,SOLID_FILL);
 switch(valor.naipe) {
  case 1 : setcolor(4); naipe(x1+4,y1+54,ouro);   naipe(x1+33,y1+4,ouro);
           break;
  case 2 : setcolor(0); naipe(x1+4,y1+54,espada); naipe(x1+33,y1+4,espada);
           break;
  case 3 : setcolor(4); naipe(x1+4,y1+54,copa);   naipe(x1+33,y1+4,copa);
           break;
  case 4 : setcolor(0); naipe(x1+4,y1+54,paus);   naipe(x1+33,y1+4,paus);
           break;
 }
 switch(valor.carta) {
  case  1 : outtextxy (x1+4,y1+4,"A");
            break;
  case  2 : outtextxy (x1+4,y1+4,"2");
            break;
  case  3 : outtextxy (x1+4,y1+4,"3");
            break;
  case  4 : outtextxy (x1+4,y1+4,"4");
            break;
  case  5 : outtextxy (x1+4,y1+4,"5");
            break;
  case  6 : outtextxy (x1+4,y1+4,"6");
            break;
  case  7 : outtextxy (x1+4,y1+4,"7");
            break;
  case  8 : outtextxy (x1+4,y1+4,"8");
            break;
  case  9 : outtextxy (x1+4,y1+4,"9");
            break;
  case 10 : outtextxy (x1+4,y1+4,"10");
            break;
  case 11 : outtextxy (x1+4,y1+4,"J");
            break;
  case 12 : outtextxy (x1+4,y1+4,"Q");
            break;
  case 13 : outtextxy (x1+4,y1+4,"K");
            break;
  default : outtextxy (x1+4,y1+4,"?");
 }

 // Bordas
 line(   x1,y1+70,x1+50,y1+70);
 line(x1+50,   y1,x1+50,y1+70);
 line(   x1,   y1,x1+50,   y1);
 line(   x1,   y1,   x1,y1+70);
}

void naipe(int x1, int y1, int vetor[169]) {
 int vii = 0, // Indice do vetor
     vij = 0, // Controla a linha
     vik = 0; // Controla a coluna

 for(vij = 0;vij < 13;vij++) {
  for(vik = 0;vik < 13;vik++) {
   if (vetor[vii] != 15) {
    putpixel(x1+(vik),y1+(vij),vetor[vii]);
   }
   vii++;
  }
 }
}

void in_graphs() {
 int gdriver = DETECT,
       gmode,
   errorcode,
        midx,
        midy,
           i;

 initgraph(&gdriver, &gmode, "\\TC\\BGI");
 errorcode = graphresult();
 if (errorcode != grOk) {
  printf("Graphics error: %s\n", grapherrormsg(errorcode));
  printf("Press any key to halt!");
  getch();
  exit(1);
 }
}