Comunidad Game Maker

¿Que tipo de juego se necesita en la actualizad?, Descubramos el misterio.

http://estudiosistemas.infinityfreeapp.com/Dixon/games/laBusquedaDelJuegoPredilecto/

Más información:
Lamentablemente no funciona en dispositivos móviles porque se me olvido agregar un simple código y no tengo tiempo por ahora para arreglarlo.  :'(

Autor: Reyes Dávila
breve descripción de su función: Dibuja una tabla de highscore adaptado a cualquier pantalla y bien organizado.
Versiones usadas: Game maker studio 1 y 2.





/*
Instrucciones:
1. Este script debe ser llamado: draw_highscore_plus;
2. En game maker studio 2 utilizar: function draw_highscore_plus(argument0,argument1,argument2){
3. Colocar en evento Draw/dibujo: draw_highscore_plus(color fondo,color titulo, color fuente);
4. Ejemplo: draw_highscore_plus(c_teal,c_navy,c_black);
*/


titulo_DXNS0006="Top Ten Players";

color_fondo_DXNS0006=argument0;
color_titulo_DXNS0006=argument1;
color_fuente_DXNS0006=argument2;
porcentaje_DXNS0006=95;
proporcion_DXNS0006=2/3;
scoreW_DXNS0006=porcentaje_DXNS0006*room_width/100;
scoreH_DXNS0006=scoreW_DXNS0006/proporcion_DXNS0006;
while(scoreH_DXNS0006>(95*room_height/100))
{
    porcentaje_DXNS0006-=1;
    scoreW_DXNS0006=porcentaje_DXNS0006*room_width/100;
    scoreH_DXNS0006=scoreW_DXNS0006/proporcion_DXNS0006;
}

scorex1_DXNS0006=(room_width-scoreW_DXNS0006)/2;
scorex2_DXNS0006=scorex1_DXNS0006+scoreW_DXNS0006;
scorey1_DXNS0006=(room_height-scoreH_DXNS0006)/2;;
scorey2_DXNS0006=scorey1_DXNS0006+scoreH_DXNS0006;

draw_set_color(color_fondo_DXNS0006);
draw_roundrect(scorex1_DXNS0006,scorey1_DXNS0006,scorex2_DXNS0006,scorey2_DXNS0006,0);

draw_set_color(color_titulo_DXNS0006);
width_DXNS0006=string_width(titulo_DXNS0006);
titulox_DXNS0006=scorex1_DXNS0006+(scoreW_DXNS0006-width_DXNS0006)/2;
tituloY_DXNS0006=scorey1_DXNS0006+7*scoreH_DXNS0006/100;
draw_text(titulox_DXNS0006,tituloY_DXNS0006,titulo_DXNS0006);

draw_set_color(color_fuente_DXNS0006);

for(i_DXNS0006=1;i_DXNS0006<=10;i_DXNS0006+=1)
{
    nombre_DXNS0006=string(highscore_name(i_DXNS0006))+".................................................................";
    txt_DXNS0006=string(i_DXNS0006)+". "+string(nombre_DXNS0006)+string(highscore_value(i_DXNS0006));
    while(string_width(txt_DXNS0006)>90*scoreW_DXNS0006/100)
    {
        length_DXNS0006=string_length(nombre_DXNS0006);
        nombre_DXNS0006=string_delete(nombre_DXNS0006,length_DXNS0006-5,1);
        txt_DXNS0006=string(i_DXNS0006)+". "+string(nombre_DXNS0006)+string(highscore_value(i_DXNS0006));
    }
    txt_DXNS0006=string(i_DXNS0006)+". "+string(nombre_DXNS0006);
    x1_DXNS0006=scorex1_DXNS0006+5*scoreW_DXNS0006/100;
    y1_DXNS0006=scorey1_DXNS0006+10*scoreH_DXNS0006/100;
    draw_text(x1_DXNS0006,y1_DXNS0006+i_DXNS0006*30,txt_DXNS0006);

    txt_DXNS0006=string(highscore_value(i_DXNS0006));
    width_DXNS0006=string_width(txt_DXNS0006);
    x1_DXNS0006=scorex1_DXNS0006+95*scoreW_DXNS0006/100-width_DXNS0006;
    draw_text(x1_DXNS0006,y1_DXNS0006+i_DXNS0006*30,txt_DXNS0006);
}


Úsenlo junto al script highscore online para tener una agradable tabla de puntuaciones online sin saber de php,sql o hosting. script hishcore_online instantáneo: https://www.comunidadgm.org/desarrollo-de-scripts/highscore_online-instantaneo/

:'(  Tengo más de 15 años deseando un script como este de score online y porfín lo he conseguido, espero que les sirva. :-[

Autor del script: Reyes Dávila (Dixon)
Nombre del script: angle_lines(x1,y1,x2,y2,x3,y3,sentido);
Breve descripción de su función: Devuelve el ángulo que forman dos líneas que tienen un punto en común.
Versiones usadas: Game maker 4. Debe funcionar en todas las versiones superiores. Sí funciona en Game maker studio 2.
Versión del script: 1 



//angle_lines(x1,y2,x2,y2,x3,y3,sentido);
//Devuelve el ángulo que forman dos líneas rectas que tienen un punto en común.
//Serial del script: _DXNS004

//Entrada de datos:
ix_DXNS004=argument0;
iy_DXNS004=argument1;
x1_DXNS004=argument2;
y1_DXNS004=argument3;
x2_DXNS004=argument4;
y2_DXNS004=argument5;
sentido_DXNS004=argument6;

pendiente1_DXNS004=(y1_DXNS004-iy_DXNS004)/((x1_DXNS004-ix_DXNS004)+0.0001*((x1_DXNS004-ix_DXNS004)=0));
pendiente2_DXNS004=(y2_DXNS004-iy_DXNS004)/((x2_DXNS004-ix_DXNS004)+0.0001*((x2_DXNS004-ix_DXNS004)=0));
pendiente1y2_DXNS004=(pendiente1_DXNS004-pendiente2_DXNS004)/((1+pendiente1_DXNS004*pendiente2_DXNS004)+0.0001*((1+pendiente1_DXNS004*pendiente2_DXNS004)=0));

//primera salida de datos:
angulo_DXNS004=arctan(pendiente1y2_DXNS004)*57.296;

direction2_DXNS004=point_direction(ix_DXNS004,iy_DXNS004,x1_DXNS004,y1_DXNS004);
distance2_DXNS004=point_distance(ix_DXNS004,iy_DXNS004,x1_DXNS004,y1_DXNS004);
direction3_DXNS004=point_direction(ix_DXNS004,iy_DXNS004,x2_DXNS004,y2_DXNS004)-direction2_DXNS004;
distance3_DXNS004=point_distance(ix_DXNS004,iy_DXNS004,x2_DXNS004,y2_DXNS004);
x4_DXNS004=ix_DXNS004+distance2_DXNS004*cos(0);
y4_DXNS004=iy_DXNS004-distance2_DXNS004*sin(0);
x5_DXNS004=ix_DXNS004+distance3_DXNS004*cos(direction3_DXNS004*pi/180);
y5_DXNS004=iy_DXNS004-distance3_DXNS004*sin(direction3_DXNS004*pi/180);


