Comunidad Game Maker

como dice el titulo cual seria la manera correcta de implementar la variable z en nuestros juegos 2d.
la forma mas simple que se me ocurrio fue con ds_grid pero la verdad no tengo ni idea sobre como usar eso.
la otra forma fue con lo que ya se usar osea place_meeting() y colisiones la verdad no consegui malos resultados pero tal vez exista una mejor manera de hacerlo
le agradezco por adelantado cualquier tip o ayuda y de paso le dejo el proyecto por si quiere echarle un vistazo.

isoScurge.gmx : https://drive.google.com/file/d/1enj_6AlgyDDuZ1Cen5URCerK-Ktc2Ev4/view?usp=sharing

Hola a todos espero tenga un buen dia, tengo esta duda como convertiria este script en un script de GM2
[gml]
var initAngle,numbBullets,bulletAngle;
initAngle=argument0;
numbBullets=argument1; 
bulletAngle=360/numbBullets;

for(var i=initAngle; i<initAngle+360;  i+=bulletAngle){
    var thisBullet= instance_create(x, y, objBullet);
    thisBullet.sprite_index=sprBull0;
    thisBullet.direction=i;
    thisBullet.speed=2;
}
[/gml]

Hola tengo esta duda cual es la manera correcta de implementar zoom al juego, yo lo hago de le siguiente manera(mirar mas abajo).
Entonces me surgio una duda sera esta la manera correcta de realizarlo, que problemas me podria generarar al hacerlo de esta manera
pregunto por que he estado mirando tutoriales sobre el tema y lo hacen de manera diferente
bueno eso es todo si podria aclararme esa pequeña duda se lo agradezco por adelantado...

zoom the easy way:
[gml]
///OBJETO CAMARA
//event create
viewWidth=320;  //ancho de su view
viewHeight=240; //largo de su view
zoom=1;         //escalado de su view
target=0;       //que jugador perseguir
//zooming view
view_wview[0]=viewWidth*zoom;
view_hview[0]=viewHeight*zoom;

//evento Step
//ZOOM-OUT
if(keyboard_check(ord("Z"))){
    zoom+=0.1;
    view_wview[0]=viewWidth*zoom;
    view_hview[0]=viewHeight*zoom;
}
//ZOOM-IN
if(keyboard_check(ord("X"))){
    zoom-=0.1;
    view_wview[0]=viewWidth*zoom;
    view_hview[0]=viewHeight*zoom;
}

//evento End Step
//ASSIGNAR CAMARA A LIDER
var setLeader=instance_nearest(x+64,y,parPlayers);
//SEGUIR AL JUGADOR
if(instance_exists(objPlayer1) || instance_exists(objPlayer2)){
    target=setLeader;
   
    //clampear view al jugador y limites de la room
    var xvf=clamp(target.x-viewWidth*zoom/2,0,room_width*10-viewWidth);
    var yvf=clamp(target.y-viewHeight*zoom/2,0,room_height-viewHeight);
   
    //velocidad de la view
    var sv=0.5;
   
    //actualizar posicion de nuestra camara
    view_xview[0]=lerp(view_xview[0],xvf,sv);
    view_yview[0]=lerp(view_yview[0],yvf,sv);
}
//ACTUALIZAR POSICION OBJETO CAMARA
x=view_xview;
y=view_yview;
[/gml]

Zoom In/out View:
[spoiler]

[/spoiler]
Zoom In/Out Surface:
[spoiler]

[/spoiler]
Zoom In/Out Surface+View:
[spoiler]

[/spoiler]

Autor del script: Jeffrey Faper
Nombre del script: scrGetSprite();
Breve descripción de su función: ayuda a controlar nuestras animaciones en 8 direcciones sin usar mucho IF.
Versiones usadas: Game Maker 1.4 .
Versión del script: 1.0;

Le ha pasado que esta creando un juego donde el jugador se mueve o apunta en 8 direcciones y de repente
se da cuenta que todo su codigo esta lleno de esto:
[gml]
if(direction==0)if(direction==45)if(direction==180)if(direction==0.20)if(direction==45)if(direction==0*25/0)if(direction==0)if(direction==45)if(direction==0)
if(direction==0)if(direction==45)if(direction==1200)if(direction==0.90)if(direction==45)if(direction==0)if(direction==0)if(direction==45)if(direction==0)
if(direction==0)if(direction==45)if(direction==1300)if(direction==010)if(direction==45)if(direction==0)if(direction==0)if(direction==45)if(direction==0)
if(direction==0)if(direction==45)if(direction==1200)if(direction==0.90)if(direction==45)if(direction==0)if(direction==0)if(direction==45)if(direction==0)
[/gml]
Bueno pos pare de sufrir que aqui le traigo una solucion simple a este problema.

