Comunidad Game Maker

Hola Luis En! Creo que podés intentar esto:


//Colision horizontal
if (place_meeting(x+hspeed,y,obj_hitbox)){
    while (!place_meeting(x+sign(hspeed),y,obj_hitbox)) {x += sign(hspeed);}
    hspeed = 0;
}

//Colision vertical
if (place_meeting(x,y+vspeed,obj_hitbox)){
    while (!place_meeting(x,y+sign(vspeed),obj_hitbox)) {y += sign(vspeed);}
    vspeed = 0;
}


Analizando el código (hortizontal):

if (place_meeting(x+hspeed,y,obj_hitbox))
Esto detecta si en x + la velocidad horizontal hay un obj_hitbox. Entonces:

while (!place_meeting(x+sign(hspeed),y,obj_hitbox)) {x += sign(hspeed);}
Mientras no esté tocando al objeto en x + sign(hspeed) [Lo que hace sign es tomar un número, en este caso hspeed, y devolver su signo. Si hspeed es -3, entonces devuelve -1.], entonces a x le añade 1 en la dirección del hspeed. Luego:

hspeed = 0;
Cambia la velocidad horizontal a 0.

Sucede lo mismo en la vspeed.

Este código tiene un error en las colisiones diagonales, pero siempre fue el que yo usé.
Espero que te sirva!

Hola Luis En! Podrías intentar esto:

En el evento keyboard:
if (place_meeting(x, y+1, [objeto] )) { vspeed = -6; }

Espero que te sirva! :D

Hola elmmertonw! Lo que sucede es que se juntan los códigos y te da un mal resultado. Me explico:

Vamos a ver sólo esta parte del código:
if (keyboard_check(vk_up) and !place_empty(x,y-19)) {vspeed=-3;} else {vspeed=0;}
if (keyboard_check(vk_down) and !place_empty(x,y+19)) {vspeed=3} else {vspeed=0;}

Supongamos que presionas la flecha de arriba. El código que detecta esa tecla hace que tu personaje tenga una vspeed de -3, pero el que detecta la tecla hacia abajo lo cambia a 0, ya que al no presionarse la flecha de abajo se ejecuta el else.
Lo mismo acá:
if (keyboard_check(vk_left) and !place_empty(x-19,y)) {hspeed=-3} else {hspeed=0;}
if (keyboard_check(vk_right) and !place_empty(x+19,y)) {hspeed=3} else {hspeed=0;}

Podés cambia el código por esto:
//Direcciones
//Horizontales
hspeed = (keyboard_check(vk_right) - keyboard_check(vk_left)) * 3;
//Verticales
vspeed = (keyboard_check(vk_down) - keyboard_check(vk_up)) * 3;

//Comprobar que colisione contra el objeto
//Horizontalmente
if (place_empty(x+hspeed, y)) {hspeed = 0;}
//Verticalmente
if (place_empty(x, y+vspeed)) {vspeed = 0;}

En hspeed, el cálculo que hace es el siguiente:
Si se presiona una tecla es 1 y si no se presiona es 0. Por ejemplo, si se presiona la tecla derecha y no la izquierda sucede esto:
hspeed = (1 - 0) * 3;
Entonces queda hspeed = 3;

También al no presionar la derecha y si la izquierda:
hspeed = (0 - 1) * 3;
hspeed = -3;

Son muy importantes los paréntesis entre el "(keyboard_check(vk_down) - keyboard_check(vk_up))". Sin ellos queda así:
Izquierda:
hspeed = 0 - 1 * 3;
hspeed = -3;

Derecha:
hspeed = 1 - 0 * 3;
hspeed = 1;
Sucede lo mismo en el vspeed.

Y en las colisiones:
if (place_empty(x+hspeed, y)) {hspeed = 0;}
Si está vacío en x+hspeed pone la hspeed en 0. El x+hspeed funciona con las dos direcciones:
Derecha:
if (place_empty(x+3, y)) {hspeed = 0;}
Izquierda:
if (place_empty(x-3, y)) {hspeed = 0;}
Y lo mismo en las verticales.