angulo2_DXNS004=abs(angulo_DXNS004);

if((y5_DXNS004<y4_DXNS004) and (sign(angulo_DXNS004)=-1)){angulo2_DXNS004=180-angulo2_DXNS004}
if((y5_DXNS004=y4_DXNS004) and (x5_DXNS004<x4_DXNS004)){angulo2_DXNS004=180}
if((y5_DXNS004>y4_DXNS004) and (sign(angulo_DXNS004)=1)){angulo2_DXNS004=180+angulo2_DXNS004}
if((y5_DXNS004>y4_DXNS004) and (sign(angulo_DXNS004)=-1)){angulo2_DXNS004=360-angulo2_DXNS004}
if(sentido_DXNS004){angulo2_DXNS004=360-angulo2_DXNS004}

return angulo2_DXNS004;





Modo de uso:

angle_lines(x1,y1,x2,y2,x3,y3,sentido): Este script es parecido al script que dibuja un triángulo. En x1 y y1 colocar el punto de colision entre las dos líneas, en x2 y y2 colocar la línea que representará la base en donde se comenzarán a contar los ángulos, y en x3 y y3 colocar un punto de la segunda línea, la cual es la línea móvil que formará el ángulo. En sentido colocar el sentido como se contarán los ángulos, normalmente se coloca -1 para sentido anti horario (como nos enseñaron en la escuela) y 1 para sentido horario.

Aquí dejo unas imágenes que pueden servir se guía:











Si existe alguna duda pueden consultarme por esta web.


Cómo funciona el script
El script calcula la pendiende de ambas líneas y con esto calcula la arco tangente para finalmente multiplicar el resultado por 57.296 para obtener el ángulo. Luego gira el triángulo que se forma para ubicar la línea de base de forma paralela al eje x para luego hacer comparaciones y obtener ángulos superiores a 90 grados.


Más información
El desarrollo de este script sigue vigente, estoy trabajando para que adquiera compatibilidad en todos los game makers ya que me puede servir en la creación de juegos de fake 3d.


Bibliografia del script
Este script lo construí en dos semanas aproximadamente y para lograrlo tuve que consultar muchos tutoriales sobre triángulos, angulos, y trigonometría. Estos son algunos de los consultados:


https://www.youtube.com/watch?v=PKeUzxt-C_k&list=LL&index=4
https://www.youtube.com/watch?v=c0SGuIk0Wds&list=LL&index=5
https://www.youtube.com/watch?v=gaJk7f_MPX4&list=LL&index=11
https://www.youtube.com/watch?v=k5ZmqESAMpw&list=LL&index=14


Bye...

Autor del script: Reyes Dávila (Dixon)
Nombre del script: arctan(x);
Breve descripción de su función: Devuelve la arco tangente de x.
Versiones usadas: Game maker 1, 2, 3, 4, al parecer funciona en todas las versiones.
Versión del script: 1 



//arctan_compatible(x)
//Calcula la arcotangente de x.
//para mayor precisión usar presicion_DXNS001=0.0001; //mientras más decimales mayor precisión.
//SeriAl del script: _DXNS001.


precision_DXNS001=0.01;
pendienteEntrada_DXNS001=argument0;
pendienteSalida_DXNS001=0;
continuar_DXNS001=1;
for(i_DXNS001=-pi/2; i_DXNS001<(pi/2) and continuar_DXNS001;i_DXNS001+=precision_DXNS001)
{
pendienteSalida_DXNS001=tan(i_DXNS001);
if(pendienteSalida_DXNS001>=pendienteEntrada_DXNS001){continuar_DXNS001=0}
}

radianes_DXNS001=i_DXNS001;

return radianes_DXNS001;



Más información
Este script fue creado para poder calcular la arco tangente en las versiones viejas GM1 y GM2 (año 2000), ya que no cuentan con esta función.

Este script carece de precisión y para aumentarla hay que aumentar la cantidad de decimales de la variable precision_DXNS001=0.01, ejemplo:  precision_DXNS001=0.00001. Al aumentar la precisión la velocidad de cálculo disminuye.

¿Cómo funciona el script?
El script crea un bucle que va desde –pi/2 hasta pi/2 para comparar el valor de x con tan(x), porque la arcotangente se calcula encontrando el valor que la tangente recibió para devolver la x de entrada.

Para lograr el script tuve que ver muchos videos de ángulos y uno de los que más me sirvió para comprender el cálculo de la arco tangente es el siguiente:

https://www.youtube.com/watch?v=1MjNl0m-g3c&list=LL&index=17&t=311s
El youtuber me dió un like por el comentario que le hice sobre el video.  :)

Tengo pensado seguir añadiendo información a este post ya que hay otras cosas extrañas e interesantes involucradas en el tema pero por los momentos no tengo mucho tiempo.

Bye...

Es un Script que contiene el juego de pong.






No se descarga, para jugar hay que copiar el código e introducirlo en game maker.

