Comunidad Game Maker

Hola saludos cordiales

En el evento step tienes un problema visible, dices que la condicion se cumple si induce<=Referencia final. Y ESO impide que indice supere a LA referencia final para poder destruir LA inatancia.. Intents con indice<=referencia.final+1....

Bueno' intents e informa

Hola, saludos cordiales.



1.   Esta comunidad me gusta y no la cambio. Aunque hace poco intenté participar en el surgimiento de otra. ver más.

2.   No sé dibujar, las imágenes son una copia a blanco y negro de algunos animes. Más abajo se explica la técnica usada.

3.   El error de plantilla, es un error real que surgió repentinamente y duró una o dos semanas aproximadamente. El error persiste pero en menor escala.



Ahora bién, discord sirve para mantenernos comunicados, pero es muy diferente a esta comunidad, porque aquí no hacemos más nada que concentrarnos en la programación.



Algunos detalles que pasaron desapercibidos


Aspectos técnicos del juego:

A simple vista el juego puede ser creado en uno o dos días, pero la base que lo soporta ya tiene dos meses de programación y todavía no ha finalizado.

Móvil en vertical

Movil en horizontal

Controles de consola y josytick


Lamentablemente no he comprobado la funcionalidad de los controles de la Xbox y de la playstation, el código empleado para integrar, el teclado, los joystick y los gamepad de consolas es el siguiente:

[gml]//////Funciones del teclado
b1=(keyboard_check(vk_right)||keyboard_check(ord("D")));
b2=(keyboard_check(vk_up)||keyboard_check(ord("W")));
b3=(keyboard_check(vk_left)||keyboard_check(ord("A")));
b4=(keyboard_check(vk_down)||keyboard_check(ord("S")));
b5=(keyboard_check(ord("1"))||keyboard_check(97)||keyboard_check(ord("Z")));
b6=(keyboard_check(ord("2"))||keyboard_check(98)||keyboard_check(ord("X")));
b7=(keyboard_check(ord("3"))||keyboard_check(99)||keyboard_check(ord("C")));
b8=(keyboard_check(ord("4"))||keyboard_check(100)||keyboard_check(ord("V"))); 
b9=keyboard_check(vk_enter);

///////////Es tableciendo comunicacion con el gamepad
usando_gamepad=0;
gp1=0;
gp2=0;
gp3=0;
gp4=0;
gp5=0;
gp6=0;
gp7=0;
gp8=0;
gp9=0;

if(global.game_maker="studio")
{
   global.gamepad_soportado=0;
   global.gamepad_conectado=0;

   global.gamepad_soportado=gamepad_is_supported();
   if(global.gamepad_soportado)
   {
      global.gamepad_conectado=gamepad_is_connected(0);
   }

   ///Para saber si una tecla esta presionada

   if(global.gamepad_conectado)
   {
      gp1=gamepad_button_check(0, gp_padr);
      gp2=gamepad_button_check(0, gp_padu);
      gp3=gamepad_button_check(0, gp_padl);
      gp4=gamepad_button_check(0, gp_padd);
      gp5=gamepad_button_check(0, gp_face1);
      gp6=gamepad_button_check(0, gp_face2);
      gp7=gamepad_button_check(0, gp_face3);
      gp8=gamepad_button_check(0, gp_face4);
      gp9=gamepad_button_check(0, gp_start);
   }
}

//Verificando que se esta usando el game pad
//para bloquear las funciones del joystick

if(gp1 || gp2 || gp3 || gp4 || gp5 || gp6 || gp7 || gp8 || gp9)
{
   usando_gamepad=1;
}

///joystick para window
jb1=0;
jb2=0;
jb3=0;
jb4=0;
jb5=0;
jb6=0;
jb7=0;
jb8=0;
jb9=0;

