Comunidad Game Maker

Te dejo uno como el de zela ya con distancia maxima, también lo puedes adaptar para que quede en un script. Al final puedes usar el que quieras, creo que el de zela puede ser algo más fácil de entender y poquitín más lento. En fín en gm da casi lo mismo.
[gml]
var x1, y1, d, x2, y2, d2, dot;
d=point_distance(objM.x, objM.y, mouse_x, mouse_y);
x1=(objM.x-mouse_x)/d;
y1=(objM.y-mouse_y)/d;

with(obj_mariposa){
      d2=point_distance(objM.x, objM.y, mouse_x, mouse_y);
      if (d2>distancia) continue;
      x2=(objM.x-x)/d2;
      y2=(objM-y-y)/d2;
      dot=radtodeg( arccos(x1*x2+y1*y2) );
      //Y listo dot es igual al angulo que querías
      if ( dot<90 ){
          //Wololo
      }
}[/gml]

Usas gm8.1?, ya tiene una función creada para esto.

Esto se hace con el producto escalar o dot_product, que básicamente dice que la multiplicación de dos vectores normalizados nos da el coseno del angulo comprendido entre ambos vectores. Puedes buscar en otras fuentes de información o preguntar en el mismo tema, solo no tengo ganas de explicar algo si no le van a poner atención.


[gml]
var x1, y1, d, x2, y2, d2, dot;
d=point_distance(objM.x, objM.y, mouse_x, mouse_y);
x1=(objM.x-mouse_x)/d;
y1=(objM.y-mouse_y)/d;

with(obj_mariposa){
      d2=point_distance(objM.x, objM.y, mouse_x, mouse_y);
      x2=(objM.x-x)/d2;
      y2=(objM-y-y)/d2;
      dot=radtodeg( arccos(x1*x2+y1*y2) );
      //Y listo dot es igual al angulo que querías
      if ( dot<90 ){
          //Wololo
      }
}
[/gml]

EL código debe de ir en cualquier objeto que no sea la mariposa..

Pues puedes simplemente cambiarlo por por show_message, creo que también dice ok nada más.

Citarok = show_message("Felicidades!  Has desbloqueado un nuevo nivel!");

Pues creo que al final solo vas a usar el gml  :P. El D&D esta limitado y cuando haces algo un poco grande se pone muy engorroso, si mucho vas a usar el D&D para hacer pequeñas acciones en las que nomas tengas que arrastrar un icono.

Sobre como aprender o que aprender primero, ni idea. Yo te remendaría que si quieres un reto te vallas directo al gml, creo que te será más rápido aprender. Para aprender gml la verdad no se de ningún buen tutorial ya que nunca use uno (quizá alguien por aquí salga con uno) pero yo te recomiendo descargar ejemplos simples y buscar una por una todas las cosas que no entiendas en el manual de gm y después intentar hacer juegos simples o implementar lo aprendido (no copiando y pegando) en tu proyecto.

mmmm pues de modo sencillo sin crear un sprite creo que no se puede. "Creo" que solo es posible de manera simple transformar a negro o a blanco el color deseado, no a transparente...

MMm. Pues no es algo realmente sencillo ni eficiente en gm. Con los shaders sería increíblemente fácil...

Bueno quizá te sirva esté script sprite_replace_color.

