Comunidad Game Maker

como dice el titulo cual es la manera correcta de executar one way slopes y ceiling slopes,   yo uso una mezcla de codigo sacados del tutorial de plataformas de monthy Drake y algunas cosas de una engine de un chico italiano  big mama era su nombre creo , bueno lo que me tiene intrigado,  es si lo estoy haciendo de la forma correcta o existe alguna manera mejor de hacerlo aqui les dejo el codigo y el projecto por si quieren echarle un viztaso y ayudarme a aclarar mis dudas, por lo poco que e probado el juego tiene poco bugs como quedarse atascado dentro de una plataforma solida y una plataforma oneway

EDITABLE  NO DUDE EN MODIFICARLO MEJORARLO O HACER ALGUNA SUGERENCIA:

https://drive.google.com/file/d/1zF4Se-PHWXp8nTsLLBUh6S3TYtZhxEFq/view?usp=sharing

EVENTO CREATE JUGADOR:
[spoiler]
[gml]
onGround    = 0;
onOneway    = 0;
konckback   = 0;

vspd = 0;
hspd = 0;
grvzero = 1;
accspd  = 0.5;
fricspd = 0.25;
gfric   = 0.5;
mainspd = movespd;



//ATTACK VAR
hitsCount   = 0;
maxHits     = 4;
slashHit    = 0;

//JUMP VAR
jumped      = 0;
minijump    = 0;
buffCount   = 0;
coyCount    = 0;


//KEYS VAR
moveX      = 0;
moveY      = 0;
keyLeft    = 0;
keyRight   = 0;
keyUp      = 0;
keyDown    = 0;
keyJumpC   = 0;
keyJumpP   = 0;
keyAttackC = 0;
keyAttackP = 0;
[/gml]
[/spoiler]

SCRIPT MOTION SIMPLIFICADO:
[spoiler]
[gml]
///scrMotion();
/*******************************************************   
/* HORIZONTAL COLLISION CHECK                              **
/******************************************************/
repeat(abs(hspd)){   
    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
    with(parPlayers){
    //condiciones para poder subir oneway slopes
    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;
                    }
                 }
              }
         }
    }
    //limitar jugador a la view tambien puede clampear su jugador a la view
    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]