Tutorial Como Usar el script:

1 - Primero necesitamos saber  en que  direccion esta apuntando o moviendose el jugador y lo haremos con las siguientes variables
[gml]
//EVENTO CREATE JUGADOR
/*
podemos usar estas variables, si usted quiere puede cambiarles el nombre o si ya tiene una variable que haga lo mismo
simplemente cambie la variable aiming del script por la suya..
*/
horMove=0;
verMove=0;
aiming=0;  //almacenara las 8 direcciones que serian 0, 45, 90, 135, 180, 225, 270, 315..
[/gml]

2 - En el evento step del jugador pondremos lo siguiente
[gml]
//ESTE CODIGO NOS DIRA EN QUE DIRECCION ESTA APUNTANDO O MOVIENDOSE EL JUGADOR
horMove=(-keyboard_check(vk_left)+keyboard_check(vk_right));
verMove=(-keyboard_check(vk_up)+keyboard_check(vk_down));
if (horMove!=0 || verMove!=0){
    aiming=point_direction(0,0,horMove,verMove);
}
[/gml]

Algo de debug para ver que todo funcione bien
[gml]
//DRAW_GUI EVENT
draw_set_colour(c_red);
draw_text(176,64,
"PLAYER 1"
+"#AIMING :"+string(aiming));
[/gml]


3 - Ahora ya podemos usar nuestro script el cual consta de un array que almacenara las 8 direcciones y su correspondiente sprite
ademas dividira las direcciones almacenadas en la variable aiming entre 45 para obtener el index del array y asi dibujar el sprite que deseado...
scrGetSprite():
[gml]
///scrGetSprite(0,45,90,135,180,225,270,315);
var sprArray;
var sprIndex;
var index;

index=floor(aiming/45.0);

sprArray[0]=argument0;
sprArray[1]=argument1;
sprArray[2]=argument2;
sprArray[3]=argument3;
sprArray[4]=argument4;
sprArray[5]=argument5;
sprArray[6]=argument6;
sprArray[7]=argument7;

sprIndex=sprArray[index];

return sprIndex;
[/gml]

Para finalizar un ejemplo de como usarlo,  como puede ver yo estoy usando una variable llamada sprindex por que estoy dibujando el personaje
con las funciones de dibujo de Game Maker - draw_text_ext() si usted usa sprite_index lo llamaria de la misma manera
sprite_index=scrGetSprite(sprAttack0, sprAttack45, sprAttack90, );
[gml]
//ESTADO CORRER DE  MI PERSONAJE
//RUNNING
    if(horMove<>0){     
        maxspdx=1.95375;
        //corriendo
        if(!shooting){
            imgspd+=0.2;
            sprindex=scrGetSprite(sprR_0180,sprR_45135,sprShootUp,sprR_45135,sprR_0180,sprR_225315,sprDuckShoot,sprR_225315);
        }
       //corriendo y disparando
        if(shooting){
            imgspd+=0.4;
            sprindex=scrGetSprite(sprRS_0180,sprRS_45135,sprShootUp,sprRS_45135,sprRS_0180,sprRS_225315,sprDuckShoot,sprRS_225315);
        }
    }
[/gml]


si tiene dudas o hay algun error no dude en comentar xd..

Alguien sabe como hacer esto . me refiero a la curvatura que hace la granada

Pues como dice el titulo alguien sabe como puedo hacer ese tipo de acciones usadas muy frecuentemente en juegos de konami.
ya tengo rampas de techo con objetos solidos y funcionan bien,  pero la verdad  no se como implementarlo con objetos a los cuales puedo atravesar desde cualquier lado les dejo  un ejemplo para que se de una mejor idea sobre lo que estoy hablando...

Estaba intentando recrear las fisicas de sonic,  para usarlas en enemigos tipo tanque que puedan aderirse al terreno, pero falle rotundamente
me decidi a buscar algun tutorial y la verdad no hay mucho de donde escoger  los pocos que encontre me dieron algunos errores
asi que si alguien sabe como implementar ese tipo de colisiones se le agradece su ayuda.

Solucionado este tutorial me ayudo a entender un poco como funcionan las colisiones en un juego de Sonic
https://www.youtube.com/watch?v=LCakJ0gjP1A
sanicPro_Test.gmz : https://drive.google.com/file/d/1IzHJcs9VWH3tcFfbI_7ltnxxSC8FGoTD/view?usp=sharing


