Comunidad Game Maker

Bueno, segundo script que resubiré al foro.
Autor: NiuWeb.
Versión de GM utilizada: Studio 1.4.
Descripción: Scripts que permiten convertir un arreglo unidimensional a uno bidimensional con el número de columnas dado, o convertir un arreglo bidimensional a uno unidimensional.
Código
[gml]
///array_1d_to_2d(array, width);
var array  = argument0;
var width  = argument1;
var length = array_length_1d(array);

var array2d;
var xn, yn;
for(var i = 0; i < length; i++)
{
    yn = floor(i/width);
    xn = i - yn*width;
    array2d[yn, xn] = array;
}
return array2d;
[/gml]
Argumentos:

array:	El arreglo unidimensional original a convertir.
width:	El número de columnas que tendrá el nuevo arreglo.

[gml]
///array_2d_to_1d(array2d);
var array2d = argument0;
var height  = array_height_2d(array2d);
var array1d, a = 0;

for(var i = 0; i < height; i++)
{
    for(var j = 0; j < array_length_2d(array2d, i); j++)
    {
        array1d[a++] = array2d[i, j];
    }
}
return array1d;
[/gml]
Argumentos:

array:

El arreglo bidimensional original a convertir.

Como siempre; dudas, inquietudes, quejas, reclamos, insultos o amenazas son bienvenidos, y si encuentran algún fallo en los códigos por favor hacérmelo saber.

Un sencillo programa que permite crear colores de forma manual o determinando su valor hexadecimal, HSV o RGB. También incluye un pequeño gestor de paletas, en donde podrás guardar tus colores favoritos y usarlos cuando desees.

https://dl.dropbox.com/s/gbua1xqscqmmtml/Paleta%20de%20colores.exe?dl=0 Como siempre, cualquier duda o sugerencia sobre el programa, o si han encontrado algún fallo en él, agradecerían lo comentaran.

Bueno. Como ya sabrán, con todo esto del foro se borraron muchísimos posts, y entre ellos varios de los scripts que yo había posteado aquí. Al igual que con mis artículos, no guardé copia de ninguno y pues pasa lo que pasa :v. Con el tiempo iré resubiendo todos los scripts que se perdieron; éste el primero.

Autor: NiuWeb.
Versión de GM utilizada: Studio 1.4.
Descripción: Reemplaza una serie de plantillas dentro de una cadena original por los argumentos (cadenas o reales) que se le den.
Código:
[gml]
///sprintf(string, [arg1, ..., arg15])
var text  = argument[0];
var argn  = argument_count - 1;
var txtln = string_length(text);