{
if(score<2)
{
juegoEstado="portada";
juegoEstadoCreate=1;
score=2;

celdas=17;

//#Bloquear="
roomwidth=room_width;
roomheight=room_height;
//"

celdaW_asd=roomwidth/celdas;
celdaH_asd=roomheight/celdas;

ballW_asd=1*celdaW_asd-2;
ballH_asd=1*celdaH_asd-2;

ballx_asd=8*celdaW_asd;
bally_asd=8*celdaH_asd;

balldx_asd=1-2*floor(random(2));
balldy_asd=1-2*floor(random(2));
ballxstar_asd=ballx_asd;
ballystar_asd=bally_asd;
ballVelocidadInicial=4;
ballVelocidad=ballVelocidadInicial;
ballVelocidadMaxima=10;

ballEstado="stop";
ballEstadoCreate=1;
ballTiempo=0;
ballTiempo2=0;
ballAceleracion=0.5;

tabla1H_asd=5*celdaH_asd-2;
tabla1W_asd=1*celdaW_asd-2;
tabla1ypos_asd=7*celdaH_asd;
tabla1x1_asd=1*celdaW_asd;
tabla1y1_asd=tabla1ypos_asd;
tabla1Velocidad=12;

tabla2H_asd=5*celdaH_asd-2;
tabla2W_asd=1*celdaW_asd-2;
tabla2ypos_asd=7*celdaH_asd;
tabla2x1_asd=15*celdaW_asd;
tabla2y1_asd=tabla2ypos_asd;
tabla2VelocidadInicial=12;
tabla2Velocidad=tabla2VelocidadInicial;
tabla2posicion=0;
tabla2posicionx=tabla2x1_asd+tabla2W_asd/2;
tabla2posiciony=0;

mb=0;

puntoP2=0;
puntoP1=0;
}

//botones a usar
//#bloquear="
if(keyboard_check(113)){game_restart()}
//mbp=(mb=0)*(mouse_button=1);
mousebutton=mouse_button;
//"
mb=(mousebutton=1);


if(juegoEstado="portada")
{
if(juegoEstadoCreate)
{
tiempo=0;
juegoEstadoCreate=0;
}
x1=8*celdaW_asd;
y1=5*celdaH_asd;
txt="Pong";
draw_text(x1,y1,txt);
tiempo+=1;
if(mb and tiempo>30){juegoEstado="juego";juegoEstadoCreate=1}
}


if(juegoEstado="final")
{
if(juegoEstadoCreate)
{
juegoEstadoCreate=0;
tiempo=0;
x1=7*celdaW_asd;
y1=5*celdaH_asd;
}
tiempo+=1;
x1=7*celdaW_asd;
y1=5*celdaH_asd;
txt="Gana el humano";
if(puntoP2>puntoP1){txt="Gana la PC"}
draw_text(x1,y1,txt);
if(mb and (tiempo>20)){score=0}
}


if(juegoEstado="juego")
{
if(juegoEstadoCreate)
{
juegoEstadoCreate=0
}


tabla1ypos_asd+=tabla1Velocidad-2*mb*tabla1Velocidad;


if(balldx_asd)
{
if((tabla2posiciony-ballH_asd)>(tabla2ypos_asd+(tabla2H_asd/4))){tabla2ypos_asd+=tabla2Velocidad}
if(tabla2posiciony<(tabla2ypos_asd+(tabla2H_asd/4))){tabla2ypos_asd-=tabla2Velocidad}
}

if((balldx_asd=-1) || (ballEstado="stop"))
{
if(tabla2ypos_asd>celdaH_asd*6){tabla2ypos_asd-=tabla2Velocidad}
if(tabla2ypos_asd<celdaH_asd*6){tabla2ypos_asd+=tabla2Velocidad}
}


if(ballEstado="play")
{
if(ballEstadoCreate)
{
ballEstadoCreate=0;
ballVelocidad=ballVelocidadInicial;
ballTiempo=0;
ballTiempo2=0;
ballx_asd=ballxstar_asd;
bally_asd=ballystar_asd;
balldx_asd=1-2*floor(random(2));
balldy_asd=1-2*floor(random(2));
tabla2Velocidad=tabla2VelocidadInicial;
}


ballTiempo+=ballVelocidad;
if(ballTiempo>=30)
{
ballTiempo=0;
ballx_asd+=balldx_asd*celdaW_asd;
bally_asd+=balldy_asd*celdaH_asd;
}


ballTiempo2+=1;
if(ballTiempo2>=30)
{
ballTiempo2=0;
ballVelocidad+=ballAceleracion;
if(ballVelocidad>ballVelocidadMaxima){ballVelocidad=ballVelocidadMaxima}
}


if(ballx_asd>(roomwidth-celdaW_asd)){ballx_asd=(roomwidth-celdaW_asd);ballEstado="stop";puntoP1+=1;ballEstadoCreate=1}
if(ballx_asd<0){ballx_asd=0;ballEstado="stop";puntoP2+=1;ballEstadoCreate=1}
c1=(puntoP1=3);
c2=(puntoP2=3);
if(c1 || c2){juegoEstado="final";juegoEstadoCreate=1}

}
else
{
if(ballEstadoCreate)
{
ballEstadoCreate=0;
ballTiempo=0;
}
ballTiempo+=1;
if((ballTiempo>30) and mb){ballEstado="play";ballEstadoCreate=1}
ballVelocidad=0;
}

}//fin if(juegoEstado="juego")



c1=(ballx_asd>tabla1x1_asd);
c2=(ballx_asd<tabla1x1_asd+tabla1W_asd+celdaW_asd);
c3=((bally_asd+1*ballH_asd)>tabla1y1_asd);
c4=(bally_asd<tabla1y1_asd+tabla1H_asd);
if(c1 and c2 and c3 and c4){balldx_asd=1}

c1=((ballx_asd+ballW_asd)<(tabla2x1_asd+tabla2W_asd));
c2=((ballx_asd+ballW_asd)>(tabla2x1_asd-celdaW_asd));
c3=((bally_asd+1*ballH_asd)>tabla2y1_asd);
c4=(bally_asd<tabla2y1_asd+tabla2H_asd);
c5=(balldx_asd=1);
if(c1 and c2 and c3 and c4 and c5){balldx_asd=-1;tabla2Velocidad-=1;if(tabla2Velocidad<0.5){tabla2Velocidad=0.5}}

if(bally_asd>(roomheight-1*celdaH_asd)){bally_asd=(roomheight-1*celdaH_asd);balldy_asd=-1}
if(bally_asd<0){bally_asd=0;balldy_asd=1}

x1=1+ballx_asd;
y1=1+bally_asd;
draw_line(x1,y1,x1+ballW_asd,y1);
draw_line(x1+ballW_asd,y1,x1+ballW_asd,y1+ballH_asd);
draw_line(x1+ballW_asd,y1+ballH_asd,x1,y1+ballH_asd);
draw_line(x1,y1+ballH_asd,x1,y1);


if(balldx_asd and balldy_asd){balldirection=-45}
if(balldx_asd and !balldy_asd){balldirection=45}
if(!balldx_asd and !balldy_asd){balldirection=135}
if(!balldx_asd and balldy_asd){balldirection=225}

pdx_asd=balldx_asd;
pdy_asd=balldy_asd;
pdirection=balldirection;

if(pdx_asd and pdy_asd){pdirection=-45}
if(pdx_asd and !pdy_asd){pdirection=45}
if(!pdx_asd and !pdy_asd){pdirection=135}
if(!pdx_asd and pdy_asd){pdirection=225}

x1=ballx_asd;
y1=bally_asd;
x2=x1;
y2=y1;

tabla2posicion=0;

i=0;
repeat(16)
{
i+=1;
x2=x1+i*celdaW_asd*cos(pdirection*pi/180);
y2=y1-i*celdaH_asd*sin(pdirection*pi/180);
if(y2>roomheight){y2=roomheight;pdy_asd=-1;x1=x2;y1=y2;i=0}
if(y2<0){y2=0;pdy_asd=1;x1=x2;y1=y2;i=0}
if(x2>roomwidth){x2=roomwidth;pdx_asd=-1;x1=x2;y1=y2;i=0}
if(x2<0){x2=0;pdx_asd=1;x1=x2;y1=y2;i=0}

c1=(y2>tabla1ypos_asd);
c2=(y2<(tabla1ypos_asd+tabla1H_asd));
c3=(x2>tabla1x1_asd);
c4=(x2<(tabla1x1_asd+tabla1W_asd));
if(c1 and c2 and c3 and c4){x2=(tabla1x1_asd+tabla1W_asd);pdx_asd=1;x1=x2;y1=y2;i=0}

if(pdx_asd and pdy_asd){pdirection=-45}
if(pdx_asd and !pdy_asd){pdirection=45}
if(!pdx_asd and !pdy_asd){pdirection=135}
if(!pdx_asd and pdy_asd){pdirection=225}

if(tabla2posicion=0)
{
c1=(x2>=(tabla2x1_asd-celdaW_asd));
if(c1){tabla2posicion=1;tabla2posicionx=x2;tabla2posiciony=y2}
}

//draw_pixel(x2,y2);
}

//draw_circle(tabla2posicionx,tabla2posiciony,5);


if(tabla1ypos_asd>(roomheight-tabla1H_asd)){tabla1ypos_asd=(roomheight-tabla1H_asd)}
if(tabla1ypos_asd<0){tabla1ypos_asd=0}
tabla1y1_asd=floor(tabla1ypos_asd/celdaH_asd)*celdaH_asd;
x1=1+tabla1x1_asd;
y1=1+tabla1y1_asd;
draw_line(x1,y1,x1+tabla1W_asd,y1);
draw_line(x1+tabla1W_asd,y1,x1+tabla1W_asd,y1+tabla1H_asd);
draw_line(x1+tabla1W_asd,y1+tabla1H_asd,x1,y1+tabla1H_asd);
draw_line(x1,y1+tabla1H_asd,x1,y1);


if(tabla2ypos_asd>(roomheight-tabla2H_asd)){tabla2ypos_asd=(roomheight-tabla2H_asd)}
if(tabla2ypos_asd<0){tabla2ypos_asd=0}
tabla2y1_asd=floor(tabla2ypos_asd/celdaH_asd)*celdaH_asd;
x1=1+tabla2x1_asd;
y1=1+tabla2y1_asd;
draw_line(x1,y1,x1+tabla2W_asd,y1);
draw_line(x1+tabla2W_asd,y1,x1+tabla2W_asd,y1+tabla2H_asd);
draw_line(x1+tabla2W_asd,y1+tabla2H_asd,x1,y1+tabla2H_asd);
draw_line(x1,y1+tabla2H_asd,x1,y1);

x1=8*celdaW_asd;
y1=1*celdaH_asd;
txt=string(puntoP1)+"/"+string(puntoP2);
draw_text(x1,y1,txt);


}




















