Comunidad Game Maker

Lo que tienes que hacer es asignar uno a uno los atributos a las intancias creadas.
Por ejemplo si yo tengo un obj_perro:
ev_Create
[GML]
//Evento Create del obj_perro
raza = ""
[/GML]
Inicialmente mi objeto es un perro indefinido, pero me apetece darle una raza en cualquier momento:
[GML]
//por ejemplo, Alamra0 del obj_perro
raza = "dalmata"
[/GML]
Luego querría crear dos instancias, para ello, necesiarías usar instance_create() y almacenar las instancias nuevas, dentro de variables:
[GML]
///cualquier evento dentro de obj_perro
dalmata1 = instance_create(x,y, obj_perro)
dalmata2 = instance_create(x,y, obj_perro)
[/GML]
Después tendrías que asignar, como se dijo al inicio, los atributos uno a uno:
[GML]
///cualquier evento dentro de obj_perro
dalmata1 = instance_create(x,y, obj_perro)
dalmata2 = instance_create(x,y, obj_perro)

dalmata1.raza = self.raza   
dalmata2.raza = self.raza
[/GML]
Asi asignarias a cada instancia el mismo atributo que tiene el objeto, que las crea.
Luego bastaría con que lo eliminaras:
[GML]
///cualquier evento dentro de obj_perro
dalmata1 = instance_create(x,y, obj_perro)
dalmata2 = instance_create(x,y, obj_perro)

dalmata1.raza = self.raza   
dalmata2.raza = self.raza

instance_destroy()
[/GML]
Finalmente tendrías un objeto perro, que fue modificado y creó otras 2 instancias modificadas, y luego se destruyó.

CitarSé que me explico como un libro cerrado y me ando por las ramas

Lo mejor que podés hacer para explicarte, es poner ejemplo de lo que estás haciendo y lo que querés lograr finalmente.
Pasa mucho de hecho, lo vi en otros foros, de que la gente gasta más tiempo intentando pedir perdon que intentando poner ejemplos para darse a entender XD

Creo que ocurre , porque al estar la verificacion de colision dentro del evento step, cada vez que se superpone un borde, la x_view se aumenta.
Por lo que el personaje pasa por encima y la x_view se aumenta muchas veces.

tengo dos soluciones:
1) tendrias que mover al player a una distancia grande de manera que deje de tocar el borde y consecuentemente deje de moverse la x_view al no cumplirse la condicion de colision
2) usar una variable booleana que indique que ya se tocó el borde para no seguir moviendo indefinidamente la x_view

hola amigou, de javascript no se mucho pero si hay algo que puedo aportar es que para conectar con game maker, los juegos digamos que tienen un protocolo para comunicarse que es diferente a lo que usualmente se podría creer con los UDP y TCP puros. Es un protocolo especial que tiene Game Maker tras balbalinas.

Sin embargo hay otra manera de conectar las aplicaciones hechas con game maker y un servidor crudo hecho en otro lenguaje, para ello necesitas hacer uso de esta funcion:
https://docs.yoyogames.com/source/dadiospice/002_reference/networking/network_connect_raw.html

de la misma manera tienes que usar las funciones _raw para enviar datos. A lo mejor algo de eso soluciona la conexion de entrada y el envio de datos

Bueno al tocar el objeto tendrías que usar:

view_xview[0] += 640

para mover la camara hacia la derecha o bien usar

view_yview[0] -= 480

para mover la camara hacia arriba.

amigo te dejo un grafico de como funciona el ciclo for en 4 pasos:
El ciclo for es eso, un ciclo, que se reptite contadas veces. En programación se conoce como "ciclo definido o ciclo finito" puesto que se sabe, cuantas vueltas va a dar el ciclo de antemano.
En nuestro ejemplo del inventario iba a dar 4 vueltas.

analizemos la estructura  de FOR:

1º) se crea una variable contador, generalmente y por comodidad, en muchos lugares se la llama "i" del "iterator" en español iterador. Que es la variable que cuenta las iteraciones(repeticiones de codigo).
Esta parte se ejecuta 1 sola vez. Declara la variable para usarla como contador.

2º) la condicion que repite el ciclo. Esta parte se ejecuta varias veces y te indica la condicion que tiene el ciclo para seguir ejecutandose. Generalmente es un numero entero o una expresion de "i es menor a 10" y de ese estilo para que el ciclo se repita determinada cantidad de veces.

3º) aqui se ejecutan las acciones que se quieren repetir. Todo el codigo dentro se repite cada vez que el ciclo da vuelta.

