int main (void)
{
int contador = 0 ;
char opcaoEscolhidaModificar ;
int opcaoEscolhida ;
int Time;
/* Movimentos */
char NomePeca[MAX_NOME];
char NomePosicao[2];
char * NomeBusca;
int Diagonal;
int Reta;
int QtdeMov;
/* Disposicao */
int NumPecas;
int NumPecasA;
int NumPecasB;
TAB_tpCondRet TabRet;
TAB_tppTabuleiro pTabuleiro;
JOG_tpCondRet JogRet;
JOG_tppJogo pJogo;
JOG_tppPecaJogo pPecaBuscaJogo;
PEC_tpCondRet PecaRet;
PEC_tppPeca pPecaBusca;
while ( 1 )
{
imprimeMenuPrincipal () ;
scanf ( "%d", &opcaoEscolhida ) ;
system ( "cls" ) ;
switch ( opcaoEscolhida )
{
/* Cria tabuleiro */
case 1: /* Criando um segundo tabuleiro, o primeiro é destruído. */
puts ( " Voce escolheu: 1- Criar tabuleiro." ) ;
TabRet = TAB_CriarTabuleiro(&pTabuleiro);
if(pTabuleiro==NULL){
puts ( "O tabuleiro nao foi criado!" ) ;
break ;
}
puts ( "Tabuleiro criado" ) ;
break;
/* Apresenta tabuleiro */
case 2: /* Mostra visualmente o tabuleiro */
puts ( " Voce escolheu: 2- Apresentar tabuleiro." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
TabRet = TAB_ApresentaTabuleiro(pTabuleiro);
puts ( "Percurso no Tabuleiro" ) ;
break;
/* Criar peca */
case 3: /* Efetua a criacao de peca */
puts ( " Voce escolheu: 3- Criar peca." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
printf("Informe o nome da peca:");
scanf ( "%s", &NomePeca ) ;
printf("Sua peca anda para DIAGONAL? (1 - Sim | 0 - Nao):");
scanf ( "%d", &Diagonal ) ;
if(Diagonal > 1){
puts("Informacao errada!");
}
printf("Sua peca anda em linha RETA? (1 - Sim | 0 - Nao):");
scanf ( "%d", &Reta ) ;
if(Reta > 1){
puts("Informacao errada!");
}
printf("Qual a quantidade de casas que sua peca anda? ");
scanf ( "%d", &QtdeMov ) ;
if(QtdeMov > 7){
puts("Informacao inconsistente!");
}
TabRet = TAB_CriarTipoPeca(pTabuleiro , NomePeca , Diagonal , Reta , QtdeMov );
strcpy(NomePeca , "");
puts ( "Peca criada \n" ) ;
break;
/* Apresenta pecas */
case 4: /* Mostra visualmente as pecas */
puts ( " Voce escolheu: 4 - Apresentar tipo pecas." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
TabRet = TAB_ApresentaTipoPecas(pTabuleiro);
if(TabRet == TAB_CondRetOK){
puts ( "Pecas do Tabuleiro" ) ;
} /* if */
break;
/* Montar time */
case 5: /* Montar time com pecas */
puts ( " Voce escolheu: 5 - Montar time." ) ;
JOG_CriarJogo(&pJogo);
imprimeMenuEscolhaTime();
scanf ( "%d", &Time ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
printf ( "Informe o numero de pecas do time %d : " , Time ) ;
scanf ("%d" , &NumPecas);
while(NumPecas > 0){
printf( "Informe o nome da peca : " );
scanf ( "%s", &NomePeca ) ;
TabRet = TAB_ProcuraPeca (pTabuleiro , NomePeca , (void**)&pPecaBusca);
if(TabRet != TAB_CondRetOK){
puts("Peca nao localizada\n");
}else{
JogRet = JOG_InserirPecaTimeA(pJogo , pPecaBusca);
NumPecas--;
}
}
imprimeMenuEscolhaTime();
scanf ( "%d", &Time ) ;
printf ( "Informe o numero de pecas do time %d : " , Time ) ;
scanf ("%d" , &NumPecas);
while(NumPecas > 0){
printf( "Informe o nome da peca : " );
scanf ( "%s", &NomePeca ) ;
TabRet = TAB_ProcuraPeca (pTabuleiro , NomePeca , (void**)&pPecaBusca);
if(TabRet != TAB_CondRetOK){
puts("Peca nao localizada\n");
}else{
JogRet = JOG_InserirPecaTimeB(pJogo , pPecaBusca);
NumPecas--;
}
}
break;
/* Dispor pecas */
case 6: /* Colocar as pecas nas casas */
puts ( " Voce escolheu: 6 - Dispor pecas." ) ;
if(pTabuleiro==NULL){
puts ( "O tabuleiro precisa ser criado!" ) ;
break ;
}
JOG_NumPecasTime(pJogo , 'A' , &NumPecasA);
if(NumPecasA==0){
puts ( "Time A nao possui pecas definidas" ) ;
break ;
}
JOG_NumPecasTime(pJogo , 'B' , &NumPecasB);
if(NumPecasB==0){
puts ( "Time B nao possui pecas definidas" ) ;
break ;
}
/* Colocacao time A */
JOG_IrInicioPecas(pJogo , 'A');
puts("**** Disposicao das pecas do time A: ****\n");
while (NumPecasA > 0){
JOG_ObterTipoPeca(pJogo , 'A' , (void**)&pPecaBusca);
PEC_ObterNome(pPecaBusca , (void**)&NomePeca);
printf("Indique a posicao da peca %s : " , NomePeca);
scanf ( "%s", &NomePosicao ) ;
/** Colocar a peca na casa do tabuleiro **/
JOG_ObterPecaJogo(pJogo , 'A' , (void**)&pPecaBuscaJogo);
TAB_SetarCorrente(pTabuleiro , NomePosicao);
TAB_InserirConteudoCasa(pTabuleiro , pPecaBuscaJogo );
/** Fim do colocar a peca na casa do tabuleiro **/
JOG_AvancarCorrrenteTime(pJogo , 'A' , 1);
NumPecasA--;
}
/* Colocacao time B */
JOG_IrInicioPecas(pJogo , 'B');
puts("**** Disposicao das pecas do time B: ****\n");
while (NumPecasB > 0){
JOG_ObterTipoPeca(pJogo , 'B' , (void**)&pPecaBusca);
PEC_ObterNome(pPecaBusca , (void**)&NomePeca);
printf("Indique a posicao da peca %s : " , NomePeca);
scanf ( "%s", &NomePosicao ) ;
/** Colocar a peca na casa do tabuleiro **/
JOG_ObterPecaJogo(pJogo , 'B' , (void**)&pPecaBuscaJogo);
TAB_SetarCorrente(pTabuleiro , NomePosicao);
TAB_InserirConteudoCasa(pTabuleiro , pPecaBuscaJogo );
/** Fim do colocar a peca na casa do tabuleiro **/
JOG_AvancarCorrrenteTime(pJogo , 'B' , 1);
NumPecasB--;
}
JOG_PreencheCaminho(pJogo , pTabuleiro );
break;
/* Salvar partida */
case 7: /* Salvar atual configuração do jogo. */
puts ( " Voce escolheu: 7 - Salvar JOGO." ) ;
gravarArquivo(pTabuleiro , pJogo , pPecaBusca);
break;
case 10:
exit(1);
/* Usuário com caracter não esperado */
default: puts ( "Favor entre com uma das opcoes abaixo." ) ;
break ;
} /* switch */
} /* while */
return 0;
}
void main(){
//mostramos una imagen super fancy
imprimeImagenPrincipal(" ");
printf("\n\n\tPulsa [ENTER] para comenzar!\n");
pausa();
//srand(time(NULL));
char opcion[STRING_MAX];
char opcionJuego[STRING_MAX];
boolean menu = TRUE; //variable del bucle del menu de opciones inicial
boolean juego = FALSE; //variable del bucle del juego
boolean buclePreJuego = FALSE; //variable del bucle de las opciones del juego
boolean bucleTurnosJuego = FALSE; //variable del bucle de las jugadas
//============================================
// BUCLE MENU PRINCIPAL
//--------------------------------------------
while(menu){
//limpia la consola
limpiar();
imprimeMenuPrincipal();
fflush(stdin); //limpia buffer entrada
fgets(opcion, STRING_MAX, stdin);
//Opciones de entrada
//opcion 1: entrar a un juego nuevo.
if(atoi(opcion) == 1){
buclePreJuego = TRUE;
}
//opcion 2: salir
if(atoi(opcion) == 2){
menu = FALSE;
}
//====================================================
// BUCLE PRE-JUEGO
//----------------------------------------------------
char cantidadJugadores[STRING_MAX];
nodo* jugadores = NULL; //jugadores
nodo* mazo = NULL; //mazo del juego
nodo* pozo = NULL; //donde se tiran las cartas
nodo** manos = NULL; // cartas de los jugadores (puntero doble porque es un malloc de nodo*)
while(buclePreJuego){
//====================================================
// CONDICIONES PRE-JUEGO
//----------------------------------------------------
limpiar();
printf("Condiciones pre-juego.\n");
//cuantos jugadores (incluyendo el humano)
printf("ingrese la cantidad de jugadores [2-10]: ");
fflush(stdin);
fgets(cantidadJugadores,STRING_MAX, stdin);
printf("jugadores: %d\n", atoi(cantidadJugadores));
if(atoi(cantidadJugadores) < 2){
buclePreJuego = FALSE;
}
else{
//hacemos un arreglo de listas enlazadas que seran las manos.
manos = (nodo**)malloc(sizeof(nodo*)*atoi(cantidadJugadores));
//generamos el mazo del juego con orden aleatorio
mazo = crearMazo();
//colocamos una carta del mazo en el pozo.
nodo* cartaInicial = obtener(mazo,0); //sacamos la primera carta
pozo = push(pozo, cartaInicial->dato, cartaInicial->dato2);
mazo = borrarTipo(mazo, cartaInicial->dato,cartaInicial->dato2);
//agrega los jugadores a una lista...
//...los CPU...
int t;
for(t=0;t<atoi(cantidadJugadores)-1;t++)
{
jugadores = push(jugadores, JUGADOR_CPU,-1);
}
//...y al humano.
jugadores = push(jugadores, JUGADOR_HUMANO,-1);
//agregamos las manos
int j,m;
for(j=0;j<atoi(cantidadJugadores);j++){
manos[j] = NULL;
for(m=0; m<MANO_INICIAL;m++){
//numero random
//vemos una carta
cartaInicial = obtener(mazo,0); //sacamos la primera carta
//se coloca en la mano
manos[j]= push(manos[j],cartaInicial->dato,cartaInicial->dato2);
//se borra del mazo
mazo = borrarTipo(mazo, cartaInicial->dato,cartaInicial->dato2);
}
}
//muestra los turnos del juego antes de comenzar.
muestraTurnos(jugadores);
//borrar
//printf("largo del mazo: %d\n", largo(mazo));
//listarCartas(mazo);
//fin borrar
printf("\nPresione ENTER para comenzar la partida...");
pausa();
//terminamos condiciones pre-juego
buclePreJuego = FALSE;
//y vamos al bucle de turnos...
bucleTurnosJuego = TRUE;
}
}
//----------------------------------------------------------
// FIN bucle pre-juego
//==========================================================
//==========================================================
// BUCLE TURNOS DEL JUEGO
//----------------------------------------------------------
limpiar();
int turno=-1; //turno actual
char opcionJuego[STRING_MAX]; //entrada por teclado
char sentido = 1; //sentido de los turnos (para cartas invertir)
nodo* jugadorActual; //jugador que le toca turno
while(bucleTurnosJuego){
//verifica si quedan cartas en el mazo
if(largo(mazo)<1){
//si no hay cartas voltea el pozo
mazo = volteaPozo(&mazo,&pozo);
}
turno = estableceTurno(atoi(cantidadJugadores),turno, sentido);
//imprime estado del juego
imprimeEstadoJuego(mazo,pozo);
//obtiene el jugador que le corresponde el turno.
jugadorActual = obtener(jugadores,turno);
if( jugadorActual->dato == JUGADOR_HUMANO){
printf("Tu turno!\n");
//muestra la mano del jugador
mostrarMano(manos[turno]," ");
//imprimirCartitas(largo(manos[turno]));
//interaccion en turno
printf(" Botar carta: ");
fflush(stdin);
fgets(opcionJuego,STRING_MAX,stdin);
//reaccion a la opcion
//==================================================
// JUGADA DEL JUGADOR HUMANO
//--------------------------------------------------
//si el turno no es exitoso, no se avanza al siguiente jugador...
if(!logicaTurno(&manos[turno], &mazo, &pozo, &turno, opcionJuego)){
if(sentido){
turno--;
}
else
turno++;
}
else{
if(largo(manos[turno])==0){
limpiar();
printf("\n\t\aFELICIDADES, HAS GANADO!!!\n\n");
imprimeEstadoJugadores(jugadores,manos);
printf("\n\t\aFELICIDADES, HAS GANADO!!!\n\n");
bucleTurnosJuego = FALSE;
printf("Presione [ENTER] para ontinuar...");
pausa();
}
}
//para salir
if(atoi(opcionJuego) == -1){
bucleTurnosJuego = FALSE;
}
//--------------------------------------------------
// FIN jugada del jugador humano
//==================================================
//este "limpiar" permite que se vean solo las jugadas
//de las CPU que se hacen hasta que le toca al usuario.
limpiar();
}
else{
//==========================================================
//JUGADA AUTOMATICA DE COMPUTADORAS
//----------------------------------------------------------
printf("Turno Computadora %d, mano:", turno+1);
imprimirCartitas(largo(manos[turno]));
//si el turno no es exitoso, no se avanza al siguiente jugador...
if(!jugadaAutomatica(&manos[turno], &mazo, &pozo, &turno)){
if(sentido){
turno--;
}
else
turno++;
}
else{
if(largo(manos[turno])==0){
limpiar();
imprimeEstadoJuego(mazo,pozo);
printf("\n\t\aLA COMPUTADORA %d, HA GANADO!\n",turno+1);
imprimeEstadoJugadores(jugadores,manos);
printf("\n\t\aLA COMPUTADORA %d, HA GANADO!\n",turno+1);
bucleTurnosJuego = FALSE;
printf("Presione [ENTER] para continuar...");
pausa();
}
}
//-----------------------------------------------------------
// FIN jugada automatica de computadoras
//===========================================================
}
}
//--------------------------------------------------------------
// FIN bucle turnos juego
//==============================================================
//======================================
// LIBERACION DE MEMORIA
//--------------------------------------
//liberamos lista de jugadores
jugadores = anular(jugadores);
//libera el mazo
mazo = anular(mazo);
//libarar el pozo
pozo = anular(pozo);
//libramos manos
if(manos != NULL){
int d;
for(d=0; d < atoi(cantidadJugadores);d++){
manos[d] = anular(manos[d]);
}
free(manos);
}
//-------------------------------------
// FIN liberacion memoria
//=====================================
}
//--------------------------------
// FIN bucle menu principal
//================================
}