Surgio este error que hace que nuestro tanque tenga ganas de hacer piss.


para solucionarlo  solo hay poner estas condiciones en el scrFindAngle
[gml]
while(k>0){
    if(!done1){
        if(hspd<>0 && collision_point(x1,y1,parSolid,1,1))
        ||(hspd<>0 && collision_point(x1,y1,parOneway,1,1)){
            done1=1;
            }
        if(onGround){
            x1+=asin;
            y1+=acos;
            }
        }
    if(!done2){
        if(hspd<>0 && collision_point(x2,y2,parSolid,1,1))
        ||(hspd<>0 && collision_point(x2,y2,parOneway,1,1)){
            done2=1;
            }
        if(onGround){
            x2+=asin;
            y2+=acos;
            }
        }
    if(done1 && done2){
        break;
        }
    k--;
}
[/gml]
y listo bueno eso creo....

En el manual YoYo recomienda no usar script_execute por ser lento y ademas menciona que un uso intensivo puede generar bajo rendimiento
lo probe para controlar los estados del jugador de esta manera.

[gml]
//EVENTO CREATE PLAYER
//PLAYER ACTIONS
action=nova.stand;
state[nova.stand]=scrStand;
state[nova.move]=scrMoving;
state[nova.fall]=scrFalling;
state[nova.hitting1]=scrHitting1;
state[nova.hitting2]=scrHitting2;
state[nova.hitting3]=scrHitting3;
enum nova{stand,move,fall,hitting1,hitting2,hitting3};

//EVENTO STEP PERSONAJE
//EJECUTAR ESTADOS DEL PERSONAJE
script_execute(state[action]);
[/gml]
mi duda es, recomiendan el uso de esta funcion o es mejor usar switch statement
ya probe con ambas y la verdad no note muchas diferencias tal vez por que solamente lo esta ejecutando una sola instancia.
aqui le dejo el proyecto de prueba por si quiere echarle un vistazo...
Test_script_execute.gmz:  https://drive.google.com/file/d/10ftzbStkZ53BiXey2CvoJ_lnbsFAA6Qy/view?usp=sharing

en mi juego estoy constantemente creando y destruyendo instancias, como enemigos, balas, explosiones
pensaba que  esa era la manera correcta de hacerlo, pues es lo que te enseñan en los tutoriales de youtube
pero hace poco me tope con esto llamado object pooling,  al parecer crear y destruir instancias genera problemas
de fragmentacion de memoria y en mi juego es evidente ese problema, ya que la memoria de la aplicacion
va aumentando con el tiempo no es algo exagerado pero tal vez en un futuro me podria causar problemas
entonces esta es mi pregunta es necesario implementar object pooling a todos los proyectos o depende del tipo de juego
y de paso como es que se implementa esta tecnica o magia oscura, se que se hace con ds_list pero no se como
gracias por su tiempo!!

cuales son las diferencias entre crear una aplicacion con Windows y Windows(YYC)

Estaba probando un nivel de mi juego de navecitas y todo marchaba bien hasta que me dio hambre y mejor decidi prepararme el desayuno, asi que deje el juego corriendo en el PC  y cuando regrese me di cuenta que el juego habia crasheado por falta de memoria
estas son mis preguntas:
la funcion game_restart no elimina la data de nuestro juego?
si no lo hace entonces para que sirve esta funcion?
si al final hay que hacerlo nosotros mismos en que casos recomiendan el uso de esta funcion?

No se si esto va aqui pero bueno. Andaba por youtube viendo tutoriales para distraerme pero  al mirar la seccion de comentarios  algo me hizo sentir muy triste y eso fue que los chavos de hoy quieren todo en la mano asi que aqui esta, como hacer slopes invertidos como en el ori o invertir la gravedad,  en realidad es muy simple solo hay que invertir los + y los - de nuestro codigo base de colision contra blockes y agregar una boleana y he aqui como debe lucir nuestro script de colisiones
recuerda cambiar el image_yscale de tu personaje
[gml]
//evento create  creamos la variable grvzero
grvzero = 1;  // -1 = gravedad invertida ... 1 = gravedad normal;

//EVENTO STEP aplicar gravedad al jugador usando el scrApproach + la nueva variable grvzero
if(!onGround){
        vspd = scrApproach(vspd, vspdMax, grvspd/grvzero);
}

///scrApproach(a,b,amount)
/******************************************
/ Increments a value by a given shift but**
/ never beyond the end value             **
******************************************/
if(argument0<argument1){
   return  min(argument0+argument2,argument1);
   }else{
         return  max(argument0-argument2,argument1);
        }