for(var i = argn; i >= 1; i--)
{
    var mark  = "$"+string(i);
    var mrkln = string_length(mark);
    for(var j = 1; j <= txtln; j++)
    {
        var test = string_copy(text, j, mrkln);
        if(test == mark)
        {
            if(string_char_at(text, j - 1) <> "\")
            {
                var part;
                part[0] = string_copy(text, 1, j - 1);
                part[1] = string_copy(text, j + mrkln, 1+txtln - (j + mrkln));
                text    = part[0] + string(argument) + part[1];
                txtln   = string_length(text);
            }
        }
    }
}
for(var i = argn; i >= 1; i--)
{
    var mark = "$"+string(i);
    text = string_replace_all(text, "\"+mark, mark);
}
return text;
[/gml]
string: Este argumento es la cadena original a modificar. Las plantillas se escriben con un signo '$', seguido del índice del argumento por el que se quiere reemplazar, por ejemplo '$3' se reemplazará por el tercer argumento (La cadena original no cuenta, así que en realidad sería el cuarto). Para evitar que una plantilla se reemplace, utiliza una barra invertida así: '\$3' en caso de que el número esté dentro de los argumentos a usar, de lo contrario no hay que modificar nada pues simplemente no se tomará en cuenta.

[arg1, ..., arg15]: Los diferentes argumentos que se le quieran añadir (opcionales).

Ejemplo
[gml]
text = sprintf("Hoy es: $1/$2/$3", 28, "04", 2017); //Devuelve "Hoy es: 28/04/2017"
text = sprintf("¡Hola, $1 $2! Este elemento cuesta \$2", "Pedrito", "Pérez"); //Devuelve "¡Hola, Pedrito Pérez! Este elemento cuesta $2"
[/gml]

Como siempre, cualquier duda o fallo en el programa, agradecería lo comentasen.

Autor: NiuWeb
Versión de GM utilizada: GM8.0, aunque no debería tener problemas en otras versiones
Descripción: Crea un path poligonal de acuerdo al radio, número de lados y ángulo de inicio dados.
Código:
[gml]
///path_create_polygon(raduis, sides, start);
var p, r, g, ang, i;
p = path_add();
path_set_closed(p, false);
r = argument0;
g = round(argument1);
ang = 360 / g;

for(i = argument2; i <= 360+argument2; i += ang)
    path_add_point(p, lengthdir_x(r, i), lengthdir_y(r, i), 100);
return p;
[/gml]
Argumentos:
    radius: El radio del polígono a generar
    sides: El número de lados del polígono. Si no es un número entero, éste se redondeará.
    start: El ángulo (en grados) de inicio.

Devuelve: Identificador de path. Puede, por ejemplo, crearse en el evento <create> de un objeto y dibujarse con draw_path().

Ejemplo:
[gml]
my_polygon = path_create_polygon(64, 4, 0);
[/gml]
Se creará un polígono cuadrilátero de 64px de radio, similar a éste:

Autor: NiuWeb
Versión de GM utilizada: Studio 1.4.1657
Descripción: Conjunto de scripts que permiten generar un punto aleatorio dentro de los bordes de un rectángulo, círculo o vector (línea).
Código:

Función point_of_rectangle(x1, y1, x2, y2):
[gml]
///point_of_rectangle(x1, y1, x2, y2);
var x1, y1, x2, y2;
x1 = min(argument0, argument2);
y1 = min(argument1, argument3);
x2 = max(argument0, argument2);
y2 = max(argument1, argument3);

var n, s, t, w, h;
n = irandom(1);
s = irandom(1);
t = irandom(1);
w = x2 - x1;
h = y2 - y1;

var pos;
pos [ 0 ] = x1 + w*n + irandom(w)*(n xor 1)*s;
pos [ 1 ] = y1 + h*(!n and s)*t + irandom(h)*(n or !s);
return pos;
[/gml]
Este script genera un punto aleatorio dentro del borde de un rectángulo dado
Argumentos:
    x1: El componente horizontal del primer punto del rectángulo
    y1: El componente vertical del primer punto del rectángulo
    x2: El componente horizontal del segundo punto del rectángulo
    y2: El componente vertical del segundo punto del rectángulo
Devuelve: Un array con dos índices; el primero contiene la posición horizontal generada, y el segundo, la posición vertical generada.
Por ejemplo:
[gml]
var pos = point_of_rectangle(0, 0, room_width, room_height);
instance_create( pos [ 0 ], pos [ 1 ], automovil);
[/gml]
Se creará una instancia del objeto automovil en cualquier punto del borde de la sala


Función point_of_circle(x, y, r):
[gml]
///point_of_circle(x, y, r);
var xx, yy, r;
xx = argument0;
yy = argument1;
r = argument2;
var dir;
dir = irandom(360);
var lenx, leny;
lenx = lengthdir_x(r, dir);
leny = lengthdir_y(r, dir);

var pos;
pos [ 0 ] = xx + lenx;
pos [ 1 ] = yy + leny;
return pos;
[/gml]
Este script genera un punto aleatorio dentro del borde de un círculo dado
Argumentos:
    x: La posición horizontal del círculo
    y: La posición vertical del círculo
    r: El radio del círculo
Devuelve: Un array; su primer índice es la posición horizontal generada, y el segundo es la posición vertical generada.
Por ejemplo:
[gml]
var pos = point_of_circle(165, 165, 133);
instance_create(pos[0], pos[1], granada);
[/gml]
Se creará una instancia del objeto granada en un punto aleatorio dentro del borde de un círculo de 133 de radio ubicado en la posición [165,165]


Función point_of_line(x1, y1, x2, y2):
[gml]
///point_of_line(x1, y1, x2, y2);
var x1, y1, x2, y2;
x1 = argument0;
y1 = argument1;
x2 = argument2;
y2 = argument3;

var len, dir;
len = point_distance(x1, y1, x2, y2);
dir = point_direction(x1, y1, x2, y2);
var sel, lenx, leny;
sel = irandom(len);
lenx = lengthdir_x(sel, dir);
leny = lengthdir_y(sel, dir);

var pos;
pos [ 0 ] = x1 + lenx;
pos [ 1 ] = y1 + leny;
return pos;
[/gml]
Este script genera una posición aleatoria dentro de un vector o línea dada
Argumentos:
    x1: El componente horizontal del primer punto del vector
    y1: El componente vertical del primer punto del vector
    x2: El componente horizontal del segundo punto del vector
    y2: El componente vertical del segundo punto del vector
Devuelve: Un array; su primer índice es la posición horizontal generada, y el segundo es la posición vertical generada.
Por ejemplo:
[gml]
var pos = point_of_line(0, 0, room_width, room_height);
instance_create(pos[0], pos[1], efecto);
[/gml]
Se creará una instancia del objeto efecto en una posición aleatoria dentro de una línea (diagonal) que cruza el origen y el final de la sala.

¡Buenas! Y muchas gracias por adelantado :-[

Tengo un problema que llevo intentando solucionar, sin resultado alguno.  Se trata de que estoy intentando ejecutar una DLL propia, creada con VB.NET desde Visual Studio 2012, en Game Maker Studio, pero, obviamente (por estar preguntando) no funciona.
A ver les cuento todo el procedimiento que seguí para crear/ejecutar (o al menos intentarlo D': ) la DLL:
Primero, creé la DLL, siguiendo estos pasos:

1)- Creé un proyecto, como se ve a continuación:

(Comento que también he intentado creándolo como "Biblioteca de clases portable", con el mismo resultado)

2)- Escribí el código:

Public Class Class1
    Public Shared Function prueba() As Object
        Return 33
    End Function
End Class

(Comento que no sé absolutamente nada de VB.NET, obtuve la estructura de esta web: http://programacionalotico.blogspot.com.co/2010/06/crear-libreria-dll-en-vbnet-y-como.html )

3)- Compilé:


4)- Moví la DLL obtenida a los Incluided Files de un proyecto en blanco de GMS.

5)- Creé un script, le llamé "prueba". Y en él, apoyándome del manual, escribí esto:
[gml]
var func = external_define("prueba.dll","prueba",dll_stdcall,ty_real,0)
var call = external_call(func);
return call;
[/gml]
6)- En el Creation Code de una room en blanco, escribí esto:
[gml]
a = prueba();
show_message(string(a));
[/gml]
Supongo que al hacer esto, normalmente, se debería mostrar un mensaje emergente con el número 33. Pero, en vez de eso, me muestra un mensaje de error:

