/* Genera la instruccion para una operacion infija y construye un registro semantico con el resultado. */
struct reg_expr gen_infijo(struct reg_expr *pei, struct reg_op *op, struct reg_expr *ped){
struct reg_expr reg;
static unsigned int numTemp = 1;
char cadTemp[TAMLEX] ="Temp&";
char cadNum[TAMLEX];
char cadOp[TAMLEX];
strcpy(cadOp, operaciones[op->cod_oper]);
sprintf(cadNum, "%d", numTemp);
numTemp++;
strcat(cadTemp, cadNum);
if (pei->clase == ID)
{
chequear(extraer(pei));
}
if (ped->clase == ID)
{
chequear(extraer(ped));
}
chequear(cadTemp);
generar(cadOp, extraer(pei), extraer(ped), cadTemp);
strcpy(reg.nombre, cadTemp);
return reg;
}
void pruebasGenerar(){
//La prueba de este módulo es similar a la del anterior
tablero t;//Iniciamos un tablero t
iniciar(t,TAMANIOTABLERO);
entornoIniciar(TAMANIOTABLERO);
generar(t);//Generamos un valor en el tablero
pintarTablero(t);//Mostramos los cambios en pantalla durante unos segundos
entornoPausa(5000000);
cout<<"Se genrará 1 numero aleatorio (2 o 4) en una casilla aleatoria vacia del tablero"<<endl;
}
int main(void) {
remove("hola.out");
listavacia();
listade1();
listademas();
selvacia();
selllena();
listadesels();
ordenar();
map();
filtrar();
generar();
return 0;
}
void tratar_instruccion_con_3_argumentos (int instruccion, int arg1, int arg2, int arg3)
{
instno++;
if (numPasada == 2)
{
generar(yyout, instruccion, arg1, arg2, arg3);
/* Tratamiento de errores en los argumentos de OSF */
if ((arg3 <= 0) || (arg2 < 0) || (arg1 <= 0))
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion OSF tiene algun argumento erroneo\n",
lineno, linepos);
error = 1;
}
}
}
/** Funcion principal del programa*/
int main()
{ //Impresión de estructura para visualizar resultados obtenidos
printf("*--------------------------------------*\n");
printf("* PROGRAMA PARA CODIFICAR FRASES *\n");
printf("*--------------------------------------*\n");
printf("Por favor Ingrese una frase:\n");
generar();
printf("*--------------------------------------*\n");
printf("+ La frase %s tiene %d caracteres. +\n",txt,n);
printf("*--------------------------------------*\n");
printf("*...........................................*\n");
printf("La generacion aleatoria de codificacion es:\n ");
printf("*...........................................*\n");
codificar();
printf("\n");
system("PAUSE");
return 0;
}
/* Genera la instruccion para escribir. */
void escribir_exp(struct reg_expr *pout){
generar("Write", extraer(pout), "Integer", "");
}
/* Genera la instruccion para leer. */
void leer_id(struct reg_expr *pin){
generar("Read", pin->nombre, "Integer", "");
}
/* genera la instruccion para la asignacion */
void asignar(struct reg_expr *vizq, struct reg_expr *vder){
generar("Store", extraer(vder), vizq->nombre, "");
}
/* Genera la instruccion para terminar la ejecucion del programa */
void terminar(void){
generar("Stop","","","");
}
void tratar_instruccion_con_1_argumento (int instruccion, int arg1)
{
instno++;
if (numPasada == 2)
{
generar(yyout, instruccion, arg1);
/* Tratamiento de errores */
switch (instruccion)
{
case STC: if ((arg1 < SHRT_MIN) || (arg1 > SHRT_MAX))
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion STC tiene un argumento fuera del rango permitido para el mismo.\n",
lineno, linepos);
printf("El rango permitido es [%d, %d]\n", SHRT_MIN, SHRT_MAX);
error = 1;
}
break;
case ENP: if (arg1 == instno)
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion ENP no puede saltar a si misma\n",
lineno, linepos);
error = 1;
}
if (arg1 <= 0)
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion ENP tiene el argumento erroneo\n",
lineno, linepos);
error = 1;
}
if (arg1 > numInst)
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion ENP no puede saltar a una instruccion mas alla del final del programa\n",
lineno, linepos);
error = 1;
}
break;
case JMP: if (arg1 == instno)
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion JMP no puede saltar a si misma\n",
lineno, linepos);
error = 1;
}
if (arg1 <= 0)
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion JMP tiene el argumento erroneo\n",
lineno, linepos);
error = 1;
}
if (arg1 > numInst)
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion JMP no puede saltar a una instruccion mas alla del final del programa\n",
lineno, linepos);
error = 1;
}
break;
case JMF:
case JMT: if (arg1 <= 0)
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion tiene el argumento erroneo\n",
lineno, linepos);
error = 1;
}
if (arg1 > numInst)
{
printf("ERROR SEMANTICO! (%d, %d): no se puede saltar a una instruccion mas alla del final del programa\n",
lineno, linepos);
error = 1;
}
break;
case RD:
case WRT: if ((arg1 != 0) && (arg1 != 1))
{
printf("ERROR SEMANTICO! (%d, %d): La instruccion no puede tener un argumento distinto de 0 o 1\n",
lineno, linepos);
error = 1;
}
break;
default : ;
}
}
}
void tratar_instruccion_sin_argumentos (int instruccion)
{
instno++;
if (numPasada == 2) generar(yyout, instruccion);
}
AlGenetico::AlGenetico(){
Bola* poblacionInit=(Bola*)malloc(sizeof(Bola)*poblacionI);
generar(poblacionInit);
}
int bt(int ** tablero, int dimension, int filini, int colini,
int * peso_solucion, par * soa)
{
/* primero todas las variables que necesitamos!!!!!!!!!!
* PXS
* sandrita, se me va la cabeza :$ por ti! */
/* como la solucion final estara en soa, en vez de considerar
* el parametro de la funcion como s, lo consideramos como soa */
par * s;
int ** recorridos;
par * paresmov;
int voa;
int peso;
int nivel;
int * mov;
int i;
/* procedemos a inicilizar todas las variables que hemos declarado */
/* memoria para s y soa */
s = (par *)malloc(MAXNIVEL*sizeof(par));
/* vamos a inicializar estas dos variables anterios, cada par tendra
* el valor de (-1,-1) */
inicializa_pares(s, -1, dimension);
inicializa_pares(soa, -1, dimension);
/* y la de movimientos! que son inicializados a -1 */
mov = (int *)malloc(MAXNIVEL*sizeof(int));
for (i = 0; i < MAXNIVEL; i++) {
mov[i] = -1;
}
/* creamos el array que tiene codificados los 4 movimientos */
paresmov = (par *)malloc(3*sizeof(par));
inicializa_paresmov(paresmov);
/* tambien inicializamos recorridos */
recorridos = inicializa_matriz(dimension, 0);
/* inicializacion de las variables! */
voa = 0xffff;
recorridos[filini][colini] = 1;
s[0].f = filini;
s[0].c = colini;
nivel = 0;
/* peso almacena el peso del camino que vamos a formar */
peso = tablero[s[0].f][s[0].c];
/* el cuerpo de nuestro programa */
do {
/*pinta_s(s, dimension);*/
if (solucion_bt(s, nivel, dimension)) {
if (peso < voa) {
voa = peso;
/*printf("Nueva solucion optima\n");
pinta_s(s, dimension);*/
asigna_pares(s, soa);
}
}
if (criterio(recorridos, s, peso, voa, nivel, dimension)) {
nivel++;
generar(tablero, mov, recorridos, s, nivel, &peso, paresmov);
}
else {
while ((nivel != 0) && (!mashermanos(mov, nivel))) {
retroceder(tablero, recorridos, mov, s, &nivel, &peso);
}
if (nivel != 0) {
generar(tablero,mov,recorridos,s,nivel,&peso,paresmov);
}
}
} while (nivel != 0);
*peso_solucion = voa;
return 0;
}
void main(){ //declaraciones de variables a usar dentro del main
int tablero[MAX],p1[MAX],p2[MAX],din_p2=100;
int i,avance1=0,avance2=0,din_p1=100,jugada,jug,ronda=1,fin=0,dado,carcel1=0,carcel2=0;
char op;
srand(time(NULL));
for(i=0; i<MAX ; i++) //inicializamos el tablero en 0
tablero[i]=0;
generar(tablero,MAX);
printf("\t\t\t\t*************\n\t\t\t\t*Bienvenidos*\n\t\t\t\t*************\n");
printf("\t\t\t\t *MONOPOLIO*\n\n");
do{
mostrar(tablero,MAX);
printf("\n\nRONDA %d\n",ronda); //ronda es el numero de lanzamientos que realizan los jugadores
printf("\n\nPlayer 1\tPresione cualquier tecla para lanzar los dados\n"); //jugador 1
op=getch();
if(op!=27){ //si el jugador presiona la tecla esc sale del programa
if(carcel1<1){
dado=lanzar_dado(); //lanza los dados
avance1=avance1 + dado; //el jugador avanza segun el resultado del dado
printf("el resultado fue %d\n",dado); //imprime el resultado del dado
if(avance1>39){ //si el jugador avanza mas de 39 (limite del arreglo) continua desde 0 y se incrementa el saldo en 100
avance1=avance1%39;
din_p1+=100;
}
jug=tablero[avance1]; //jug contiene el resultado de la casilla donde cayo el jugador
jugada=obtener_jugada(jug); //jugada determina el tipo de jugada
mostrar_jugada(jugada,jug); //muestra al jugador el contenido de la casilla y el tipo de jugada
getch();
carcel1=esta_en_la_carcel(jugada); //si cae en la carcel entonces carcel=2(numero de turnos que perdera)
if(carcel1==2)
din_p1-=100; //disminuye el saldo en 100
din_p1=din_p1+pago_o_cobro(jug,jugada); //aumenta o disminuye el saldo
avance1=avance1 +avanza_o_retrocede(jug,jugada); //avanza o retrocede segun sea la jugada
if(avance1>39){ //valida el avance para que si sobrepasa el limite del arreglo continue desde el inicio
avance1=avance1%40;
din_p1+=100; //al pasar por inicio aumenta el saldo en 100
}
if(avance1<0) //si retrocede antes del inicio, el jugador se queda en el inicio
avance1=0;
}
else{
printf("el resultado fue 0\n"); //si esta en la carcel se lo sanciona con lanzamientos en cero
carcel1--;
}
printf("player 1 en %d\n",avance1); //muestra la posicion del jugador luego de la ultima jugada
printf("saldo player 1= %d\n",din_p1); //muestra el saldo
fin=finaliza(din_p1,ronda,op); //verifica las condiciones que finalizan el juego
//jugador 2
if(fin!=1){ // si el jugador 1 presiono esc en ese instante finaliza el juego
printf("\n\nPlayer 2\tPresione cualquier tecla para lanzar los dados\n");
op=getch();
if(op!=27){
if(carcel2<1){
dado=lanzar_dado();
avance2=avance2 + dado;
printf("el resultado fue %d\n",dado);
if(avance2>39){
avance2=avance2%40;
din_p2+=100;
}
jug=tablero[avance2];
jugada=obtener_jugada(jug);
mostrar_jugada(jugada,jug);
getch();
carcel2=esta_en_la_carcel(jugada);
if(carcel2==2)
din_p2-=100;
din_p2=din_p2+pago_o_cobro(jug,jugada);
avance2=avance2 +avanza_o_retrocede(jug,jugada);
if(avance2>39){
avance2=avance2%40;
din_p2+=100;
}
if(avance2<0)
avance2=0;
}
else{
printf("el resultado fue 0\n");
carcel2--;
}
printf("player 2 en %d\n",avance2);
printf("saldo player 2= %d\n",din_p2);
fin=finaliza(din_p2,ronda,op);
}
}
}
ronda++; //aumenta la cantidad de lanzamientos que han realizado los jugadores
if(op==27) //si un jugador presiona esc al momento de lanzar los dados el juego termina
fin=1;
if(ronda>20) //si ambos jugadores realizan mas de 20 lanzamientos el juego termina
fin=1;
getch();
}while(fin==0); //el juego continua si ninguna de las condiciones que lo finalizan se cumplen
printf("\n\tGAME OVER\nGRACIAS POR JUGAR MONOPOLIO"); //mensaje de despedida
getch();
} //FIN DEL JUEGO