///scrMotion();
/*******************************************************   
/* HORIZONTAL COLLISION CHECK                         **
/******************************************************/
repeat(abs(hspd)){
    //GRAVEDAD NORMAL
    if(grvzero==1){
        var block = place_meeting(x+sign(hspd),y,parSolid);
        //SOLID SLOPE UPWARD
        if(block){
            for(var i=1; i<=maxslp; i++;){
                if(!place_meeting(x+sign(hspd),y-i,parSolid)){
                    y -= i;
                    break;
                    }
                }
            }else{//SOLID SLOPE UPWARD
                    for(var i=maxslp; i>=1; i--;){
                        if(!place_meeting(x+sign(hspd),y+i,parSolid)){
                            if(place_meeting(x+sign(hspd),y+i+1,parSolid)){
                                y += i;
                                break;
                                }
                            }
                        }
                    }
        }
    //GRAVEDAD INVERTIDA
    if(grvzero==-1){
        var block = place_meeting(x+sign(hspd),y,parSolid);
        //SOLID SLOPE UPWARD
        if(block){
            for(var i=1; i<=maxslp; i++;){
                if(!place_meeting(x+sign(hspd),y+i,parSolid)){
                    y += i;
                    break;
                    }
                }
            }else{//SOLID SLOPE UPWARD
                    for(var i=maxslp; i>=1; i--;){
                        if(!place_meeting(x+sign(hspd),y-i,parSolid)){
                            if(place_meeting(x+sign(hspd),y-i-1,parSolid)){
                                y -= i;
                                break;
                                }
                            }
                        }
                    }
        }     
    //ONEWAY SLOPE CONDITIONS
    if(!place_meeting(x,y+1,parSolid)   && !place_meeting(x,y+1,overOneway))
    ||(!place_meeting(x,y+1,overOneway) &&  place_meeting(x,y+1,parSolid)   && keyUp)
    ||(!place_meeting(x,y+1,parSolid)   &&  place_meeting(x,y+1,overOneway) && keyUp){
   
    var oneway = place_meeting(x+sign(hspd),y,parOneway);
    //ONEWAY SLOPE UPWARD
    if(oneway){
       for(var i=1; i<=maxslp; i++;){
           if(!place_meeting(x+sign(hspd),y-i,parOneway)){
              y -= i;
              break;
              }
           }
       }else{//ONEWAY SLOPE DOWNWARD
          for(var i=maxslp; i>=1; i--;){
              if(!place_meeting(x+sign(hspd),y+i,parOneway)){
                 if(place_meeting(x+sign(hspd),y+i+1,parOneway)){
                    y += i;
                    break;
                    }
                 }
              }
         }
    }
    //LIMIT PLAYER TO CAMERA BORDERS
    if(x+sign(hspd)<=view_xview+16) || (x+sign(hspd)>=view_xview+view_wview-16){
       hspd = 0;
       }
   
    //LEFT-RIGHT SOLID COLISION CHECK
    if(!place_meeting(x+sign(hspd),y,parSolid)){
       x += sign(hspd);
       }else{
              hspd = 0;
              break;
       }
}
/*******************************************************   
/* VERTICAL COLLISION CHECK                           **
/******************************************************/
repeat(abs(vspd)){
    if(place_meeting(x,y+sign(vspd),parSolid)){
       vspd = 0;
       break;
       }
    if(vspd>0 && !place_meeting(x,y,parOneway) && place_meeting(x,y+sign(vspd),parOneway)){
       vspd = 0;
       break;
       }
    if(vspd>0 && !place_meeting(x,y,overOneway)&& place_meeting(x,y+sign(vspd),overOneway)){
       vspd = 0;
       break;
       }else{
              y += sign(vspd);
       }
}
[/gml]

DEVLOG + Tutorial Primer Personaje Accion y Plataformas:
[spoiler]
devlog1:
[spoiler]

[/spoiler]
devlog2:
[spoiler]
proyecto base descarga : https://drive.google.com/file/d/1CyKkdFar03yUjLD7PDUlUwJhD2IjOzec/view?usp=sharing

[/spoiler]
devlog3:
[spoiler]
prinSprites: https://www.spriters-resource.com/fullview/22864/

[/spoiler]
devlog4:
[spoiler]

prinScripts : https://drive.google.com/file/d/1Xi0Nuni3DyEiW7E0NJA36re6L74EHLLK/view?usp=sharing
[/spoiler]

[/spoiler]

no he actualizado el ejecutable del juego lo mas probable es que lo haga cuando termine el primer mapa y su respectivo jefe de nivel.