___________________________________________
############################################################################################
ERROR in
action number 1
of Create Event
for object <undefined>:

Error defining an external function.
at gml_Script_prueba (line 1) - var func = external_define("prueba.dll","prueba",dll_stdcall,ty_real,0)
############################################################################################
--------------------------------------------------------------------------------------------
stack frame is
gml_Script_prueba (line 1)
called from - gml_Room_room0_Create (line 1) - a = prueba();


Inmediatamente después de cerrar la ventana de error, el programa deja de funcionar:


No tengo idea de por qué sucede este error. He visto extensiones del marketplace que usan este mismo método (aunque la DLL es programada en C++), y no tienen errores.

Muchas gracias de antemano :D

Autor: NiuWeb
Versión de GM utilizada: GM8.0, no he probado si funciona en anteriores, ni tengo cómo.
Descripción: Una emulación sencillísima de la función lerp() de GMS. No me sé la fórmula de la interpolación lineal, ni tengo idea de cómo trabaja la misma en GMS. Pero lo importante es que hace el mismo trabajo xDD
Códigos:
Función lerp(a, b, amt);
[gml]
///lerp(a, b, amt);
var a, b, amt;
a = argument0;
b = argument1;
amt = argument2;
var w, p;
w = b - a;
p = w*amt;
return a + p;
[/gml]
Argumentos:
a: El primer valor a interpolar.
b: El segundo valor a interpolar.
amt: La cantidad a interpolar.