Modo de uso:

1. Copia el código.
2. Abre tu game maker.
3. Crea un nuevo proyecto.
4. Crea un objeto.
5. Creale un evento draw/dibujo.
6. Pégale el código entregado.
7. Crea una room.
8. Introduce el objeto en la room.
9. Ejecuta el juego.


Más información:

Siempre me han gustado ese tipo de juegos que no necesitan descargarse. Mi objetivo es proporcionar un código compatible para todos los game makers.
Le diseñé un código para que la computadora con la cual vamos a competir sepa en donde va a caer la pelota para que sus movimientos sean más humanos.

Versiones y evolución del código:
Versión uno: solo era compatible desde game maker 4 hasta game maker studio 1.
Versión dos:  se agrega compatibilidad para incluir los 3 game makers más antiguos.
Versión tres:  Ahora es compatible también con Game maker studio 2.

Compatibilidad comprobada: ⭐ Funciona en todos los Game makers desde el antiguo Game Maker 1.4 (june 1, 2000) hasta GameMaker studio 2. No ha sido verificado si el juego funciona en los game makers para mac pero la teoria dice que sí.

Conocimientos adquiridos en el proceso:
1.   La potencialidad del Game Maker 1.4 (june, 1 2000) es alta, creo que se pueden crear sistemas interesantes de falso 3D.
2.   Game maker 1.4 (june, 1 2000) no usa las constantes: mb_left, mb_right.
3.   El valor inicial del score en game maker studio 2 es 1.
4.   En Game Maker studio 2 para declarar una variable tipo string no se puede usar comillas simples, solo comillas dobles.
5.   Problemas con fps: Las velocidades de procesamiento difieren entre los game makers y la variable fps que pudiese solucionar este problema no está disponible en todas las versiones, tampoco la current_time. Esto significa que los juegos tendrán diferentes velocidades. En otras palabras: la pelota en game maker studio 2 se mueve más rápido que en 1.4 (june 1, 2000).

Nuevos Scripts desarrollados:
1. Script línea trayectoria: es un script que permite ver la trayectoria que seguirá un objeto, sirve para ver la trayectoria que seguira una pelota al colisionar. Este script dibuja una linea la cual se quiebra al colisionar para indicar la direccion que va a seguir. Este script tengo que pulirlo para mostrarlo al público.

Preguntas Dragón:

1.¿Cómo se crearía un script que contenga un juego que funcione en todos los game makers pero que no sea dependiente del game maker, es decir que pueda ejecutarse el juego sin usar ningún game maker?
Esta pregunta tiene varias soluciones, cuando la respondan por el método sencillo se aumentará la complejidad de la pregunta.

2.¿Cómo crear un juego encapsulado en un script compatible con todos los game makers y que contenga score online?
Para responder esta primero se necesitará conocer la respuesta de la primera pregunta en nivel complejo.

Pistas:  .gml .gml  .html .bat

Nuevas ideas:

Sería bueno poder ofrecer recompensas a los primeros que respondan estas preguntas complejas, la idea sería crear sistemas tan valiosos como monedas los cuales sirvan de premio, es decir  el reto sería crear sistemas/juegos de alta calidad de uso exclusivo. Por ahora solo puedo pagar con feedback, es decir el que responda podrá solicitar que le analice un video juego y hablo de un análisis sincero y profundo.

La otra idea va relacionada: crear un modelo de feedback que incluya:
a.   Un game play en video subido a youtube.
b.   Un análisis del juego de principio a fin. Es decir pasar el juego a menos que sea demasiado difícil.
c.   Declarar fallas en el juego y sus posibles correcciones.


Nuevos retos:

Para continuar la creación de este tipo de juegos ahora tengo nuevos retos:

1. Definir tres nuevos scripts:
   a. Línea trayectoria(explicado arriba).
   b. Script que determina el ángulo que forman dos líneas.
   c. Script que calcula la arco tangente. Para poder calcular arcotangente en veriones viejas.

2. Crear sistema de falso 3d.
3. Dominar la creación de mapas alojados en arrays.

Video juegos que tengo pensado crear con este mismo estilo:

1. Uno sobre conducir un vehículo en un plano 2d.
2. Otro sobre conducir un vehículo tipo top gear aplicando pseudocódigo.
3. Uno de fake 3d como doom, aplicando un raycasting original que permita acelerar el procesamiento.
4. La carreta precisa: volver a programar ese juego desde cero pero sin emplear sprites ni background.
otros más y más que se me vallan ocurriendo.
5. Uno sobre el tennis de mesa aplicando las reglas oficiales.

bye...

Hola, espero que se encuentren bien.


Aquí voy a publicar editables y programas de todo tipo que he creado con game maker, también juegos pero todos sin terminar o recién empezados.

Los editables son para game maker 4

Top gear:


Tengo en mente re crear la primera carrera de top gear y en un dia logré solo crear el carro y el horizonte, se deja ejecutable y editable para game maker 4. Se avanza con S y turbo con X.
Descargar aquí topGear

La creación de este juego presenta una dificultad fuerte que involucra principalmente el tema de perspectiva cónica. Si algunos pueden recordar hace tiempo presenté un script llamado draw_cube, el cual permite dibujar un cubo 3D sin activar funciones 3D, ahora para lograr el juego de top gear es necesario crear un script como ese pero que permita crear un cubo ondulado como el siguiente respetando las reglas de perspectiva cónica:



Y eso no es garantía de que la velocidad del juego valla a ser rápida.


Mario bros 1-1


Tengo pensado crear el primer nivel de Mario bros y ofrecer el editable.
Descargar aquí mario 1-1 sin finalizar para game maker 4


Ya_pasará

Es un juego que estoy intentando crear.

Descarga aquí ejecutable y editable para game maker 4

Bueno, me despido, nos vemos luego.

Hola de nuevo, un gusto en saludarlos.


Permítanme contarles con libertad sobre los problemas que he arrastrado en la creación de juegos por más de 15 años desde que comencé a utilizar game maker.


