[Script]Scripts matemáticos

Vou colocar alguns scripts envolvendo matemática.
São simples, mas podem ser muito úteis.
Alguns são de minha autoria, outros parcialmente, outro não.

1- Checando se um ponto (x,y) está dentro de um triângulo.

Código:

 //Esse não é meu.
var x1, y1, x2, y2, x3, y3, x4, y4, a, b, c;
//primeiro vértice do triângulo
    x1 = argument[0];
    y1 = argument[1];
//segundo vértice do triângulo
    x2 = argument[2];
    y2 = argument[3];
//terceiro vértice do triângulo
    x3 = argument[4];
    y3 = argument[5];
// Ponto que será checado
    x4 = argument[6];
    y4 = argument[7];
// Calculos
    a = (x1 - x4)*(y2 - y4) - (x2 - x4)*(y1 - y4);
    b = (x2 - x4)*(y3 - y4) - (x3 - x4)*(y2 - y4);
    c = (x3 - x4)*(y1 - y4) - (x1 - x4)*(y3 - y4);
//Resultado. Retorna: 0 se não estiver, 1 se estiver
    return (sign(a) == sign(b) && sign(b) == sign(c));

2- Checar se um ponto está dentro de um círculo

Código:

//É meu parcialmente, só fiz uma adaptação
// Argument0: x do ponto
//Argument1: y do ponto
//Argument2: x do centro do circulo
//Argument3: y do centro do circulo
//Argument4: Raio do circulo
//Retorna se a distância do ponto até o centro do circulo é menor ou igual ao raio do circulo.
//Se a distância for menor que o raio, logo o ponto está dentro do círculo.
return (point_distance(argument0,argument1,argument2,argument3) <= argument4);

3- Checar se um ponto está dentro de um quadrado (não é retângulo):

Código:

// Esse é totalmente meu
//Argument0: x do ponto
//Argument1: y do ponto
//Argument2: x do centro do quadrado
//Argument3: y do centro do quadrado
//Argument4: Comprimento do quadrado
return (point_distance(argument0,argument1,argument2,argument3)<=argument4*0.5);


4- Calcular a área de um circulo:

Código:

// É meu tambem
//Argument0: raio
return (floor(3.14*sqr(raio)));

5- Calcular o perímetro de um circulo:

Código:

//É meu tambem
//Argument0: raio
return (floor (6.28*argument0));

Adicionado 16/07/11 - 18:30

6- Simulando point_distance.

Código:

 //Esse não é meu
var x1, y1, x2, y2;
x1=argument0;
y1=argument1;
x2=argument2;
y2=argument3;
return sqrt(sqr(x1-x2)+sqr(y1-y2));


7- Calculando a direção entre dois pontos.

Código:

/*
Autor: Pedro Henrique
angulo=ponto_direcao(x1,y1,x2,y2);
Retorna o ângulo entre dois pontos.
*/
var tan_deg, tan_rad, ang_rad, ang_deg, x1, x2, y1, y2;
x1=argument0;
x2=argument2;
y1=argument1;
y2=argument3;
//Diz que o tangente do angulo é a divisão
tan_deg=(y2-y1)/(x2-x1);
//Converte o tangente para radianos
tan_rad=degtorad(tan_deg);
//Pega o angulo em radianos a partir do tangente
ang_rad=arctan(tan_rad);
//Converte em graus
ang_deg=radtodeg(ang_rad);
//Retorna o valor, que pode ser guardado numa variavel
return ang_deg;

8- Calculando a distância entre dois pontos, em 3D:

Código:

//Não é meu script
var x1, y1, z1, x2, y2, z2, a, b, c;
x1=argument0;
y1=argument1;
z1=argument2;
x2=argument3;
y2=argument4;
z2=argument5;
a=point_distance(x1,y1,x2,y2);
b=abs(z1-z2);
c=sqrt(sqr(a)+sqr(b));
return c;


9- Fazendo uma brincadeirinha, onde o número se repete:

Código:

//Esse é meu
var numero, a, resultado;
numero=get_integer("Digite um número:", 1); //numero de 1 a 9
if numero<1 or numero>9 exit;
a=12345679;
resultado=a*numero;
show_message(string(resultado));


10- Retornar o resto da divisão:

Código:

//Esse é meu também.
//Argument0: Um numero
//Argument1: outro numero
return (argument0 mod argument1);

11- Pegar a parte decimal do numero:

Código:

// Pedro Henrique
//argument0: o numero com decimais, tipo 123.4529
return (argument0-floor(argument0)); //vai retornar 0.4529


12- Calcular a raiz quadrada de um número, com margem de erro:

Código:

//Adaptação de um algoritmo
//argument0: o numero
var aprox, val1, val2;
aprox=0.1;
val1=1;
val2=0;
  while (abs(val1-val2) > aprox) {
                val2 = val1;
                val1 = (val1 + (argument0/val1))/2;
        }
        return val1;


