Comunidad Game Maker

Cita de: Bangaran en Junio 17, 2021, 03:50:52 PM
Entonces si quiero que otro ítem sea apilable en ese script lo colocaría

Ir ítem==1||ítem==2||ítem==3|| etc etc ...???

Correcto, por cierto, esto es algo que podrías haber probado tu mismo usando ese código que pusiste. Si bien acá siempre estamos dispuestos a responder las dudas de los miembros del foro, un poco de experimentación por cuenta propia va a ser esencial si realmente quieres aprender.

Cita de: Bangaran en Junio 17, 2021, 08:07:19 PM
Amigo si quisiera que por ejemplo una de las pociones Rojas tenga por por ejemplo 5

Tendría que agregarle en el create code del la instancia algún number= 5

Algo asi??

Si quieres que una variable number determine la cantidad de items que se agregan al inventario por instancia entonces tienes que cambiar la función scr_agregar para que tome en cuenta dicho valor:

[gml]function scr_agregar(){
   //scsr_agregar(item)
   
   var _item = argument0;
   var _number = argument1;
   
   with obj_inventario {
      //Busca si el item ya existe en el inventario y es apilable
      for ( i = 1; i <= slotT; i++;) {
         if scr_stackable(i,_item) {
            slot = _item;
            slot_n+=_number;
            return(1);
         }
      }//Busca si hay un espacio vacio para poner el item
      for ( i = 1; i <= slotT; i++;) {
         if slot = 0{
            slot = _item;
            slot_n = _number;
            return(1);
         }
      }
      return(0);
   }
}[/gml]

Ahí se le estaría pasando el número de items a agregar como argument1, y en lugar de aumentar el valor de un slot de 1 en 1 se aumenta de acuerdo a dicho valor. Solo quedaría cambiar la llamada de scr_agregar para agregar la nueva variable:

[gml]if scr_agregar(item,number) {
   instance_destroy();
}[/gml]

Algo a tener en cuenta es que esto hace que la variable number sea obligatoria y deberá agregarse al evento create del objeto, o al create code de cada instancia.

Como dije en el post anterior, la función scr_stackable es la función que determinará que ítems se pueden apilar:

[gml]function scr_stackable(i,item){
    //Busca si el item es uno de los apilables
    if item == 1 || item == 2 {
        //Busca si la casilla actual tiene el mismo tipo de ítem
        if slot == item{
            return 1;
        }
        else return 0;
    }
    else return 0;
}[/gml]

En la función se buscan los items 1 y 2, si se quiere cambiar a otros items o agregar más seria cuestión de modificar esa parte del código.

La función draw_text_transformed puede aumentar y disminuir la escala del texto dibujado, ten en cuenta que dichos cambios acarrean una perdida de calidad de la fuente, y que dicha perdida de calidad es usualmente menos notable cuando se disminuye la escala que cuando se incrementa.

Ok, primero creamos nuevas variables para mantener la cantidad de objetos por casilla:

[gml]///Variables
open = true;

L = 18; //Distancia entre dos slots
slotT = 16; //Total de slots

for (i = 1; i<=slotT; i++;) {
   slot = 0; //Item que almacena el slot i
   slot_n = 0;//Cantidad de ítems en el slot
}

//variables del mouse
mouse = 0;
mouse_n = 0;//Cantidad de ítems en el mouse[/gml]

Como puedes ver tenemos dos variables nuevas, un nuevo array llamado slot_n, que contendrá la cantidad de objetos que las casillas del inventario tienen, y una variable llamada mouse_n que contendrá la cantidad de objetos que el mouse tiene.

Ahora cambiamos la función scr_agregar, en la función original se buscaba en las casillas del inventario hasta encontrar un espacio vacío y se ponía ahí el ítem. Con los cambios que le hacemos:

[gml]function scr_agregar(){
   //scsr_agregar(item)
   
   var _item = argument0;
   
   with obj_inventario {
      //Busca si el ítem ya existe en el inventario y es apilable
      for ( i = 1; i <= slotT; i++;) {
         if scr_stackable(i,_item) {
            slot = _item;
            slot_n++
            return(1);
         }
      }//Busca si hay un espacio vació para poner el ítem
      for ( i = 1; i <= slotT; i++;) {
         if slot = 0{
            slot = _item;
            slot_n = 1
            return(1);
         }
      }
      return(0);
   }
}[/gml]

Ahora hace dos búsquedas, una para ver si el ítem ya existe dentro del inventario y es apilable, y si esa falla entonces una para buscar un espacio vacío donde poner el objeto. Nota como cuando el ítem ya existe dentro del inventario le sumamos 1 a slot_n en lugar de ponerle un valor predeterminado.

También notaras que llamamos una función nueva, scr_stackable, esta es la función que determinara que ítems se pueden apilar:

[gml]function scr_stackable(i,item){
   //Busca si el item es uno de los apilables
   if item == 1 || item == 2 {
      //Busca si la casilla actual tiene el mismo tipo de ítem
      if slot == item{
         return 1;
      }
      else return 0;
   }
   else return 0;
}[/gml]

Ahora hay que cambiar las interacciones con el mouse, con un par de excepciones esta parte es simple, simplemente hay que asegurarse de que los valores de las variables que contienen la cantidad de ítems en la casilla también se cambien.

[gml]//Dibujar Inventario

if open {
   var h = 0,
      k = 0,
      vx = view_xport,
      vy = view_yport,
      color = c_ltgray;
      
   for (i=1; i<=slotT; i++;) {
      //coordenadas individuales
      var sx = vx + L*k, sy = vy + L*h;
      
      //interaccion
      if point_in_rectangle(mouse_x, mouse_y, sx, sy, sx+16, sy+16) {
         //click
         if mouse_check_button_pressed(mb_left){
            //mouse vacio y slot lleno
            if mouse = 0 and slot != 0 {
               mouse = slot;
               mouse_n = slot_n;
               slot = 0;
               slot_n = 0;
            }
            //mouse lleno y slot vacio
            else if mouse != 0 and slot = 0 {
               slot = mouse;
               slot_n = mouse_n;
               mouse = 0;
               mouse_n = 0;
            }
            //mouse lleno y slot lleno
            else if mouse != 0 and slot != 0 {
               //variable de respaldo
               var _item = slot;
               var _item_n = slot_n;
               
               //Si ambos items son iguales
               if slot == mouse{
               slot_n += mouse_n
               mouse = 0
               mouse_n = 0
               }
               //Si los items son diferentes
               else{
               slot = mouse;
               slot_n = mouse_n;
               mouse = _item;
               mouse_n = _item_n;
               }
            }
         }
         color = c_yellow;
      } else {
         color = c_white;
      }
      
      //fondo
      draw_sprite_ext(spr_borde, 1, sx, sy, 1, 1, 0, color, 1);
      
      //borde
      draw_sprite_ext(spr_borde, 0, sx, sy, 1, 1, 0, c_white, 1);
      
      //item
      if slot != 0 {
         draw_sprite(spr_items, slot, sx, sy);
         
         //Dibuja la cantidad de items si es mayor que 1
         if slot_n>1 {
            draw_set_colour(c_black)
            draw_text_transformed(sx+12,sy+12,"x"+string(slot_n),0.25,0.25,0)
            draw_set_color(c_white)
         }
         
      }
      
      //aumentar coordenadas
      k++;
      if frac(i/4) = 0 {
         h += 1;
         k = 0;
      }
   }
}

//Dibujar item del mouse
if mouse != 0 {
   //Dibujar item
   draw_sprite(spr_items, mouse, mouse_x-8, mouse_y-8);
   //Dibuja la cantidad de items si es mayor que 1
   if mouse_n>1 {
      draw_set_colour(c_black)
      draw_text_transformed(mouse_x+4,mouse_y+4,"x"+string(mouse_n),0.25,0.25,0)
      draw_set_color(c_white)
   }
   
   //Soltar item
   if mouse_check_button_pressed(mb_right) {
      with(instance_create_depth(obj_player.x-8, obj_player.y-8, 0, obj_item)){
         item = other.mouse;
      }
      mouse_n--;
      if mouse_n == 0 mouse = 0;
   }
}[/gml]

Podrás notar que por ejemplo, en mouse vacio y slot lleno también movemos el valor de slot_n a mouse_n, para así asegurarnos de que la cantidad de objetos que había en ese slot sea la misma que cuando esta en el mouse, igualmente en cada interacción con el mouse deben tenerse en cuenta esas variables.

Las excepciones que mencione son en mouse lleno y slot lleno, donde agregamos una condición para que combine la cantidad de ítems si el ítem en la casilla y el que esta en el mouse son del mismo tipo, de lo contrario hace su comportamiento normal de cambiar ítems.

La otra excepción es en soltar ítem, ya que ahora es posible tener más de un ítem en el mouse se agrego un código para que suelte los ítems de uno en uno. Cada vez que suelta un ítem mouse_n se reduce en 1 y cuando llega a 0 es cuando se limpia el ítem del mouse.

También se agrego un dibujo de texto para mostrar la cantidad de ítems en una casilla si dicha cantidad es mayor a uno.

Dejo el editable para que veas los cambios.

Los scripts get_ortho_* no estan regresando nada, tenias que agregar un return para px y py respectivamente.

Dejo el editable arreglado.

No necesitas cambiar de coordenadas cartesianas a isometricas, eso ya lo estas haciendo con el código que pusiste, necesitas cambiar las coordenadas del mouse de isometricas a cartesianas y realizar las comprobaciones con esas nuevas coordenadas.