4º) aqui se aumenta (o disminuye) el contador de manera de que se vaya sumando éste y termine en algun momento la condicion.
Por lo general se le suma de a 1 , raras veces vá hacia atrás o se suman en mas cantidad.
Luego de este 4º paso se vuelve a repetir el 2º paso y así, hasta que la condicion deje de cumplise.

Un ejemplo:

[gml]
for(i=0; i<2; i++){
         instance_create(o_nave_enemiga, x,y)
         audio_play_sound(snd_campana,1,0);
}
[/gml]
1) Este codigo inicializa la variable "i" en cero.
2) Verifica si la condicion es verdadera. "i" es menor a 3? en efecto, puesto que es igual a cero.
3) se crea una nave espacial y hace un sonido
4) aumenta el contador en 1 (i++ o bien se puede escribir como i+= 1), ahora vale 1
5) se verifica la condicion: "i" es menor a 3? en efecto, puesto que es igual a 1
6) se crea una nave y se hace un sonido
7) se aumenta el contador "i" en 1, ahora vale 2
8 ) se verifica la condicion "i" es menor a 2? no, puesto que es igual a 2, y 2 no es menor a 2.
9) termina el ciclo sin ejecutar acciones. No se vuelve a entrar en él

hola amigooou

hay dos maneras de trabajar con arreglos(vectores, arrays, listas, etc).
una es usando los arreglos convencionales de gm:   vector
la segunda es usando listas dinamicas de gm: ds_list_create()

yo te voy a explicar usando arreglos estandar.

primero hay que declarar el arreglo e inicializarlo con un valor que nos indique que esta vacio, por ejemplo vamos a poner el 0:
(Evento Create)
[GML]
global.MAX = 4; //maximo de slots disponibles en el inventario
for(i=0; i<global.MAX; i++)
      inventario = 0; // el cero indica que no hay nada en el inventario
[/GML]

Esto crea el arreglo con 4 elementos, que son el numero 0 que a efectos practicos, nos indicaria que no tienen items.

Luego, creamos un script desde el panel de recursos, que usaremos para obtener un espacio libre.
scr_obtener_slot
[GML]
for(i=0; i<global.MAX; i++){  //recorremos el arreglo
      if (inventario == 0)   //si hay un slot que este vacio
           return i;    // devolvemos la posicion que esta desocupada (puede ser 0, 1, 2, 3)
}

return -1;  //en caso de que este todo ocupado, devolveremos el indice -1 que no existe, por lo tanto es un error
[/GML]
Este script nos devolvera el primer indice que esté desocupado. O -1 si esta todo lleno de items.

