Comunidad Game Maker

Para hacer lanzamientos con diferente ángulo tenemos 2 alternativas:

* Si el ángulo es constante y el aterrizaje debe ser exacto, primero se define el alcance horizontal (X), se define el ángulo (angulo) y se calcula la velocidad inicial (vi)
[gml]
vi = sqrt( X*g / sin(degtorad(2*angulo)) );
[/gml]
se debe poner degtorad si el ángulo está en grados.
Después se calculan las componentes de la gravedad
[gml]
vx = lengthdir_x( vi, angulo );
vx = lengthdir_y( vi, angulo );
[/gml]

* Si el ángulo es variable, no conviene definir primero el alcance horizontal, en este caso la variable X no se utiliza porque el aterrizaje no es exacto (se deberá utilizar el deslizamiento). Primero se define la velocidad inicial y el ángulo, y las componentes se calculan directamente
[gml]
vx = lengthdir_x( vi, angulo );
vx = lengthdir_y( vi, angulo );
[/gml]
el código es igual al anterior.
Es importante notar que la velocidad inicial no es linealmente proporcional al alcance horizontal, la relación es cuadrática, entonces existen más probabilidades de hacer un lanzamiento largo que uno corto.

Gracias fasst007, es un buen método. Entre todas las alternativas prefiero usar la que lleva abs, pues he notado que es mejor usar poco código; en GM8 la velocidad de interpretación del código es lenta en comparación con la velocidad de las funciones matemáticas.

Acabo de recordar que hay otro método para resolver el problema (con mediatrices), si en ese método se necesitan menos operaciones es probable que el resultado sea más preciso.

Y en mi mensaje anterior me equivoqué en el nombre de una función, en realidad se llama math_set_epsilon.

Aquí está un nuevo motor en el que se recortan la imágenes, y para demostrarlo, no hay imágenes dentro del proyecto; se debe cargar una imagen externa para funcionar.

Este proyecto ha cambiado mucho comparado con la versión anterior, los principales cambios están en el objeto controlador, y también hay una gran cantidad de variables globales, eso es lo óptimo porque casi todas las instancias usan las mismas variables.

Cuando un proyecto se hace grande se utilizan muchas variables, en estos casos me gusta escribir una tabla de variables para ayudarme a recordar, para tener una referencia rápida, para evitar variables repetidas, etc. La tabla también está adjunta.

Las piezas se dibujan en superficies, la forma básica de cada pieza se construye combinando (sumando) 4 sprites (que he llamado "clips"), después la imagen se recorta usando la forma de la pieza, estableciendo un "blend mode".
He estado pensando que es mejor construir las formas básicas de las piezas usando el método inverso: restar en lugar de sumar, haré el cambio en la próxima actualización.

La interfaz gráfica es extremadamente sencilla para no complicar el código. La imagen cargada se muestra pequeña para tener suficiente espacio alrededor para distribuir las piezas; si el área exterior forma bandas delgadas se necesitan demasiadas iteraciones para colocar las piezas fuera del marco, si el marco se hace más grande es necesario mejorar el algoritmo que busca una posición libre.

Hay que pensar en una forma de obtener el mejor contraste entre el fondo y las piezas, también me gustaría dibujar un contorno en las piezas, porque en ocasiones las formas se pierden de vista, sobre todo cuando se usan fotografías o imágenes con muchos detalles.

¿Qué código usas?

Hola, hice un programa para encontrar la circunferencia que pasa por 3 puntos (usando el método de sistema de ecuaciones), pero hay pérdidas debidas al redondeo y en ocasiones, al comparar el radio con las distancias de los puntos al centro de la circunferencia,  no se consideran iguales (usando el operador ==).
A veces las diferencias son insignificantes y los números no se consideran iguales y otras veces las diferencias son de la misma magnitud ¡y si se consideran iguales!.

Si sólo quisiera dibujar el círculo no importaría, el problema es que pienso usar el algoritmo para generar una triangulación de Deloné (o Delaunay) y si no hay seguridad en las comparaciones el sistema se va a complicar mucho.

En GMS el problema se puede solucionar con la función math_set_delta, sin embargo, en GM8 no existe esa función. He pensado en usar string_format para redondear hasta un número fijo de cifras decimales, pero esa función es demasiado lenta y sería necesario usarla en cientos o miles de iteraciones, además hay que hacer comparaciones de intervalos (<, >), entonces se debería usar la función real que también es lenta. Otra solución sería comparar los números a nivel de bits, pero no estoy seguro de cómo hacerlo. ¿Alguien tiene otra idea?

