Movimento

Programação Java
#1

Eu estou com um problema com a movimentação de objetos. Eu consigo movimentá-los para o lado (eixo X) e pra cima e pra baixo (eixo Y), talvez eu até conssiga fazer eles se moverem num ângulo de 45º mas o problema é que eu quero conseguir movimentar estes objetos em qualquer ângulo.

Eu fiz um código que na verdade até da certo, só que é um quebra-galho.

//Codigo para calcular o próximo pixel
//posx e posy são atributos do objeto
public Point Prox(){
		
		Point nextPos = new Point();
		
		double adx = Math.cos(Math.toRadians(graus));//coseno do grau
		double ady = Math.sin(Math.toRadians(graus));//seno do grau
		
		posx += adx;  //adiciona resultado à coordenada x
		posy += -ady;// adiciona resultado à coordenada y
	
		nextPos.x = (int)posx; //arredonda e atribui
		nextPos.y = (int)posy; //à variável de retorno
				
		return nextPos;
		
	}

Eu queria saber se tem um jeito melhor de fazer isso porque eu fiz mas não me parece certo, na verdade extremamente errado.

Ex:
Para um objeto se mover em um angulo de 45º é preciso que seja adicionado 1 pixel em cada eixo a cada ‘passo’ que ele dá. O seno de 45º é 0.7, quando arredondar vai para 1 mas da próxima vez o programa vai ter que arredondar 1.4 e vai arredondar para 1 ao invés de 2.

Se puderem me falar uma coisa ou duas sobre vetores em java eu seria muito grato, também. :wink:

#2

Pergunta boba número 1.

Por que é que você guarda a posição como 2 ints?

Que tal guardar como double, e só passar para int na hora de redesenhar o objeto?

Aliás, Java2D trabalha com pontos especificados como 2 floats (Point2D.Float) ou 2 doubles (Point2D.Double). É por isso que estou achando esquisito você guardar uma posição como pixels.

#3

A posição é um Point, eu converto pra int a soma entre a posição atual do objeto e o quanto ele deve se mover na hora em que atribuo esses valores as coordenadas do Point. Eu estou pensando na tela como se fosse um plano cartesiano, não tem como eu mostrar meio pixel por exemplo, por isso a necessidade do inteiro.

Em nenhum momento do código (mesmo o código inteiro) eu mechi com o java2D, eu estava testando inserindo um valor para o ângulo através de um JOptionPane, então eu clicava em um botão começar que iniciava um Timer que movia uma JLabel (O objeto que falei) para sua nova posição a cada 17 milésimos de segundo.

Mas o que eu queria saber é algo sobre a lógica desse código, eu não sei de que outra maneira posso calcular o próximo ponto a partir de um angulo.

#4

Se for possível utilizar um passo variável menor que 10 pixels, sugiro:

  nextPos.x = (int)(posx * 10); //arredonda e atribui   
  nextPos.y = (int)(posy * 10); //à variável de retorno
#5

É, no lugar do ‘10’ eu poderia por uma variável, isso seria o quanto o objeto ‘anda’ a cada ‘passo’.

O problema que estou tendo é que esse método não é 100% preciso, eu queria alguma dica de como fazer isso dar certo, com senos e cosenos parece não dar. Eu to quebrando minha cabeça aqui mas não consigo pensar em outra maneira de fazer isso.

Como eu queria ter prestado mais atenção nas aulas de trigonometria D:

#6

Não é para colocar algo no lugar do 10.
No seu exemplo em que, para 45º obtém 0,7 teremos um passo de 7 pixels.

#7

Você ta certo. Eu não tinha entendido muito bem, mas agora eu vi.

Se eu multiplicar por 10 não vou ter problemas com arredondamentos, mas acho que 7 pixels é um passo muito grande pra se dar, eu perderia muito FPS tentando fazer isso numa velocidade razoavel.

		posx += adx*10;  //adiciona resultado à coordenada x
		posy += -ady*10;// adiciona resultado à coordenada y

e deveria ser assim também, se não a posição dele que seria multiplicada por 10, e não a soma das coordenadas do próximo pixel em relação a ele.

Ex: se o proximo pixel que o objeto iria fosse 100,100 na verdade ele iria para 1000,1000.

#8