if(usando_gamepad=0)
{
   if(joystick_exists(1))
   {
      jb1=(joystick_xpos(1)>0);
      jb2=(joystick_ypos(1)>0);
      jb3=(joystick_xpos(1)<0);
      jb4=(joystick_ypos(1)<0);

      jb5=joystick_check_button(0,1);
      jb6=joystick_check_button(0,2);
      jb7=joystick_check_button(0,3);
      jb8=joystick_check_button(0,4);
      jb9=joystick_check_button(0,5);
   }
}

//Comprobando entrada de botones

global.boton_right_check=(b1 || gp1 || jb1);
global.boton_up_check=(b2 || gp2 || jb2);
global.boton_left_check=(b3 || gp3 || jb3);
global.boton_down_check=(b4 || gp4 || jb4);
global.boton_z_check=(b5 || gp5 || jb5);
global.boton_x_check=(b6 || gp6 || jb6);
global.boton_c_check=(b7 || gp7 || jb7);
global.boton_v_check=(b8 || gp8 || jb8);
global.boton_enter_check=(b9 || gp9 || jb9);

global.boton_right_pressed=(global.boton_right=0)*global.boton_right_check;
global.boton_up_pressed=(global.boton_up=0)*global.boton_up_check;
global.boton_left_pressed=(global.boton_left=0)*global.boton_left_check;
global.boton_down_pressed=(global.boton_down=0)*global.boton_down_check;
global.boton_z_pressed=(global.boton_z=0)*global.boton_z_check;
global.boton_x_pressed=(global.boton_x=0)*global.boton_x_check;
global.boton_c_pressed=(global.boton_c=0)*global.boton_c_check;
global.boton_v_pressed=(global.boton_v=0)*global.boton_v_check;
global.boton_enter_pressed=(global.boton_enter=0)*global.boton_enter_check;

global.boton_right=(b1 || gp1 || jb1);
global.boton_up=(b2 || gp2 || jb2);
global.boton_left=(b3 || gp3 || jb3);
global.boton_down=(b4 || gp4 || jb4);
global.boton_z=(b5 || gp5 || jb5);
global.boton_x=(b6 || gp6 || jb6);
global.boton_c=(b7 || gp7 || jb7);
global.boton_v=(b8 || gp8 || jb8);
global.boton_enter=(b9 || gp9 || jb9);
[/gml]

Necesito que me ayuden a comprobar si los controles responden correctamente al juego, para de esa manera seguir afinando el código.


Pantallas táctiles:

Tuve que recorrer otro camino bastante entrincado, tratando de imitar la draw gui empleando un orrible sistema de escalas el cual involucra toda la superficie el canvas (superficie html5 donde se presenta el video juego) y toda el área del navegador web.


Game Maker 4 (año 2003)

Inicialmente el sistema se programa en game maker studio, pero la mayor parte fue programada con game maker 4, y game maker studio se empleó básicamente para poder exportar a html5. Se pueden apreciarla lista de alguno de los scripts empleados, sin mencionar los scripts internos del controlador del juego, el player, el mapa, el  agua que sube y las burjas.


Imágenes:

La verdad es que no sé dibujar, o mejor dicho carezco de práctica en el dibujo. La imágenes que se pueden apreciar en el juego fueron producto de una técnica de calqueo:


fin.

Saludos, seguimos programando.


Imagen del juego out of this world de snes.

Hola, saludos cordiales.



