Comunidad Game Maker

Las funciones son display_set_size y display_set_all, pero sólo funcionan en :GM8: (y versiones anteriores), en :GMS: se consideran obsoletas, por lo que debes usar diferentes métodos para ajustar el juego a la pantalla.

Así es, el efecto zoom se puede lograr fácilmente cambiando el "field of view", sin embargo hay que evitar sobrepasar un ángulo de 45 grados para no deformar la escena, lo mejor es usar un ángulo cercano a 40 grados.

En tu ejemplo no se aprecia el zoom porque el cambio de tamaño no afecta los ángulos, si se escala un figura geométrica conserva todas las medidas y propiedades de sus ángulos, por lo tanto el campo de visión sigue abarcando el mismo porcentaje de área en el cubo.

Lo que se debe hacer es cambiar el ángulo de visión y dejar el cubo con el mismo tamaño. El campo de visión se puede relacionar con la variable zoom de esta forma:
[gml]fov = 40/zoom;[/gml]
a mayor zoom, menor field of view.

No tiene sentido saber el id de una instancia que no ha sido creada, no puede usarse para nada.
En el caso de la serpiente cada segmento podría crear otro segmento con éste código:
[gml]
with instance_create( x,y, obSegmento )
ancestro = other.id;
[/gml]
en la nueva instancia creada se define la variable ancestro con el id de la instancia que la creó.
Si un objeto controlador es el que crea las instancias entonces se puede hacer algo como ésto:
[gml]
//segmento 1
instancia = instance_create( x,y, obSegmento );
with( instancia ) ancestro = noone;

//segmento 2
with instance_create( x,y, obSegmento )
{
    ancestro = other.instancia;
    other.instancia = id;
}

//segmento 3
with instance_create( x,y, obSegmento )
{
    ancestro = other.instancia;
    other.instancia = id;
}

//...
[/gml]
el id de la nueva instancia se guarda en la variable "instancia", cuando se van agregando nuevas instancias se asigna la variable ancestro y el id se recorre. El código se puede reducir usando un ciclo for.

Se ve que ese código mueve los dos objetos a la misma posición, y siempre a la posición del cuarto punto táctil. Si los dos usan el mismo código no pueden moverse de forma independiente, sin embargo, falta ver cómo se asignan las variables "mover" y "soltar". ¿Cómo quieres que se muevan los objetos?, para tener una idea de qué código te puede servir.

Si, image_*scale modifica la máscara de colisión al igual que image_angle (se menciona en el manual de GM8: Changing the scale also changes the values for the image width and height and influences collision events as you might expect.) En tu ejemplo has manejado bien la forma de posicionar el objeto al cambiar la escala, el problema es el funcionamiento de la acción "Align to grid", que mueve el origen de la instancia a el vértice más cercano sin tomar en cuenta la escala.

Si no te gustan los métodos que has usado, aún queda otra opción: Crea un sprite con la forma de la máscara de colisión (un simple rectángulo) y asígnalo al objeto, en el evento Create inicializa una variable que se usará en vez de image_xscale, por ejemplo filph, y en el evento draw dibuja el sprite del personaje:
[gml]
draw_sprite_ext( sprite,subimg, x+16,y+16, fliph,flipv, 0,c_white,1 );
//(el origen del sprite está en el centro)
[/gml]

Me quedé pensando en cómo resolver este problema con un buffer de audio. Creo que se si es necesario hacer una grabación o muestreo, pero que no sea continuo sino que se haga una captura de una fracción de segundo, después se analiza y el ciclo se repite.

Lo que me parece más complicado es determinar en qué momento se produce un sonido adecuado para iniciar el evento; si el sonido se guarda en un buffer formado por números con signo, tal vez se pueda analizar empleando la "media cuadrática" y así obtener la magnitud de la onda.

Sin embargo, presiento que no es tan sencillo; se debe crear un buffer lo suficientemente grande para almacenar una onda con la frecuencia máxima que se quiera detectar, y es posible que la media cuadrática devuelva una magnitud alta para un sonido que tiene una frecuencia muy baja y ni siquiera es audible, entonces se deberían aislar determinadas frecuencias o buscar una forma de calcular la energía del sonido, ¿alguien ha estudiado sobre sonido en física?

No se puede programar con "switch" porque ésa expresión sólo sirve comparar valores exactos (==) y en tu código estás comparando intervalos (<, >). Se puede reducir un poco haciendo "ifs" anidados, por ejemplo:
[gml]
if (charging > 10  && charging < 70 ) //Megabuster medium
    {
        if( state_id == state_idle ) {
            image_speed = 0.3;
            sprite_index = spr_megaman_charge_medium_idle;
        }
        if( state_id == state_run ) {
            image_speed = 0.2 - 0.05;
            sprite_index = spr_megaman_charge_medium_run;
        }
        if( state_id == state_jump ) {
            image_speed = 0.3;
            sprite_index = spr_megaman_charge_medium_jump;
        }
    }