Aquí te lo paso con una pequeñísima modificación con la que puedes añadir alpha al nuevo color.
[gml]
/*
**  Usage:
**      sprite_replace_color(sprite,oldcolor,newcolor, newalpha)
**
**  Arguments:
**      sprite      sprite to change
**      oldcolor    color that will be replaced
**      newcolor    color used as replacement
**      newalpha    alpha used as replacement
**
**  Returns:
**      (-1) on error
**
**  Notes:
**      This script replaces one color in a sprite with another.
**      No new sprites are created, the given sprite is changed.
**
**  GMLscripts.com
*/
{
    var sprite, oldc, newc, newa;
    sprite = argument0;
    oldc  = argument1;
    newc  = argument2;
    newa  = argument3;

    var w, h, n, i, xo, yo, surf, tempsprite, newsprite, alphasprite;
    w  = sprite_get_width(sprite);
    h  = sprite_get_height(sprite);
    n  = sprite_get_number(sprite);
    xo = sprite_get_xoffset(sprite);
    yo = sprite_get_yoffset(sprite);

    surf = surface_create(w,h+1);
    surface_set_target(surf);

    for(i=0; i<n; i+=1) {
        draw_clear_alpha(c_black,1);
        draw_set_blend_mode_ext(bm_inv_dest_color,bm_one);
        draw_sprite(sprite,i,xo,yo);
        draw_set_blend_mode(bm_normal);
        draw_point_color(0,h,oldc);
        tempsprite = sprite_create_from_surface(surf,0,0,w,h+1,true,false,xo,yo);
        draw_clear_alpha(newc, newa);
        draw_sprite(tempsprite,0,xo,yo);
        sprite_delete(tempsprite);
        if (i == 0) {
            newsprite = sprite_create_from_surface(surf,0,0,w,h,false,false,xo,yo);
            if (newsprite < 0) return -1;
        }else{
            sprite_add_from_surface(newsprite,surf,0,0,w,h,false,false);
        }
        draw_clear_alpha(c_white,1);
        draw_set_blend_mode_ext(bm_zero,bm_src_alpha);
        draw_sprite(sprite,i,xo,yo);
        if (i == 0) {
            alphasprite = sprite_create_from_surface(surf,0,0,w,h,false,false,xo,yo);
            if (alphasprite < 0) {
                sprite_delete(newsprite);
                return -1;
            }
        }else{
            sprite_add_from_surface(alphasprite,surf,0,0,w,h,false,false);
        }
        draw_set_blend_mode(bm_normal);
    }

    surface_reset_target();
    sprite_assign(sprite,newsprite);
    sprite_set_alpha_from_sprite(sprite,alphasprite);
    sprite_delete(newsprite);
    sprite_delete(alphasprite);
    surface_free(surf);
}
[/gml]
Entonces para borrar el rojo de la imagen sería así. sprite_replace_color(spr, c_red, c_black, 0);

Quizá una está pequeña pregunta necesite un tutorial completo para explicarse  :-X. Es raro, nunca había visto que alguien preguntará esto y según tengo entendido pocos entienden como funcionan los blending modes.

Bueno los blending modes son básicamente multiplicaciones de colores. El mismo manual de gm te lo dice, solo que se vuelve algo confuso por que usa la palabra factor

Citardraw_set_blend_mode_ext(src,dest) Indica el modo de mezcla que se debe usar para la fuente y el destino. El color resultante se calcula aplicando a cada color (fuente y destino) un factor diferente.

Bueno, primero pondré la tabla con los factores que se pueden usar con esa función.

Citar
    bm_zero: El factor de mezcla es (0, 0, 0, 0).
    bm_one: El factor de mezcla es (1, 1, 1, 1).
    bm_src_color: El factor de mezcla es (Rf, Gf, Bf, Af).
    bm_inv_src_color: El factor de mezcla es (1–Rf, 1–Gf, 1–Bf, 1–Af).
    bm_src_alpha: El factor de mezcla es (Af, Af, Af, Af).
    bm_inv_src_alpha: El factor de mezcla es (1–Af, 1–Af, 1–Af, 1–Af).
    bm_dest_alpha: El factor de mezcla es (Ad, Ad, Ad, Ad).
    bm_inv_dest_alpha: El factor de mezcla es (1–Ad, 1–Ad, 1–Ad, 1–Ad).
    bm_dest_color: El factor de mezcla es (Rd, Gd, Bd, Ad).
    bm_inv_dest_color: El factor de mezcla es (1–Rd, 1–Gd, 1–Bd, 1–Ad).
    bm_src_alpha_sat: El factor de mezcla es (f, f, f, 1); f = min(Af, 1–Ad).

Bien partamos de que los colores en 32 bits están siempre formados por 4 canales y cada uno va de 0 a 1 (en realidad de 0 a 255 pero es mucho más cómodo manejarlos de esté modo) el primero de rojo, después sigue verde, luego azul y por ultimo el canal alpha (r.g.b.a), donde en cada uno el 0 indica que no se usará ese color y el 1 indica que se usará el tono más alto de ese color (en el caso del alpha se sigue la misma lógica aunque puede ser algo diferente ya que esté no es un color).