1.   Problema 1: El miedo a abandonar proyectos fastidiosos. Creo que a nivel mundial existe un consejo que dice "Culmina lo que has empezado". Siempre me he sentido frustrado cuando he trabajado durante un mes en un proyecto y este deja de motivarme, ahora pienso con libertad que si el proyecto se vuelve tedioso debemos desecharlo a la papelera o mejor aún publicar lo  que tenemos, nos olvidarnos de él y comenzamos otro. Si no está completo lo publicamos como juego en desarrollo y si no se puede jugar lo publicamos como recurso para analizar.


2.   Problema 2: El miedo a que nos roben el juego: Debemos olvidarnos de eso. Creo que sería muy provechoso para todos ofrecer los juegos con sus respectivos editables para que otros puedan aprender de él. Si alguien se aprovecha de eso, bien por él.


3.   Problema 3: el factor sorpresa y la desmotivación. A veces trabajamos duro en un juego y ni siquiera hablamos de el a nadie, tenemos la idea de causar impacto aprovechándonos del factor sorpresa. Esto es malo según mi pensamiento ya que se corre el peligro de desmotivarse, además el factor sorpresa tampoco es muy útil; los video juegos terminan siendo olvidados y desechados.


4.   Problema 4: Obras perfectas: a veces no queremos mostrar nuestro juego a menos que no esté pulido y eso puede ser perjudicial por el mismo problema de la desmotivación. La estrategia de creación de juegos que propongo es la de crear juegos imperfectos, publicarlos tal cual y pulirlos solo si se está motivado.


Creo que si dejamos esos problemas atrás lograremos producir juegos con más libertad y mejoraremos nuestras habilidades.


Bueno eso es todo por ahora.

Hola, saludos caramaradas.



En este post les contaré sobre algunos scripts que intenté programar pero no pude concretarlos:


Script 1: pote de pintura:
Una vez quise crear mi propia herramienta de dibujo y para hacerla completa tenía que desarrollar un código que permitiera colorear un área de dibujo como lo hace el pote de pintura de paint.


El script tenía que recorrer toda el área como si estuviera programando un desbordamiento de agua sobre un laberinto, después de mucho esfuerzo y varios días  de programación logré crear una especie de Sudoku giratorio que se multiplicaba como virus  hasta que encontrase un límite. Algo como eso:


Lo dejé luego de muchos intentos ya que en un momento no logré comprender que más podía hacer.



Script 2: execute_string(str)
El execute string era una función que estuvo presente hasta game maker 8, con ella podíamos transformar un string en un código real, es decir si escribíamos: execute_string("draw_text(0,0,'Hola mundo')") se ejecutaba el draw_text y se mostraba "hola mundo". Con dicha función y un poco de imaginación se podía crear un game maker dentro de game maker. Los ingenieros del GML simplemente la llamaron obsoleta y luego dijeron que al no ser compatible con todos los módulos no era necesaria.




Cuando decidí re crear esta función con el mismo game maker, me topé con el inconveniente de la velocidad de procesamiento, pero esa no fue excusa para seguir adelante, entonces lancé la primera versión "execute_string(str)".

Cuando decidí mejorar el script para presentar una segunda versión, el script reveló un problema complejo que los ingenieros del game maker se negaron a solucionar.

El problema es el siguiente: Que una simple suma dentro de un string pueda resolverse, ejemplo:


numero = real("5+5");
draw_text(0,0,numero);



Para lograr el "execute_string(str)" no solo hay que resolver ese pequeño inconveniente, también hay que apoyarse fielmente a las reglas matemáticas y crear un código que resuelva strings de ecuaciones, ejemplo: "5+6*17/3+5*(3+2-(4*5))". Y ese es solo el primer reto del script, luego hay que enseñarlo a reconocer funciones, corregirlas de ser necesario y otras cosas extrañas, y todo esto solo para que el resultado final sea medianamente interesante.

Después de muchos esfuerzos y códigos extraños que resolvían funciones de una manera absurda, el script fue aumentando en complejidad, me obligó a empezar de cero varias veces para reorganizar; la dificultad no dejaba de aumentar y a pesar que me divertí en el desarrollo del mismo durante un buen tiempo, lo abandoné, no recuerdo porqué pero creo que me estaba apartando de la sociedad.


Bueno, por ahora me despido, faltó hablarles sobre el script de plataforma 360, el script que permite que el enemigo encuentre al player atravesando muros, y otros que por ahora no recuerdo pero que poco a poco iré mencionando.

¡Bay!

Autor del script: Reyes Dávila (Dixon)
Nombre del script: movimiento_parabolico(distancia,altura,velocidad horizontal);
Breve descripción de su función: Aplica movimiento parabólico a un objeto estableciendo solo la distancia, la altura y la velocidad.
Versiones usadas: Game maker 4  y game maker html5. Debe funcionar en todas las demás versiones superiores a gmk 4.
Versión del script: 2  (se añade argumento altura para establecer la altura màxima a alcanzar)


Html5: Aquí podrán ver el código en funcionamiento.



[gml]
//movimiento_parabolico(distancia,altura,velocidad horizontal)
//Colocar en evento create: movimiento_parabolico_create=1;
//distancia: es la distancia que recorrerá el objeto;
//altura: es la altura máxima a alcanzar;
//velocidad horizontal: es la velocidad horizontal que puede ser positiva o negativa;
//serial del script: A12HRJ36;

if(movimiento_parabolico_create)
{
movimiento_parabolico_create=0;
distancia_A12HRJ36=abs(argument0);
altura_A12HRJ36=abs(argument1);
velocidad_A12HRJ36=argument2;
xfinal_A12HRJ36=x+distancia_A12HRJ36;

direction270=0;

gravedad_A12HRJ36=0;
y2_A12HRJ36=y;
continuar_A12HRJ36=1;
while(y2_A12HRJ36>(y-altura_A12HRJ36) and (continuar_A12HRJ36))
{
gravedad_A12HRJ36+=0.1;
x2_A12HRJ36=x;
y2_A12HRJ36=y;
for(i_A12HRJ36=0;i_A12HRJ36<=(distancia_A12HRJ36/2) and continuar_A12HRJ36;i_A12HRJ36+=1)
{
x2_A12HRJ36+=velocidad_A12HRJ36;
direction=90+(distancia_A12HRJ36-(xfinal_A12HRJ36-x2_A12HRJ36))*180/distancia_A12HRJ36;
y2_A12HRJ36-=gravedad_A12HRJ36*sin(direction*pi/180);
if(y2_A12HRJ36<=y-altura_A12HRJ36){continuar_A12HRJ36=0}
}
}

}

x+=velocidad_A12HRJ36;
if(direction270<270){direction=90+(distancia_A12HRJ36-(xfinal_A12HRJ36-x))*180/distancia_A12HRJ36;direction270=90+abs((distancia_A12HRJ36-(xfinal_A12HRJ36-x))*180/distancia_A12HRJ36)};
y=y-gravedad_A12HRJ36*sin(direction*pi/180);

[/gml]

Modo de uso 1. Crea un nuevo script y pégale el código que se está entregando. 2. Colocar en el evento create del objeto a mover (ejemplo: la pelota, el proyectil):


