Comunidad Game Maker

hola makeros! hoy se me ha pasado un problema que me ha hecho quedarme de manos cruzadas jaja.. bueno, yo se que alguno de ustedes sabra:

El problema surge a traves del manejo de surfaces, lo que quiero es cortar una imagen particular de la siguiente manera


Lo que tengo hasta ahora es hasta la imagen 3, pero no se como llegar a la 4


        // vemos si la superficie existe, si no la volvemos a crear
        if (!surface_exists(surface)) surface = surface_create(radio*2,radio*2);
       
        // iniciamos la edicion del surface
        surface_set_target(surface)
            draw_clear_alpha(0,0);
            draw_circle_colour(radio,radio,radio,c_white,c_white,0);
            draw_set_blend_mode_ext(bm_dest_color,bm_zero);
                draw_sprite(sprite, 0, 0, 0)
            draw_set_blend_mode(bm_normal);
        surface_reset_target()


Otra cosa, la imagen 3 no se ve asi, se ve de esta manera:


de antemano muchas gracias, cualquier ayuda les agradecere mucho :)
si alguien me explica mejor acerca de los surfaces y los canales alpha seria mejor, o una pagina en donde se entienda realmente como funciona :P

 :o!!! verdad que usas gm8 xD!!! el codigo sirve en GMS, solo cambia los var variable = valor; por var variable; variable = valor xD

Hace poco hice un algoritmo de movimiento preciso, lo adapte y salio esto:

    /****************************************************
        precise_movement(xspeed,yspeed,obstacle)
    -------------------------------------------------------------------
        movimiento preciso con movimientos horizontal y vertical separados
    *****************************************************/
   
    // obstaculo del movimiento
    var obstacle = argument2;
   
    // obtenemos direcciones: vertical y horizontal
    var dirh = sign(argument0);
    var dirv = sign(argument1);
   
    var xspeed = argument0;
    var yspeed = argument1;
   
    // para la velocidad de precision
    var pspeed = 0;
   
    // para mover en otra direccion cuando toca la muralla
    // vemos por donde esta mas libre
    if (dirh != 0) && (dirv == 0)
    {
        var lu = 0, ld = 0;
        while (place_meeting(x+dirh,y-lu,obstacle) && (lu < sprite_height+1)) lu++;
        while (place_meeting(x+dirh,y+ld,obstacle) && (ld < sprite_height+1)) ld++;
       
        if ((lu <= sprite_height) or (ld <= sprite_height))
        and ((lu > 0) or (ld > 0))
        {
            if (lu < ld) dirv = -1;
            else dirv = 1;
            yspeed = abs(xspeed)*dirv;
        }
    }
    if (dirv != 0) && (dirh == 0)
    {
        var ll = 0, lr = 0;
        while (place_meeting(x-ll,y+dirv,obstacle) && (ll < sprite_width+1)) ll++;
        while (place_meeting(x+lr,y+dirv,obstacle) && (lr < sprite_width+1)) lr++;
       
        if ((ll <= sprite_width) or (lr <= sprite_width))
        and ((ll > 0) or (lr > 0))
        {
            if (ll < lr) dirh = -1;
            else dirh = 1;
            xspeed = abs(yspeed)*dirh;
        }
    }
   
    // loop horizontal
    while (pspeed*dirh < xspeed*dirh)
    {
        // si se encuentra un obstaculo en la velocidad_precision actual, se sale del while
        if place_meeting(x+pspeed+dirh,y,obstacle) break;
        else
        {
            // si se encuentra en una esquina, se puede doblar
            if !place_meeting(x+pspeed+dirh,y+dirv,obstacle)
            && place_meeting(x,y+dirv,obstacle)
                y += dirv;
   
            // en este caso, velocidad_precision cambia
            pspeed += dirh;
        }
    }
   
    // movemos en x
    x += pspeed;
   
    // reseteamos la velocidad de precision obtenida
    pspeed = 0;
   
    // velocidad de precision en y
    while (pspeed*dirv < yspeed*dirv)
    {
        // si se encuentra un obstaculo en la velocidad_precision actual, se sale del while
        if place_meeting(x,y+pspeed+dirv,obstacle) break;
        else
        {
            // si se encuentra en una esquina, se puede doblar
            if !place_meeting(x+dirh,y+pspeed+dirv,obstacle)
            && place_meeting(x+dirh,y,obstacle)
                x += dirh;
   
            // en este caso, velocidad_precision cambia
            pspeed += dirv;
        }
    }
   
    // movemos en y
    y += pspeed;


