Comunidad Game Maker

No tengo idea, pero creo que no es necesaria para compilar, además la API 9 es demasiado antigua.

Deben ir en ...\android-sdk\platforms\

Esa parece una buena herramienta 3dgeminis.
También puedes guardar como .dae y convertir con Blender.
Toma en cuenta que GameMaker no soporta el formato obj wavefront, por lo que tienes que usar una extensión para cargar los modelos o usar un convertidor para pasar los modelos al formato de GameMaker. Por ejemplo estos:
https://sourceforge.net/projects/sivmodeler/
http://www.maartenbaert.be/model-creator/

Lo voy a revisar con calma, yo también quiero implementar ese funcionamiento, espero no tardar más de dos días :P

Me parece que el problema es que se revisan las coordenadas del device_mouse en el room, que a su vez dependen del tamaño de la vista, entonces se hace un ciclo que altera el cambio verdadero de coordenadas. Lo mejor sería leer las coordenas en la pantalla, con las funciones
[gml]
device_mouse_x_to_gui
device_mouse_y_to_gui
[/gml]
o
[gml]
device_mouse_raw_x
device_mouse_raw_y
[/gml]

Autor: Clamud
Versión: GameMaker Studio
Descripción: Crea una matriz 2D de números reales a partir de una cadena, usa 'coma' para separar las columnas y 'punto y coma' para separar las filas. Se pueden usar espacios, puntos decimales y saltos de línea. La cadena debe terminar con 'punto y coma'.

string_matrix( string )
[gml]
///string_matrix( string );
/*
   Crea una matriz 2D a partir de una cadena
   , separa las columnas
   ; separa los renglones
*/

var cad = argument0; //cadena
var lon = string_length(cad); //longitud
var pos; //posicion
var mat; //matriz
var car; //caracter
var sub = ""; //sub-cadena
var i=0, j=0; //indices

for( pos=1; pos<=lon; pos++ ) //para todos los caracteres
{
    car = string_char_at( cad, pos );
    if( car == "," ){ //si es coma
        mat[i,j] = real(sub); //agregar valor a la matriz
        sub = ""; //borrar sub-cadena
        i++; //incrementar indice
    }
    else if( car == ";" ){ //si es punto y coma
        mat[i,j] = real(sub); //agregar valor a la matriz
        sub = ""; //borrar sub-cadena
        i = 0; //reiniciar i
        j++; //incrementar j
    }
    else sub += car; //agregar caracter a sub-cadena
}
return mat; //devolver matriz
[/gml]