movimiento_parabolico_create=1;

3. Colocar en el evento step o paso del objeto a mover:

movimiento_parabolico(200,150,10);





Detalles de la función:
movimiento_parabolico(distancia,altura,velocidad horizontal): en distancia colocar la distancia a alcanzar, en altura colocar la altura máxima que alcanzará el objeto y en velocidad colocar la velocidad de movimiento horizontal, para mover a la izquierda usar velocidades negativas.

Imagen de referencia:



Ejemplo:

movimiento_parabolico(50,50,1);


Mejoras a futuro:
Se requiere un script que controle el movimiento parabólico aplicando las reglas generales de la física.

Más información:
Este script lo he creado principalmente para nuestro amigo Jeffrey Faper , el cual se mantiene en constante programación y en algún momento nos mostrará alguno de sus proyectos. Le deseo que tenga éxito en su proyecto y que sus métodos sirvan de aprendizaje para todos nosotros.

El archivo index empleado en el juego de la parabola es el siguiente:

<!DOCTYPE html>
<html lang="en">
    <head>
        <!-- Generated by GameMaker:HTML5 http://http://www.yoyogames.com/gamemaker/html5 -->
        <meta http-equiv="X-UA-Compatible" content="IE=edge" >
        <meta name="apple-mobile-web-app-capable" content="yes" />
        <meta name ="viewport" content="width=device-width; initial-scale=1.0; maximum-scale=1.0; user-scalable=0;" />
        <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
        <meta charset="utf-8"/>

        <!-- Set the title bar of the page -->
        <title>Game Maker HTML 5</title>

        <!-- Set the background colour of the document -->
        <style>
            body {
              background: #222;
              color:#cccccc;
            }
            canvas {
                      image-rendering: optimizeSpeed;
                      -webkit-interpolation-mode: nearest-neighbor;
            }
        </style>
    </head>

    <body>
            <!-- Create the canvas element the game draws to -->
            <canvas id="canvas" width="400" height="300">
               <p>Your browser doesn't support HTML5 canvas.</p>
            </canvas>

        <!-- Run the game code -->
        <script type="text/javascript" src="html5game/gmk.js?FWFZB=2052234977"></script>






















<div id="botonA"></div>
<div id="botonB">F</div>


<style>
body
{
   text-align: center;
}

#botonA
{
position:absolute;
top: 5vh;
left: 5vw;
width: 90vw;
height: 90vh;
}

#botonB
{
    -webkit-user-select: none;
    -moz-user-select: none;
    -khtml-user-select: none;
    -ms-user-select:none;

position:absolute;
top: 5px;
right: 5px;
font-size: 1em;
border-radius: 10%;
border: 1px solid white;
width: 2em;
}

</style>



<script>

var canvas = document.getElementById("canvas");
        var canvasProporcion = canvas.width/canvas.height;

var ventana={
ancho: window.innerWidth,
alto: window.innerHeight,
orientacion: "landscape"
}

var botonA_Elemento = document.getElementById("botonA");
var botonB_Elemento = document.getElementById("botonB");

var touchDevice = ('ontouchstart' in document.documentElement);

if(touchDevice == true)
{
  botonA_Elemento.addEventListener("touchstart", function(){funcionBoton(65,"pulsar")});
  botonA_Elemento.addEventListener("touchend", function(){funcionBoton(65,"soltar")});
  botonA_Elemento.addEventListener("touchleave", function(){funcionBoton(65,"soltar")});

  botonB_Elemento.addEventListener("touchstart", function(){toggleFullScreen()});
}
else
{
  botonA_Elemento.addEventListener("mousedown", function(){funcionBoton(65,"pulsar")});
  botonA_Elemento.addEventListener("mouseup", function(){funcionBoton(65,"soltar")});
  botonA_Elemento.addEventListener("mouseleave", function(){funcionBoton(65,"soltar")});

  botonB_Elemento.addEventListener("mousedown", function(){toggleFullScreen()});
}


/////////////////Funcion de botones
////////////////SIMULANDO TECLADO
////////////////////////////////////////////////////////////////////////////////
function funcionBoton(codigoBoton, accionBoton){
    //alert(codigoBoton);
var eventObj_izquierda = document.createEventObject ?
    document.createEventObject() : document.createEvent("Events");
eventObj_izquierda.keyCode = codigoBoton;
eventObj_izquierda.which = codigoBoton;
eventObj_izquierda.key=' ';
eventObj_izquierda.code='Space';
if(accionBoton == "pulsar")
{
if(eventObj_izquierda.initEvent){eventObj_izquierda.initEvent("keydown", true, true)}
document.dispatchEvent ? document.dispatchEvent(eventObj_izquierda) : document.fireEvent("onkeydown", eventObj_izquierda);
}
if(accionBoton == "soltar")
{
if(eventObj_izquierda.initEvent){eventObj_izquierda.initEvent("keyup", true, true)}
document.dispatchEvent ? document.dispatchEvent(eventObj_izquierda) : document.fireEvent("onkeyup", eventObj_izquierda);
}
}
//////////////////////////////////////////////////////////////////////////////////


///////////////FUNCION PANTALLA COMPLETA
////////////////////////////////////////////////////////////////////////////////
function toggleFullScreen() {
  if ((document.fullScreenElement && document.fullScreenElement !== null) ||   
    (!document.mozFullScreen && !document.webkitIsFullScreen)) {
    if (document.documentElement.requestFullScreen) {
    document.documentElement.requestFullScreen();
    } else if (document.documentElement.mozRequestFullScreen) {
document.documentElement.mozRequestFullScreen();
} else if (document.documentElement.webkitRequestFullScreen) {
document.documentElement.webkitRequestFullScreen(Element.ALLOW_KEYBOARD_INPUT);
}
} else {
if (document.cancelFullScreen) {
document.cancelFullScreen();
} else if (document.mozCancelFullScreen) {
document.mozCancelFullScreen();
} else if (document.webkitCancelFullScreen) {
document.webkitCancelFullScreen();
}}}
/////////////////////////////////////////////////////////////////////////////////


setInterval('ejecucionConstante()',1000/30);
function ejecucionConstante()
{
ventana["ancho"]=window.innerWidth;
ventana["alto"]=window.innerHeight;

var porcentajeMaximo=95;
var canvasAncho = porcentajeMaximo*ventana["ancho"]/100;
var canvasAlto = canvasAncho/canvasProporcion;
var canvasAltoMaximo = porcentajeMaximo*ventana["alto"]/100;

while(canvasAlto>canvasAltoMaximo)
{
canvasAncho -=1;
var canvasAlto = canvasAncho/canvasProporcion;
}

canvas.style.width=`${canvasAncho}px`;


}//fin function ejecucionConstante()
</script>































    </body>
</html>

































Bay...

Autor del script: Reyes Dávila
Nombre del script: option_konami(obj);
Breve descripción de su función: mueve uno o X objetos como se mueven los option del video juego "Gradius/ Life force/salamander".
Versiones usadas: Game maker 4 y game maker html5; teóricamente funciona en casi todas las versiones.
Versión del script: 3 ,  (24-05-2022).

Html5: Aquí podrán ver la versión 3 en funcionamiento, Click en la imagen:







///option_konami(obj);

