Ponto V!

Home Arquitetura Matemática e Física O uso de vetores nos jogos
Vinícius Godoy de Mendonça
O uso de vetores nos jogosImprimir
Escrito por Vinícius Godoy de Mendonça

Muitos programadores ao se depararem com assuntos envolvendo matemática sentem profundos calafrios. Entretanto, se você quer ir além de jogos envolvendo “quadradinhos” na tela, deve começar aprendendo uma das mais úteis ferramentas da matemática: os vetores.

Este artigo introduz o conceito de vetores sem muito linguajar matemático e de maneira prática, mostrando como programá-lo no seu programa. Ao final, também disponibilizamos o download de classes de vetores 2D e 3D para as linguagens Java, C++ e C#.

O que são vetores?

Mas, afinal, o que são vetores? Algumas grandezas, tais como um número de sapato, a altura de um prédio ou mesmo os minutos que faltam para você acabar de ler essa matéria são representadas por um simples número, dentro de uma escala qualquer. Essas são as grandezas escalares.

Outras grandezas não são tão fáceis de descrever assim. Por exemplo, como descrever a direção que o seu corpo se move? Ou, como entender a força do vento? Além de uma intensidade, a força do vento também tem uma direção. Por isso, ela não é simplesmente uma grandeza escalar, mas sim, uma grandeza vetorial.

Vetores possuem uma orientação (ou seja, uma direção e um sentido) e um tamanho. Graficamente, representamos um vetor por uma seta, onde a ponta indica a orientação e o comprimento dá a noção de seu tamanho, por exemplo:

Representação gráfica do vetor

Vetores são muito versáteis. No exemplo acima, enquanto o primeiro poderia indicar a direção de uma bola sendo chutada por um zagueiro, o segundo poderia indicar a força gravidade. Vamos pegar o primeiro vetor exibido ali e colocar num eixo cartesiano. Assim, podemos dissecá-lo e entender suas propriedades:

Propriedades dos vetores

Um vetor bidimensional de tamanho t, no eixo cartesiano, pode ser expresso por duas grandezas, uma em x e outra em y. No C++ ou no Java, essas grandezas virariam duas variáveis float ou double:

#include 
class Vector2D
{
   public:
      float x;
      float y;

      Vector2D() : x(0.0f), y(0.0f) {}
      Vector2D(float _x, float _y) : x(_x), y(_y) {}
};

Um valor em x... outro em y... Isso lembra a coordenada de um ponto, não? Apesar de parecidos em sua estrutura, os vetores não são equivalentes a pontos. Eles representam um deslocamento em uma direção e não tem posição no espaço. Já os pontos, representam uma posição, e não tem direção ou sentido. Entretanto, você pode usar um vetor para representar um ponto: ele indicará então o deslocamento do ponto em relação à origem (0,0). Só tome cuidado pois algumas operações não fazem sentido entre pontos, como somar dois pontos.

Se você for um bom observador, já deve ter notado que o tamanho do vetor pode ser facilmente obtido pelo teorema de Pitágoras. Não notou ainda? Então, repare melhor na figura anterior. Os tamanhos em x e y são lados de um triângulo retângulo e o vetor é a hipotenusa. Assim, podemos acrescentar a nossa classe a seguinte função:

float Vector2D::size() 
{ 
   return std::sqrt(x*x + y*y); 
}

Até agora nada disso teve muita graça. Não desanime, estamos chegando na parte interessante. Podemos fazer a soma e a subtração entre dois vetores. Isso é moleza: basta somar o x do primeiro vetor com o x do segundo e repetir o processo para o y. A subtração também ocorre da mesma forma. Vamos demonstrar isso graficamente:

Soma e subtração

Que tal ver como isso ficaria no C++?

Vector2D Vector2D::operator +(const Vector2D& other) const
{
   return Vector2D(x + other.x, y + other.y);
}

Vector2D& Vector2D::operator +=(const Vector2D& other) 
{
   x += other.x;
   y += other.y;
   return *this;
}

Deixamos para você a tarefa de repetir o código para o sinal de menos.

Que tal algumas aplicações práticas disso tudo? Lembra-se que vetores podem representar pontos? Pois bem, a subtração entre dois vetores que representam pontos resulta num vetor que é a trajetória entre esses dois pontos e o tamanho desse vetor representa a distância que terá de ser percorrida. Observe:

image

E o que mais tem de interessante nisso tudo? Observe o que aconteceria se, a cada segundo (ou a cada loop do nosso jogo), somássemos o vetor que representava a trajetória de uma bola ao vetor da gravidade. Na figura abaixo, as linhas tracejadas representam o vetor trajetória do segundo anterior e o vetor gravidade, enquanto a linha forte a trajetória resultante da soma dos dois:

Soma de forças

Que chute, hein? O mais interessante é que se quiséssemos adicionar vento, bastaria simplesmente somar o vetor indicando a força e a direção do vento a cada segundo, como foi feito com a gravidade.

Agora, e se desejássemos um vetor que fosse duas vezes maior que outro? Ou que tal duas vezes menor? O fato é que vetores podem ser multiplicados ou divididos também por um escalar. O processo é simples, basta multiplicar (ou dividir) o x e y do vetor pelo número desejado, como nesse código em C++:

Vector2D Vector2D::operator *(float scalar) const
{
   return Vector2D(x * scalar, y * scalar);
}

Vector2D& Vector2D::operator *=(float scalar) 
{
   x *= scalar;
   y *= scalar;
   return *this;
}

E se quiséssemos impor um tamanho a um vetor? Um dos processos mais importantes envolvendo vetores chama-se normalização. Esse processo reduz o tamanho do vetor para 1. Um vetor normalizado pode então ser multiplicado por um escalar para obtermos tamanho desejado. Para normalizar um vetor, basta dividirmos x e y pelo tamanho do vetor:

Vector2D& Vector2D::normalize()
{
   return (*this /= size());
}

Você pode estar curioso a respeito do porque do nome normalização. Acontece que o tamanho do vetor também tem outros nomes como: magnitude, módulo, intensidade ou norma. O que prova que os matemáticos também sabem ser criativos com o português quando querem.

Vetores e ângulos

Além de definir um x e y fixos, seria muito bom que pudéssemos criar um vetor a partir de um ângulo em relação ao eixo x e um tamanho. Assim, poderíamos dizer que o atacante chutou a bola com um ângulo de 50º e uma força de 10. Como fazer isso? Lembre-se que todo vetor pode ser desenhado como um triângulo retângulo. Por conseqüência, podemos aplicar senos e co-senos para achar os valores de x e y. A fórmula é a seguinte:

X = co-seno(ângulo) * tamanho;
Y = seno(ângulo) * tamanho

