Bien, cuando mi juego esté más avanzado, quiero tener un sistema de repeticiones de las mejores jugadas.
Por ejemplo, la partida termina, y muestra algunas repeticiones.
Había pensado en algo así como tener constantemente guardados los últimos 10 segundos de juego, por ejemplo, y si se detecta algun suceso que sea "memorable", esos 10 segundos se guarden en un archivo de video, y que el juego siga adelante.
Piensan que seria la manera correcta? Se apoyarían de algun otro lenguaje o algo asi?
Comparte tus ideas =O
a todo esto y si viene al caso, ¿como puedo sacar un video del juego que estoy jugando??
y para responderte, se podria sacar unos snapshot cada x tiempo del juego que se vaya guardando en el mismo sitio para no ocupar una memoria inmensa
Sería un método, pero imagino que iría muy mal de rendimiento.
Lo mejor quizás sería ir guardando las cosas que van pasando (el usuario dispara, ...) y luego reejecutarlas, pero la verdad es que tendrás que darle más de una vuelta al tema.
La pregunta es interesante y compleja. Por un lado, podrías hacer lo de los snapshots, pero ocuparía demasiado y sería muy lento. Otra forma es que se pudiera capturar el buffer de pantalla antes de dibujarlo y mandarlo a un fichero, de esta forma se podrían generar videos AVI sin compresión, y al acabar el juego, usar el módulo de VLC para hacer la conversión (no sé si se le puede mandar la imágen directamente a VLC para que se lo añada al video).
En ambos casos el rendimiento es muy malo.
Las opciónes más viables son:
1: Guardar los datos más relevantes (posición, fichero, gráfico...) de todos los elementos que se muevan, a cada frame, en un fichero, y luego los reproduzcas. Siempre serán menos datos que todos los pixels de pantalla.
2: Ir almacenando a cada frame los botones que están pulsados y los que no, y enviárselos al protagonista a la hora de reproducir. Esto no funciona si algún elemento del escenario tiene algún RAND en su comportamiento, por lo que habría que optar por la alternativa anterior.
la getscreen devuelve la ultima pantalla dibujada, o sea, que no hace procesamiento extra de ningun tipo, ahora si, el almacenarlo en un fichero si consumira.
Vaya. Todas las opciones parecen viables, aunque muy engorrosas.
No conozco bien el funcionamiento de getscreen, intentaré experimentar un poco con ello.
Mi juego al parecer no consumirá muchos recursos, asi que quizás podría permitirme hacer algo así. Habría que probar.
si pensas salvar a disco cada pantalla, vas a depender de la velocidad del dispositivo, silo vas a hacer en caanoo/wiz, te veo mal... quizas la mejor opcion es salvar un par de frames por segundo y a memoria, consumira memoria dependiendo de la cantidad de frames por segundo que quieras almacenar, la cantidad de segundos y obviamente la resolucion, pero sera mucho mas rapido.
Quote from: Drumpi on June 12, 2011, 12:32:06 AM
1: Guardar los datos más relevantes (posición, fichero, gráfico...) de todos los elementos que se muevan, a cada frame, en un fichero, y luego los reproduzcas. Siempre serán menos datos que todos los pixels de pantalla.
Yo creo q esto es lo mas viable ... guardar las características de los procesos los últimos 5 segundos ... aunq habrá que hacerlo con los procesos mas representativos y no todos ... pero la cosa es probar a ver que sale xD
Va a hacer falta una Estructura/Tabla monumental para hacerlo me temo xDD
Quote from: KeoH on June 13, 2011, 02:01:18 AM
Quote from: Drumpi on June 12, 2011, 12:32:06 AM
1: Guardar los datos más relevantes (posición, fichero, gráfico...) de todos los elementos que se muevan, a cada frame, en un fichero, y luego los reproduzcas. Siempre serán menos datos que todos los pixels de pantalla.
Yo creo q esto es lo mas viable ... guardar las características de los procesos los últimos 5 segundos ... aunq habrá que hacerlo con los procesos mas representativos y no todos ... pero la cosa es probar a ver que sale xD
Va a hacer falta una Estructura/Tabla monumental para hacerlo me temo xDD
si, es lo mejor, pero hay que guardar muchos datos, yo diria de todos los procesos, incluso si usas scroll, posicion del mismo, etc.
Quote from: SplinterGU on June 12, 2011, 11:30:05 PM
si pensas salvar a disco cada pantalla, vas a depender de la velocidad del dispositivo, silo vas a hacer en caanoo/wiz, te veo mal... quizas la mejor opcion es salvar un par de frames por segundo y a memoria, consumira memoria dependiendo de la cantidad de frames por segundo que quieras almacenar, la cantidad de segundos y obviamente la resolucion, pero sera mucho mas rapido.
Igual eso me convence más, aunque justamente no se puede tomar ese camino para maquinas con consumo limitado de memoria...
Lo de guardar las imágenes en disco, como digo es costoso, ya que como apunta Splinter, guardar en disco es tremendamente lento. Aun en una SD, que es lo más rápido que hay, puede no soportar ese volumen de datos a esa velocidad (sea la que sea), y acortaría su vida notablemente.
Sería más sensato tener las imágenes en memoria y esperar a terminar la partida antes de salvarlo todo tranquilamente en el disco, lo cual requiere una RAM muy generosa, a menos que puedas almacenarlas en memoria pero comprimidas, o bien tener un hilo de ejecución aparte encargada de ir guardando los datos según se pueda.
La solución de guardar los datos relevantes es, en mi opinión, la mejor. Quizás tengas que trabajar con una lista enlazada si no quieres estar escribiendo en un fichero durante la "grabación". En este segundo caso, no necesitas estructuras ni nada: usas GET_ID para crear una lista de los diversos procesos, y luego vas accediendo a sus datos.
El scroll no hace falta: si se mueve de forma manual es que va siempre a una velocidad constante, y si es de forma automática es que sigue a un proceso, y teniendo su X e Y ya se sabe su posición.
Pero bueno, es cuestión de pensar, porque hay muchas formas posibles de hacerlo (incluso teniendo acceso a los dirty_rects se podría encontrar un método).
Huh, hay varias ideas buenas, aunque lamentablemente como no llevo ni una semana en Bennu, hay ciertas cosas que no sé bien cómo implementar. Con el tiempo lo haré, por suerte aprendo rápido, jeje.
Quote from: Drumpi on June 13, 2011, 08:14:36 PM
Sería más sensato tener las imágenes en memoria y esperar a terminar la partida antes de salvarlo todo tranquilamente en el disco, lo cual requiere una RAM muy generosa, a menos que puedas almacenarlas en memoria pero comprimidas, o bien tener un hilo de ejecución aparte encargada de ir guardando los datos según se pueda.
Si uno guarda las imágenes pero cada 2 frames, por ejemplo, quizás se pueda obtener una animación de menor calidad pero que sirva para su cometido... Como ya dijeron antes.
No sé, a mis ojos de novato esta forma me parece más simple xD
Aunque ya que he tenido experiencias anteriores con listas enlazadas, seguro será una buena idea comenzar a indagar respecto a su uso en Bennu. Voy a tomar nota de lo que dices ;D
En todo caso, yo estoy pensando meramente en un replay de un juego 2D. No tengo mucha idea de cómo funciona el mundo de los juegos 3D (algo he leído... además de todo lo que he jugado claro xD) pero no sé por qué tengo la idea de que es más fácil hacer esto en ese tipo de juegos. Basta con recordar cuando jugaba FIFA '98 y había replays de diversos ángulos... Estoy equivocado respecto a esto?
Saludos!
Lo que hacen esos juegos es grabar los comportamientos, posiciones, y acciones de los personajes, y despues el mismo motor del juego las reproduce... con la opcion de cambiar camaras, angulos, velocidad de reproduccion, etc...
Creo que seria la mejor forma de hacerlo, pero no es algo facil :P
se me ocurre que podrias tener un proceso generico para reproducir repeticiones, algo asi como:
proccess repeticion()
begin
loop
frame;
end
end
sin nada dentro, para que vos lo controles desde afuera.
luego, te engargas de guardar frame por frame el valor de todas las variables locales predefinidas de cada proceso que quieres repetir despues (x,y,graph,file,region, etc), al fin de cuentas, esas variables son las unicas importantes porque definen como se van a ver los procesos luego.
Para evitar guardar muchos datos, podrias guardar en cada frame solo aquellas variables que cambiaron con respecto al frame anterior.
luego, por cada proceso que grabaste, creas un proceso repeticion, y en cada frame le asignas las variables locales que guardaste.
y listo!
si, la mejor forma es recorrer todos los procesos, guardar sus coordenadas, graficos, angulo, flags, size, size_x, size_y, paleta del grafico si esta cambiada, guardar toda variable importante como ser contadores de tiempo, puntaje, timers, guardar scroll si tienes, guardar valores de tablas blend si usas, guardar posicion de los fade (esta es dificil) y alguna otra cosa que se guro se me escapa.
la verdad que si bien (quizas) ocupara menos memoria, es muy engorroso tener todos los datos.
Suena funcional aunque muy engorroso como dicen.
Gracias JaViS por tu respuesta.
Pero me surge una duda. Qué pasa con los procesos que mueren en algun momento? Cómo lo haría para, en la repetición, "revivir" esos procesos?
no vas a usar los mismos procesos, vas a usar 'copias' del tipo 'repeticion' como te puse en el ejemplo mas arriba. son copias sin logica, solamente reproducen el resultado de guardar las variables locales de los procesos originales.
Aaaah toda la razón =O... no comprendí mucho al principio, pero justamente como explicas, las variables locales son las que determinan todo lo que se va viendo por pantalla... Así que si, una vez terminada la partida, le pasas todas sus variables locales predefinidas (guardadas previamente) a este nuevo proceso en cada frame, sería capaz de animarse tal cual lo hace el proceso original...
aha!
Ya lo he pillado xD disculpad lo lento pero es que me ha quebrao un poquito la cabeza. Sí, creo que usare listas enlazadas.
La idea de JaViS es genial! Karma++;!
Gracias a todos por sus respuestas, es bueno que la comunidad sea tan ingeniosa, y tan cooperativa. Trataré de ayudar en lo que pueda también.
Saludos!
vas a tener que agregar una variable tipo a los procesos y setear en cada una el tipo de proceso, o hacer whiles get_id por tipo... e ir guardando listas separadas.
bastante engorroso.
EDIT: realmente no importa el tipo, con su grafico y las coordenadas y luego ir metiendo procesos dummy de los mismos ya esta.
Quote from: HenBanKeN on June 15, 2011, 01:26:28 AM
La idea de JaViS es genial! Karma++;!
mi primer karma :')
Bien merecido lo tienes ;D !
te doy otro!
(http://3.bp.blogspot.com/-XhZ2kzyulPA/TeqkF6xFBEI/AAAAAAAAAGw/dPr1KDIYjSU/s1600/meme_me_gusta.jpg)
jaja, la verdad es que es un lindo problemita. La parte de los procesos ya esta mas o menos resuelta con eso, ahora tenes que ver como y que vas a guardar del resto de la info, como dice Splinter, posiciones de Scroll, paletas, tablas de blend, lo que estes usando.
Tambien estoy pensando en que quizas necesites guardar en que momento de tu grabacion nace un nuevo proceso (como por ejemplo, una explosion)
cuando muere es facil, es cuando no tenes mas nada para reproducir XD
suerte con eso! :D
Quote from: JaViS on June 15, 2011, 12:09:25 PM
Tambien estoy pensando en que quizas necesites guardar en que momento de tu grabacion nace un nuevo proceso (como por ejemplo, una explosion)
También pensaba en eso, ya que en mi juego hay unos dos procesos que siempre están apareciendo y desapareciendo... jum jum... habrá que meter las manos en la masa, y en el camino ir viendo qué cosillas pasan.
Eso es fácil de hacer: antes de escribir las estructuras de ese frame, indica con una variable cuantas de estas van a existir. Después lees tantas como indiquen y asignas los valores a los procesos. El orden te va a dar igual, y al proceso que se lo asignes, pues vas a cambiar la posición, gráfico y todos los estados de todos los procesos.
Si usas listas enlazadas sólo te tendrás que preocupar de añadir unos pocos procesos nuevos, o eliminar algunos que no se usen. Al fin y al cabo, todos los procesos de la repetición tendrán un código tal que así:
process obj_repeticion ()
begin
signal(id,s_freeze);
frame;
end
Y sus variables se escriben desde fuera, y te sirven para el prota, para los disparos, para el decorado o incluso para los datos en pantalla como la energía y todo eso.
A ver, no sé si entendí.
Lo que entendí, es que en cada frame, debería comprobar cuántos procesos existen, y guardar ese valor en una variable. Después, leo tantas variables locales de procesos, como esa variable me diga, para ese frame. Y más adelante, por cada frame, vuelco todas las variables locales sobre una cantidad de procesos obj_repeticion dada por la cantidad de procesos existentes en ese frame. ¿algo así? xD
Nuevamente, siento un poco preguntar tanto, pero teniendo aproximadamente una semana de experiencia en Bennu, me cuesta seguir un poco el ritmo de la conversación xD jeje.
saludos!
Más o menos.
Supon que tenemos un tipo de datos propio (o una estructura) donde se almacena la info importante de cada proceso (X,Y,FILE,GRAPH...). Llamémosle estructura PERSO.
Luego tenemos un fichero donde hemos guardado cientos de estructuras de este tipo.
Empezamos a leer el fichero. El primer dato que leemos es un entero con valor 3, eso significa que a continuación leeremos tres PERSO y le asignaremos sus valores a tres procesos como el que te puse en mi último mensaje del hilo (obj_repeticion). Hacemos FRAME.
Leemos otro entero del fichero, por ejemplo 5, por lo que leeremos cinco estructuras PERSO. Aquí podemos hacer dos cosas:
-Eliminar todos los procesos obj_repeticion, crear cinco nuevos y asignarle los valores.
-Asignar valores a los tres procesos existentes y crear dos nuevos.
Lo suyo es hacer lo segundo, pero entonces debes controlar cuándo crear nuevos procesos obj_repeticion y cuando eliminar los restantes (aquí vendría bien tener una lista enlazada de procesos).
Y haces FRAME.
Y repites mientras haya datos en el fichero.
Puedes añadir más cosas, por ejemplo, estructuras sobre paletas, inicio de scrolls, o cosas así, y tener un entero que te diga cuantas estructuras de esas hay en cada frame. Por ejemplo, en lugar de leer un entero a cada frame, puedes leer tres que te digan el número de estructuras PERSO, el número de estructuras MIS_PALETAS y el numero de estructuras MI_SCROLL respectivamente (y si no se usa en ese frame, pues se pone 0 y no se lee nada).
Suena más complicado de lo que realmente es. Yo hago algo parecido en mi motor de tiles (en el proceso control). Pero vamos, empieza por algo sencillo y lo vas mejorando con el paso del tiempo.
Lo he pillao =) muchas gracias por tu respuesta!