Puedes cambiar de coordenadas isometricas a cartesianas con este código:

[gml]var xx,yy,px,py;
xx=(argument0 - room_width/2)/global.width_iso
yy=(argument1 - room_height/2)/global.height_iso

px=(yy+xx)*2*(global.width_ortho/2) + room_width/2
py=(yy-xx)*2*(global.height_ortho/2) + room_height/2[/gml]


Lo pones en un par de scripts, uno para x y otro para y, y cuando quieres usar el mouse para interactuar conviertes sus coordenadas y usas los nuevos valores en lugar de las coordenadas normales, por ejemplo, en el projecto que dejaste se puede poner en el draw de los tiles:

[gml]var isox= get_iso_x(x,y)
var isoy= get_iso_y(x,y)

var iso_mouse_x = get_ortho_x(mouse_x,mouse_y)
var iso_mouse_y = get_ortho_y(mouse_x,mouse_y)

if collision_point(iso_mouse_x,iso_mouse_y,self,1,0)
    draw_sprite_ext(spr_iso_tile,0,isox,isoy,1,1,0,c_red,1)
else
    draw_sprite(spr_iso_tile,0,isox,isoy)[/gml]

Eso hará que el tile sobre el que este el mouse cambia a color rojo.

Para crear secuencias con código se usa layer_sequence_create():

[gml]layer_sequence_create(Layer_ID,x,y,Sequence_ID)[/gml]

Como consejo, si vas a seguir experimentando con secuencias deberías empezar por el manual

layer_sequence_create
Capas de Sequencia
El Editor de Secuencias

Las secuencias no se destruyen automáticamente al llegar a su cuadro final, dependiendo del comportamiento que se le ha dado se quedaran en su cuadro final, se regresaran a su cuadro inicial y empezaran de nuevo, o se ejecutaran en reversa hasta llegar al punto inicial y volverán a empezar.

Es a criterio propio cuales secuencias se deben eliminar y cuales pueden seguir existiendo. Para eliminarlas se puede usar la función layer_sequence_destroy():

[gml]
if layer_sequence_is_finished(Sequence_id)
   layer_sequence_destroy(Sequence_id)[/gml]

Cambia el código de manera que el enemigo regrese a su estado actual si el jugador no esta en rango, o que cuando empiece a lanzar una flecha tenga que lanzar la flecha si o si.

Para la primera opción simplemente agrega  un else al if de distance_to_object que regrese image_speed y index a 0.

[gml]if instance_exists(obj_Seiya)
{
if (distance_to_object(obj_Seiya) < 100) && (ataca = true)
{
    image_speed = 1.2;
    if (image_index = 3)
    {
        flecha = instance_create_depth(x,y,-1,obj_Enemigo_Flecha_Izq);
        image_index = 0;
        image_speed = 0;
        ataca = false;
    }
   
    alarm[0] = 150;
}
else{
image_index = 0;
image_speed = 0;
}
}[/gml]


Para la segunda solo agrega una comprobación de la velocidad del sprite al if de distance_to_object:

[gml]if instance_exists(obj_Seiya)
{
if ((distance_to_object(obj_Seiya) < 100) || (image_speed != 0)) && (ataca = true)
{
    image_speed = 1.2;
    if (image_index = 3)
    {
        flecha = instance_create_depth(x,y,-1,obj_Enemigo_Flecha_Izq);
        image_index = 0;
        image_speed = 0;
        ataca = false;
    }
   
    alarm[0] = 150;
}
}[/gml]

Puedes usar la función layer_sequence_get_headpos() para ver en que posición esta la secuencia, una vez llega a la posición que quieres ejecutas el código que quieres:   

[gml]if layer_sequence_get_headpos(Sequence_id) >= 150 {
   room_goto_next()
}[/gml]



Alternativamente, puedes hacer que la secuencia transmita un mensaje en la posición en que quieres ejecutar el código:



Luego en el evento Broadcast Message colocas el código que ocupas que corra cuando la secuencia envia el mensaje:

[gml]if event_data[? "event_type"] == "sequence event"{
   switch (event_data[? "message"]){
      case "Finish":
           room_goto_next();
         break;
   }
}[/gml]



También podrías simplemente poner un objeto al final de la secuencia que tenga el código que quieres usar:





Finalmente, puedes agregar un "momento" a la secuencia, en el que se ejecutará una función de script previamente definida:



Con la funcion de script ejecutando el código que necesitas:

[gml]/// @function change_room();
function change_room(){
   room_goto_next();
}[/gml]

El GMS usa semillas para su RNG de manera que las funciones que generan resultados al azar siempre generan el mismo resultado si tienen la misma semilla. Y el GM siempre inicia con la misma semilla.