Ejemplo:
[gml]
Matrix = string_matrix("
1.10, 2.00, 3.14, 4.00;
5.00, 6.66, 7.00, 8.00;
9.22, 10.0, 11.1, 12.9;
");
[/gml]

Suponiendo que tienes una variable carga que va de 0 a 100 y un sprite con n sub-imágenes; al valor 0 le corresponde la sub-imagen 0, y al valor 100 le corresponde la sub-imagen n-1; entonces debes usar un código como este:
[gml]
//Create
n = image_number; //numero de sub-imagenes
carga = 0;

//Step
carga += 1; //sumar cualquier numero
if( carga >= 100 ) carga = 100;
image_index = (n-1)*carga/100;
[/gml]

Otra forma es usar este script http://www.comunidadgm.org/desarrollo-de-scripts/dibujar-sector-circular/
[gml]
//Create
carga = 0;
angulo = 90;

//Step
carga += 1; //sumar cualquier numero
if( carga >= 100 ) carga = 100;
angulo = 90 - 360*carga/100;

//Draw
dibujar_sector( x,y,64, angulo,90,5, true );
[/gml]

Intenta instalarla manualmente:
http://downloads.puresoftware.org/files/android/API/

Sí, es una buena alternativa, hace tiempo que escribí el script, supongo que decidí usar un while para ahorrarme el var i  :P
En los dos casos se debe escribir el draw_vertex después del ciclo.
También es preferible que el barrido se haga desde a2 hasta a1, porque en ese punto a2 es mayor que a1, entonces los vértices se agregan en el sentido de las manecillas del reloj, y no hay problema si se usa d3d_set_culling(true).

Autor: yo
Descripción: Dibuja un sector circular o "queso partido"
Versión: GM8 en adelante, también podría funcionar en versiones previas

Código:
[gml]
///dibujar_sector( x,y,r, a1,a2,a3, contorno );
/*                 0 1 2  3  4  5   6
DIBUJAR UN SECTOR CIRULAR
Dibuja un sector circular con vertice en (x,y), el vertice
es el centro del circulo, con radio r. El area dibujada va
desde el angulo 1 (a1) hasta el angulo 2 (a2), en el sentido
contrario a las manecillas del reloj, en incrementos iguales
al angulo 3 (a3). Si se intercambian los valores de a1 y a2
el sector resultante es el conjugado del primero.

Argumentos
    x,y: vertice del sector
    r: radio
    a1: angulo inicial
    a2: angulo final
    a3: angulo incremento (precision)
    contorno: dibujar solo contorno o llenar poligono
   
Devuelve: nada
*/
var xx, yy, r, a1, a2, a3;
xx = argument0; //vertice
yy = argument1;
r  = argument2; //radio

a1 = argument3; //angulo inicial
a2 = argument4; //angulo final
while( a1 > a2 ) a2 += 360; //evitar sectores mayores
while( a2-a1 > 360 ) a1 += 360; // a 360 grados

if( argument5 == 0 ) a3 = 10; //la precision debe
else a3 = abs(argument5); // ser mayor a cero

//iniciar primitivas (contorno o lleno)
if( argument6 ) draw_primitive_begin( pr_linestrip );
else draw_primitive_begin( pr_trianglefan );

draw_vertex( xx, yy ); //primer vertice
while( a2 >= a1 ) //hacer un barrido desde a2 hasta a1
{
    draw_vertex(
    xx + lengthdir_x(r,a2),
    yy + lengthdir_y(r,a2) );
    a2 -= a3;
}
draw_vertex( //vertice en a1
xx + lengthdir_x(r,a1),
yy + lengthdir_y(r,a1) );

if( argument6 ) draw_vertex( xx, yy ); //vertice final
draw_primitive_end();
[/gml]

Estos shaders:
https://marketplace.yoyogames.com/assets/705/vignette-and-noise-shader
https://marketplace.yoyogames.com/assets/1124/postfx-bundle-1

Tal vez ocurre porque nunca se dejan de leer los comandos del teclado. Entonces necesitas una variable que indique el momento en que se habla con un NPC:
[gml]
if( not hablando )
{
    if(keyboard_check(vk_left))
    {
        phy_position_x -= 4;
    }
    // ...
}
[/gml]

Se pueden usar las ecuaciones de movimiento parabólico para controlar el movimiento de esta forma
[gml]
x = xi + vx*t;
y = yi + vyi*t + g*t*t/2;
[/gml]
xi, yi es la posición cuando inicia el salto
vx es la velocidad horizontal (que es constante)
vyi es la velocidad vertical cuando inicia el salto
g es la gravedad
t es el tiempo (en steps)

Cuando se oprima el botón de salto, se debe guardar la posición inicial:
[gml]
xi = x; //x inicial
yi = y; //y inicial
[/gml]
Y de alguna forma se debe conocer la posición final. En el ejemplo que he adjuntado se busca el bloque que está próximo a la derecha, entonces se calculan las otras variables:
[gml]
if instance_exists( bs ){ //si hay bloque a la derecha
    xf = bs.x; //x final
    yf = bs.y - 32; //yfinal
   
    tt = (xf - xi)/vx; //tiempo total para el salto
    vyi = (yf - yi - g*tt*tt/2)/tt; //velocidad inicial de salto
   
    saltando = true; //activar salto
    t = 0; //tiempo actual
}
[/gml]
El tiempo total de salto es igual a la x final menos la x inicial, es decir, la distancia horizontal entre los dos bloques, que se divide entre la velocidad horizontal.
La velocidad vertical inicial se obtienen despejando la ecuación original y sustituyendo la variable t por el tiempo total.
Se activa la variable saltando y el tiempo transcurrido se hace igual a cero.

En el evento Step se actualiza la posición:
[gml]
if( saltando == true )
{
    t += 1; //incrementar tiempo
    if( t > tt ){ //si llega al limite
        t = tt; //limitar
        saltando = false; //termina salto
    }
    //formula de tiro parabolico
    x = xi + vx*t;
    y = yi + vyi*t + g*t*t/2;   
}
[/gml]

En el ejemplo adjunto se puede ver cómo funciona. Para saltar presiona ESPACIO.

Toma en cuenta que una ventana de 3000 px de ancho se sale de la mayoría de las pantallas, por lo tanto, sí debes usar una view para mostrar sólo una parte de la room.

Si has puesto la "View in room" a 640x480 y quieres que se vea más grande en pantalla, entonces debes hacer el "Port on screen" más grande, por ejemplo 1024x768. También puedes iniciar el juego en pantalla completa marcando la casilla "Start in fullscreen mode" en los Ajustes Globales de Juego.

Entonces escribe el código en el evento Create del misil, y NO en el evento Step.