| MACROMEDIA FLASH |
| ACTIONSCRIPT: PROGRAMMATIC MOVEMENT |
as with the collision detection routines, thanks go to derek clayton and mike linkovich for their help with the math in these demos.
| > | move an object along a path |
| >>download the .fla (zipped) >>view the demo all of the movement systems presented here start out by initializing an object and its environment. for simple movement, initialization begins with placing the object randomly on the screen (this is done in the "init_object" subroutine). once the object is placed, we pick a random direction and speed for our object. in some languages, you might express the direction in radians (points on a circle) and speed as the distance travelled between each screen refresh (or time point). while this is an excellent method of tracking movement, it requires the use of sin, cos, and square root, which are not available in actionscript (but can be hand-calculated). since we have none of these math functions in actionscript (*sigh*), we express the speed and direction as a vector. a vector is made up of two points, a start point which is always defined by 0,0, and an end point which is defined by an arbitrary x and an arbitrary y coordinate. mathematically, a vector describes both direction (the angle of the line) and magnitude, (the distance between the two points). magnitude maps logically to speed in our case, because it represents the distance our object moves between screen refreshes. since we know the x and y position of our object, we can move it in any direction at any speed by simply incrementing the x and y by a standard amount (the defined vector), over and over. to get a starting vector, we pick a random x between -10 and 10, and a random y between -10 and 10 (in our code these values are stored as x_dir and y_dir, and are determined in the "getrandomDirection" subroutine). Set Variable: "max_dist" = "20" Set Variable: "x_dir" = Random ((max_dist) + 1) - (max_dist / 2) Set Variable: "y_dir" = Random ((max_dist) + 1) - (max_dist / 2)then, every turn, we call the "move" subroutine, which updates the current location of the object by adding the vector (x_dir and y_dir) to it.
Set Variable: "obj1_x" = GetProperty ("/obj1", _x)
Set Variable: "obj1_y" = GetProperty ("/obj1", _y)
Set Property ("/obj1", X Position) = obj1_x + x_dir
Set Property ("/obj1", Y Position) = obj1_y + y_dir
|
|
| > | redirecting an object off a wall |
|
>>download the .fla (zipped) >>view the demo in this example, our ball has three new features: it bounces off the walls, it can be sized, and its speed can be controlled. before we can bounce our object off a wall, we first have to move it (using the "move" subroutine). we add the wall collision code to the "move" subroutine. once the ball is moved, we check its location to see if it has gone beyond its allowed boundaries (set as "leftmax", "rightmax", "topmax", and "bottommax"). let's take the left wall as an example to show how: if the x value of the ball's centre point plus its radius is less than the value of the left edge of the canvas (in the demo, zero), then the ball has exceeded the left wall. If (obj1_x < (leftmax + obj1_radius))when we know the ball has been moved outside of the boundaries, we have to recalculate the real location of the ball. in other words, if the ball had not gone through the wall, but had actually bounced off it, where would it be now? to find that out, we measure how far the ball travelled along the axis on which it exceeded the wall (this is stored in "amount_over"). then, we add or subtract that value to/from the wall's location and place the ball there. i suppose a diagram is probably in order:
If (obj1_x < (leftmax + obj1_radius))
Set Variable: "amount_over" = leftmax - obj1_x + obj1_radius * 2
Set Property ("/obj1", X Position) = amount_over
Set Variable: "x_dir" = x_dir * -1
Else If (obj1_x > (rightmax - obj1_radius))
Set Variable: "amount_over" = obj1_x - rightmax + obj1_radius * 2
Set Property ("/obj1", X Position) = rightmax - amount_over
Set Variable: "x_dir" = x_dir * -1
End If
to speed the ball up and slow it down, we increase the x_dir and y_dir by 150% or reduce them by 25%. these percentages are arbitrary. in the next example they're kept in a variable so you can easily set how much each speed change should affect the speed of the ball. there's a drawback to this method though: if you speed the ball up too much, you'll notice that it eventually can't be drawn on screen anymore. this is because when the ball is travelling a distance greater than the canvas with each move, repositioning it will always place it off the canvas again. in the next example you'll see how to prevent the ball from going that fast.
to change the size of the ball, we increase or decrease the scale property in the "shrink" and "grow" subroutines. when shrinking the ball, we just need to be sure the reduction won't make the ball smaller than 0.
If ((current_scale - scale_modifier) > 0)
Set Variable: "current_scale" = current_scale - scale_modifier
End If
Set Property ("/obj1", X Scale) = current_scale
Set Property ("/obj1", Y Scale) = current_scale
when expanding it, we need to be sure we aren't making the ball larger than the canvas size. because _scale is a percentage in actionscript, we have to do our check relative to the original height and width of the ball.
If (obj1_origwidth * (current_scale/100) < (rightmax - 20)
AND obj1_origheight * (current_scale/100) < (bottommax - 20) )
Set Variable: "current_scale" = current_scale + scale_modifier
End If
Set Property ("/obj1", X Scale) = current_scale
Set Property ("/obj1", Y Scale) = current_scale
at then end of both operations, we recalculate the ball's radius so the collision with the walls will still be accurate.
Set Variable: "obj1_radius" = GetProperty ("/obj1", _width) / 2
|
|
| > | bouncing with gravity and a speed limit |
| >>download the .fla (zipped) >>view the demo this demo adds two new features: gravity and a speed limit. to add gravity to the ball, we first make it bounce in a parabola by increasing the y_dir by a standard amount each time "move" is executed. if the ball is heading down (y_dir is positive), then it will move down faster as we incrementally increase y_dir until the ball bounces off the bottom, at which point, y_dir becomes a negative (it's moving up). when y_dir is negative, the ball will moves up slower, until y_dir is 0, then it will move down again faster. at this point there is no gravity because all the speed gained by y_dir on the way down is converted to speed up when the ball hits the bottom. similarly, though the ball loses its speed on the way up, it gains the exact amount it lost on the way back down. so, to make the simulated gravity pull the ball down more and more with each bounce, we also add friction to the bottom wall by reducing both the x_dir and y_dir by a standard percentage each time the ball collides with the bottom. instead of hard-coding the standard amount for the simulated gravity and friction, we use a variable, "grav_amount", to calculate how quickly the ball should lose speed. by setting grav_amount to 0, you can make the ball bounce forever. the max for grav_amount is 9.9. as grav_amount increases, it adds more to y_dir, and increases percentage of speed that is removed from the ball by the friction on the bottom wall. to add a speed limit, we put a check on the "speedUp" subroutine which prevents the ball from going further in one move on the x or y axis than the width or height of the bounded region minus the width of the ball. as the ball gets bigger, it is allowed to travel shorter and shorter distances.
Comment: get the absolute values of x & y without sqrt.
If (y_dir < 0)
Set Variable: "y_dir_abs" = y_dir * -1
Else
Set Variable: "y_dir_abs" = y_dir
End If
If (x_dir < 0)
Set Variable: "x_dir_abs" = x_dir * -1
Else
Set Variable: "x_dir_abs" = x_dir
End If
Comment: begin speedlimit check
If (x_dir_abs * speed_modifier < rightmax - obj1_radius * 2)
Set Variable: "x_dir" = x_dir * speed_modifier
End If
If (y_dir_abs * speed_modifier < bottommax - obj1_radius * 2)
Set Variable: "y_dir" = y_dir * speed_modifier
End If
Comment: end speedlimit check
when we increase the size of the ball, we must also check to see that we're not making a large ball go at a speed that's only allowed for a smaller ball. if we find that that's happening, we have to reduce the speed of the ball to an allowable amount.
If (obj1_origwidth * (current_scale/100) < (rightmax - 20)
AND obj1_origheight * (current_scale/100) < (bottommax - 20) )
Set Variable: "current_scale" = current_scale + scale_modifier
End If
Set Property ("/obj1", X Scale) = current_scale
Set Property ("/obj1", Y Scale) = current_scale
Set Variable: "obj1_radius" = GetProperty ("/obj1", _width) / 2
Comment: check if we're going to fast for the ball's new size.
If (y_dir < 0)
Set Variable: "y_dir_abs" = y_dir * -1
Set Variable: "y_orientation" = "-1"
Else
Set Variable: "y_dir_abs" = y_dir
Set Variable: "y_orientation" = "1"
End If
If (x_dir < 0)
Set Variable: "x_dir_abs" = x_dir * -1
Set Variable: "x_orientation" = "-1"
Else
Set Variable: "x_dir_abs" = x_dir
Set Variable: "x_orientation" = "1"
End If
Comment: begin speedlimit check
If (x_dir_abs > rightmax - obj1_radius * 2)
Set Variable: "x_dir" =
((rightmax - obj1_radius * 2) * .5) * x_orientation
End If
If (y_dir_abs > bottommax - obj1_radius * 2)
Set Variable: "y_dir" =
((bottommax - obj1_radius * 2) * .5) * y_orientation
End If
Comment: end speedlimit check
|
|
| > | randomation: experimental bouncing demo |
| >>view the demo
this experiment adds sound, gravity controls, a squishing effect on bounces, and a random size/speed toggle. no .fla for this one...i have to keep *some* secrets to myself ;) |
