[code language="bennu"]Process miniradar();
private
int tiempo;
int cambiar_multiplicador;
Begin
// RECURSOS
resolution=10;
fpg_minijuego=LOAD_FPG("minialunizaje.fpg");
miniradar_fuente=load_fnt("tiempo.fnt");
miniradar_fuente_ceros=load_fnt("null.fnt");
miniradar_fuente_vel=load_fnt("velocidades.fnt");
miniradar_fuente_puntos=load_fnt("puntos.fnt");
miniradar_fuente_sumas=load_fnt("sumas.fnt");
miniradar_fuente_limite=load_fnt("limite_vel.fnt");
// COLOCAMOS OBJETOS EN PANTALLA Y PREPARAMOS EL MINIJUEGO
write_var(0,20,150,4,miniradar_multiplicador);
write_int(miniradar_fuente,400,165,4,&tiempo);
write(0,400,120,4,"VELOCIDAD MÁXIMA: ");
write_var(0,500,120,4,miniradar_vel_max);
write(0,400,140,4,"VELOCIDAD MINIMA: ");
write_var(0,500,140,4,miniradar_vel_min);
crear_mapa();
from i=1 to jugadores;
write_var(miniradar_fuente_puntos,miniradar_pos_contadores
- +8,miniradar_pos_contadores[1]+70,4,puntos);
end
from i=1 to jugadores; creador_coches(i);radar_miniradar(i); end //creamos los creadores XD
valla_miniradar(115,0);
valla_miniradar(315,1);
valla_miniradar(515,0);
valla_miniradar(715,1);
// PREPARADOS, LISTOS...
getready();
// YA!
dificultad_miniradar();
/****************BUCLE PRINCIPAL****************************/
while(ganador==0)
/*Truco malvado a borrar*/
if(key(_1))bonus_miniradar(1,1);end
if(key(_2))bonus_miniradar(2,1);end
if(key(_3))maltiempo_miniradar(1);end
/*Truco malvado a borrar*/
from i=1 to jugadores
if((miniradar_bonus==3)&&(miniradar_niebla_llamada==0))//mira a ver si el jugador tiene el bonus de niebla y no acaba de llamar a ninguna
maltiempo_miniradar(i);
niebla_miniradar(i,1);end//si no hay ninguna en ejecucuion llama a ...la niebla...
end//from
tiempo=(90-timer/100);
cambiar_multiplicador=rand(0,400);
if(cambiar_multiplicador==10)miniradar_multiplicador=miniradar_multiplicadores[rand(0,13)];end
frame;
end //aquí nos quedamos hasta que gane alguien
// ESPERAMOS UNOS SEGUNDOS Y SALIMOS DEL MINIJUEGO
frame(5000); //esperamos un poquico
menu(1); //y salimos del minijuego
End
[/code]
[code language="bennu" options="singleline"]
niebla_miniradar(i,1);end//si no hay ninguna en ejecucuion llama a ...la niebla..[/code].
Si cambio la i de esta linea por cualquier valor, o incluso si borro la línea me da un error que dice
unknown identifier al line 94 "BEGIN"
pero en la línea 94 no hay ningún begin, son las declaraciones de las variables globales. Esto me deja rallado...
te falta el ";" en el from, ahora todas las instrucciones cuyos parametros (por definicion) no se encierran entre parentesis deben ser cerrados por ";"
OOOOOOOstia puta! pues, me he fijado y hay muchos en los que tengo el ; y otros muchos en los que no, pero no me había dado error hasta ahora.
He puesto el punto y coma en ese from (solo en ese) y me sigue dando el mismo error si borro la línea. También he probado poniendo ; en todos los from y me da exactamente el mismo error. Lo raro, es que antes de escribir esa línea, funcionaba, mal, pero funcionaba, y desde que la escribí me da ese error que no se ni de donde viene ni a cuento de qué.
el error se puede deber a otra linea de codigo, mas arriba... sin el fuente completo no es posible ayudarte...
Haz por ejemplo una busca de todos los from y comprueba que tengan el ;
Tyco, eso fue lo primero que hize, voy a postearos el 99% del código.[code language="bennu"]declare Process vehiculo_miniradar(int bonus,float velocidad,int jugador);
Private
float avance;
int fotos=1; //valor máximo 1
int carril=0; //por defecto irán por el carril 0
float slow_mo;
int detectado=1;
string bonus_text;
int map_bonus;
int fuentecilla;
end
Public
float velocidad_publica;
float coche_delantero; //2
float coche_derecho; //1
float coche_izquierdo; //0
int frenando;
int adelantando;
end
end
declare Process mapa_frenadas_miniradar(int jugador,x,y);
private
end
Public
int tiempo_nacido;
end
end
global
/*string minirradar_fuente_mini_bonus[4]="autom.fnt",
"slow_motionm.fnt",
"nieblam.fnt",
"lluviam.fnt";*/
int miniradar_niebla_llamada[4];
int miniradar_lluvia_llamada[4];
int miniradar_graficos_bonus[5]=0,34,33,32,31,30;
int miniradar_contorno_bonus[5]=0,44,43,42,41,40;
string minirradar_fuente_bonus[4]="empty","auto.fnt",
"slow_motion.fnt",
"niebla.fnt",
"lluvia.fnt";
int miniradar_bonus[5]; //Los posibles bonus de cada jugador.
//1: Disparo automático
//2: Cámara lenta
//3: Niebla hijaputa
//4: LLuvia mamona
//5: INMUNIDAD
int miniradar_slow_mo=2; //cuan eficiente es la cámara lenta.
miniradar_niebla_pos[4][1]=0,0,200,100,
400,100,
200,400,
400,400;
int miniradar_salida_coches[4]=0,330,330,630,630;
int miniradar_vel_max=100; //Estas variables controlan los
int miniradar_vel_min=50; //margenes de velocidad que toman los coches
int miniradar_flashing[4];
int miniradar_graficos_coches[]=1,12,13,14,15,16,17,18,19,20,21,22;
int miniradar_probabilidad=1; //la probabilidad de que aparezca un coche
int miniradar_vel_permitida=50;//la velocidad máxima permitida en cada momento, con la que te multan
int miniradar_altura_banda[4]=0,280,280,580,580;
int miniradar_vel_detect[4];
int miniradar_limite_superior[4]=0,0,0,300,300;
int miniradar_limite_inferior[4]=0,250,250,550,550;
int miniradar_umbral_desaparicion[4]=0,-20,-20,280,280;
int miniradar_vel_permitidas[]=50,50,50,50,60,70,
50,60,60,70,70,80,
60,70,70,80,80,100,
60,70,70,80,90,100,
70,70,80,80,90,100,
80,90,90,100,100,120,
100,110,120,130,130,140,
100,110,110,140,130,150,
130,140,140,150,140,160;
int miniradar_vel_max_permitida=6; //estas dos variables son para controlar
int miniradar_vel_min_permitida=0; //Los margenes de velocidades permitidas
int miniradar_multiplicadores[]=2,1,2,1,2,2,3,4,5,2,1,1,3,4;
int miniradar_pos_contadores[4][1]=0,0,50,35,
450,35,
50,335,
450,335;
int miniradar_carril_ocupado[4][3];
int miniradar_num_carriles=3;
int miniradar_carril[4][3]=0,0,0,0,160,190,230,260, /*Carriles Jugador 1*/
560,590,630,660, /*Carriles Jugador 2*/
160,190,230,260, /*Carriles Jugador 3*/
560,590,630,660; /*Carriles Jugador 4*/
int miniradar_radar_x[4]=0,50, /*Jugador 1*/
750, /*Jugador 2*/
50, /*Jugador 3*/
750; /*Jugador 4*/
int miniradar_radar_y[4]=0,250, /*Jugador 1*/
250, /*Jugador 2*/
550, /*Jugador 3*/
550; /*Jugador 4*/
int miniradar_multiplicador=1;
int miniradar_fuente;
int miniradar_fuente_ceros;
int miniradar_fuente_vel;
int miniradar_fuente_puntos;
int miniradar_fuente_sumas;
int miniradar_fuente_limite;
int miniradar_num_jugador;
end
process velocimetro_miniradar(x,altura,velocidad,int jugador);
private
int puntaje;
int dif_del_limite;
begin
y=altura;
if(altura>miniradar_limite_superior[jugador] && altura<miniradar_limite_inferior[jugador]) //si está dentro de los límites de la foto estos hay que invertir la comparación, ya que el límite superior es menor que el límite inferior (por lo de la y0 es arriba)
/*Todo lo que se haga ha de h acerse aquí dentro, ya que si no significaría que no le ha pillado la foto*/
dif_del_limite=velocidad-miniradar_vel_permitida;
if(velocidad>miniradar_vel_permitida)
puntaje=(dif_del_limite*miniradar_multiplicador);
else
puntaje=velocidad*dif_del_limite*(0.2);
end
/*Esto es por si está en modo automático y caza a uno que no debe, no lo reste*/
if(miniradar_bonus[jugador]==1 && puntaje>0)
puntos[jugador]+=puntaje;
graph=write_in_map(miniradar_fuente_sumas,puntaje,4);
alpha=240;
repeat
frame;
alpha-=3;
until(alpha<0);
elif(miniradar_bonus[jugador]!=1) //aquí si no está el automático, suma los puntos, sea negativo o positivo
puntos[jugador]+=puntaje;
graph=write_in_map(miniradar_fuente_sumas,puntaje,4);
alpha=240;
repeat
frame;
alpha-=3;
until(alpha<0);
end//if
end //if de evaluación de límites
end //begin
/*---------------------------------*/
/*
process puntuador(int puntaje,int jugador)
private
int negatividad;
begin
if(puntaje<0)
negatividad=1;
puntaje*=(-1);
end//if
from i=1 to puntaje
if(negatividad && puntos[jugador]>=(-1000))
puntos[jugador]--;
elif(!negatividad)
puntos[jugador]++;
end
frame;
end//from
end//begin */
process valla_miniradar(x,flags);
private
int tile;
int j;
int cambiar;
begin
graph=new_map(8,600,16);
y=300;
z=100;
tile=map_clone(fpg_minijuego,11);
from i=0 to 17;
map_put(0,graph,tile,4,j);
j+=36;
end
repeat
cambiar=rand(0,900);
if(cambiar==20)
miniradar_vel_permitida=miniradar_vel_permitidas[rand(miniradar_vel_min_permitida,miniradar_vel_max_permitida)]; //esta línea es larga, pero lo único que hace es cambiar la velocidad máxima permitida dentro de los límites establecidos por las variables.
end
frame;
until(ganador>0);
end //begin
process foto_miniradar(int jugador)
begin
file=fpg_minijuego;
graph=5;
flags=3;
x=miniradar_radar_x[jugador];
y=miniradar_radar_y[jugador]-60;
alpha=90;
miniradar_flashing[jugador]=1;
repeat
frame;
alpha-=5;
until(alpha<=0);
miniradar_flashing[jugador]=0;
frame;
end
process radar_miniradar(int jugador)
private
byte auto=0;
begin
file=fpg_minijuego;
graph=4;
x=miniradar_radar_x[jugador];
y=miniradar_radar_y[jugador];
z=200;
switch (jugador)
case 1,3: flags=0;end
case 2,4: flags=1;end
end
repeat
frame;
if(botones[jugador] && miniradar_flashing[jugador]==0)
foto_miniradar(jugador);
end
if(key(_alt) && key(_s))auto=1;end
until(ganador>0);
end //begin
/*-------------------------------------------------------------------------------*/
Process frenada_miniradar(int coche,float velocidad_final,int jugador)
private
float reduccion_justa;
vehiculo_miniradar coche_a_frenar;
begin
coche_a_frenar=coche;
reduccion_justa=coche_a_frenar.velocidad_publica/4;
repeat
if(!father)signal(id,s_kill);end //esto es necesario, si no tiene padre quiere decir que el abuleo (curiosamente en la variable privada padre) va a morir pronto, y si intenta acceder a alguna de sus variables da error en tiempo de ejecución
coche_a_frenar.velocidad_publica--;
mapa_frenadas_miniradar(jugador,coche_a_frenar.x-10,coche_a_frenar.y+20);
mapa_frenadas_miniradar(jugador,coche_a_frenar.x+10,coche_a_frenar.y+20);
frame;
until(coche_a_frenar.velocidad_publica<=velocidad_final);
coche_a_frenar.frenando=0; //avisa de que ya ha frenado.
end
process mapa_frenadas_miniradar(int jugador,x,y);
private
mapa_frenadas_miniradar hermano;
begin
z=500;
region=jugador;
graph=new_map(5,5,16);
map_clear(0,graph,rgb(1,1,1));
tiempo_nacido=timer;
hermano=bigbro;
if(bigbro)tiempo_nacido=hermano.tiempo_nacido;end
repeat
frame;
until(timer-tiempo_nacido>=500)//vive 5 segundos
end//begin
process adelantar_miniradar(int coche,int jugador)
private
vehiculo_miniradar coche_a_mover;
float vel_adelantamiento;
int x_auxiliar;
begin
coche_a_mover=coche;
vel_adelantamiento=coche_a_mover.velocidad_publica;
x_auxiliar=coche_a_mover.x+30;
repeat
coche_a_mover.x++;
frame;
if(!father)signal(id,s_kill);end //esto es necesario, si no tiene padre quiere decir que el abuleo (curiosamente en la variable privada padre) va a morir pronto, y si intenta acceder a alguna de sus variables da error en tiempo de ejecución
until(coche_a_mover.x>=x_auxiliar)
coche_a_mover.adelantando=0; //avisa de que ya ha adelantado
end //begin
/*---------------------------------------------------------------------------------*/
Process fantasmilla_miniradar(int jugador,int lugar);
private
vehiculo_miniradar ident;
vehiculo_miniradar padre;
begin
file=fpg_minijuego;
graph=1;
region=jugador;
alpha=50;
//map_clear(0,graph,rgb(255,0,0));
padre=father;
repeat
frame;
switch(lugar)
case 1:x=father.x+25;y=father.y;end
case 2:x=father.x;y=father.y-70;end
end
ident=collision(type vehiculo_miniradar);//Aquí collisiona
/*Esta parte es para actuar dependiendo de si es el fantasmilla derecho o el superior*/
switch(lugar)
case 1:
if(ident || collision(type valla_miniradar))padre.coche_derecho=1; //esto es para que no se adelanten o no se salgan del arcen
else padre.coche_derecho=0;end//Este solo avisa de que hay un coche a la derecha
end
case 2:
if(ident &&(ident.region==padre.region)&& ident.velocidad_publica<padre.velocidad_publica)
if(padre.coche_derecho==0 && padre.adelantando==0)//Este if tiene que ir aparte porque si no el else haría que se frenase el coche por ejemplo si ident=0 (no hay ninguno delante) o cualquiera de las otras condiciones fuera falsa
adelantar_miniradar(padre,jugador);
padre.adelantando=1; //así solo llama al adelantamiento una vez por cada coche, de lo contrario lo llamaba todo el rato que el fantasma estaba en contacto con el coche (adelantaba 3 o 4 veces por frame)
elif(padre.frenando==0 && !padre.adelantando);
frenada_miniradar(padre,ident.velocidad_publica,jugador);
padre.frenando=1;
end //if
end//if
end//case 2
end//switch
until(y<miniradar_umbral_desaparicion[jugador])
signal(id,s_kill_tree); //esto es necesario para liquidar a los procesos frenada y adelantamiento, que intentando acceder a su abuelo cuando esta ya había muerto generaban muchos errores en tiempo de ejecución.
end
Process vehiculo_miniradar(int bonus,float velocidad,int jugador);
Private
//float avance;
//int fotos=1; //valor máximo 1
//int carril=0; //por defecto irán por el carril 0
//float slow_mo;
//int detectado=1;
Begin
file=fpg_minijuego;
region=jugador;
avance=miniradar_salida_coches[jugador];
if(velocidad<600)
graph=miniradar_graficos_coches[rand(0,2)];
elif(velocidad<1000 && velocidad>600)
graph=miniradar_graficos_coches[rand(2,6)];
elif(velocidad>1000 && velocidad<2000)
graph=miniradar_graficos_coches[rand(7,9)];
elif(velocidad>2000)
graph=miniradar_graficos_coches[rand(7,9)];
end
if(bonus)
chivato_bonus_miniradar(bonus,jugador);
end
velocidad_publica=velocidad;
fantasmilla_miniradar(jugador,2);
fantasmilla_miniradar(jugador,1);
from i=0 to miniradar_num_carriles;//aqui comprueba si el carril vale 0 (libre)
if(!miniradar_carril_ocupado[jugador]) //pero si el carril i vale 1(true), el carril está ocupado
carril=i;
break; //Nos vamos al otro carril
else //todos los carriles ocupados
carril=0;
avance+=100;
end
end
miniradar_carril_ocupado[jugador][carril]++;//avisamos de que el carril está ocupado
x=miniradar_carril[jugador][carril]; //y nos vamos al carril
repeat
/*COMPORTAMIENTO EN CASO DE BONUS*/
/*AUTO*/
if(miniradar_bonus[jugador]==1&& fotos>0 && y<miniradar_limite_inferior[jugador]-100 && (velocidad_publica*0.2)>miniradar_vel_permitida) //Esto es para que solo le puedas pillar una vez por pero que no pase nada si le das al flash antes de que este dentro de los límites Antes ocurria que el coche todavía no había aparecido en pantalla y sin embargo ya habías gastado la foto y no te permitía puntuar.
foto_miniradar(jugador);
end
/*SLOW MOTION*/
slow_mo=velocidad_publica/miniradar_slow_mo;//así la cámara lenta actua en tiempo real cuando se cambia la velocidad del coche
if(miniradar_bonus[jugador]==2)avance-=(slow_mo/100);//si el jugador la camara lenta (bonus 2) va lento
else avance-=(velocidad_publica/100); //de lo contrario irá a velocidad normal
end
y=avance;
if(miniradar_flashing[jugador] && fotos>0 && y<miniradar_limite_inferior[jugador]) //Esto es para que solo le puedas pillar una vez por pero que no pase nada si le das al flash antes de que este dentro de los límites Antes ocurria que el coche todavía no había aparecido en pantalla y sin embargo ya habías gastado la foto y no te permitía puntuar.
fotos--;
velocimetro_miniradar(x,y,velocidad_publica*0.2,jugador);
end
if(y<=miniradar_altura_banda[jugador] && detectado>0)//esto es para el marcador de velocidad
miniradar_vel_detect[jugador]=velocidad_publica*0.2;
detectado--; //esto es para que una vez detectados dejen de mandar su valor al radar y lo dejen libre para otros
end
frame;
until(y<miniradar_umbral_desaparicion[jugador]);
miniradar_carril_ocupado[jugador][carril]--;//libera el carril (vacio)
//signal(id,s_kill_tree);
//explosión de las naves o algo
End
process creador_coches(int jugador)
private
float tiempo;
int crear;
int probabilidad_bono;
int bonus;
begin
repeat
crear=rand(0,200);
probabilidad_bono=rand(0,2);
if( crear < miniradar_probabilidad )
if(probabilidad_bono==0)bonus=rand(1,4);else bonus=0; end //por cada coche mira su probabilidad de tener bonus
vehiculo_miniradar(bonus,rand(miniradar_vel_min,miniradar_vel_max),jugador);
timer[jugador]=0;
else
end
while(timer[jugador]<100)frame;end //esto garantiza que habrá al menos 1 segundo entre coche y coche
frame;
until(ganador>0); //fin repeat cuando gane alguien
end //begin
/*-----------------------------------------*/
/*BONUS----BONUS----BONUS----BONUS--------------------------------------------*/
process bonus_miniradar(int tipo,int jugador)
private
int tiempo_nacido;
int fuente;
int texto;
int desp=40;
int despx=15;
int vida=500;
begin
tiempo_nacido=timer;
miniradar_bonus[jugador]=tipo;
switch(tipo)
case 1: //Automático
fuente=load_fnt(minirradar_fuente_bonus[tipo]);
texto=write(fuente,miniradar_pos_contadores[jugador][0]+despx,miniradar_pos_contadores[jugador][1]+desp,4,"AUTO");
end
case 2: //Slow motion
fuente=load_fnt(minirradar_fuente_bonus[tipo]);
texto=write(fuente,miniradar_pos_contadores[jugador][0]+despx,miniradar_pos_contadores[jugador][1]+desp,4,"SLOW");
end
case 3: //niebla
fuente=load_fnt(minirradar_fuente_bonus[tipo]);
texto=write(fuente,miniradar_pos_contadores[jugador][0]+despx,miniradar_pos_contadores[jugador][1]+desp,4,"NIEBLA");
end
case 4: //lluvia
fuente=load_fnt(minirradar_fuente_bonus[tipo]);
texto=write(fuente,miniradar_pos_contadores[jugador][0]+despx,miniradar_pos_contadores[jugador][1]+desp,4,"LLUVIA");
end
end//switch
repeat
frame;
/*TRUCO TRUCO TRUCO LINEA A BORRAR*/
if(key(_alt)&&key(_a))vida=3000;end
/*######################*/
until(timer-tiempo_nacido>=vida || miniradar_bonus[jugador]<>tipo)
if(miniradar_bonus[jugador]==tipo)miniradar_bonus[jugador]=0;end //si el bonus no ha sido suplantado por otro lo ponemos a cero
delete_text(texto);
unload_fnt(minirradar_fuente_bonus[tipo]);
end
/*-----------------------------------------------*/
process chivato_bonus_miniradar(int tipo,int jugador)
private
int cambio_map;
begin
graph=miniradar_graficos_bonus[tipo];
region=jugador;
cambio_map=timer;
loop
if((timer-cambio_map)<=20)//primeras 3 centesimas
graph=miniradar_graficos_bonus[tipo];
else
graph=miniradar_contorno_bonus[tipo];
end
if((timer-cambio_map)>=50)cambio_map=timer;end
x=father.x;
y=father.y;
z=father.z-200;
if(miniradar_flashing[jugador] && y<miniradar_limite_inferior[jugador]) //Esto es para que solo le puedas pillar una vez por pero que no pase nada si le das al flash antes de que este dentro de los límites Antes ocurria que el coche todavía no había aparecido en pantalla y sin embargo ya habías gastado la foto y no te permitía puntuar.
bonus_miniradar(tipo,jugador);
break;
end
frame;
end
end
/*-----------FIN BONUS FIN BONUS FIN BONUS FIN BONUS-----------------*/
process dificultad_miniradar();
private
tiempo_corto;
tiempo_largo;
tiempo_super;
texto[2];
begin
timer[5]=0;
repeat
if(timer[5]>100)
tiempo_corto++;
tiempo_largo++;
tiempo_super++;
timer[5]=0;
end
/*CADA 5 SEGUNDOS se aumenta la velocidad máxima que pueden tomar los coches*/
if(tiempo_corto>=5)
miniradar_vel_max+=100; /*LINEA A CAMBIAR valor original 100*/
tiempo_corto=0;
end
/*CADA 10 SEG se aumenta la velocidad mínima que pueden tomar los coches
y los rangos de velocidades permitidas para estos*/
if(tiempo_largo>=10)
miniradar_vel_min+=5;
miniradar_vel_min_permitida+=6;
miniradar_vel_max_permitida+=6;
miniradar_probabilidad+=2;
miniradar_slow_mo++;
tiempo_largo=0;
i=0;
repeat
texto[1]=write(0,400,320,4,"Aumentando Velocidad Minima");
frame(1000);
delete_text(texto[1]);
i++;
until(i>10)
i=0;
end
/*CADA 30 SEG. se cambia de escenario, son 3 escenarios posibles*/
if(tiempo_super>=30)
//aqui poner el cambio de escenario
i=0;
repeat
texto[2]=write(0,400,340,4,"Cambiando de escenario");
frame(1000);
delete_text(texto[2]);
i++;
until(i>10)
i=0;
tiempo_super=0;
end
frame;
until(ganador>0)
end
[/code]
[code language="bennu"]process maltiempo_miniradar(int jugador)
begin
switch (miniradar_bonus[jugador])
case 3: //la niebla
switch(jugador)
case 1:
niebla_miniradar(2,1);
niebla_miniradar(3,1);
niebla_miniradar(4,1);
end
case 2:
niebla_miniradar(1,1);
niebla_miniradar(3,1);
niebla_miniradar(4,1);
end
case 3:
niebla_miniradar(2,1);
niebla_miniradar(1,1);
niebla_miniradar(4,1);
end
case 4:
niebla_miniradar(2,1);
niebla_miniradar(3,1);
niebla_miniradar(1,1);
end
end//switch
end//case 3
case 4: //la lluvia
end //case
end//switch
end
process niebla_miniradar(int jugador,int clase);
private
int direccion;
begin
region=jugador;
x=miniradar_niebla_pos[jugador][0];
y=miniradar_niebla_pos[jugador][1];
graph=23;
z=-500;
miniradar_niebla_llamada[jugador]++;
switch(clase);
case 1: direccion=1;end
case 2: direccion=-1;end
end
repeat
x+=direccion;
if(miniradar_lluvia_llamada[jugador])break;end //si el jugador que provocó la niebla, provoca una lluvia se rompe el bucle y .... ....
//y+=rand(-1,1);
frame;
until(out_region(id,jugador))
miniradar_niebla_llamada[jugador]--; // esta niebla ya ha desaparecido, se va a disolver, ¿para que dejar que siga contando?
repeat
alpha-=2; //... ... ... la niebla se disuelve y el proceso muere, jo jo jo
x+=direccion;
frame;
until(alpha<=0);
end
process crear_mapa()
private
int tile[1];
int pos[4][1]=0,0,200,150,
600,150,
200,450,
600,450;
begin
/*CREACIÓN DE LA CARRETERA*/
tile[0]=map_clone(fpg_minijuego,2);
tile[1]=map_clone(fpg_minijuego,3);
graph=new_map(400,300,16);
from i=0 to 5;
map_put(0,0,tile[rand(0,1)],200,50+(i*100));
map_put(0,0,tile[rand(0,1)],600,50+(i*100));
end
unload_map(0,tile[0]);
unload_map(0,tile[1]);
//El frame de cada jugador-----------------------------------------
//aqui esta creando el frame
tile[0]=map_clone(fpg_minijuego,6);
tile[1]=map_clone(fpg_minijuego,9);
map_put(0,graph,tile[0],50,150);
map_put(0,graph,tile[1],375,150);
unload_map(0,tile[0]);
unload_map(0,tile[1]);
tile[0]=map_clone(fpg_minijuego,7);
tile[1]=map_clone(fpg_minijuego,8);
from i=50 to 350;
map_put(0,graph,tile[0],i,0);
map_put(0,graph,tile[1],i,297);
end
unload_map(0,tile[0]);
unload_map(0,tile[1]);
//aqui lo coloca
from i=1 to jugadores;
map_put(0,0,graph,pos
- ,pos[1]);
end
/*---------------------------------------*/
/*CREACIÓN DE LOS VELOCÍMETROS*/
graph=map_clone(fpg_minijuego,10);
from i=1 to jugadores;
map_put(0,0,graph,miniradar_pos_contadores- ,miniradar_pos_contadores[1]);
end
unload_map(0,graph);
from i=1 to jugadores;
write(miniradar_fuente_ceros,miniradar_pos_contadores- +29,miniradar_pos_contadores[1],5,"888");
write_var(miniradar_fuente_vel,miniradar_pos_contadores- +29,miniradar_pos_contadores[1],5,miniradar_vel_detect);
end
/*----------------------------*/
/*CREACIÓN DE LA SEÑAL DE VELOCIDAD MÁXIMA*/
graph=map_clone(fpg_minijuego,50);
map_put(0,0,graph,402,255);
write_var(miniradar_fuente_limite,402,255,4,miniradar_vel_permitida);
unload_map(0,graph);
/*--------------------------*/
//Regiones--------------------------------------
define_region(1,0,3,400,294);
define_region(2,400,3,400,294);
define_region(3,0,303,400,294);
define_region(4,400,303,400,294);
//---------------------------------------------------
end
Process miniradar();
private
int tiempo;
int cambiar_multiplicador;
Begin
// RECURSOS
resolution=10;
fpg_minijuego=LOAD_FPG("minialunizaje.fpg");
miniradar_fuente=load_fnt("tiempo.fnt");
miniradar_fuente_ceros=load_fnt("null.fnt");
miniradar_fuente_vel=load_fnt("velocidades.fnt");
miniradar_fuente_puntos=load_fnt("puntos.fnt");
miniradar_fuente_sumas=load_fnt("sumas.fnt");
miniradar_fuente_limite=load_fnt("limite_vel.fnt");
// COLOCAMOS OBJETOS EN PANTALLA Y PREPARAMOS EL MINIJUEGO
write_var(0,20,150,4,miniradar_multiplicador);
write_int(miniradar_fuente,400,165,4,&tiempo);
write(0,400,120,4,"VELOCIDAD MÁXIMA: ");
write_var(0,500,120,4,miniradar_vel_max);
write(0,400,140,4,"VELOCIDAD MINIMA: ");
write_var(0,500,140,4,miniradar_vel_min);
crear_mapa();
from i=1 to jugadores;
write_var(miniradar_fuente_puntos,miniradar_pos_contadores- +8,miniradar_pos_contadores[1]+70,4,puntos);
end
from i=1 to jugadores; creador_coches(i);radar_miniradar(i); end //creamos los creadores XD
valla_miniradar(115,0);
valla_miniradar(315,1);
valla_miniradar(515,0);
valla_miniradar(715,1);
// PREPARADOS, LISTOS...
getready();
// YA!
dificultad_miniradar();
/****************BUCLE PRINCIPAL****************************/
while(ganador==0)
/*Truco malvado a borrar*/
if(key(_1))bonus_miniradar(1,1);end
if(key(_2))bonus_miniradar(2,1);end
if(key(_3))maltiempo_miniradar(1);end
/*Truco malvado a borrar*/
from i=1 to jugadores;
if((miniradar_bonus==3)&&(miniradar_niebla_llamada==0))//mira a ver si el jugador tiene el bonus de niebla y no acaba de llamar a ninguna
maltiempo_miniradar(i);
niebla_miniradar(i,1);end//si no hay ninguna en ejecucuion llama a ...la niebla...
end//from
tiempo=(90-timer/100);
cambiar_multiplicador=rand(0,400);
if(cambiar_multiplicador==10)miniradar_multiplicador=miniradar_multiplicadores[rand(0,13)];end
frame;
end //aquí nos quedamos hasta que gane alguien
// ESPERAMOS UNOS SEGUNDOS Y SALIMOS DEL MINIJUEGO
frame(5000); //esperamos un poquico
menu(1); //y salimos del minijuego
End
[/code]
Y eso es todo lo que yo he hecho, espero que no sea mucho ni muy duro de leer.
Encontré lo que creo que era un error, pero que no corrije el anterior, no obstante lo posteo porque no estoy seguro de si es verídico lo que pienso. En el segundo proceso que declaro al principio había una variable privada que no había declarado ahí y sí la había declarado en la parte del proceso en sí. ¿Lo correcto es declarar las variables en la parte del declare del proceso no? tanto las public como las private y luego no volver a declararlas en el propio proceso (de esto si estoy seguro porque daba error de variable duplicada). Que alguien más sabio me corrija si me equivoco.
En el post anterior a el ultimo que has puesto, que empieza con:
"declare Process vehiculo_miniradar(int bonus,float velocidad,int jugador);"
yo pongo esto al final de GLOBAL:
....
....
int miniradar_fuente_limite;
int miniradar_num_jugador;
puntos[10];
fpg_minijuego;
i;
ganador;
botones[10];
end
begin
end
Y compila perfectamente.
Otra cosa es como se comporte, pero compilar compila y crea el DCB, esto con Bennu WIP 7.5
Veo que pones ";" en los PROCESS (en algunos no lo pones) yo nunca he puesto ";" en "PROCESS taltal()" no s esi tendra algo que ver.
Por ultimo... yo no soy mas sabio que tu, pero las puedes declarar en los dos sitios, aunque igual es mejor declararlas al principio (en los declare) para el compilador, de todas formas no estoy seguro, pero por poder... se puede en ambos lugares, otra cosa es que por tenerlas separadas repitas una variable en la declaracion.
Las unicas que no se pueden declarar en 2 lugares son las publicas, que deben ser declaradas en el declare (o en la funcion misma si esta esta escrita con anterioridad a su uso), las demas pueden ser en cualquier parte...
el fuente no esta completo, me da errores de declaraciones inexistentes, porque no me lo mandas por mail? o lo adjuntas comprimido?
Pues juraría que había que declarar las private también si declarabas algo, bueno, da igual, ya lo tengo así.
Muchas gracias splinter, para el próximo error te lo mando, he borrado la línea anterior y posterior además de la línea problemática y el error ha desaparecido, sigo sin saber el motivo pero bueno, funciona.
Proximamente en sus foros.... el nuevo error que me trae de cabeza (parece coña pero va en serio)
no dejes pasar esto, si podes volver a activar el error, y me envias el programa, me ayudas a poder hacer una mejor herramienta, no pases por alto un error, ayudaria mucho al proyecto poder corregirlo...
De acuerdo, creo que tengo una versión con el error aún en funcionamiento, voy a buscarla.
Splinter, no la tengo, pero acabo de caer en la cuenta de que no hace falta, el source completo con el error (el único que ha cambiado) posteado, solo tienes que llamarlo radar_bennu.inc.prg y compilar el prg que viene en el archivo zip. No se cual no te gustaba, si rapidshare o megaupload, creo que era rapidshare.
http://www.megaupload.com/?d=B54QMMK0 (http://www.megaupload.com/?d=B54QMMK0)
era al reves, pero bueno, parece que ahora megaupload deja descargar sin tener que instalar nada... ya lo probare... gracias...
probado, compila perfectamente... que version estas usando?
0.73 creo
ah, espera, creo que no, es la del bennu pack, cuando vuelva a casa te lo confirmo.
ok, entonces si podes tener errores de parseo y esas cosas...
De todos modos, splinter ¿pusiste el código que postee anteriormente? ¿borraste y/o modificaste la línea que mencioné? Es que si lo compilas tal cual lo puse compilaba perfectamente.
Splinter, me gustaría poder usar la última version de bennu, voy a ver que error me daba y te lo digo.
ah, compile tal cual lo pusiste, como seria la cosa?
Debes modificar esta línea
[code language="bennu" options="singleline"]niebla_miniradar(i,1);end//si no hay ninguna en ejecucuion llama a ...la niebla.. .[/code]
o borrarla solo esa.
En la 0.73 me dice "WARNING VARIABLE ALPHA_STEPS REDECLARED"o algo así y otro que versa lo siguiente
"UNKNOWN IDENTIFIER MOUSE"
Ninguno de esos errores me los da con la versión anterior.
el redeclare es perfecto, es un aviso a nivel librerias... obvialo...
claro que te va a fallar, eso, estas borrando un "end"... ;)
el mouse, tenes que importar "libmouse"
otra cosa... tene cuidado cuando usas cosas de este estilo...
x=father.x;
y=father.y;
z=father.z-200;
siempre una vez que entras de un FRAME, chequea si father existe antes de acceder a sus variables...
Ja ja ja, splinter, gracias por el consejo, ya he tenido más de un quebradero de cabeza con la muerte de padres y abuelos, muchos errores y muchas horas comiendome el tarro de como solucionarlo.
Por lo que veo splinter has cambiado la disposición de algunas de las funciones dentro de las librerias, ya que acabo de importar la libmouse y ahora se queja del rand_seed :P
Nuevos errores: error bgdc.exe no se encontró libpng12-0.dll
y
error lybrary mod_map.dll not found (esta si estoy seguro de que está en el directorio)
si no tenes la libpng12-0.dll no cargara la mod_map.dll...
PD: por otro lado, muevo todos los temas de consultas/problemas a mesa de ayuda... deben ser posteados ahi