Comunidad Game Maker

Es un script interesante. Para hacer secuencias podrías usar la sintaxis de Matlab
a:b el incremento es 1
a:c:b el incremento es c

GMS no tiene suficiente rendimiento para programar algo así. Debería programarse como una extensión en un lenguaje diferente a GML.

Me gustan las mejoras del juego, hacer guiones se te da muy bien. Lo único que no me gusta son los colores de fondo, creo que se vería mejor con colores menos saturados y una textura que se repita.

Puedes crear un ds_map para relacionar cada room con un numero de subimagen.

Al inicio del juego crea el mapa
[gml]
global.subimg_rooms = ds_map_create();
global.subimg_rooms[? rm_nivel1] = 0;
global.subimg_rooms[? rm_nivel2] = 0;
// etc.
[/gml]

Al iniciar cada room revisa el mapa para ver qué sprite se debe dibujar
[gml]
subimagen = global.subimg_rooms[? room];
[/gml]

En vez de usar un background como textura usa un sprite con varias sub-imágenes.

En algún lugar del código asigna el sprite y la velocidad de animación
[gml]
sprite_index = spr_caminar;
image_speed = 0.3;
[/gml]

En el evento Draw obtén la textura de la sub-imagen actual
[gml]
tx = sprite_get_texture(sprite_index, image_index);

d3d_transform_set_rotation_z( obCamara.direction );
d3d_transform_add_translation( x,y,z );
d3d_model_draw(mdl, 0,0,0, tx);
[/gml]

De esa forma no se está aprovechando la utilidad del script. Cuando se detecta colisión la cámara se debe mover justo al punto donde el rayo colisiona con el muro, ese punto lo calcula el script.

Quise ver cómo funcionaba y cambié todo el ciclo while en obj_camara por esto
[gml]
c = collision_line_point(obj_player2.x,obj_player2.y, x,y, obj_colision,false,true);
if( c[0] <> noone ){
   x = c[1];
   y = c[2];
   d = point_distance(obj_player2.x,obj_player2.y, x,y) / uw;
}
z = d*uz + obj_player2.z + 35; //volver a calcular z
[/gml]

Pero después no me gustó el movimiento de la cámara al colisionar con el piso y el techo, entonces cambié todo el código de colisión
[gml]
/// Colisiones de la camara v0.2

// longitudes del vector unitario que apunta del jugador a la camara
uw = lengthdir_x( 1,elevacion);
ux = lengthdir_x(uw,direction);
uy = lengthdir_y(uw,direction);
uz = lengthdir_y(-1,elevacion);

d = distancia; //d se va a reducir si hay colisiones
z = d*uz + obj_player2.z + 35; //calcular z
if( z > 55 ){
   z = 55; //no colisionar con el techo
   d = (z - obj_player2.z - 35) / uz; //reducir d
}
if( z < 5 ){
   z = 5; //no colisionar con el piso
   d = (z - obj_player2.z - 35) / uz; //reducir d
}

// coordenadas en el plano horizontal
x = d*ux + obj_player2.x;
y = d*uy + obj_player2.y;

// detectar colision con los muros
c = collision_line_point(obj_player2.x,obj_player2.y, x,y, obj_colision,false,true);
if( c[0] <> noone ){ //si se detecta colision
   x = c[1]; //mover la camara al punto de colision
   y = c[2];
   d = point_distance(obj_player2.x,obj_player2.y, x,y) / uw; //reducir d
}
z = d*uz + obj_player2.z + 35; //volver a calcular z
[/gml]

Me gustaría explicar el código, pero hoy no tengo mucho tiempo. Todo se explica con triángulos semejantes y trigonometría.

Cosas como esta se deben planear desde el principio, para evitar que se vuelvan complicadas.
Puedes usar un código como el que se mostró anteriormente [gml]with( all )image_alpha = valor;[/gml] después usar la variable image_alpha como argumento de la función draw_sprite_part_ext

Recuerdo que GM8 incluía efectos de sonido para usar en los tutoriales, podrías descargar GM8 junto con los sonidos. En GMS puedes ir a la pestaña Tutoriales y descargar varios tutoriales con sonidos, creo que muchos son los mismos de GM8.

Cambia draw_sprite_part por draw_sprite_part_ext donde se puede controlar la opacidad/transparencia.