todo esto esta en modo prueba asi que si quiere dar alguna recomendacion o encuentra algun error no dude en comentar

https://drive.google.com/file/d/1VkbsiePA8y7D9epCt2mzCPqksLHGScTB/view?usp=sharing

necesito consejos para conseguir mejores animaciones, por el momento uso image_speed pero me estoy plantenado usar otro tipo de metodo..alguna recomendacion?

el jugador no se queda encima de la plataforma, funciona bien con plataformas solidas
ya lo solucione me faltaba esto vspd>0 en el codigo de colisiones , ya funciona correctamente con ambos tipos de plataformas pero me surgio otra duda como hago para controlar velocidades  de plataforma menores a 1 como 0.5;

PLATAFORMAS MOVILES :
EDITABLE SI ENCUENTRA BUGS AVISE :
https://drive.google.com/file/d/1zF4Se-PHWXp8nTsLLBUh6S3TYtZhxEFq/view?usp=sharing
[spoiler]
[gml]
//creditos para youtuber Art Games and Tech
//EVENT CREATE
platformType = 0;
initx = x;
inity = y;
hspd = 0;
vspd = 0;
radius = 60;
platDir = 1;
platAng = irandom(360);

//EVENT END STEP
switch(platformType){

//HORIZONTAL PLATFORM
case 0:
var platormSpeed = 0.5;
if(platAng mod(360)==0){
    platAng =-platAng;
    }
    platAng += platormSpeed*platDir;
    hspd = initx+lengthdir_x(radius,platAng)-x;
   
    with(parPlayers){
        if(!place_meeting(x,y,other) && place_meeting(x,y+1,other)){
            if(!place_meeting(x+other.hspd,y,parSolid)){
                x += other.hspd;
                }
            }
    }
    x += hspd;   
break;

//VERTICAL PLATFORM
case 1:
var platormSpeed = 0.5;
if(platAng mod(360)==0){
    platAng =-platAng;
    }
    platAng += platormSpeed*platDir;
    vspd = ceil(inity+lengthdir_y(radius,platAng)-y);
   
    with(parPlayers){
        if(!place_meeting(x,y,other) && place_meeting(x,y+abs(other.vspd),other)){
            if(!place_meeting(x,y+other.vspd,parSolid)){
                y += other.vspd;
                }
            }
    }
    y += vspd;   
break;
   
//CIRCULAR PLATFORM
case 2:
var platormSpeed = 0.5;
if(platAng mod(360)==0){
    platAng =-platAng;
    }
    platAng += platormSpeed*platDir;
    hspd = initx+lengthdir_x(radius,platAng)-x;
    vspd = ceil(inity+lengthdir_y(radius,platAng)-y);
   
    with(parPlayers){
        if(!place_meeting(x,y,other) && place_meeting(x,y+1,other)){
            if(!place_meeting(x+other.hspd,y,parSolid)){
                x += other.hspd;
                }
            }
        if(!place_meeting(x,y,other) && place_meeting(x,y+abs(other.vspd),other)){
            if(!place_meeting(x,y+other.vspd,parSolid)){
                y += other.vspd;
                }
            }
    }
    x += hspd;
    y += vspd;   
break;
}
[/gml]
[/spoiler]

Estoy trasteando con shaders,  me parecen increibles pero la mayoria de documentacion esta en ingles asi que lo poco que tengo son shaders de la pagina shaderToy convertidos a shaders  Game Maker 2 uno de estos cambia la tonalidad de la imagen por tiempo y el otro es un shader tipo waves ondas
la duda que tengo es como combinar ambos efectos,  trate de hacer un solo shader con ambos efectos pero siempre me arrojaban errores y ni idea de como solucionarlo
PROYECTO:
https://drive.google.com/file/d/1v31QgyNM6fKaxZmWWslwiFNOWyrP9P3-/view?usp=sharing

SHADER DISCO:
[spoiler]
[gml]
//shDisco
/*
//EVENT CREATE OBJECT:
sh_res  = shader_get_uniform(shDisco,"iResolution");
sh_time = shader_get_uniform(shDisco,"iGlobalTime");


//DRAW_EVENT OBJECT:
shader_set(shDisco)
shader_set_uniform_f(sh_res,512,512,0);
shader_set_uniform_f(sh_time,current_time/1000);
draw_self();
shader_reset()

*/

varying vec2 v_vTexcoord;
varying vec4 v_vColour;

uniform float iGlobalTime;
uniform vec3 iResolution;