Saludos 3dgeminis, discúlpeme por interrumpir, perdóname esta.  :-[ , le dejo la version html5 que puede ejecutar desde aquí, para que vea el resultado directamente.

https://ndika3y7yuiuyd81pfplkq-on.drv.tw/www.dixonweb.dx/games/ventilador_html5/







¿Tienes un problema con tu ventilador (abanico)?, no te preocupes, hoy estas de suerte, afortunadamente me dedico a la reparación de computadoras, ventiladores y lavadoras (no automáticas) y en mis tiempos libres programo en game maker. Para continuar, tendremos presente que se le llamará "ventilador" al abanico, porque así lo llamamos en Venezuela.





Viendo bien el código de tu ventilador, "no me gusta su aspecto", al parecer le ha entrado polvo, hay que hacerle mantenimiento, comprarle los rodamientos (bocinas, rolines) nuevos, y echarle buena grasa, pero para eso hay que destaparlo por completo, es por eso que la mano de obra (mi trabajo técnico) te sale más o menos (te cuesta aproximadamente, te costará alrededor de, tendrá un precio aproximado de) 10 dólares americanos incluyendo el costo de los repuestos (refacciones). XD.
La global.fan_on es el interruptor de encendido. Debería llamarse global.fan_ switch, ya que es incorrecto llamar a los interruptores de corriente "apagadores o encendedores", su nombre técnico es "interruptores" porque interrumpen el paso de la corriente eléctrica. Ahora bien, en el script que presentas no me indicaste la función que enciende al ventilador, es decir: me entregastes un ventilador sin el interruptor. Pero no te preocupes porque aunque lo encendí en el evento CREATE me di cuenta que no arrancaba, luego se recalentó (aumentó su temperatura, se puso caliente) y comenzó a echar mucho humo, entonces lo apagué antes de que se terminara de dañar.





La variable global.spins_number, no está haciendo absolutamente nada, es un cable que está demás, no tengo idea porque el técnico anterior lo dejó hay, pero no te preocupes que tengo fé de que te lo voy a reparar, he trabajado con ventiladores en condiciones más desfavorables.

El script approach representa el capacitor (condensador o filtro) el cual le da el primer impulso de corriente al embobinado produciendo un fuerte campo magnético. No he trabajado con ese modelo de script que me presenta, pero estuve investigando bastante y descubrí que es correcto usar este tipo de script para acelerar ventiladores, entre otras cosas. Es decir tu script está bueno.

Estuve trabajando por aproximadamente 3 horas para hallarle la solución a tu ventilador (abanico) y logré repararlo.
Descubrí que estabas usando el script approach de manera incorrecta, así es como debe usarse:
Este es el script:
scr_approach(variable a sumar, valor maximo, aceleracion)

El primer argumento (el argumento0), llamado "variable a sumar", es la variable que va a cambiar de valor o que va a ser incrementada, no es una variable fija, el segundo argumento (valor máximo), es el valor máximo que tendrá  la variable del primer argumento, y el tercer argumento es la velocidad o el factor de aceleración que tendrá la variable, en otras palabras será el valor que se le sumará variable por cada paso o step. Es un poco confuso entender todo esto, pero con la práctica se domina el tema.

El ángulo también presentaba problemas, ya que no estaba recibiendo correctamente el valor solicitado.
Esto fue lo que hice:

1.   Modifiqué el script, permitiendo que el ventilador girara, y que su inicio fuera acelerado como los ventiladores reales.
2.   Agregué un evento del teclado para apagar y encender el ventilador el presionar ENTER.
3.   Agregué otro pequeño script, para que el ángulo se mantenga dentro de los 360 grados y no salga de ahí.
4.   Anexé otro pequeño script approach para la disminución del giro a la hora de apagar el ventilador (abanico), para que también se disminuyera su aceleración al apagar.
5.   Agregué un pequeño código muy útil, el cual permite visualizar fácilmente el estado de las variables cuando está en ejecución, lo he llamado draw_text_super2.  Este código es necesario para todos los programadores del game maquer, ya que facilita en gran manera el desarrollo al permitir visualizar las variables de la manera más rápida y cómoda que estar usando la variable draw_text por cada variable.

El script quedó de la siguiente manera:
[gml]//[create]
angle=0
fan_power=0;
fan_power_min = 0;
fan_power_max = 10;

aceleracion=1
friccion=1

global.fan_on=false;

//variable de texto
zzz=""[/gml]

[gml]///[Alar0]
global.spins_number+=1;

//instance_create_depth(x,y,depth-999,obj_auto_guardar)
[/gml]


[gml]//[STEP]

if (global.fan_on=true) and (alarm[0]==-1) {alarm[0]=room_speed/2}
if (global.fan_on=false) alarm[0]=-1


if (global.fan_on=true)
{
   angle=angle+fan_power
   fan_power=scr_approach(fan_power,fan_power_max,aceleracion)
}
else
{
    angle=angle+fan_power
   fan_power=scr_approach(fan_power,0,aceleracion)
}

//Para mantener el ángulo dentro de los 60 grados
if(angle>360){angle=angle-360}
if(angle<0){angle=angle+360}[/gml]



[gml]//[DRAW]
draw_sprite_ext(sprite_index,image_index,x,y,image_xscale,image_yscale,angle,c_white,1)

draw_text(x,y,string(angle))


////texto para visualizar variables
dx=0;
dy=0;
fuente_size=20;
fuente_espacio=fuente_size+fuente_size/2;

draw_text(dx,dy,"global.fan_on: "+string(global.fan_on));dy+=fuente_espacio;if(dy>room_height-fuente_espacio){dy=0;dx+=room_width/2}
draw_text(dx,dy,"fan_power: "+string(fan_power));dy+=fuente_espacio;if(dy>room_height-fuente_espacio){dy=0;dx+=room_width/2}
draw_text(dx,dy,"angle: "+string(angle));dy+=fuente_espacio;if(dy>room_height-fuente_espacio){dy=0;dx+=room_width/2}
draw_text(dx,dy,"zzz: "+string(zzz));dy+=fuente_espacio;if(dy>room_height-fuente_espacio){dy=0;dx+=room_width/2}
draw_text(dx,dy,"zzz: "+string(zzz));dy+=fuente_espacio;if(dy>room_height-fuente_espacio){dy=0;dx+=room_width/2}
draw_text(dx,dy,"zzz: "+string(zzz));dy+=fuente_espacio;if(dy>room_height-fuente_espacio){dy=0;dx+=room_width/2}
draw_text(dx,dy,"zzz: "+string(zzz));dy+=fuente_espacio;if(dy>room_height-fuente_espacio){dy=0;dx+=room_width/2}[/gml]



[gml]///EVENTO PRESS <ENTER>
//Para encender y apagar el ventilador.

if(global.fan_on=true)
{
global.fan_on=false;
}
else
{
global.fan_on=true;
}
[/gml]





Realmente no estoy cobrando, pero si usted cree que sería conveniente darme una donación, se la aceptaré con gusto, pero si no puede no importa, seguiremos siendo amigos. XD  8). Aqui le dejo el gmz para game maker studio 1.4 el cual puede ser importado a game maker studio 2.

