Comunidad Game Maker

Mi problema es el siguiente. Tengo un archivo ini que guardo en la carpeta included files. Cuando lo modifico desde el juego la primera vez, pasa de estar en el file bundle a la save area (o local storage). Todas las operaciones sobre el archivo ini, tanto lectura como escritura, desde ese momento se realizan sobre la versión guardada en la save area. El problema es que si saco una versión nueva del juego con el ini modificado en included files, el juego seguirá ocupando la versión de la save area en vez de actualizarla. En otras palabras, GMS no hace una instalación "fresca" de la actualización de un juego ya que usa la misma carpeta save area que ya existía, sin borrar su contenido. Por una parte eso es conveniente para poder, por ejemplo, guardar el progreso del jugador y que no se pierda al actualizar el juego, pero por otra no me permite hacer modificaciones de esos archivos ini que tengo modificados en la carpeta included files. Tengo entendido que para Android se puede activar la opción Always do full install of APK en las preferencias, que borra todo registro del juego previo antes de instalar una actualización pero en Windows parece que no existe esa opción. Lo único que se me ocurre por ahora es agregar otro archivo ini que guarde una variable que indique si es la primera vez que se corre el juego; si es así, desde el juego borrar los archivos en la save area para obligar a leerlos desde el file bundle ¿Habrá otra manera mejor?

Estoy tratando de implementar una variable que tome los valores discretos 1, 0, -1, 0 en ese orden, cambiando a un nuevo valor en cada step. Es decir, para los primeros steps de juego la variable valdría lo siguiente:

Step   Variable
1        1
2        0
3        -1
4        0
5        1
6        0
7        -1
8        0
9        1
10        0
etcétera

Mi pregunta es cuál será la forma más eficiente de hacer esto, dado que en el peor de los casos habrá 154 instancias ejecutando el código para darle el valor a la variable. Pensé en 3 formas (tomando como v la variable y n una variable auxiliar que parte en 0 y se incrementa en 1 en cada step):

1. Una función definida como:

v=-n+1    para n=0,1,2
v=0           para n=3

Además el código tendrá que hacer n=0 cuando n>3

2. usando trigonometría:

v=cos(n*pi()/2)
para n=0,1,2,3,4,etc.

Esta forma tiene la ventaja de que no requiere resetear a cero la variable n

3. Definiendo una función para cada valor de n (se parece a la solución Nº1 pero no requiere descomponer la función en 2 partes):

f[0]=1;
f[1]=0;
f[2]=-1;
f[3]=0;
v=f[n];
para n=0,1,2,3

Esta forma también requiere hacer n=0 cuando n>3

Voy a ser más concreto. Todo esto es para poder desplazar un sprite horizontalmente 1 pixel para dar la impresión de que está vibrando. Mi idea es que en el evento draw el código tome la forma:

draw_sprite_ext(sprite_index,-1,x+v,y,image_xscale,image_yscale,image_angle,image_blend,image_alpha);

Pensé en hacer que el sprite (que es de 32x32) tenga 4 subimágenes en vez de una, con cada subimagen desplazada 1 pixel horizontalmente respecto a la anterior de acuerdo a la secuencia que indiqué y así me evito todo el problema del cálculo de v en el evento step. Pero como voy a tener 4 objetos que tienen que hacer esto, cada uno con su sprite, paso de tener 4 imágenes de 32x32 a 16 imágenes de 32x32. Tal vez esta forma no sea tan descabellada considerando los tamaños de los sprites.

¿Qué será más eficiente de hacer para lograr lo que quiero?   :-\

¡Demuestra tu astucia resolviendo singulares puzzles de imágenes eróticas!
¡Comprueba que tienes el cacumen que se requiere para ensamblar las piezas!
Cacumen es un juego de piezas deslizantes donde debes armar una imagen cuyas partes han sido desordenadas. ¡Termina de armar una imagen y acepta el siguiente desafío!