Espero que te sirva! :D

Hola Marcusmaniacus! Te doy un consejo: Fijate en la parte de abajo de la ventana del código, te dice lo que requiere la función para ser usada de forma correcta. Te dejo una imagen para que lo veas.
En este caso dice instance_destroy([id], [execute_event_flag]). Al estar en corchete quiere decir que lo que pongas dentro es opcional. Si la función la ponés vacía en un objeto, elimina sólo ese objeto de la room. Si queres usar esa función desde otro objeto, necesitas su id. Ésta puede ser obtenida desde un evento de colisión con otro objeto con la función "other". Por ejemplo: Se choca una bala contra una pared:
    instance_destroy();         //Destruye la bala
    instance_destroy(other); //Destruye la pared
La función other devuelve el valor de la ID del otro objeto con el que se colisiona.
Si ponés instance_destroy(Obj_Personaje_De_Marco), estarías quitando a todos esos objetos del nivel, ya que no hacés referencia a un sólo objeto, si no a todos los que hayan en el nivel (aunque esto no se puede hacer en game maker).

Otra forma es como dice BssString, pero con un pequeño cambio:
Si se usa with (Obj_Personaje_De_Marco) {instance_destroy();} sucede lo de eliminar a todos los Obj_Personaje_De_Marco del nivel, no solo a uno. Por lo tanto, se puede cambiar por la función other:
with (other) {instance_destroy();}

Recordá que lo que configurás en game maker, los objetos, son "padres", y al usarlos en el juego pasan a ser "hijos", que son copias de ese padre con las características que configuraste heredadas. Pero cada hijo tiene una variable "id" que devuelve su id como objeto, ya que no pueden haber 2 objetos con la misma id.
Para explicarlo de otra forma, si tenés un objeto padre "manzana", podés decir que es rojo, grande y comestible. Los hijos tendrán características distintas. Heredan las propiedades (rojo, grande y comestible en este caso), pero pueden modificarse, agregarse o quitarse algunas propiedades. Por ejemplo, uno de los hijos puede ser rojo, mediano, comestible y mordida, y otro puede ser rojo, grande, no comestible y podrida. Por lo tanto, al configurar esto tenés que ver si querés eliminar a todos los objetos o sólo a uno.

Otra cosa, lo de Obj_Personaje_De_Marco.destroy() no es posible. Eso sólo funciona con variables, no con funciones.

Creo que me extendí mucho  XD

Espero que te sirva!   :D

Hola Felicito! Te recomiendo este video que muestra sobre cómo hacer escenas automáticas para un RPG, pero también muestra sobre cómo hacer esos efectos de un diálogo que se muestra letra por letra. Creo que eso último puede interesarte.

https://www.youtube.com/watch?v=YxUydlLhCxI

Espero que te sirva!

0,0 es la coordenada en la room, si no se debería usar las variables "x" e "y".

Hola somnus! Deberías usar una "mask" en el objeto de tu jugador. Para usar una, tenés que crear un sprite con la hitbox que querés para el personaje (hay otras formas, pero yo siempre lo hice así) y en el objeto de tu jugador, debajo de la profundidad, dice parent y  mask. En mask usás el sprite de la hitbox.

Saludos!

Hola jpsaenz! Supongo que ese objeto tiene puesto un sprite, y que al cliquearlo en la room lo seleccionas. Te doy 2 soluciones:

1) Mantener la forma en la que estás haciendo ese efecto
En el objeto de tu jugador (digo el del jugador porque lo más probable es que en los niveles que necesites ese efecto va a estar presente el jugador, quizás en el menú principal no lo necesites), en el evento create, podés poner:
instance_create(0,0,[objeto]);
y eliminar el objeto de la room donde editás el nivel.

2) Hacer el efecto por código
En el evento draw de tu objeto para el efecto podés poner:

///DRAW
//Características del efecto
draw_set_color(c_black); //El color del efecto. Si querés hacer el efecto de oscuridad, supongo que vas a usar el color negro :v
draw_set_alpha([alpha]); //La opacidad del efecto. 1 máximo, 0 mínimo