Pensé que collision_line devolvía true o false, pero devuelve el id de una instancia encontrada en la colisión. Modifiqué dos líneas
[gml]
c = collision_line(x,y, obj_player2.x,obj_player2.y, obj_colision,false,true);
if( c == noone )break; //si no hay colision, terminar bucle
[/gml]

Modifiqué otros detalles: La colisión de la cámara ahora se revisa en End Step, el personaje se dibuja con un modelo, se cambiaron dos signos de la función que dibuja el piso para poder usar d3d_set_culling(true) sin problemas, el background del que se obtiene la textura del personaje ya no está invertido. Archivo gmz adjunto.

Me di cuenta de que este método de reducir la distancia no se ve muy bien, el cambio de distancia se hace escalonado. Para mejorarlo se puede usar un script que devuelva el punto de colisión con el muro de un rayo imaginario que va del personaje a la cámara. Se pueden usar dos métodos:
https://yal.cc/gamemaker-collision-line-point/
http://gmc.yoyogames.com/index.php?showtopic=479678

El problema es que las instancias que tienen una animación de oscilación se dibujan con un script, debes modificar el script para que se pueda indicar el nivel de opacidad.

Es por esto: obj_player2.z. El objeto no tiene definida la variable z, simplemente cambia esa parte por 16 (es el valor que usé en otros lugares del código), o define la variable z en obj_player2 (si después quieres hacer que el personaje salte vas a necesitar esa variable).

Esa imagen se ve muy bien, tengo ganas de probar el juego.

Supongo que los muros son bloques en el editor de rooms. Lo más fácil que se me ocurre es usar la función collsion_line para ver si hay un muro entre el jugador y la cámara, si es así, la distancia se reduce hasta que ya no hay colisión. Se pueden usar métodos más optimizados, pero más complicados, creo que esto debe funcionar bien. Hay que eliminar la parte que calcula las coordenadas cartesianas en el ejemplo anterior y sustituirla por esto:
[gml]
// longitudes del vector unitario que
// apunta del jugador a la camara
uw = lengthdir_x(1 ,elevacion);
ux = lengthdir_x(uw,direction);
uy = lengthdir_y(uw,direction);
uz = lengthdir_y(1 ,elevacion);

r = distancia;
c = true; //condicion

// repetir hasta que la linea que va de la camara al jugador este libre de
// colision, o se alcance la distancia minima entre la camara y el jugador
while( true ){
  //calcular posicion
  x = r*ux + obJugador.x;
  y = r*uy + obJugador.y;
 
  if( r <= 10 )break; //si se alcanza la distancia minima, terminar bucle
 
  c = collision_line(x,y, obJugador.x,obJugador.y, obMuro,false,true);
  if( c == false )break; //si no hay colision, terminar bucle
  else r -= 10; //si hay colision, disminuir la distancia
}
z = r*uz + obJugador.z; //calcuar posicion faltante
if( z > 50 )z = 50; //no colisionar con el techo
[/gml]

¿Sigues usando el ciclo with(all) o el código está en todas las instancias?

Para dibujar el personaje se pueden usar varios métodos. Uno es dibujar con d3d_draw_wall:
[gml]
// calcular extremos
x1 = x + lengthdir_x(8, obCamara.direction + 90);
y1 = y + lengthdir_y(8, obCamara.direction + 90);
x2 = x + lengthdir_x(8, obCamara.direction - 90);
y2 = y + lengthdir_y(8, obCamara.direction - 90);
z1 = 0;
z2 = 16;

// dibujar plano
d3d_draw_wall( x1,y1,z1, x2,y2,z2, tex,1,1 );
[/gml]

Otro es usar un modelo y transformaciones:
[gml]
// Evento Create
// Modelo
mdl = d3d_model_create();
d3d_model_wall( mdl, 0,-8,0, 0,8,16, 1,1 );
[/gml]
[gml]
// Evento Draw
d3d_transform_set_rotation_z( obCamara.direction );
d3d_transform_add_translation( x,y,0 );
d3d_model_draw( mdl, 0,0,0, tex );
d3d_transform_set_identity();
[/gml]

Dejo un ejemplo adjunto. Camina con WASD, y con M se cambia entre los dos métodos.