-¡Escoge una imagen desbloqueada que hayas completado o intenta desbloquear una nueva jugando al modo Aventura!
-Selecciona el número de piezas de la imagen entre 3x3 y 4x4. ¿Que 4x4 es muy difícil? Bueno, ¡como recompensa desbloquearás 2 imágenes simultáneamente en vez de una!
-¡Elabora una estrategia para mover una pieza al punto que deseas sin deshacer el trabajo ya hecho!

Versión Windows imágenes femeninas: https://drive.google.com/open?id=0B7kwdvQ3WxTncGh4MDlicnhFZTg Versión Windows imágenes masculinas: https://drive.google.com/open?id=0B7kwdvQ3WxTnVGJWanUtSWRIcGc Versión Android imágenes femeninas: https://drive.google.com/open?id=0B7kwdvQ3WxTnZ2ZKQkVTSVEyNHM Versión Android imágenes masculinas: https://drive.google.com/open?id=0B7kwdvQ3WxTnWDl5aWVheUVVME0 Cacumen está disponible para Windows y Android. Para cada plataforma existe además una versión con desnudos de mujeres y otra con desnudos de hombres. ¡No hay excusa para no probarlo, seas hombre o mujer! Agradecimientos a penumbra por sus sugerencias (no es necesario volver al menú de inicio para jugar una imagen recién desbloqueada; añadido un tema adicional al repertorio de música de fondo).

Tengo una duda con las capacidades de networking de GMS. Haciendo pruebas logro conectar un servidor con un cliente en una red local, pero no lo consigo a través de internet. Para este último caso la IP del servidor que uso es la pública. ¿Habrá que tomar alguna precaución especial distinta a la hora de crear una conexión por internet? ¿Alguien conoce algún ejemplo de engine con networking que funcione a través de internet?

Tengo un problema con el siguiente código que puse en el evento destroy de un objeto:

if instance_exists(o_selector)
    o_selector.x=0;

Me arroja el siguiente error:


___________________________________________
############################################################################################
FATAL ERROR in
action number 1
of Destroy Event
for object o_menu_red:

Unable to find any instance for object index '4'
at gml_Object_o_menu_red_DestroyEvent_1 (line 10) -     o_selector.x=0;
############################################################################################

El objeto o_selector lo desactivé anteriormente y luego lo reactivé desde otra instancia antes de ejecutar el código que indiqué, pero GMS parece no reconocer su existencia. Si no reconoce que existe, ¿cómo es posible que el código se haya ejecutado siquiera dada la condición if que está antes? Sospecho que algo tiene que ver el hecho de que fue recién reactivada pero no entiendo por qué.

Hola, resulta que estoy estudiando las funciones de GMS para crear conexiones cliente/servidor y hasta ahora pensé que lo había logrado: consigo crear un servidor y un cliente y comunicarlos. Cuando reinicio el juego destruyo el servidor con network_destroy antes de volver a crear otro. Sin embargo, cuando trato de crearlo por segunda vez usando el mismo puerto, la función network_create_server falla. Y esto pasa solamente cuando tenía previamente un cliente conectado, es decir, si creo un servidor y lo destruyo antes de que un cliente se conecte, no tengo problemas en crear el servidor otra vez, pero si tenía un cliente conectado (incluso si ese cliente luego desaparece) entonces no puedo crear otra vez el servidor. Logré descubrir que si en el segundo intento de crear el servidor cambio a otro puerto entonces funciona, es decir, pareciera que el puerto que usé con el primer servidor cuando lo creé quedó "tomado"y no fue liberado con network_destroy. ¿Será que hay que hacer algo además de usar network_destroy para liberar el puerto, o será otro el problema?