https://drive.google.com/u/0/uc?id=1w1tjGL7H2cj4_5-apYhGCX2rSFrIYGZK&export=download

Hola, saludos, espero que estés bien.

No tengo buenas noticias, solo te voy a contar mi experiencia: Si más no recuerdo hace algún tiempo había encontrado una información que decía que por razones de seguridad estaban bloqueadas o limitadas las funciones relacionadas con la administración de archivos y/o carpetas, en algunos sistemas. Por tanto borrar carpetas y/o archivos que se encuentren fuera de la carpeta de trabajo( donde está alojado el juego), es casi imposible, a menos que alguna extensión logre revelar el secreto. Pero no te preocupes.



para eso se crearon los archivos .ini, que no son no más que; simples hojas creadas en el block de notas en las cuales "siguiendo las instrucciones"; puedes modificar información, almacenar y administrar datos en cualquier sistema, "en teoría".

Información sobre archivos ini:

https://manual.yoyogames.com/#t=GameMaker_Language%2FGML_Reference%2FFile_Handling%2FIni_Files%2FIni_Files.htm&rhsearch=ini&rhhlterm=ini

Anímate a usar archivos .ini, no son tan difíciles.... cuando se leen sus instrucciones tres veces. XD... en mi caso.

Hola, saludos cordiales.