[/gml]

No puedo descargar la última versión del archivo, ¿tu si?, se supone que ahí está la explicación de las funciones.

Parece que no hay forma de capturar sonido en android, sólo quedan dos opciones: la primera es esperar a que los buffers de audio sean funcionales en android y la segunda es programar una extensión en java (y se ve que es bastante trabajo).

Autor: Clamud
Versión: :GM8: 8.1 y :GMS: 1.4
Descripción: Conjunto de scripts para modelar cuerpos geométricos. Son el resultado de varios experimentos hechos en mi juego de planetas.

scDodecaedro( ind, r );
Modela un dodecaedro regular con el radio indicado. Los vértices se calculan como se muestra aquí, y se usan ciclos para hacer las diferentes combinaciones de signos.
[spoiler=Código][gml]
///scDodecaedro( ind, r );
/*
MODELAR DODECAEDRO
    ind: indice del modelo
    r: radio del dodecadedro
   
Devuelve: nada
Autor: Clamud
*/
var fi, a,b,c,d,e, i,j,k, i1,i2, v1,v2,v3,v4,v5, n;

fi = (sqrt(5)+1)/2; //número aureo

a = argument1/sqrt(3); //vértices
b = a/fi;
c = a*fi;// b < a < c

d = 1/point_distance(0,0,1,fi); //normales
e = d*fi;// d < e

d3d_model_clear( argument0 );
for( i=0; i<3; i+=1 )// i : {0,1,2}, posición del cero
{
    i1 = (i+1)mod(3); //posición de b
    i2 = (i+2)mod(3); //posición de c
   
    for( j=-1; j<2; j+=2 )// j : {-1,1}, signo de c
    for( k=-1; k<2; k+=2 )// k : {-1,1}, signo de b
    {
        v4 = 0;      v4[i1] = k*b;  v4[i2] = j*c;
        v5 = 0;      v5[i1] =-k*b;  v5[i2] = j*c;
        v2 = j*k*a;  v2[i1] = k*a;  v2[i2] = j*a;
        v3 = j*k*a;  v3[i1] =-k*a;  v3[i2] = j*a;
        v1 = j*k*c;  v1[i1] = 0;    v1[i2] = j*b;
         n = j*k*d;   n[i1] = 0;     n[i2] = j*e
         
        d3d_model_primitive_begin( argument0, pr_trianglestrip );
        d3d_model_vertex_normal_texture( argument0,  v1[0],v1[1],v1[2], n[0],n[1],n[2], .5+lengthdir_x(.5,90),  .5+lengthdir_y(.5,90) );
        d3d_model_vertex_normal_texture( argument0,  v2[0],v2[1],v2[2], n[0],n[1],n[2], .5+lengthdir_x(.5,18),  .5+lengthdir_y(.5,18) );
        d3d_model_vertex_normal_texture( argument0,  v3[0],v3[1],v3[2], n[0],n[1],n[2], .5+lengthdir_x(.5,162), .5+lengthdir_y(.5,162) );
        d3d_model_vertex_normal_texture( argument0,  v4[0],v4[1],v4[2], n[0],n[1],n[2], .5+lengthdir_x(.5,306), .5+lengthdir_y(.5,306) );
        d3d_model_vertex_normal_texture( argument0,  v5[0],v5[1],v5[2], n[0],n[1],n[2], .5+lengthdir_x(.5,234), .5+lengthdir_y(.5,234) );
        d3d_model_primitive_end( argument0 );
    }
}
[/gml][/spoiler]

scDodecaedroEstrellado( ind, r1, r2 );
Cada cara del dodecaedro se divide en 5 triángulos para formar una punta de estrella; r1 es el radio base y r2 es el radio de cada punta. Requiere el sript scNormal para calcular el vector normal de cada triángulo.
[spoiler=Código][gml]
///scDodecaedroEstrellado( ind, r1,r2 );
/*
MODELAR DODECAEDRO ESTRELLADO
    ind: indice del modelo
    r1: radio del dodecadedro base
    r2: radio de las puntas
   
Devuelve: nada
Nota: requiere el script scNormal
Autor: Clamud
*/
var a,b,c,d,e, i,j,k, i1,i2, v1,v2,v3,v4,v5, v0;//, nx,ny,nz;

fi = (sqrt(5)+1)/2; //número aureo

a = argument1/sqrt(3); //vértices
b = a/fi;
c = a*fi; // b < a < c

d = argument2/point_distance(0,0,1,fi); //puntas
e = d*fi; // d < e