[spoiler]
SCRIPT PLAYER STEP:
en este script van todas las entradas que realizara el jugador  y la inicializacion de los estados
puede modificarlo a su gusto es solo un ejemplo
[spoiler]
[gml]
///scrPlayerStep{player,movLeft,movRight,movUp,movDown,button1,button2,view}
var playerID  = argument[0];
var moveLeft  = argument[1];
var moveRight = argument[2];
var moveUp    = argument[3];
var moveDown  = argument[4];
var action1   = argument[5];
var action2   = argument[6];
var viewIndex = argument[7];   

   
with(playerID){

   var getName = object_get_name(object_index);
   sprite_index = asset_get_index("spr"+getName+setAction);
   scrAction();
   
   
   var onWallL = vspd>0 && !place_meeting(x,y+1,parSolid) && place_meeting(x-1,y,sWall);
   var onWallR = vspd>0 && !place_meeting(x,y+1,parSolid) && place_meeting(x+1,y,sWall);
   
   
   onGround = scrGroundCheck();
   onOneway =!place_meeting(x,y,parOneway) && place_meeting(x,y+1,parOneway) && moveX==0 && moveY==-1;
   
   //SET.CONTROL PLAYER
   switch(canMove){
   case 0:
           keyJumpP   = 0;
           keyAttackP = 0;
           if(onGround){
              hspd = scrApproach(hspd,0,1);
              }
           break;
   
   case 1: keyLeft    = keyboard_check(moveLeft);
           keyRight   = keyboard_check(moveRight);
           keyUp      = keyboard_check(moveUp);
           keyDown    = keyboard_check(moveDown);
       
           keyJumpC   = keyboard_check(action1);
           keyJumpP   = keyboard_check_pressed(action1);
           keyAttackC = keyboard_check(action2);
           keyAttackP = keyboard_check_pressed(action2);
       
           moveX = keyRight-keyLeft;
           moveY = keyUp-keyDown;
           
           if(moveX<>0){
              image_xscale = sign(moveX);
              hspd = scrApproach(hspd,moveX*mainspd,accspd);
              }
   }
   //INIT.JUMP BUFFER
   if(keyJumpP && !keyAttackP && !keyAttackC && buffCount<=0 && !onOneway){
      buffCount = buffMaxJump;
      }
   //COUNTDOWN.JUMP BUFFER
   if(buffCount>0){ 
      buffCount--;
      }
   //MINI.JUMP
   if(vspd<0 && minijump && !keyJumpC && !onOneway){
      minijump = 0;
      vspd = 0;
      }
   //WALL.JUMP LEFT
   if(onWallL){
      setAction = "JumpMove2";
      grvzero = 2;
      if(buffCount>0){
         vspd =-jumpspd;
         hspd = 4;
         setAction = "JumpMove1";
         airState = stateWallJump;
         image_xscale = 1;
         }
      }else{
            if(!onWallL && !onWallR){
               grvzero = 1;
      }
   }
   //WALL.JUMP RIGHT
   if(onWallR){
      setAction = "JumpMove2";
      grvzero = 2;
      if(buffCount>0){
         vspd =-jumpspd;
         hspd =-4;
         setAction = "JumpMove1"
         airState = stateWallJump;
         image_xscale =-1;
         }
      }else{
            if(!onWallL && !onWallR){
               grvzero = 1;
      }
   }
   //ON.GROUND
   if(onGround){
      airState = noone;
      minijump = 1;
     
      //HITS.BUFFER
      var hitBuffer = keyboard_check_pressed(action2);
      if(hitBuffer && hitsCount<maxHits){
         hitsCount = (hitsCount+1) mod(maxHits);
         }         
             
      //GROUNDED.STATES
      if(groundState==noone){
         groundState = stateIdle;
         }else{
               scrGroundStates();
              }
      //DESCENDER DE PLATAFORMA ONEWAY
      if(keyJumpP && onOneway){
         y++;
         }
   }
   //ON.AIR
   if(!onGround){
      vspd += grvspd/grvzero;
      countHits = 0;
      groundState = noone;
      //AIR.STATES
      if(airState==noone && jumped==0){
         setAction = "JumpMove2";
         airState = "JumpMoving2";
         image_index = 0;
         vspd = 0;
         }else{
               scrAirStates();
              }
      //COYOTE.TIME
      if(coyCount>0){ 
         coyCount -= 1;
         if(!jumped && minijump){
            if(keyJumpP){
               jumped = 1;
               buffCount = 0;
               vspd =-jumpspd;               
            }
         }
      }
   }else{
          jumped = 0;
          coyCount = coyMax;
        }
}       
     
        /******************************************************************************   
        /* SIMPLE CAMERA 1                                                           **
        /*****************************************************************************/
        //TWO PLAYERS FREE CAMERA
        if(instance_exists(P1) && instance_exists(P2)){
           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;
           }else{
                  view_xview = ((x-view_wview/2)+view_xview*5)/6;
                  view_yview = ((y-view_hview/2)+view_yview*5)/6;             
                }
           /*
           //TWO PLAYERS ONE-SIDE CAMERA
           var camH = ((mean(P1.x,P2.x)-view_wview/2)+view_xview*5)/6 && P1.moveX>0 && P2.moveX>0;
           if(camH){
              view_xview += 1*dTime;
              }
              view_yview = ((mean(P1.y,P2.y)-view_hview/2)+view_yview*5)/6;
           */

        if(view_xview[viewIndex]<=0){view_xview[viewIndex] = 0;}
        if(view_xview[viewIndex]>=room_width-view_wview[viewIndex]){view_xview[viewIndex] = room_width-view_wview[viewIndex];}
        if(view_yview[viewIndex]>=room_height-view_hview[viewIndex]){view_yview[viewIndex] = room_height-view_hview[viewIndex];}   
[/gml]
[/spoiler]

y por ultimo
SCRIPT ON GROUND:
regresa 1 si estamos pisando tierra firme
[spoiler]
[gml]
///scrGroundCheck();
var colGround = ((place_meeting(x,y+1,parSolid)) || (vspd>=0 && !place_meeting(x,y,parOneway) && place_meeting(x,y+1,parOneway)) || (vspd>=0 && !place_meeting(x,y,overOneway) && place_meeting(x,y+1,overOneway)));
return colGround;
[/gml]
[/spoiler]