La función randomize() genera una semilla usando verdadero azar, si la pones al inicio del juego el resultado de dichas funciones cambiara cada vez que corras el juego, incluyendo la función choose.

La ventana para variables locales solo se llena mientras el juego esta pausado, puedes pausarlo manualmente con el botón de pausa en la barra superior de la pestaña Debugger, o colocando un punto de pausa en el código, lo que causara que el juego se pause automáticamente al ejecutar esa parte del código, el punto de pausa se puede agregar presionando la tecla F9 cuando tienes el cursor de texto en la línea en la que quieres agregar el punto de pausa, o haciendo click en el espacio antes del número de línea de una ventana de código.

Si quieres ver las variables en tiempo real puedes ir a la pestaña Instances, en la sección All Instances podrás ver una lista de instancias según su ID y el objeto al que pertenecen, al expandir un elemento podrás ver las variables que pertenecen a esa instancia.

Es relativamente simple, lo primero es, en el evento Create, determinar el punto de origen desde donde sale la granada y el punto final donde caerá la granada, y usar esos puntos para determinar la distancia y dirección en que la granada va a viajar, e inicializamos una variable z para la altura del vuelo de la granada:

[gml]Dest_x = mouse_x;
Dest_y = mouse_y;

Dist = point_distance(xstart,ystart,Dest_x,Dest_y);
Dir = point_direction(xstart,ystart,Dest_x,Dest_y);

z = 0;[/gml]

Luego en cada paso movemos la instancia la cantidad apropiada y calculamos la altura que tendría la granada en ese paso:

[gml]Dist_Rem = point_distance(x,y,Dest_x,Dest_y)

x += lengthdir_x(min(Dist_Rem,8),Dir)
y += lengthdir_y(min(Dist_Rem,8),Dir)

z = sin((((Dist_Rem)/Dist))*pi)[/gml]

El calculo de z es simple, tomamos la distancia que le falta a la granada por viajar y la dividimos entre la distancia total que debe viajar para normalizar el valor, tomamos dicho valor y lo multiplicamos por pi para poder aprovechar la parábola de la función matemática seno.

Ahora simplemente se dibuja manualmente el sprite del objeto, multiplicando z por el valor de la altura máxima que la granada puede alcanzar y restándole el resultado a al valor y. Recomendaría en lugar de usar un valor estático para la altura máxima usar un factor de la distancia total:

[gml]draw_sprite_ext(sprite_index,image_index,x,y-z*(Dist/3)[/gml]

Dejo un ejemplo con el código:

La variable no cuenta cuantas líneas de texto han pasado, la usamos como una variable booleana que determina cuando se puede eliminar la instancia, por uso usamos la misma condición en que eliminabas la instancia en el código original.

El objetivo es que en el step que la instancia debe ser eliminada esperar hasta el final de dicho step para saltarnos el if !instance_exists(obj_dialogo) and keyboard_check_pressed(ord('T')) del objeto que crea nuevos diálogos.

El problema que tienes es que cuando terminas un dialogo se cumplen las condiciones para crear otro, es decir, ya no existe una instancia de obj_dialogo y la tecla T acaba de ser presionada, y la solución es hacer que al menos una de esas condiciones no se cumpla.

Raro, hasta donde veo debería funcionar, pero entonces cambiemos de táctica.

Agrega en el evento Create de obj_dialogo una variable nueva, ponle el nombre que quieras, para efectos de este ejemplo la llamaré doomed, e iníciala en 0.

[gml]tm=2;
con=0;
post=1;
alarm[0]=tm;
global.fin="";
esc=false;
frame=0;
if instance_exists(obj_linkR)//Esto para el movimiento de link mirando a la Derecha(Right)(ignorenlo)
{obj_linkR.canmove=false};
if instance_exists(obj_linkL)//Esto para el movimiento de link mirando a la Izquierda(Left)(ignorenlo tambien)
{obj_linkL.canmove=false};

doomed = 0;[/gml]

Luego en el evento keyboard_pressed T de obj_dialogo cambia instance_destroy(); por doomed = 1;

[gml]if (esc){
if(con<=global.maxi)
{
con+=1;
post=1;
cop="";
global.fin="";
alarm[0]=tm;
esc=false;
}


if!(con>global.maxi)
{//instance_destroy();
doomed = 1;}
}else{
global.fin=global.texto[con];
post=string_length(global.texto[con])+1;
}[/gml]

Finalmente agrega un evento End Step al obj_dialogo y en el pon una comprobación para que si el valor de la variable es 1 la instancia sea destruida.

[gml]if (doomed == 1)
{instance_destroy();}[/gml]

Con esto retrasas la destrucción de la instancia hasta el final del step, y debería evitar la creación de nuevos obj_dialogos.