//Dibujar el rectángulo
//Lo de view es por si usas views, si no probá estos valores: 0,0,room_width,room_height
draw_rectangle(view_xview[0],view_yview[0],view_wview[0],view_hview[0],false);


No probé el código, pero debería funcionar.

Espero que te sirva

Hola jpsaenz! Lo que podés hacer es esto:

Cuando presionas la tecla arriba:
///Step

//Mirar en diagonal
//Arriba izquierda
if (sprite_index == [sprite] && keyboard_check(vk_up)){
    sprite_index = [sprite];
}
//Arriba derecha
else if (sprite_index == [sprite] && keyboard_check(vk_up)){
    sprite_index = [sprite];
}
//Al soltar las teclas
if (keyboard_check_released(vk_up)){
    switch (sprite_index){
        case spr_upleft: sprite_index = [sprite]; break;
        case spr_upright: sprite_index = [sprite]; break;
    }
}


Donde dice [sprite] reemplazalo por el nombre del sprite correspondiente.

Te dejo un archivo adjunto por si lo necesitas ver.
Espero que te sirva!

Hola Reaper! Supongo que lo que necesitás es que tu personaje se mueva hasta el cursor al hacer clic en algun lugar de la pantalla.
Te dejo un video que explica eso:

Movimientos inteligente estilo RPG Tutorial GameMaker
https://www.youtube.com/watch?v=FcxZ2zXex2M

Hola MateG_. Ya estuve viendo algunos videos sobre el tema y se me fue aclarando. Gracias por la ayuda!!

Hola Sr.Mojon!

Este efecto se activa apenas se crea el objeto.
En el evento CREATE:
//El tiempo de vida máximo del objeto
time_max = 5 * room_speed;
/*
El tiempo de vida del objeto.
Si tu room_speed = 30, será de: 1 seg = 30 steps.

En este caso son 30 steps, por lo tanto durará 10 segundos.
ya que se debe multiplicar la cantidad de segundos que queremos
que dure el efecto por la velocidad de la room.
*/



//Usado como reloj
time = time_max;

En el evento STEP:
time--; //Bajar el contador

//Destruír el objeto si el contador llega a 0
if (time == 0) {instance_destroy();}

En el evento DRAW:
//Dibujar un efecto de desvanecimiento
draw_set_alpha(time/time_max);

//Dibujar el sprite del powerup
draw_sprite(spr_powerup,0,x,y);

//Dejar al valor alpha en 1 para que no afecte a otros objetos
draw_set_alpha(1);


Otro tipo de efecto es que se active cuando queden unos pocos segundos de vida al objeto. Para hacerlo cambia el código anterior en DRAW por este:
//Variable para cuando comience el efecto
//Nos seguimos refiriendo al tiempo en segundos multiplicado por la room_speed
var effect_time = 3 * room_speed;

//Si el tiempo restante es menor al tiempo donde comienza el efecto
if (time < effect_time){
    draw_set_alpha(time/effect_time);
}


//Dibujar el sprite del powerup
draw_sprite(spr_powerup,0,x,y);

//Dejar al valor alpha en 1 para que no afecte a otros objetos
draw_set_alpha(1);

Te adjunto un proyecto con el efecto hecho.
Espero que te sirva :)

Pude solucionar el error. Gracias por la ayuda!! :D

Dale, gracias por la ayuda :D.

Este es el evento create del cliente:
//Variables de conexion multiplayer
socket = 0;
ip = 0; //La IP se elige con una función en el evento step, al igual que el port
port = 0;
socket_type = network_create_socket(network_socket_tcp);
global.client_id = -1;

//Lista de instancias y jugadores
player_list = ds_list_create();
instance_list = ds_list_create();

Este es el evento STEP:
if (keyboard_check_pressed(vk_enter)){
//Conectarse al servidor
network_connect(socket_type,ip,real(port));
room_goto(rm_play_mp)
}