d3d_model_clear( argument0 );
for( i=0; i<3; i+=1 )// i : {0,1,2}, posición del cero
{
    i1 = (i+1)mod(3); //posición de b
    i2 = (i+2)mod(3); //posición de c
   
    for( j=-1; j<2; j+=2 )// j : {-1,1}, signo de c
    for( k=-1; k<2; k+=2 )// k : {-1,1}, signo de b
    {
        v4 = 0;      v4[i1] = k*b;  v4[i2] = j*c;
        v5 = 0;      v5[i1] =-k*b;  v5[i2] = j*c;
        v2 = j*k*a;  v2[i1] = k*a;  v2[i2] = j*a;
        v3 = j*k*a;  v3[i1] =-k*a;  v3[i2] = j*a;
        v1 = j*k*c;  v1[i1] = 0;    v1[i2] = j*b;
        v0 = j*k*d;  v0[i1] = 0;    v0[i2] = j*e;
       
        d3d_model_primitive_begin( argument0, pr_trianglelist );
       
        scNormal( v0[0],v0[1],v0[2], v1[0],v1[1],v1[2], v2[0],v2[1],v2[2] );
        d3d_model_vertex_normal_texture( argument0,  v0[0],v0[1],v0[2], nx,ny,nz, .5,.5 );
        d3d_model_vertex_normal_texture( argument0,  v1[0],v1[1],v1[2], nx,ny,nz, .5+lengthdir_x(.5,90),  .5+lengthdir_y(.5,90) );
        d3d_model_vertex_normal_texture( argument0,  v2[0],v2[1],v2[2], nx,ny,nz, .5+lengthdir_x(.5,18),  .5+lengthdir_y(.5,18) );
       
        scNormal( v0[0],v0[1],v0[2], v2[0],v2[1],v2[2], v4[0],v4[1],v4[2] );
        d3d_model_vertex_normal_texture( argument0,  v0[0],v0[1],v0[2], nx,ny,nz, .5,.5 );
        d3d_model_vertex_normal_texture( argument0,  v2[0],v2[1],v2[2], nx,ny,nz, .5+lengthdir_x(.5,18),  .5+lengthdir_y(.5,18) );
        d3d_model_vertex_normal_texture( argument0,  v4[0],v4[1],v4[2], nx,ny,nz, .5+lengthdir_x(.5,306), .5+lengthdir_y(.5,306) );
       
        scNormal( v0[0],v0[1],v0[2], v4[0],v4[1],v4[2], v5[0],v5[1],v5[2] );
        d3d_model_vertex_normal_texture( argument0,  v0[0],v0[1],v0[2], nx,ny,nz, .5,.5 );
        d3d_model_vertex_normal_texture( argument0,  v4[0],v4[1],v4[2], nx,ny,nz, .5+lengthdir_x(.5,306), .5+lengthdir_y(.5,306) );
        d3d_model_vertex_normal_texture( argument0,  v5[0],v5[1],v5[2], nx,ny,nz, .5+lengthdir_x(.5,234), .5+lengthdir_y(.5,234) );
       
        scNormal( v0[0],v0[1],v0[2], v5[0],v5[1],v5[2], v3[0],v3[1],v3[2] );
        d3d_model_vertex_normal_texture( argument0,  v0[0],v0[1],v0[2], nx,ny,nz, .5,.5 );
        d3d_model_vertex_normal_texture( argument0,  v5[0],v5[1],v5[2], nx,ny,nz, .5+lengthdir_x(.5,234), .5+lengthdir_y(.5,234) );
        d3d_model_vertex_normal_texture( argument0,  v3[0],v3[1],v3[2], nx,ny,nz, .5+lengthdir_x(.5,162), .5+lengthdir_y(.5,162) );
       
        scNormal( v0[0],v0[1],v0[2], v3[0],v3[1],v3[2], v1[0],v1[1],v1[2] );
        d3d_model_vertex_normal_texture( argument0,  v0[0],v0[1],v0[2], nx,ny,nz, .5,.5 );
        d3d_model_vertex_normal_texture( argument0,  v3[0],v3[1],v3[2], nx,ny,nz, .5+lengthdir_x(.5,162), .5+lengthdir_y(.5,162) );
        d3d_model_vertex_normal_texture( argument0,  v1[0],v1[1],v1[2], nx,ny,nz, .5+lengthdir_x(.5,90),  .5+lengthdir_y(.5,90) );
       
        d3d_model_primitive_end( argument0 );
    }
}
[/gml][/spoiler]

scTorus( ind, r,R, n,N, hrep,vrep );
Modela un toro (o rosquilla) empleando sus ecuaciones paramétricas; r es el radio menor, R es el radio mayor, n es el número de segmentos en cada anillo, N es el número de anillos, hrep y vrep definen cuantas veces se repite la textura.
[spoiler=Código][gml]
///scTorus( ind, r,R, n,N, hrep,vrep );
/*
MODELAR TORUS
    ind: indice del modelo a usar
    r: radio menor (radio del conducto)
    R: radio mayor (radio del trayecto)
    n: cantidad de segmentos en cada anillo
    N: cantidad de anillos
    hrep: repetición horizontal de la textura
    vrep: repetición vertical de la textura
   
Devuelve: nada
Autor: Clamud
*/
var r,R, n,N, hrep,vrep, A,cA,sA, B,cB,sB, t,ct,st;
r = argument1; //radio del conducto
R = argument2; //radio del trayecto
n = max( floor(argument3), 3 ); //por lo menos 3 segmentos
N = max( floor(argument4), 3 ); //por lo menos 3 anillos
hrep = argument5; //repetición de la textura
vrep = argument6;