Ventajas que puedo percibir.
1)   Los backgrounds son más ligeros en teoría, porque no almacenan datos sobre su "área de colisión o máscara", en cambio los sprites sí. Y cuando usamos texturas, normalmente no necesitamos la información de la máscara. Es decir al usar sprites estamos gastando más memoria de la que se requiere, "en teoría".


2)   Los sprites pueden ser secuenciales y los backgrouns normalmente no, por lo tanto si se requiere una textura animada como: la cara cuadrada de un personaje 3D hablando; en este caso utilizar una secuencia de imágenes es propio. Esto tambén está aplicado a los enemigos.


3)   La organización: Supongamos que queremos asignar un conjunto de imágenes a un grupo determinado de objetos los cuales presentan texturas similares y lo que queremos que estas imágenes cambien según la posición del objeto para representar: iluminación, texturas modificadas, degradación de textura, etc... Almagenar todas las imágenes relacionadas en un mismo sprite puede ser útil y más ordenado, que crear un conjunto de backgrounds. Aunque en cuanto a iluminación existen otras alternativas, yo me quedo con las empíricas ahorradoras.



Bueno, adiós...  :-[

Dos formas más:

Otra forma sería almacenar cada id en una variable global por cada objeto (como en el ejemplo del comentario anterior) y recurrir a esta cuando el objeto esté inactivo para obtener su id y luego la variable.

También se puede activar la instancia por un instante, obtener su id y volver a desactivarla. Para luego usar su id y obtener la ps. No creo que haya problemas en activar y desactivar una instancia en una pequeña fracción de tiempo, pues si se activa y desactiva en un mismo step (paso), sus variables deberían permanecer y ya sabemos que su evento créate no se vuelve a ejecutar.

;D

Tube que recurrir al manual y estas indicaciones encontré:

1)   Tenga en cuenta también que la activación y desactivación no son instantáneas,
2)   Una instancia desactivada efectivamente deja de existir en el juego, pero las instancias individuales aún pueden tener acceso a sus variables.
3)   Sin embargo, no puede usar con (objeto) o con (instancia) , sino que debe acceder a la instancia directamente usando su identificación única en la siguiente forma
val = inst.variable;
Ejemplo
val=object1.variable;
4)   NOTA: Si desactiva una instancia al iniciar la sala (es decir, desde el código de creación de la sala o desde un evento de creación de instancia de una instancia dentro de la sala), todas las instancias que se colocan dentro de la sala desde el editor de sala seguirán ejecutando su evento de creación antes de ser desactivado.

Opiniones:
Creo que el problema no es obtener la variable del objeto inactivo, el problema es obtener su id.
Lo que se puede hacer para obtener el id de las instancias inactivas es crear una lista que contenga todas las id con sus respectivas posiciones (x,y) de las instancias. Para luego evaluar si la distancia a algún objeto coincide con las posiciones y si se devuelve o no el id. Es decir, buscaremos un punto en el plano donde se encuentre la instancia, pero este punto será previamente almacenado en una lista. Ahora bien el objeto inactivo, luego de seguro volverá a activarse y su posición tendrá que actualizarse en la lista para que cuando se vuelva a desactivar se pueda acceder a él.

Hice una prueba pequeña  pero sin la dslits,
El objeto inactivo tiene en su evento créate:

[gml]aleatorio=random(10)
global.id_inactivo=id[/gml]

El objeto que desactiva instancias ejecutó:
instance_deactivate_object(object1)

Luego este objeto solicitó la variable de la instancia inactiva de esta forma:
[gml]inst=global.id_inactivo
numero=inst.aleatorio;
[/gml]

Luego la instancia inactiva, volvió a activarse y el valor de la variable aleatoria era el mismo, confirmando de que no se vuelve a ejecutar el evento create.