Coincidiendo con el aniversario de la publicación de Reblock para Windows (http://www.comunidadgm.org/juegos-completos/reblock-(win)/msg100916/#msg100916), ahora que mis medios lo permiten y luego de un intenso trabajo, traigo esta versión portada y adaptada para sistemas Android de mi juego de puzzle tipo 3-en-línea. El juego consiste en deslizar bloques de colores horizontalmente para formar alineaciones de 3 o más del mismo color, generando combos y cadenas para atacar al adversario. Por las limitaciones de tamaño de pantalla disminuí ligeramente el tamaño del tablero y ahora (obviamente) no hay disponible un modo 2 player como la versión de Windows (aunque sigue existiendo la CPU como adversario), y esta versión está mejorada con 2 nuevos modos: Tiempo (hacer más puntaje que el oponente en un tiempo determinado) y Puzzle (despejar el tablero con un número limitado de movimientos). Si tu pantalla es lo suficientemente grande o tus dedos finos, puedes jugar con ella en posición panorámica para ver el juego de la CPU y el tuyo en paralelo.

Actualización: para facilitar la prueba del juego agregué una versión para Windows. Esta versión tiene como extra un modo para 2 jugadores simultáneos y es compatible con joystick.

Video de la versión Windows (referencial): Versión Android: https://drive.google.com/open?id=0B7kwdvQ3WxTnZ3QySjlhdUlPSm8 Versión Windows: https://drive.google.com/file/d/0B7kwdvQ3WxTnSllaSmQtSzdQcEE/view?usp=sharing

Cacumen es una variante del Juego del 15 (o Taken) en que las piezas numéricas son reemplazadas por fragmentos de una imagen. Por lo tanto, el juego consiste en armar un rompecabezas de una imagen compuesta de piezas rectangulares donde falta una pieza. Las piezas se pueden deslizar una a la vez gracias al hueco que deja la pieza faltante. Existen 2 versiones de Cacumen, una con imágenes eróticas de mujeres y otra con imágenes eróticas de hombres (algunas con desnudos totales). Aunque el juego está acabado, quisiera saber si hay algún comentario antes de pasarlo a la sección de juegos completos.

Al comienzo sólo hay disponible una imagen y a medida que se resuelven se van desbloqueando otras nuevas. Mientras que el tablero principal es de 4x4, hay un modo \"fácil\" que lo simplifica a uno de 3x3 (ed decir 8 piezas en vez de 15). En el modo \"fácil\" terminar un puzzle desbloquea 1 imagen nueva mientras que el modo normal de 4x4 permite desbloquear 2.

https://drive.google.com/open?id=0B7kwdvQ3WxTndWFyNHFwZ0tHMzQ La versión con imágenes masculinas es la siguiente: https://drive.google.com/file/d/0B7kwdvQ3WxTncy1OaHdzWHpySFk/view?usp=sharing Versión Windows (imágenes femeninas): https://drive.google.com/open?id=0B7kwdvQ3WxTnN29vMVA2WG5NSW8

Hola, me hice con el módulo para exportar a Android y me funciona a la perfección, pero estoy teniendo problemas a la hora de crear una red entre un teléfono con Android y un PC con Windows 7. Leyendo el manual de GMS y un tutorial, logré crear un código que me permite establecer una conexión dentro del mismo PC corriendo 2 instancias del programa en paralelo: creo un servidor en una instancia y en la otra el cliente y ambos se conectan sin problemas. Pero cuando trato de replicar el experimento entre el PC y un dispositivo Android, no me funciona. Simplemente el cliente no reconoce al servidor. Probé usando como IP del servidor "127.0.0.1" y luego con la IP real del equipo, tanto creando el servidor en el PC como en el celular. Tal vez sea un problema con el puerto que uso (64198). ¿Tiene alguien alguna idea de lo que pueda estar pasando? Adjunto el editable del programa que usé para las pruebas, que consiste en un botón para crear un servidor y otro para crear el cliente, más unos botones para escribir la IP (necesarios en la versión de celular ya que no hay teclado).

Videojuego de lógica donde el jugador intercambia horizontalmente pares de piezas de colores ubicadas en un tablero para generar líneas horizontales o verticales de 3 o más bloques de un mismo color (al estilo de juegos de 3 en línea).

★6 modos diferentes
★4 niveles de dificultad
★Menú de ayuda explica los detalles del juego
★Uso de teclado, mouse o joystick (PC), o táctil (Android)
★Editor de puzzles con variadas opciones
★Posibilidad de jugar modos Arcade o Tiempo en red contra otra persona
★Replay del último juego completo
★Leaderboard online

Android: https://play.google.com/store/apps/details?id=com.Neomentor.Reblock Windows: http://gamejolt.com/games/reblock/96067 La versión actual (2.0.1) tiene un montón de mejoras y cambios respecto a la original, destacando el rediseño completo de su aspecto gráfico (con ayuda de eams) y la incorporación de un leaderboard para registrar puntajes y tiempos record. Video del juego

10/07/14: Actualización del juego con nueva beta 2.0, nuevo enlace a un video y nuevas imágenes.
Esta versión permite 2 jugadores, P1 vs CPU y CPU vs CPU, soporte para joystick y posee 3 niveles de dificultad. Se incorporó menú de presentación y ayuda.

Videojuego de puzzle del tipo 3-in-a-row inspirado en Tetris Attack y Puzzle Fighter, donde el jugador debe alinear 3 o más bloques para formar líneas horizontales o verticales, realizando combos y cadenas. Solicito por favor su cooperación para el testeo de bugs y el envío de sugerencias antes de trasladarlo a juegos completos.

Video: https://www.youtube.com/watch?v=0qKVPIlfDIY

Se adjunta el archivo

Tengo la versión 1.1.917 de GM:S y al agregar un sonido en formato mp3 el previsualizador que viene incorporado en las propiedades del sonido lo reproduce perfectamente. Sin embargo, durante el juego el sonido se reproduce con una calidad espantosamente mala. ¿A qué puede deberse esto? ¿Le pasa lo mismo a alguien más?

Adjunto el proyecto para importarlo en formato .gmz

Nombre del creador: Guacusio

Versión GM utilizada:  :GMS: (compatible con  :GM6:  :GM7:  :GM8:)

Descripción: Cambia en forma continua y automática el valor de una variable dada en una instancia dada entre dos valores dados a una velocidad dada

Este script surge de la necesidad de cambiar variables en forma continua sin necesidad de crear código especial para cada una en los objetos que las contienen. Ejemplos del uso de este script son mover una instancia de un punto a otro, rotarla, cambiar su escala, velocidad, etc. cambiando la variable correspondiente en forma continua en vez de discreta. Pueden cambiarse variables de 0, 1 o 2 dimensiones.

El formato de llamada del script es el siguiente:

argument0=nombre de la variable a cambiar(string)
argument1=valor inicial con que partirá la variable
argument2=valor final deseado de la variable
argument3=número de steps deseados para el cambio
argument4=id de la instancia que contiene a la variable

Ejemplos (asumiendo que el script se llama scr_cv):

Mueve la instancia actual 100 pixeles a la derecha y 80 pixeles hacia arriba en 35 steps:
scr_cv("x",x,x+100,35,id);
scr_cv("y",y,y-80,35,id);

Rotar 90º la instancia j en 40 steps:
scr_cv("image_amgle",j.image_angle,j.image_angle+90,40,j);

Mover el view[0] hasta las coordenadas (100,100) en 60 steps:
scr_cv("view_xview[0]",view_xview[0],100,60,id);
scr_cv("view_yview[0]",view_yview[0],100,60,id);

Este script requiere un objeto auxiliar que manipule las variables, llamado o_cv. Se requiere agregar este objeto con los siguientes eventos:

Create:
[gml]nvar=0;[/gml]

End step:
[gml]//proceso principal de cambio de variables
//array v[i,j] guarda los datos necesarios para cambiar la variable i-ésima
//v[i,0]=id de la instancia que contiene a la variable
//v[i,1]=nombre de la variable a cambiar (string)
//v[i,2]=valor inicial de la variable
//v[i,3]=valor final de la variable
//v[i,4]=valor actual de la variable
//v[i,5]=incremento aplicado a la variable en cada step

var i,j,a1,a2,n,n1,n2,c,fin,aux;
i=0;
while i<nvar//recorre el array con variables
    {
    fin=false;//indica si la variable ya llegó a su valor final
    if instance_exists(v[i,0])//sólo cambia variables de instancias existentes
        {
        if sign(v[i,3]-(v[i,4]+v[i,5]))!=sign(v[i,5])//detecta si la variable alcanza su valor final ahora
            {
            fin=true;
            v[i,4]=v[i,3];
            }
        else
            v[i,4]+=v[i,5];
        aux=v[i,4];//valor actualizado de la variable
        n=v[i,1];//nombre de la variable
        a1=string_pos("[",v[i,1]);//revisa si es array
        if a1>0
            {
            a2=string_pos("]",v[i,1]);
            n=string_copy(v[i,1],1,a1-1);
            c=string_pos(",",v[i,1]);//revisa si es de 2 dimensiones
            if c>0
                {//variable de 2 dimensiones
                n1=real(string_copy(v[i,1],a1+1,c-a2+1));//subíndice 1 de la variable
                n2=real(string_copy(v[i,1],c+1,a2-c+1));//subíndice 2 de la variable
                }
            else//variable de 1 dimensión
                n1=real(string_copy(v[i,1],a1+1,a2-a1+1));//subíndice de la variable
            }
        with v[i,0]
            {
            switch n//actualiza el valor de la variable
                {//NOTA: modificar según las variables esperadas que se cambiarán
                case "image_angle":
                    image_angle=aux;
                    break;
                case "x":
                    x=aux;
                    break;
                case "y":
                    y=aux;
                    break;
                case "a0":
                    a0=aux;
                    break;
                case "image_xscale":
                    image_xscale=aux;
                    break;
                case "image_yscale":
                    image_yscale=aux;
                    break;
                case "vspeed":
                    vspeed=aux;
                    break;
                case "hspeed":
                    hspeed=aux;
                    break;
                case "view_xview":
                    view_xview[n1]=aux;
                    break;
                case "view_yview":
                    view_yview[n1]=aux;
                    break;
                case "view_angle":
                    view_angle[n1]=aux;
                    break;
                }
            }
        }
    if fin or !instance_exists(v[i,0])
        {//elimina del array de variables las variables que ya no necesitan cambiarse
        for(j=0;j<6;j+=1)
            v[i,j]=v[nvar-1,j];
        nvar-=1;
        i-=1;
        }
    i+=1;
    }[/gml]

El código del evento end step anterior debe ser editado dentro de la sentencia switch para agregar o quitar las variables que reconoce el script; esto es así porque en GM Studio no existe la antigua función variable_local_set que habría facilitado enormemente la programación permitiendo el reconocimiento de cualquier variable. Por el mismo motivo, no es posible crear dentro del script el objeto o_cv usando object_add, ya que esta función también quedó obsoleta.

Script de llamada a la función:
[gml]// cambia el valor de la variable numérica argument0
// desde el valor argument1 hasta el valor argument 2
// en argument3 pasos
// en la instancia argument4

var aux,i,inc;
if !instance_exists(o_cv)
    instance_create(0,0,o_cv);//crea una instancia de o_cv si no existe
with o_cv
    {
    aux=nvar;
    for(i=0;i<nvar;i+=1)
        {
        if v[i,0]=argument4 and v[i,1]=argument0
            aux=i;//esta variable ya estaba cambiando
        }
    v[aux,0]=argument4;
    v[aux,1]=argument0;
    v[aux,2]=argument1;
    v[aux,3]=argument2;
    v[aux,4]=argument1;
    inc=(argument2-argument1)/argument3;//incremento por paso
    if inc<0
        v[aux,5]=min(-0.0001,inc);
    else
        v[aux,5]=max(0.0001,inc);
    if aux=nvar
        nvar+=1;//esta variable es nueva
    }[/gml]

Bueno, resulta que dentro del programa que estoy preparando necesito girar un sprite mediante la manipulaci?n de la variable image_angle. Este sprite tiene su origen fuera de s? mismo, m?s abajo, y necesito rotarlo en incrementos muy peque?os, del orden de 0.2 grados por step. El problema es que cuando me acerco al valor cero, el giro se detiene moment?neamente y luego da un salto hasta el nuevo ?ngulo (todo esto ocurre gr?ficamente, porque el valor de image_angle s? cambia suavemente). Me parece que es porque el GM aproxima los ?ngulos con valor absoluto menores a 0.5 a 0, produci?ndose este desagradable efecto. Dejo un editable hecho en  :GM6: donde se aprecia el problema.

?Alguien tiene una idea de c?mo corregir este efecto visual?