//////////////
//NETWORKING//
//////////////
//Enviar los datos al servidor
if (room == rm_play_mp){
    var package = buffer_create(64, buffer_grow, 1);
    key_left = keyboard_check_pressed(ord("A"));
    key_right = keyboard_check_pressed(ord("D"));
    key_jump = keyboard_check_pressed(vk_space);
   
    buffer_write(package, buffer_bool, key_left);
    buffer_write(package, buffer_bool, key_right);
    buffer_write(package, buffer_bool, key_jump);
    network_send_packet(socket_type, package, buffer_tell(package));
}

Este en el evento NETWORKING:
var type_data = async_load[? "type"]
if (type_data = network_type_data){
    //Leer los datos recibidos
    var buffer = async_load[? "buffer"];
    buffer_seek(buffer, buffer_seek_start, 0);
    scr_received_packet(buffer);
}

Y este el script. Está separado por partes según la variable "pack_id":
///scr_received_packet(buffer);
var buffer = argument0;

//Si el jugador reciés se conecta, debe recibir un paquete de información especial
if (global.client_id < 0){
    global.client_id = buffer_read(buffer, buffer_u8);
    var players = buffer_read(buffer, buffer_u8);
   
    for(i=0;i<players;i++){
        var inst = instance_create(0,0,obj_other_player);
        var socket = buffer_read(buffer, buffer_u8);
        ds_list_add(player_list, socket);
        ds_list_add(instance_list, inst);
    }
}

//Si el jugador ya está conectado, recibir información de la partida
else {
    //Identificar el tipo de dato recibido. 0 es de la partida, 1 es la conexión de un nuevo usuario, 2 es la desconexión de un usuario
    var pack_id = buffer_read(buffer, buffer_u8);
   
    //Si es información de la partida
    if (pack_id == 0){
        var players = buffer_read(buffer, buffer_u8);
        //Repetir esta acción según la cantidad de usuarios conectados
        for(i=0;i<players;i++){
            //Obtener el identificador de cliente
            var player_id = buffer_read(buffer, buffer_u8);

            //Si el identificador de cliente es el mismo que el cliente, entonces aplicarlo a la instancia jugador
            if (player_id == global.client_id){
                obj_player.x = buffer_read(buffer, buffer_u16);
                obj_player.y = buffer_read(buffer, buffer_u16);
            }
            //Si no es el mismo, entonces aplicarlo a las instancias "otros jugadores"
            else {
                var pos = ds_list_find_index(player_list, player_id);
                var inst = ds_list_find_value(instance_list, pos);
       
                inst.x = buffer_read(buffer, buffer_u16);
                inst.y = buffer_read(buffer, buffer_u16);
            }
        }
    }
    //Si es la conexión de un nuevo usuario
    else if (pack_id == 1){
        var inst = instance_create(0,0,obj_other_player);
        var player_id = buffer_read(buffer, buffer_u8);

        //Añadir en la lista de jugadores la nueva id del nuevo cliente
        ds_list_add(player_list, player_id);
        //Añadir en la lista de instancias la ID de la nueva instancia
        ds_list_add(instance_list, inst);
    }
    //Si se desconecta un jugador
    else if (pack_id == 2){
        var pos = buffer_read(buffer, buffer_u8);

        //Eliminar de las listas en la posicion recibida
        ds_list_delete(player_list, pos);
        ds_list_delete(instance_list, pos);
    }
}