Ejemplo:
[gml]
lerp(10, 15, 0.5); //Devuelve 12.5
lerp(7, 24, 0.2); //Devuelve 11.4 aprox.
lerp(12, 18, 1.5); //Devuelve 21.
lerp(21, 3, 0.5); //Devuelve 12.
[/gml]

Es muy corto, pero qué se le hace, funciona xD. Espero le pueda ser de utilidad a alguien que aún use GM8 xD

Se trata de una pequeña calculadora estadística (bastante simple) que permite hallar los valores básicos estadísticos (sumatoria, media, moda, mediana y desviación estándar) de los valores numéricos que se le ingresen.

Dropbox Adjunto No es la gran cosa, pero puede que llegue a ser de utilidad a alguien :D En sí, el programa está completo, pero si llegasen a encontrar un bug o tuviesen una recomendación, sugerencia, duda, inquietud, queja, reclamo o amenaza, podrían comentármelo, me ayudaría mucho :D PD: Sí, los scripts de estadística que hace poco publiqué en Desarrollo de scripts fueron los que programé para esta calculadora xD

Autor: NiuWeb
Versión de GM utilizada:  :GMS: Studio 1.4
Descripción: Conjunto de scripts para poder convertir de un número decimal a un binario y a un hexadecimal, y de un número binario o hexadecimal (a modo de cadena) a un número real.

Código:

Decimal a binario
[gml]
///dec_to_bin(dec);
var dec, bin;
dec = argument0;
bin = "";
while(dec > 0)
{
    bin = string(dec mod 2) + bin;
    dec = dec div 2;
}
return bin;
[/gml]
Su único argumento es el número decimal a convertir. Devuelve una cadena con el número binario.

Binario a decimal
[gml]
///bin_to_dec(bin);
var bin, len, dec;
bin = string(argument0);
len = string_length(bin);
dec = 0;

var i;
for(i = len; i >= 1; i--)
{
    dec += power(2, len - i) * real(string_char_at(bin, i));
}
return dec;
[/gml]
Su único argumento es el número binario (a modo de cadena) a convertir. Devuelve un número real.

Decimal a hexadecimal
[gml]
///dec_to_hex(dec);
var base, dec, bin;
base = "0123456789ABCDEF";
dec  = argument0;
bin  = "";
while(dec > 0)
{
    bin = string_char_at(base, (dec mod 16) + 1) + bin;
    dec = dec div 16;
}
return bin;
[/gml]
Su único argumento es el número decimal a convertir. Devuelve una cadena con el número hexadecimal.

Hexadecimal a decimal
[gml]
///hex_to_dec(hex);
var base, hex, len, dec;
base = "0123456789ABCDEF";
hex  = string(argument0);
len  = string_length(hex);
dec  = 0;

var i;
for(i = len; i >= 1; i--)
{
    dec += power(16, len - i) * (string_pos(string_char_at(hex, i), base) - 1);
}
return dec;
[/gml]
Su único argumento es el número hexadecimal (a modo de cadena) a convertir. Devuelve un número real.

Espero que le pueda ser de utilidad a alguien :D

EDIT: Scripts optimizados.

Autor: NiuWeb
Versión de GM utilizada:  :GMS: Studio 1.4+
Descripción: Son un conjunto de scripts que permiten hallar valores estadísticos básicos de una lista. Estos valores son: sumatoria, mediana, moda y desviación estándar. La media no la incluyo porque al tener la sumatoria y la cantidad de datos ( ds_list_size()  ) se puede obtener fácilmente. Sería desperdiciar por completo un script.

Códigos:
Todos los scripts a continuación requieren de un sólo argumento: La lista a la que queremos sacarle los datos.

Sumatoria:
[gml]
///ds_list_sumatory(list)
var list = argument0;
var count = 0;
for(var i = 0; i < ds_list_size(list); i++)
    count += real(list[| i]);