//Estableciendo distancia de separación
distancia_asd=argument0.sprite_height/2;
for(i=0;i<=instance_number(object_index);i+=1)
{
   id_asd=instance_find(object_index,i);
   if(id_asd=id){distancia_asd=distancia_asd*(i+1)}
}

//Siguiendo a la nave
c1_asd=(point_distance(x,y,argument0.x,argument0.y)>distancia_asd);
while(c1_asd)
{
   direction=point_direction(x,y,argument0.x,argument0.y);
   x+=0.5*cos(direction*pi/180);
   y-=0.5*sin(direction*pi/180);
   c1_asd=(point_distance(x,y,argument0.x,argument0.y)>distancia_asd);
}

//Contrayendo al llegar a los bordes de la pantalla.
if((argument0.y=argument0.yprevious) and (argument0.x=argument0.xprevious))
{
   c1_asd=0;
   c2_asd=0;
   c3_asd=0;
   c4_asd=0;
   if(argument0.y<argument0.sprite_height){c1_asd=keyboard_check(vk_up)}
   if(argument0.y>room_height-argument0.sprite_height){c2_asd=keyboard_check(vk_down)}
   if(argument0.x<argument0.sprite_width){c3_asd=keyboard_check(vk_left)}
   if(argument0.x>room_width-argument0.sprite_width){c4_asd=keyboard_check(vk_right)}
   if(c1_asd or c2_asd or c3_asd or c4_asd)
   {
      if(x>argument0.x+5){x-=5}
      if(y>argument0.y+5){y-=5}
      if(x<argument0.x-5){x+=5}
      if(y<argument0.y-5){y+=5}
   }
}

//Invirtiendo movimiento.
if(argument0.y<argument0.yprevious){y+=abs(argument0.y-argument0.yprevious)}
if(argument0.y>argument0.yprevious){y-=abs(argument0.y-argument0.yprevious)}
if(argument0.x<argument0.xprevious){x+=abs(argument0.x-argument0.xprevious)}
if(argument0.x>argument0.xprevious){x-=abs(argument0.x-argument0.xprevious)}

































Modo de uso
1. Crea un script el cual deberás llamar opcition_konami(obj).
2. Copia el código que te estoy ofreciendo y pégalo en el script.
3. Crea tu objeto option y en su evento step coloca:

option_konami(obj);

4. Deberás reemplazar obj por el objeto que va a seguir el option, es decir en obj se debe colocar el objeto de la nave.

Ejemplo:
Supongamos que mi objeto nave se llama object_gradius y mi objeto opción se llama object_option, entonces en mi object_option debo colocar:

option_konami(object_gradius);



Más información
1. El movimiento resultante es bastante genial, pero si lo observamos con detalle notaremos que no es exacto. Se puede alcanzar la exactitud de movimiento más adelante en otra versión.
2. Si la nave se mueve a la velocidad de la luz, los OPTION tambien.
3. Las variables del código no van a chocar con las variables del juego.
4. Para crear más options solo hay que crear más instancias y cada una tomará su posición.
5. Los nombres propuestos para el script son:
option_gradius_movement(obj);
follow_gradius(obj);
move_to_salamander(obj);
option_lifeForce(obj);

Pero como todos son de konami le coloqué: option_konami(obj).


Mejoras realizadas:
1. Distancia de separación: La separación entre la nave y las option es más parecida a las de gradius.
2. Contracción de options: Cuando la nave llega al borde de la pantalla las options se contraen cono en el juego original, pero obliga al programador a usar las teclas direccionales del teclado.
3. Inversión de movimiento: Originalmente en el juego las options siguen el movimiento de la nave, para lograr esto se puede recurrir al sistema de arrays recomendado por Jeffrey Faper, pero como quiero crea un único script fácil de implementar tuve que imitar ese movimiento invirtiendo la dirección de movimiento de las options con respecto a la dirección de la nave y el resultado quedó bueno.


Anécdota
El código lo he creado para mi amigo somnus al cual conozco desde hace años cuando la CGM estaba comenzando. Mi saludos siempre y mi estima para todos.

En mi infancia me dediqué a jugar un juego llamado LifeForce para la nes y lo pasé hasta el final varias veces (es increíble pero algo difícil, bueno, muy difícil):





Quizás me motive a jugar salamander 2 para la playstation el cual nunca he jugado:



Gradius no me simpatizaba mucho porque era más difícil y menos colorido. Claro ahora Gradius en sus nuevas versiones tiene gráficos increíbles.




Bueno, eso es todo por ahora, nos vemos en otro post, saludos a mi amigo somnus, quizás me motive a programar alguna nave para luchar junto a él contra alienígenas malignos robóticos en el espacio sideral, él representaría a gradius y yo a lifeForce.




Edito:


Creo que los principios de este script pueden ser usados para lograr:

La cuerda floja de new mario.



Los huevos de Yoshi



Aquí podrán jugar life force:
https://oldgameshelf.com/life-force-580.html?lang=es

Hola, que tengan un buen día.


Algunos quizás se pregunten ¿para qué necesitamos scripts de otros lenguajes?, la respuesta que considero adecuada: Para romper los límites del game maker y permitir por ejemplo que un juego se ejecute directamente en esta web.

Hay muchos scripts en distintos lenguajes que requieren ser definidos y ajustados. En este post colocaré algunos scripts que considero importantes, de los cuales a  algunos les he dado una apariencia parecida a la de los de game maker.

Para JavaScript: Si empleamos el siguiente código en javascript podremos programar con algunas funciones del game maker.





function random(x)
{
var min = 0;
var max = x;
return Math.random() * (max - min) + min;
}

function abs(x)
{
return Math.abs(x);
}

function sign(x)
{
return Math.sign(x);
}

function floor(x)
{
return Math.trunc(x);
}

function frac(x)
{
int_part = Math.trunc(x); // returns 3
return Number((x-int_part).toFixed(2));
}





function chr(val){
return String.fromCodePoint(val);
}

function ord(str){
return str.charCodeAt();
}

function real(str){
return Number(str)
}

function string(val){
return val.toString()
}

function string_length(str){
return str.length;
}

function string_pos(substr,str){
return str.indexOf(substr)+1;
}

function string_copy(str,index,count){
num=index-1;
return str.substr(num,count);
}

function string_delete(str,index,count){
str1 = str.substr(0, index);
str2 = str.substr(index+count, str.length-count);
str3 = str1+str2;
return str3;
}

function string_insert(substr,str,index){
num=index-1;
return str.slice(0, num) + substr + str.slice(num);
}

function string_replace(str,substr,newstr){
return str.replace(substr,newstr);
}

function string_replace_all(str,substr,newstr){
return str.replaceAll(substr,newstr);
}


function string_count(substr,str)
{
return str.split(substr).length-1;
}


function string_count(substr,str)
{
contador=0;
while(str.includes(substr))
{
str=str.replace(substr,"");
contador+=1;
}
return contador;
}

function string_lower(str)
{
return str.toLowerCase();
}

function string_upper(str)
{
return str.toUpperCase();
}

function string_digits(str)
{
return str.replace(/\D/g,"");
}

function string_letters(str)
{
return str.replace(/\d/g,"");
}

function string_repeat(str,count)
{
return str.repeat(count);
}

