Comunidad Game Maker

Buen día, he estado buscando una forma sencilla (automática) para copiar los colores junto con el código GML, para pegarlo en algún editor de texto como Word. Yo uso  :GM8: y  :GMS:, me gusta más la combinación de colores de GM8, quiero copiar esos colores. He leído que hay editores de código externos para GML, ¿en alguno de ellos se podrán copiar los colores?
Gracias, hasta luego.

Aquí está la otra versión del código.
En el evento Create de la nave es necesario definir 2 variables:
[gml]
///Create de la nave

//Componentes del vector gravedad
gravity_x = 0;
gravity_y = 0;
[/gml]
El evento Step del planeta se debe cambiar a Begin Step y modificar los siguiente:
[gml]
///Begin Step de un Planeta

//...

if( f > 0 )
{
    k = point_direction( obNave.x, obNave.y, x, y ); //dirección en la que actúa la gravedad
    obNave.gravity_x += lengthdir_x( f, k ); //sumar componente x de la gravedad
    obNave.gravity_y += lengthdir_y( f, k ); //sumar componente y de la gravedad
}
[/gml]
En el Step de la nave se asignan las variables de gravedad:
[gml]
///Step de la nave

gravity = point_distance( 0,0, gravity_x, gravity_y );
gravity_direction = point_direction( 0,0, gravity_x, gravity_y );
[/gml]
Y por último se restablecen las componentes de la gravedad en el evento End Step de la nave:
[gml]
///End Step de la nave

gravity_x = 0;
gravity_y = 0;
[/gml]

No se puede, esa es la desventaja de usar surfaces, son "volátiles". Si necesitas usar surfaces que se actualizan constantemente debes revisar, antes de dibujar, que las surfaces existen, si no existen no intentar dibujarlas, o crearlas y actualizarlas en ese momento. Si la surface cambia pocas veces dentro del juego, se pueden crear sprites o backgrounds a partir de éstas, esos recursos se borran hasta que se cierra el juego.

Hola chetuu16. Da una explicación más detallada o muestra el código, porque así es muy difícil determinar el error.

Coloqué un código para distancias menores al radio como protección, para que la fuerza de atracción que ejerce un planeta no pueda ser mayor a g, en caso de que al detectar colisiones la nave quede traslapada con un planeta o que necesites calcular una trayectoria, usando la misma fórmula en distancia menores a r (f = (d-a)*g/(r-a)) la fuerza de gravedad crecerá, aunque sería poco. Se supone que ningún objeto podrá traspasar los planetas, pero como dije, el código if( d < r ) f = g; está como mecanismo de protección.

La variable "r" (radio) indica a qué distancia se tendrá la mayor fuerza de gravedad, o sea, el borde del planeta, y a partir de ahí disminuye hasta donde indica la variable "a" (alcance), para distancias mayores la fuerza de gravedad es cero. El código se puede modificar para no contemplar el radio, y hacer que la fuerza de gravedad sea máxima en el centro del planeta y de ahí disminuya, se puede obtener el mismo resultado haciendo r=0, pero me parece que establecer los valores de "g" y "a" es más dificil de ese modo.

Usar la variable "gravity" no lo había pensado, es buena idea, pero el código queda un poco más largo. Sería casi lo mismo a usar la función motion_add(), pero en vez de modificar las variables "speed" y "direction" se modificarían las variables "gravity" y "gravity_direction". En unas horas, cuando tenga tiempo, te mostraré el código modificado.

Tal vez el archivo no se guarda bien porque el juego necesita correr como administrador.

Si tu planeta es un círculo que cabe en un cuadro (sprite) de x pixeles por lado, el radio es la mitad de ese valor. La gravedad máxima y el alcance se tendrán que decidir a base de prueba y error, elige los valores que hagan que tu nave se comporte como quieres.

En GMS, en el menú file elige "export", para crear un sólo archivo que es más cómodo de descargar.

Aquí hay algo parecido:
http://www.comunidadgm.org/preguntas-y-respuestas/hacer-un-canon/

¿Cómo agregas los elementos a la lista?

Escribe:
[gml]
phy_speed_x = 0;
phy_speed_y = 0;
[/gml]
Cuando se activa el sistema de físicas las variables normales de movimiento no se toman en cuenta, el icono "move fixed" modifica las variables normales "speed" y "direction" por eso no funciona.