return count;
[/gml]

Mediana:
[gml]
///ds_list_median(list);
var _list = argument0;
var list = ds_list_create();
ds_list_copy(list, _list);

ds_list_sort(list, true);

var size = ds_list_size(list);
if size >= 1 {
    var iseven = (frac(size / 2)) == 0;
    var med;
   
    if (iseven) {
        med = (list[| (size/2) - 1] + list[| size/2]) / 2;
    }
    else {
        med = list[| (size-1) / 2];
    }
    ds_list_destroy(list);
    return med;
}
else return 0;
[/gml]

Moda:
[gml]
///ds_list_mode(list);
var list = argument0;
var indexes = ds_list_create();
var amounts = ds_list_create();

if ds_list_size(list) >= 1 {
    var i, a, b, c, d;
   
    for(i = 0; i < ds_list_size(list); i++) {
        a = list[| i];
        b = ds_list_find_index(indexes, a);
       
        if (b == -1) {
            ds_list_add(indexes, a);
            ds_list_add(amounts, 0);
        }
        else
            amounts[| b] ++;
    }
   
    c = 0;
   
    for(i = 0; i < ds_list_size(amounts); i++) {
        c = max(c, amounts[| i]);
        if (c == amounts[| i])
            d = i;
    }
   
    var index = indexes[| d];
    var first = amounts[| 0];
    b = true;
    for(i = 0; i < ds_list_size(amounts); i++) {
        a = amounts[| i]
        if a != first
            b = false;
    }
   
    if(b)
        index = undefined;
   
    ds_list_destroy(amounts);
    ds_list_destroy(indexes);
   
    return index;
}
else return 0;
[/gml]
Esta función devuelve la última de las modas, es decir que de una lista con los valores {1, 2, 3, 2, 4, 5, 3} se obtendrá la moda 3. Y si no hay moda (todos los valores con la misma frecuencia) devolverá <undefined>

Desviación estándar:
[gml]
///ds_list_standev(list);
var list = argument0;

var m = 0;
for(var i = 0; i < ds_list_size(list); i++) {
    m += list[| i];
}

m = m / max(ds_list_size(list), 1);

var a, b;
b = 0;
for(i = 0; i < ds_list_size(list); i++) {
    a = list[| i];
    a = a - m;
    b += power(a, 2);
   
}

b = b / max(1, ds_list_size(list));

return sqrt(b);
[/gml]

Espero le pueda ser de utilidad a alguien :D

Autor: yo + Jucarave
Versión de GM utilizada:  :GMS: 1.4+
Descripción: Permite subir una imagen al servidor Imgur. Para ello, debes tener creada una App de desarrollador en imgur, y es recomendable leer la documentación de la API: Imgur API, donde se explica cómo crear la app. Jucarave hizo la "empaquetación" de la imagen en base64 (necesario para subirla a la API), que me tenía con la cabeza a punto de estallar, pero como él no quiere subir el script pues me toca a mí :'( xDD

Código:
[gml]
///imgur_upload_image(fname, imgur_client_id);
var fname = argument0;
var client_ID = argument1;
var file = file_bin_open(fname, 0);

var size = file_bin_size(file);
var buffer = buffer_create(size, buffer_fixed, 1);

var byte;
for (var i=0;i<size;i++){
    byte = file_bin_read_byte(file);
    buffer_write(buffer, buffer_u8, byte);
}

file_bin_close(file);
var headers = ds_map_create();
ds_map_add(headers, "Authorization", "Client-ID " + client_ID);
ds_map_add(headers, "Content-Type", "application/json");

var base64 = buffer_base64_encode(buffer, 0, size);
var data = '{"image": "' + base64 + '"}';

return http_request("https://api.imgur.com/3/image.json", "POST", headers, data);
[/gml]
Esta función tiene dos argumentos:
fname: El archivo de imagen a subir. Obviamente debe ser formato de imagen, porque la API de imgur verifica que lo sea, y si no lo es, no lo dejará subir.
imgur_client_id: Al crear la App de desarrollador en imgur, se te da un "client Id", debes ponerlo a modo de cadena en este argumento.