Acabé de darme cuenta que en el evento networking del servidor estaba leyendo un buffer llamado buffer, pero busca uno llamado data. Arreglé eso, pero no me solucionó el problema  :-[.

Si, eso lo tengo.

Este es el código en el evento create del servidor:
//Características del servidor
port = 1024;
max_user = 8;
type = network_create_socket(network_socket_tcp);

//Crear el servidor
server = network_create_server(type, port, max_user);

//Si no se pudo crear el servidor
while (server < 0){ //Mientras no sea creado
    server = network_create_server(type, port, max_user);
    port++; //Cambiar el port aumentándolo en 1
}



//Características del servidor ya creado
player_list = ds_list_create();
instance_list = ds_list_create();

Esto es el evento NETWORKING:
//Tipo de evento a ejecutar
var type_event = ds_map_find_value(async_load, "type");

//Operaciones según el evento
switch (type_event){
    case network_type_connect:
        //Tomar el socket del jugador que se conecta
        var client = ds_map_find_value(async_load, "socket");

        //Añadir el socket del jugador a la lista de jugadores
        ds_list_add(player_list, client);

        //Enviar el identificador de cliente al cliente conectado (Client ID)
        var package = buffer_create(64, buffer_grow, 1);
        var players = ds_list_size(player_list)-1;

        buffer_write(package, buffer_u8, client);
        buffer_write(package, buffer_u8, players);
        for(i=0;i<players;i++){
            var player_id = ds_list_find_value(instance_list, i);
            buffer_write(package, buffer_u8, player_id);
        }
        network_send_packet(client, package, buffer_tell(package));

        //Enviar la información a los otros clientes sobre el nuevo usuario
        var package2 = buffer_create(64, buffer_grow, 1);
        buffer_write(package2, buffer_u8, 1);      //El valor es 1 porque significa un nuevo usuario conectado
        buffer_write(package2, buffer_u8, client); //Enviar la ID del cliente conectado
        network_send_packet(client, package, buffer_tell(package));

        //Crear un jugador en la sala
        var inst;
        inst = instance_create(obj_spawn_player.x, obj_spawn_player.y, obj_player);
        //Añadir la instancia a la lista de instancias
        ds_list_add(instance_list, inst);
        break;

    case network_type_disconnect:
        //Remover al jugador de la lista de jugadores
        var socket = ds_map_find_value(async_load, "socket");
        var position = ds_list_find_index(player_list, socket);

        //Remover la id de la lista
        ds_list_delete(player_list, position);
        //Remover la instancia y la id de la instancia de la lista
        with (ds_list_find_value(instance_list, position)) {instance_destroy();}
        ds_list_delete(instance_list, position);

        //Enviar la información a los demás clientes sobre el usuario desconectado
        //for(i=0;i<ds_list_size(player_list);i++){
            var package = buffer_create(64, buffer_grow, 1);
            buffer_write(package, buffer_u8, 2); //Es 2 porque significa que un usuario se desconectó
            buffer_write(package, buffer_u8, position);
            network_send_packet(type, package, buffer_tell(package));
        //}
        break;

    case network_type_data:
        //Leer los datos recibidos
        var data = ds_map_find_value(async_load, "buffer");
        buffer_seek(data, buffer_seek_start, 0);
        scr_received_packet(buffer);
        break;
}

Y este es del evento STEP:
var players = instance_number(obj_player);
if (players > 0) {
    var package = buffer_create(64, buffer_grow, 1);
    //Enviar el tipo de dato que se va a enviar. En este caso, informacion de la partida (0)
    buffer_write(package, buffer_u8, 0);
   
    //Enviar la cantidad de jugadores que hay en partida
    buffer_write(package, buffer_u8, players);

    for(i=0;i<players;i++){
        //Enviar todos los datos en orden de la lista de jugadores
        var socket = ds_list_find_value(player_list, i);
        var inst = ds_list_find_value(instance_list, i);
        buffer_write(package, buffer_u8, socket);  //Identificador de cliente
        buffer_write(package, buffer_u16, inst.x); //Posición x
        buffer_write(package, buffer_u16, inst.y); //Posición y
    }
    network_send_packet(type, package, buffer_tell(package));
}

Este es el script que recibe los datos:
///scr_received_packet(buffer);
var buffer = argument0;

//Comprobar el ID del cliente
var pack = buffer_read(buffer, buffer_u8);

//Analizar a qué instancia corresponde esa ID
var position = ds_list_find_index(instance_list, pack);

//Aplicar los datos recibidos a la instancia
with (ds_list_find_value(instance_list, position)){
    //Leer las teclas que presiona el cliente
    var key_left = buffer_read(buffer, buffer_bool);
    var key_right = buffer_read(buffer, buffer_bool);
    var key_jump = buffer_read(buffer, buffer_bool);
}