A  = 0; //= 0*2*pi/N;
cA = 1; //= cos(A);
sA = 0; //= sin(A);
for( i=1; i<=N; i+=1 )
{
    B  = i*2*pi/N; //párametro en la trayectoria
    cB = cos(B);
    sB = sin(B);
    d3d_model_primitive_begin( argument0, pr_trianglestrip );
    for( j=0; j<=n; j+=1 )
    {
        t = pi - j*2*pi/n; //parámetro en el conducto
        ct  = cos(t);
        st  = sin(t);
        d3d_model_vertex_normal_texture( argument0,
            cA*(R+r*ct), -sA*(R+r*ct), r*st,
            cA*ct,       -sA*ct,       st,
            hrep*(i-1)/N, vrep*j/n );
        d3d_model_vertex_normal_texture( argument0,
            cB*(R+r*ct), -sB*(R+r*ct), r*st,
            cB*ct,       -sB*ct,       st,
            hrep*i/N, vrep*j/n );
    }
    d3d_model_primitive_end( argument0 );
    A  = B;
    cA = cB;
    sA = sB;
}
[/gml][/spoiler]

scCuboEsfera1( ind, r, n, hrep, vrep );
Una forma alternativa de modelar una esfera. El algoritmo se puede interpretar de esta forma: se tiene un cubo base que es inflado hasta convertirse en una esfera, de forma más precisa: varios punto en la cara de un cubo se proyectan hacia la superficie de una esfera; r es el radio, n es el número de divisiones (en horizontal y vertical) de cada cara, hrep y vrep definen cuantas veces se repite la textura.
[spoiler=Código][gml]
///scCuboEsfera1( ind, r, n, hrep, vrep );
/*
MODELAR CUBO-ESFERA
    ind: indice del modelo a usar
    r: radio de la esfera
    n: número de divisiones
    hrep: repetición horizontal de la textura
    vrep: repetición vertical de la textura
   
Nota: requiere el script scDistTriangulo
Autor: Clamud
*/
var r,n, hrep,vrep, X,Y,Z, i,j, d,
x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4, u1,u2,v1,v2;

r = argument1; //radio
n = max( 1, floor(argument2) ); //n es un entero mayor o igual a 1
hrep = argument3; //repetición de la textura
vrep = argument4;

//Calcular los vectores normales (unitarios)
X[n,n] = 0; //inicializar arreglos
Y[n,n] = 0;
Z[n,n] = 0;
for( i=0; i<=n; i+=1 )
{
    for( j=0; j<=n; j+=1 )
    {
        x1 = 2*i/n - 1;
        y1 = 2*j/n - 1;
        z1 = 1;
        d = point_distance_3d( 0,0,0, x1,y1,z1 );
        X[i,j] = x1/d;
        Y[i,j] = y1/d;
        Z[i,j] = z1/d;
    }
}