Veamos un ejemplo, el manual de gm nos dice:

CitarPor ejemplo, el modo de mezcla normal pone la fuente a bm_src_alpha y el destino a bm_inv_src_alpha

La fuente es lo que sea que vayamos a dibujar (un sprite, poligono, texto, etc) y el destino es el fondo en el que vamos a posicionar lo que dibujaremos, es decir, lo que estaba dibujado antes.

Bueno tenemos que los valores de bm_src_alpha son (Af, Af, Af, Af) lo que nos dice que todos los canales de la fuente son multiplicados por el alpha de la fuente.

Tambien tenemos bm_inv_src_alpha (1-Af, 1-Af, 1-Af, 1-Af) que nos dice que todos los canales del destino serán multiplicados por el alpha inverso de la fuente.

Una vez multiplicados se suman los canales de la fuente y el destino.

Entonces el nuevo color usando draw_set_blend_mode_ext(bm_source_alpha, bm_inv_source_alpha)
nuevo rojo = (Rf * Af)  + (Rd * (1-Af) )
nuevo verde = (Gf * Af)  + (Gd * (1-Af) )
nuevo azul = (Bf * Af)  + (Bd * (1-Af) )
nuevo alpha = (Af * Af)  + (Ad * (1-Af) )

Y gráficamente lo puedes ver así.


Hay algo raro con esto y difícil de notar pero usando valores de alpha como 0.5 en tu fuete al ponerlo en el destino su nuevo alpha va a ser 0.25 ya que (0.5*0.5=0.25) y si haces eso en una superficie varias veces el alpha irá disminuyendo hasta ser casi cero.

Creo que el bm_add es draw_set_blend_mode_ext(bm_one, bm_one), de ese modo los colores simplemente son sumados ya que al multiplicarse por uno quedan iguales...

Hay un tutorial genial en la gmc que no pude encontrar, es algo parecido a como lo explique pero más bastante más extendido. Si lo veo lo pongo aquí, sería bueno traducirlo.

Por cierto quizá tu no necesites tanta explicación pero lo dejo así para otros usuarios.

Actualiza tu game maker. La version que se ve en la imagen que adjuntaste ya es muy vieja.

Cita de: internauta en Junio 13, 2013, 03:13:00 AM
La verdad brunoxzx, es que no se que es un shader, porque todavía no me he metido con esas cosas...

Y tampoco se que es lo del compiller   :'(


Un saludo, y gracias.

XD no te preocupes.

Bién primero que nada lo de compilacion lo explique por aquí, también puedes usar google.

Y bién lo de los shaders en realidad es muy raro que se sepá lo que son (almenos en el universo de gm). Bueno para no escribir una explicacion demaciado grande te digo que son unos pequeños programas que te permiten manipular directamente lo que dibuja la tarjeta de video, permitiendo super efectos graficos en tiempo real.

Bueno la respuesta ya te la dio mgbu pero te recuerdo que no siempre son iguales cuando usas blend modes el blanco que usas que es 100% transparente puede llegar a verse.

También hay problemas cuando en tus sprites tienes colores (cualquier valor que no sea negro) con 0 de transparencia. Esto es complicado que ya que en el editor de sprites no se ven, pero al usar la interpolación de texturas (interpolate colors between pixels) se ven y dan el aspecto de pixeles blancos o negros aparentemente aleatorios en tus sprites.

Sobre la versión 1.2. Ni idea de cuando salga pero la verdad no creo que falte demasiado, ya se ve que los shaders funcionan en windows (direct x) y en los demás sistemas que usan openGL (es importante mencionar eso ya que los shaders estan escritos en glsl y me imagino yoyo tuvo que hacer algo para que funcionen correctamente en directx). También se ha visto funcionar el yoyo compiller.

Sobre lo de los demás engines ni idea, recuerda que esta comunidad es de gm y muy probablemente todos te digamos que gm es el mejor.

En mi caso al principio aprendí empíricamente, un día aburrido y sin internet decidí ponerme a experimentar con un gm que un amigo me paso unos 15 días atrás. Desde ese día fueron unos 2 años en que aprendí sin leer o ver algún tutorial, quizá algunos pocos ejemplos que descargue de yoyo (uf al principio yoyo ni existía). Pero ese método era muy lento, con decir que tarde varios meses en descubrir las views.