Como todas las funciones asíncronas, este script devuelve una identificación que permite recibir la respuesta de la API como cualquier otra función asíncrona. Es necesario saber que esta respuesta está en formato JSON (usar json_decode() para sacar la info), y en esta respuesta se encuentra el enlace de la imagen subida.

Autor: NiuWeb
Versión de GM utilizada: GMS 1.4.1657 stable, aunque funciona perfectamente en GM8.0
Descripción: Encripta una cadena con una contraseña para hacer ilegible su contenido. A diferencia del primer sistema que hice (ronda por aquí en esta sección), este sistema no devuelve caracteres especiales, y por ello los resultados son más "normales", aparte de que el proceso de encriptación es diferente. Pero este sistema tiene dos desventajas: Las cadenas encriptadas resultantes tienen un largor 25 veces mayor a la cadena original, lo que le hace un poco tedioso con cadenas muy largas.  La otra es que si la cadena a encriptar tiene un caracter con valor decimal mayor a 99999, el proceso fallará y no se encriptará como debe D:

Código:
Encriptador:
[gml]
///encode(str, key);
var str, key;
str = string(argument0);
key = string(argument1);
var i, j, d, c, nstr1, nstr2;
nstr2 = "";
nstr1 = "";
for(i = 1; i <= string_length(str); i += 1)
{
    c = string(ord(string_char_at(str, i)));
    while(string_length(c) < 5)
        c = "0"+c;
    nstr1 += c;
}
for(j = 1; j <= string_length(key); j += 1)
{
    d = string(ord(string_char_at(key, j)));
    while(string_length(d) < 5)
        d = "0" + d;
    nstr2 += d;
}

if string_length(nstr2) > string_length(nstr1)
    nstr2 = string_copy(nstr2, 1, string_length(nstr1));
while(string_length(nstr2) < string_length(nstr1))
    nstr2 += string_copy(nstr2, 1, string_length(nstr1) - string_length(nstr2));
   
var str2, k, l, e, f, str3;
str2 = "";
str3 = "";

for(k = 1; k <= string_length(nstr1); k += 1)
{
    e = chr(ord(string_char_at(nstr1, k)) + ord(string_char_at(nstr2, k)));
    str2 += e;
}
for(l = 1; l <= string_length(str2); l += 1)
{
    f = string(ord(string_char_at(str2, l)));
    while(string_length(f) < 5)
        f = "0" + f;
    str3 += f;
}
return str3;
[/gml]
Argumentos:
str: La cadena a encriptar
key: La clave para encriptar la cadena.

Ahora, el desencriptador:
[gml]
///decode(str, key);
var str, key;
str = string(argument0);
key = string(argument1);

var i, a, ns1;
ns1 = "";
for(i = 1; i < string_length(str); i += 5)
{
    a = chr(real(string_copy(str, i, 5)));
    ns1 += a;
}
var j, b, ns2;
ns2 = "";
for(j = 1; j <= string_length(key); j += 1)
{
    b = string(ord(string_char_at(key, j)));
    while(string_length(b) < 5)
        b = "0"+b;
    ns2 += b;
}
if string_length(ns2) > string_length(ns1)
    ns2 = string_copy(ns2, 1, string_length(ns1));
while(string_length(ns2) < string_length(ns1))
    ns2 += string_copy(ns2, 1, string_length(ns1) - string_length(ns2));

var k, c, d, e, ns3;
ns3 = "";
for(k = 1; k <= string_length(ns1); k += 1)
{
    c = string_char_at(ns1, k);
    d = string_char_at(ns2, k);
    e = ord(c) - ord(d);
    ns3 += chr(e);
}
var l, f, ns4;
ns4 = "";
for(l = 1; l <= string_length(ns3); l += 5)
{
    f = string_copy(ns3, l, 5);
    f = chr(real(string_digits(f)));
    ns4 += f;
}
return ns4;
[/gml]
Argumentos:
str: Una cadena encriptada por el script anterior, la que queremos desencriptar.
key: La clave con la que se encriptó la cadena.


[spoiler]Spam:
http://niuweb-blog.blogspot.com.co/2016/03/sistema-de-encriptacion-de-cadenas-para.html
[/spoiler]