void main( void )
{
    //Inputs
    float gridRows = 1.0;
    float gridCols = 1.0;
    float satFactor = 0.5;
    float movingSpeed = 2.0;
   
   
    // Normalized pixel coordinates (from 0 to 1)
    vec2 uv = 1.0/iResolution.xy;
   
    //We find out in which grid the pixel is
    int pixCol = int(uv.x*gridCols);
    int pixRow = int(uv.y*gridRows);
   
    // Time varying pixel color
    vec3 col = satFactor + satFactor*cos(iGlobalTime*movingSpeed+vec3(pixCol,pixRow,pixCol)+vec3(0,2,4));

    // Output to screen
    gl_FragColor = vec4(col,1.0)* texture2D(gm_BaseTexture, v_vTexcoord );
}
[/gml]
[/spoiler]

SOLUCION PROBLEMA :
al dibujar el backgroundWaves con el shader waves activado, se dibujaba la pagina de textura completa en lugar de solo el background
la solucion fue simple dibujar el backgroundWave en una surface y pasar lo dibujado en dicha surface al shader quedando nuestro evento de dibujo de esta manera
[spoiler]
[gml]
//evento draw
    //SHADER WAVES-----------------------------------------------
    //CREATE WAVES SURFACE:
    if(!surface_exists(surfWaves)){
       surfWaves = surface_create(room_width, room_height);
       }
       //draw wave sprite to waves surface:
       surface_set_target(surfWaves);
       draw_background_tiled_ext(backgroundWav,0,0,1,1,c_white,1);
       surface_reset_target();
       
       //DRAW SHADER SURFACE TO SCREEN
       shader_set(shWave);
       shader_set_uniform_f(sh_wtime,current_time/1000);
       shader_set_uniform_f(sh_wscale,mouse_x,5);
       shader_set_uniform_f(sh_wfactor,0.05,0.1);
       draw_surface(surfWaves,0,0);
       shader_reset();
[/gml]
[/spoiler]

SHADER WAVES:
[spoiler]
[gml]
//shWave
/*
//EVENT CREATE
sh_wtime =  shader_get_uniform(shWave,"time");
sh_wscale = shader_get_uniform(shWave,"Scale");
sh_wfactor = shader_get_uniform(shWave,"Factor");

//EVENT DRAW
shader_set(shWave)
shader_set_uniform_f(sh_wtime,current_time/1000);
shader_set_uniform_f(sh_wscale,10,5);
shader_set_uniform_f(sh_wfactor,0.05,0.1);
shader_reset();
*/

varying vec2 v_vTexcoord;
varying vec4 v_vColour;

uniform float time;
uniform vec2 Scale;   // 10,5
uniform vec2 Factor; // 0.05, 0.1

void main() {
     
     vec2 texCoord = v_vTexcoord;
     texCoord.x = texCoord.x+cos(texCoord.y*Scale.x+time*Factor.x)*Factor.y;
     texCoord.y = texCoord.y+sin(texCoord.x*Scale.y+time*Factor.x)*Factor.y;
     
     gl_FragColor = texture2D(gm_BaseTexture, texCoord);
}
[/gml]
[/spoiler]

es la primera vez que intento agregar dos jugadores , ya tengo casi todo listo, pero surgio una duda como controlar la camara   
SOLUCION : usar la funcion mean
[gml]
          //DOS JUGADORES UNA CAMARA...
           view_xview = ((mean(P1.x,P2.x)-view_wview/2)+view_xview*5)/6;
           view_yview = ((mean(P1.y,P2.y)-view_hview/2)+view_yview*5)/6;

[/gml]
plataformas 2 jugadores :  https://drive.google.com/file/d/1zkOHIF5ZABHBGiZIvm5_42D04HwYHNkh/view?usp=sharing

Cuales son las diferencias entre estos eventos  tal vez el evento step es el que tengo mas claro de todos esots, pero el resto de ellos jamas los he usado mucho menos sabria en que tipo de circunstancias seria mas  util usar uno u otro

estaba jugando algunos shoot em up para insipirarme, no plagio 100% inspiracion y  me tope con algunos efectos interesantes que mucha gente suele confundir con el modo7 de la super nintendo, en realidad son solo pseudo efectos 3d cualquier codificador experto de la epoca los podia crear y navegando por ahi me tope con una demo tecnica de la PC-Engine corriendo ese pseudo efecto 3d que todo mundo suele confundir con el modo7  de la snes,  para ser mas preciso estoy hablando de  una demo del Axelay....y bueno si la PC-Engine puede con ese tipo de efectos supongo que  Game Maker tambien seria capaz, sin mas rodeos estas son mis preguntas,  como podria dibujar ese tipo de backgrounds con Game Maker , es mejor usar shaders? , algun tutorial , por cierto ya intente usar las herramientas de dibujo 3d de Game Maker como d3d_draw_floor() pero los resultados no fueron muy buenos  les dejo el proyecto de prueba por si quiere echarle un vistazo