Como já temos um construtor que recebe dois floats, vamos definir um método estático para essa função (lembre-se que o C++ trabalha com ângulos em radianos, não em graus e que 1 grau equivale à PI/180 radianos):

Vector2D Vector2D::newBySizeAngle(float size, float angle)
{
   return Vector2D(
      cos(angle) * size,
      sin(angle) * size);
}

Da mesma forma, podemos definir qual é o ângulo de um vetor em relação ao eixo x, através do arco-tangente entre y e x:

float Vector2D::angle() const
{
   return atan2f(y,x);
}

Outra operação interessante é a rotação de um vetor. Com um pouco de trigonometria, a rotação pode ser descrita da seguinte forma:

Vector2D& Vector2D::rotate(float angle)
{
   float s = sin(angle);
   float c = cos(angle);

   float newX = x * c - y * s;
   float newY = x * s + y * c;

   x = newX;
   y = newY;

   return *this;
}

E que tal acharmos o ângulo entre um vetor A e B quaisquer? Para isso, usamos uma propriedade dos vetores conhecida como produto escalar. Afinal, o produto escalar é definido por duas formas:

Produto escalar

Assim, podemos dizer que:

Produto escalar

Onde |A| e |B| são respectivamente os tamanhos de A e B e α o ângulo que queremos calcular. Agora, note como o cálculo seria simplificado se A e B fossem vetores de tamanho 1:

Produto escalar: vetor unitário

Evitar o cálculo do tamanho reduz muito processamento, por isso é bom usar vetores normalizados para representar direções. No C++, o método para o cálculo do produto escalar fica assim:

float Vector2D::dot(const Vector2D& other) const
{
   return x * other.x + y * other.y;
}

E o do ângulo entre os dois vetores unitários, assim:

float relativeAngleBetween(const Vector2D& other) const
{
   float dp = dot(other); 

   //Força que o valor esteja na faixa esperada pelo C++
   //Se os floats fossem totalmente precisos, 
   //não precisaríamos fazer esses testes

   if(dp >= 1.0) dp = 1.0f;
   else if(dp <=-1.0) dp = -1.0f;

   //Faz o cálculo do ângulo. O C++ sempre retorna positivo
   float angPi = (float)acos(dp);

   //teste de lado para definir o sinal
   return perpDot(*this, other) > 0 ? -angPi : angPi;
}

Onde perpDot refere-se ao produto escalar do vetor perpendicular ao this, em relação ao vetor other.

Mais exemplos práticos

E qual a utilidade disso tudo? Como isso é usado nos jogos? Em primeiro lugar, é fácil representar qualquer objeto no espaço por dois vetores. O primeiro descreve a posição do personagem. O segundo, descreve a sua direção (sendo esse normalmente um vetor unitário).

Antes de continuar lendo a matéria, pense em como você faria para que o Igor, o troll, caminhasse na direção a sua comida sem se virar bruscamente (os vetores da direção estão em azul e os da posição em preto):

Igor e sua comida

O primeiro passo seria calcular a trajetória do troll em relação a princesa. Já vimos que isso é fácil: basta subtrair as duas posições. O segundo, seria calcular o ângulo da direção do troll em relação a essa trajetória, para isso, normalizamos o vetor e usamos a função angleBetween. Por fim, bastaria rodarmos Igor alguns graus a cada loop do jogo, até que esse ângulo fosse atingido. O código se resumiria a:

//Calculamos a trajetória entre A e B
Vector2D path = A.position – B.position;

//Vemos se precisamos rodar
path.normalize() //Angulos so com vetores normalizados
float angleToRotate = A.direction.angleBetween(path);
float oneDegree = 3.1415f / 180;

//Roda suavemente, no máximo um grau
a.direction.rotate(
   angleToRotate > oneDegree ? oneDegree : angleToRotate); 

//Anda naquela direção
a.position += a.direction * speed * time;

Outro exemplo? Imagine uma nave com dois canhões laterais. Você já viu que é possível rodar vetores, portanto, seria fácil girar a nave. Como fazer para rodar os canhões junto com a nave e, assim, saber a posição onde os tiros devem sair?

A resposta é simples: Para cada canhão, crie um vetor partindo do centro da nave até a posição desejada (indicados em branco na terceira imagem). Sempre que o vetor de direção (amarelo) da nave rodar, gire também esses vetores de posicionamento dos canhões usando o mesmo ângulo.

Posições relativas dos canhões

Agora, basta somar os vetores à posição da nave para obter a posição real dos canhões.

Também seria possível calcular um campo de visão. Como saber se um inimigo da IA de seu jogo consegue ver o herói do jogador? Lembre-se: a subtração da posição do personagem e da posição do inimigo resulta no vetor da trajetória entre os dois. Com isso, você poderia definir que o jogador só seria visto se o tamanho desse vetor fosse menor que, por exemplo, 10 unidades. E melhor, além disso, o ângulo da direção do inimigo com esse vetor não poderia ser maior do que 45º (ou menor do que -45º). Voilá! Um campo de visão perfeito:

Campo de visão

Ufa! Não foi dessa vez que a princesa virou comida nas mãos de Igor (vamos torcer para ele não ter um bom faro).

Com vetores, você também seria capaz de modelar o comportamento dos planetas do sistema solar, exércitos, cardumes, fazer um carro perseguir outro, ou mesmo, manter aviões em uma perfeita formação no céu. Esses e outros exemplos podem ser encontrados no site sobre uma técnica conhecida como Steering Behaviors (site em inglês): http://www.red3d.com/cwr/steer/

Agora que você compreendeu a importância dos vetores e um pouco sobre como e quando usa-los, ponha seu conhecimento em prática! Você pode tentar fazer algo similar ao jogo Worms, onde um jogador atira objetos no outro. Além da gravidade, tente adicionar também a força do vento. Depois de pronto, chame seus amigos e divirta-se!

Clicando nos links a seguir, você poderá baixar as classes de vetores 2D e 3D em três versões: C++, Java e C#.