Autor: NiuWeb
Versión de GM utilizada: GM8.0, aunque funciona perfectamente en GMS
Descripción: Formatea una cadena para que salgan sólo los caracteres aprobados por la cadena raíz. Por ejemplo, si formateo "hola1234,como le va" con la cadena "hola123", el script devolverá "hola123oola".
Código:
[gml]
///string_specformat(root, str);
var i, root, str, c, n; n="";
root = argument0;
str = argument1;

for(i = 1; i <= string_length(str); i+= 1)
{
    c = string_char_at(str, i);
    if string_pos(c, root) > 0
        n += c;
}
return n;
[/gml]
Argumentos:
root: La cadena raíz con la cual formatear.
str: La cadena a formatear.

Ejemplo:
[gml]
a = string_specformat("123456789,.", "yo tenía 1, o quizás 302 gatitos. Pero 3096 murieron en las 2 explosiones");
[/gml]
La variable a tendrá el valor de "1,32.3962"

Autor: NiuWeb
Versión de GM utilizada: Studio 1.4.1657 stable (sí, sé que hay una actualización pero weno xD), aunque totalmente funcional en GM8
Descripción: Dibuja una línea dependiendo de un ángulo y un largor que se le dé
Código:
[gml]
///draw_line_angle(x, y, dir, dist)
var xx, yy, dir, dist;
xx = argument0;
yy = argument1;
dir = argument2;
dist = argument3;

var lx, ly;
lx = lengthdir_x(dist, dir);
ly = lengthdir_y(dist, dir);
draw_line(xx, yy, xx+lx, yy+ly);
[/gml]
Argumentos:
x: La posición horizontal (en pixeles) del origen de la línea (eje de rotación)
y: La posición vertical (en pixeles) del origen de la línea (eje de rotación)
dir: La dirección, en grados de la línea
dist: El largor de la línea, en pixeles

---

Espero pueda serle de utilidad a alguien :D

Guenashfgjfkkk,
Comenzando uno de esos cientos de proyectos mierda que nunca termino, creé un sencillito programa "pixelArt", para joder más que todo xD, pero mi duda es la siguiente:
¿Qué es más óptimo, objetos que se dibujen con el color del pixel, o rectángulos y ciclos?
En cualquiera de las dos formas se usa el evento draw, pero en una se crearían cientos de objetos con un sprite de cuadrado blanco, y con un draw_sprite_ext() se les daría el color; y en la otra se usa un array bidimiensional que almacene los colores de los pixeles, y un par de ciclos for que dibujen rectángulos con el color guardado en el índice [i, j] del array.
Como es un "pseudo" editor, obviamente los "pixeles" se verían más grandes de lo normal, así que pongamos como ejemplo si tuvieran que verse cada pixel de 8*8, ¿Cuál método comería más memoria?

Como apunte digo que descarten cualquier comentario sobre surface, que aunque posiblemente gasten menos memoria, en algunos dispositivos funcionarían y en otros sencillamente no
Muchas gracias de anteoreja xD

[spoiler=No me hagas click D:]Lo he decidido, a la mierda los videojuegos, bienvenidas sean utilidades inútiles xDDDDDD[/spoiler]
Es un pequeño programa que sirve como seleccionador de colores, o paleta de colores HSV. Muestra el valor RGB, HSV y hexadecimal del color elegido. También permite ingresar tus propios valores HSV, RGB o hexadecimales para generar el color, presionando las teclas R, G y B para modificar el valor RGB; H, S y V para modificar el valor HSV; y enter para modificar el hexadecimal
hecho totalmente con GMS, y un poquito de fotochó para dibujar las paletas xD...

Arjunto XD Es demasiado simple, y ni siquiera es un juego. Pero de ahora en adelante verán esta sección llena de más porquerías como ésta porque no es ilegal y es lo que me gusta hacer xDDD Tiene un pequeño, muy pequeño, bug que descuadra un poco algunos hexadecimales que se le ingresan. Casi no sucede, pero si les llega a ocurrir sólo vuelvan a ingresar el hexadecimal y se arregla. Es un pequeño error en el sistema para transformar el número , el único que tiene (o al menos el único que le he encontrado) y lo estoy intentando solucionar; por lo demás, el programita está completo xD