PC-Engine demos fake mode7 F-ZERO & AXELAY: https://www.chrismcovell.com/creations.html

game maker backgrounds 3d ejemplo : https://drive.google.com/file/d/1vqksrwXiYTTSoVA9rJkIBmWaBFm--IFJ/view?usp=sharing

He solucionado dos problemas  uno era que no se estaba creando la surface3D y el segundo es que  los backgrounds no se estaban dibujando correctamente al parecer si no se activa la casilla de uso para 3d las funciones de dibujado en 3d no se ejecutan correctamente, me alegra saberlo ya que en el manual no especifican nada,  pero bueno  hay otro problema y es como controlar la transparencia de los backgrounds 3d o el alpha  de la surface....
la idea es muy simple la nave navega dentro de las nubes,agua,lava hasta desaparecer dentro de estas  diminuyendo la depth de la camara y despues aumentamos la direcionz para simular un efecto zoom, para finalizar reduciriamos la transparencia de los backgrounds 3d  simulando un efecto pseudo3d muy simple pero algo es mejor que nada creo yo,  la cuestion es como se controla el alpha de una surface?
debo aclarar que  en mi mente se veia mas bonito verda de dios iwata  tal vez con un background mas grande y dibujando mas sprites se puede mejorar
tal vez hace falta jugar un poco con las variables y ver como queda mejor

estoy diseñando los niveles de mi juego con un programa externo llamado Ogmo editor pero solo maneja el formato json
como podria importarlo a Game Maker o existe algun editor que exporte mapas en formato .gmx........
lo unico que encontre fue este script que lee y almacena la data en ds_grids pero mejor usare Tiled otro editor  que  exporta tus mapas directamente a room.gmx
[gml]
///loadLevel
if(objMain.extFiles==true){
        dir = program_directory + "maps\";
        background_replace(tileset0, program_directory + "/maps/tileset_test.png",0,0);
        }
        else{
             dir = working_directory + "maps\";
        }

     var str  = "";
     var file = "";
     var hey  = "";
     var lineCount = 0;
     var tilemapWidthCountFlag = false;
     global.mapWidth = 0;

     if(ds_exists(objMain.levelData,ds_type_grid)){
        ds_grid_destroy(objMain.levelData);
     }
     
     if(ds_exists(objMain.levelDataLayer2,ds_type_grid)){
        ds_grid_destroy(objMain.levelDataLayer2);
     }
     
     file = file_text_open_read(dir+argument[0]);
     var mapHeader = file_text_readln(file);
     
     for(k=1; k<=string_length(mapHeader); k++)
     {
         if(string_char_at(string(mapHeader),k)=='"')
         { 
            var j = "";
                k++;
            while(string_char_at(string(mapHeader),k)!='"'){
                  j += string_char_at(string(mapHeader),k);
                  k++;
            }
            if(global.mapWidth<=0){
               global.mapWidth=real(j)/16;
            }
            else{
                 global.mapHeight=real(j)/16;
            }
          j = "";
         }   
    }

    global.tileWidth  = 16;
    global.tileHeight = 16;
    objMain.levelData = ds_grid_create(global.mapWidth, global.mapHeight);
    objMain.levelDataLayer2 = ds_grid_create(global.mapWidth, global.mapHeight);
    global.tilesetIndex = 0;

    for(var i=1; i<=global.mapHeight ;i++;)
    {
        for(var j=1; j<=global.mapWidth ;j++;)
        {
            var hey =  file_text_readln(file);
            var commaCount = 0;
            var tileBuffer = "";
            var tileID = "";
            for(var k=1; k <= string_length(hey); k++)
            {
                if(global.tilesetIndex==0)
                { 
                   var q="";
                   if(string_char_at(string(hey),k)==' ')
                   {
                      k+=23;
                      while(string_char_at(string(hey),k)!='"' && k<57){
                            q += (string_char_at(string(hey),k));
                            k++;
                      }
                      global.tilesetIndex = background_get_name(asset_get_index(q));//argument[1];
                      k+=19;
                   }
                   if(k==string_length(hey)){
                      i++; j--;
                   }         
                }
                tileBuffer = tileBuffer+string_char_at(string(hey),k);
                if(string_char_at(string(hey),k)==',')
                {   
                   tileID = string_delete(tileBuffer,string_length(tileBuffer),1);
                if(tileID="-1"){
                   tileID=0;
                   }
                   ds_grid_set(objMain.levelData, j-1, i-1, tileID);
                   tileBuffer = "";         
                   j++;
                }
                else if(j>=global.mapWidth){
                        tileID="";
                  while(string_char_at(string(hey),k)!='<') && (k<string_length(hey)){
                        tileID += string_char_at(string(hey),k);
                        k++;
                  }
                  if(tileID="-1"){
                     tileID=0;
                  }
                  ds_grid_set(objMain.levelData, j-1, i-1, tileID);
                  break;
                }
            } 
        }
    }