function string_lettersdigits(str)
{
return str.replace(/[^a-zA-Z]/g, "");
}






Las funciones habilitadas con el script son:

random(x): Devuelve un número real aleatorio entre 0 y x. El numero es siempre menor que x.
abs(x): Devuelve el valor absoluto de x.
sign(x): Devuelve el signo de x (-1 o 1).
floor(x): Devuelve el piso de x, es decir, x redondeado a un número entero.
frac(x): Devuelve la parte fraccionaria de x, es decir, la parte detrás del punto decimal.

chr(val):Devuelve una cadena que contiene el carácter con código asci val.
ord(str):Devuelve el código asci del primer carácter en str.
real(str):Convierte str en un número real. str puede contener un signo menos, un decimal punto e incluso una parte exponencial.
string(val):Convierte el valor real en una cadena.
string_length(str):Devuelve el número de caracteres de la cadena.
string_pos(substr,str):Devuelve la posición de substr en str (0 = no ocurrencia).
string_copy(str,index,count):Devuelve una subcadena de str, comenzando en índice de posición y de conteo de longitud.
string_delete(str,index,count):Devuelve una copia de str con la parte eliminado que comienza en el índice de posición y tiene un recuento de longitud.
string_insert(substr,str,index):Devuelve una copia de str con substr agregado en el índice de posición.
string_replace(str,substr,newstr):Devuelve una copia de str con la primera ocurrencia de substr reemplazada por newstr.
string_replace_all(str,substr,newstr):Devuelve una copia de str con todos ocurrencias de substr reemplazadas por newstr.
string_count(substr,str):Devuelve el número de apariciones de substr en la cadena
string_lower(str):Devuelve una copia en minúsculas de str.
string_upper(str):Devuelve una copia en mayúsculas de str.
string_repeat(str,count):Devuelve una cadena que consiste en contar copias de str.
string_letters(str):Devuelve una cadena que solo contiene las letras en str.
string_digits(str):Devuelve una cadena que solo contiene los dígitos en str.
string_lettersdigits(str):Devuelve una cadena que contiene las letras y dígitos en str.

Hola amigos espero que se encuentren bien en este magnifico dia.




Aquí en este post voy a ir colocando los video juegos que he abandonado.





Nombre: Under the Water.

Tiempo aproximado que  se emplearía para su desarrollo de principio a fin por una sola persona: 2 semanas aproximadamente, trabajando unas 5 horas diarias.

Más detalles:
Under the Water es un proyecto de juego inspirado en la música de Aurora Aksnes titulada Under The Water, lo he abandonado porque actualmente no puedo alcanzar la calidad gráfica mínima  que me he exigido y además de eso la programación interna que requiere es algo exigente aunque el proyecto puede ser concretado en 2 semanas aproximadamente.

Cuando me propongo a crear un video juego lo hago con el objetivo principal de transmitir sentimientos y en este caso el sentimiento es de suspenso y miedo, realmente estoy seguro que si en algún momento logro concretar el proyecto el video juego resultante hará que algunos espectadores sientan una sensación de misterio que roza lo sobrenatural.

Interesados en participar en el proyecto contactarme en el Facebook  https://m.facebook.com/reyes.davila.52459

Hola saludos, espero que estén muy bien.



Este post va dirigido a la creación de imágenes.

Aqui dejo una web para dibujo verctorial.
https://editor.method.ac/

A continuación un conjunto de imagenes que he creado con paint, gifanimator.exe y game maker.

Citar

Hola saludos cordiales.



Aquí les dejo un video donde se presenta la primera etapa de mi nueva idea para hacer video juegos.


https://youtu.be/NXL_HwBLQ1U


Por ahora mi objetivo es enseñar a hacer video juegos sencillos con materiales reciclados aplicando una técnica fácil.
1.   Primero se hace la maqueta real.
2.   Luego se grava el video.
3.   Se le agregan los efectos de sonido.
4.   Por último se sube a una plataforma online que estoy construyendo la cual no está terminada.
5.   Finalmente se obtiene un video juego muy básico.






Aquí les dejo un bosquejo de un juego que tengo en mente.
https://www.youtube.com/watch?v=vZkJlTH2pvk

chao, nos vemos.

Este juego lo cree gracias al canal Jeff Aporta de youtube, el cual ofrece el siguiente tutorial:
https://youtu.be/n8ujo9spBR4

Autor del script: Reyes Dávila
Nombre del script: draw_text_ext_html5(x,y,str,w);
Breve descripción de su función: Ajusta un texto al ancho indicado al exportar a html5.
Versiones usadas: Game maker html5, debe funcionar en studio.
Version del script: 1

Código del script

//draw_text_ext_html5(x,y,str,w);
//Para crear textos ajustados a un ancho al exportar a html5.
//Serial del script: _WXP2F

posicion_x_WXP2F=argument0;
posicion_y_WXP2F=argument1;
string_x_WXP2F=argument2;
ancho_x_WXP2F=argument3;

length_x_WXP2F=string_length(string_x_WXP2F);
length_x_prev_WXP2F=length_x_WXP2F;
index_WXP2F=1;
count_WXP2F=1;
width_min_WXP2F=string_width("X");
for(i_WXP2F=1;i_WXP2F<=length_x_WXP2F;i_WXP2F+=1)
{

copy_x_WXP2F=string_copy(string_x_WXP2F,index_WXP2F,count_WXP2F);
width_x_WXP2F=string_width(copy_x_WXP2F);

count_x_WXP2F=string_count(" ",copy_x_WXP2F);
c1_WXP2F=(width_x_WXP2F>ancho_x_WXP2F);
c2_WXP2F=(ancho_x_WXP2F>width_min_WXP2F);
c3_WXP2F=(i_WXP2F>1);
c4_WXP2F=(length_x_WXP2F<length_x_prev_WXP2F*2);
c5_WXP2F=(count_x_WXP2F);

if(c1_WXP2F and c2_WXP2F and c3_WXP2F and c4_WXP2F and c5_WXP2F)
{

index_WXP2F=i_WXP2F;count_WXP2F=1;
copy_x2_WXP2F=string_copy(string_x_WXP2F,index_WXP2F,count_WXP2F);
while(copy_x2_WXP2F!=" " and i_WXP2F>2)
    {
        i_WXP2F-=1;
        index_WXP2F=i_WXP2F;count_WXP2F=1;
        copy_x2_WXP2F=string_copy(string_x_WXP2F,index_WXP2F,count_WXP2F);
    }

string_x_WXP2F=string_insert(chr(35),string_x_WXP2F,i_WXP2F+1);
length_x_WXP2F+=1;
index_WXP2F=i_WXP2F+3;
count_WXP2F=0;
}

count_WXP2F+=1;
}

draw_text(posicion_x_WXP2F,posicion_y_WXP2F,string_x_WXP2F);


Detalles:
La función original draw_text_ext(x,y,str,sep,w) no funciona al exportar a html5 por esta causa se ha creado este script como sustituto, el cual en su primera versión no emplea el argumento "sep" que hace referencia a la separación de las líneas.

Mejoras a futuro:
1. Agregar el argumento sep.
2. Correcciones internas.
3. Mejorar precisión.
4. Crear conjunto de script para el control de textos que permita medir el alto de los párrafos con gran precisión al exportar en html5.