Este experimento funcionó correctamente, ahora solo quedaría utilizar las dslist para administrar a un número x de instancias.

Nota extra: nunca he usado la desactivación de instancias pero siempre la he necesitado y de ahora en adelante creo que la voy a usar. Antes, cuando el objeto salía de la view lo que hacía eliminarlo y luego creaba otro que servía de guía.

:-[

Hola, saludos cordiales.

Para acceder al valor de una variable de un objeto inactivo esta tiene que estar dentro de un script externo.
Ejemplo:
1)   En el evento créate del objeto inactivo escribes el nombre del script que contendrá el nombra de la variable a llamar. Ejemplo:
Script_objeto_inactivo()
[gml]ps=0
return ps[/gml]

2)   El objeto, que obtendrá la variable del objeto inactivo, tendrá que ejecutar el script
[gml]///Obteniendo la variable del objeto inactivo
Variable_inactiva=script_objeto_inactivo()[/gml]

Bien, el objeto está inactivo y podemos acceder a la variable que se haya declarado en el script.
Ahora bien, supongamos que queremos acceder a varias variables del objeto inactivo:

1)   En el evento creación llamamos al script "script_objeto_inactivo()", y este script debe contener:
script_objeto_inactivo()
[gml]ps=0;
live=100;
hp=20;

if(argument0="ps")
{
return ps;
}
if(argumento0="live")
{
return live;
}
if(argumento0="hp")
{
return hp;
}
[/gml]

Esto también se puede hacer con la sentencia switch.

2)   El objeto que quiere obtener la variable del objeto inactivo tiene que llamar al script y especificar la variable:
[gml]////Obteniendo alguna variable de un objeto inactivo
Vida_obj_inactivo= script_objeto_inactivo("live");
Hp_obj_inactivo=script_objeto_inactivo("hp");
Ps_objeto _inactivo("ps");[/gml]

Bien, pues ya podemos obtener cualquier variable del objeto inactivo...

Pero, bueno, supongamos que queremos un solo script, solo un script que controle a todos los objetos inactivos y pueda acceder a cualquiera de sus variables.

Bueno:

1)   En el evento créate de los objetos inactivos, llamamos al mismo script
[gml]Script_objetos_inactivos("asignar","objeto1","variables")[/gml]

2)   En el script escribimos
[gml]if(argument0="objeto1")
{
hp=5;
ps=10;
live=3;
}
if(argument0="objeto2")
{
hp=10;
ps=20;
live=5;
}

if(argument0="obtener")
{
if(argument2="hp")
{
return hp;
}

if(argument2="live")
{
return live;
}

if(argument2="ps")
{
retur ps;
}
}[/gml]

3)   En el objeto que obtendrá las variables de los objetos inactivos escribimos:
[gml]///obtener variables de los objetos inactivos
Obteto1_ps=script_objetos_inactivos("obtener","objeto1","ps")
Obteto2_hp=script_objetos_inactivos("obtener","objeto2","hp")[/gml]