Después comencé a aprender viendo ejemplos de un foro llamado yoshimaker (estos eran mejores por que estaban en español) ya de allí solo buscaba ejemplos en la web y de hecho solo me inscribí a esta pagina por sus ejemplos.

La tercera fase comenzó cuando encontré el manual de gm en español (casualmente lo encontré en yoyo y no aquí) leyéndolo aprendí a usar los fors y whiles y a buscar las funciones precisas que necesitaba. Por supuesto así comencé a aprender MUCHO más rápido.

Cabe destacar que por todo ese tiempo simplemente aprendía para poder mejorar mis juegos y prácticamente todo lo que aprendía lo aplicaba en ellos por lo que siempre practicaba lo aprendido (si te vas a poner a leer cosas como loco no olvides que tienes que poner todo lo que puedas en practica).

Después de todo eso me puse a contestar preguntas aquí y aunque no lo parezca he aprendido mucho, a veces intentado investigar para poder responder preguntas que ni yo sabia la respuesta y otras leyendo lo que escriben los usuarios grandes (por lo general tus juegos no necesitan de toda las técnicas que puede llevar un video juego y al responder o ver respuestas a preguntas seguro aprendes cosas que nunca necesitaste para un juego antes).

Al final terminas leyendo tutoriales o artículos genéricos de programación, el manual de gm se queda corto (solo sirve de referencia) al igual que la mayoría de los tutoriales escritos específicamente para gm, así que tienes que ingeniártelas para mantenerte aprendiendo y no quedarte estancado, quizá aprendiendo un nuevo lenguaje.

Sobre los video tutoriales, en lo personal los considero lentos, prefiero leer ya que te puedes pasar todo lo que ya sabes e ir al grano, pero en esencia es lo mismo que un tutorial pero en video :-[.

En fin espero te haya servido mi historia para decidir que tienes que hacer ahora.

Pues lo único que tiene mal el código es que al show message le hace falta un parentecis.

Cita de: clloses en Junio 06, 2013, 06:27:27 PM
¿Cómo pongo dinámicamente, 3 instancias de objeto en pantalla y que cada una tenga una propiedad "nombre" diferente?

Tal como lo estás haciendo usando un "." para acceder a las variables locales de una instancia en especifico.

También puedes usar la construcción "with". Se usa de esté modo.
[gml]with(vectorCajas){
     Nombre="juan";
     Tipo=wololo;
}[/gml]

Si usas el with con el nombre de un objeto y no con una instancia en especifico se hará un loop entre todas las instancias del objeto pasado. Ejemplo.
[gml]with( obj_caja ){
     Nombre="juan";
     //¡Todas las instancias de obj_caja nos llamamos juan!
     Tipo=wololo;
}[/gml]

Ni idea de lo que dices de game_end(), pero siempre puedes avisar bugs a bugs.yoyogames.com, no tardan mucho en resolverlos es importante que adjuntes un .gmx con un ejemplo del bug para facilitarles el trabajo.

Tampoco tengo idea de que suceda con la pantalla blanca, quizá sea algo de la gpu. Hay una opción en los global game settings - android - graphics que dice Device Support, allí puedes cambiar si es necesario que el dispositivo tenga una gpu para ejecutar tu juego, por defecto debe tenerla.

Tu mismo puedes revisar cuanta ram consume tu apk en alguna clase de administrador de tareas para android (creo que hay algo parecido en configuración). De allí puedes deducir si la causa es la ram.

Aquí hay un video que compara algunos engines 2d de videojuegos, entre ellos game salad y gm.
https://www.youtube.com/watch?v=3PeGbMvpz4M

Este es un extra para que tengas en cuenta que en la actualización 1.2 en la que el gml será compilado y no interpretado algunas cosas podrían ser hasta 100 veces más rápidas.
https://www.youtube.com/watch?v=VzWNZ-497C0

Cita de: Wadk en Junio 05, 2013, 08:28:52 PM
Como lo puse los eventos draw de los objetos deberían ejecutarse antes de que se ejecute el instance_create, así que debería funcionar bien, creo yo.

Ups perdón  ???. Me confundí creí que el orden del depth iba al revés (-99999 sería el primero en dibujarse y no el ultimo).