Bueno, el que me conozca un poco ya le sonará mi obsesión de hacer programas inútiles, cuyo único atractivo reside en dejar que se ejecute y mirarmlo hasta que te aburras cual idiota. No se porqué, pero es lo que me divierte.
El caso es que ahora estoy intentando (de manera muy cutre) simular una "especie" de hormiguero. Digo especie porque de momento no tiene ninguna lógica ni ningún objetivo. Ahora mismo solo quiero hacer funcionales algunas funciones (valga la redundancia)
Aquí abajo teneis el código de la antz. De momento su comportamiento es completamente aleatorio. Ahora mismo lo primerísimo que quiero resolver es el problema con el terreno deformable. Quiero que las hormigas no puedan atravesar, a no ser que caben el espacio blanco. Además quiero que caminen de una forma creible, ahora mismo cuando llegan a un agujero "caen" cuando se supone que lo que deberían hacer es recorrerlo. He conseguido que más o menos cuando caminan sin un rumbo fijo, salgan de los agujeros de una forma un poco coherente, pero me gusstaría mucho mejorar ese aspecto, si alguien me puede ayudar dándome consejos o documentación sobre como comportarse ante terrenos deformables lestaría eternamente agradecido. Bueno, ahi dejo el código.
Bueno, ya voy por la versión 0.3.1 0.3.2
Ahora mismo tiene errores bastante frustrantes y tan pronto se tira 3 horas funcionando sin problemas como que crashea a los 5 minutos.
De momento no se han repetido dos hormigueros, y estoy probando varias configuraciones de las constantes que producern hormigueros completamente distintos. Aquí os dejo algunas capturas de como son los hormigueros que se producen actualmente
(http://forum.bennugd.org/index.php?action=dlattach;topic=2197.0;attach=1862)
UPDATE 13 Abril 2011
Gracias al código que me ha pasado cierta persona, llamémosle F.Mind, no es demasiado obvio, Mejor Free M. La hormiguita (porque de momento con varias se va todo al traste) ya saca la tierrecita y la va amontonando al lado de su casita, (ita ita ita), y para muestra un botón. A ver si corrijo los fallos que tiene hasta ahora y la subo.
Un saludazo!
(http://forum.bennugd.org/index.php?action=dlattach;topic=2197.0;attach=1871)
Te falta la hormiga. ;D
De momento no merece tal calificación. Dejémoslo en la basurilla que es ahora, pero va avanzando gracias al soporte de este foro. Gracias a todos! (en especial a splinter ;) )
A ver si alguien me ayuda un poco con el tema de los túneles.
Ahora mismo es más o menos aleatorio con ciertos condicionantes. Alguien puede darme algunos consejos para "incitarlas" a hacer los túneles más o menos largos? es que ahora mismo me salenmas bien "cuevas"
Gracias (en especial a fede).
Gracias a todos! XD
Tengo ciertos problemas con como lo tengo planteado.
Ahora mismo las hormigas tienen un 30% de probabilidades de ir a la misma dirección donde se cabó el último agujero y cabar en la misma dirección. El problema es que me salen agujeros muy "verticales", y cuando ya son bastante profundos solo se dedican a ensancharlos.
¿Ideas de como obligar a expandirse en más direcciones? Y que no ensanchen tanto los túneles.
Voy a adjuntar la primera release del proyecto a ver si viendolo todo completo alguien se anima a hecharme una mano.
Ahora si. El anterior prg me daba error en un gráfico llamdo "hormiga". :D
Por cierto, había un juego que se llamaba 'sim ant' de los sim de toda la vida. :D
Por cierto, me he perdido en la conversación. En especial cuando Free me da las gracias. ???
¿As probado a tratar el hormiguero como un ente?
Me parece que tratas a cada hormiga indepedientemente y aleatoriamente.
Un hormiguero no se porta así. Cuando hay que hacer algo se hace, no se hace un trozo.
Deberías enfocar el programa a órdenes del estilo:
Hacer un tunel de tantos.
Hacer una cueva.
Mover terreno.
etc.
Y añadir un componente aleatorio en lo derecho que está el tunel, lo redondo que será la cueva, etc.
Hombre fede, ahora sí que te tenemos que dar las gracias XD, aunque ya solo por comentar te las habías ganado.
El caso es que si trato al hormiguero como un ente me van a salir siempre las mismas... ¿cosas? Aunque es una idea excelente para darle homogeneidad.
Ya he cambiado algunas cosas en el código y ahora funciona mucho mejor. Tal como está implementado no sería muy difícil hacer un especie de "cerebro" que tomase decisiones aleatorias, pero con un objetivo mayor, es decir, en vez de hacer un agujero, hacer un tunel de 10, por ejemplo, y dar órdenes para que luego, las hormigas (eso sí de forma independiente) las fueran ejecutando con cierto componente aleatorio, que sería lo que le daría ese puntillo de rand.
Si, conozco el sim ant, pero su interfaz se me hace un poco engorrosa, aunque tal vez lo vuelva a jugar para "inspirarme"
También hay muchos videos de National Geographics. :D
Lo que te he explicado es lo que más o menos he aprendido de la "2". :D
A simple vista las hormigas tienen un comportamiento caótica, pero si las observamos como un todo son un 'ente' altamente especializado.
¿Que tal hacer un terrario estilo tamagotchi?
Podrías hacer un 'simulador' de juego de un terrario, donde vas observando a las hormigas, les ayudas dádodole de comer, recursos, etc. e interactuas con ellas.
Si te lo curras puedes poner obejtivos para conseguir más recursos, etc.
Por dar ideas, que no quede. :D
si esto, es el ejemplo del path_find que vi ayer, yo no usaria la path_find para hacer los tuneles, yo haria lo siguiente.
- tengo hormiguero.
- tengo hormigas en la superficie.
- establezco la entrada del homiguero (punto de partida) (aca tambien creo una tabla de puntos de entrada)
- uso un randomico de X pixels hacia abajo+laterales del hormiguero/tierra (podemos agregar arriba si ya estamos bajo el hormiguero), a partir del punto de partida, y este seria el destino, hasta aca usaria un algoritmo de rectas.
- hacemos el tunel de a 1 pixel (o a unidad de ancho que representemos es el ancho) segun el punto anterior, ese granito de tierra que sacamos lo tenemos que poner en la superficie, asi que nos movemos hasta la entrada, aca si, usando path_find.
- luego nos movemos hasta donde habiamos dejado el tunel anteriormente y seguimos cavando y moviendo los pedazos de tierra que sacamos a la superficie 1 a 1, hasta llegar al destino calculado.
- una vez llegado al destino, y este punto lo agregaria a una tabla de nodos (a partir de los cuales se van a hacer los nuevos tuneles). Esta tabla puede ser un historico de los ultimos N destinos, asi se evita tener 1000 tuneles sobre el mismo nodo, o no.
- una vez que una hormiga se libera de cavar un tunel, busca en la tabla destinos anteriormente mencionada a partir de que nodo hara su nuevo tunel, y aca usa path_find. la hormiga solo se libera, cuando llego a destino y luego de sacar el grano de tierra a la superficie.
- si un nodo esta siendo usado, ese nodo se bloquea para que otra hormiga no cave en el mismo nodo.
- solo se puede cavar hacia lugares con tierra, no tiene sentido hacer un tunel en el aire.
yo en principio haria eso, luego iria depurando mejor el metodo, pero basicamente podria funcionar asi.
Jolin splinter, debo estar volviendóme mejor programador porque yo había pensado algo así (aunque aún no he conseguido que funcione correctamente).
Básicamente elijo un punto objetivo y un punto de partida, y como tu bien has dicho, calculo la dirección hacia la que cabar con un simple cálculo de rectas. Todo esto lo hace un proceso independiente al que he llamado cerebro. Este proceso pone los objetivos en unas tablas que las hormigas consultan cuando les viene en gana para ver la lista de objetivos y hacerlos.
Vamos, todo lo que has dicho tu, pero peor explicado, pero sin reservarle el tunel a ninguna hormiga en concreto. A ver que consigo sacar.
Puff, esto se me está complicando más de lo que esperaba.
Voy a quedar en ridículo por lo oxidado de mis matemáticas, pero no se como aplicar las ecuaciones de la recta a este problema.
Dados dos puntos debemos calcular cual será el siguiente punto que debemos alcanzar. Esto he pensado que se podría hacer teniendo la pendiente.
pendiente=y2-y1/x2-x1
Pero no se luego como aplicar el resultado.
Una vez que tengo la pendiente, si se supone que avanzo de 4 en 4, ¿que debería hacer? Ir al primer punto y una vez allí multiplicar la pendiente por el valor de avance e ir al punto que resulte?
Que cutre me siento :P
Olvidadlo, creo que ya tengo una forma, aunque no esta resultando todo lo bien que esperaba.
Nada, creo que estoy atascado.
Tengo varios problemas a la hora de implementarlo:
1. Establecer un objetivo para las ormigas. No se si debería ser uno global o uno para cada una, aunque no todas decidirán buscar un objetivo
2. Empezar los túneles. Ahora mismo pongo un límite de túneles, y le doy a cada hormiga un porcentaje de probabilidad de empezar uno.
3. Llegar al objetivo. Puede parecer una chorrada, pero me está costando llegar a los objetivos. Ahora mismo lo que hago es, si la x y la y son menores, avanzar reduciendolas, y cuando uno ya está alineado solo circula en el sentido del otro. Pero llega un punto en el que se atasca, ya que no puede seguir cabando debido a que el último punto al que llega lo considera vacío, y no avanza.
Pero no os debanéis los sesos hoy. Mañana más fresco y mejor haré mejores preguntas después de replantearme todo esto.
Un saludo.
Bueno, ya estoy aquí de nuevo. He intentado hacerlo tal como dijo splinter, ya que como lo estaba haciendo yo había llegado a un punto muerto.
ahora mismo parece que tiene un funcionamiento aceptable, pero no os fieis! Casca muy a menudo y aún no he averiguado porqué.
Si alguien ve porqué, que no dude en decírmelo.
Actualizado el primer post.
Creo que lo siguiente que debería hacer ahora que parece que todo funciona más o menos como debería es añadir algun medio para "sacar" la tierra a la superficie y que se vaya acumulando.
Había pensado en que cuando la hormiga llegase a la superficie crease un proceso que se encargase de "caer un poco" y cuando terminase pegar un par de píxeles en el fondo y en el mapa de durezas.
Aún no se si los túneles que se crean son aceptables o debería trabajarmelo para que no se apelotonaran tantos e implementar la creación de "cuevas"
¡SUGERENCIAS!
yo probe este ultimo codigo que pusiste (el 03) y me hace un tunel en diagonal, siempre para la izquierda... esto es asi?
No splinter, ese código ya está bastante viejuno. Voy a subir el último que he hecho en cuanto le ponga unos últimos ajustes y algunas constantes las ponga como deben estar.
¡Gracias por comentar!
excelente, esperare la proxima version... va quedando bien...
DIoss!! No se me ocurre como hacer para ir sacando los trocitos de tierra.
Subo el código de como lo tengo implementado ahora mismo. Si alguien le quiere hechar un ojo y hacerme alguna sujerencia de como simular tierra que cae o algo asín, le besaré los pies.
http://forum.bennugd.org/index.php?topic=358.0
again :D
Again gracias.
También le daré las gracias a aquel que me facilite un link a la demo (aa que recuerdos de cuando yo tenía 14 años) de divscecene en la que nevaba.
Tus deseos son ordenes.
Free, eres una caja de sorpresas... ;D
Tienes de todo.
De todo no, pero cerca
http://www.youtube.com/watch?v=3MnDUN0eNhw
Jua, jua, jua.
Ya sólo te falta tener los apuntes del asturiano. ;D
Free! Muchas gracias! Karma upp!
Hace tiempo que llevo queriendo preguntarte algo... ¿tu eres gamemaster?
Un saludo.
Hheheheheh, yo soy el hermano bennusero de GameMaster xD
Ja ja ja, genial!
Estoy descifrando el código. Joder! Que pedazo de mierda tan ingenioso! Mira que lo he tenido veces entre mis manos, pero esta es la vez que más majestuoso me parece. Además que está indentado que da gusto.
Otra cosa no, pero desde que empecé a programar a los 12, sin internet y sin nada, me he comido montooones de ejemplos, y sin comentar, por lo que a veces me sorprendo con lo rápido que entiendo lo que hacen algunos códigos.
Lo estoy comentando a mi estilo, es decir, exhaustivamente, tal vez sea negativo para otros programadores el no plantearse ellos mismos lo que hace el código, pero si pensáis que es interesante tenerlo comentado (para que sirva de ejemplo a otros como yo) os lo devuelvo comentado.
MUCHAS GRACIAS!
Por cierto splinter, tengo otra duda sobre el path find (que la postearé en cuanto me contestes en su hilo correspondiente, para tenerlo organizado)
El mapa de búsqueda, debe ser de 8 bits, eso lo tengo claro, pero ¿debe ser blanco y negro obligatoriamente? o puede ser color 0 y cualquier otro color dentro de la paleta de 8 bits?
Muchas gracias de nuevo, dios, que haría sin este foro.
Puedes poner muchos mas colores, incluso para indicar un grado de dificultad para pasar por ellos, asi por ejemplo, podrias tener 10 colores, en los cuales el 0 indica no traspasable, y del 1 al 10 van de menos a mas traspasables, siendo el 10 el mas sencillo, el algoritmo buscara que camino es el mas rapido para llegar del punto A al B sorteando esos colores (el 1 podria ser por ejemplo un rio, el 2 un desierto, el 3 un bosque, etc.. y el 10 una carretera, entonces el algoritmo siempre intentaria ir por la carretera, pero si no le queda otra, buscaria los siguientes caminos para llegar al destino)
Eso supongo que lo dices refiriendote a algún algoritmo que haya implementado yo mismo o de alguna librería externa no?
Porque que yo sepa el algoritmo de path find que trae bennu solo distingue entre traspasable o no traspasable.
De todos modos he ido a consultar la wiki y la página está en blanco. Tal vez me podría animar a escribir algo, pero no tengo suficiente info y no se que tal se me dará la redacción técnica.
path_wall(VALOR)
Esta función, definida en el módulo "mod_path", modifica el valor de "pared" empleado por la función path_find().
Este valor de pared será un número que indica la posición mínima del color dentro de la paleta (perteneciente al
gráfico de 8 bits que representa el camino) a partir del cual un punto del gráfico es intraspasable. Es decir, si por
ejemplo el parámetro vale 5, todos los píxeles del gráfico del camino pintados con los colores que ocupan las
posiciones 0,1,2,3 y 4 de la paleta serán traspasables, y el resto no.
El orden de los colores traspasables influye en la facilidad de "traspase". En el ejemplo anterior, el color 1 es el más
fácil de traspasar porque no ofrece apenas resistencia para los móviles; en cambio, el color 4 será más dificultoso, y en
principio no será la opción escogida para crear un camino, a no ser que no haya otra opción. Es decir, la posición de
los colores en la paleta se interpreta como el "coste" de movimiento de un punto dado, hasta llegar a la posición
marcada por el parámetro, la cual marca la barrera infranqueable. Más concretamente: cada posición en la paleta
requiere el doble de pasos que la anterior, hasta llegar a la posición infranqueable (1ª posición, 1 paso necesario; 2ª
posición, 2 pasos necesarios,etc)
Evidentemente, esta función se ha de invocar siempre antes de path_find(), ya que ésta utiliza el valor previamente
definido por path_wall() para calcular el camino más adecuado. Si no se utiliza esta función, por defecto, el valor de
la "pared" que utilizará path_find() está a 1, lo que significa que sólo los puntos a 0 serán traspasables por el camino
a resolver. Por otro lado, si a la función se le pasara como parámetro un valor menor a 0, éste no será modificado.
Bueno, pongo el código de la penúltima (ya que la última versión está en fase experimental y no me gusta nada) de mi particular hormiguero.
Ahora mismo tiene la configuración más segura, dentro de lo que se considera seguro para un programa que cada dos por tres se pega la hostia, aunque a veces funciona durante horas y horas sin problema. Misterios de la vida. De momento esa configuración segura incluye a una sola hormiga.
A veces las hormigas no les apetece hacer nada, por lo que simplemente se pasearán por el hormiguero, dejadlas vivir su vida y no las agobiéis.
Si quereis más velocidad os recomiendo que aumentéis las probabilidades de que a la hormigua le apetezca cabar, es un porcentaje dentro del código de la ant, algo así como rand(0,100)<10, pues ponéis 20 y listo.
Estooooo. Me da un error en el tratamiento de la variable timer. Lo he tenido que corregir para que compile.
process screen_shot()
private
int tiempo;
begin
tiempo=timer[0];
repeat
if ( timer[0]-tiempo > (minutos_screenshot*60*100) )//cada minuto
tiempo=timer[0];
graph=screen_get(); // grabs the screen and sets it as the program graphic
png_save(0,graph,"hormiguero"+ftime("%d-%m-%Y_%H%M%S",time() )+".png"); // saves the graphic as png
say("Tomando screenshot el: "+ftime("%d-%m-%Y_%H:%M:%S",time() ) );
map_unload(0,graph); //frees the graphic
else
frame;
end
until( key(_esc));
end
La hormiga no debería de cavar tan 'recto'. Si ves cualquier documental donde se han sacado moldes de hormiguero son un autentico churro.
(http://2.bp.blogspot.com/_zjEni4WS4HU/ScnrTPre6kI/AAAAAAAABkA/Gm0ggMMu8KU/s400/molde_natural_hormiguero_%5B1%5D.jpg)
Por lo demás te está quedando chulo. A ver cuando metes más hormigas, con diferentes tipos. ;D