13- Scripts por Kabeção.

Se um número chegar a um limite, começar do zero:

Código:

// var - > variável
// valor -> valor para adicionar ou subtrair
// valor_max -> valor máximo (atingido ira voltar para 0)
var = (var+valor) mod valor_max;

Adicionar valores até um valor máximo:

Código:

var = min(var+valor,var_max);

Subtrair valores até um valor minimo:

Código:

var = max(var-valor,var_min);

14- Calcular a área de um triângulo com as coordenadas de seus vértices:

Código:

 //Pedro Henrique
var x1, x2, y1, y2, x3, y3;
x1=argument0;
x2=argument2;
x3=argument4;
y1=argument1;
y2=argument3;
y3=argument5;
area = (x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2))*0.5;
return abs(area);

Vou adicionar mais alguns quando der.

Até mais!

Interessante essas funções matemáticas... Bom, como ainda estou no 8º ano, não sabia que a distância entre dois pontos era a raiz quadrada do quadrado do primeiro ponto mais o segundo ponto. Mas a função point_distance já faz isso para nós... É sempre bom saber o que corre por trás dessas funções do GM. Seria legal você reproduzir algumas funções.

A do resto da divisão eu já sabia, parece que se chama aritmética modular, eu uso muito ele para estabelecer uma espécie de loop com um valor-limite

Pedro Henrique escreveu:Fica só uma curiosidade: O game maker processa contas de multiplicação mais rapidamente do que contas de divisão. Prefira usar 0.5*numero do que numero/2.

Não só o Game Maker, o ser humano também xD Mas valeu pela dica. Outra coisa, qual é o tempo de atraso entre as operações? Sabe me dizer?

Vou tentar reproduzir outras funções.

Não só o Game Maker, o ser humano também xD Mas valeu pela dica. Outra coisa, qual é o tempo de atraso entre as operações? Sabe me dizer?

Fiz o teste. A diferença de tempo foi nula várias vezes. Só uma vez a diferença foi de 10 milissegundos.
Só que eu coloquei para repetir as contas várias vezes no mesmo step. A diferença variou de 0 a 50 milissegundos. Ou seja, se você fizer a conta uma única vez no step, os resultados são praticamente iguais. Em escala maior, as diferenças são notadas.
--------------------------
Atualizações
Foram adicionados mais scripts:

- Raiz quadrada (funciona com numeros inteiros)
- Pegar a parte decimal (depois da virgula) de um numero
- Simulando point_direction. Calcula o angulo entre dois pontos.

Até mais!

Muito bom, é bom conhecer como algumas funções do game maker trabalham internamente, pegar a função prontinha e usar é fácil, agora é bom saber como elas funcionam para quem sabe usar em um outra linguagem onde não tenha a função pronta.

Fica só uma curiosidade: O game maker processa contas de multiplicação mais rapidamente do que contas de divisão. Prefira usar 0.5*numero do que numero/2.

Interessante isso, agora só por curiosidade, isso é uma logica, no caso um computador consegue multiplicar mais rápido que dividir, ou isso é exclusividade do game maker, se for exclusivo do game maker como chegou a essa conclusão?

Pedro Henrique escreveu:Fica só uma curiosidade: O game maker processa contas de multiplicação mais rapidamente do que contas de divisão. Prefira usar 0.5*numero do que numero/2.

Hmmm... Surgiu-me uma dúvida: para o 0.5*numero funcionar como numero/2, ele tem que estar obrigatoriamente antes do número, correto? Ou posso usar depois também, como você fez no 3º script?

Markituh escreveu:

Pedro Henrique escreveu:Fica só uma curiosidade: O game maker processa contas de multiplicação mais rapidamente do que contas de divisão. Prefira usar 0.5*numero do que numero/2.

Hmmm... Surgiu-me uma dúvida: para o 0.5*numero funcionar como numero/2, ele tem que estar obrigatoriamente antes do número, correto? Ou posso usar depois também, como você fez no 3º script?

A ordem dos fatores não altera o produto.

Seria bom adicionar também algumas facilidades que a matemática nos da na hora de programar como:
Quando atingir a valor máximo, voltar a 0 em uma linha:

Código:

// var - > variável
// valor -> valor de incremento
// valor_max -> valor máximo (atingido ira voltar para 0)
var = (var+valor) mod valor_max;

Adicionar valores até um limite máximo sem precisar usar um "if"

Código:

var = min(var+valor,var_max);

Diminuir valores até um limite mínimo sem presisar usar um "if"

Código:

var = max(var-valor,var_min);

E também código eficientes que embora não pareça, envolve matemática ou simplesmente boolean.

Trocar true por false ou vice e versa sem usar um "if"

Código:

var = !var;

Definir direção do jogador (direita ou esquerda) com base nas teclas pressionada

Código:

// -1 = esquerda, 1 = direita, 0 = nulo (apertando as duas teclas ao mesmo tempo ou não apertando nem uma)
dir = keyboard_check(vk_left)-keyboard_check(vk_right);

// Assim para adicionar movimento basta multiplicar o dir pelo acréscimo
// Note que quando dir for 0 o jogador vai parar
// Isso é um script básico de movimento com apenas alguns códigos
x += x_speed*dir;

Adicionar valores até um limite máximo sem precisar usar um "if"
CÓDIGO:
var = min(var+valor,var_max);

Diminuir valores até um limite mínimo sem presisar usar um "if"
CÓDIGO:
var = max(var-valor,var_min);

Também pode usar esse codigo estabelecendo um valor minimo e um máximo, fazendo que o valor fica entre o minimo e o máximo

Código:

min(var_max, max(var_min, value));

Klior escreveu:min(var_max, max(var_min, value));

É mais prático usar essa função, embora não mude muita coisa:

Código:

median(var_min, var_max, valor);

Kabeção escreveu:dir = keyboard_check(vk_left)-keyboard_check(vk_right);

Está invertido. o certo seria:

Código:

dir = keyboard_check(vk_right)-keyboard_check(vk_left);

Valeu gente por contribuir. Em breve vou colocar mais algumas fórmulas/equações.
E Markituh, a ordem dos fatores não altera o produto, como disse o Kabeção.

Até mais!

Mesmo que isso não sirva pra nada, tá aí:

Código:

var xx, yy;
xx=0
yy=0

if mouse_check_button(mb_left)
{xx=mouse_x
yy=mouse_y}
draw_line(xx,yy,x,y)

x=mouse_x
y=mouse_y

Coloca isso no draw, clica na tela e fica arrastando :/. Vou ver se faço algo mais útil. Ótimos scripts, Pedro.

Um método de calcular a área de um triângulo, usando o determinante (estude matrizes):

| x1 y1 1 |
| x2 y2 1 | = Area * 2
| x3 y3 1 |

x1*y2+x3*y1+x2*y3 - x3*y2 - x1*y3 - x2*y1 = Area * 2
x1*(y2-y3) + x2*(y3-y1) + x3*(y1-y2) = Area * 2

O script de exemplo pode ser conferido no tópico.
Adicionados os scripts do Kabeção.

Até mais!

Pedrø, demorei pra comentar porque quero tirar todas as minhas dúvidas e comentar tudo num post só. Vamos lá, a numeração que eu estarei usando é a mesma que você usou:

1- UAU! Ainda não testei, mas se funcionar... UAU! Você teria um histórico de como o sujeito chegou a essa função?
3- Há um erro. O script verifica se o ponto está dentro do círculo inscrito no quadrado, mas ignora as bordas.
4- e 5- Acho que existe a constante "pi" no game maker. Ela aumentaria a precisão do script.
7- O script dará erro quando X1 for igual a X2. Talvez seja interessante prever essa eventualidade. Tentei fazer isso uma vez (a mais tempo), e cheguei a conclusão que usar arc_tan2 era melhor, mas não lembro porque.
8- Dá pra fazer em uma linha, se você usar pitágoras duas vezes seguidas.
9- Eu brincava disso com calculadoras, muito antes de computadores serem itens domésticos!
Pra pegar o número, eu sugeriria fazer assim:

Código:

var i;
i=0;
while(i<1 || i>9){
   i=get_integer("Digite um número de um a nove", 1)
   }

11- return(argument0 div 1) deve ser mais rápido
13- Adicionar e subtrair valores até certo limite pode ser simplificado assim:

Código:

valor=madian(valorMínimo, valor+variação, valorMáximo)

Obs: Ah, li os comentários. Você já sabe disso.

Pra ir diminuindo de um em um e, quando chegar a zero ir para o valor máximo, em uma linha, você pode usar

Código:

valor = (valor + valorMáximo - 1) mod valorMáximo

14- Outro script impressionante, que eu gostaria de ver uma explicação. Que funciona, funciona, porque eu testei no excell. Mas eu não saberia explicar o porque desse funcionamento.

15- Existe um truque (que eu não vou saber explicar) que calcula a diferença entre ângulos. Esse truque te retorna valores entre 180 e -180. Ou seja, a diferença entre 359 e 0 será -1, o que é útil pra fazer um canhão ir girando lentamente em direção ao player, por exemplo.
Lembre-me de te mandar esse truque (ele usa uns 4-5 mods, então não tenho ele de cabeça...)

Edit: Tá aqui, créditos no próprio script. Parece que só usa dois mods, afinal...

Código:

/*
**  usage:
**      diff = angle_difference(angle1,angle2);
**
**  given:
**      angle1    first direction in degrees, real
**      angle2    second direction in degrees, real
**
**  returns:
**      difference of the given angles in degrees, -180 to 180
**
**  GMLscripts.com
*/
{
    return ((((argument0 - argument1) mod 360) + 540) mod 360) - 180;
}