/*
//overlay tileset
global.overlayTilesetIndex=0;

for(var i=1; i<=global.mapHeight ;i++;)
{
for (var j=1; j<=global.mapWidth ;j++;)
{
var hey =  file_text_readln(file);
var commaCount = 0;
var tileBuffer = "";
var tileID = "";
for (var k=1; k <= string_length(hey); k++)
   {
   
      if global.overlayTilesetIndex==0
      {
        var q="";
          if (string_char_at(string(hey),k)==' ')
          {
          k+=20;
         
          while (string_char_at(string(hey),k)!='"' && k<57)
          {
          q += (string_char_at(string(hey),k));
          k++;
          }
         
          global.overlayTilesetIndex=background_get_name(asset_get_index(q));//argument[1];
         
          k+=19;
          }
      if k==string_length(hey)-1 {i++;j--;}   
         
      }
     
      if j>=string_length(hey)-1 {i++;break;}   
     
       tileBuffer = tileBuffer + string_char_at(string(hey),k);

       if (string_char_at(string(hey),k)==',')
       {

       tileID = string_delete(tileBuffer,string_length(tileBuffer),1);
       
       if (tileID="-1"){tileID=0;}
       //tileID is the tile we want to store here. Let's store it into the ds_grid.
       ds_grid_set(objMain.levelDataLayer2, j-1, i-1, tileID);
       
       tileBuffer = "";
       j++;
       }
       else if(j>=global.mapWidth)
       {
       tileID="";
       while (string_char_at(string(hey),k)!='<') && (k<string_length(hey))
       {
       tileID += string_char_at(string(hey),k);
       k++;
       }
       
       
       if (tileID="-1"){tileID=0;}
       ds_grid_set(objMain.levelDataLayer2, j-1, i-1, tileID);
       
       break;
       }
       
   } 
     
}
}
*/
/*

hey =  file_text_readln(file); //<entities>
hey =  file_text_readln(file); //first sprite

//entities layer
if(ds_exists(objMain.levelDataSprites,ds_type_grid)){
   ds_map_destroy(objMain.levelDataSprites);
   }
   objMain.levelDataSprites = ds_map_create();
   var q = 0;
while(string_char_at(string(hey),5)=="<")
{
   //loop through every sprite and draw them properly
   var dataPart = 0;
   var spriteIndex = "";
   for(var k=6; k<=string_length(hey); k++)
  {
    valueBuffer="";
    while(string_char_at(string(hey),k)!=' ') && (spriteIndex=="")
    {
       valueBuffer+=string_char_at(string(hey),k);
       k++;
    }
    if(spriteIndex==""){
       spriteIndex = valueBuffer;
       }
       valueBuffer = "";
    if(string_char_at(string(hey),k)=='"'){
       k++
       while(string_char_at(string(hey),k)!='"')
       {
         valueBuffer+=string_char_at(string(hey),k);
         k++;
       }
       switch(dataPart)
       {
        case 0: spriteID   = real(valueBuffer); break;
        case 1: spriteXPos = real(valueBuffer); break;
        case 2: spriteYPos = real(valueBuffer); break;
        default: break;
       }
       dataPart++;
    }
  }
  var b = string(q);
  ds_map_add(objMain.levelDataSprites, "spriteIndex" + b, spriteIndex);
  ds_map_add(objMain.levelDataSprites, "spriteID"    + b, spriteID);
  ds_map_add(objMain.levelDataSprites, "spriteXPos"  + b, spriteXPos);
  ds_map_add(objMain.levelDataSprites, "spriteYPos"  + b, spriteYPos);
  q++;
  hey =  file_text_readln(file);
}
spawnSprites();
*/
//Close the text document to avoid memory leaks
file_text_close(file);
global.tilesetWidth   = 16;
global.tilesetHeight  = 16;
global.currentMap     = argument[0]; //Let the game know which map is currently loaded
objMain.switchingMaps = false;
[/gml]