si no le funciona  aqui le dejo un ejemplo de como usar clamp, lo siento Game Maker elimino view_xview y view_wview que eran variables muy eficientes la verdad,  creo que las sustituyo por  camera_get_view_x(camera) y camera_get_view_width(camera) entonces para clampear el jugador a la view seria algo asi, no lo se
[gml]
   //EVENTO STEP JUGADOR:
   //clamp x,y del jugador a la camara
    x = clamp(x ,camera_get_view_x(camera)+32 ,camera_get_view_x(camera)+camera_get_view_width(camera)-32);
    y = clamp(y ,camera_get_view_y(camera)+32 ,camera_get_view_y(camera)+camera_get_view_height(camera)-32);
   
   //SUMAR VELOCIDAD DE LA CAMARA A POSICION DEL JUGADOR 
   x += "camaraVelocidadHorizontal"; //SI EL JUGADOR DEJA DE MOVERSE ESTE MANTENDRA SU POSICION  HORIZONTAL RESPECTO A LA VIEW
   y += "camaraVelocidadVertical";  //SI EL JUGADOR DEJA DE MOVERSE ESTE MANTENDRA SU POSICION  VERTICAL RESPECTO A LA VIEW
                                                             

[/gml]

Bueno yo lo hago de esta manera, no se si sea la forma mas eficiente de hacerlo, pero , hasta la fecha me sigue funcionado incluso si se usan velocidades de movimiento muy altas,  el jugador permanece dentro de la view y ademas el jugador no se ralentiza  cuando esta en los limites y se ejecuta un movimiento en diagonal
ACLARACION!!
No se si le funcionara ,  ya que yo jamas necesite mover la camara , pues  este codigo  lo usaba para shoters verticales y tanto el mapa como enemigos los generaba por tiempo aun asi yo creo que si deberia de funcionar eso espero
[gml]
//EVENTO CREATE JUGADOR:
movVer  = 0;
movHor  = 0;
hspd    = 0;
vspd    = 0;
halveMov  = 0;
spd  = 25;  //opcional

//EVENTO STEP JUGADOR:
     //SET PLAYER CONTROL
    var Up      = keyboard_check(global.keyU)             || gamepad_button_check(global.gpd,global.padUp)    || gamepad_axis_value(global.gpd,global.axisY)<-0.4;               
    var Left    = keyboard_check(global.keyL)             || gamepad_button_check(global.gpd,global.padLeft)  || gamepad_axis_value(global.gpd,global.axisX)<-0.4;               
    var Down    = keyboard_check(global.keyD)             || gamepad_button_check(global.gpd,global.padDown)  || gamepad_axis_value(global.gpd,global.axisY)> 0.4;               
    var Right   = keyboard_check(global.keyR)             || gamepad_button_check(global.gpd,global.padRight) || gamepad_axis_value(global.gpd,global.axisX)> 0.4;               
    var shoting = keyboard_check(global.keyShot)          || gamepad_button_check(global.gpd,global.padShot);   
    var bombing = keyboard_check_pressed(global.keyBomb)  || gamepad_button_check_pressed(global.gpd,global.padBomb);
    var speedup = keyboard_check_pressed(global.keySpeed) || gamepad_button_check_pressed(global.gpd,global.padSpeed);
   

     //MOVIMIENTO VERTICAL
     if(Up && !Down){
        movVer =-1;
        }
else if(Down && !Up){
        movVer = 1; 
        }
   else{movVer = 0;}       
     
     //MOVIMIENTO HORIZONTAL
     if(Left && !Right){
        movHor =-1;
        }