Listo,  :-[

Hola, saludos cordiales.

El manual de Game Maker studio 2 en español sirve tanto para comprender el game maker studio 1 como el 2. Lo puedes descargar desde aquí:

http://www.mediafire.com/file/z2ym96s5pdiz1y8/GMS2_Spanish-master.zip/file

También puedes traducir manualmente algunas páginas del manual de game maker studio 1, con el traductor de google.
Imagen explicativa:

Es un Juego corto con una breve historia basada en hechos reales (con algunas modificaciones), donde intentaré contarles una pequeña vivencia familiar.


Descarga:
Puede jugarse en cualquier sistema, pero presenta problemas con la adaptación de pantalla (el canvas del html5)  :(, lo programé cuando no sabia mucho sobre canvas, ahora para arreglarlo tengo que volver a crearlo de cero.

Se juega diretamente en esta web:
http://estudiosistemas.infinityfreeapp.com/games/elPanDeNuestraFamilia/

En medio de esta crisis, un hombre intenta consolar a su mujer.

Se juega directamente en la siguiente web. https://dixonysusjuegoseducativos.000webhostapp.com/juegos_completos/aferrate_a_mi/index.html

Sinopsis

Tema: la triste exclusión social que sufren las personas que han contraído alguna enfermedad contagiosa.

Botones: valoro mucho la intuición, me gusta que las personas puedan encontrar los botones por sus propios medios. Admito que todavía me falta mucho por aprender sobre eso.

Duración: Lamentablemente es de poca duración, mi objetivo era crear un juego simple y corto con un mensaje profundo.

Anécdota:
Al acercarme a cierto grupo social, escuche una conversación sobre el virus que nos asecha, en ella se recomendaba no volver a visitar ni tratar a algunas personas lo cual me hiso sentir mucha tristeza y espontáneamente me surgió la motivación de crear un juego donde se pudiera transmitir el dolor que sienten las personas excluidas para generar conciencia en las personas discriminadoras. La motivación fue tal que comencé a crearlo a las 11:00 pm (23:00) y no dormí nada hasta que lo culminé las 5:00 am aproximadamente.

Datos técnicos:
Aunque solo es un juego simple, sirve de base para comprender la importancia de la accesibilidad y para establecer una nueva estrategia de programación o un nuevo modelo de juego que nos permita hacerle frente a la gran ola de video juegos.

Retos informáticos por alcanzar:

Estos tres retos informáticos tienen el propósito de aumentar la accesibilidad e inteligibilidad del juego.
Inteligibilidad del juego: la capacidad que tiene un juego para ser comprendido por diversos grupos sociales, a esto se aplica la posibilidad de cambiar el idioma.

Accesibilidad del juego: Posibilidad de acceder al juego de manera fácil e inmediata.
1.   Multisistema: Lograr que se pueda ejecutar en móviles desde la web html5. Para esto es solo es necesario integrar el movimiento del mouse y permitir la adaptación de pantallas.
2.   Guardado web: Lograr que la web al ser guardada pueda guardar también el juego correctamente.
3.   Idioma: Lograr que se presente en dos o más idiomas.

Correcciones al juego:
1.   Uso de teclas.
2.   Palabras escritas incorrectamente.

Hola, gusto en saludarlos.

Un niño juega y dibuja garabatos de colores luego presenta su obra de arte a su padre; el mira aquel desordenado dibujo y lo considera hermoso porque lo hiso su hijo, y el niño luego al ver la alegría del padre, vuelve a hacer otro dibujo y se lo muestra  a su madre. Tanto su padre como su madre al ver su obra de arte, tratan de evaluarla con sinceridad y con mucho entusiasmo y le dicen a su hijo "Que bella obra de arte has hecho", el niño al ver la sonrisa se siente motivado a seguir dibujando garabatos.

Motiva y serás motivado, eso quiere decir que para ser motivados necesitamos motivar a alguien. Cuando perdemos la motivación es hora de buscar a alguien para motivarlo. La motivación es como una siembra, hay que sembrar y luego cosechar, y la desmotivación es como la carencia de alimentos por falta de trabajo. Por tanto hay que motivar para ser motivado, hay que sembrar para luego cosechar, hay que ayudar para ser ayudado, hay que dar ánimo para recibir ánimo.

Agradecimientos a algunos maqueros:

TU PADRE: tu programa es bueno y sinceramente me ha gustado, es bastante sencillo porque me gustan las ideas nuevas que son diferentes, además me ha dado muchas ideas nuevas, felicidades de verdad.

DARKKRULER: coloque en google la imagen que tienes de perfil, y he notado que se trata sobre una serie gráfica. Vi algunas escenas y sin duda es bastante profunda, misteriosa, me gustó mucho lo que hicieron los autores de esa serie, crearon una especie de serie anime bastante profunda que engancha a cualquiera.

Marth: Todavía estoy tratando de copiar la motivación que tienes, es bastante grande,  sabes sacarle provecho a los juegos y tu motivación es constante.

SHAORAN: increíble los juegos que has realizado, ¿Cómo fue posible que lograras trabajar con tantas variables en el juego de la ciudad?, armasteis tu propia web y sabes dibujar muy bien.

Clamud: es notorio tu esfuerzo por darle respuesta a todo aquel que tiene una duda sobre game maker, tu empeño por ayudar es grande, inclusive a mí me has motivado y alentado a seguir adelante con mis metas,

T789: sigue buscando respuestas y las tendrás, siempre con la ayuda de Dios por supuesto, tienes mucha motivación.

Black_cat: Sorprendentes los dibujos manga que realizas, y los conocimientos que tienes... que puedo decir, todavía no he leído la guía de conexiones online, se ve que le has puesto mucho empeño.

Kostra: Gracias por guiarme a conseguir el significado de la vida, no sé si mi interpretación es la correcta pero "uno" es el significado de la vida, por tanto la humanidad es lo más importante, y lo más importante de un video juego son los autores de los mismos.

Cher3: la música es bastante motivadora y alegue, no he dejado de escucharla, con ella reflejas también que eres una persona alegre.

Me falto hablar de mis otros amigos, usuarios y administradores, espero que me disculpen.

Imagen de un juego que intente realizar pero perdí la motivación, en esta imagen se ven a algunos makeros de esta comunidad


Imagen de una historia que intente crear pero perdí la motivación.


:-[

Hola gusto en saludarlo.

Cuando las cosas se ponen dificiles en game maker, entonces hay que crear editores.

La tecnica que mencionas como locura es bastante genial si se mira desde un punto de vista distinto.

Dejame alardear un rato: "cuando el programador no puede programar del mismo modo porque la cantidad de codigos es exagerada entonces debe crear editores de codigo que hagan el trabajo pesado, entonces el programador ya no escribe codigos sino que contruye estructuras complejas presionando un par de botones".

Mi recomendacion es que sigas usando los 10 modelos, pero crea un editor de modelos 3D a tu medida, que facilite la creacion de estructuras arquitectonicas complejas y que devuelva el codigo necesario, el cual estaria compuesto por draw_set_color y draw_set_alpha.

Ahora bien, no estoy queriendo decir que contruyas un autocad 2020, solo un pequeño programa que ubique los 10 modelos en algun punto en el espacio 3D empleando el mouse y las teclas del cursor, donde se pueda definir sus colores y su alpha, inclusive su textura, presionando algunos botones de la interface. Luego que exista un boton llamado "generar codigo gmk" y que al presionarlo cree un archivo de texto con el codigo usado.

Hola, gusto en saludarlos.

Hay una propiedad en paper mario de wii  que siempre me llamó bastante la atención, es la propiedad de transformar mundos 3D en 2D y viceversa, tráiler Aquí.
Game maker puede hacer eso y mucho más, pero es necesario traspasar algunas fronteras de programación. No vengo a decirles cómo se crea ese efecto, vengo a hablarles de las nuevas fronteras, de esos nuevos retos que he encontrado al programar en Game Maker.






Mark Overmars declaró en su manual de Game Maker:

CitarEntonces, ¿esto significa que es imposible crear tus propios juegos de computadora? Afortunadamente no. Por supuesto que no deberías Espere crear su propio Quake o Age of Empires en unas pocas semanas.
Designing Games with Game Maker Version 6.1 Written by Mark Overmars.

Refurtando, diré que con game maker y herramientas especiales, se puede crear un Age of the empire o Quake en menos de un més. Las herramientas que se requerirían para lograr eso, no existen aún o no las conozco, pero sé que se pueden desarrollar con game maker al igual que con otros lenguajes de programación. Estas herramientas imaginarias, también pudiesen ser utilizadas para crear cosas sorprendentes las cuales enlistaré: