En esta entrada se tratará en profundidad las fichas 11 y 12, dentro de la 11 hablaremos en concreto de el manejo de objetos simultáneamente (haciendo un bucle de sol y luna) y dentro de la 12 trataremos de hacer estrellas de n lados deseados.
Ficha 11
Sol y Luna
Este es un ejemplo del resultado final después de leer esta práctica:
(Por ciertas limitaciones de OpenProcessing usamos capturas de pantalla)
Iniciación de los objetos:
Para la realización de este programa (cuyos cuerpos van orbita constantemente)
creamos dos clases, una sol y otra luna, que van a actuar de la misma manera.
Es muy recomendable almacenar en las propias clases las variables de posición, así tenemos objetos relativos independientes al resto del programa.
Ejemplo código clase luna:
class Luna {
float x, y, b, moonAngle;
int s;
PImage moonImg;
// Constructor…
}
Como vemos también almacenamos la imagen dentro de la clase pero la URL la definiremos al instanciar el objeto.
El movimiento de estas clases (como vemos por moonAngle) será circular. X e Y variarán según el angulo y b es el brillo que otorga el objeto, de lo que no hablaremos en esta ficha.
¡Importante!
Al iniciar el programa (porque el radio del sol y la luna será el mismo) hemos definido un OrbitRadius que nos ayudará con la posición. También hemos definido orbitX y orbitY como centro de circunferencia
Recomendado poner ImageMode(CENTER) en el Setup
Crearemos dentro de cada uno de los objetos una función update(), que mostrará la imagen iniciada en la posición.
Ponemos una imagen de fondo y con nuestros dos objetos ya deberíamos tener una escena estática que queremos. Un astro debería verse fuera de la pantalla, lo podemos ver usando scale(0.25). Los astros de momento se verán con una posición X, Y que les hayas dado arbitraria.
Movimiento de los objetos:
Para mover los objetos no usaremos ninguna función de la propia clase sino que cambiaremos la función ángulo.
Para calcular las posiciones:
X = orbitX + sin(radians(moonAngle)) * orbitRadius;
Orbit X será el centro, que se sumará al seno EN RADIANES del ángulo * la orbita. Te invito a hacer la Y tu mismo.
Ahora podemos poner en el draw una función sun.sunAngle++; y veremos como el movimiento del sol se va actualizando.
¡Ya tenemos nuestros dos astros en orbita!
Ficha 12
Estrella de nº lados
Aquí tenemos dos polígonos, sus «esquinas exteriores» son las mismas (5) pero tenemos una diferencia, en lugar de haber una arista que una cada esquina como en el pentágono, en la estrella tenemos dos.
(Creamos una función, para mayor comodidad)
void Estrella(int x, int y, int radio, int radio2, int nLados)
Radio 1 va a ser el que tomen las puntas de la estrella y radio dos el que tome el vértice interior, x e y el centro del a estrella y nlados el numero de lados que queremos que tenga
{
// Definimos el angulo con el que va a ir saltando la función, según los lados que queremos
float angulo = TWO_PI / nLados;
float sx, sy; // Posiciones temporales de vertices
…
}
Lo que queremos es que en cada iteración de un bucle for que haremos para dibujar los vertices, se aumente n el ángulo, según los lados que queramos. Vamos a usar sx y sy para ir haciendo los vértices.
Usamos beginShape(); para constatar que empezamos una forma:
beginShape();
for(float anguloActual = 0; anguloActual < TWO_PI; anguloActual += angulo) {
…
}
endShape();
Teniendo este bucle vamos a conseguir ir alrededor de un circulo saltando por el ángulo que necesitamos,dentro del bucle:
sx = x + cos(anguloActual) * radio1;
sy = y + sin(anguloActual) * radio1;
vertex(sx, sy);
Esto dibuja las puntas exteriores, no hay complejidad.
sx = x + cos(anguloActual+angulo/2) * radio2/2;
sy = y + sin(anguloActual+angulo/2) * radio2/2;
vertex(sx, sy);
Esto dibuja las interiores, son las mismas pero a la mitad de radio, hay que hacer también unos cálculos en el ángulo.
Con todo esto ya tendríamos nuestro código flexible completo.