Esempio n. 1
0
/**
Esta função tem como objetivo imprimir as cartas no tabuleiro.
Se a carta a apresentar se encontre na mão do jogador (mao toma o valor de 0 e o actual_jogador no estado for igual a 0),
e caso a carta seja selecionada é então adicionada ao highlight. Se já se encontrar no highlight, então é removida de lá.
Caso contrário, se a carta se encontrar na mão de um bot, é imprimido o verso de uma carta, caso contrário a carta já foi jogada por um bot logo é mostrada a carta correspondente.
@param path O path.
@param x Coordenada HTML.
@param y Coordenada HTML.
@param e O estado atual.
@param mao Número de um jogador.
@param naipe O naipe da carta (inteiro entre 0 e 3).
@param valor O valor da carta (inteiro entre 0 e 12).
*/
void imprime_carta(char *path, int x, int y, ESTADO e, int mao, int naipe, int valor) {
    char *suit = NAIPES;
    char *rank = VALORES;
    char script[10240];
    ESTADO novo = e;
    novo.card = 1;
    
    if (mao == 0 && e.actual_jogador == 0) {
        if (carta_existe (novo.highlight, naipe, valor)) {
            novo.highlight = rem_carta(novo.highlight, naipe, valor);
        }
        
        else {
            novo.highlight = add_carta(novo.highlight, naipe, valor);
        }
        
        sprintf(script, "%s?%s", SCRIPT, estado2str(novo));
        printf("<a xlink:href = \"%s\"><image x = \"%d\" y = \"%d\" height = \"110\" width = \"80\" xlink:href = \"%s/%c%c.svg\" /></a>\n", script, x, y, path, rank[valor], suit[naipe]);  
    }
    
    else {
        if (carta_existe(e.mao[1],naipe,valor) || carta_existe(e.mao[2],naipe,valor) || carta_existe(e.mao[3],naipe,valor))
            printf("<image x = \"%d\" y = \"%d\" height = \"110\" width = \"80\" xlink:href = \"%s/11C.png\" />\n", x, y, path);
        else printf("<image x = \"%d\" y = \"%d\" height = \"110\" width = \"80\" xlink:href = \"%s/%c%c.svg\" />\n", x, y, path, rank[valor], suit[naipe]);
    }
}
Esempio n. 2
0
/*
Função auxiliar que recebe parametros da função imprime. Aqui é vista a forma de como as cartas são apresentadas, neste caso por naipe.
*/
void imprime_aux_naipe (ESTADO e, int m, int bx1, int by1, int bx2, int by2, int bx3, int by3, int x, int y, char *path) {

    int n,v;

    for (n = 0; n < 4; n++){
        for (v = 0; v < 13; v++) {
            if (m == 1 && carta_existe(e.cartas_bots[1],n,v)) {
                imprime_carta(path, bx1, by1, e, m, n, v);
                by1+=20;
            }
            if (m == 2 && carta_existe(e.cartas_bots[2],n,v)) {
                imprime_carta(path, bx2, by2, e, m, n, v);
                bx2+=20;
            }
            if (m == 3 && carta_existe(e.cartas_bots[3],n,v)) {
                imprime_carta(path,bx3, by3, e, m, n, v);
                by3 += 20;
            }
            if (carta_existe(e.mao[m], n, v)) {
                if (m % 2 == 0) {
                    x += 30;
                }
                else {
                    y += 30;
                }
                if (m == 0 && carta_existe(e.highlight, n, v)) {
                    imprime_carta(path, x, (y - 20), e, m, n, v);
                }
                else {
                    imprime_carta(path, x, y, e, m, n, v);
                }
            }
        }
    }
}
Esempio n. 3
0
/* *
Numa jogada de 1,2 e 3 cartas esta função é utilizada para comparar o valor entre a ultima_jogada e a efetuda pelo atual_jogador. 
@param m A mão de um jogador.
@returns O valor de uma carta.
*/
int da_valor (MAO m){
    
    int n, v, primeiraCarta, flag = 0;
    primeiraCarta = 0;
    
    for (n = 0; n < 4 && flag != 1; n++) {
        
        for (v = 0; v < 13 && flag != 1; v++)
        
        if (carta_existe(m, n, v)){
            primeiraCarta = v ;
            flag = 1;
        }
    }
    
    for (n = 0; n < 4 ; n++) {
        
        for (v = 0; v < 13 ; v++)
        
        if (carta_existe(m, n, v)){
            if (v != primeiraCarta){
                return -1 ;
            }
        }
    }
    return primeiraCarta;
}
Esempio n. 4
0
/**
Ao receber o highlight do utilizador (neste caso um straight), confirma se este é válido para ser efetuada uma jogada.
@param m A mão de um jogador.
@returns Um inteiro 1, se for válido o straight, e -1 caso contrário.
*/
int valida_straight (MAO m) {
    
    int v,i,n,j;
    
    int contaValores[14];
    
    for (i = 0; i < 14; i++) {
        contaValores[i] = 0;
    }
    
    i = 2;
    for (v = 0; v <= 13; v++) {
        for(n = 0; n < 4; n++) {
            switch (v) {
                case 11: if (carta_existe(m,n,v)) { contaValores[0]++; contaValores[13]++; } break;
                case 12: if (carta_existe(m,n,v)) { contaValores[1]++; } break;
                default: if (carta_existe(m,n,v)) { contaValores[i]++; } break;
            }
        }
        i++;
    }
    
    j = 0;
    while ((j + 4) < 14) {
        if ((contaValores[j] != 0) && (contaValores[j+1] != 0) && (contaValores[j+2] != 0) && (contaValores[j+3] != 0) && (contaValores[j+4] != 0)) {
            return 1;
        }
        j++;
    }
    
    return -1;
}
Esempio n. 5
0
/**
Nas cartas selecionadas pelo utilizador (neste caso um straight flush), determina o valor da maior carta desse, para mais tarde comparar, se necessário, com as ultimas jogadas, de forma a avaliar a jogada.
Esta função foi usada para avaliar a mão do utilizador, pois seguia o mesmo precedimento.
A função retorna então o valor da maior carta de um straight se existir um straight, e -1 se não existir.
@param m A mão de um jogador.
@returns O valor de uma carta.
*/
int maior_carta_straight_bots(MAO m){
    /* USAMOS MAIOR_CARTA_STRAIGHT_BOTS PARA AVALIAR A MAIOR CARTA DE UM STRAIGHT FLUSH, POIS ERA O MESMO PROCEDIMENTO */
    int v,i,n,j;
    
    int contaValores[14];
    
    for (i = 0; i < 14; i++) {
        contaValores[i] = 0;
    }
    
    i = 2;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            switch (v) {
                case 11: if (carta_existe(m,n,v)) { contaValores[0]++; contaValores[13]++; } break;
                case 12: if (carta_existe(m,n,v)) { contaValores[1]++; } break;
                default: if (carta_existe(m,n,v)) { contaValores[i]++; } break;
            }
        }
        i++;
    }
    
    if (contaValores[1] != 0) {
        j = 12;
        while ((j-4) >= 0) {
            if ((contaValores[j] != 0) && (contaValores[j-1] != 0) && (contaValores[j-3] != 0) && (contaValores[j-4] != 0)) {
                switch (j) {
                    case 0: { j = 11; } break;
                    case 1: { j = 12; } break;
                    default: { j -= 2; } break;
                }
                return j;
            }
            j--;
        }
    }
    else {
        j = 13;
        while ((j-4) >= 1) {
            if ((contaValores[j] != 0) && (contaValores[j-1] != 0) && (contaValores[j-3] != 0) && (contaValores[j-4] != 0)) {
                switch (j) {
                    case 0: { j = 11; } break;
                    case 1: { j = 12; } break;
                    default: { j -= 2; } break;
                }
                return j;
            }
            j--;
        }
    }
    
    return -1;
}
Esempio n. 6
0
/**
Nas cartas selecionadas pelo utilizador (neste caso um four of a kind), determina o valor da maior carta de entre as quatro cartas com o mesmo valor,
para mais tarde comparar, se necessário, com as ultimas jogadas, de forma a avaliar a jogada.
@param m A mão de um jogador.
@returns O valor das quatro cartas iguais.
*/
int maior_carta_fourkind (MAO m) {
    
    int v,i,x,n,j,var,flag;
    int contaValores[13];
    
    var = -1;
    
    for (i = 0; i < 13; i++) {
        contaValores[i] = 0;
    }
    
    x = 0;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            if (carta_existe(m,n,v)) {
                contaValores[x]++;
            }
        }
        x++;
    }
    
    flag = 0;
    for (j = 12; j >= 0 && flag != 1; --j) {
        if ((contaValores[j]) == 4) {
            var = j;
            flag = 1;
        }
    }
    return var;
}
Esempio n. 7
0
/**
Ao receber o highlight do utilizador (neste caso um four of a kind), confirma se este é válido para ser efetuada uma jogada.
@param m A mão de um jogador.
@returns Um inteiro 1, se for válido o four of a kind, e -1 caso contrário.
*/
int valida_fourkind (MAO m) {
    
    int v,i,n,j;
    
    int contaValores[13];
    
    for (i = 0; i < 13; i++) {
        contaValores[i] = 0;
    }
    
    i = 0;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            if ((carta_existe(m,n,v))) {
                contaValores[i]++;
            }
        }
        i++;
    }
    
    for (j = 0; j < 13; j++) {
        if (contaValores[j] == 4) {
            
            return 1;
        }
    }
    
    return 0;
}
Esempio n. 8
0
/**
Nas cartas selecionadas pelo utilizador (neste caso um fullhouse), determina o valor da maior carta do trio desse, para mais tarde comparar, se necessário, com as ultimas jogadas, de forma a avaliar a jogada.
@param m A mão de um jogador.
@returns O valor da maior carta do full house.
*/
int maior_carta_trio_fullhouse (MAO m) {
    
    int v,i,n,j,var;
    int contaValores[14];
    var = 0;
    
    for (i = 0; i < 14; i++) {
        contaValores[i] = 0;
    }
    
    i = 0;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            if (carta_existe(m,n,v)) {
                contaValores[i]++;
            }
        }
        i++;
    }
    
    for (j = 0; j < 13; j++) {
        if (contaValores[j] == 3) {
            var = j;
        }
    }
    
    return var;
}
Esempio n. 9
0
/**
Ao receber o highlight do utilizador (neste caso um fullhouse), confirma se este é válido para ser efetuada uma jogada.
@param m A mão de um jogador.
@returns O valor.
*/
int valida_fullhouse (MAO m) {
    
    int v,i,n,j,p,flag;
    int contaValores[13];
    
    p=-1;
    flag=0;
    
    for (i = 0; i < 13; i++) {
        contaValores[i] = 0;
    }
    
    i = 0;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            if (carta_existe(m,n,v)) {
                contaValores[i]++;
            }
        }
        i++;
    }
    
    for (i = 0; i < 13 && flag != 1; i++) {;
        if (contaValores[i] >= 3 && flag != 1) {
            for (j = 0; j < 13 && flag != 1; j++) {
                if ((contaValores[j] >= 2) && j != i && flag != 1) {
                    p = i;
                    flag = 1;
                    return p;
                }
            }
        }
    }
    return p;
}
Esempio n. 10
0
int fourofakindpos (DATABASE * simulacao, int jog, int sametype,MAO jogadas[40], int count) { /*sametype: 1-> a última jogada foi um four of a kind 0: foi uma jogada de rank inferior */
    MAO temp = 0;
    int n,v, ind;
    int i = 0;
    int rank[13] = {0};
    separa_val(simulacao->mao[jog], rank);
    if(sametype != 0){
        i = (maior_carta_mao(simulacao->jogada) % 13) + 1;
    }
    for(; i < 13; i++)
        if(rank[i] == 4){
            jogadas[count] = 0;
            temp = add_carta(temp,0,i);
            temp = add_carta(temp,1,i);
            temp = add_carta(temp,2,i);
            temp = add_carta(temp,3,i);
            for(ind = 0; ind < 52;ind++){
                n = ind / 13;
                v = ind % 13;
                if(carta_existe(simulacao->mao[jog],n,v) && v != i){
                    jogadas[count] = add_carta(temp,n,v);
                    count++;
                }
            }
        }
    return count;
}
Esempio n. 11
0
/**
Esta função procura na mão um par válido para ser usado num full house. Se existir um par, é retornado o valor desse.
@param m A mão de um jogador.
@returns Valor de um par para full house.
*/
int maior_carta_par_fullhouse (MAO m) {
    
    int v,i,n,j,var,flag;
    int contaValores[13];
    var = 0;

    for (i = 0; i < 13; i++) {
        contaValores[i] = 0;
    }
    
    i = 0;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            if (carta_existe(m,n,v)) {
                contaValores[i]++;
            }
        }
        i++;
    }
    
    flag = 0;
    for (j = 0; (j < 13) && (flag != 1); j++) {
        if (contaValores[j] >= 2) {
            var = j;
            flag = 1;
        }
    }
    
    return var;
}
Esempio n. 12
0
/**
Para a formação de um four of a kind, é necessário quatro cartas com o mesmo valor mais uma carta qualquer existente na mão.
Esta função escolhe essa carta, verificando primeiro se existe na mão. A primeira que for encontrada, é adicionada ao four of a kind.
A função retorna o valor da primeira carta que encontra para juntar ao four of a kind.
@param m A mão de um jogador.
@returns O valor de uma carta.
*/
int da_carta_fourkind (MAO m) {
    
    int v,i,n,j,var=0,flag;
    int contaValores[13];
    
    for (i = 0; i < 13; i++) {
        contaValores[i] = 0;
    }
    
    i = 0;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            if ((carta_existe(m,n,v))) {
                contaValores[i]++;
            }
        }
        i++;
    }
    
    flag = 0;
    for (j = 0; (j < 13) && (flag != 1); j++) {
        if (contaValores[j] == 1) {
            var = j;
            flag = 1;
        }
    }
    
    return var;
}
Esempio n. 13
0
/**
Depois de ser validada um straight na mão de um dos bots, esta função determina o naipe da maior carta nesse straight, para se for necessário comparar com valores iguais.
A função retorna o valor correspondente ao naipe da maior carta do straight existente.
@param m A mão de um jogador.
@param maiorCarta A maior carta de um straight.
@returns O naipe da maior carta de um straight.
*/
int maior_naipe_straight_bots (MAO m, int maiorCarta) {
    int i,n;
    i = 0;
    for (n = 3; n >= 0; --n) {
        if (carta_existe(m,n,maiorCarta)) i = n;
    }
    return i;
}
Esempio n. 14
0
int fullhousepos (DATABASE * simulacao, int jog, int sametype, MAO jogadas[40], int count) {
    int rank[13] = {0};
    int rank2[13] = {0};
    int i = 0, v, n;
    int c = 0;
    MAO mao = simulacao->mao[jog], temp = 0;
    separa_val(mao, rank);
    if(sametype != 0){
        separa_val(simulacao->jogada, rank2);
        for(i = 0; i < 13; i++)
            if(rank2[i] == 3){
                ++i;
                break;
            }
    }
    for(; i < 13; i++){
        temp = 0;
        if(rank[i] > 2){
            for(n = 0; n < 4; n++)
                if(carta_existe(mao, n, i)){
                    temp = add_carta(temp,n,i);
            		c++;
                    if(c == 3){
                        c = 0;
                        n = 4;
                    }
                }
            for(v = 0; v < 13; v++)
                if(rank[v] > 1 && v != i){
                    jogadas[count] = temp;
                    for(n = 0; n<4; n++)
                        if(carta_existe(mao,n,v)){
                            jogadas[count] = add_carta(jogadas[count],n,v);
                            c++;
                            if(c == 2){
                                c = 0;
                                count++;
                                n = 4;
                            }
                        }
                }
        }
    }
    return count;
}
Esempio n. 15
0
/**
Função que valida o highlight do jogador, para 1, 2 ou 3 cartas. Aqui, é permitido ao utilizador jogar uma das 3 combinações.
@param e O estado actual.
@returns Um inteiro 1 se for possível jogar, caso contrário retorna 0.
*/
int utilizador_joga_singles_pares_triplos (ESTADO e) {
    if (e.ultima_jogada == -1) {
        if (!combinacao_valida (e.highlight) ) {
            return 0;
        }
        else {
            if (e.actual_jogador != 0) {
                return 0;
            }
            else {
                if ((da_valor (e.highlight) != -1) && (carta_existe(e.highlight, 0, 0))) {
                    return 1;
                }
                else return 0;
            }
        }
    }
    
    if (e.ultimo_jogador == 0) {
        if (!combinacao_valida (e.highlight) ) {
            return 0;
        }
        else {
            if (e.actual_jogador != 0) {
                return 0;
            }
            else {
                if ((da_valor (e.highlight) != -1) ) {
                    return 1;
                }
                else return 0;
            }
        }
    }
    
    else {
        if (!combinacao_valida (e.highlight)) {
            return 0;
        }
        else {
            if (e.actual_jogador != 0) {
                return 0;
            }
            else {
                if (!compara_tamanho (e.ultima_jogada, e.highlight)) {
                    return 0;
                }
                else {
                    if (!combinacao_maior (e.ultima_jogada, e.highlight)) {
                        return 0;
                    }
                }
            }
        }
        return 1;
    }
}
Esempio n. 16
0
void separa_nap (MAO mao, int y[4]){
    int i,n,v;
    for(i=0;i<52;i++){
        n = i/13;
        v = i%13;
        if(carta_existe(mao,n,v)){
            y[n]++;
        }
    }
}
Esempio n. 17
0
void atualizastraight(int v[13], MAO mao, int y[2]) {
    int ind = 0, i;
    if (v[11] != 0 && v[12] != 0){ /*temos um ás e é o primeiro da sequência, pq existe um 2 */
        y[0] = 3; /*5 de alguma coisa é obrigatoriamente a carta mais alta*/
        for(i = 0; i < 4; i++)
            if(carta_existe(mao, i, 2)){
                y[1] = i;
                break;
            }
    }
    else {
        for(i = 0; i < 4; i++)
            if(carta_existe(mao,i, 12))
                mao = rem_carta(mao, i, 12); /*remove os 2's*/
        ind = maior_carta_mao(mao);
        y[0] = (ind % 13) + 1;
        y[1] = ind / 13;
    }
}
Esempio n. 18
0
void separa_val (MAO mao, int y[13]){
    int i,n,v;
    for(i=0;i<52;i++){
        n = i/13;
        v = i%13;
        if(carta_existe(mao,n,v)){
            y[v]++;
        }
    }
}
Esempio n. 19
0
/**
A função jogar vai ser invocada pela função parse, e vai retirar as cartas da mão do jogador caso esta exista no highlight,
colocando-a na posição do tabuleiro correspondete a jogada do utilizador, ou seja, vai ser a função executada quando carregamos no botao jogar para um dado highlight.
Esta função também convoca as funções dos bots que executam as suas jogadas enquanto não for a vez do utilizador jogar.
@param e O estado actual.
@returns O novo estado.
*/
ESTADO jogar (ESTADO e) {
    
    int n, v, x, y;
    
    x = 551;
    y = 450;
    
    e.play = 0;
    if(e.layout == 1){
        for (v = 0; v < 13; v++) {
            for (n = 0; n < 4; n++) {
                if (carta_existe((e.highlight), n, v)) {
                    e.mao[0] = rem_carta(e.mao[0], n, v);
                    x += 20;
                    imprime_carta(BARALHO, x, y, e, 4, n , v);
                }
            }
        }
    }
    else{
        for (n = 0; n < 4; n++) {
            for (v = 0; v < 13; v++) {
                if (carta_existe((e.highlight), n, v)) {
                    e.mao[0] = rem_carta(e.mao[0], n, v);
                    x += 20;
                    imprime_carta(BARALHO, x, y, e, 4, n , v);
                }
            }
        }
        
    }
    
    e = bots2(e);
    while(e.actual_jogador != 0 && e.cartas[0] != 0 && e.cartas[1] != 0 && e.cartas[2] != 0 && e.cartas[3] != 0){
        e = bots2(e);
    }
    
    e.actual_jogador = 0;
    e.highlight = 0;
    return e;
    
}
Esempio n. 20
0
void checkFirst(MCtree tree, DATABASE * data){
    int counter_tree, nc;
    for(nc = 0; nc < 4; nc+= 1){
        for(counter_tree = 0; (tree->nextN[nc][counter_tree] != NULL) && (counter_tree < 40); counter_tree++)
            if((tree->nextN[nc][counter_tree]->estado == 0) || (carta_existe(tree->nextN[nc][counter_tree]->estado,0,0) == 0)){
                    tree->nextN[nc][counter_tree]->t = 0;
                    tree->nextN[nc][counter_tree]->r = 0;
            }
	}
    data->firstplay = 2;
}
Esempio n. 21
0
/**
Conta o número de cartas que se encontra numa mao numa dada altura.
@param m A mão de um jogador.
@returns O número de cartas.
*/
int numero_de_cartas(MAO m) {
    
    int n, v, contaCartas=0;
    
    for (n = 0; n < 4; n++) {
        for (v = 0; v < 13; v++)
        if (carta_existe(m, n, v)) contaCartas++;
    }
    
    return contaCartas;
}
Esempio n. 22
0
int da_maior_naipe (MAO m){
    int n, v, maior=0;
    
    for (n = 0; n < 4; n++) {
        
        for (v = 0; v < 13; v++)
        
        if (carta_existe(m, n, v)) { if (n > maior) maior = n;}
    }
    
    return maior;
}
Esempio n. 23
0
/**
Nas cartas selecionadas pelo utilizador (neste caso um flush), determina o valor da maior carta desse, para mais tarde comparar, se necessário, com as ultimas jogadas, de forma a avaliar a jogada.
@param m A mão de um jogador.
@returns O valor da maior carta do flush.
*/
int maior_carta_flush (MAO m) {
    
    int i, n, v;
    i = 0;
    for (v = 0; v < 13; v++) {
        for (n = 0; n < 4; n++) {
            if (carta_existe(m,n,v)) i = v;
        }
    }
    
    return i;
}
Esempio n. 24
0
/**
Depois de ser validada um flush na mão de um dos bots, esta função determina o valor da maior carta nesse flush, para se for necessário comparar com valores iguais.
A função retorna o valor da maior carta do flush.
@param m A mão de um jogador.
@param n1 Naipe correspondente ao flush.
@returns O valor da maior carta do flush.
*/
int maior_carta_flush_bots (MAO m, int n1) {
    int i,v,flag;
    i = 0;
    flag = 0;
    for (v = 12; (v >= 0) && (flag != 1); --v) {
        if (carta_existe(m,n1,v)) {
            flag = 1;
            i = v;
        }
    }
    return i;
}
Esempio n. 25
0
/**
Nas cartas selecionadas pelo utilizador (neste caso um straight), determina o valor da maior carta desse, para mais tarde comparar, se necessário, com as ultimas jogadas, de forma a avaliar a jogada.
@param m A mão de um jogador.
@returns O valor da maior carta de um straight.
*/
int maior_carta_straight (MAO m) {
    
    int v,i,n,j;
    
    int contaValores[14];
    
    for (i = 0; i < 14; i++) {
        contaValores[i] = 0;
    }
    
    i = 2;
    for (v = 0; v < 13; v++) {
        for(n = 0; n < 4; n++) {
            switch (v) {
                case 11: if (carta_existe(m,n,v)) { contaValores[0]++; contaValores[13]++; } break;
                case 12: if (carta_existe(m,n,v)) { contaValores[1]++; } break;
                default: if (carta_existe(m,n,v)) { contaValores[i]++; } break;
            }
        }
        i++;
    }
    
    if ((contaValores[1] != 0)) {
        for (j = 12; j >= 0; j--) {
            if (contaValores[j] != 0) {
                return (contaValores[j]);
            }
        }
    }
    
    else {
        for (j = 13; j > 0; j--) {
            if (contaValores[j] != 0) {
                return contaValores[j];
            }
        }
    }
    return 0; /* TER CUIDADO COM ISTO, FOI ADICIONADO PARA RESOLVER PROBLEMAS DE COMPILAÇÃO */
}
Esempio n. 26
0
/**
O estado clear permite-nos após termos diferentes cartas no highlight, removê-las do mesmo, e colocando-as de novo na nossa mão, melhorando assim a jogabilidade.
@param e O estado actual.
@returns O novo estado.
*/
ESTADO clear(ESTADO e){
    int n,v;
    n=0;
    v=0;
    
    for (n = 0; n <= 3; n++)
    for (v = 0; v <= 12; v++) {
        if(carta_existe(e.highlight,n,v)){
            e.highlight = rem_carta(e.highlight,n,v);
        }
    }
    return e;
}
Esempio n. 27
0
void simula_maos(DATABASE * data){
    int ind, jog;
    int i,n,v;
    int num[4] = {13,13,13,13};
    int flag = 0;
    MAO atribuir=0x000fffffffffffff;
    for(jog = 1; jog<4; jog++)
        data->mao[jog] = 0;
    
    for(ind = 0;ind < 52; ind ++){
        n = ind / 13;
        v = ind % 13;
        for(i = 0; i < 3; i++){
            if(carta_existe(data->usadas[i+1],n,v)){
                atribuir = rem_carta(atribuir, n, v);
                num[i]--;
            }
            else if(carta_existe(data->mao[0],n,v) ||carta_existe(data->usadas[0],n,v) )
                atribuir = rem_carta(atribuir, n, v);
        }
    }
    for (ind = 0; ind < 52 ; ind ++){
        n = ind / 13;
        v = ind % 13;
        if(carta_existe(atribuir,n,v)){
            do{
                flag = 0;
            	jog = rand()%3;
                if(num[jog] > 0){
                    data->mao[jog+1] = add_carta(data->mao[jog+1],n,v);
                    num[jog]--;
                    flag = 1;
                }
            }while(flag == 0);
        }
    }
}
Esempio n. 28
0
int maior_carta_mao(MAO mao){
    int ind;
    int max=-1;
    int n,v;
    
    for(ind=0;ind<52;ind++){
        n=ind/13;
        v=ind%13;
        if(carta_existe(mao,n,v)){
            if((v>max%13||(v==max%13&&n>max/13)) || max == -1)
                max = ind;
        }
    }
    return max;
}
Esempio n. 29
0
int jogadas1(DATABASE * simulacao, int jog, MAO jogadas[40]){
    int count = 0, n = 0, v,max;
    max = maior_carta_mao(simulacao->jogada);
    if(max == -1)
        v = 0;
    else{
        v = max % 13;
        n = max / 13;
    }
    for(; n<4; n++)
        if(carta_existe(simulacao->mao[jog],n,v)){
            jogadas[count] = add_carta(0,n,v);
            count++;
        }
    v++;
    for(; v < 13; v++)
        for(n= 0; n < 4; n++)
        	if(carta_existe(simulacao->mao[jog],n,v)){
            	jogadas[count] = add_carta(0,n,v);
            	count++;
            }
    count++;
    return count;
}
Esempio n. 30
0
/**
Ao receber o highlight do utilizador (neste caso um flush), confirma se este é válido para ser efetuada uma jogada.
Nesta função, é retornado 0,1,2 ou 3 conforme o naipe do flush.
Exemplo:
0 -> Ouros;
1 -> Copas;
etc...
Com isto, conseguimos mais tarde avaliar dois flushes.
@param m A mão de um jogador.
@returns Um inteiro (0,1,2,3), que corresponde a diferentes naipes.
*/
int valida_flush (MAO m) {
    
    int v, n, i;
    
    int contaNaipes[4];
    
    for (i = 0; i < 4; i++) {
        contaNaipes[i] = 0;
    }
    
    for (v = 0; v < 13; v++)
    for(n = 0; n < 4; n++) {
        switch(n) {
            case 0: if (carta_existe(m,n,v)) { contaNaipes[0]++; } break;
            case 1: if (carta_existe(m,n,v)) { contaNaipes[1]++; } break;
            case 2: if (carta_existe(m,n,v)) { contaNaipes[2]++; } break;
            case 3: if (carta_existe(m,n,v)) { contaNaipes[3]++; } break;
        }
    }
    
    
    if (contaNaipes[0] >= 5) return 0;
    
    else {
        if (contaNaipes[1] >= 5) return 1;
        
        else {
            if (contaNaipes[2] >= 5) return 2;
            
            else {
                if (contaNaipes[3] >= 5) return 3;
                else return -1;
            }
        }
    }
}