Comunidad Game Maker

mis dieses <3 <3 <3 <3 <3 <3

ACTUALIZADO!
-Tenía un bug grave que podía hacerte perder la info de tus listas. Solucionado.

un admin del foro en inglés dice:
Hello! There is no native function to be able to do this and you'd have to write an extension for it.... And I have zero idea how you'd even start going about that I'm afraid.
es decir.. nativamente con GM no se puede.. que busques a ver si hay alguna extensión y que no puede ayudarle pk no tiene ni p idea xD
fuente: https://forum.yoyogames.com/index.php?threads/can-my-game-communicate-with-a-printer.87843/

he buscado en la marketplace a ver si hay algo y....
[spoiler]Sorry, no hay nada :(   xdd, así que mucha suerte.. busca cómo hacerlo en otros lenguajes y busca cómo implementar al GM tales lenguajes... no te queda otra[/spoiler]

Nombre del creador: Kostrón Sobakón
Breve descripción de su función: Nunca te ha pasado que quieres transformar en string una ds_list, pero el json solo sirve para ds_maps?, te da pereza tener que ingeniartelas cómo hacerlo? para qué, si ya lo hice yo por ti!! c:
Versión GM utilizada: GMS2.. pero meh, seguro sirve para todos o casi todos los GM
Modo de uso:
En el encoder, como argumento hay que poner una ds_list y devuelve un json (un ds_map transformado en string)
En el decoder, como argumento hay que poner un json (string que representa un ds_map... obviamente un json sacado de un jsln_encoder, si no no sirve!!!)
CódigoS (son 2, el encoder y el decoder):
[gml]
#region jsln encode
   function jsln_encode(_ds_list) {
      var _list = ds_list_create();
      ds_list_copy(_list,_ds_list);
      var _map = ds_map_create();
         ds_map_add_list(_map,"list",_list );
         var _json = json_encode(_map);
      ds_map_destroy(_map);
         
      return _json;
   }
#endregion
#region jsln decode
   function jsln_decode(_json) {
      var _map = json_decode(_json);
         var _ds_list = ds_list_create();
         ds_list_copy(_ds_list,_map[? "list"]);
      ds_map_destroy(_map);

      return _ds_list;
   }
#endregion
[/gml]

Adaptaciones a los antiguos scripts...
[gml]
///jsln_encode(ds_list)
var _list = ds_list_create();
ds_list_copy(_list,argument[0]);
var _map = ds_map_create();
   ds_map_add_list(_map,"list",_list );
   var _json = json_encode(_map);
ds_map_destroy(_map);
         
return _json;
[/gml]
[gml]
///jsln_decode(json)
var _json = argument[0];
var _map = json_decode(_json);
   var _ds_list = ds_list_create();
   ds_list_copy(_ds_list,_map[? "list"]);
ds_map_destroy(_map);

return _ds_list;
[/gml]

Cualquier duda, pss pregunten

NOTA IMPORTANTE!!! No se flipen con el tamaño de la password (no es necesario) pk peta con stack overflow!! (me acabo de dar cuenta xd)

Nombre del creador: Kostrón Sobakón
Breve descripción de su función: Encripta una string con apariencia de base64 pero cuando alguien trate de decodificarlo verá que no conseguirá nada aunque lo decodifique varias veces en cadena, pues pa eso está la "password" c:
Versión GM utilizada: GMS2.. pero meh, seguro sirve para todos o casi todos los GM
CódigoS (son 2, el encoder y el decoder):
[gml]
#region mega64_encode
   function mega64_encode(_string,_password) {
      var _str = _string;
      for (var i = 0; i < string_length(_password); ++i) {
         _str = string_char_at(_password,i+1)+base64_encode(_str);
      }
      db(_str)
      return _str;
   }
#endregion
#region mega64_decode
   function mega64_decode(_mega64_string,_password) {
      var _str = _mega64_string;
      var _reversed_pass = "";
      for (var i = 0; i < string_length(_password); ++i) {
         _reversed_pass += string_char_at(_str,0);
         _str = string_copy( _str,2,string_length(_str)-1 );
         _str = base64_decode(_str);
      }
         
      var _pass = "";
      for (var i = 0; i < string_length(_reversed_pass); ++i) {
         _pass += string_char_at( _reversed_pass,string_length(_reversed_pass)-i );
      }
         
      if (_password == _pass) { return _str; }
      else { return false; }
   }
#endregion
[/gml]

Adaptaciones a los antiguos scripts...
[gml]
///mega64_encode(string,password)

var _string = argument[0];
var _password = argument[1];
var _str = _string;
for (var i = 0; i < string_length(_password); ++i) {
   _str = string_char_at(_password,i+1)+base64_encode(_str);
}
db(_str)
return _str;
[/gml]
[gml]
///mega64_decode(mega64_string,password)

var _mega64_string = argument[0];
var _password = argument[1];
var _str = _mega64_string;
var _reversed_pass = "";
for (var i = 0; i < string_length(_password); ++i) {
   _reversed_pass += string_char_at(_str,0);
   _str = string_copy( _str,2,string_length(_str)-1 );
   _str = base64_decode(_str);
}
         
var _pass = "";
for (var i = 0; i < string_length(_reversed_pass); ++i) {
   _pass += string_char_at( _reversed_pass,string_length(_reversed_pass)-i );
}
         
if (_password == _pass) { return _str; }
else { return false; }
[/gml]

Supongo que no hace falta explicar su uso a detalle... se usa igual que el base64 pero con una pasword que tú te inventes.. poniendo siempre la misma que uses al encriptar.. para desencriptar, que si no la lías parda!! D:
Sé que se podría aprovechar mejor la pass, pero lo hice rápido, si alguna vez lo actualizo avisaré. Se aceptan sugerencias (otra cosa es que haga caso xD)

Ni me acordaba de este post, pero bueno ya que reviviste, aquí tienen un tuto que me sirvió bastante para aprender un poco todo lo que otros 800 videos me enseñaron de las bases de la machine learning, aplicado a GML. Posible sí que es, he obtenido buenos resultados con unas pruebas y malos con otras. Lo que aun me cuesta de entender es qué clase de "pesos" (bias) debería poner en según qué circunstancias. Espero a alguien le sirva, a mí sí me sirvió y le dí duro hasta que me cansé xd

https://highleapstudios.wordpress.com/2019/09/24/neural-network-in-game-maker-studio-1/

primero de todo... al CREAR server, no tienes que poner ninguna ip :/

pasa el código que usas para crear el socket

en hamachi hay 2 IPs, la IPv4 y la IPv6  cuál estás usando? Has abierto el server desde el mismo GM (testeando) y has mirado si sale algo en la consola? Añadiste el server (y el cliente también por si acaso) a las excepciones del Firewall?

PD: si te pasas por el discord del foro podremos hacer pruebas más rápidamente

Si has hecho todo correctamente, usar hamachi sí debería funcionar. Lo que sirve en local sirve también en online si configuras todo bien. Hamachi hace que no te haga falta tal configuración, así que no debería haber ningún problema. Podrías, antes de postear, haberlo probado tú mismo y ya si falla algo traer la duda. Este post es demasiado abstracto xd

Buenakas! ando haciendo un plagio genérico de maincra, tengo ya 170 items programados, mecánicas sofisticadas, crafteos, construcción etc... muy muy avanzado. Y actualmente empecé a hacer pruebas para la generación de un mapa muy muy grande. El tamaño que he considerado para la room principal de la superficie, la cual trato de generar un terreno pseudo-aleatorio de tierra y más alante poner bordes de arena simulando playas, es de exactamente 12800x12800px, usando una view de 640x352px

Como la interacción con esta tierra base, es mínima y la puedo detectar de muchas maneras, he decidido usar tiles que es mil veces más eficientes que poner una cantidad muy muy masiva de objetos, aun desactivándolos a fuera de la room, entonces, mi generación consiste en un objeto, con un sprite de 2048x2048 las cuales tiene unos cuantos frames con distintas formas que funcionarán como plantillas de pseudo-aleatoriedad. Uso un objeto con este sprite, con el siguiente código:

create:
[gml]///init

//coloco el generador con el sprite plantilla en el centro de la room, snapeado a una grid de 16x16
x = floor( (room_width/2)/16 )*16;
y = floor( (room_height/2)/16 )*16;
image_speed = 0;

//el centro tendrá la plantilla del frame 0 siempre
image_index = 0;
image_angle = irandom(359);

//inicializamos variables de la generacion
procesos = 100; //veces que la plantilla cambiará de forma y se moverá de lugar
tubo = 0; //variable para controlar una barra de carga basada en los procesos

//rellenar la plantilla principal
for (var i=x-1024;i<x+1024;i+=16) {
    for (var j=y-1024;j<y+1024;j+=16) {
        if collision_point(i,j,oterraingen,true,false) {
            tile_add(tdirt,0,0,16,16,i,j,5);
            }
        }
    }

//actualizacion de variables
procesos--;
tubo++;
[/gml]

step:
[gml]///generar terreno

if procesos {
    //mover plantilla
    x = floor( irandom_range(2048,room_width-2048)/16 )*16;
    y = floor( irandom_range(2048,room_height-2048)/16 )*16;
   
    //cambiar de forma
    image_index = irandom(image_number-1);
    image_angle = irandom(359);
   
    //rellenar plantilla nueva con tiles
    for (var i=x-1024;i<x+1024;i+=16) {
        for (var j=y-1024;j<y+1024;j+=16) {
            if collision_point(i,j,oterraingen,true,false)
            && !tile_layer_find(5,i,j) {
                tile_add(tdirt,0,0,16,16,i,j,5);
                }
            }
        }

    //actualizacion de variables
    procesos--;
    tubo++;
    }
else {
    //volver al centro, crear al jugador y destruirse para empezar la partida
    x = room_width/2;
    y = room_height/2;
    instance_create(x,y,oplayer);
    view_object[0] = oplayer;
    instance_destroy();
    }[/gml]

y de extra, irrelevante al problema, el tubo de carga en ev draw:
[gml]///draw tubo loading

var _tmaxlengh = 500;
var _tmax = 100;
var _tpos = tubo*_tmaxlengh/_tmax;

var _x = view_xview[0]+view_wview[0]/2-_tmaxlengh/2;
var _y = view_yview[0]+view_hview[0]/2;

draw_set_colour(c_black);
draw_rectangle(0,0,room_width,room_height,false);

draw_set_colour(c_white);
draw_rectangle(_x,_y-2,_x+_tmaxlengh,_y+2,true);
draw_rectangle(_x,_y-2,_x+_tpos,_y+2,false);[/gml]


Una vez hayan entendido el método que hice, veo que solo con 100 procesos (y no niego que me encantarían más), se me genera un terreno (una especie de gran isla) que me acaba de gustar sin que quede tierra suelta inaccesible y/o formas muy raras que no me convencen... Observo que usar tiles, probablemente sí ayuda, incluso si están activos todos a la vez ( hablamos de +300k tiles ), pero claro, como podrán adivinar... se me tira ~20 mins generando terreno y esto me parece un problema MUY GORDO que hará que el jugador se canse de esperar y cierre el juego...

Alguna sugerencia para mejorar este método. O incluso alguna idea para tener una generación parecida aun que deba de cambiar radicalmente el método?

parecía que si funcaba pero no, pasa lo mismo o algo parecido, con 0.6 parece que oc, con 0.8 va mal para según qué dirección

[gml]///path_start_alt(ind,speed)

var _xx = path_get_point_x(argument[0],1);
var _yy = path_get_point_y(argument[0],1);

dir = point_direction(x,y,_xx,_yy);
spd = argument[1];[/gml]

ya tengo mis vars de spd, hsp, vsp y dir PROPIAS, con el ípico bucle que aplica el movimiento

[gml]for ( var i=0;i<abs(hsp);++i )
        if place_free( x+sign(hsp),y )
        && !place_meeting( x+sign(hsp),y,owater )
        && !place_meeting( x+sign(hsp),y,oswamp )
            x += sign(hsp)*min( 1,abs(hsp) );
        else {
            if hsp != 0 {
                dir = irandom(359);
                get_hsp();
                }
            }
    for ( var i=0;i<abs(vsp);++i ) {
        if place_free( x,y+sign(vsp) )
        && !place_meeting( x,y+sign(vsp),owater )
        && !place_meeting( x,y+sign(vsp),oswamp )
            y += sign(vsp)*min( 1,abs(vsp) );
        else {
            if vsp != 0 {
                dir = irandom(359);
                get_vsp();
                }[/gml]

[gml]///get_hsp()

hsp = dcos(dir)*spd;[/gml]

[gml]///get_hsp()

hsp = -dsin(dir)*spd;[/gml]


no podría aprovechar esas vars simplemente asignando la dir con point_direction?

Y no acabo de comprender lo de sacar punto por punto, insisto que cada 2 steps (o 1 si es posible), se reinicia todo, entonces, no podría ahorrarme el for y pillar simplemente el primer x,y (que no sé si ser´el 0 o el 1) y aplicar la dir y la spd y ya está?

algo así?

[gml]var _pointsx =  ds_list_create();
var _pointsy =  ds_list_create();
for ( var i=0;i<path_get_number(argument[0]);i++ ) {
    ds_list_add(_pointsx,path_get_point_x(argument[0],i) );
    ds_list_add(_pointsy,path_get_point_y(argument[0],i) );
    }[/gml]

a partir de aquí no se me ocurre cómo seguir, desconozco mucho tanto las funciones path como las de ds_ xDD

Tengo el clásico sistema de pathfinding que enseñan en el 99% de los tutoriales

[gml]///AI_init(width,height,precise)

precise = argument[2];
width = argument[0];
height = argument[1];

_grid = mp_grid_create(0,0,ceil(room_width/argument[0])
,ceil(room_height/argument[1]),argument[0],argument[1]);
_path = path_add();
_obstacles = ds_list_create();

mp_grid_add_instances(_grid,obj_wall,precise);

_priorityGrid = ds_grid_create(width,height);
[/gml]

y

[gml]///AI_patrol(x,y,allowDiagonal,speed)

if !mp_grid_path(_grid,_path,x,y,argument[0],argument[1],argument[2]) {
    //show_debug_message("Path could not be computed")
    return false;
    }
else{
    path_start(_path,0.6,path_action_reverse,true)
    return true;
    }[/gml]

me funciona bien pero... solo si pongo una speed >= 1... si pongo una speed < 1 por ejemplo 0.6 pues ya no funciona cuando ha de dirigirse hacia abajo y/o derecha, sin embargo arriba y/o izquierda sí funca... me topé con el mismo problema con más velocidad cuando implementé estos scripts en el evento step, entonces lo cambié a un bucle de 2 steps en una alarm y se arregló, hasta ahora que lo estoy intentando con menos velocidad.

Antes que comentéis lo que me imagino, la razón por la que la quiero poner en bucle es porque mi juego, a parte de que el pathfinding lo hago para los enemigos sigan al player (y el player obviamente se mueve xd),  también he de resetear a tiempo real los obstáculos, ya que es un juego estilo minecraft y las paredes, agua, etc (obstáculos) pueden cambiar en cualquier momento.

Cómo soluciono esto? me encantaría poner enemigos lentos :(

no quiero ser duro pero....

han pasado casi 13 años... Cuándo vas a presentar un juego que no se programe en media hora? xd