Comunidad Game Maker

Hola cristopher2545! Le podés aplicar álgebra booleana.

Lo que querés hacer es lo que haría la puerta lógica "AND". En álgebra booleana esto se expresa de esta forma:
Con dos valores:
A * B = B * A
O con tres valores
(A * B) *C = A * (B * C) = A * B * C

Aplicándolo a lo que querés hacer vos quedaría así:
[gml]//Las teclas las definís vos según tu necesidad
var tecla_a = keyboard_check(tecla);
var tecla_b = keyboard_check(tecla);
var tecla_c = keyboard_check(tecla);

//Primer caso (TECLA A + TECLA B = salto)
if (tecla_a * tecla_b){
    //Ejecutar un script de salto
    salto();
}

//Segundo caso (TECLA A + TECLA B + TECLA C = sprintar)
if (tecla_a * tecla_b * tecla_c){
    //Ejecutar un script de sprint
    sprint();
}
[/gml]

Lo que sucede es que, al presionar las teclas, las variables se actualizan a 1. Y al soltar, a 0.
Suponé que estás presionando las teclas "a" y "b":
[gml]if (tecla_a * tecla_b *tecla_c) {...}
//Es igual que:
if (1 * 1 * 0) {...} //1 * 1 * 0 = 0, que es false
[/gml]
Se tiene que presionar las 3 teclas al mismo tiempo para que ese evento se ejecute.

Te recomiendo que leas información sobre álgebra booleana. Este tema aplicado a la programación es muy útil.

Podés intentar que se cambie la posición del arma desde el objeto círculo.

Hola florgm! Podés hacer que detecte cuando el personaje está encima del bloque y que luego se destruya con una alarma. Por ejemplo:
OBJETO BLOQUE: EVENTO CREATE
[gml]puede_romperse = true; //Si puede romperse o no[/gml]
EVENTO STEP
[gml]if (place_meeting(x,y-1,obj_personaje) && puede_romperse = true){
    alarm[0] = room_speed * 1; //1 segundo hasta que se rompa
    puede_romperse = false; //Hacer que este evento no vuelva a suceder
}[/gml]
EVENTO ALARM 0
[gml]instance_destroy();[/gml]

Te dejo el proyecto donde hice la prueba por si querés hecharle un vistazo.

Lo estoy haciendo en 1280x720 (720p) para que quede en 16:9, pero me gustaría adaptarlo a otras resoluciones y aspect ratio intentando de no perjudicar mucho la calidad gráfica del juego (ya sea al comprimir los píxeles o al expandirlos).

Buenas gente! Tengo un problema con la colision vertical entre una plataforma que se vaya moviendo por el nivel y el personaje. Mi idea es que el personaje se mueva "solo" (o sea, que la plataforma le lleve) al estar encima de la misma. Horizontalmente no tengo ningún problema, pero con las colisiones verticales se me complica.
Personaje: script de colisíon:
[gml]//Colisión vertical
if (place_meeting(x,y+vsp,argument0)){
    while(!place_meeting(x,y+sign(vsp),argument0)) {y += sign(vsp);}
    vsp = 0;
    on_ground = true;
}
//Colisión horizontal
if (place_meeting(x+hsp,y,argument0)){
    while(!place_meeting(x+sign(hsp),y,argument0)) {x += sign(hsp);}
    hsp = 0;
}

//Si atravesó la hitbox en el step anterior
if (place_meeting(x,y,argument0) && last_move != -1){
    switch (last_move){
        case 0:
            while(place_meeting(x-1,y,argument0)) {x++;} //Derecha
            x -= 1;
            break;
        case 1:
            while(place_meeting(x,y+1,argument0)) {y--;} //Arriba
            y -= 1;
            break;
        case 2:
            while(place_meeting(x+1,y,argument0)) {x--;} //Izquierda
            x += 1;
            break;
        case 3:
            while(place_meeting(x,y-1,argument0)) {y++;} //Abajo
            y += 1;
            break;
    }
}

//Actualizar variable
last_move = -1;