y la parte de control es asi (en el evento step):

   
    obstaculo = obj_solido;
   
    //---------------------------------------------------------------------------------------------------------------------------
    // ACTUALIZAR CONTROLES DE DIRECCION
    //---------------------------------------------------------------------------------------------------------------------------
   
    key_left  = keyboard_check(vk_left)
    key_right = keyboard_check(vk_right)
    key_up    = keyboard_check(vk_up)
    key_down  = keyboard_check(vk_down)
   
    //---------------------------------------------------------------------------------------------------------------------------
    // ENCONTRAR LAS DIRECCIONES
    //---------------------------------------------------------------------------------------------------------------------------
   
    // direccion horizontal
    vel_h = velocidad*(key_right - key_left)
   
    // direccion vertical
    vel_v = velocidad*(key_down - key_up)
   
    // movemos
    precise_movement(vel_h,vel_v,obstaculo);


velocidad debes crearla en el evento create... a mi me ha funcionado :)

yo encuentro que es mejor utilizar listas, ya que vas agregando datos de forma dinamica (ya que no hay un limite de elementos), o bien arreglos (si hay un limite de elementos), si fuere el caso en que utilices una cantidad limitada de elementos (por ej: n elementos para mostrar) podrias hacerlo asi:

Evento Create

// n es el numero de rondas posibles
for (var i=0; i<n; i++) rondas_ganadas[i] = -1;
ronda_actual = 0;
// el arreglo rondas_ganadas puede tener 3 posibles casos
// 0 : perdio
// 1 : gano
// -1 : indefinido aun


---

luego, para saber si ganas o pierdes(que en realidad no se como tienes tus algoritmos)

rondas_ganadas[ronda_actual] = valor; // -1, 0, 1
if (valor != -1) ronda_actual++;

donde "valor" es 0 si perdio, 1 si gano, -1 si empato

---

Deberias crear un sprite que tenga como sub-imagen 0 -> cruz, 1 -> circulo
Evento Draw

for (var i=0; i<n; i++)
{
    if (rondas_ganadas[i] != -1)
    draw_sprite(spr_xo,rondas_ganadas[i],px+w*i,py);
}


donde spr_xo es el sprite con las dos imagenes, (px,py) es el punto superior izquierdo del lugar en donde se dibujan los circulos y equis, w es la separacion entre cada imagen...

ojala que esta idea te sirva :) ... no la he probado pero me imagino que funciona si la adaptas bien
Saludos!

una variable global sirve para que puedas acceder a ella desde cualquier objeto, cuando creas una variable en el evento create estas inicializando una variable que pertenece a tal objeto y que puede ser utilizada en el mismo en todos sus eventos...

global.variable : se puede acceder a esta variable por todos los objetos del juego

variable : se puede acceder a esta variable por un mismo objeto, y desde otro objeto como objeto.variable si es que el objeto existe, OJO que solo se puede acceder a ella si ya esta creada, por eso siempre es bueno que se inicialicen en el evento create que es el momento de cuando se instancia el objeto en el room.

var variable : puede accederse a esta variable en todo el sub-programa que la contiene, si la tienes al comienzo de un evento, solo se puede acceder a ella en el evento, si la tienes dentro de un loop while o for, solo se accede a ella dentro de ese loop, como tambien sucede con un if, do...while, repeat

hay otra que es globalvar variable, pero digamos que nunca la he ocupado y no se para que sirve, tal vez en el manual salga...

espero que hayas entendido! saludos!

hola! una pregunta... sabes GML? o haces tus juegos con D&D? si no sabes GML te recomiendo que te adentres en el mundo de la programacion :)

con respecto a tu problema das a conocer muy poco como funciona tu personaje, puedes tener tus propios algoritmos para saltar y yo no se por donde empezar

hola! bueno, tu problema parece que lo acabo de entender un poco, tu dices que al momento de morir, el personaje debe ir al ultimo lugar por donde entro, por lo que se me ocurre que hagas un objeto checkpoint, y dos variables globales que guarden la posicion del ultimo objeto checkpoint tocado, asi por ejemplo, si tu personaje toco un objeto checkpoint situado en la entrada de uno de tus cuartos, la variable global cambie a la posicion de ese objeto checkpoint, no se si será algo parecido, pero yo una vez hice un checkpoint para un juego de megaman, y si tu sabes, cuando el boss te mataba, volvias a la entrada del cuarto del boss, y no se si eso es lo que quieres hacer :p

Saludos!