//Construir el modelo
for( i=0; i<n; i+=1 )
{
    for( j=0; j<n; j+=1 )
    {
        x1=X[i,j]; x2=X[i+1,j]; x3=X[i+1,j+1]; x4=X[i,j+1];
        y1=Y[i,j]; y2=Y[i+1,j]; y3=Y[i+1,j+1]; y4=Y[i,j+1];
        z1=Z[i,j]; z2=Z[i+1,j]; z3=Z[i+1,j+1]; z4=Z[i,j+1];
       
        u1=i*hrep/n; u2=(i+1)*hrep/n;
        v1=j*vrep/n; v2=(j+1)*vrep/n;
       
        if( scDistTriangulo( x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4 ) > 0 ) //celda N
        {
            //z+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, u2, v1 );
            d3d_model_primitive_end( argument0 );
            //z-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x4*r, -y4*r, -z4*r, x4,-y4,-z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x1*r, -y1*r, -z1*r, x1,-y1,-z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x3*r, -y3*r, -z3*r, x3,-y3,-z3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, x2*r, -y2*r, -z2*r, x2,-y2,-z2, u2, v1 );
            d3d_model_primitive_end( argument0 );
           
            //y+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x4*r, z4*r, -y4*r, x4,z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x1*r, z1*r, -y1*r, x1,z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x3*r, z3*r, -y3*r, x3,z3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, x2*r, z2*r, -y2*r, x2,z2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
            //y-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -x4*r, -z4*r, -y4*r, -x4,-z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -x1*r, -z1*r, -y1*r, -x1,-z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -x3*r, -z3*r, -y3*r, -x3,-z3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, -x2*r, -z2*r, -y2*r, -x2,-z2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
           
            //x+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, z4*r, -x4*r, -y4*r, z4,-x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, z1*r, -x1*r, -y1*r, z1,-x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, z3*r, -x3*r, -y3*r, z3,-x3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, z2*r, -x2*r, -y2*r, z2,-x2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
            //x-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -z4*r, x4*r, -y4*r, -z4,x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -z1*r, x1*r, -y1*r, -z1,x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -z3*r, x3*r, -y3*r, -z3,x3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, -z2*r, x2*r, -y2*r, -z2,x2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
        }
        else //celda Z
        {
            //z+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, u2, v2 );
            d3d_model_primitive_end( argument0 );
            //z-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x1*r, -y1*r, -z1*r, x1,-y1,-z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x2*r, -y2*r, -z2*r, x2,-y2,-z2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, x4*r, -y4*r, -z4*r, x4,-y4,-z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x3*r, -y3*r, -z3*r, x3,-y3,-z3, u2, v2 );
            d3d_model_primitive_end( argument0 );
           
            //y+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x1*r, z1*r, -y1*r, x1,z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x2*r, z2*r, -y2*r, x2,z2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, x4*r, z4*r, -y4*r, x4,z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x3*r, z3*r, -y3*r, x3,z3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
            //y-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -x1*r, -z1*r, -y1*r, -x1,-z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -x2*r, -z2*r, -y2*r, -x2,-z2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, -x4*r, -z4*r, -y4*r, -x4,-z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -x3*r, -z3*r, -y3*r, -x3,-z3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
           
            //x+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, z1*r, -x1*r, -y1*r, z1,-x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, z2*r, -x2*r, -y2*r, z2,-x2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, z4*r, -x4*r, -y4*r, z4,-x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, z3*r, -x3*r, -y3*r, z3,-x3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
            //x-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -z1*r, x1*r, -y1*r, -z1,x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -z2*r, x2*r, -y2*r, -z2,x2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, -z4*r, x4*r, -y4*r, -z4,x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -z3*r, x3*r, -y3*r, -z3,x3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
        }
    }
}
[/gml][/spoiler]

scDomoEsferico1( ind, r, n, hrep, vrep );
Es el script en el que está basado el script anterior. El modelo corresponde a la cara de un cubo cuyo vector normal apunta en dirección z, se puede usar para formar una esfera con diferentes texturas; los argumentos son iguales a los anteriores.
[spoiler=Código][gml]
///scDomoEsferico1( ind, r, n, hrep, vrep );
/*
MODELAR DOMO ESFÉRICO (CUBO-ESFERA)
    ind: indice del modelo a usar
    r: radio de la esfera
    n: número de divisiones
    hrep: repetición horizontal de la textura
    vrep: repetición vertical de la textura
   
Nota: requiere el script scDistTriangulo
Autor: Clamud
*/
var r,n, hrep,vrep, X,Y,Z, i,j, d,
x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4;

r = argument1;
n = max( 1, floor(argument2) ); //n es un entero mayor o igual a 1
hrep = argument3; //repetición de la textura
vrep = argument4;

//Calcular los vectores normales
X[n,n] = 0; //inicializar arreglos
Y[n,n] = 0;
Z[n,n] = 0;
for( i=0; i<=n; i+=1 )
{
    for( j=0; j<=n; j+=1 )
    {
        x1 = 2*i/n - 1;
        y1 = 2*j/n - 1;
        z1 = 1;
        d = point_distance_3d( 0,0,0, x1,y1,z1 );
        X[i,j] = x1/d;
        Y[i,j] = y1/d;
        Z[i,j] = z1/d;
    }
}

//Construir el modelo
for( i=0; i<n; i+=1 )
{
    for( j=0; j<n; j+=1 )
    {
        x1=X[i,j]; x2=X[i+1,j]; x3=X[i+1,j+1]; x4=X[i,j+1];
        y1=Y[i,j]; y2=Y[i+1,j]; y3=Y[i+1,j+1]; y4=Y[i,j+1];
        z1=Z[i,j]; z2=Z[i+1,j]; z3=Z[i+1,j+1]; z4=Z[i,j+1];
       
        d3d_model_primitive_begin( argument0, pr_trianglestrip );
       
        if( scDistTriangulo( x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4 ) > 0 ) //celda N
        {
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4,  i*hrep/n,    (j+1)*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1,  i*hrep/n,     j*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, (i+1)*hrep/n, (j+1)*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, (i+1)*hrep/n,  j*vrep/n );
        }
        else //celda Z
        {
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1,  i*hrep/n,     j*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, (i+1)*hrep/n,  j*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4,  i*hrep/n,    (j+1)*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, (i+1)*hrep/n, (j+1)*vrep/n );
        }
        d3d_model_primitive_end( argument0 );
    }
}
[/gml][/spoiler]