//Si atraviesa la hitbox48x48
if (place_meeting(x,y,argument0)){
    //Actualizar variables
    x_ = x;
    y_ = y;
    y_p = 0;
    y_n = 0;
    x_p = 0;
    x_n = 0;
    //Ver qué dirección es la más corta para salir de la colisión
    while(place_meeting(x,y-1,argument0)) {y++; y_p++;} //Desde arriba
    x = x_;
    y = y_;
    while(place_meeting(x,y+1,argument0)) {y--; y_n++;} //Desde abajo
    x = x_;
    y = y_;
    while(place_meeting(x-1,y,argument0)) {x++; x_p++;} //Desde izquierda
    x = x_;
    y = y_;
    while(place_meeting(x+1,y,argument0)) {x--; x_n++;} //Desde derecha
    x = x_;
    y = y_;

    //Mover al objeto a la posición
    var result = min(y_p,y_n,x_p,x_n);
    if (y_p == result) {y += y_p-1; last_move = 3;} //Abajo
    else if (y_n == result) {y -= y_n-1; last_move = 1;} //Arriba
    else if (x_p == result) {x += x_p-1; last_move = 0;} //Derecha
    else if (x_n == result) {x -= x_n-1; last_move = 2;} //Izquierda
}
[/gml]

Plataforma: Evento CREATE:
[gml]
///VALORES GENERALES
change_state = false;
state = true; //Si se está moviendo o no
go_to = 1; //Si es 1, va desde x1, y1 a x2, y2, y si es -1 va desde x2, y2 a x1, y1.
dist = 0; //Distancia entre el punto x, y hasta el destindo
_dist = 0; //Distancia entre el punto x, y desde la salida
dir = 0; //Ángulo entre el punto A y el punto B
hitbox = instance_create(x,y,obj_hitbox48x48); //ID del objeto hitbox que se usará como hitbox de la plataforma

spd = 0;
[/gml]
Plataforma: Evento STEP:
[gml]///CONTROL DE ESTADO
dir = point_direction(x1,y1,x2,y2);
//Cambiar de estado
if (change_state){
    change_state = false;
   
    //Cambiar estado
    if (state) {state = false;}
    else {state = true;}
}

//Comprobar el estado
if (state){
    //Desde qué punto hasta qué punto
    if (go_to == 1) {dist = point_distance(x,y,x2,y2); _dist = point_distance(x,y,x1,y1);}
    else if (go_to == -1) {dist = point_distance(x,y,x1,y1); _dist = point_distance(x,y,x2,y2);}
    //Moverse
    if (_dist < 48) {spd = log10(1.1+_dist/3)*go_to}
    else if (dist < 48) {spd = log10(1.1+dist/3)*go_to}
   
    //Detenerse
    if (dist < spd || (spd < 0.1 && spd > -0.1) && _dist >= 48){
        if (go_to == 1) {x = x2; y = y2; go_to = -1;}
        else if (go_to == -1) {x = x1; y = y1; go_to = 1;}
    }
}

//Colision con el personaje
//if (place_meeting(x,y-1,obj_character)){ ANTERIOR
if (y > obj_character.y - 0.1 && place_meeting(x,y-1,obj_character)){
    obj_character.x += spd * cos(degtorad(dir));
    obj_character.y += spd * -sin(degtorad(dir));
}

//Mover la plataforma
x += spd * cos(degtorad(dir));
y += spd * -sin(degtorad(dir));

//Mover la hitbox
if (hitbox != 0){
    hitbox.x = x;
    hitbox.y = y;
}
[/gml]

Adjunto un video para que se entienda mejor mi problema.
Cuando la imagen del personaje es azul es porque está cayendo. Cuando es roja es porque está quieto o "idle".

Hola Smoke! Creo que no se puede. Estuve viendo el manual de GMS y no tiene (o no lo leí) algo como eso. Ví que hay una funcion que sirve para obtener el parent de un objeto (object_get_parent), pero no una para cambiar ese valor desde el juego. Si lo que querés es ocupar el mismo código para distintos objetos, podés usar los scripts, que siempre vienen bien.

Hola Shirohige28! Por lo que veo, tu problema puede estar en el evento create del personaje. Al comienzo de tu mensaje decís que agregás un valor relativo en la vspeed, pero en el evento de step en la imagen no se ve esa acción, así que supongo que está en el evento create. Por lo que esa acción sólo se ejecuta 1 vez, es decir, al crearse la instancia dentro de la room. Si esa acción la ponés dentro del evento step debería funcionar, ya que es en step donde las acciones se repiten constantemente.