Hola! saludos a todos los makeros que estan en la comunidad, hoy les vengo a dejar un script muy util para mover un objeto de forma precisa solo definiendo 3 argumentos, velocidad horizontal, velocidad vertical, y obstaculo del movimiento, lo he testeado y funciona la 100 %  ;)

Creador: Fab62

---

Version de GM:  :GMS:

---

Descripción: Mueve un objeto de forma precisa, sin estancarse en el objeto obstaculo que se define en el 3er argumento, las velocidades horizontal y vertical son independientes, es decir, que si el objeto se detiene de forma vertical, puede seguir moviendose de forma horizontal y viceversa, como tambien puede doblar libremente en las esquinas, este script funciona a cualquier velocidad. Su uso sirve en cualquier evento, pero es mas util utilizarlo en el evento step.

---

Script: Consta de un solo script, y se utiliza de la misma manera que la funcion motion_add()

precise_movement(velocidad horizontal, velocidad vertical, obstaculo)

/****************************************************************************************************************************
    precise_movement(xspeed,yspeed,obstacle)
-----------------------------------------------------------------------------------------------------------------------------
    movimiento preciso con movimientos horizontal y vertical separados
****************************************************************************************************************************/

// obstaculo del movimiento
var obstacle = argument2;

// obtenemos direcciones: vertical y horizontal
var dirh = sign(argument0);
var dirv = sign(argument1);

// para la velocidad de precision
var pspeed = 0;

// loop horizontal
while (pspeed*dirh < argument0*dirh)
{
    // si se encuentra un obstaculo en la velocidad_precision actual, se sale del while
    if place_meeting(x+pspeed+dirh,y,obstacle) break;
    else
    {
        // si se encuentra en una esquina, se puede doblar
        if !place_meeting(x+pspeed+dirh,y+dirv,obstacle)
        && place_meeting(x,y+dirv,obstacle)
            y += dirv;

        // en este caso, velocidad_precision cambia
        pspeed += dirh;
    }
}

// movemos en x
x += pspeed;

// reseteamos la velocidad de precision obtenida
pspeed = 0;

// velocidad de precision en y
while (pspeed*dirv < argument1*dirv)
{
    // si se encuentra un obstaculo en la velocidad_precision actual, se sale del while
    if place_meeting(x,y+pspeed+dirv,obstacle) break;
    else
    {
        // si se encuentra en una esquina, se puede doblar
        if !place_meeting(x+dirh,y+pspeed+dirv,obstacle)
        && place_meeting(x+dirh,y,obstacle)
            x += dirh;

        // en este caso, velocidad_precision cambia
        pspeed += dirv;
    }
}

// movemos en y
y += pspeed;


Espero que les sea de utilidad en sus juegos para que no ocurran esas molestas ocasiones en donde los objetos quedan pegados... un ejemplo sencillo en la siguiente linea.

---

Ejemplo: Movimiento en 8 direcciones

---

Evento Create

velocidad = 5

Evento Step

obstaculo = obj_solido;

//---------------------------------------------------------------------------------------------------------------------------
// ACTUALIZAR CONTROLES DE DIRECCION
//---------------------------------------------------------------------------------------------------------------------------

key_left  = keyboard_check(vk_left)
key_right = keyboard_check(vk_right)
key_up    = keyboard_check(vk_up)
key_down  = keyboard_check(vk_down)

//---------------------------------------------------------------------------------------------------------------------------
// ENCONTRAR LAS DIRECCIONES
//---------------------------------------------------------------------------------------------------------------------------

// direccion horizontal
vel_h = velocidad*(key_right - key_left)

// direccion vertical
vel_v = velocidad*(key_down - key_up)

// movemos
precise_movement(vel_h,vel_v,obstaculo);


El obstaculo debe ser un objeto creado con anterioridad y debe representar el objeto solido, que tengan un buen dia y saludos!

el metodo funciona, que tengas otras cosas de por medio es otro problema, pero bueno... tu dices que englobas a tus personajes con un objeto parent, no debes inicializarlo ahi, antes de crear a tu personaje, debes darle valor la variable global.jugador que te dije, en un room anterior o no se si el cambio lo hagas en el mismo room... seria util que me dieras mas informacion de que es lo que realmente quieres hacer

puedes hacer un chequeo de quien acompaña al objeto bloque, en 4 direcciones, verificando su image_index...

script : destruir_igual()

var izquierda = instance_place(x-1,y,obj_bloque)
var derecha = instance_place(x+1,y,obj_bloque)
var arriba = instance_place(x,y-1,obj_bloque)
var abajo = instance_place(x,y+1,obj_bloque)