Comentários (82)
  • Vitor Almeida da Silva  - Excelente artigo
    avatar

    Excelente artigo Vinícius.

    Este é um tema que eu queria escrever um artigo a muito tempo.

    Os exemplos estão bem didáticos e os temas estão na medida.

    Parabéns.

    PS: qual programa você utilizou para fazer os diagramas e gráficos? Photoshop mesmo?

  • Vinícius Godoy de Mendonça  - Programas
    avatar

    Por incrível que pareça foi o próprio MS-Word. Os desenhos foram tirados da MS-Clipart Gallery.

    Eu tenho esse artigo há alguns anos, mas estava em formato PDF. Ia ser publicado no PDJ-Zine, mas a publicação acabou nunca acontecendo.

    Decidi então passa-lo para o formato de webpage e o resultado está aí. Ainda falta falar um pouco mais de produto vetorial, escalar e talvez até quaternions, mas isso deixo para um artigo futuro.

  • Bruno Crivelari Sanches  - Aulas de GA
    avatar

    Lendo esse artigo lembrei da frase do meu professor de Ga (Geometria Analítica): "Vetor é que nem anjinho de árvore de natal, você coloca ele onde quiser".

    Falava isso tentando enfiar na cabeça do pessoal que um vetor era uma direção e magnitude, independente da posição :).

  • Eduardo  - Ótimo
    avatar

    Muito bom esse artigo, ficou ótimo toda a metodologia utilizada, por favor continuem esse trabalho, sempre to seguindo vc !!! parabéns !

  • julio brito
    avatar

    Parabéns Vinícius.
    Muito fácil de entender, boas ilustrações.
    Artigo excelente.

  • Mikhail  - Duvida C++
    avatar

    Ainda estou aprendendo C++ ...

    Oque significa esse formato de contrutor/função:

    Vector2D(float _x, float _y) : x(_x), y(_y) {}

    por que tem esses ": x(_x), y(_y)" ???

  • Vinícius Godoy de Mendonça  - Lista de inicialização
    avatar

    Depois do : está a lista de inicialização. Ali, existe uma chamada ao construtor de cada atributo da classe. A vantagem da lista de inicialização é que ela é executada no momento que o C++ cria cada variável.

    Se você inicializar os dados apenas dentro das chaves, o C++ rodará a inialização padrão, para só então rodar o que está dentro das chaves. Ou seja, você acaba fazendo 1 inicialização seguida de uma atribuição de valor, desperdiçando tempo e recursos.

    Note que para a lista, os tipos primitivos também tem uma espécie de construtor. Por exemplo, mesmo uma variável x criada como int poderá ser inicializada com x(20), onde 20 é seu valor.

  • Bruno BPS  - Parabens
    avatar

    Parabens tio miii! se é foda D:!!

    Quando eu me formar em desgne de web sites, pode conta comigo para coisas do tipo oks?

    Muito bom o tutorial, estou lendo todos =D!!

    Vou começar tecnico em programação para ter uma base de programação =p

    Até mais tio mii!

  • Marcos  - Mto Show
    avatar

    Galera parabens pelo site,sou tecnico em eletrônica e "arranho" um pouco de programação.O trabalho de vcs é coisa nova no Brasil e deve ser valorizado...um abraço e continuen postando novos artigos.

  • Gustavo Borba  - Dúvida em relação à vetores
    avatar

    Olá Vinícius! Estou usando um Thread para executar o update:

    Código:
    Runnable r = new Runnable() {
    public void run() {
    while(true) {
    cubeSpeed = cubeSpeed.add(gravity);
    cubePos = cubePos.add(cubeSpeed);
    repaint();
    }
    }
    };

    update = new Thread(r);
    update.start();

    Mas este código aparentemente não funciona na hora de atualizar os vetores ao meu ver ele está indo muito rápido! Pois quando dou o println ele meio que faz um "sleep" e a imagem não sai voando tão rápido!

    Ex.:

  • Vinícius Godoy de Mendonça
    avatar

    Desse jeito vai ficar rápido mesmo. Dá uma lida [url=http://www.pontov.com.br/site/index.php/arquitetura-de-jogos/51-p rogramacao/113-animacao-baseada-em-tempo]aqui[/url], aqui e aqui. :)

  • Gustavo Borba  - Opa! Valeu pela dica!
    avatar

    Opa! Valeu pela dica, consegui consertar o problema, a gravidade estava muito forte, ;) .

    Mas tenho dúvida em relação a uma coisa. Estou utilizando a classe Graphics para desenhar simples retângulos e crio objetos da classe 'Rectangle' para checar uma colisão entre eles (intersects()). Mas se fosse o caso da figura geométrica estiver girada/rotacionada em um ângulo diferente, ele detectaria?

    Outra dúvida, meu quadrado cai somente no eixo Y ele fica parecendo muito falso! pois seu eixo X não se mexe nem um pouquinho e sua rotação não muda! Como posso fazer para que ele se torne mais real?

  • Vinícius Godoy de Mendonça
    avatar

    Detectaria, mas ao rotacionar o bounding box fica enorme, e a detecção pode ficar bem feia.

    O ideal seria rotacionar o retângulo junto, mas a classe Rectangle 2D não implementa a matemática disso, nem a detecção de colisão de retângulos rotacionados.

    Para melhorar a física de agora em diante, só com um bocado de matemática. Ou então, use uma engine pronta com isso pronto, como essa aqui: http://www.cokeandcode.com/phys2d/

  • Gustavo Borba  - Pergunta
    avatar

    o problema de eu não poder usar essa engine é porque eu mesmo gostaria de saber como fazer, não é nenhum trabalho, mas sim por curiosidade e interesse. Não haveria outro jeito?

  • Vinícius Godoy de Mendonça  - Física
    avatar

    Ter tem. Basta comprar um livro de física e estudar. Um ótimo material é o Mathematics and Physics for Programmers, mas ele é numa linguagem diferente do Java.

    Tem também o Physics for Game Programmers, do Grant Palmer, que é em Java. Os dois livros são muito bons.

    Infelizmente, não tem material assim tão direcionado em português. Talvez seja bom dar um pulo numa livraria e verificar se há algum livro de física (normal, não pra programadores) que você goste.

    Mas certamente, não é em um post que vou conseguir te explicar. Talvez eu elabore mais artigos sobre o assunto, mas primeiro vou terminar as publicações de OpenGL.

    Agora, com a teoria de vetores já dá para simular muita coisa, aliás, boa parte do que os jogos 3D usam no dia a dia.

  • Fabricio Maciel  - Parabéns, ótimo artigo
    avatar

    Muito bom o artigo, ja peguei sua classe em JAVA e comecei a brincar, em desenhar uma linha na tragetória entre 2 pontos.
    Ai é que estou fazendo confução, esse vetor 2D dentro de um plano cartesiano não seria um linha certo? (de um ponto x,y á z,w) e sim um ponto (somente x,y).
    Não sei se eu estou fazendo confusão, eu pediria se possivel, um exemplo pratico (tanto faz em java ou C++) que demonstrasse a utilização dessa classe para mostrar a linha dos/entre (algo bem simples mesmo)
    Obrigado

  • Vinícius Godoy de Mendonça
    avatar

    Oi. Realmente, ele representa um ponto.

    Esse ponto, a partir da origem (0,0) está na exata distância entre os dois pontos que você fez a subtração.

    E o ângulo da reta formada pela origem e ele em relação à reta x é o mesmo ângulo formado pela origem a reta entre esses dois pontos.

    Você pode entender esse ponto como aquela reta da trajetória "transportada" até a origem.

    O vetor também tem uma direção. Se você transportar um segmento de reta até a origem, terá a opção de coloca-la em 1 entre 2 quadrantes. O primeiro seria colocando uma das pontas da reta no (0,0) e o outro colocando a outra ponta.

  • Mateus PL
    avatar

    Quando um tempo atraz quando comecei a aprender a fazer jogos estava fazendo um jogo do Sonic em java para treinar mas fiquei empacado na lógica de criação de rampas e de como fazer o personagem correr em direção dela e subir. Consegui fazer algo incrementando o Y (decrementando no caso do Java2D) quando o personagem colidia com a rampa, mas ficou meio tosco por que dava conflito com o tipo de gravidade que eu tinha implementado.

    Estou a mais de um ano sem mexer no jogo e agora lendo o post pensei em fazer usando vetores. Imaginei assim: o movimento do Sonic é por exemplo 5 em X e em Y. Quando o Sonic esta no plano o angulo do vetor é de 0°, então

    - movX = X.cos 0° ; como cos 0° = 1 então X seria ele mesmo
    - movY = Y.sen 0° ; como sen 0° = 0 então Y seria zero

    Isso faria com que no plano o Sonic andasse reto no eixo X.

    Quando ouvesse colisão com o objeto rampa eu pegaria o seu angulo e somaria com o angulo inicial. Se o angulo da rampa fosse = 30° então

    - movX = X.cos 30° ; movX = 4.3 (aproximadamente)
    - movY = Y.sen 30° ; moY = 2.5

    o que faria o Sonic subir a rampa :D

    Concerteza vai precisa de alguns ajustes, mas acho que essa lógica vai funcionar! :woohoo:

  • Vinícius Godoy de Mendonça
    avatar

    Na verdade, a idéia toda pro trás dos vetores é simplificar esse tipo de cálculo. Você não precisará olhar para os senos, cossenos e tangentes.

    Simplesmente associe ao tile da rampa, um vetor, com a inclinação e direção da rampa.

    Depois, basta somar à posição do sonic (que também será um vetor) o vetor de inclinação da rampa, na hora de desloca-lo.

    Fica simples como:
    sonicPos += tileRampa[posX][posY].inclinacaoDaRampa * velocidade;

  • Lourival  - Commment
    avatar

    Vinícius,

    vi que vc mora na cidade maravilhosa de Curitiba e só posso concluir uma coisa: vc não é curitibano, mais conhecido por "curitibesta", certo?
    Se fosse, vc jamais compartilharia conhecimento gratuitamente e, muito menos, responderia a comentários....

    abraço e parabéns...

  • Vinícius Godoy de Mendonça
    avatar

    hehhehehehe... oi Lourival. Sou nascido em SP, e criado numa família Goiana.

    Mas tem muito Curitibano legal, o povo daqui só é mais reservado.

  • Oberlan
    avatar

    Parabéns pelo artigo.

    Como idéia, se é que não pensaram nisso, seria fazer uns exemplos de uso de vetor 2d e 3d em OpenGL.

    Abraços

  • Felipe Tonello  - Quem escreveu o artigo não estudou matemática
    avatar

    Vinícius,

    Eu sei que quase ninguém sabe o que é um vetor. A culpa, na verdade, é do professor de Geometria Analítica da maioria que faz um "curso" de exatas.
    Seu artigo está muito bom, tirando a definição de vetor e de como você o usa. Sugiro você pesquisar bem antes de escrever qualquer coisa que leve seu nome.

    Se me permitir, um vetor é uma definição *lógica* da Teoria das Classes e não uma grandeza.

    Seja R uma equivalência em uma classe K. Definimos o conjunto quociente de K por R, denotado pelo símbolo K/R, da seguinte forma:
    K/R := { [X]R | X є K }
    Resulta que K/R é uma partição de K, i.e., K/R é uma classe de subconjuntos não vazios de K, dois a dois disjuntos (que não se interceptam) e cuja união é a classe K.
    Em resumo, temos o seguinte resultado importante:
    Sendo R uma equivalência de uma classe K, então, o conjunto quociente de K por R é uma partição de K.

    R é a relação definida na classe K de todos os *seguimentos orientados* do plano, da seguinte forma:
    xy R uz se, e somente se, o comprimento de xy for igual ao uz, a reta suporte de xy é paralela a uz e xy tem o mesmo sentido de uz.
    Resulta que R é uma equivalência em K. Portanto:
    K/R = { [PQ]R | PQ є K } é uma partição de K. Portanto:
    PQ R P'Q' ↔ [PQ]R = [P'Q']R

    Lembrando que [X]R := { Y є K | Y R X } ⊂ K

    Então, um *vetor* do plano é, por definição, um qualquer elemento do conjunto quociente de K por R. Assim temos, PQ R P'Q' ↔ PQ(vetor) = P'Q'(vetor)

    Claro que todos que estudam engenharia, matemática, física e etc deveriam saber esta definição. Porém sabemos que a maioria deles nem tem um curso de lógica.
    Então, recomendo, que se você não quer complicar e mesmo assim usar uma definição correta de vetor diga o seguinte:
    O vetor é um conjunto de *todos* os segmentos orientados equipolentes entre si. Ou seja AB(vetor) = { A'B' | A'B' ~ AB }.

    Por que você acha que é possível escrever AB(vetor) = CD(vetor)? Sendo que entre seguimentos orientados só é possível escrever AB = CD se eles realmente são os mesmos e, não, se são iguais. No caso de serem iguais, o correto é usar a equipolência. É claro que esse é um assunto para ser outro estudo, da Teoria da Identidade.

  • Vinícius Godoy de Mendonça
    avatar

    Felipe, eu comecei dando exemplo de grandezas vetoriais, mas não defini vetor como uma grandeza. Aliás, o artigo em momento nenhum dá uma definição formal de vetor. Ele deixa que o aluno chegue a definição por indução, e duvido muito que o público ao qual o artigo se destina precise de uma definição mais precisa.


    Como ressaltei no início do artigo, esse texto é uma introdução, para pessoas que não tem experiência com matemática, sem linguajar matemático. Mesmo a sua definição "simples", envolve o conhecimento de equipolência e fala de uma forma que diz pouco (para não dizer quase nada), para quem não tem uma formação matemática muito sólida.

    Você também se engana ao dizer que não estudei matemática, eu não só cursei os dois primeiros anos da faculdade de matemática (e, portanto, vi toda a geometria analítica), como também pedi para alguns colegas matemáticos revisarem esse artigo antes de publicá-lo. Eu abandonei o curso justamente por dar preferência à informática, mas é uma ciência que faz parte do meu dia-a-dia, tanto que sempre trabalhei com empresas relacionadas à Engenharia.

    Concordo com você. A culpa muitas vezes é dos professores de geometria analítica. Mas muitos deles justamente cometem o erro que você cometeu: falar uma linguagem que está muito longe da realidade dos alunos. Tenho experiência em ensinar Matemática e Física para jogos em sala de aula e muitas vezes peguei alunos que já estudaram geometria analítica de maneira formal, que sequer tinham noção do que podiam fazer com os vetores. Não raro, vários deles saem maravilhados e se arrependem de não ter prestado mais atenção na faculdade.


    Se quiser conferir as referências bibliográficas que usei para escrever o artigo, ficarei feliz em te passar. Tratam-se de livros escritos por matemáticos e físicos para programadores. A maioria usa uma abordagem didática, como eu usei, sem formalismos que assustam o aluno.

    A idéia aqui é só aproximar o leitor das contas, fazer com que ele perca o medo e entender a ferramenta maravilhosa que ele estará abrindo mão, caso decida se manter longe da matemática. Mostramos vetores através de exemplos da física e da computação gráfica, justamente para que o aluno veja utilidade prática de tudo isso. Se ele se interessar em se aprofundar no assunto, os livros estarão aí para dar a ele todo formalismo necessário.

  • Rodolfo Mendes
    avatar

    Parabéns! Você mostrou que manja, vai ganhar uma estrelinha!

  • renatinho
    avatar

    1-> A abstracao eh uma das maiores virtudes da humanidade.
    2-> oq vc fez foi trollagem ? eu nao entendi !!! Um cara inteligente sabe QUANDO se deve usar uma definicao formal e quando NAO.

    Se me permitir, um vetor é uma definição *lógica* da Teoria das Classes e não uma grandeza.
    1-> nao permito
    2-> Teoria das Classes non ecxiste ???? teorica dos conjuntos ?

    tem alguns erros na sua formalizacao amigo.
    ao dizer:
    R é a relação definida na classe K de todos os *seguimentos orientados* do plano, da seguinte forma:
    xy R uz se, e somente se, o comprimento de xy for igual ao uz, a reta suporte de xy é paralela a uz e xy tem o mesmo sentido de uz.
    nao da pra concluir que:
    Resulta que R é uma equivalência em K
    Para ser uma relacao de equivalence, diversos "criterios devem ser atendidos, precisa no minimo definir oq vc quer dizer com "comprimento de xy ..... " se eh pra ser formal tem q ir ate o fim ....

    Aqui:
    Então, um *vetor* do plano é, por definição, um qualquer elemento do conjunto quociente de K por R. Assim temos, PQ R P'Q' ↔ PQ(vetor) = P'Q'(vetor)

    como assim "do plano", oque é plano ???? vc nao definiu ....

    Como vc foi desnecessario ...........

  • Rafael Vieira Braga  - TOMA!
    avatar

    Quer ser rato de laboratório? Fica por lá mesmo, deixa a galera que sabe como conviver e lidar com "gente", fazer o que ela sabe. Se alguns dos professores do ensino médio deixassem de ter a TUA falta de didática, o "mundo" da universidade seria bem mais simples para todos.
    Gostei da resposta Vinícius. Parabéns mais uma vez.

  • Henrique Lobo Weissmann (Kico)  - É Vinicius, você conseguiu o que a UFMG não conseg
    avatar

    Opa,

    sabe de uma coisa? Quando fazia Matemática Computacional e estudei vetores, nunca vi uma aplicação tão nítida e bem feita como esta que você deu no assunto cara.

    Parabéns!

    E ah.... a KGames (Kico Games) agradece, porque agora muitas das coisas que eu julgava difíceis ficaram fáceis!

    Cara, você brilha (no bom sentido, é claro)!

  • Ermano Arruda  - Parabéns cara
    avatar

    Ótima conduta didática,e um excelente artigo,meus sinceros parabéns,Vinícius.Sou estudande de ciências da comp. pela ufpe(ainda um semi-calouro rumando para o segundo período) e fiquei maravilhado com seu artigo e com a forma livre de preconceitos e intuitiva como foi trabalhado.Fiquei feliz também pois muitas dessas "funcionalidades vetoriais" mostradas foram utilizadas em um joguinho que fiz como projeto da displina de álgebra linear(um joguinho de nave parecido com Asteróides - do Atari),foi legal saber que consegui entender e utilizar essas ferramentas um pouco além dos formalismos tradicionais.Também foi legal ter ganhado algumas ideias ao ver outros exemplos práticos que eu não tinha pensado,e relembrado e aprendido alguns detalhes muito úteis,como aquela sacada do campo de visão.Parabéns mais uma vez Vinícius ^^

  • Vinícius Godoy de Mendonça
    avatar

    Valeu. :)

    Essa é definitivamente a ferramenta matemática mais importante para o desenvolvedor de jogos.

  • adailton  - bom
    avatar

    cara eu acho muito legal é a forma de movimento de um objeto quando voce clicka em um tile do mapa e o avatar vai e consegue chegar cortando caminho.

    mas nao entendo nada ja revirei e nao achei nada disso na net.

  • Vinícius Godoy de Mendonça
    avatar

    Procure por "Path finding" e pelo algoritmo A*. Um bom material é esse aqui: http://www.policyalmanac.org/games/aStarTutorial_port.htm

  • Diego  - Ótimo artigo
    avatar

    Ficou excelente o artigo, parabéns :cheer:

    Vi que vc comentou sobre as referências bibliográficas e fiquei interessado, se for possivel gostaria de saber quais foram as referências :)

    Valeu :D

  • Vinicius de Sousa Araujo  - Excelente artigo chara...
    avatar

    Parabéns pelo artigo e por ter iniciativa!
    Achei muito explicativo e direto, sem enrolação...
    Muito bom para quem quer aprender...
    e no meu caso, é ótimo saber como aplicar oque aprendi na faculdade!

  • Vinícius Godoy de Mendonça
    avatar

    Obrigado. :)

    A sequência natural desse artigo é seguir para os artigos de matrizes e transformações.

  • Napoleon  - Muito bom
    avatar

    :woohoo: isso é muito legal poderia ensinar mais segredos sobre os vetores? :)

  • Vinícius Godoy de Mendonça
    avatar

    Claro, dê uma olhada nos artigos de matrizes. Elas podem transformar vetores. :)

  • Lucas Petrini
    avatar

    Cara, muito bom! Parabéns pelo artigo!! Sempre que entro aqui no pontov me animo e tenho vontade de começar a estudar gamedev novamente e me esforçar mais!

  • Vinícius Godoy de Mendonça
    avatar

    Obrigado. :)

  • Rafael Vieira Braga  - Dúvida
    avatar

    Como eu faço pra incluir essas classes no meu projeto??? Configuro só no compilador e no linker? Tem que compilar pra gerar o objeto?

  • Vinícius Godoy de Mendonça
    avatar

    Basta jogar os fontes dela no seu projeto e usa-las como se fossem parte do seu próprio programa. Não transformei elas em lib.

  • Rafael Vieira Braga  - Dúvida
    avatar

    Ah, tá certo. Blz então.

  • Rafael Vieira Braga  - Dúvida 2
    avatar

    Coloquei os arquivos lá no projeto, só copiei as fontes na pasta. Aí quando incluo uma variável do tipo Vector2D dá a seguinte mensagem:
    C:\DevJogos\SpaceWar\SpaceWar\teste.cpp|29|error: `Vector2D' does not name a type
    E agora, como faço pra Vectod2D ser reconhecido como um tipo?

  • Bruno Crivelari Sanches
    avatar

    Você colocou #include do arquivo onde o Vector2D é declarado? Compilador C/C++ só conhece aquilo que foi declarado.

    Para entender melhor como a compilação funciona, recomendo ler: http://pontov.com.br/site/cpp/46-conceitos-basicos/95-compilacao-de-pr ogramas-cc

  • Vinícius Godoy de Mendonça
    avatar

    Além do que o Bruno falou, observe que o Vector2D está no namespace math. Portanto, é necessário fazer:

    using namespace math;

    No início do arquivo.

  • Anônimo  - Muito bom.
    avatar

    Parabens pelo artigo.

    Cara, muito bom o artigo, isso abriu minha mente. Uma vez eu fiz um programa de lancamento obliquo mas nao usei vetores ( pelo menos nao explicitamente ) funcionou mas o codigo nao ficou nada legivel nem mesmo reutilizavel. Refarei com vetores, eles mudaram meu jeito de ver o mundo.

  • Vinícius Godoy de Mendonça
    avatar

    Obrigado. Você vai ver que o programa vai ficar trivialmente simples... e será muito fácil incluir outras forças, como vento.

  • Paulo  - Ótimo artigo
    avatar

    Ótimo artigo Vinícius, mandou muito bem. Me ajudou muito a entender o uso das grandezas vetoriais.

    Muito Obrigado, continue assim!

  • Vinícius Godoy de Mendonça
    avatar

    Valeu. :)

  • Cezar Marcelo Tung  - Muiiito obrigado
    avatar

    Vinícius,
    Quero agradecer demias por você compartilhar seus ensinamentos.
    Muito muito mesmo!!!
    Um grande abraço

  • Pietro Monteiro  - Dúvida
    avatar

    Olá Vinícius,
    Tenho algumas dúvidas, mas não é especificamente com relação ao seu trabalho (Mas já dizendo aqui, é um artigo maravilhoso e que esclareceu várias das diversas dúvidas que tinha) , mas voltando gostaria de saber se pode me esclarecer algumas coisas.

    1-Porque quando se trabalha equações de reta no ensino médio não se usa vetor, ou seja, não se utiliza um tratamento vetorial?
    Na realidade nem vetor se vê.

    2-No Curso de Geometria Analítica, já se vê equações de reta por meio de um tratamento vetorial, mas porque não se inicia pela equação geral da reta como é de habito no ensino médio?

    3- No Ensino Médio se ensina equação geral da reta, equação reduzida, equação segmentaria e equação paramétrica, nessa ordem. Seria possível ser aleatórias?

    Bem, num sei se fugiu um pouco do seu alcance essas questões, mas caso possa me ajudar a esclarecelas ficaria muito grato.

    forte abraço

  • Vinícius Godoy de Mendonça
    avatar

    Oi. Realmente não conheço bem o currículo do segundo grau. Entretanto, trabalho com uma autora de matemática na Positivo Informática, e ela respondeu o seguinte:

    "Provavelmente é uma questão histórica: sempre se fez assim e continuaremos fazendo. Tradicionalmente, o estudo de vetores é abordado pelos professores de Física, no contexto do estudo de forças. É importante notar que os conteúdos selecionados para o Ensino Médio seguem diretrizes bem genéricas do MEC. Então, se algum professor, adicionalmente, quiser trabalhar com vetores, não acredito que haja problema.
    Durante esses 9 anos em que trabalho no Positivo, venho observando como se desenvolve um material didático. E há pontos importantes a destacar:
    - os professores não são criativos em sala de aula, eles costumam seguir exatamente o que está nos livros que utilizam;
    - e quem escreve livros costuma acompanhar o que os concorrentes fazem, e dificilmente propõe grandes mudanças. Como há muitas queixas de que os professores não conseguem dar conta do conteúdo de Matemática do Ensino Médio, acho difícil que se proponha assuntos adicionais aos que já são contemplados. Aliás, o que vem ocorrendo, é a diminuição do número de aulas de Matemática para sobrar tempo à Música, Filosofia, Sociologia,...
    - Se aqui no Brasil tivéssemos a oportunidade de, dentro da escola, optar por disciplinas adicionais, como aprofundamento de estudos, seria possível termos, por exemplo, um curso de Matemática voltado para a Física ou para outras aplicações.
    - existe a grande possibilidade de até o estudo das matrizes ser retirado do currículo do Ensino Médio, já que não é um assunto cobrado no ENEM, assim como Números complexos.
    Quanto ao item 3 das dúvidas enviadas, acho que é apenas uma questão pedagógica. Se o professor optar por uma metodologia diferente, e preferir ensinar as equações em outra ordem, não há problema. Se os alunos aprenderem, e entenderem a diferença, está ok."

  • João Henrique
    avatar

    Achei excelente seu post, tive dificuldade em ver isso na faculdade.

    Fazia uns 5 anos que não via matemática do ensino médio, então aprender algo além disso era complicado.

    Mas vc me lembro meu professor de sistema de informação, por ele ser muito didático logo lembrei das coisas que ele dizia.

    Mesmo assim confesso que ficava tudo muito vago... creio que grande parte da dificuldade em matemática vem da forma não prática e nenhum um pouco objetiva que as coisas são passadas.


    Ainda fico pensando como vc consegue arranjar tempo para ser fera em C++ em JAVA e ao mesmo tempo manjar tanto de matemática. Fora outras coisas que provavelmente eu não sei.(Vc já fez algum curso de leitura dinâmica?).

  • Vinícius Godoy de Mendonça
    avatar

    Oi. Não fiz leitura dinâmica, e não acho que isso seja necessário.

    Bem, estou trabalhando com informática há mais de 15 anos. Com o tempo, você vai ver que aprender novas linguagens fica cada vez mais fácil.

    Hoje eu domino Java, C++ e C#, mas confesso que dá bastante trabalho me manter atualizado nas 3.

    Como atuei muito tempo com sistemas para engenharia, a matemática sempre esteve muito presente em minha vida. Hoje dou aula disso, então, surgem muitas oportunidades para revisar conceitos.

    Se você gostou dos artigos, aproveite também para ler os de matrizes e transformações, pois são a seqüência natural da Álgebra Linear. Dentre os conceitos matemáticos que um programador de games deve saber, vetores e suas transformações são, sem dúvida nenhuma, os mais importantes.

    E, qualquer dúvida, claro, é só perguntar. :)
    Devo lançar outro artigo de vetores num futuro próximo. Já inclusive até está escrito, passando apenas pela revisão. Creio que você vai gostar também.

  • janrie carlos tidres  - Otimo post mesmo, muito util
    avatar

    Fabricio Maciel, como você faz para ligar dois pontos?
    tem como passar o código que você usou?
    É que eu tav pracisando justamente disso, de ao clicar na tela desenha um ponto e ao dar um segundo clique em outro lugar da tela ligaria os dois pontos com uma linha e a cada clique ia sendo atualizado.
    Obrigado

  • mayk cesar  - ajuda rotacionar imagem
    avatar

    ola vinicios, primeiro parabens pelo artigo,bom sou novo no meio, estou fazendo faculdade e esse é um trabalho de matematica em que tenho que fazer um canhao rotacionar em graus de 0 a 90 e fazelo atiar em arco. estou com uma dificuldade em rotacionar uma imagem, o problema e que a imagem rotaciona mais o eixo do tiro não, o codigo que usei para rotacionar a imagem foi

    public static BufferedImage girar(BufferedImage img, double angle) {
    int w = img.getWidth();
    int h = img.getHeight();

    BufferedImage dimg =new BufferedImage(w, h, BufferedImage.TYPE_4BYTE_ABGR);
    Graphics2D g = dimg.createGraphics();
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, // Anti-alias!
    RenderingHints.VALUE_ANTIALIAS_ON);

    g.rotate(angle*PI/180, w/2, h/2);
    // g.rotate(Math.toRadians(angle), w/2, h/2);

    g.drawImage(img, null, 0, 0);
    return dimg;
    }
    bom se puder me ajudar obrigado.

  • ViniGodoy
    avatar

    Oi. Veja o exemplo em:
    http://www.guj.com.br/java/251733-rotacionando-um-imageicon/2#1307920< br />

  • mayk cesar
    avatar

    obrigado vinicios, mas cara não consigo fazer a mira rodar, vou postar o meu codigo todo para vc ver o que eu estou fazendo de errado.


    package canhao;

    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.Serializable;
    import static java.lang.Math.PI;

    public class Jogador extends Sprite implements Serializable{

    private int vida;
    private boolean left;
    private boolean right;
    private boolean up;
    private boolean down;

    private int timeInvensivel;
    private double miraX,miraY,novoX,novoY;
    private double mira_angulo;
    private double angle = 0;
    private double forca;

    private int frameAtual = 0;
    private int timeAnimacao = 0;
    private int framesAnimados = 8;

    public Jogador() {
    super("/fogo.png";);
    //setLargura(getLargura()/8);
    this.mira_angulo=0;
    }

    /**
    * @return the vida
    */
    public int getVida() {
    return vida;
    }

    /**
    * @param vida the vida to set
    */
    public void setVida(int vida) {
    this.vida = vida;
    }

    /**
    * @param left the left to set
    */
    public void setLeft(boolean left) {
    this.left = left;
    }

    /**
    * @param right the right to set
    */
    public void setRight(boolean right) {
    this.right = right;
    }

    /**
    * @param up the up to set
    */
    public void setUp(boolean up) {
    this.up = up;
    }

    /**
    * @param down the down to set
    */
    public void setDown(boolean down) {
    this.down = down;
    }



    public static BufferedImage girar(BufferedImage img, double angle) {

    int w = img.getWidth();
    int h = img.getHeight();

    BufferedImage dimg =new BufferedImage(w, h, BufferedImage.TYPE_4BYTE_ABGR);
    Graphics2D g = dimg.createGraphics();
    g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, // Anti-alias!
    RenderingHints.VALUE_ANTIALIAS_ON);

    g.rotate(angle*PI/180, w/2, h/2);
    // g.rotate(Math.toRadians(angle), w/2, h/2);

    g.drawImage(img, null, 0, 0);

    return dimg;
    }
    private static BufferedImage newOptimizedImage(int width, int height,
    boolean alpha, int transparency) {
    GraphicsConfiguration destination = GraphicsEnvironment
    .getLocalGraphicsEnvironment().getDefaultScreenDevice()
    .getDefaultConfiguration();
    return alpha ? destination.createCompatibleImage(width, height,
    transparency) : destination
    .createCompatibleImage(width, height);
    }

    public static BufferedImage setAngle(BufferedImage image, double angle) {


    double sin = Math.abs(Math.sin(angle)), cos = Math.abs(Math.cos(angle));
    int w = image.getWidth(), h = image.getHeight();
    int neww = (int) Math.floor(w * cos + h * sin);
    int newh = (int) Math.floor(h * cos + w * sin);
    BufferedImage drawImage = newOptimizedImage(neww, newh,
    image.getColorModel().hasAlpha(), image.getTransparency());
    Graphics2D g = drawImage.createGraphics();
    g.translate((neww - w) / 2, (newh - h) / 2);
    g.rotate(angle, w / 2, h / 2);
    g.drawRenderedImage(image, null);
    g.dispose();
    return image;
    }

    public double getAngle() {
    return angle;
    }



    @Override
    public void desenha(Graphics buffer) {

    buffer.drawImage (girar(getImagem(),getMira_angulo()), (int)getX(), (int) getY(),
    (int)getX() + getLargura(), (int) getY() + getAltura(),
    frameAtual * getLargura(), 0,
    (frameAtual+1) * getLargura() , getAltura(), null);

    }

    @Override
    public void atualiza(long difTempo) {

    float deslocamento = 200f * (difTempo / 1000f);


    if (down) setMira_angulo(getMira_angulo()+ 5);
    if (up) setMira_angulo(getMira_angulo()- 5);
    if (left) setForca(getForca()-5);
    if (right)setForca(getForca()+5);


    }


    public int getTempoInvensivel() {
    return timeInvensivel;
    }


    public void setTempoInvensivel(int timeInvensivel) {
    this.timeInvensivel = timeInvensivel;
    }

    public void definePosicaoInicial() {
    setX(PainelJogo.TELA_LARGURA / 2 - getLargura() / 2);
    setY(PainelJogo.TELA_ALTURA / 2 - getAltura() / 2) ;
    }


    public double getMira_angulo() {
    return mira_angulo;
    }


    public void setMira_angulo(double mira_angulo) {
    this.mira_angulo = mira_angulo;
    }


    public double getForca() {
    return forca;
    }


    public void setForca(double forca) {
    this.forca = forca;
    }


    public double getMiraX() {
    return miraX;
    }


    public void setMi...

  • mayk  - olha o que acontece na imagem
    avatar

    View image e quando rotaciono fica assim e atira sempre na mesma posição


    View image

  • mayk  - duvida
    avatar

    eu preciso fazer algo do tipo

    A resposta é simples: Para cada canhão, crie um vetor partindo do centro da nave até a posição desejada (indicados em branco na terceira imagem). Sempre que o vetor de direção (amarelo) da nave rodar, gire também esses vetores de posicionamento dos canhões usando o mesmo ângulo.


    ht tp://www.pontov.com.br/site//images/stories/artigos/6.png

    Agora, basta somar os vetores à posição da nave para obter a posição real dos canhões.

    so que nao tenho a menor ideia de onde começar , se vc puder me ajudar te agradeço muito é um trabalho para faculdade e ja vasculhei por tudo e ainda não consegui entender.

    se puder me mandar um exemplo em java te agradeço.obrigado pela atenção

  • Raphael Martins  - Parabens!
    avatar

    Boa noite! Tudo bem?
    Sou estudante de Matematica na UERJ, aqui no Rio de Janeiro, e sou um amante de computadores. Fiz um cursinho de Java e sempre tive curiosidade sobre como utilizavam as ideias de vetores em jogos. Esse teu artigo clareou muito as coisas para mim e, assim q eu tiver tempo, farei umas experiências com o que sei de matemática e JAVA.
    Está de parabéns com as explicações!

  • Carlos  - Muito bom.
    avatar

    Os artigos desse site são excelentes.
    Só faltou explicar a função perpDot usada no cálculo do ângulo.
    E se nesse cálculo os vetores não estiverem normalizados daria para economizar uma normalização, que requer uma custosa raiz quadrada, desta forma:

    cos²(a) = (A.B)²/(||A||.||B||)² // Não precisará tirar a raiz no size()

    cos²(a) = (cos(2a) + 1)/2
    cos(2a) = 2cos²(a) - 1
    a = acos(2cos²(a)-1) / 2

  • Anônimo
    avatar

    oi tudo bem, preciso fazer um trabalho de geometria analítica sobre vetor ,onde aplicar vetor mais que tenha números . se puder me ajudar, agradeço ....

  • Anônimo
    avatar

    E qual a duvida? Ninguém vai fazer o trabalho para você.

  • Lucas B. Luna
    avatar

    Vinicius, muito obrigado por esse maravilhoso artigo, champz! rsrs

    Eu tentava entender ele há vários meses, sempre voltando pra dar uma olhada de novo. Eu conseguí ter uma certa noção de vetores nesse tempo, mas sempre ficava "voando" em certos aspectos.

    Agora eu entendo muito bem, cara. Eu comecei a ver vetores na escola há poucos dias e isso me ajudou muito a entender esse artigo, e como "retribuição", o artigo além de estar me ajudando na programação, também tá me ajudando na escola! LOL!

    Parabéns man!

  • Vinicius
    avatar

    Que bom que você gostou. Esse artigo realmente explica pouco a parte matemática, é mais focado na implementação. Eu coloco apenas alguns exemplos para instigar quem nunca ouviu falar no assunto.

    Você provavelmente também vai gostar de ver esse outro artigo aqui, com vários exemplos práticos: http://pontov.com.br/site/index.php/arquitetura/54-matematica-e-fisica /332-vetores-guia-de-referencia

    Não sei como é seu inglês, mas se quiser explicações detalhadas sobre a parte de cálculo, vale a pena ver os vídeos da Khan Academy.

  • Matheus
    avatar

    Olá Vini, não me surpreendeu muito a boa didática do post pois já conhecia sua maneira de responder a dúvidas do GUJ, eu sou iniciante na parte de jogos e tenho algumas dúvidas muito simples como a seguinte: Você desenharia algo no JPanel por exemplo você tem de dar um inicio e um fim a linha, com a origem da altura do plano cartesiano começando de cima(não que isso atrapalhe), para desenhar uma linha após a outra ou até mesmo nem desenhar só saber por onde essa linha fica no plano para colocar outro objeto como a imagem de uma bola, não seria melhor que a classe vector tivesse as propriedades de começo X e Y e de fim de X e Y, desculpe se a dúvida é muito boba mas pra min ainda é um mistério como aquele quadrado cinza vira um game HAHAHA.

  • Vinicius - Vectruz  - Duvida
    avatar

    Olá, eu tenho tido um problema, pois preciso movimentar um objeto entre 2 pontos, mas não estou tendo facilidade em achar um meio certo de criar os vetores, de modo que a movimentação do meu objeto se tornou estranha, o codigo a seguir demonstra o que fiz
    [code]public void mover(){

    if(x!=fx){
    if(x>fx){
    x-=aceleracao;
    }
    if(x

  • Anônimo
    avatar

    Poste o código usando o codepad.org.

    Basta pegar os dois pontos, subtrair o destino da origem que você já tem um vetor com a direção para se mover da origem ao ponto final.

    Normalize esse vetor e você pode usar ele todo frame para avançar com base no tempo.

  • Pietro
    avatar

    Me desculpem a ignorância, vi um colega falando sobre que é muito usado o produto interno vetorial na área de jogos. Qual a real finalidade disso?

  • Pietro
    avatar

    O produto interno dá o ângulo entre os dois vetores em radianos. uga!

  • Anônimo
    avatar

    Bem vindo ao mundo: matemática mesmo só usa radianos.

  • Pietro
    avatar

    desculpem, não era isso. Embora o produto interno faça parte também do cálculo do ângulo.

  • Pietro
    avatar

    OBS: Muito bom esse artigo, fazendo o link com teoria e prática. Está me obrigando a relembrar conceitos que não vejo a muito tempo.

  • vinigodoy
    avatar

    Veja o guia sobre vetores para mais exemplos.

  • Pietro
    avatar

    Tinha um jogo do DOS em Basic. Gorila que usava esses princípios, muito massa isso.

  • Igor Baad  - Artigo Muito Bom!
    avatar

    Valeu Vinicius, o artigo realmente é muito..

    Abraço!

  • Bruno  - Tem esse código em C#
    avatar

    Preciso urgentemente desse código, mas em c#,se alguem puder me ajudar, agradeço

  • Keyton Klaus  - Assunto muito bem colocado!
    avatar

    Cara, parabéns. Conteúdo muito didático e prático. É o que precisamos mas nas academias. :)

Escrever um comentário
Your Contact Details:
Gravatar enabled
Comentário:
[b] [i] [u] [url] [quote] [code] [img]   
:angry::0:confused::cheer:B):evil::silly::dry::lol::kiss::D:pinch::(:shock:
:X:side::):P:unsure::woohoo::huh::whistle:;):S:!::?::idea::arrow:
Security
Por favor coloque o código anti-spam que você lê na imagem.
LAST_UPDATED2  

Busca

Linguagens

Twitter