else if(Right && !Left){
        movHor = 1;
        }
   else{movHor = 0;}
     //LIMITAR VELOCIDAD DIAGONAL OPCIONAL 
     if(movHor!=0 && movVer!=0) && (hspd!=0 && vspd!=0){
        halveMov = sqrt(2);  //SI NO SE LIMITA , SU NAVE SE MOVERA EL DOBLE DE RAPIDO, POR LO TANTO TENDRA MENOS CONTROL SOBRE ELLA
        }
   else{halveMov = 1;}   
   
        hspd = (spd*movHor/halveMov);  // velocidad*direccion(0,180)/limitador de velocidad diagonal
        vspd = (spd*movVer/halveMov);   // velocidad*direccion(90,270)/limitador de velocidad diagonal   
     
     //VIEW LIMITE HORIZONTAL
     repeat(abs(hspd)){
     if(x+sign(hspd)<=view_xview[0]+"ANCHO DE SU SPRITE" && (movHor=-1))
     ||(x+sign(hspd)>=view_wview[0]-"ANCHO DE SU SPRITE" && (movHor= 1)){
        hspd = 0;
        }
   else{x += sign(hspd)*dTime;}
   }
      //VIEW LIMITE VERTICAL
     repeat(abs(vspd)){
     if(y+sign(vspd)<=view_yview[0]+"ALTURA DE SU SPRITE" && (movVer=-1))
     ||(y+sign(vspd)>=view_hview[0] -"ALTURA DE SU SPRITE"  && (movVer= 1)){
        vspd = 0;
        } 
   else{y += sign(vspd)*dTime;}
   }
   //AÑADIR VELOCIDAD DE LA VIEW A JUGADOR, ESTO ES OPCIONAL DEPENDERA DEL TIPO DE NIVEL
   x += "viewHorizontalSpeed";
   y += "viewVerticalSpeed";
[/gml]

veo que ya lo resolvio,  aun asi voy a explicar como hacer este tipo de patrones para  los mas nuevos
es muy sencillo la logica seria  direcion de nuestra bala = a rotacion;

[gml]
///METODO 1 CON VARIABLES
//Evento create
rotacion = 0;