Luego para dibuijar las cosas tendrias que ir al Evento Draw y colocar algo como:
[GML]
for(i=0; i<global.MAX; i++){
      draw_sprite(spr_cuadradito_del_inventario, x + (sprite_get_width(spr_cuadradito_del_inventario) * i, y); //esto dibujaria tantos cuadraditos como maximo de slots haya en el inventario
}

for(i=0; i<global.MAX; i++){ //este ciclo dibujaria los items

     if (inventario == "navaja") //si en el espacio "i" hay una navaja, dibujarla
                 draw_sprite(spr_navaja,  x + (sprite_get_width(spr_cuadradito_del_inventario) * i, y);

     if (inventario == "comida") //si en el espacio "i" hay una navaja, dibujarla
                 draw_sprite(spr_comida,  x + (sprite_get_width(spr_cuadradito_del_inventario) * i, y);
}
[/GML]

eso dibujaria el inventario y los items necesarios, Cabe resaltar que los sprites tienen que ser igual tamaño que el sprite que hace de cuadradito en el inventario

Luego la forma de guardar un item, por ejemplo Evento Colision de Player contra Pocima:
[GML]
var espacio_vacio = scr_obtener_slot();
if (espacio_vacio != -1) //si hay espacio vacio
          inventario[espacio_vacio] = "pocima"
[/GML]

no probe el codigo, pero creo que la idea está

Complicado no es realmente, solo que hay que tener en cuenta muchas cosas. Primeo y principal, seria saber sobre como manejar buffers. Puesto que es la manera en que se mandan los datos a trevez del networking en GMS.
Para una explicacion detallada tenés el tutorial de Juca:
https://www.comunidadgm.org/articulos/tutorial-buffers-(parte-1-3)/msg125452/#msg125452

Si querés saber como funciona UDP podés mirar este tutorial de Ashe:
https://www.comunidadgm.org/articulos/tutorial-online-udp-39dll/msg128337/#msg128337
Que si bien usa una vieja DLL, el concepto de como funciona es el mismo. La diferencia con GMS es que tiene un propio evento asincrono para procesar los datos en vez de hacerlo en el evento step.

Si querés una explicacion detallada de como manjar TCP tenés mi tutorial extenso:
https://www.comunidadgm.org/articulos/(programacion)hacer-un-juego-multijugador-online-con-game-maker-studio-ver2/

Ahora, podés leer el tutorial de TCP y tratar de hacer algo con eso.
Una vez que dominés ese protocolo, solo extrapolalo a UDP. Que es en escencia mas sencillo que TCP.

////////////////////////////////////////////////
Revisando la Doc de otro motor(Godot) encontre esto:
https://gafferongames.com/post/what_every_programmer_needs_to_know_about_game_networking/

Está en español de donal trump, pero plantea el asunto el networking bastante especificado para juegos

saludos

Hola amigo, lo recomendable siempre para juegos que sean en tiempo real es usar UDP por la velocidad de transferencia. A diferencia de TCP, el protocolo UDP no verifica demasiado las cosas para poder trabajar, por lo que la velocidad aumenta considerablemente. Por contra si se pierden paquetes de datos, no es capaz de solventarlo.

Si ya trabajaste en algun otro motor haciendo juegos Online seguro con Game Maker es parecido.
Pero si sos novato en todo esto, lo menos que querrías hacer es hacer un juego online de primera, porque requiere muchisimos aspectos a tener en cuenta. Como ser, la programacion del juego en si, la logica, el gameplay. Por otro lado tendrias que programar la conexion y el envio de datos entre el juego y el servidor. Por otro lado, programar el servidor para que conecte  y envie datos a los juegos. Y si tu servidor planea alojar diversas partidas, es otro baile más.

Hola amigo, podrías combinar la respuesta de este post:
https://www.comunidadgm.org/preguntas-y-respuestas/comprobar-una-variable-de-todas-las-instancias-resuelto/msg136770/#msg136770

Que a grandes rasgos, lo que hace es almacenar en un vector todas las instancias creadas de un objeto determinado.
La parte que te tocaría programar sería la de elegir aleatoriamente y luego hacer que el objeto A, siguiera al objeto tomado aleatoriamente.

[gml]
randomize();
var cant = instance_number(obj_B);
var insta = vector_instancias[irandom(cant)];

move_towards_point(insta.x, insta.y, 5);
[/gml]
Ese codigo lo que hace, es escoger aleatoriamente uno de los tantos objetos B que haya y lo sigue.

Esta un poco tosco y tal, pero creo que la idea se entiende.

Lo que ocurre es que al momento de crear el proyecto colocaste "Drag and Drop", por lo cual solo se pueden usar los bloques.
En todo caso tendrías que crear un nuevo proyecto, seleccionadno "GML" para poder escribir puramente código.
Sin embargo existen estas soluciones:

   
• hacer click derecho en la ventana de acciones y colocar "Convert to GML".

   
• Empezar un nuevo proyecto para GML

   
• O programar con los bloques, haciendo la equivalencia de GML a D&D.

Efectivamente.
Aunque tambien se puede implementar con una alarma, como dato.

Usa audio_is_playing() para verificar que no se esté reproduciendo tal sonido, luego larga el que sigue.

https://docs.yoyogames.com/source/dadiospice/002_reference/game%20assets/sounds/audio_is_playing.html

Hola amigo, lo que podés hacer es crear un vector con espacios suficientes para las instancias de pelota.

[gml]
var i;
for (i = 0; i < instance_number(obj_pelota); i ++)
   {
   pelotas = instance_find(obj_pelota,i);
   }
[/gml]

luego, de iniciar el vector bastaría con recorrerlo y verificar si la velocidad en cada uno es cero.
Usarías una variable centinela para saber si todas cumplen o no en estar quietas.

Bueno, lo que estás haciendo mal es que, al usar el nombre del recurso "obj_comida" estás diciendo que borre todas las instancias de ese objeto.
En cualquier caso deberías obtener el ID de la instancia a destruir y se destruiría solo esa instancia y no todas.

Yo te recomendaria usar instance_nearest(...):
https://docs.yoyogames.com/source/dadiospice/002_reference/objects%20and%20instances/instances/instance%20functions/instance_nearest.html

Para obtener la instancia mas cercana,  y destruirla:

[GML]
if distance_to_object(obj_comida) < 3 and keyboard_check_pressed(vk_space)
var comida_cercana = instance_nearest(x,y, obj_comida);
if (comida_cercana != noone)
{instance_destroy(comida_cercana )
   if vida >= 0 {vida +=10}
   if vida > 100 {vida = 100}
   }
[/GML]

Acá hay un listado de errores que pasan al momento de ejecutar el proyecto:

https://docs.yoyogames.com/source/dadiospice/002_reference/debugging/runner%20errors.html

Basicamente lo que dice es que no declaraste intVXMax