scCuboEsfera2( ind, r, n, hrep, vrep );
Es casi igual a scCuboEsfera1, pero la forma en que se calculan los vértices del modelo es diferente, aquí se determinan los puntos de intersección de un conjunto de circunferencias máximas de la esfera, como resultado se tiene un modelo con una distribución de triángulos más uniforme.
[spoiler=Código][gml]
///scCuboEsfera2( ind, r, n, hrep, vrep );
/*
MODELAR CUBO-ESFERA
    ind: indice del modelo a usar
    r: radio de la esfera
    n: número de divisiones
    hrep: repetición horizontal de la textura
    vrep: repetición vertical de la textura
   
Nota: requiere el script scDistTriangulo
Autor: Clamud
*/
var r,n, hrep,vrep, X,Y,Z, i,j, d, alfa,beta,
x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4, u1,u2,v1,v2;

r = argument1; //radio
n = max( 1, floor(argument2) ); //n es un entero mayor o igual a 1
hrep = argument3; //repetición de la textura
vrep = argument4;

//Calcular los vectores normales (unitarios)
X[n,n] = 0; //inicializar arreglos
Y[n,n] = 0;
Z[n,n] = 0;
for( i=0; i<=n; i+=1 )
{
    alfa = (i/n)*(pi/2)-(pi/4);
    for( j=0; j<=n; j+=1 )
    {
        beta = (j/n)*(pi/2)-(pi/4);
        x1 = sin(alfa);
        y1 = cos(alfa)*tan(beta);
        z1 = cos(alfa);
        d = point_distance_3d( 0,0,0, x1,y1,z1 );
        X[i,j] = x1/d;
        Y[i,j] = y1/d;
        Z[i,j] = z1/d;
    }
}

//Construir el modelo
for( i=0; i<n; i+=1 )
{
    for( j=0; j<n; j+=1 )
    {
        x1=X[i,j]; x2=X[i+1,j]; x3=X[i+1,j+1]; x4=X[i,j+1];
        y1=Y[i,j]; y2=Y[i+1,j]; y3=Y[i+1,j+1]; y4=Y[i,j+1];
        z1=Z[i,j]; z2=Z[i+1,j]; z3=Z[i+1,j+1]; z4=Z[i,j+1];
       
        u1=i*hrep/n; u2=(i+1)*hrep/n;
        v1=j*vrep/n; v2=(j+1)*vrep/n;
       
        if( scDistTriangulo( x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4 ) > 0 ) //celda N
        {
            //z+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, u2, v1 );
            d3d_model_primitive_end( argument0 );
            //z-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x4*r, -y4*r, -z4*r, x4,-y4,-z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x1*r, -y1*r, -z1*r, x1,-y1,-z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x3*r, -y3*r, -z3*r, x3,-y3,-z3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, x2*r, -y2*r, -z2*r, x2,-y2,-z2, u2, v1 );
            d3d_model_primitive_end( argument0 );
           
            //y+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x4*r, z4*r, -y4*r, x4,z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x1*r, z1*r, -y1*r, x1,z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x3*r, z3*r, -y3*r, x3,z3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, x2*r, z2*r, -y2*r, x2,z2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
            //y-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -x4*r, -z4*r, -y4*r, -x4,-z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -x1*r, -z1*r, -y1*r, -x1,-z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -x3*r, -z3*r, -y3*r, -x3,-z3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, -x2*r, -z2*r, -y2*r, -x2,-z2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
           
            //x+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, z4*r, -x4*r, -y4*r, z4,-x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, z1*r, -x1*r, -y1*r, z1,-x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, z3*r, -x3*r, -y3*r, z3,-x3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, z2*r, -x2*r, -y2*r, z2,-x2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
            //x-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -z4*r, x4*r, -y4*r, -z4,x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -z1*r, x1*r, -y1*r, -z1,x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -z3*r, x3*r, -y3*r, -z3,x3,-y3, u2, v2 );
            d3d_model_vertex_normal_texture( argument0, -z2*r, x2*r, -y2*r, -z2,x2,-y2, u2, v1 );
            d3d_model_primitive_end( argument0 );
        }
        else //celda Z
        {
            //z+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, u2, v2 );
            d3d_model_primitive_end( argument0 );
            //z-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x1*r, -y1*r, -z1*r, x1,-y1,-z1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x2*r, -y2*r, -z2*r, x2,-y2,-z2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, x4*r, -y4*r, -z4*r, x4,-y4,-z4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x3*r, -y3*r, -z3*r, x3,-y3,-z3, u2, v2 );
            d3d_model_primitive_end( argument0 );
           
            //y+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, x1*r, z1*r, -y1*r, x1,z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, x2*r, z2*r, -y2*r, x2,z2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, x4*r, z4*r, -y4*r, x4,z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, x3*r, z3*r, -y3*r, x3,z3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
            //y-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -x1*r, -z1*r, -y1*r, -x1,-z1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -x2*r, -z2*r, -y2*r, -x2,-z2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, -x4*r, -z4*r, -y4*r, -x4,-z4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -x3*r, -z3*r, -y3*r, -x3,-z3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
           
            //x+
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, z1*r, -x1*r, -y1*r, z1,-x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, z2*r, -x2*r, -y2*r, z2,-x2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, z4*r, -x4*r, -y4*r, z4,-x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, z3*r, -x3*r, -y3*r, z3,-x3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
            //x-
            d3d_model_primitive_begin( argument0, pr_trianglestrip );
            d3d_model_vertex_normal_texture( argument0, -z1*r, x1*r, -y1*r, -z1,x1,-y1, u1, v1 );
            d3d_model_vertex_normal_texture( argument0, -z2*r, x2*r, -y2*r, -z2,x2,-y2, u2, v1 );
            d3d_model_vertex_normal_texture( argument0, -z4*r, x4*r, -y4*r, -z4,x4,-y4, u1, v2 );
            d3d_model_vertex_normal_texture( argument0, -z3*r, x3*r, -y3*r, -z3,x3,-y3, u2, v2 );
            d3d_model_primitive_end( argument0 );
        }
    }
}
[/gml][/spoiler]