//Evento Step:
switch(pattern)
{
case  1:
        rotacion = (rotacion+5) mod 360; //velocidad de rotacion. + girara de derecha a izquierda , - girara de izquierda a derecha
                         //si su objeto rota sobre su propio eje puede usar image_angle
     if(rotacion%25==0)  //cada cuando debera crear una bala esto solo funciona con numeros enteros creo no lo se
     {
     var bullet = instance_create(x , y , objBullet);
         bullet.direction    = rotacion ;
     }
     break;
}
///METODO 2  CON BUCLES FOR
     //PATRON SENCILLO DE DISPARO EN ESPIRAL
     if(keyboard_check(vk_enter))
     {   
          image_angle++;  //rotacion del patron usare image_angle pues el arma es una torreta
         
      for(var i=0; i<360/15; i+=30;){
          var bullet = instance_create(x,y,mainP1Bullets);
              bullet.direction    = i+image_angle;
              bullet.sprite_index = sprWaveBullet;
              bullet.mainSpeed = 70*mainC.deltaTime;
       
      }
      //MAS EJEMPLOS PATRON- CRUZ DEL SAGRADO CORAZON DE IWATA  TORRETA DE CUATRO CAÑONES
      if(keyboard_check(vk_up))
     {   
          image_angle++;
         
      for(var i=0; i<360; i+=90;){
          var bullet = instance_create(x,y,mainP1Bullets);
              bullet.direction    = i+image_angle;
              bullet.sprite_index = sprWaveBullet;
              bullet.mainSpeed = 70*mainC.deltaTime;
       
      }
     
[/gml]

Fan game  del juego Soldier Blade de la PC-Engine
fase del juego prototipo
menus intro estados principales del juego70%
collisiones 100%
enemigos comportamientos  40%
niveles  0%
historia ,dialogos, escenas 0%
jugador 90%
sonido 20%
sprites 30%
rank, puntuacion 0%
jefes 30%

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

Fan game  del juego Soldier Blade de la PC-Engine
fase del juego prototipo
menus intro estados principales del juego70%
collisiones 100%
enemigos comportamientos  40%
niveles  0%
historia ,dialogos, escenas 0%
jugador 90%
sonido 20%
sprites 30%
rank, puntuacion 0%
jefes 30%

https://i.ibb.co/4gpy0yX/1.png https://drive.google.com/file/d/1gc06wwDLrvuMeFPwJg4-Ic0kiGEbs9vB/view?usp=sharing

es muy simple tiene que usar break para romper el bucle , pero si la velocidad sigue siendo mayor que 1 seguira reproduciendose asi que es mejor que use una alarma o cree  una condicion para evitar que el bucle continue ejecutandose
[gml]

if(speed>1 &&  instance_number(obj_robot_stela)<1) //condicion se volvera a reproducir el sonido
                                                      //hasta que la instancia obj_robot_stela sea destruida
{
   for(var i = 0; i<1;  i++;)
  {
    audio_play_sound(sound_rapido,0,0);
  }
    instance_create_layer(x + 0, y + 0, "Instances", obj_robot_stela);
}

[/gml]

Cita de: Ikaro3d en Diciembre 11, 2021, 04:14:27 PM
Muchas gracias ,muy bien resuelto , me avía quedado estancado    ;D

De nada para eso estamos , yo tambien la lio con esas funciones del game maker sobre todo con move_towards_point
pero bueno ahora que esta usando una variable para controlar la velocidad de sus objetos cuando pause y despause su juego le resultara mas sencillo restablecerla
claro eso dependera de como maneje la pausa de su juego
[gml]
if(global.paused){
    speed = 0;
    }
if(!global.paused){
    speed = velocida;
    }
[/gml]

ya intento poner la velocidad a cero  ademas tiene que cambiar de estado cuando el objeto llega a su posicion por ejemplo
[gml]
  speed = mainspd; //VELOCIDAD DE MOVIMIENTO

switch(posicion_robot)
{
case "DESTINY1":
 
  //CAMBIAR DE ESTADO SI LA POSICION DEL OBJETO ES >= mayor o igual  o <= menor o igual QUE SU DESTINO
  if(x>=1400 && y>=600)  // >= o <= DEPENDIENDO SI SU OBJETO RECORRE LA PANTALLA DE ARRIBA HACIA ABAJO O VICEVERSA
                                             // DE IZQUIERDA A DERECHA Y VICEVERSA
  {
   posicion_robot = "STANDBY";//cambio de estado
   mainspd =  0;//velocidad de su objeto
  }
  break;

case "STANDBY": //aciones mirar sus  ojos bonitos , disparar , tomar un descanso etc etc

var timer = 0+current_time/6000;  //TEMPORIZADOR
var target = point_direction(x,y,objeto.x,objeto.y) //MIRAR HACIA OBJETIVO
   
    image_angle = target;
  //DISPARAR
  if(timer%3==0)
  {   
   var bull = instance_create(x,y,bullet);
       bull.mainspd = 20*dtime;
       bull.direction = target;
  }
  //CAMBIAR DE ESTADO OTRA VEZ
  if(timer>=5)
  {
   posicion_robot = "OTHER STATE"     
  }
  break;

case "OTHER STATE": break;
}
[/gml]

He creado una intro para mi juego, el problema es que al minimizar la aplicacion este sigue ejecutandose
existe alguna funcion para controlar la pausa del juego cuando esta queda en segundo plano o se minimiza

LEYENDO EL MANUAL encontre estas funciones os_is_paused()  y  window_has_focus() 
ejemplo  simple de como usarlas :
[gml]
///EVENTO STEP OBJETO MAIN CONTROL
if(os_is_paused())
{   
    io_clear(); 
    instance_deactivate_object(all);
    audio_pause_sound(global.currentSong);
for(var i=0; i<8; i++;){
    background_visible = false;
    }
if(!instance_exists(mainPause))
   {
    instance_create(0,0,mainPause);
   }
}
///EVENTO STEP OBJETO  MAIN PAUSE
if(window_has_focus())
{
   instance_activate_object(all);
   audio_resume_sound(global.currentSong);
   instance_destroy();
}

[/gml]

olvide lo que dije ya corregi el codigo, el problema es que estaba usando current_time por eso es que el patron salia rotado

es muy facil solo que en el video se ve algo complicado seria algo como esto recuerda debes cambiar los objetos y sprites por los tuyos... lo siento una pequeña correcion al codigo ahora esta exactamente como lo hace guinxu,  si quiere 10 puntas de estrella pues multiplicar sin( i*100) si quiere 5 puntas multiplicar  sin(i*50) creo que ahora funciona correctamente

[gml]
      //SPREAD SHOT STAR MONA CHINA FO%&A OTAKUS DE LA MUERTE PATTERN
     if(keyboard_check_pressed(vk_enter))
{
         var bullAngle = 5;
         var targetPos = point_direction(x,y,mouse_x,mouse_y);
     for(var i=0; i<360/bullAngle; i++)
  {   
         var bull360 = instance_create(x+sin(current_time/200)*70,y,mainP1Bullets);
             bull360.direction = i*bullAngle;
             /*bull360.direction = i*bullAngle+targetPos; //PATRON TELEDIRIGIDO */
             bull360.speed= 8-sin(i*60*pi/360)*1;  //PATRON ESTATICO
             /*bull360.speed= 8-sin(i*60*pi/360+current_time/200)*1; //PATRON DINAMICO*/
             bull360.sprite_index = sprClusterBullet;
  }
}

[/gml]

esto parece un problema de instancias y objetos
un objeto es como una plantilla que sera usada por las instancias que coloquemos en la room,
si usted dibuja la municion de un objeto Game Maker dibujara la primera instancia pero si existen mas tambien las dibujara
su problema se arregla creando unas cuantas variables que almacenen el id de la instancia del arma,
no se como controla sus armas pero yo lo suelo hacer todo con el jugador y con una sola variable que almacenara el id del arma que cogi de hecho se puede controlar armas sin necesidad de crear objetos de arma todo controlado por el objeto jugador, bueno por  eso le recomende el uso de un objeto powerUp cuando el jugador lo coge almacenara el id del arma
en la variable weapon1 o weapon2 del jugador  con eso ya tiene el id del arma sin necesidad de estar checando si el arma esta activa, esa misma variable la puede usar en el objeto del jugador para dibujar la municion y el tipo de arma  que cogio,  un  consejo no necesita crear un objeto para cada cosa con un solo objeto puede crear infinidad de armas, balas, dibujar y controlar niveles enteros
tal vez le sirva este tutorial:
https://www.youtube.com/watch?v=2l9drqMlE6s

Cita de: roy_focker en Octubre 24, 2021, 08:36:50 AM
probe lo que dijiste(cambiando la escala de prioridades) pero el resultado es el mismo, aun asi gracias, me sirve para ir descartando distintas alternativas.

sabia que no funcionaria es que yo uso Game Maker Studio, parece que el problema esta en su codigo ya que anclar la posición de un objeto a otro es muy sencillo
a intentado poner su código de esta manera
[gml]
if object_exists(obj_player){
if activar = true
{
    x=obj_alma.x;
    y=obj_alma.y
   //Y DESPUES LO QUE SIGUE
[/gml]
otra solucion es que use items de powerUp estos contendrán el tipo de arma y munición  que el jugador obtendrá
al colisionar y presionar E  creara el arma en la posición deseada  el item de  powerUp se destruirá
de esa manera no tendrá que verificar si el arma esta activa, yo creo que esa parte del código es la causa de su problema

tienes razón hay muy  poca información sobre estos temas de trepar por todos lados con slopes y toda la cosa pero bueno
colisionar con un objeto y trepar es muy sencillo te dejo un ejemplo sobre como se hacen los wall jump de megaman

[gml]
      //WALL-JUMP-LEFT-SLIDE
     if(!place_meeting(x,y+1,parSolid)  &&  place_meeting(x-1,y,Wall))
{   
     //MEGAMON se deslizara solo si se mantiene la tecla izquierda presionada
     if(keyL){
        vsp = grvspeed/.28;  //si pones la velocidad vertical en 0 megaman no se deslizara..
                //puedes crear un control de velocidad vertical para hacer que escale con las teclas up y down
               //en juegos como ori lo que hacen es ejecutar el mismo codigo de colisiones y gravedad pero a la inversa osea cambian la gravedad
            //cuando ori esta trepando en realidad esta en el suelo numero 2 creo que de esa forma consiguen que haga ceil slopes  tan bonitos
        state = Action.WallSlideL;  //megaman esta en el estado wall sliding left 
       }
     
     //MEGAMON ejecutara un wall jump si el jugador presiona la tecla de salto y esta colisionando contra la pared
     if(place_meeting(x-1,y,Wall) && keyJump){
        vsp =-jmpspeed;           //su velocidad de salto
        hsp = maxspeed*2.2;  //incrementamos la velocidad horizontal para que se aleje de la pared
        jump = 1;        //contador de saltos util para double jump
        state = Action.WallKickingL; //entra al estado wall kick
      }
}   
[/gml]