Processing: Creative Coding and Computational Art

ground collision
if(groundYTemp > -orb.r){
// keep orb from going into ground
groundYTemp = -orb.r;
// bounce and slow down orb
velocityYTemp *= -1.0;
velocityYTemp *= damping;
}
Up until now, when handling orthogonal collisions, I’ve been checking if the object’s x or y
property was past its respective x or y boundary. However, in the ground collision conditional
block, I’m checking if the difference (along the y-axis) between the orb and the
ground is greater than the negative of the orb’s radius; this reads like one of those annoying
logic problems on a standardized test (sorry). You’ll remember that, a few paragraphs
back, the variable deltaY was assigned the difference between the orb’s y position and the
ground’s y position; that value was then rotated and assigned to the variable groundYTemp.
As the orb nears the ground, the difference between their y values will decrease, until the
orb passes through the ground, at which time this value will begin increasing. Before the
orb actually hits the ground, though, as the difference between the orb and ground’s y
value continues to decrease, there will be a point when the orb’s center point is the same
distance from the ground as the orb’s radius—which would make the expression orb.
y-ground.y equal to -orb.r. When the orb then moves one more pixel toward the
ground, the difference between orb.y and ground.y, though still negative, will be greater
than -orb.r, and the conditional will evaluate to true. You may have to read that a few
times to get it; or just embrace the temporary confusion—I do it all the time. Once the
conditional evaluates to true, the steps to reflect the orb should be old hat and selfexplanatory.
Now that the ground and velocity have been rotated, allowing you to successfully detect
and reflect the orb, all that’s left to do is reset the ground and velocity back to their initial
non-orthogonal rotations and update the position of the orb:
// reset ground, velocity and orb
deltaX = cosine * groundXTemp - sine * groundYTemp;
deltaY = cosine * groundYTemp + sine * groundXTemp;
velocity.vx = cosine * velocityXTemp - sine * velocityYTemp;
velocity.vy = cosine * velocityYTemp + sine * velocityXTemp;
orb.x = ground.x + deltaX;
orb.y = ground.y + deltaY;
The first four lines of code use the same long form trig functions we looked at earlier, but
the signs in the expressions are reversed, and the ground and velocity temp values are now
used as the current coordinates. Remember, reversing the signs in the expression will have
the effect of causing the rotation to go in the opposite direction—putting the ground and
velocity back in their original non-orthogonal positions. Of course, as I mentioned earlier,
the ground and velocity were not actually affected, rather the four temp variables
(groundXTemp, groundYTemp, velocityXTemp, and velocityYTemp) were assigned the
rotated values. Now, however, the orb’s velocity is updated by the trig expressions, as is
the orb’s position, based on the ground coordinates and the updated deltaX and deltaY
variables.
MOTION
539
11