scDomoEsferico2( ind, r, n, hrep, vrep );
También modela un fragmento de esfera, usa el método del script anterior.
[spoiler=Código][gml]
///scDomoEsferico2( ind, r, n, hrep, vrep );
/*
MODELAR DOMO ESFÉRICO (CUBO-ESFERA)
    ind: indice del modelo a usar
    r: radio de la esfera
    n: número de divisiones
    hrep: repetición horizontal de la textura
    vrep: repetición vertical de la textura
   
Nota: requiere el script scDistTriangulo
Autor: Clamud
*/
var r,n, hrep,vrep, X,Y,Z, i,j, d, alfa,beta,
x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4;

r = argument1;
n = max( 1, floor(argument2) ); //n es un entero mayor o igual a 1
hrep = argument3; //repetición de la textura
vrep = argument4;

//Calcular los vectores normales
X[n,n] = 0; //inicializar arreglos
Y[n,n] = 0;
Z[n,n] = 0;
for( i=0; i<=n; i+=1 )
{
    alfa = (i/n)*(pi/2)-(pi/4);
    for( j=0; j<=n; j+=1 )
    {
        beta = (j/n)*(pi/2)-(pi/4);
        x1 = sin(alfa);
        y1 = cos(alfa)*tan(beta);
        z1 = cos(alfa);
        d = point_distance_3d( 0,0,0, x1,y1,z1 );
        X[i,j] = x1/d;
        Y[i,j] = y1/d;
        Z[i,j] = z1/d;
    }
}

//Construir el modelo
for( i=0; i<n; i+=1 )
{
    for( j=0; j<n; j+=1 )
    {
        x1=X[i,j]; x2=X[i+1,j]; x3=X[i+1,j+1]; x4=X[i,j+1];
        y1=Y[i,j]; y2=Y[i+1,j]; y3=Y[i+1,j+1]; y4=Y[i,j+1];
        z1=Z[i,j]; z2=Z[i+1,j]; z3=Z[i+1,j+1]; z4=Z[i,j+1];
       
        d3d_model_primitive_begin( argument0, pr_trianglestrip );
       
        if( scDistTriangulo( x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4 ) > 0 ) //celda N
        {
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4,  i*hrep/n,    (j+1)*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1,  i*hrep/n,     j*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, (i+1)*hrep/n, (j+1)*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, (i+1)*hrep/n,  j*vrep/n );
        }
        else //celda Z
        {
            d3d_model_vertex_normal_texture( argument0, x1*r, y1*r, z1*r, x1,y1,z1,  i*hrep/n,     j*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x2*r, y2*r, z2*r, x2,y2,z2, (i+1)*hrep/n,  j*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x4*r, y4*r, z4*r, x4,y4,z4,  i*hrep/n,    (j+1)*vrep/n );
            d3d_model_vertex_normal_texture( argument0, x3*r, y3*r, z3*r, x3,y3,z3, (i+1)*hrep/n, (j+1)*vrep/n );
        }
        d3d_model_primitive_end( argument0 );
    }
}
[/gml][/spoiler]

Los siguientes scripts se usan dentro de los anteriores.

