Acabo de terminar de trabajar en mi cubo LED 4x4x4 . Estoy tratando de escribir una animación para una pelota que rebota en el cubo. Básicamente, una bola de 1 LED grande o 2x2 LED grande debe moverse dentro del límite del cubo. La bola debe rebotar correctamente en los bordes y continuar viajando hasta que toque otro borde. Será como un objeto que rebota en las superficies en un vacío.
No puedo calcular el algoritmo para lograr esto. ¿Cuál es la lógica para simular esto?
Como han dicho otros, Google puede ser tu amigo aquí en términos de buscar el código existente.
Sin embargo, más allá de eso, los conceptos básicos del algoritmo son bastante simples. Tiene variables que representan la posición actual de x, y, z de la bola y otro conjunto que representa el vector de la bola (también en x, y y z). Con esta información, es bastante sencillo realizar la detección de bordes (cuando x, y o z es 0 o 3 en su caso).
Cuando la pelota golpea un borde, debe "rebotar" en la pared. Esta es la parte que se vuelve un poco más peluda ya que tienes que averiguar en qué se basa el vector de reflexión en el vector actual. Para hacerlo más interesante, es probable que también desee agregarle un poco de aleatoriedad para que no se degrade rápidamente en 'pong' entre dos o tres paredes (a menos que sea lo que está buscando).
Puedo buscar un código más tarde si no puedes encontrar nada apropiado.
--- actualización ---
Este instructivo tiene un código para hacer lógica de rebote muy simple. Aquí está el código de rebote básico de ese proyecto convertido a todas las compensaciones positivas (el código original tenía una Z negativa que iba "a" la pantalla / lejos del observador) y valores enteros:
// size of the space
int height = 4;
int width = 4;
int depth = 4;
// Starting position of the shape
int xpos = width / 2;
int ypos = height / 2;
int zpos = depth / 2;
// Speed of the shape along each axis
int xspeed = 1;
int yspeed = 2;
int zspeed = 1;
int xdirection = 1; // Left or Right
int ydirection = 1; // Top to Bottom
int zdirection = 1; // front or back
void loop()
{
// Turn off the led at the current position: xpos, ypos, zpos
// Update the position of the shape
xpos = xpos + ( xspeed * xdirection );
ypos = ypos + ( yspeed * ydirection );
zpos = zpos + ( zspeed * zdirection );
// Test to see if the shape exceeds the boundaries of the screen
// If it does, reverse its direction by multiplying by -1
// and adjust the position to be at the edge
if (xpos >= width || xpos < 0) {
xpos = constrain(xpos, 0, width-1);
xdirection *= -1;
}
if (ypos >= height || ypos < 0) {
ypos = constrain(ypos, 0, height-1);
ydirection *= -1;
}
if (zpos >= depth || zpos < 0) {
zpos = constrain(zpos, 0, depth-1);
zdirection *= -1;
}
// turn on the led at the new position: xpos, ypos, zpos
// apply some delay based on your update frame rate
}
La exención de responsabilidad estándar se aplica a este código (YMMV = su millaje puede variar). No tengo un cubo, así que no he probado este código. No sé si funciona y es posible que haya cometido errores en los ajustes que le hice.
Como un ejercicio avanzado, podría considerar agregar código para modificar la velocidad de un eje en particular según la distancia a la que se desplazó, etc. También puede volver a convertir a punto flotante para velocidad / posición y luego usar el redondeo para obtener la posición real del LED.
Si no está familiarizado con constricción , se incluye con las bibliotecas de Arduino. La descripción es "Restringe un número a estar dentro de un rango".