Se puede simular la gravedad con diferentes grados de realismo; una forma sencilla y muy aproximada a la realidad sería manejar la gravedad como una función cuadrática de la distancia al centro del planeta, pero para un juego de naves sería incómodo ya que la gravedad se hará muy fuerte al acercarse a un planeta, es mejor usar una relación lineal entre gravedad y distancia.

En tu juego, no se si los planetas tienen el mismo tamaño o la misma fuerza de gravedad, si es así, el código puede ir dentro del objeto nave, si no, es mejor que cada planeta ejecute los siguientes códigos:
[gml]
///Create de un planeta

r = //radio del planeta
g = //gravedad máxima del planeta (la que se siente en la superficie)
a = //alcance de la gravedad
[/gml]
En el objeto nave se van a modificar las variables speed y direction a causa de la gravedad:
[gml]
///Step de un planeta

d = point_distance( x,y, obNave.x,obNave.y ); //distancia
if( d < r ) f = g; //fuerza de gravedad = gravedad máxima
else if( d > a ) f = 0; //a esa distancia la fuerza de gravedad es cero.
else f = (d-a)*g/(r-a); //si la distancia está entre el radio y el alcance, la fuerza es una función lineal

if( f > 0 )
{
    k = point_direction( obNave.x, obNave.y, x, y ); //dirección en la que actúa la gravedad
    with( obNave ) motion_add( other.k, other.f ); //agregar la fuerza de gravedad al movimiento de la nave
}
[/gml]
Con esos códigos la nave ya puede reaccionar a la gravedad de los planetas que estén en la room, pero no está especificado un método para detener la nave al colisionar con los planetas, ni la forma en que la nave se va a propulsar. Para no escribir el código en cada objeto planeta usa un objeto parent (padre), todos los objetos hijos deben tener su propio código en el evento Create.

No entendí bien, ¿quieres que las barras de arriba a la izquierda queden cubiertas por el rectángulo negro?

También está la función move_wrap, que además teletransporta verticalmente y permite definir un margen alrededor de la room.

Suponiendo que el laser es completamente horizontal y se dispara hacia la derecha, creamos una instancia del objeto laser, en algún evento del objeto jugador:
[gml]
instance_create( x,y, obLaser );
[/gml]
En el evento Create de obLaser ponemos esto:
[gml]
x0 = x; // punto inicial
y0 = y;

while( collision_point(x,y,all,false,true ) == noone // mientras no impacte con un objeto
and                                                  // y
x <= (view_xview + view_wview) )                     // no se salga de la view
x += 8;                                              // el rayo se sigue extendiendo

if( collision_point( x,y,all,false,true) != noone ) {      // si ha impactado en un objeto
    do x--;                                                // regresar un pixel a la izquierda
    until( collision_point( x,y,all,false,true) == noone ) // hasta quedar en el borde del objeto
}
[/gml]
Para avanzar el rayo he puesto un valor de 8 pero debes ajustarlo al tamaño de la máscara de colisión de tus objetos, para que no los salte sin detectarlos, y no debe ser un valor muy pequeño, para que el ciclo no se repita demasiadas veces. En el tipo de objetos que se detectan he puesto all (todos), pero es probable que no quieras que el laser choque con ciertos objetos, entonces deberás poner varias condiciones para cada tipo de objeto a detectar.

Luego en el evento Draw del laser:
[gml]
draw_circle( x0,y0, 10, false );  // circulo en la boca del arma que dispara
draw_line_width( x0,y0, x,y, 4 ); // el rayo
draw_self();                      // se dibuja el propio sprite, en las posición en la que choca
[/gml]
El sprite del objeto laser se usa para tener una máscara de colisión y para hacer el efecto de una pequeña explosión o un resplandor en el lugar que impacta. Para darle una mejor apariencia puedes hacer que el color cambie en cada step (como en Metal Slug) o usar las funciones para dibujar círculos y líneas con dos colores a la vez, o en vez de usar esas funciones puedes dibujar sprites.

Por último el objeto laser se destruye en algún evento antes de que se dispare otro rayo con posición y forma actualizada:
[gml] instance_destroy(); [/gml]

Ahora tienes que ajustar el código para disparar hacia la izquierda, arriba y abajo. Si el rayo se va a disparar con diferentes inclinaciones, tal vez sea mejor usar otro método.