scNormal( x1,y1,z1, x2,y2,z2, x3,y3,z3 );
Calcula el vector normal de un triángulo, para que el dodecaedro estrellado tenga una iluminación adecuada. Se podría optimizar para usar las nuevas características de los arreglos en :GMS:, lo dejaré así por ahora.
[spoiler=Código][gml]
///scNormal( x1,y1,z1, x2,y2,z2, x3,y3,z3 );
/*
CALCULAR VECTOR NORMAL
Se obtiene el vector normal a un triangulo con los
puntos indicados en orden de las manecillas del reloj.

Devuelve: nada, pero se asignan las variables nx, ny, nz.

Nota: el vector obtenido está invertido porque
el sistema de coordenadas en GM está invertido.
Autor: Clamud
*/
var Ax,Ay,Az, Bx,By,Bz, l;

//Vector A
Ax = argument3 - argument0;
Ay = argument4 - argument1;
Az = argument5 - argument2;

//Vector B
Bx = argument6 - argument0;
By = argument7 - argument1;
Bz = argument8 - argument2;

//n = A x B (producto cruz)
nx = (Ay * Bz) - (Az * By);
ny = (Az * Bx) - (Ax * Bz);
nz = (Ax * By) - (Ay * Bx);

//Unitario
l = point_distance_3d( 0,0,0, nx,ny,nz );
nx/=l;  ny/=l;  nz/=l;
[/gml][/spoiler]

scDistTriangulo( x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4 );
Calcula la distancia entre un punto y un plano definido con tres puntos, se usa para garantizar que la superficie de las esferas es completamente convexa.
[spoiler=Código][gml]
///scDistTriangulo( x1,y1,z1, x2,y2,z2, x3,y3,z3, x4,y4,z4 );
/*                  0  1  2   3  4  5   6  7  8   9  10 11
DISTANCIA A TRIANGULO
Se obtiene la distancia entre un punto (x0,y0,z0) y
un plano definido con tres puntos en sentido horario

Devuelve: un número real
Autor: Clamud
*/
var Ax,Ay,Az, Bx,By,Bz, Nx,Ny,Nz;

//Vector A
Ax = argument6 - argument3;
Ay = argument7 - argument4;
Az = argument8 - argument5;

//Vector B
Bx = argument9  - argument3;
By = argument10 - argument4;
Bz = argument11 - argument5;

//N = A x B (producto cruz)
Nx = (Ay * Bz) - (Az * By);
Ny = (Az * Bx) - (Ax * Bz);
Nz = (Ax * By) - (Ay * Bx);

//Unitario
//l = point_distance_3d( 0,0,0, Nx,Ny,Nz );
//Nx/=l;  Ny/=l;  Nz/=l;

//Distacia
return
(argument0-argument3)*Nx +
(argument1-argument4)*Ny +
(argument2-argument5)*Nz;
[/gml][/spoiler]

Es probable que esta lista crezca con el tiempo. Pueden solicitar otras figuras.

La X siempre se muestra, no hay forma de cambiar ese comportamiento. La única solución es usar una extensión o dll (http://www.gmtoolbox.com/).

No hay muchas opciones para dibujar la barra sin escribir código, sólo están las acciones "dibujar rectángulo" y "dibujar gradiente", pero al final resulta más complicado que usar una función como draw_healthbar, además con código puedes hacer una barra con forma personalizada y con cualquier tipo de decoraciones.

No temas escribir código, es mejor que el sistema DnD, y éste problema es lo bastante sencillo para empezar a practicar.

Lo que propuso Marth es una buena idea, lo implementé en el ejemplo adjunto.

Te falta sumar una variable dentro del if:
[gml]
if( x+5*argument0 <= view_xview[0]+32
or  x+5*argument0 >= view_xview[0]+view_wview[0]-32 )
{ /*no se mueve*/ }
else
{ /*ejecuta código de movimiento*/ }
[/gml]

Si usas Chrome, debes seguir las instrucciones de esta página: https://support.google.com/chrome/answer/6213033. Sin embargo, es una solución temporal, en la próxima actualización de Chrome se terminará el soporte para aplicaciones Java; argumentan que es un sistema obsoleto y que pone en riesgo la seguridad del usuario.

Encontré un error al querer ver la colección de monstruos derrotados:

FATAL ERROR in
action number 1
of Other Event: User Defined 4
for object MenuColeccion:

second index out of bounds request 0,35 maximum size is 1


Ya logré avanzar bastante, vaya que son difíciles las batallas. Aprovechando que estarás hurgando en el código, ¿podrías bajar la probabilidad de fallo? A veces ocurren series de fallos que parecen interminables, y lo peor es cuando todos tus aliados fallan y los enemigos no, eso es frustrante porque no es posible hacer una estrategia suficientemente sólida.

Otra cosa que me gustaría es que la velocidad de las animaciones de ataque y de movimiento fueran más rápidas. Tal vez los enemigos necesitan un tiempo mínimo para calcular su trayectoria, pero espero que se pueda reducir el tiempo de animación.

Eso es todo por ahora. Hasta pronto.