Simulação física (Gravidade)

23 de Julho de 2011
3,217
1,329
0
31
www.peredelski.com.br
#1
[glow=red,2,300]~~ Pré-Requisitos ~~[/glow]

Conhecimento Básico em ActionScript 2.0/3.0

Macromedia Flash(MX ou Superior)

[glow=blue,2,300]~~ Objetivo ~~[/glow]

O objetivo deste tutorial é que você, ao término dele possa entender como criar efeitos reais. O efeito que veremos é o da gravidade, a colisão inelástica e elástica de uma bola quando esta colide com uma parede, solo ou qualquer outra superfície. Todas neste tutorial podem ser acionadas apenas clicando na bolinha arrastando para jogá-la onde quiser.

[glow=green,2,300]~~ Conceitos ~~[/glow]

Os conceitos que serão vistos aqui, são mais de aplicação da física em simulações que podem ser usadas para tornar seu game ainda mais legal e viciante. Dentre os conceitos que serão apresentados podemos destacar o da gravidade, coeficiente de restituição, colisão elástica e ineláslitca.

[glow=yellow,2,300]~~ Tutorial ~~[/glow]

Inicialmente baixe os arquivos que disponibilizei no final deste tutorial. Abra o Macromedia Flash 8 e crie um documento flash novo apertando CTRL + N. Agora crie um novo símbolo do tipo button apertando CTRL + F8, coloque o nome de bola_drag. Com o botão no modo de edição vá em file -> import -> import to library. Importe a imagem a imagem que está nos arquivos que você baixou, o arquivo se chama bola_golf.jpg. Quando importar a imagem irá aparecer na sua library, portanto arraste essa imagem para o centro do stage de edição do botão e posicione nos valores mostrados na figura abaixo::



Figura 1 – Dimensões e a posição da imagem

Pronto, insira novamente um novo símbolo do tipo movie clip e dê o nome bola. Com esse movie clip vazio aberto coloque ao centro o botão que acabamos de fazer, coloque o mesmo tamanho e posição que está na imagem acima. Depois de posicionar, dê um clique nesse botão bola_drag e coloque o seguinte código:

1.on (press)

2.{

3.  arrastando = true;

4.  startDrag(this, true);

5.}

6.on (release, releaseOutside)

7.{

8.  arrastando = false;

9.  stopDrag();

10.}

Volte à cena principal e crie duas layers: uma chamada Action e outra chamada Bola, na layer chamada Bola você irá até a library e arrastar o mc chamado bola que acabamos de fazer para o centro do stage, caso tenha dúvida olhe só como ficou a disposição das layers:

[img width=300 height=120]http://www.mxstudio.com.br/imagens_artigos/marcioSilva_out07_gravidade_imagens/img2.jpg

Figura 2 – Layers da simulação .

Note também que na figura acima vc irá ver o frame rate que utilizei nesta simulação, coloquei 36 fps, quanto maior melhor fica a simulação. No frame 1 da layer Action coloque o seguinte código:

1.maxWidth = Stage.width-5;

2.maxHeight = Stage.height-5;

3.stop();

4.align=justify>

Agora Vamos ao código que realmente faz a simulação física que implementaremos, o código mostrado a seguir implementa uma teoria vista em física, pretendo apenas mostrar um breve conceito do que o código faz, fica a seu cargo estudar mais a fundo essa teoria.

1.onClipEvent (load)

2.{

3.  gravidade = 10; // valor da gravidade

4.  restituicao = 0.89; //coeficiente de restituição

5.  raio = this._width/2; //raio da bolinha

6.  vx = 140; //valor inicial da velocidade em X

7.  vy = 140; //valor da velocidade inicial em Y

8.}

9.onClipEvent (enterFrame)

10.{

11.  /*pega a ultima posição ocupada pela bolinha

1.  * no instante anterior ao corrente

2.  */

13.  oldx = x;

14.  oldy = y; /* armazena a atual posição da bolinha na tela*/

15.  x = this._x;

16.  y = this._y;

17.  /* Verifica se o usuário está arrastanto a bolinha*/

18.  if (arrastando)

19.  {

20.      /*pega a variação de posição da bolinha*/

21.      vx = (x-oldx);

22.      vy = (y-oldy);

23.  }

24.  else

25.  {

26.      vy += gravidade; //aplica o efeito de gravidade

27.      x += (vx/10); //aplica a velocidade em X

28.      y += (vy/10); //aplica a velocidade em Y

29.      /*Verificação de colisão com as bordas do Stage*/

30.      if (y < raio) //SUPERIOR

31.      {

32.        y = raio;

33.        vx *= restituicao;

34.        vy *= -restituicao;//muda o sentido da velocidade em Y

35.      }

36.      if (y > (_root.maxHeight-raio)) //INFERIOR

37.      {

38.        y = _root.maxHeight-raio;

39.        vx *= restituicao;

40.        vy *= -restituicao;

41.      }

42.      if (x < raio) //ESQUERDA

43.      {

44.        x = raio;

45.        vx *= -restituicao;

46.        vy *= restituicao;

47.      }

48.      if (x > (_root.maxWidth-raio)) //DIREITA

49.      {

50.        x = _root.maxWidth-raio;

51.        vx *= -restituicao;

52.        vy *= restituicao;

53.      }

54.      /* atualiza a posição da bolinha*/

55.      this._x = x;

56.      this._y = y;

57.  }

58.}//adaptado flashGuru

[glow=red,2,300]~~ Entendendo o Código ~~[/glow]

As variáveis que o código utiliza são todas variáveis de expressões físicas. A gravidade dispensa explicações; vx e vy são respectivamente velocidade no eixo x e y; raio é o raio da bolinha e por fim a restituicao responsável pelo efeito ‘quicar’ da bolinha. Formalizando essa variável restituição ela é obtida fazendo a divisão entre a velocidade v2 depois da colisão com a velocidade v1 antes da colisão. Veja abaixo várias formas de se obter o valor do coeficiente de restituição:

[img width=300 height=120]http://www.mxstudio.com.br/imagens_artigos/marcioSilva_out07_gravidade_imagens/img3.jpg

Figura 3 – Formalização matemática

Minhas desculpas aos que não gostam de física ou matemática, mas é preciso dessa formalização para entender por que o código foi implemementado daquela forma. A diferença entre o código e a formalização é que já temos de antemão o valor do coeficiente de restituição e o valor da velocidade v1 logo para obtermos a velocidade v2 que é após a colisão basta multiplicarmos a velocidade atual pelo coeficiente de restituição. As linhas 35, 36, 41, 42, 47, 48, 53 e 54 fazem exatamente o cálculo de v2 baseado na velocidade v1. E veja que o coeficiente somente é utilizado no cálculo da velocidade quando há uma colisão. O coeficiente é um número sem unidade, ou seja, é adimensional, variando entre 0 e 1.



Créditos:

Imagens - MXCLUB

Tutorial - Jhonas(Com Muitas Modificações Feitas Por Mim Diego Peredelski)

1773_.zip