Autor: NiuWeb
Versión de GM utilizada: Studio 1.4.1657
Descripción: Separa una cadena en un array, tomando como separador la subcadena dada. Por ejemplo, si se separa "hola-que-hace" con el signo "-", devolverá un array con las cadenas "hola", "que" y "hace"
Código:
[gml]
///split(string, separator);
var str = argument0 + argument1;
var sep = argument1;
var sln = string_length(str);
var pln = string_length(sep);

if(sep == "") return false;

var arr, ind = 0;

var i = 1;
while(string_pos(sep, str))
{
    check = string_copy(str, i, pln);
    if(check == sep)
    {
        arr[ind++] = string_copy(str, 1, i - 1);
        str = string_delete(str, 1, i + pln - 1);
        i = 1;
        continue;
    }   
    i++
}
return arr;
[/gml]

Nota: El separador puede ser tanto de uno como de varios caracteres

Argumentos:
str: La cadena a dividir
sep: El separador para dividir.

EDIT: Código optimizado.

CSS Drawer es un software simple de dibujo de figuras, y su principal característica es la posibilidad de exportar los proyectos realizados a un archivo *.html con CSS incluído que redibuja el proyecto en el documento web.

[spoiler=imagen 1][/spoiler] [spoiler=imagen 2][/spoiler] [spoiler=imagen 3][/spoiler] [spoiler=imagen 4][/spoiler] Descargar instalador (2.69 MB) Dropbox Descargar archivo comprimido (2.5 MB) Dropbox Adjunto también Características de la versión Añadida interfaz gráfica, botones y menús para el fácil uso del programa y control de opciones rápido. Añadida la opción de transparencia total en el fondo o borde de las figuras. Añadida encriptación leve de proyectos para evitar posibles daños en la información de los mismos. Por lo tanto, los proyectos creados con la versión anterior ALPHA v0.1 son incompatibles y considerados obsoletos a partir de esta versión. Añadida la extensión de archivos personalizada (*.cdm), los proyectos pueden ser abiertos desde el Explorador de Windows con CSS Drawer BETA v0.2 como programa por defecto.(Requiere reinicio después de la primera ejecución) Añadido editor de figuras, con posibilidad de mover, redimensionar y modificar el color de la figura. Añadido portapapeles para copiar y pegar figuras La web oficial del programa: CSS Drawer Documentación del programa: CSS Drawer Docs

Buenashffjfdkfj!! xD
Me surge esa duda principalmente porque en ocaciones necesito almacenar más de un valor en una llave de una ds_map(), y obviamente la mejor forma de hacerlo es con un array, una ds_list() u otra ds_map().

La pregunta es, si yo tengo un array dentro de una estructura de datos (digámosle ds_map()), con una estructura algo como esto:


Había pensado en intentar como un array bidimensional, algo así:
[gml]
mapa[? 'llave1', 0]
[/gml]
Pero me sale error de compilación:


¿Cómo podría obtener la información que se encuentra en el Array de cada llave del mapa sin tener que almacenar la misma en otra variable?

Gracias de antecabeza :B

Va bajando la calidad de los scripts xD
Autor: Generación espontánea xD. Mentiras, yo (NiuWeb)
Versión de GM utilizada: Studio 1.4.1657 stable versión
Descripción: Devuelve un array que contiene los argumentos dados. No es muy útil, pero ahorra bastante código. (Obviamente ahorra un máximo de 16 líneas de código xD)

Código:
[gml]
///set_array(values);
var n = argument_count;
var arr;
for(var i=0; i < n; i++)
{
arr = argument;
}
return arr;
[/gml]

Ejemplo:
Escribir:
[gml]
array = set_array("hola","como","estás","xD");
[/gml]
Nos ahorra tener que escribir:
[gml]
array[0] = "hola";
array[1] = "como";
array[2] = "estás";
array[3] = "xD";
[/gml]

Nivel de utilidad: -600%... Completamente inútil, pero ayuda a los flojos xDDD