Buenas tardes comunidad, llevaba mucho tiempo creando mi propia librería de física para vídeo juegos, y recientemente he probado la estupenda Chipmunk portada a bennuGD..
Me he quedado maravillando con lo bien que funciona :)
Y como todos o casi todos los que andamos por aquí venimos del amor por Div y Div2, pues me he dicho.. por que no crear una colección de funciones que ayuden hasta el infinito a simplificar el uso de la chipmunk en bennuGD?
Pues eso, que comienzo lo que espero que sea una ayuda para todo el que quiera disponer de una serie de funciones "al mas puro estilo DIV" para trabajar con física en bennuGD haciendo juegos.
Los objetivos que tengo marcados como iniciales son estos:
- Crear un editor gráfico para el diseño de los escenarios.
- Crear las funciones que cargan el escenario "scroll" o mode7 completamente vectorizado.
- Crear un API "DIV-Style" para el uso de la chipmunk en bennuGD.
EL EDITOR:
Como avance, el editor gráfico de escenarios lo comencé a crear por allá en el 2009, y durante estos años lo he ido puliendo hasta dejarlo perfectamente operativo.
Creo que será una gran ayuda para los que nos dedicamos a crear juegos, lo que permite es navegar por un gráfico cargado desde disco y mediante unas simples herramientas miy similares a las del editor de mapas de Div2 pero llevadas a la actualidad poder setear puntos de control en un mapa, tiene zoom y mas cosillas interesantes.
En realidad no solo es un editor de puntos de control, también trae una herramienta que permite cargar un tileset desde un simple PNG/BMP/JPG y recortar sprites como lo hacía el editor de Div2, y bueno, bastantes cosillas mas ;)
El editor es Open Source, abierto a cualquier tipo de cambio, modificación o lo que haga falta.
LAS FUNCIONES DE CARGA DE ESCENARIOS:
- Serán simples funciones cuyo principal objetivo es el de teclear algo como esto: INT chipmunk_load_scenario( string cpt_file ); y chipmunk_make_scenario( int id_scenario );
Como se ve, es lo mas simple del mundo XD.. la idea es que respete al máximo la filosofía DIVERA.
LA CAPA DE ABSTRACCION PARA CHIPMUNK EN BENNUGD:
- Esta es la parte que mas trabajo tiene, se trata de una gran colección de funciones que permiten realizar cualquier tipo de acción sobre los objetos, por poner algunos ejemplos:
- INT chipmunk_build_entity( float raduis, float mass );
- chipmunk_set_entity( int entity_id );
- chipmunk_add_velocity( int entity_id, float velocity, float angle );
- chipmunk_entiy_brake( int entity_id, int brake_percent );
Llevo mucho tiempo con este tema, no es una idea que se me acaba de ocurrir XD.. el proyecto está ya maduro y es funcional, pero no está terminado, en cuanto lo tenga todo listo lo publicaré para uso y disfrute de todos, siendo posible crear un juego con física en scroll o mode7 con tan solo 20 lineas de código o menos ;)
Por la dificultad de como usarlo que no se preocupe nadie.. voy a montar unos vídeo tutoriales como los que vengo haciendo desde hace ya años para otros menesteres, ahora dedicados a bennuGD y al uso de chipmunk con el.
La idea principal de todo esto es la de eliminar o "en la medida de lo posible" evitar montar complicados códigos que comprueban coordenadas en un mapa de durezas, automatizando todo esto mediante un escenario vectorizado.
Bueno.. espero tener pronto esto listo, sinceramente, me muero de ganas por publicarlo y ver que os parece, ya que espero que sea una grata alternativa que nos ahorre tiempo a todos a la hora de crear vídeo juegos ;)
Guauuu, lo he leido y me he quedado flipando xd. Lo de las funciones que vienes haciendo, creo que que muy largas, al escribir, y memorizar. Lo de que ahorre escribir lineas a keoh le va q gustar el que mas xdd. Suena bien, ya pronto se programara una fisica como la de bad piggies, (( ese juego me dejo flipado con la fisica) o mejor. Surrte con el prroyecto.
Gracias ALEX, la idea es que podamos programar un juego de scroll o mode7 igual de fácil que como se hace en div, pero evitando todo ese royo de comprobar durezas.
Osea.. imaginate un proceso personaje como este:
process personaje(x,y);
begin
chipmunk_build_entity( 50, 10 ); 50 de radio y 10 de masa..
chipmunk_entity_set_position( this, x, y ); coloco al personaje en las coordenadas pasadas como parámetros a este proceso..
ale.. ya está todo el control de colisiones creado XD..
ahora el loop para mover al perso..
LOOP en pseudo código:
if(tecla LEFT) chipmunk_entity_Add_velocity( this, 0.1, 180000 );end
if(tecla RIGHT) chipmunk_entity_add_velocity( this, 0.1, 0 );end
con eso ya te mueves para izquierda/derecha..
Para un salto usando una simple variable llamada 'ESTADO'
switch(estado)
si vale cero -> si pulso key UP -> estado vale 1..
si vale uno -> chipmunk_entity_add_velocity( this, 4.0, 90000 ); ahora estado vale 2..
si vale dos -> mientras no se toque suelo no volverá a valer cero..
Ya te puedes imaginar como va a ser ;)
Toda la paranolla del control de un personaje se reduce a eso.
tienes alguna forma fácil o función de mapear un grafico irregular (con varios shape's de tipo LINE por ejemplo) para que colisione con otro objeto con todas sus partes distintas de su cuerpo (o sea que no sea una simple caja, circulo, trinagulo, etc, pero un grafico formado por varias formas). ?
He estado estudiando este tema, es quizá uno de los mas complejos, todavía no tengo nada que funcione, pero tengo algunas ideas sobre como hacerlo, la principal idea es basarme en un tipo de formas irregulares, las creadas con lineas, ya puede ser el gráfico lo complejo que sea, si está hecho a base de vertices el algoritmo debe funcionar.
Se basa en un scanner de contorno mediante la 'tortuga de papert', se almacena todo el contorno de la imagen en una lista dinámica de vectores simples [ X / Y ] para luego reescanearla con el algoritmo de la linea clásico e ir sacando la lista final de segmentos mediante una comprobación simple de trayectoria.
La idea la tengo clara pero todavía no me he puesto a montarla, aunque en realidad es bastante simple en concepto.
En lo que he invertido bastantes horas es en crear todo el API de getters/setters para la librería, tanto de velocidad, posición, angulo, constraints etc etc.. me falta por implementar el collision_matrix[] que no es mas que una matriz de estados de colisión en tiempo real que tenía implementada para mi librería de física, pero viendo que la chipmunk ya maneja esto directamente tengo que modificar los getters del api para que sea compatible.
Lo del algoritmo de vectorización de imágenes "por segmentos" es uno de mis pendientes que tengo que ponerme un dia de estos cuando todo lo que tengo ahora mismo entre manos esté terminado, pero la idea es esa que te comento.
Por si quieres indagar tu mismo un poco sobre el tema te explico un poco mas profundamente como debería ser:
- El primer paso es cargar una imagen y mediante map_get_pixel() "disculpadme si llamo mal a alguna función, uso muchos divLikes y aveces me confundo", pues eso, se coloca el cursor en el centro de la imagen "cursor virtual claro" y se comienza a subir hasta encontrar un pixel sin color.
- El segundo paso es utilizar el algoritmo conocido como "pappert turtle" para barrer el contorno pixel a pixel, esto ya lo tengo implementado y funciona perfecto.
- El tercer paso es que mientras la tortuga de pappert avanza se comprueba si la posición del vector actual es igual a la del vector inicial, si es así el escaneo de contorno ha terminado.
- El cuarto paso es, habiendo guardado todos los vectores "aclaro que llamo vector a un campo de una estructura X/Y como lo sería un c_point" que la tortuga de pappert ha reconocido como "propiedad del contorno de la imagen" hay que hacer un segudo barrido, esta vez se parte de la lista de vectores creada anteriormente.
Este paso final debe hacer lo siguiente:
1 - Colocar el cursor en el primer vector de la lista.
2 - comprobar el angulo con el siguiente vector.
3 - avanzar una posición en la lista de vectores y comprobar que el angulo entre el primer vector y el angulo entre el segudo y el tercer vector son iguales "con una tolerancia mínima", si es así se trata de 3 puntos que están en la misma recta o segmento.
4 - seguir avanzando en la lista de vectores hasta encontrar un vector que se sale de la trayectoria de la recta..
5 - Se crea el segmento mediante la chipmunk con la posición inicial y la posición final del barrido actual.
6 - Ahora el segmento inicial es la posición donde termino el barrido anterior..
7 - vuelta a empezar.
Esto debería funcionar, seguramente será lento por que son muchas operaciones, lo mejor sería implementarlo en C pero vamos, que en lenguaje bennuGD tiene que funcionar por cojones ;)
La idea que tengo en mente es esta, es un scaner de contorno + un scaner de segmentos.
En realidad el ultimo port de Chipmunk trae el algoritmo ese para detectar la forma del grafico pero esta en fase beta, todavia no va perfecto, el cual se puede mejorar si alguien se quiere dedicar a el ya que viene el src y ejemplo prg con la ultima version.
Primer objetivo completado.
- Ya tengo el editor de archivos .cpt, las features son estas:
- Carga de imagenes en formatos standard png, bmp, jpg..
- Edición de puntos de control de forma totalmente visual y cómoda.
- Zoom, se puede ampliar la imagen y trabajar con el editor tranquilamente, esto es muy practico en mapas de scroll para dispositivos de reducida resolución.
- Color flip, se selecciona la herramienta del cuentagoatas y se hace click en un pixel de la imagen, se recoje el color, se abre la paleta y se selecciona un nuevo color, se hace click en la herramienta de color flip y voila.. se intercambian de color todos los pixeles de la imagen.
- Sprite CUTTER "un calco al del editor de Div2", se abre la herramienta de recorte de sprites y se hace click en un pixel con color diferente de cero, se hace click en "Sprite Cut" y ale.. el algoritmo de la tortuga de pappert recorre el contorno del sprite y lo exporta.
- .CPT options:
* Export as..
* Clear current list.
* Import.
Como veis aparte de servir para crear y editar archivos .cpt sirve para realizar algún trabajo extra con tilesets.
Comienzo el tema de las funciones de carga de escenarios y el port completo del API de mi lib de física para hacerlo compatible con la chipmunk, en cuanto tenga el ditor bien testeado y sin bug´s lo comparto.
Un saludo.
Vaya, leyendo todo el hilo de la chipmunk para bennuGD y viendo todo el trabajo que se ha invertido en esta librería me he quedado gratamente sorprendido, tenía la intención de montar algunas funciones para simplificar e integrar un poco la lib con el lenguaje bennuGD pero veo que esta librería está super integrada con el lenguaje, que bien!
Mis felicitaciones al autor, lo de que funcione de una forma tan próxima a los procesos no tiene precio.
Viendo que este trabajo está cojonudo me voy a poner a aumentar las capacidades del editor de escenarios y a montar ejemplos para que sirvan de plantilla para el que tenga curiosidad, realmente no esperaba que la chipmunk estuviera tan integrada con bennu.. me he llevado una muy grata sorpresa.
Gracias de nuevo al autor del port, es cuanto menos excelente.
Avances:
- Ya tengo implementados los setters para mover a un objeto con absoluta y rigurosa suavidad!
* Estoy trabajando a tope en este proyectillo para simplificar al máximo el uso del gran trabajo que ha realizado el señor Prg, ya tengo una de las partes mas importantes montada y por suerte he conseguido aprender como funciona lo que ha hecho Prg, la suerte es que ha respetado el api oficial casi al máximo y esto ayuda mucho para continuar el trabajo jeje.
Un avance de una de las funciones que ya me funcionan a la perfección, la cuelgo por si alguien quiere usarla mientras completo todo lo demás.
function Physics_entity_add_velocity( float module_, float angle_ );
private
cpVect velocidad_; // velocidad a sumar a la actual de la entidad..
cpVect velocidadActual_; // velocidad actual de la entidad..
float vx;
float vy;
begin
vx = module_ * cos(angle_);
vy = module_ * sin(angle_);
cpv( vx, vy, &velocidad_ );
GetBody(father.lphysics.body,cp_c_v,&velocidadActual_);
cpvadd(&velocidadActual_, &velocidad_,&velocidadActual_); // Suma de velocidad actual mas velocidad a añadir..
DEFBODYP(father.lphysics.body,CP_C_V,&velocidadActual_); //Define la nueva velocidad de la entidad..
return(0);
end
Osease, para que se vea la diferencia de código a picar entre la lib a pelo y el engendro que estoy montando "capa de abstracción", basicamente eso es lo que hay que teclear para mover un objeto, pero con el API de alto nivel que estoy armando basta con hacer esto:
if(key(_left)) Physics_entity_add_velocity( 2.0, 0.0 ); end
Esta linea suma 2 al vector de velocidad del cuerpo que pertenece al proceso que realiza la llamada a la función, creo que queda bastante simple XD.. los parámetros de la función son bien simples:
1 - velocidad.
2 - angulo.
La función ya descompone la velocidad pasada como MODULO|ANGULO a VX|VY y la aplica por punteros con el api original que hizo Prg.
Bueno.. sigo con esto.. haber si logro crear todo lo que tengo en la lista, creo que va a resultar algo bastante simple de usar jeje.
Un saludo.
Edito:
Para mover un objeto con los cursores:
si se pulsa la tecla izquierda: Physics_entity_add_velocity( 2.0, 180000.0 );
si se pulsa la tecla derecha: Physics_entity_add_velocity( 2.0, 0.0 );
si se pulsa la tecla arriba: Physics_entity_add_velocity( 2.0, -90000.0 );
si se pulsa la tecla abajo: Physics_entity_add_velocity( 2.0, 90000.0 );
Para que se vea un poco lo que simplifica el API que estoy preparando.. esto es un proceso bola que se puede mover..
process test_object();
begin
x = 100;
y = 50;
graph = g_ball;
// Definición de las propiedades de este cuerpo: [ masa, elasticidad, fricción ].
Physics_entity_build( 10.0, 0.9, 0.3 );
loop
if(key(_left))
Physics_entity_add_velocity( 10.0, 180000.0 ); // parametros de velocidad: [ modulo, angulo ]
end
frame;
end
end
Incomming..
Woww!!! sorprendente!!!!! esto me ayuda a entenderlo mejor :D
Pues no sabes la que se avecina XD..
buf, veo que lleva trabajo, yo en esto te podria ayudar poco, (no he visto funciones trigonometricas todavia, aujnque se mas o menos que hace el seno y el coseno de un angulo). Una cosa en las lineas que haces el coseno y seno funcionan en milesimas de angulo??? pag 293 manual de osk,
QuoteCOS(NUMERO)
Esta función, definida en el módulo "mod_math", devuelve el coseno de un ángulo dado en milésimas de grado (la
unidad estándar para especificar ángulos en Bennu). El resultado será un número en coma flotante entre -1 y 1.
Jodo!! ya tengo portados los brakers!
Esto me preocupaba por que en mi lib eran bastante ineficaces y lentos, pero directamente multiplicando vectores literalmente la cosa vuela.
Se trata de un set de funciones que permiten el frenado dinámico por porcentaje, están diseñadas especialmente para juegos tipo plataformas donde controlamos normalmente un personaje y al soltar los mandos vemos claramente que la inercia no hace lo que exactamente deseamos.
Estas funciones son tan simples como esto: Physics_entity_brake( float percent_ );
El parámetro debe comprender valores de entre cero y 100, siendo 100 un frenado en seco, y valores menores representaran frenados desde muy muy suaves hasta lo bruscos que necesitemos.
Esto se anima XD.. ahora podremos de una forma muy simple al mas puro estilo DIV frenar un objeto "de una forma increiblemente suave" sea cual sea su masa y/o el valor de inercia seteado por la lib, digamos que es una función que aplica un decremento de inercia por si misma.
Hola alex, uso el seno y coseno con FLOATS, de esta manera mantengo la consistencia de los tipo de datos.
Si se usase con INT´s el resultado cambia ;)
Quote from: Erkosone on January 18, 2013, 06:13:55 PM
Hola alex, uso el seno y coseno con FLOATS, de esta manera mantengo la consistencia de los tipo de datos.
Si se usase con INT´s el resultado cambia ;)
Pero son en milesimas de grado entonces deberias multiplicar por 1000 en la funcion... igual no te he entendido muy bien, el caso es que yo e cai justo ahi, que programando una funcion para situar una camara le daba valores como 180, y no entendia porque no se movia, hasta que puse 180000 xD.
PD: Se me fue la olla, te puse angle y no las funciones.
Vale, me autocorrijo, no mire bien el codigo, en milesimas de grado con coma flotante.
Y parece que no se leer que lei despues que el parametro era en coma flotante. Sorry.
Bueno.. me voy al curro.. la tarde ha cundido bastante jeje..
Lo que ya tengo funcionando:
- Physics_world_set_gravity( float module_, float angle_ );
- Physics_world_set_timestep( delta_time_type_ );
- Physics_entity_build( float masa, float elasticFactor, float friccion );
- Physics_entity_add_velocity( float module_, float angle_ );
- Physics_entity_add_vx( float module_ );
- Physics_entity_add_vy( float module_ );
- Physics_entity_brake( float percent_ );
- Physics_entity_brake_x( float percent_ );
- Physics_entity_brake_y( float percent_ );
Esta noche cuando llegue del curro comenzaré con los getters y setters de velocidad, serán algo como esto:
- Physics_entity_get_velocity( float * module_, float * angle_ );
- Physics_entity_get_vx();
- Physics_entity_get_vy();
- Physics_entity_set_velocity( float module_, float angle_ );
- Physics_entity_set_vx( float vx_ );
- Physics_entity_set_vy( float vy_ );
Esto servirá para hacer algo como esto:
if( Physics_entity_get_vx() > 5.0 ) Physics_entity_set_vx( 5.0 ); end
Así se puede controlar de una forma muy simple la velocidad máxima de un objeto, por ejemplo un personaje que se mueve por un escenario o cualquier cosa vaya.
Hola amigo. No se si por chipmunk te refieres a mi mod_chipmunk, creo que sí.
Mira, tengo un código de aproximación poligonal, te podría servir para convertir un gráfico en un conjunto de lineas. Lamentablemente no he podido hacerlo en c. Es un código de mi tesis que pensaba usar, pero no he tenido tiempo.
Comparto este código contigo y la explicación de él (pdf adjunto, comienza en las últimas lineas de la primera página). Está escrito en matlab, espero conozcas el lenguaje.
function aproxPolig()
clc; close all;
set(0,'RecursionLimit',1500);
im = im2gray(imread('05.png'));
im = bwmorph(im,'remove');
im = bwmorph(im,'skel');
[vi,vj]=vertices(im);
[ir,jr]=aproxP(vi,vj,5);
imshow(im);
%line([jr jr(1)],[ir ir(1)]);
hold on
plot([jr jr(1)],[ir ir(1)],'*g',[jr jr(1)],[ir ir(1)],'-y');
hold off
fprintf('cantidad de puntos = %d\n',length(jr));
end
%recorre la imagen de bordes agregando los vértices a un vector
function [ai aj]=vertices(im)
[i,j]=find(im,1);
ind=1;
while (1)
ai(ind)=i;
aj(ind)=j;
im(i,j)=0;
ind=ind+1;
if (im(i,j+1)==1)
j=j+1;
continue;
end
if (im(i+1,j+1)==1)
j=j+1;
i=i+1;
continue;
end
if (im(i+1,j)==1)
i=i+1;
continue;
end
if (im(i+1,j-1)==1)
j=j-1;
i=i+1;
continue;
end
if (im(i,j-1)==1)
j=j-1;
continue;
end
if (im(i-1,j-1)==1)
j=j-1;
i=i-1;
continue;
end
if (im(i-1,j)==1)
i=i-1;
continue;
end
if (im(i-1,j+1)==1)
j=j+1;
i=i-1;
continue;
end
break;
end
end
function [ci,cj]=centroide(vi,vj)
ci=round(mean(vi));
cj=round(mean(vj));
end
function d=fdist(ix,iy,fx,fy)
d=sqrt((ix-fx).^2 +(iy-fy).^2);
end
%x3,y3 son las coordenadas del punto
function d=rectdist(x1,y1,x2,y2,x3,y3)
up=(y1-y2);
down=(x1-x2);
%tam=length(x3);
%d=zeros(1,tam);
%for z=1:tam;
if (up==0) %la misma y
d=x3-x1;
return;
end
if (down==0) %la misma x
d=y3-y1;
return;
end
m=up/down;
b=y1-(m*x1);
d=abs(m.*x3-y3+b)./sqrt(m^2+1);
%end
end
%vii lista de coordenadas en i
%vij lista de coordenadas en j
%ir lista resultado en i
%jr lista resultado en j
%umb umbral de error para limitar la fragmentación en los trozos.
%ind se marcan con 1 los puntos que pertenecen al cuerpo poligonal
function [ir,jr]=aproxP(vii,vjj,umbb)
global ind;
global vi;
global vj;
global umb;
%global cont;
%cont=0;
vi=vii;
vj=vjj;
umb=umbb;
clear vii;
clear vjj;
clear umbb;
[ci,cj]=centroide(vi,vj);
ind=zeros(1,length(vi));
d=dist(ci,cj,vi,vj);
[y,inc]=max(d); %toma el índice del punto más alejado al centroide
ind(inc)=1; %marca el punto más alejado al centroide como parte del cuerpo poligonal
d=fdist(vi(inc),vj(inc),vi,vj);
[y,fin]=max(d); %toma el índice más alejado punto anterior
ind(fin)=1; %marca ese punto como parte del cuerpo poligonal
recursApro(inc,fin); %llama recursividad para dividir por cuerpos poligonales usando la linea del índice inc al fin que son los índices del principio y final de la primer linea
recursApro(fin,inc);
%rs(ind)=1;
ir=vi(find(ind)); %las i del resultado son aquellas que se han marcado como parte de la aproximación poligonal
jr=vj(find(ind));
end
%inic índice inicial para la linea en que comenzará la recursividad
%fin índice final de la linea para comenzar la recursividad
%umb umbral de error para limitar la aproximación poligonal
%si fin<inic se debe hacer un buffer circular para esto xxxoooooxxx con x
%---los puntos de búsqueda
%ind almacena con 1 los puntos que forman parte del resultado
function recursApro(inic,fin)
global ind;
global vi;
global vj;
global umb;
%global cont;
%cont=cont+1
if (fin<inic) %buffer circular
tm=length(vi);
d1=rectdist(vi(1),vj(1),vi(fin),vj(fin),vi(1:fin),vj(1:fin));
d2=rectdist(vi(inic),vj(inic),vi(tm),vj(tm),vi(inic:tm),vj(inic:tm));
[v i]=max([d1 d2]);
%pause
if (v>umb)
if (i>fin) %ajusta i al arreglo completo
i=i-fin+inic+1;
end
ind(i)=1;
if (i~=1)
recursApro(inic,i-1);
elseif(inic~=tm)
recursApro(inic,tm);
end
if (i~=tm)
recursApro(i+1,fin);
elseif (fin~=1)
recursApro(1,fin);
end
end
return;
end
d=rectdist(vi(inic),vj(inic),vi(fin),vj(fin),vi(inic:fin),vj(inic:fin));
[v i]=max(d);
%pause
i=i+inic-1;
if (v>umb)
ind(i)=1;
if (i~=inic)
recursApro(inic,i-1);
end
if (i~=fin)
recursApro(i+1,fin);
end
end
end
Si lo escribes en c, no olvides compartirlo para poderlo agregar en la librería. Creo que siempre compartí el código fuente de Chipmunk, si también quieres trabajar sobre él.
Saludos, espero pronto continuar con el proyecto chipmunk... Saludos
pd: espero entiendas mi redacción. No he revisado coherencia detenidamente y esta versión de mi documento no la han revisado mis asesores así que ello no tienen la culpa si no se entiende... je je XD ... De cualquier forma creo que sí te servirá...
[/code]
Vaya, gracias Prg, y si, lo que ando haciendo es una simplificación de todo tu trabajo.
En esencia es una colección de funciones para hacer todo lo que solemos hacer en un juego de scroll o mode7 pero sin tener que tocar funciones a tan bajo nivel que funcionan a la perfección pero para alguien sin experiencia seguro que se espanta pronto al ver el código necesario jeje.
Por cierto, he visto que la librería está muy integrada en el lenguaje BennuGD, y quisiera hacerte algunas sugerencias para ella, cuando saque un rato si lo ves correcto me gustaría abrirte un post con un par o tres de cosillas que puede que ayuden bastante a simplificar mas todavía el uso de la 'mod_chipmunk' ;)
Sobre el source que me pasas pues no, no se mathlab, pero todo es ponerse, seguramente leyendo el documento que lo acompaña y entendiendolo sea capaz de entender tu idea, haber si termino los primeros pasos de todo esto que es dejar un API muy simplificado y funcionando, y ya los siguientes pasos son este que comentas y que comentaba anteriormente FreeYourMind y el de crear un archivo para los escenarios, tengo un formato creado y un editor ya funcionales pero quiero añadirle algunas caracteristicas mas para que simplemente el archivo sea una lista de objetos vectorizados y no solo una lista de puntos de control la cual hay que tratar desde el código.
En cualquier caso muchas gracias por compartirlo, le hecharé un ojo lo antes posible ;)
Y gracias también por tu trabajo, está cojonudo.
Bueno.. misión cumplida!
Ya están implementadas todas las funciones que he comentado, ahora le toca el turno a los segmentos y a las colisiones.. haber si este fin de semana termino de montar esto y cuelgo un zip con unos cuantos ejemplos de uso, creo que a los expertos les podrá resultar insultante XD.. pero a los novatos sin experiencia quizá les abra una nueva puerta por explorar!
Os dejo un .ZIP con lo que tengo hasta ahora por si alguien quiere ojearlo, todavía está verde pero se ve la idea de todo esto ;)
Ahora si, un zip para probar:
Lo he probado y va muy bien, la física ya es bastante buena, a veces se queda dando botitos muy pequeños no se si es por la física que tienes configurada, pero por lo demás va muy bien :D
AVANCES:
- Physics_scenario_load( string fileName_ );
- Physics_scenario_build();
Bueno.. pues después de pelearme con la WIKI de bennuGD unas cuantas horas "gracias a quien la haya redactado, es un recurso muy valioso", pues eso, que después de estár horas leyendo la documentación sobre split() y el modulo regex ya he logrado completar el segundo objetivo, el poder cargar un par de archivos generados desde mi editor, uno con extensión png y el otro con extensión cpt.
El resultado es un escenario vectorizado en scroll jeje.. que por cierto.. es una delicia para mis ojos ver como funcionan las colisiones, son mas que perfectas y suaves.
Voy a preparar un nuevo ZIP con una muestra de como queda el asunto por si alguien siente curiosidad.
Todavía tengo que simplificar mas la cosa pero esto ya es algo que pinta bien ;)
Test de ejemplo:
- Personaje controlable.
- Escenario vectorizado en modo scroll.
Teclas:
- cursores LEFT | RIGHT | UP para desplazarse.
- SPACE para frenar al personaje.
A la pregunta: Lo veis fluido? que me contestáis?
Vídeo con pruebas de performance del API, he hecho un poco el burro creando procesos para probar hasta que punto es funcional "sin ralentización" esto, los resultados iniciales son bastante satisfactorios :)
http://www.youtube.com/watch?v=38D4CmlasNk (http://www.youtube.com/watch?v=38D4CmlasNk)
Joder es la leche! por qué la bola queda flotando en vez de tocar el suelo? la fisica es muy buena! tengo ganas de probarla con algun juego ya :D
Mi comentario igual te ofende un poco...... "MENUDA FISICA!!!" xDDD
Lo de que se ralentiza, no he percibido nada, me ha parecido a la misma velocidad todo.
Una pregunta, son bolas lo que has puesto, pero las colisiones te las captura en hexagonos, o eso lo puedes hacer más manual???
PD: estaria guay, (que yo he visto muchos videos de esos, sin embargo no se como se hace), creo que es un programa que te captura la tecla (o si es el raton tambien) que pulsas, asi poder ver un poco con el codigo que has dejado como va...
PD2: siento no haber mirado el zip de antes, si que esta muy curradisimo segun he mirado el codigo, pero no lo he podido probar, estoy en linux, y no tengo instlada la lib (soy un vago para compilar e instalar cosas manualmente xD)
He probado con 700 pelotas y ni se inmuta jeje.. que pasada.. estoy flipando.. la mod_chipmunk funciona muy bien.
Gracias por los comentarios, pero el mérito de todo esto antes que mio es de Prg que se ha currado la librería mod_chipmunk y la ha integrado jeje, yo solo estoy haciendo que sea "mas sencillo" su uso pero todo se basa en su trabajo.
Sobre el código, pues es este:
process Personaje(x,y);
begin
ctype = c_scroll;
scroll.camera = id;
graph = g_ball;
size = 20;
// Definición de las propiedades de este cuerpo: [ masa, elasticidad, fricción ].
Physics_entity_build( 10.0, 0.1, 0.3 );
loop
if(key(_left))
Physics_entity_add_velocity( 2.0, 180000.0 ); // parametros de velocidad: [ modulo, angulo ] aplica una fuerza hacia la izquierda.
end
if(key(_right))
Physics_entity_add_velocity( 2.0, 0.0 ); // parametros de velocidad: [ modulo, angulo ] aplica una fuerza hacia la derecha.
end
if(key(_UP))
Physics_entity_add_velocity( 5.0, -90000.0 ); // parametros de velocidad: [ modulo, angulo ] aplica una fuerza hacia arriba.
end
if(key(_SPACE))
Physics_entity_brake(10.0); // Freno en un 10%/frame a la entidad.
end
if(Physics_entity_get_vx() > 200.0) // Si supero la velocidad en X..
Physics_entity_set_vx(200.0); // la limito..
end
if(Physics_entity_get_vx() < -200.0) // Si supero la velocidad en X..
Physics_entity_set_vx(-200.0); // la limito..
end
frame;
end
end
Creo que se entiende bien de un vistazo rápido y como ves el API es de muy alto nivel, te despreocupas de todo lo que sucede por debajo, solo hay que emplear esfuerzos en hacer el juego, que de eso se trata al fin y al cabo ;D [size=78%].[/size]
Ahora mismo estoy programando el editor de niveles para este API, la cosa es tan sencilla como generar el mundo del juego desde un programa que estoy haciendo llamado "SCENARIO" y luego simplemente lo cargas con: Physics_scenario_load( string fileName_ ); con esto ya tienes un escenario "scroll" en marcha con la chipmunk con todas las paredes suelos techos y demás cosas que son el horror de programar a mano con una calidad igual a la de la chipmunk.
Haber si termino el editor, lo había preparado para trazar lineas solamente.. pero he visto alguna limitación con este sistema tan simple, y al final me he decidido a crear algo currado, digamos que estos serán los pasos para crear un scroll para bennuGD con mod_chipmunk en este API:
1 - Abrir el editor SCENARIO y hacer click en NEW SCENARIO.
2 - Click en NEW OBJECT.
3 - Mediante la herramienta automática de lineas interconectadas entre si se hace click en los vertices de un objeto estatico del scroll "que se tendrá en pantalla a la vista".
4 - Click en SAVE OBJECT.
Y así para todos los objetos estaticos del escenario, luego CLICK en SAVE SCENARIO y ale.. lo cargas desde bennuGD y listos, no hay que preocuparse de nada mas, todo se configura solo para que funcione.
El tema es que quiero que los escenarios luego sean editables y tal.. no solo un simple "test", así que ando diseñando la estructura del programa y la estructura del archivo .SCN, cuando esté terminado te aseguro que crear un juego de scroll con física será cuestión de 1 minuto 2 como mucho.
AVANCES:
- Editor de escenarios completado 8)
Ahora ya tengo el API base y la herramienta para crear escenarios jejeje... en breve un vídeo con un tutorial sobre como crear un juego desde cero con todo esto y las descargas de todo en un pack.
Un saludo.
Joer como suena eso! que ganas de verlo!
Buenas, Prg si pasas por aquí me gustaría hacerte una consulta, cuando uso la función addInanimateShape() hay alguna forma de setearle el collisionType a ese shape?
He empezado a montar los collision hadlers para el API que ando haciendo y no veo el sistema para setearle a las lineas del escenario el collisionType = 2, sabes como se debe hacer?
O tendría que usar otro tipo de objetos "no estáticos" para esto?
Kamematen.. ya me auto respondo gracias a un comentario en uno de tus archivos .prg jeje.. "y se añaden al fondo.." he imaginado que el collisionType era el cero y efectivamente es el, ya ta!
AVANCES:
- Physics_entity_get_collision( TYPE_WORLD | TYPE_ENTITY );
Que hace esto?
- Esta función retorna el angulo de la normal del plano donde se produce una colisión, dicho en palabras "DIV".. retorna el angulo del suelo jeje.. creo que mas fácil imposible..
Esto implica que el API ahora tiene una nueva función que hay que llamar al inicio del programa: Physics_world_init();
- Esta función inicializa los collisionHandlers de forma completamente transparente, esto sirve para poder acceder al discriminador de colisiones interno de la chipmunk, y de esta manera poder conocer si existe o no una colisión entre dos tipos de objetos, en este caso la llamada a la función de esta manera:
angulo_suelo = Physics_entity_get_collision( TYPE_WORLD );
Con esto lo que obtenemos es, si no hay colision se obtiene un cero, si hay colisión con algún elemento del "mundo", osea.. las lineas.. pues nos devuelve automáticamente el angulo de la normal con esa linea, osea.. el angulo que necesitamos para saltar jeje..
Bueno.. sigo con esto.. la cosa está que arde!
joer que sencillo! pero cuanto curro hay detras! :D quiero probarlo ya!
Dios, estoy deseando que saques una versión ya "oficial" con su documentación y todo para utilizarla en un proyecto que tengo en mente.
No lo voy a usar ahora, porque tengo muchos proyectos abiertos y todavía no has sacado una versión "estable" ya me entiendes xD
Ya queda menos para la 1.0 ;D
La documentación estará en vídeo al completo.
AVANCES IMPORTANTES:
- Ya está integrado el sistema que abstrae del apoteosico sistema de collisionHandlers que usa la chipmunk :o
Que significa esto?
- La librería de física Chipmunk incluye un sistema de alto performance para la detección de colisiones, el tema es que puede resultar un poco complejo trabajar directamente con el, aunque es excelente hay que decir que es algo lioso por que hay que inicializarlo y usarlo con tipos definidos por el usuario, esto significa que hay que definir tipos en las entidades u objetos y dependiendo del tipo asociado a un objeto pues será un handler u otro el que haya que consultar.
Que leches he hecho yo para simplificar todo esto?
- He creado estas funciones "para mantener la consistencia del API":
* Physics_entity_set_type( int type );
* Physics_entiy_build_collision_handle( int type );
Ahora con estas dos simples funciones podemos hacer lo siguiente, sabiendo de antemano que todos los objetos del WORLD siempre serán del tipo CERO:
1 - Crear la entidad con Physics_entity_build();
2 - Setear el tipo con Physics_entity_set_type();
3 - Crear un detector de colisiones con: detector_de_colision = Physics_entiy_build_collision_handle( 0 );
4 - Ya está todo!!
Simplemente para saber si estamos tocando el WORLD se hace esto:
angulo_suelo = Physics_entity_get_collision( detector_de_colision );
if( angulo_suelo != 0.0)..
Voy a montar el tercer vídeo tutorial sobre este tema, es muy interesante y con esto creo que ya estoy muy cerca de tener una versión 1.0 ahora ya si, con colisiones jeje!!
El detector de colisiones ahora es para mearse XD.. creo que esto para el que use la chipmunk le va a ayudar bastante..
Making off vídeo tutorial incoming.. esta vez con varios objetos diferentes..
Buenas, estoy trabajando en la abstracción de los joints, ya tengo la función que crea un joint pero tengo errores en la ejecución de la función que los elimina, en cuanto lo tenga arreglado publicaré otro tutorial y la explicación de como se usan ;)
Que es un joint?
- Es una unión entre 2 cuerpos, básicamente sirve para unir 2 objetos por 2 puntos, esto permite agarrar con el mouse a un objeto, o por ejemplo crear un coche con un par de rectangulos y 2 circulos como ruedas, es exactamente lo que deja hacer el juego "bad piggies".
Las funciones inicialmente van a ser estas:
- id_joint = Physics_entity_set_joint( int id_destino_ );
- Physics_entity_kill_joint( id_joint );
Luego ya las iré ampliando para crear joints mucho mas elaborados como los joint´s excentricos y cosas así.
De forma colateral a esto me ha surgido la necesidad de crear una nueva función:
- Physics_entity_set_position( x, y );
Esta función será la encargada de colocar a un objeto en su posición exacta justo antes de crear el joint, de esta manera podremos crear uniones de una forma extremadamente sencilla.
Bueno.. sigo con ello.. haber si descubro el motivo de que al intentar eliminar el joint la lib me salte con "antes de eliminar el joint debe estar añadido al mundo" o algo así.
Ya tengo los joints integrados en el API de una forma chachi piruli ;D
Con estos dos pedos de funciones conseguimos agarrar "justo por el punto de colisión" a cualquier objeto del mundo jeje..
He sudado para aprenderme bien como funcionan las funciones que hizo Prg integradas con bennu, pero ahora que he comprendido exactamente lo que hacen la cosa queda así de simple jeje..
Physics_entity_set_joint( id_process_to_joint );
Physics_entity_kill_joint( &id_joint );
Estas 2 funciones con tan pocos parámetros las he montado especialmente para el 'MOUSE', tengo que mirar ahora que ya me funcionan perfect como dejarlas un poco mas dinámicas y abiertas a mas configuraciones.
Preparo el 5º vídeo tutorial con todo esto y lo cuelgo en unos minutos.
Gracias 'Prg' por permitirnos disfrutar de la física en bennu, a mi me hace enormemente feliz.
Que bueno que les guste la librería :)
A ver si en breve puedo revisar los editores que suenan muy bien y claro que aceptaré la lista con las sugerencias para la librería.
Saludos :)
La librería está genial de verdad, gran trabajo en lo que a la integración con bennu se refiere, está todo bastante bien organizado.
He creado una nueva función que simplifica mucho mas los códigos y los hace mas eficientes con el mismo resultado.
Antes era necesario hacer esto para controlar los limites de velocidad de una entidad dentro de su loop:
if(Physics_entity_get_vx() > 200.0) // Si supero la velocidad en X..
Physics_entity_set_vx(200.0); // la limito..
end
if(Physics_entity_get_vx() < -200.0) // Si supero la velocidad en X..
Physics_entity_set_vx(-200.0); // la limito..
end
Ahora simplemente con esta función accedemos al vector limitador de velocidad de la propia chipmunk:
Physics_entity_set_maxMotion( 200.0 );
Cada minuto que pasa esto queda mas simple XD..
AVANCES:
+ Añadidas las funciones para la creación de joints de forma completamente al gusto.
De que va esto?
- Simplemente con la función: Physics_entity_set_joint2( ID1, ID1x, ID1y, ID2, ID2x, ID2y ) ahora podemos crear un joint entre 2 procesos cualesquiera, esto abre un amplio abanico de posibilidades y como se ve es muy sencillo de utilizar.
Se le pasa el ID de un proceso y "un punto dentro de su gráfico" y otro ID de otro proceso y "un punto dentro de su gráfico", y automáticamente quedan unidos por esos puntos, esto es bastante interesante por que se puede preparar un gráfico con 2 puntos de control definidos por ejemplo.. para crear puerdas o cosas así es la leche jeje.. el siguiente tutorial va sobre esto..
Lo que abstrae esta función es básicamente escribir todo el código que se necesita para recuperar la posición dentro del mundo de los puntos que queremos usar.
Estoy añadiendo algo interesante y que simplifica bastante e integra con este tipo de lenguaje los joints..
La función se llama Physics_entity_set_joint2( id1, cp1, id2,cp2 );
Que hace?
- Crea un joint desde el ID1 en su posición interna "punto de control cp1" y ID2 y su punto de control pasados como parámetros.
Esto permitirá crear gráficos prefabricados con puntos de control y luego simplemente engancharlos desde ellos, me estoy peleando con la formula que saca el offset del punto de control dentro del shape "en el mundo físico".. haber si lo consigo.. pero estoy cerca.. ya se crean aproximadamente bien XD.. pero estoy restando algo mal de lo que me devuelven get_real_point() y map_info()..
Incomming..
Conseguido!
Ahora estoy con otra función interesante: Physics_entity_fix_point( id_process, c_point_number, world_X, world_Y );
Esta función ancla un proceso al mundo en las coordenadas pasadas como parámetro y desde el punto de control pasado como parámetro ;)
Osea, si tenemos una caja y queremos anclar su c_point[1] en las coordenadas de un scroll "100,50" se hace esto:
Physics_entity_fix_point( id, 1, 100, 50 ); y ale.. proceso anclado..
La función retorna el id que apunta al joint para poder eliminarlo en cualquier momento.
Incomming.. cuando funcione esta función armo otro vídeo explicando como se usa.
joer la leche! lo estas simplificando muchisimo! un excelente trabajo el tuyo, despues del div espero que mi primer proyecto publicado sea con tu lib de físicas :D
queremos probar pero donde descargo algoooo
Aquí están los vídeos sobre el tema y cada descargable, cada nuevo tutorial incluye nuevas funcionalidades que se muestran en el vídeo que lo acompaña ;)
http://forum.bennugd.org/index.php?topic=3413.0
AVANCES:
- Función añadida: Physics_entity_fix_point();
- Función añadida: Physics_entity_set_joint2();
Esta función ancla al mundo un objeto en su posición actual por el c_point pasado como parámetro, un uso común en juegos es este: "la he creado para esto precisamente jejeje.."
Como crear un puente por donde el personaje y los malos pueden caminar.. y que el puente sea construido a eslabones:
- Crear los procesos de los eslabones y guardad sus Id´s.
- unirlos mediante Physics_entity_set_joint2( id1, c_point, id2, c_point );
- Colocarlos en su sitio dentro del scroll.
- Usar esto con el primer y el ultimo eslabon: Physics_entity_fix_point( id, 0 );
Esto ancla los extremos del punte y crea una cadena por donde podremos pasearnos, con 2 simples funciones.. el próximo tutorial en vídeo trata este tema.
Comienzo el tema de los motores y en cuanto tenga lista la función que convierte a una entidad en un motor y la función que establece la velocidad del mismo publicaré otro tutorial.
La idea que tengo es la de crear una entidad como hasta ahora y simplemente llamando a una función sencilla se pueda convertir en un motor para que resulte sencillo de esta manera crear un rectangulo con 2 ruedas/motores que sean los que le proporcionen el movimiento. ;)
Creo que hay algún bug en la mod_chipmunk con el tema de los motores.. pero no estoy seguro..
Alguien los ha usado ya y sabe el modo de usarlos correctamente?
Yo simplemente desde un proceso el cual ya tiene una entidad de física creada hago esto y debería funcionar.. no da error pero no hace nada:
mi_motor = addsimplemotor(id,0,0.0);
SETSIMPLEMOTORPROPERTIES(mi_motor, CP_C_RATE, 10000.0);
El caso es que si establezco el RATE directamente si que funciona con: addSimpleMotor( ID, 0, 10000.0 );
Con lo cual creo que el error es que yo no se actualizar el valor de CP_C_RATE, alguien puede ayudarme?
Parece que con CP_C_RATIO si que se puede actualizar la velocidad del motor de forma dinámica pero en la documentación no aparece este campo, quizá sea un error tipográfico, bueno, el caso es que ya tengo las funciones que crean y manipulan el motor jeje..
Physics_entity_set_motor( id ); -> Le pasamos el ID del proceso el cual se quiere convertir en un motor.
Physics_entity_Set_motor_velocity( id_motor, float velocity_ );
El siguiente tutorial va sobre esto, mostraré como crear un simple coche o carro que acelera pulsando la barra espaciadora jeje..
AVANCES:
- Añadidas 2 funciones para crear máquinas, osea, crear motores y ajustarlos.
De camino el Video tutorial final número 7.
Contenido:
- Ejemplo ridículamente simple de como se crea un coche y se hace correr por el escenario!
El vídeo está compilandose, en breve estará disponible.
Un saludo.
Quizá te ayude el ejemplo de máquina TheoJansen.
Test09
Se usa un motor para activar las patas...
Voy a examinarlo, por que.. si te cuento lo que estoy haciendo XD..
tengo un vehiculo complejo ya montado con todas sus partes, y sucede que usé motores para las ruedas XD.. el problema es que al dejar de acelerar se ve un defecto en la representación de la simulación, no es culpa de la lib, está clarisimo que es culpa de un planteamiento deficiente por mi parte XD.. digamos que las ruedas desaceleran y eso proboca una fricción que frena al vehículo.
Ahora estaba esbozando el diseño de dos tipos distintos de tracción, el que mas me gusta por ahora es super simple, trata sobre anclar en el cuerpo de la máquina un motor circular con un size = 10; para el shape, osea, el shape bastante reducido, entonces coloco las ruedas en la posición clave en la cual friccionarían con el motor si este tubiera un poco mas de radio, entonces uso SIZE como si de un embrague se tratara, osea, con un size alto se embragan por fricción y con size bajo no XD.. así he conseguido simular "en mi opinión" un coche de una forma casi excelente, bueno.. sigo con ello, gracias por la recomendación, voy a mirarlo haber como está hecho ;)
estaria buena una tabla de compraciones o ventajas/desventajas del la implementacion de prg vs la de erkosone... o al menos que mejoras traer el usar una sobre la otra...
no se si me explico.
Solo me interesa el algoritmo que haga los bordes a un grafico para las colisiones, regalo un jamon a quien lo termine
que?
Ves preparando ese jamón XD.. yo lo tengo apuntito..
Para ir abriendo boca con algo de código XD..
Este fragmento es un scanner de contorno.. no está terminado todavía por que lo estoy portando desde otro lenguaje que lo tenía ya hecho y en bennuGD cambian algunas cosas pero practicamente es idéntico, me falta ya un pedo para que guarde en la lista de c_point del gráfico la lista de vectores jeje..
//.............................................................
//.............................................................
//..............VECTORIZAR UN GRAFICO EN LINEAS................
function Physics_entity_calculate_shape();
private
int ancho_; // ancho de la imágen en pixels..
int alto_; // alto de la imágen en pixels..
int x_inicial = -1; // X del inicio del contorno..
int y_inicial = -1; // Y del inicio del contorno..
int secure_steeps = -4; // En el quinto paso por la tortuga será mayor que cero y entonces tendré la certeza de que no estoy
// En el punto inicial del contorno..
begin
// Heredar gráfico del proceso que realiza la llamada..
file = father.file;
graph = father.graph;
// No pintar nada en pantalla desde esta función..
alpha = 0;
// Obtener las dimensiones del gráfico..
ancho_ = map_info(file, graph, g_width);
alto_ = map_info(file, graph, g_height);
// Buscar un pixel con color diferente de cero para establecer el inicio del contorno...
for(y=0; y<alto_; y++) // Scanear filas de la imágen..
for(x=0; x<ancho_, x++) // Scanear columnas de la imágen..
if( map_get_pixel( file, graph, x, y ) <> rgb(0,0,0) )
// Guardo las coordenadas del punto que tomaré como inicio del contorno para la imágen..
x_inicial = X;
y_inicial = Y;
break;
end
end
end
// Si la imágen no contenía ningún pixel con color entonces se termina esta función..
// Valor de retorno -1 para este error..
if(x_inicial == -1 or y_inicial_ == -1)
Return(-1);
end
// Comienza el scan real de contorno..
while(true)
// Tortuga de Pappert, COLOR DETECTION, método excelente..
if(map_get_pixel(file, graph, x, y) <> rgb(0, 0, 0) )
angle+=90000;
advance(1);
end
// Tortuga de Pappert, COLOR MISSING, método excelente..
if(map_get_pixel(file, graph, x, y) == rgb(0, 0, 0) )
angle-=90000;
advance(1);
end
// Aumento este contador.. es el que pasados 5 pasos me dejará comprobar si la posición actual es la inicial..
// y entonces asumiré que el contorno se ha recorrido al completo..
secure_steeps ++;
if(secure_steeps > 0 )
if(x_inicial = X && y_inicial == Y) // he vuelto al punto de partida del contorno??
BREAK; // si es cierto se termina el scanner..
end
end
end
end
//.............................................................
La idea de todo esto es que cualquiera haga esto desde un proceso cualquiera:
Physics_entity_calculate_shape();
y ale.. ya tenemos la lista de vectores guardada en el propio gráfico ya que dudo muchísimo que una imágen tipo "sprite" necesite mas de 999 vectores ;D
Y lo siguiente es esto:
Physics_entity_build( TYPE_POLY..... )
Con la interesante cosa de que no hay que hacer absolutamente nada con vectores ni lineas ni nada de nada.. está pensado para alguien que no sabe hacer nada de esto, simplemente el tipo poligonal usará la propia lista de puntos de control del gráfico jeje.. ingenioso no?
Esta es la forma que está tomando la función.. no está testeada.. estoy montandola ahora mismo.. voy por un café que la neurona me pide azucar XD..
Os lo pego por si alguien tiene curiosidad.. es bastante sencillo de seguir.. y tengo que optimizarlo un montón cuando lo termine.. pero básicamente esta es la estructura de la función en si misma..
//.............................................................
//.............................................................
//..............VECTORIZAR UN GRAFICO EN LINEAS................
function Physics_entity_calculate_shape();
private
// variables para el scanner de contorno..
int ancho_; // ancho de la imágen en pixels..
int alto_; // alto de la imágen en pixels..
int x_inicial = -1; // X del inicio del contorno..
int y_inicial = -1; // Y del inicio del contorno..
int secure_steeps = -4; // En el quinto paso por la tortuga será mayor que cero y entonces tendré la certeza de que no estoy
// En el punto inicial del contorno..
// variables para el vectorizador de contorno..
int _x_[4]; // buffer de 5 posiciones X para pixels con color..
int _y_[4]; // buffer de 5 posiciones Y para pixels con color..
int _steep_ = 0; // indica los pasos de relleno del buffer..
int vertices = 1; // Empezamos a rellenar en el c_point número 1.. el cero lo dejamos para ubicar al gráfico en pantalla..
int med_x_; // indica la média aritmética del buffer de variables X..
int med_y_; // indica la média aritmética del buffer de variables Y..
int back_x_; // indica la posición en X del c_point anterior..
int back_y_; // indica la posición en Y del c_point anterior..
int umbral_angulo_ = 10000; // umbral en angulo que debe superar una comparación entre vectores para considerarse fuera de una recta el segundo de ellos..
begin
// Heredar gráfico del proceso que realiza la llamada..
file = father.file;
graph = father.graph;
// No pintar nada en pantalla desde esta función..
alpha = 0;
// Obtener las dimensiones del gráfico..
ancho_ = map_info(file, graph, g_width);
alto_ = map_info(file, graph, g_height);
// Buscar un pixel con color diferente de cero para establecer el inicio del contorno...
for(y=0; y<alto_; y++) // Scanear filas de la imágen..
for(x=0; x<ancho_; x++) // Scanear columnas de la imágen..
if( map_get_pixel( file, graph, x, y ) <> rgb(0,0,0) );
// Guardo las coordenadas del punto que tomaré como inicio del contorno para la imágen..
x_inicial = X;
y_inicial = Y;
break;
end
end
end
// Si la imágen no contenía ningún pixel con color entonces se termina esta función..
// Valor de retorno -1 para este error..
if(x_inicial == -1 or y_inicial == -1)
Return(-1);
end
// ya que tenemos la posición inicial del contorno.. le creamos ya el primer vector..
set_point(file, graph, vertices, x, y);
// pasamos al siguiente punto de control..
vertices ++;
// Comienza el scan real de contorno..
while(true)
// Tortuga de Pappert, COLOR DETECTION, método excelente..
if(map_get_pixel(file, graph, x, y) <> rgb(0, 0, 0) )
// _vectorGraphic_ por _buffer_ de 5 pixels..
if( _steep_ < 5) // si quedan posiciones del buffer por rellenar..
_x_[_steep_] = x; // las relleno..
_y_[_steep_] = y; // las relleno..
_steep_ ++; // paso a la siguiente posición del buffer..
else // si el buffer está lleno.. entonces toca mirar si hay que crear un nuevo vector..
if(vertices > 1)
// calculo la posición real para el nuevo vector.. será la media aritmética de las 5 lecturas tomadas en el buffer..
med_x_ = (_x_[0] + _x_[1] +_x_[2] + _x_[3] + _x_[4]) / 5;
med_Y_ = (_y_[0] + _y_[1] +_y_[2] + _y_[3] + _y_[4]) / 5;
// obtengo la posición del vector anterior..
get_point( file, graph, vertices-1, &back_x_, &back_y_ );
// comparo el angulo entre los vectores que forman ambos puntos de control..
// si sobrepasan un umbral en angulo se considerará que es necesario crear un nuevo punto de control..
// si no se pasa el umbral se considerará que el punto actual está dentro de la trayectoria de una recta..
// y en consecuencia sería un desperdicio de performance crear mas puntos de control para definir una unica recta..
z = fget_angle( back_x_, back_y_, med_x_, med_y_);
if(abs(z) > umbral_angulo_)
set_point(file, graph, vertices, med_x_, med_y_ );
vertices ++; // nos colocamos en el siguiente punto de control..
_steep_ = 0; // y ahora volvemos a empezar a rellenarlo..
for(z=0; z<5; z++) // pero primero pongo a cero el buffer..
_x_[z] = 0; // pues eso.. lo pongo a cero..
_y_[z] = 0; // pues eso.. lo pongo a cero..
end
end
end
end
angle+=90000;
advance(1);
end
// Tortuga de Pappert, COLOR MISSING, método excelente..
if(map_get_pixel(file, graph, x, y) == rgb(0, 0, 0) )
angle-=90000;
advance(1);
end
// Aumento este contador.. es el que pasados 5 pasos me dejará comprobar si la posición actual es la inicial..
// y entonces asumiré que el contorno se ha recorrido al completo..
secure_steeps ++;
if(secure_steeps > 0 )
if(x_inicial = X && y_inicial == Y) // he vuelto al punto de partida del contorno??
BREAK; // si es cierto se termina el scanner..
end
end
end
end
//.............................................................
mañana lo pruebo y veremos si te llebas uno de jabugo o de cebo ;D
Todavía no está terminada, esa es la forma que está tomando pero estoy todavía implementandolo en el api que tengo, cuando lo tenga listo lo cuelgo con vídeo tutorial extra.
Primera parte del tema solucionada!!
Ya tengo la función: Physics_entity_calculate_shape();
Al usarla desde cualquier proceso lo que sucederá es que se rellenará la tabla de c_point del gráfico del proceso que realiza la llamada con los puntos que definen el contorno del shape poligonal ;D
El código es una copiada descarada de uno de los tutoriales de Prg XD.. pero adaptado a las necesidades de este caso concreto..
Ahora toca la parte que creo que será mas sencilla.. es la de crear el shape para el proceso a partir de esta información de puntitos ;)
Sigo con ello.. creo que en breve estará listo y será coser y cantar hacer shapes super complejas con un pedo de función.
Gracias PRG por tus códigos de ejemplo y por el algoritmo de vectorización de imagen, es un trabajo soberbio te lo digo de verdad, puede preguntarte si lo diseñaste tu solo?? te basaste en algún otro trabajo de alguien para poder hacerlo o es de tu propia cosecha? por que si me dices que es tuyo desde cero te puedo decir que OLE MACHOTE!
Estoooooo....
Vale... haber como lo digo XD...
Estoy flipando en colores...
Yo matandome a montar las funciones y bla bla bla aquí pasando las noches alimentandome a cacahuetes y café jajajaja... y oye.. me da por probar por eso de que la curiosidad mató al gato..
Pues eso.. que me ha dado por probar a meterle un TYPE_CONVEX_POLIGON así directamente ya por el cansancio a un objeto.. y COÑO!! la lib calcula el shape poligonal ella solita!
No se si ya es el sueño o que.. pero estoy flipando.. acto seguido "que se me ha caido el puñetero café encima XD.." he vuelto a poner TYPE_BOX y coño!! la cosa cambia y mucho!
No se si estoy ya loco o que.. pero me da que la librería ya coje el shape y hace todo esto solita, weno.. no es que me dé.. es que lo estoy probando y es así, funciona perfecto :o
Verificado al 100%
No hace falta para nada especificar un shape complejo y un arreglo de vectores para crear una forma poligonal, no salgo de mi asombro.. hasta calcula el centro de gravedad todo automático en función del area del poligono.
Estoy usando una versión de mi API que todavía no he liberado, calcula varias cosas extra cuando hacemos un Physics_entity_build() y el resultado es soberamente bueno.
Voy a montar un ejemplo ahora mismo en vídeo y cuelgo la ultima versión que tengo que ya incluye un sistema ridiculamente simple para crear perros guardianes para los joint´s, osea, los watchdog´s de toda la vida en C.
Incomming.. ahora si que estoy contento jeje.. esto es la leche, funciona mas que perfecto.
Arriba comentabas que si me hice solito lo de la vectorización: La verdad es que uní partes mías y partes ajenas. Yo codifiqué todo, pero la idea del algoritmo de aproximación poligonal ya es vieja. Lo mío fue la parte del cálculo de bordes por morfología matemática + limpieza de bordes con morfología matemática y cálculo de chi (Se define como dos veces el número de conexiones potenciales del resto del objeto con el pixel que se analiza). El cálculo de bordes usa operaciones binarias de corto circuito para acelerarse... Esa es mi cocecha. A partir de estos bordes reviso elementos conexos y obtengo sus coordenadas; luego identifico si es un contorno cerrado o abierto para luego aproximarlo por partición sucesiva.
La partde convex_poly... síp, la librería las calcula sola. REvisa el test 16 para más información
La lista de text es esta:
Quotetest00 Pelota rebotando
addInanimateShape
lphysics.mass
lphysics.ELASTICITY
lphysics.friction
lphysics.ShapeType
forceCreateBody()
lphysics.inertia
GETOPTIMALINERTIA()
INTERSECTSBB(id2) --> colisión
muerte de procesos con física
test01 Cuerpos sin gravedad estilo bomberman, Empujar objetos, Movimiento de personaje y Traspasar objetos.
gphysics.bias_coef
gphysics.damping
lphysics.static
lphysics.group
TYPE_CONVEX_POLYGON
cpMomentForCircle()
TYPE_CIRCLE
CP_NO_GROUP
TYPE_box
test02 Slew, cuerpos estáticos y Pirámide de dominós.
gphysics.iterations
gphysics.collision_slop
gphysics.sleepTimeThreshold
cpvadd()
Slew()
test03 Polígonos definidos por arreglo y lphysics.group
lphysics.params
TYPE_CONVEX_POLYGON
test04 Movimiento con el ratón, Joint, Colisión puntual, gphysics.interval, y uso de boundingbox (intersecciones y envoltura).
gphysics.SLEEPTIMETHRESHOLD
infinityf()
cpBBIntersects
cpBBmerge
DefConstraintF
CP_C_MAXFORCE
CP_C_BIASCOEF
RemoveConstraint
ShapeCacheBB
cpBB
test05 Varias pelotas que se pueden mover, piso formado por línea y función para obtener los shapes y constraints de un proceso, gphysics.bias_coef.
COLLISIONHANDLERNEW
SpaceSegmentQueryFirst
SegmentQueryHitPoint
SegmentQueryHitDist
GETCOLLISIONINFO
GETCONSTRAINTS
GETSHAPES
test06 phresolution, pin, joint, motor y resortes.
addPivotJoint
addSimpleMotor
addPinJoint
addDampedRotarySpring
infinityf
test07 Física de juego tipo plataformas, péndulos, objetos con centro distinto del (0,0), Movimiento por fuerzas
cpContactPointSet
cpvperp
cpvmult
cpvadd
DEFBODYP
CP_C_V
GETCOLLISIONINFO
cpfclamp
test08 Eliminar zona y eliminar todos los cuerpos físicos. Constraints
cleanSpace
WORLD2LOCAL
RemoveConstraint
cpMomentForPoly
addPinJoint
addSlideJoint
addPivotJoint
addGrooveJoint
addDampedSpring
addDampedRotarySpring
addRotaryLimitJoint
addRatchetJoint
addSimpleMotor
DefShapeI
CP_C_LAYERS
NOT_GRABABLE_MASK
addInanimateShape
COLLISIONHANDLERNEW
test09 Uso de constraints, Modificación de propiedades de constraints, Procesos con más de un shape, Simulación de máquina TheoJansen.
cpMomentForSegment
ADDPIVOTJOINT2
ADDCIRCLESHAPE
defShapef
ADDPINJOINT
SETPINJOINTPROPERTIES
CP_C_DIST
DefShapeI
CP_C_LAYERS
NOT_GRABABLE_MASK
CP_C_E
CP_C_U
DefShapeF
cpvforangle
CM_PI
ADDSIMPLEMOTOR
SETSIMPLEMOTORPROPERTIES
DEFCONSTRAINTF
CP_C_MAXFORCE
test10 Generación de terrenos mediante .cpt
COLLISIONHANDLERNEW
addInanimateShape
cpMomentForCircle
cpvperp
cpvmult
cpvadd
GETCOLLISIONINFO
cpBodyActivate
cpContactPointSet
test11 Handlers de collision. Omitir respuesta de cuerpos al colisionar (Útil para juegos de plataformas donde el personaje colisiona con el piso sólo cuando desciende y no cuando asciende (aquí revisaríamos la dirección de la normal de colisión para filtrar las colisiones)).
SPACEADDCOLLISIONHANDLER
SPACEREMOVECOLLISIONHANDLER
Ejemplo de handler presolve, postsolve, separate e inicia.
test12 Simulando objeto que cae en un líquido
addInanimateShape
SPACEADDCOLLISIONHANDLER
GETARBITERPOINT
MODARBITERPROCESSA
ResetForces
ApplyForce
DefBodyP
cpfclamp
lphysics.collisionType
updateVelocity
test13 Lista de cuerpos colgados y destrucción de constraints al superar un umbral en la fuerza aplicada (Destrucción de uniones y resortes)
ADDSLIDEJOINT
DEFCONSTRAINTF
CONSTRAINTSETPOSTSOLVEFUNC
RemoveConstraint
getConstraintFatherA
getConstraintFatherB
CP_C_MAXFORCE
GETCONSTRAINTF
SpaceGetCurrentTimeStep
constraintGetImpulse
test14 Mover un cuerpo y hacer que se vaya frenando con el tiempo
APPLYIMPULSE
gphysics.damping
test15 Simulando una soga
APPLYIMPULSE
addPivotJoint2
WORLD2LOCAL
test17 simulación de soga.
test16 Creación automática de cuerpos convexos
CALCULATECONVEXBODY
ejemplo con uso de size
test18 Creación de cuerpos a partir de gráfico
test19 Simulación y pintado de agua...
El problema de mi algoritmo de convex es que genera un cuerpo convexo de toda la imagen, pero esto es para lo que normalmente se usa.
El algoritmo de aproximación poligonal por su parte genera un cuerpo poligonal para cada elemento conectado (Hace un etiquetado de componentes conexas al vuelo, si es que lo podría llamar así a lo que hace).
Quote from: Erkosone on February 03, 2013, 02:28:08 AM
Verificado al 100%
No hace falta para nada especificar un shape complejo y un arreglo de vectores para crear una forma poligonal, no salgo de mi asombro.. hasta calcula el centro de gravedad todo automático en función del area del poligono.
Estoy usando una versión de mi API que todavía no he liberado, calcula varias cosas extra cuando hacemos un Physics_entity_build() y el resultado es soberamente bueno.
Voy a montar un ejemplo ahora mismo en vídeo y cuelgo la ultima versión que tengo que ya incluye un sistema ridiculamente simple para crear perros guardianes para los joint´s, osea, los watchdog´s de toda la vida en C.
Incomming.. ahora si que estoy contento jeje.. esto es la leche, funciona mas que perfecto.
El algoritmo calcula solo cuerpos convexos...
Splinter comentaba algo de una tabla.
Yo sólo ofrezco la librería y algunos test-examples... Lo que sí podría hacer es listar las nuevas características... je je... pero hacer una tabla, Erksone me ganaría ya que el ofrece lo de mi librería y lo que él está haciendo.
Erksone nos ha creado código para facilitar el uso de la librería mod_chipmunk. Gracias amigo.
No se merecen Prg, yo solo comparto igual que compartís vosotros. ;)
Nuevo tutorial de camino jeje..
Contenido:
- Shapes poligonales.
- Funciones "perro guardián".
- Nueva función Physics_joint_get_impulse() que retorna el porcentaje de esfuerzo realizado por un joint.
Lo estoy compilando.. en cuanto esté listo lo cuelgo con la ultima versión del api.
a que te referis con las funciones "Watch Dog"? un watch dog es un metodo por el cual se envian pulsos con una frecuencia preestablecida para confirmar que el sistema sigue vivo y no congelado y en caso de falla (no recibir una de estas señales) reinicia todo el sistema... pero como ayuda esto a esto al motor de fisica? podrias dar detalles?
Quote from: Prg on February 03, 2013, 02:51:00 AM
Quote from: Erkosone on February 03, 2013, 02:28:08 AM
Verificado al 100%
No hace falta para nada especificar un shape complejo y un arreglo de vectores para crear una forma poligonal, no salgo de mi asombro.. hasta calcula el centro de gravedad todo automático en función del area del poligono.
Estoy usando una versión de mi API que todavía no he liberado, calcula varias cosas extra cuando hacemos un Physics_entity_build() y el resultado es soberamente bueno.
Voy a montar un ejemplo ahora mismo en vídeo y cuelgo la ultima versión que tengo que ya incluye un sistema ridiculamente simple para crear perros guardianes para los joint´s, osea, los watchdog´s de toda la vida en C.
Incomming.. ahora si que estoy contento jeje.. esto es la leche, funciona mas que perfecto.
El algoritmo calcula solo cuerpos convexos...
Splinter comentaba algo de una tabla.
Yo sólo ofrezco la librería y algunos test-examples... Lo que sí podría hacer es listar las nuevas características... je je... pero hacer una tabla, Erksone me ganaría ya que el ofrece lo de mi librería y lo que él está haciendo.
Erksone nos ha creado código para facilitar el uso de la librería mod_chipmunk. Gracias amigo.
no se trata de ganar o perder... la pregunta va mas en "por que deberia usar la libreria de Erkosone en lugar de la de Prg o a la inversa?" y no me vale que me digan, porque la de Erkosone esta mas completa o tiene mas features.
me interesa saber, diferencias de uso, funcionalidad que trae una y la otra, en que fallan, en que tienen soporte parciales (por ejemplo, entendi que dicen que el sistema detecta formas convexas... y que onda con las concavas? o quizas seguramente estoy entendiendo mal)... pregunto todo esto, desde la mas absoluta ignorancia del tema... pero seguramente asi como me lo pregunto yo, se lo preguntaran mucho.
Si, Splinter, mira cuelgo ya el link del vídeo que he montado para enseñar las funciones estas watch dog y algunas cosas mas y supongo que viendolo se entiende a la primera el concepto, en esencia es el mismo que cuando se programa un watch dog para la integridad de un circuito electrónico basado en un microcontrolador, he sacado de ahí el nombre por que pienso que es lo que mas se asemeja a su uso en la lib.
Quiero aclarar que todo el trabajo que yo he añadido está profundamente ligado y se apoya en el trabajo de Prg, el api que muestro no es mas que una capa de abstracción de muchos aspectos que complican el diseño de un juego por que requieren un mayor manejo y control de la chipmunk, simplemente hacen mas sencillas operaciones que ya existen en la librería o agrupan un set de operaciones para realizar acciones que son necesarias de forma repetitiva en los vídeo juegos.
Originalmente la PhysicsMotion no era "API", era "LIB" y esa versión si que es un motor de física dinámica en si mismo, pero este para bennu está apoyado en los calculos de la chipmunk que son bastante mejores en todo ;D
Iba a colgar el vídeo en la sección recursos pero no la veo accesible en el foro, no veo nada del foro en español, ande está ahora?
Bueno, lo he encontrado accediendo desde el finder, ya está disponible el nuevo vídeo tutorial sobre estos temas y el descargable para trastearlo ;)