El proyecto está adjunto. Los controles son:
Click izquierdo - agregar un punto
Click derecho - reiniciar
Enter - agregar puntos con el teclado
Espacio - agregar puntos aleatorios

Las siguientes combinaciones de puntos producen resultados diferentes:

una causa error
( 365, 302 )
( 383, 184 )
( 548, 199 )

y la otra no
( 394, 470 )
( 369, 184 )
( 191, 251 )

Subí un ejemplo, el tutorial está en esta colección: http://gmc.yoyogames.com/index.php?showtopic=86203

Debes tomar en cuenta el ángulo relativo entre el frente del enemigo y el ángulo del vector que va del enemigo a la cámara, entonces para cada intervalo dentro de los 360 grados se muestra el sprite en alguna dirección, he visto algunos ejemplos, pero no recuerdo dónde, luego los busco. (busca "mode 7 en gamemaker" te puede aparecer algo relacionado)

El primer mensaje es por un bug de GM, que corrompe un archivo que carga los tutoriales y ejemplos, al parecer no hay forma de arreglarlo, intenta actualizar GM. El segundo error se puede solucionar así: http://help.yoyogames.com/entries/25986633-Access-violation-on-start

Revisa este tema: http://www.comunidadgm.org/preguntas-y-respuestas/recordar-objetos-encontrados-segun-nivel-(solucionado)/

Hacer que un sprite siempre se muestre de frente a la cámara usa una técnica conocida como billboarding, en el tutorial clásico de GM para hacer un First Person Shooter se muestra una forma de hacerlo: http://sandbox.yoyogames.com/extras/user/cv/san2/504/472504/GM_Tutorial_-_First_Person_Shooter.pdf
Hacer enemigos con movimiento inteligente es más difícil de hacer, existen muchos algoritmos de inteligencia artificial y su rendimiento depende del diseño del juego.

Eso que mencionas musteroix es más o menos el método que estoy utilizando, y ya funciona, sólo mea faltan algunos detalles para presentarlo. Otra idea que tengo es usar primitivas, pero al ser las piezas con muchas curvas se usan demasiados polígonos y, por lo tanto, necesitan demasiado procesamiento. En cambio, las superficies se dibujan más rápido.

Puedes reproducir el sonido cuando se muestre el sprite con el pie abajo.

¿Los ejes te devuelven -1 o es un valor pequeño?
Es un comportamiento muy extraño, también lo he encontrado al dejar desativadas las palancas analógicas en el mando.
Si las funciones de ejes te devuelven un valor pequeño, la solución es usar una zona muerta.

Para evitar secuencias repetidas usa la función randomize()

Hola, hice unas ligeras modificaciones a tu ejemplo solsticio.

Lo primero que hice fue editar el sonido click porque tardaba mucho en sonar al seleccionar una pieza, sólo recorté las partes de silencio. Antes de reproducir el click agregué una línea:
[gml]
if( !audio_is_playing(snd_clic) )
audio_play_sound(snd_clic, 1, false); // sonido click //
[/gml]
de esa forma evitamos la superposición de muchos clicks.

Otra modificación a obPiezas es que al momento de calzar una pieza se coloca abajo de todas las demás , es el proceso inverso al que se usó para poner la pieza encima:
[gml]
//enviar al fondo
for( i=1; i<global.k; i+=1 ) //para todas las piezas
{
    global.lista[|i-1] = global.lista[|i]; //recorrer un lugar
    global.lista[|i].depth -= 1; //disminuir la profundidad
}
depth = global.k-1; //esta se coloca abajo de otras piezas
global.lista[|global.k-1] = id;
[/gml]
noten que la variable k, que es declarada en los objetos controladores, ahora es global, y su valor es igual al total de piezas creadas, lo cual es muy útil para saber la profundidad máxima (y otras cosas).

También hice una modificación al área donde se distribuyen las piezas, con el siguiente código se distribuyen alrededor del marco, sin embargo los límites no están bien medidos y se deben mejorar:
[gml]
with( obj_Piezas ) //con todos los objetos pieza
{
    ESTADO = MEZCLA; //cambiar estado
    do {
        xfinal = irandom_range( 1216,16 ); //posicion final
        yfinal = irandom_range( 32, 576 );
    } until (
        xfinal < 150 or
        xfinal > 850 or
        yfinal < 100 or
        yfinal > 600
    )
    depth = ds_list_find_index( global.lista, id ); //profundidad aleatoria
}
[/gml]

Ya comencé a diseñar motor para recortar las imágenes dentro del juego, en unos días mostraré los avances.