Hola :)
Tengo un problema con una variable pública.
Dentro del proceso Ball(), antes del begin, tengo lo siguente:
[code language="bennu"]
public
int life;
end[/code]
Tengo también una variable GLOBAL(antes de process Main()), llamada BALL, la cual es el identificador de Ball(), la cual fue asignada en el begin de Main().
El problema viene con un proceso hijo de un proceso inicializado tambien en Main.
No me reconoce lo que es BALL.life, me dice Unknown Identifier.
Gracias por leer!
Yo huyo de las public porque me parecen muy raras de declarar... :P
Sólo le he usado una vez por eso, y lo hice así, poniendo esto ANTES de los GLOBAL:
[code language="bennu"]
DECLARE PROCESS ball() // Aquí tienes que poner también parámetros si los tienes
PUBLIC
int life;
END
END
[/code]
Luego ya declaras el proceso main y el proceso ball, debería irte.
Por cierto, te recomiendo que no nombres igual un proceso que una variable, yo usaría ball para el proceso e id_ball para el identificador (no sé si bennu las distingue, pero no tentemos a la suerte...). Ni con distintas mayúsculas/minúsculas como es tu caso, ya que en ese caso bennu no las distingue
funciona bien declarar variables y procesos con los mismos nombres.
No estaba seguro, la duda me venía por el tema de que igual se hacía la picha un lío al utilizar "type ball" en colisiones y bucles... pero bien pensado no tiene sentido, type sólo se aplica a procesos... Bueno es saberlo ;D
Ahora, nombres de variables no los distingue de tipos de variable, no?
[code language="bennu"]
type point
int x;
int y;
end
int point;
[/code]
Lo pregunto por el tema de sizeof aplicado a ambos casos...
Hola, puse:
[code language="bennu"]
DECLARE PROCESS Ball()
public
int life;
end
END
[/code]
Detrás de las declaraciones globales, y me sigue tirando que BALL.life no existe ???
Buenas ,me imagino que a la hora de crear el proceso ball lo hicistes de esta forma :
ball=ball();
de no ser asi posiblemente ahi tengas el error...
Si es asi estaria bien que nos enseñaras algo mas de codigo.
Saludos
No era necesario antes de const creo, exageraba ;D pero antes de Bala sí. Te dejo mi ejemplo simplificado:
[code language="bennu"]
PROGRAM VIDEOJUEGO;
INCLUDE...
DECLARE PROCESS barraVelocidad(int ini, int x, int y, int z)
PUBLIC
int tiempo;
END
END
CONST
...
END
GLOBAL
id_barra;
END
BEGIN
id_barra=barraVelocidad();
LOOP
say(id_barra.tiempo);
FRAME;
END
END
PROCESS barraVelocidad(int ini, int x, int y, int z)
BEGIN
tiempo=0;
LOOP
tiempo++;
FRAME;
END
END
[/code]
lo que pasa es que ball al tener una publica se transforma en una clase de datos, entonces las variables que usaras para referencias a las publicas debe ser del tipo ball... por ejemplo.
ball pid;
...
pid.life
...
edit: grisendo, lo que pusiste no va a funcionar.
¿No? ¿Por qué? No es exactamente el código que hice funcionar, es una adaptación simplificada (sin probar) de una cosa que me funcionaba, pero no logro ver que haya algún fallo...
Creo recordar que para acceder a la variable pública, primero necesitas el ID del proceso que tiene dicha variable, y almacenarlo en otra variable del proceso que lo va a leer PERO dicha variable contenedora no es de tipo INT, sino del tipo "nombre-del-proceso-que-tiene-la-variable-pública".
Algo así:
DECLARE PROCESS bola ()
PUBLIC
int variable;
END
END
PROCESS pepito ()
PRIVATE
bola dato;
BEGIN
dato=get_id(type bola);
x=5+dato.variable;
(...)
END
Esto es de memoria, no suelo usar públicas, lo mismo me he confundido.
eso mismo, muy bien drumpi... te ganaste un premio... karma por hacer la tarea.
Ok, el tipo :P Ahora, esto iría, no? Porque lo del get_id(type barraVelocidad) no tuve que hacerlo nunca:
[code language="bennu"]
PROGRAM VIDEOJUEGO;
INCLUDE...
DECLARE PROCESS barraVelocidad(int ini, int x, int y, int z)
PUBLIC
int tiempo;
END
END
CONST
...
END
GLOBAL
barraVelocidad id_barra;
END
BEGIN
id_barra=barraVelocidad();
LOOP
say(id_barra.tiempo);
FRAME;
END
END
PROCESS barraVelocidad(int ini, int x, int y, int z)
BEGIN
tiempo=0;
LOOP
tiempo++;
FRAME;
END
END
[/code]
Si alguien tiene dudas (Cosa normal) le recomiendo leer el último tema de mi tutorial:
http://trinit.es/temario/Tema%2039%20PUBLIC.pdf (http://trinit.es/temario/Tema%2039%20PUBLIC.pdf)
Último por ahora, este Verano ampliaré y mejoraré :P
sí, grisendo, si estoy en lo cierto (que parece que si :D) eso mismo vale.
Get_id sirve para obtener la id de un proceso si no lo has guardado en una variable. Se suele usar con type y el nombre (ojo, no es lo mismo nombre que crear un proceso, hay un () de diferencia) para que devuelva la ID de un proceso cualquiera que coincida con ese nombre.
I know, I know... sólo que me había descolocau que lo utilizases aquí :D
Aunque parezca novato, soy de la vieja escuela de DIV (creo que era la versión 2 la primera que usé), donde los eructos eran pedos y los pedos son eructos, donde los procesos tenían todos ID impar... donde impar era TRUE y par era FALSE... menos mal que esas rarezas han cambiado :P Lo que pasa que con tanto lenguaje que utilizo a diario me lío a veces :P
¿Y como es que es tan peculiar el uso de PUBLIC? ¿Cómo es que no se utiliza de la misma forma que un PRIVATE?
Cierto, a mí también me pareció extraño eso de tener que pre-declarar cada proceso que usa PUBLIC.
Al final y con todo, los usos de PUBLIC que he hecho han sido más bien pocos :P
nada de esto es extraño...
me parece que estoy entendiendo que no tienen en claro el uso de type y no type.
No digo extraño, me refiero a "menos usable de lo habitual", y es que Bennu es muy usable xD
De todas formas me gustaría que nos hablases del uso de type y no type, que en este foro todos los días se aprende algo nuevo :P
los procesos que se escriben son las definiciones = tipos
las instancias son las ejecuciones de dichos procesos = id
si uno usa type esta identificando a (o a cualquier de) los procesos en ejecucion de un tipo determinado
si uno no usa type, esta referenciando a un proceso en concreto (id)
el type solo funciona en combinacion para algunas funciones.
Muchos lenguajes necesitan declaraciones de sus prototipos, metodos, propiedades. Esto no es cuestion de usabilidad o no, es cuestion de ser correcto y ordenado programando o no, por otro lado, no hay que escribir el prototipo 800 veces, con 1 vez alcanza y sobra.
Esa diferencia entre type y no type sí que la tenía clara, pensaba que ibas a relacionar type con PUBLIC y ahí me habías descolocado un poco :P
Entonces Splinter, ¿Sería complicado conseguir que la declaración de variables PUBLIC se hiciese de la misma forma que PRIVATE sin tener que usar DECLARE? Por ejemplo:
PROCESS mordisquitos ( )
PUBLIC
int numero_dientes;
PRIVATE
int puntos_de_vida = 100;
BEGIN
...
END
Ya sé que no cuesta nada ponerlas una vez y que es muy ordenado tener declaraciones, pero opino que sería más cómodo permitir algo "similar" a lo anterior.
no, no se puede, porque eso implicaria muchos cambios, una compilacion en 2 pasos por ejemplo, y actualmente no es posible.
pensemos un poquito, con logica, sin necesidad de conocimientos internos de bennu:
1) variables privadas, se usan dentro de una funcion, y la definicion de estas variables estan antes del codigo de las usa (se definen antes de usarlas).
2) variables publicas, son variables que pertenecen a otra funcion, pero que tenemos acceso a ellas, entonces estas variables pueden estar definidas despues de que las referenciemos en nuestra funcion, entonces si desconocemos su definicion, no vamos a poder generar el codigo correcto para usarlas, por ende, si las necesitamos antes de la funcion a las que pertenecen, entonces debemos declararla (resumen, se definen antes de usarlas).
no solo las funciones que tienen variables publicas se pueden definir con declare, sino cualquier funcion/proceso, y esto es recomendable, porque se evita la carga extra de codigo que en algunos casos significa la autoconversion de datos.
por otro lado, si las funciones/procesos aparecen escritos antes de llamarlas desde otra funcion, entonces no necesitan ser declaradas.
estos temas ya se hablaron hace tiempo.
creo que en algun momento me voy a tener que dedicar a barrer el foro y hacer un FAQ de las cosas que se preguntan y responden frecuentemente.
Entonces según lo que dices, ¿actualmente es posible tener ficheros de declaración puros y duros separados de ficheros de definición en Bennu? No lo había visto en ningún tutorial antes (tampoco es que haya leído muchos...)
A partir de hoy cambia completamente mi forma de programar en Bennu :P Y ahora como me digas que se pueden definir funciones como si los procesos fuesen objetos, me da un patatús de alegría :D
o te equivocaste al redactar el texto o no te entendi nada... podrias reformular la pregunta?
y lo de objetos tampoco lo entendi? algunas cosas las podes ver como objetos perfectamente.
Jejeje. Lo de separar me refería a separar en plan .c y .h
Este sería "protagonista.hpp"
[code language="bennu"]
DECLARE PROCESS protagonista(string name, int life)
PUBLIC
string nombre;
int vida;
END
PRIVATE
int x_anterior;
int y_anterior;
END
END
DECLARE FUNCTION float multiplicar(float x, float y)
// Resto de declaraciones de procesos y funciones
[/code]
Y este sería "protagonista.cpp"
[code language="bennu"]
INCLUDE "protagonista.hpp"
PROCESS protagonista(string name, int life)
BEGIN
nombre = name;
vida = life;
END
FUNCTION float multiplicar(float x, float y)
BEGIN
return(x * y);
END
// Resto de definiciones de procesos y funciones
[/code]
Y lo que decía de objetos me refería a algo así:
[code language="bennu"]
// Declaración
DECLARE PROCESS fecha(int dia, int mes, int anyo) // Declaración de constructor
PUBLIC
int day;
int month;
int year;
FUNCTION int esValida();
FUNCTION int esAnyoBisiesto();
END
PRIVATE
int aux;
FUNCTION int aux(int p1, int p2);
END
END
//Definición
PROCESS fecha(int dia, int mes, int anyo)
BEGIN
day = dia; month = mes; year = anyo; // Implementación del constructor
LOOP // Bucle principal
FRAME;
END
FUNCTION esAnyoBisiesto()
BEGIN
return(...);
END
...
ONEXIT
// Implementación del destructor
END
//Uso
BEGIN
fecha hoy;
hoy = fecha(1, 2, 2010);
IF (hoy.esAnyoBisiesto())
say("Bisiesto!!!");
END
END
[/code]
claro que es asi lo de los .h.
lo de los objetos, se puede hacer pero no de esa forma y las funciones dentro de un proceso son solo de ambito privado a la funcion.
Y como se haría lo de los objetos???
Declarando una función normal y metiendo el objeto como un parámetro? (que es como lo hacía yo hasta ahora)
los procesos pueden tener funciones que son privadas a el, estas se definen con etiquetas, y se usan con la funcion del lenguaje call/gosub, y se retorna de ellas con return, estas funciones comparte en area de datos con el proceso, asi que cualquier variable que modifiques modificas las del mismo proceso.
No conozco "gosub" (en la wiki no está) pero el uso de call y las etiquetas...¿no es volver al código spaguetti?
Siempre se dice en los manuales de programación que hay que huir del goto...
Aunque si es la única manera si simular un objeto, pues bienvenido sea...
Venga, hasta luego
el problema del goto no es usarlo, sino usarlo mal.
la cosa es que en lineas generales hay malos programadores y muy pocos buenos, asi que conociendo esto es sugerible no usarlo, por eso mismo hay poca documentacion al respecto de estas funciones en bennugd, pero si preguntan obtendran respuestas, ahora si estas respuestas son aconsejables a todos o no, eso es otra cosa.
Por otras palabras, Splinter no sabe usarlo bien ;D
Quote from: FreeYourMind on June 09, 2010, 05:38:40 AM
Por otras palabras, Splinter no sabe usarlo bien ;D
;)
y como sabia que no iba a usarlo nunca, lo implemente para hacer mas bulto en el codigo... :D
De hecho la mayoría del código de Bennu es para hacer bulto :P
Sí, lo único importante de Bennu es el código para dominar el mundo ;D
Ups, se me ha vuelto a escapar.
Fijate que cuando saque los fractales y antes de este post, me lo habia pensado, seria muy util volver al principio del main principal (Begin principal), con un goto por ejemplo (dandole a un boton por ejemplo), te ahorras muchas cosas.
Es posible ?
dentro del mismo main, es posible.
pero eso no te va a resetear las variables, si es lo que buscas (a menos que las resetees manualmente en el inicio del main), si no buscas eso, entonces todo bien.
Me refiero que en un proceso (el cual sólo esta el mismo activo, con un let_me_alone por ejemplo) al apretar un boton se pueda hacer un goto que vaya justo al principio del main (las variables globales logicamente no tienen que estar reseteadas, tendrán los respectivos valores en memória que tenian antes del goto).
ni las globales ni las locales ni las privadas... mantendran su valor, y respondiendo, si, es posible hacerlo.
etiqueta:
....
goto etiqueta
No me gusta para nada la idea del GOTO, pudiendo controlar adecuadamente el árbol de procesos, las invocaciones entre ellos, etc. No lo veo necesario :P
tampoco tiene por que gustarte, para algunos casos es necesario.
muchos tambien pueden decir lo mismo de C, pero si esta, por algo es.
no todo le tiene que gustar a todos.
Quería decir que no lo veo necesario para mí, pero si ahí está la opción, bendita sea :P
En ese sentido me gustaría ver algún código mínimo que haga un buen uso de GOTO y demuestre ser capaz de resolver el mismo problema en menos líneas.
imaginate el caso donde tengas anidados muchos bloques iterantes, y necesitas tener en el mas bajo nivel un corte que te saque de todos, en ese caso necesitarias una variable de corte de control que se transmita en todos los bloques, con lo cual tenes una carga extra de condiciones en cada uno de las intrucciones tipo loop que estan haciendo esta anidacion, sin embargo, podes tener 1 sola condicion con un solo goto en el bloque de mas profundidad.
en este caso no es extremadamente necesario, aunque si la performance es una necesidad, entonces en este caso es necesario.
Usar el GOTO para volver al principio del main lo veo super útil, ya que te permite no tener que montar una estrutura del programa.
Ya que tan sólo quieres volver al menu principal sin que este sea un proceso, de forma rápida.
Me han gustado esos 2 últimos ejemplos, la verdad es que en el caso de multitud de bucles anidados me ha tocado más de una vez controlar la condición de salida con tantos IF y BREAKS como bucles anidados había.
La próxima vez usaré GOTO, gracias ;D
:)