if (izquierda != noone) and (izquierda.image_index == image_index)
with (izquierda) {destruir_igual()}

if (derecha != noone) and (derecha.image_index == image_index)
with (derecha) {destruir_igual()}

if (arriba != noone) and (arriba.image_index == image_index)
with (arriba) {destruir_igual()}

if (abajo != noone) and (abajo.image_index == image_index)
with (abajo) {destruir_igual()}

instance_destroy()


eso es lo que se me ocurre por ahora... saludos!

para eso debes crear una variable global que identifique a que personaje utilizar, y un objeto que cree al personaje correcto en el room, por ejemplo, tienes una variable global llamada jugador:

global.jugador = "pistola"

y un objeto "selector" que crea el personaje de acuerdo a esa variable

Objeto selector

Evento create

switch (global.jugador)
{
  case "pistola" : instance_create(x,y,obj_pistola); break
  case "ak47" : instance_create(x,y,obj_ak47); break
}


y ahi tienes una forma facil de crear un objeto a traves de la informacion que contenga una variable, espero que entiendas la idea.

Saludos!

:O!! tienes un solo enemigo, entonces solo debes colocar esto :)

instance_create(x,y,obj_enemigo1);


ya que el arreglo era para cuando tienes muchos enemigos diferentes
otra cosa que se me olvido es que debes limitar "enemigos_limite" xD:


if (global.enemigos_matados >= enemigos_restantes)
{
   repeat(enemigos_limite)
   {
       randomize();
       instance_create(x,y,enemigo[irandom(enemigos_limite-1)]);
   }
   enemigos_restantes = enemigos_limite;
   enemigos_limite += ronda_aumento;

   if (enemigos_limite > enemigos_total-1) enemigos_limite = enemigos_total-1;
   
   global.enemigos_matados = 0;
   global.level++;
}


Enemigos total seria la cantidad de enemigos diferentes que quieres crear, pero como tienes 1 como que no sirve mucho que digamos el codigo xD ...

Saludos!

Por lo que supe gracias a unos amigos, el spawn es crear un objeto, bueno, lo que tu quieres es crear una cantidad, y luego de haberlos matado a todos crear otra cantidad superior a la anterior... por lo que vi, dedicas a un objeto a realizar el spawn (objeto spawn) a ver que se me ocurre...

TODO ESTO TE RECOMIENDO QUE LO AGREGUES A TU OBJETO SPAWN

hagamos que tienes un arreglo con todos los enemigos posibles (N) que se pueden crear [Evento Create]:

enemigo[0] = obj_enemigo0;
enemigo[1] = obj_enemigo1;
...
enemigo[N] = obj_enemigoN;


Ahora, tienes 2 variables globales, que encuentro que estan bien, solo cambié una a local [Evento Create]:

global.enemigos_matados  = 0;
global.level = 0;
enemigos_restantes = 0;
enemigos_limite = 6;
ronda_aumento = 2;

La variable "ronda_aumento" define cuantos enemigos más se van a crear en la proxima ronda, y la variable "enemigos_limite" será el delimitador, para lo que refiere el spawnear una cantidad de enemigos cuando todos los hayas matado.

Ahora que ya tenemos estas variables podemos spawnear como tu quieres:

Debemos crear la cantidad de enemigos por cada ronda, cuando global.enemigos_matados es mayor o igual a enemigos_restantes, quiere decir que ya has matado a todos los enemigos de la ronda, por lo que al comienzo sólo se crean

if (global.enemigos_matados >= enemigos_restantes)
{
   repeat(enemigos_limite)
   {
       randomize();
       instance_create(x,y,enemigo[irandom(enemigos_limite-1)]);
   }
   enemigos_restantes = enemigos_limite;
   enemigos_limite += ronda_aumento;
   
   global.enemigos_matados = 0;
   global.level++;
}


Ahora que ya se crearon, el objeto spawner debe esperar a que se maten a todos los enemigos creados, por lo que mantienes el evento en los enemigos cuando se destruyen (ESTO NO ESTA EN EL OBJETO SPAWN):
global.enemigos_matados += 1;

Si tienes dudas, me dices :)

Hola Makeros! ultimamente he estado realizando varios ejemplos de utilidades para el game maker, y como hace tiempo que no me adentraba al sitio estaba olvidando subirlos para que ustedes los usen en sus proyectos.

Estos scripts sirven para crear listas con elementos que se escojen con probabilidad, mientras mayor sea la probabilidad de un elemento, mayor serán las veces que se escoja ese elemento de la lista.

Creador: Fab62

---

Version de GM:  :GMS:

---

Descripcion: Elije un elemento al azar, dependiendo de una probabilidad dada por la formula:
probabilidad = factor de probabilidad * 100 / suma total de los factores probables
El factor de probabilidad es el numero que los usuarios pueden dar a la probabilidad en la lista.

---

Scripts:
Para iniciar el sistema, se necesita un contador de listas probables, aunque sea un script de una sola linea, es necesaria.
Su uso debe ser en el evento create, antes de todo script que de a conocer aqui.

probable_iniciar()
prob_count = -1;

---

Para crear una lista probable, que en si son dos listas del mismo tamaño, solo basta agregar este script:

probable_crear()

prob_count++;
prob_elements[prob_count] = ds_list_create();
prob_factors[prob_count]  = ds_list_create();
   
return prob_count;


para usarlo debe guardarse en una variable, para su uso posterior, esto tambien debe estar en el evento create:

lista = probable_crear();


---

despues de haber creado la lista, es necesario agregar los elementos:

probable_elemento(elemento, factor de probabilidad)

ds_list_add(prob_elements[prob_count],argument0);
ds_list_add(prob_factors[prob_count],argument1);


Como se puede ver, este script no necesita la variable que se guardo anteriormente, que es para guardar un identificador de la lista, ya que el contador nos proporciona esto por ahora.

---

Ya tenemos la lista creada, por lo que ahora se puede elegir un elemento al azar con la probabilidad que se le dio a cada elemento:

probable_elegir(id de la lista, comienzo, fin)
elige un elemento entre comienzo y fin
probable_elegir(id de la lista, fin)
elige un elemento entre 0 y fin
probable_elegir(id de la lista)
elige un elemento de toda la lista


// elegimos el intervalo
var pstart, pend;
if (argument_count == 1) {pstart = 0; pend = ds_list_size(prob_factors[argument[0]])-1}
else if (argument_count == 2) {pstart = 0; pend = argument[1]}
else {pstart = argument[1]; pend = argument[2]}

// para saber cual es el total de la probabilidad en el intervalo
var ptotal = 0;
for (var i=pstart; i<=pend; i++) ptotal += ds_list_find_value(prob_factors[argument[0]],i);

// semilla
randomize();

// valor aleatorio y suma parcial
var prand = irandom(ptotal);
var pparcial = 0;

// encontrando el valor
for (var i=pstart; i<=pend; i++)
{
    // reseteamos suma parcial
    pparcial = 0;
   
    // sumamos todas las probabilidades hasta la i
    for (var j=pstart; j<i; j++) pparcial += ds_list_find_value(prob_factors[argument[0]],j);
   
    // chequeamos si estamos en el rango
    if (prand >= pparcial && prand <= pparcial+ds_list_find_value(prob_factors[argument[0]],i))
        return ds_list_find_value(prob_elements[argument[0]],i);
}


---

Ya cuando no se necesiten las listas las destruimos para liberar memoria:

probable_destruir()

for (var i=0; i<=prob_count; i++)
{
    ds_list_destroy(prob_elements[i]);
    ds_list_destroy(prob_factors[i]);
}


---

Un ejemplo puede ser lo siguiente:
Evento create

probable_iniciar()

objeto = probable_crear()
probable_elemento(obj_enemigo00, 100)
probable_elemento(obj_enemigo01, 50)
probable_elemento(obj_enemigo02, 35)
...

tipo = probable_crear()
probable_elemento("normal", 50)
probable_elemento("medio", 38)
probable_elemento("dificil", 20)


Evento del click izquierdo del mouse (cuando se presiona)

var mi_objeto = probable_elegir(objeto, global.nivel);
var mi_tipo    = probable_elegir(tipo);

var instancia = instance_create(mouse_x, mouse_y, mi_objeto)
with (instancia) {tipo = other.mi_tipo}


En este ejemplo se muestra la creacion de 2 listas probables, una de objetos, y otra de sus tipos, en donde la creacion de objetos depende de una variable global.nivel

---

Bueno... eso es todo espero que les sea de utilidad para sus proyectos, no olviden darme credito si lo usan, les estaria muy agradecido.

Les agrego un .gml adjunto para que tengan todos los scripts rapidamente  ;)

Saludos y que tengan un buen dia!

Con los timelines, puedes hacer eso facilmente, creas un timeline, y en el tiempo de room_speed*2 (eso debes calcularlo) creas el objeto que quieres
Luego para activar el timeline, debes agregar el set timeline en el evento create y buscas el timeline que creaste... es una solucion a lo que preguntas :B