Lo que podés hacer es poner gravedad en el evento create y comprobar la velocidad en el step:


O podés poner la velocidad vertical relativa como si fuese gravedad y la comprobación en el step:

No, solo que hay distintas formas de hacer el movimiento de un personaje, y quería saber cómo lo hacer vos. Si lo haces con D&D podés dejar imágenes de cómo está hecho, o describir el orden de las acciones.

Si te referís a hacer eso sin crear OBJETOS nuevos, entonces tenés que hacer que el jefe, al disparar, le aplique direcciones distintas a las instancias de las balas. Por ejemplo:
[gml]//Desde el objeto jefe en el evento donde dispare
var bala = instance_create(x,y,obj_bala); //Crear una instancia de uan bala y almacenar su id única en una variable "bala"
bala.direction = point_direction(x,y,obj_personaje.x,obj_personaje.y); //Darle como direccion el ángulo entre el jefe y el personaje
bala = instance_create(x,y,obj_bala); //Crear la segunda bala
bala.direction = point_direction(x,y,obj_personaje.x,obj_personaje.y) - 20; //La misma dirección, pero 20º menos
bala = instance_create(x,y,obj_bala); //Crear la tercer bala
bala.direction = point_direction(x,y,obj_personaje.x,obj_personaje.y) + 20; //La misma dirección, pero 20º más[/gml]
[gml]//Luego, desde el evento STEP de la bala...
x += cos(degtorad(direction))*5;
y += -sin(degtorad(direction))*5; //El menos va porque el eje y de gm está invertido[/gml]

En cambio, si lo querés hacer sin crear INSTANCIAS nuevas, es más complicado, ya que tenés que detectar las cajas de colisión de cada bala, procesar su movimiento, etc. Lo mejor es haciéndolo con instancias. Te recomiendo añadir el evento OTHER > OUTSIDE ROOM y hacer que se destruya la bala cuando sale de la room, para evitar que se siga procesando desde donde ya no sirve que esté.

¿Cómo es el codigo que usas para tu personaje?

¿Qué versión de GM?

Hola SantiWasho! Podés ocupar una variable para guardar la cantidad de veces que se presiona el botón que querés, y al llegar a 10 que reproduzca el sonido. Por ejemplo:
STEP
[gml]//Suponé que tenés una variable llamada "tecla" que se crea en el evento CREATE
//y digamos que querés detectar la tecla espacio.
//Cada vez que presiones esa tecla se le añade 1 a la variable.
tecla += keyboard_check_pressed(vk_space);

//Luego detectás cuando llega a 10 y reproducís el sonido
if (tecla == 10) {audio_play_sound(sonido_enojado);}[/gml]

Encontré este video que muestra cómo usar y qué aplicaciones se puede dar al desplazamiento de bits. No parece que sea algo que es indispensable, simplemente una forma distinta para hacer algunas cosas.
Operadores de desplazamiento de bits || UPV

Hola kostra! Es un poco raro ver este tema. Al menos yo no lo ví mas de 1 vez XD, pero tengo una idea de cómo se puede aplicar esto en un juego.
Imaginate que querés, en un archivo .ini, guardar los datos de los logros que consiguió el usuario. Pero hacerlo logro1 = 0; logro2 = 1; ... es muy largo y ocupa mucho espacio en el archivo, o querés hacerlo más secreto y que no se sepa cambiar eso de una forma tan obvia. Entonces podés poner algo así: logros = 65; que en binario corresponde a 1100101, teniendo en cuenta que 65 está en hexadecimal. De esta forma sabes que el usuario consiguió los logros 1, 3, 6 y 7, porque en bits se lee de derecha a izquierda.
En conclusión: Este ejemplo no te da una idea de cómo usar el desplazamiento de bits en sí :-[, pero eso ya depende del código que se necesite.

Es sólo por curiosidad :D. Sé que puede hacer cosas copadas, pero ni idea de cómo usarlas. Vi los tutoriales que me dejó Johann y entiendo mejor el tema ahora.