Esto es muuy raro. Error incomprensible que no referencia bien

[Danielo515]

[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...
  

[SplinterGU]

te falta el ";" en el from, ahora todas las instrucciones cuyos parametros (por definicion) no se encierran entre parentesis deben ser cerrados por ";"

[Danielo515]

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.

[Danielo515]

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é.

[SplinterGU]

el error se puede deber a otra linea de codigo, mas arriba... sin el fuente completo no es posible ayudarte...

[TYCO]

Haz por ejemplo una busca de todos los from y comprueba que tengan el ;

[Danielo515]

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]

[Danielo515]

[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.

[Danielo515]

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.

[TYCO]

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:

Code Select Expand


....
....
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.

[SplinterGU]

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?

[Danielo515]

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)

[SplinterGU]

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...

[Danielo515]

De acuerdo, creo que tengo una versión con el error aún en funcionamiento, voy a buscarla.

[Danielo515]

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