You are on page 1of 12

TabIe of Contents

Table of Contents
Canvas Coordinate System
Adding a Canvas Component to Your App
mage Sprites and Balls
Animating Objects with Clock.Timer
Timer Events
High-Level Animation Functions
Edge Reached
CollidingWith and NoLongerCollidingWith
nteractive Animation
Stopping and Starting By Disabling and Enabling Timers
Specifying Sprite Animation without a Clock Timer
Painting on a Canvas

This chapter discusses methods for creating apps with simple animationsobjects that move.
You'll learn the basics of creating two-dimensional games with App Inventor and become
comfortable with image sprites and handling events like two objects colliding.

When you see an object moving smoothly along the computer screen, what you are really
seeing is a quick succession of images with the object in a slightly different place each time. t's
an illusion not much different than the "flipbooks that let you see a "moving picture by flipping
quickly through the pages.

With App nventor, you'll define animation by placing objects within a Canvas component and
moving those objects over time. n this chapter, you'll learn how the Canvas coordinate system
works, how the CIock.Timer event can be used to trigger movement, how to control the speed
of objects, and how to respond to events such as two objects colliding.
Adding a Canvas Component to Your App
You can drag a Canvas component into your app from the Basic palette. After dragging it out,
specify the Canvas' Width and Height. Often, you'll want the width to span the width of the
device screen. To do this, choose Fill Parent when specifying the width, as shown in figure 17-

Figure 17-1. Setting the Canvas Width to span the screen.

You can do the same for the height, but generally you'll set it to some number (e.g., 300 pixels)
and leave room for other components above and below the Canvas.
Canvas Coordinate System
To the computer, a drawing on a canvas is really a table of pixels, where a pixel is the tiniest
possible dot of color that can appear on the phone (or other device). The canvas is defined
by an X-Y coordinate system, as illustrated in figure 17-2, with x defining a location on the
horizontal plane (the column), and y defining a location on the vertical plane (the row).




Figure 17-2. The Canvas coordinate system.

Computer scientists like to start counting with 0, so the top-left cell in a Canvas is the position
(x=0,y=0). As you move right the x-coordinate gets larger; as you move down, the y-coordinate
gets larger. The cell to the right of (x=0,y=0) is (x=1,y=0). The top-right corner has an x-location
the same as the width of the canvas minus 1. Most phone screens have a width close to 300,
but for the sample canvas shown here, the Canvas width is 20 so the top-right corner is the
coordinate (x=19,y=0).

You can change the appearance of the canvas in two ways: 1) by painting on it, or 2) by placing
and moving objects within it. This chapter will focus primarily on the latter, but let's first discuss
how you "paint and how you can paint to create animation (this is also the topic of the PaintPot
app of chapter 2).

Each table cell of the canvas holds a pixel defining the color that should appear there. The
Canvas component provides the DrawLine and DrawCircIe blocks for painting pixels on it. You
first set the Canvas.PaintColor property to the color you want, then call one of the Draw blocks
to draw in that color. With DrawCircIe, you can paint circles of any radius, but if you set the
radius to 1, as in Figure 17-3, you'll paint an individual pixel:

Figure 17-3. DrawCircle is being used to paint an individual pixel with each touch.

App nventor provides a palette of fourteen basic colors which you can use to paint pixels (or
component backgrounds). You can access a fuller range of colors by using the color numbering
scheme explained in the App nventor documentation at

The second way to modify the appearance of a canvas is to place Ball and ImageSprite
components within it. A sprite is a graphical object placed within a larger scene, in this case
a canvas. Both the Ball and ImageSprite components are sprites; they are different only in
appearance. A Ball is a circle whose appearance can only be modified by changing its color or
radius, whereas an ImageSprite can take on any appearance as defined by an image file you
upload. Image Sprites and Balls can only be added within a Canvas; you won't be allowed to
drag them into the user interface outside of a Canvas.
Animating Objects with Timer Events
One way to specify animation in App nventor is to transform an object in response to a timer
event. You can specify pixel-level animation by drawing various lines and circles as time
passes. More commonly, you'll move sprites to different locations on the canvas on set time
intervals. Using timer events is the most general method of defining animation. Later, we'll also
discuss an alternative method of programming animation using the ImageSprite and Ball
component's Speed and Heading properties.

Button clicks and other user-initated events are simple to understand: the user does something
and the app responds by performing some operations. Timer events are different: they aren't
triggered by the end-user but by the passing of time.You have to conceptualize the phone's
clock triggering events in the app.

To define a timer event, you first drag a Clock component into your app within the Component
Designer. The Clock component has a TimerInterval property associated with it. The interval
is defined in terms of milliseconds (1/1000 of a second). f you set the TimerInterval to 500,
that means a timer event will be triggered every second. The smaller the TimerInterval, the
faster your object will move.

After adding a Clock and setting a TimerInterval in the Designer, you can drag out a
CIock.Timer event in the Blocks Editor. You can put any blocks you like in this event, and they'll
be performed every timer interval.
To show an sprite move over time, you'll use the MoveTo operation found in both the
ImageSprite and Ball components. For example, to move a ball horizontally across the
screen, you'd use the blocks in figure 17-4.
Figure 17-4. These blocks move the ball horizontally across the screen.

MoveTo moves an object to an absolute location on the canvas, not a relative amount. So
to move an object some amount, you set the MoveTo arguments to the object's current
location plus an offset. Since we're moving horizontally, the x argument is set to the current x-
location (BaII1.X) plus the offset 20, while the y argument is just set to stay at its current setting

f you wanted to move the ball diagonally, you'd add an offset to both the x- and y-coordinate, as
in figure 17-5.
Figure 17-5. Offsetting both the x- and y- coordinates moves the ball diagonally.
How fast is the ball moving in the example above? The speed depends on both the Clock's
TimerInterval property, and the parameters you specify in the MoveTo operation. f the
interval is set to 1000 milliseconds, that means an event will be triggered every second. For the
horizontal example above, the ball will move 20 pixels/second.

But a TimerInterval of 1000 milliseconds doesn't provide very smooth animation: the ball
will only move every second. To get smoother movement, you need a smallerinterval. f the
TimerInterval was set instead to 100 milliseconds, the ball would move smoothly 20 pixels
every tenth of a second, or 200 pixels per second. Or you could retain the original speed by also
changing the MoveTo so the ball only moves 2 pixels every timer interval (2/100ms is still 20/
High-LeveI Animation Functions
The ability to move an object across the screen is useful for things like animated ads, but to
build games and other animated apps you need more complex functionality. Fortunately, App
nventor provides some high-level blocks for dealing with animation events such as an object
reaching the edge of the screen or two objects colliding.

High-level, in this context, means that App nventor takes care of the lower-level details of
determining things like when two sprites collide. You could check yourself for such occurences
using CIock.Timer events and checking the X,Y, Height, and Width properties of the sprites.
Such programming would require some fairly complex logic, however. Because these events
are common to many games and other apps, App nventor provides them for you.
Edge Reached
Consider again the animation in which the object is moving diagonally from the top-left to the
bottom-right of the canvas. As we programmed it, the object would move diagonally then stop
when it reached the right or bottom edge of the canvas (the system won't move an object past
the canvas boundaries).

f you instead wanted the object to reappear back at the top-left corner after reaching the
bottom-right you could define a response to the BaII.EdgeReached event shown in figure 17-6.

Figure 17-6. This event causes the ball to reappear at the top-left corner when it reaches an

EdgeReached is triggered when the Ball hits any edge of the canvas. This event handler,
combined with the diagonal movement specified with the timer event above, will cause the ball
move diagonally left-top to bottom-right, then pop back up to the top-left when it reaches the
edge, and then do it all over again, forever.

Note that there is an argument, edge1, with the EdgeReached event. The argument specifies
which edge the ball reached, using the following numbering scheme:

north = 1
northeast = 2
east = 3
southeast = 4
south = -1
southwest = -2
west = -3
northwest = -4
CoIIidingWith and NoLongerCoIIidingWith
Shooting games, sports, and other animated apps often rely on activity occurring when two or
more objects collide, e.g., a bullet hitting a target.

Consider a game, for instance, in which an object changes colors and plays an explosion sound
when it hits another object. Figure 17-7 shows the blocks for such an event-handler.

Figure 17-7. The ball changes color and an explosion sounds when it hits another object.

NoLongerCoIIidingWith provides the opposite event of CoIIidedWith. t is triggered only
when two objects have come together and then separated. So for your game, you might include
blocks like these in Figure 17-8?

Figure 17-8. When the objects release from each other, change color back and stop explosion.

Note that both CoIIidedWith and NoLongerCoIIidingWith have an argument other. other
specifies the particular object with which you collided (or separated). This allows you to perform
operations only when the object (e.g., Ball1) interacts with a particular other object, as shown in
Figure 17-9:

Figure 17-9. Only perform the response if Ball1 hit ImageSprite1.

The component ImageSprite1 block is one we haven't discussed. When you need to compare
components, as in this example, you need some way to refer to a specific component. For
this reason, each component has a special block which refers to itself. So in the drawer for
mageSprite1, you'll find the component imageSprite1 block.
Interactive Animation
With the animated behaviors discussed so far, the end-user isn't involved. Of course games
are interactive, with the end-user playing a central role. Often they will control the speed or
direction of an object with buttons or other user interface objects.

As an example, let's update the diagonal animation by allowing the user to stop and start the
diagonal movement. You can do this by programming a Button.CIick event-handler to disable
and re-enable the timer event of the clock component.

By default, the Clock component's timerEnabled property is checked. You can disable it
dynamically by setting it to false in an event-handler. This event handler in figure 17-10, for
example, would stop the activity of a Clock timer on the first click.
Figure 17-10. This event handler stops the timer the first time the button is clicked.

After the Clock1.TimerEnabled property is set to false, the CIock1.Timer event will no longer
trigger, and the ball will stop moving.

Of course stopping the movement on the first click isn't too interesting. nstead, you
could "toggle the movement of the ball by adding an ifeIse in the event handler that either
enables or disables the Timer, as shown in figure 17-11.

Figure 17-11. By adding an ifelse, the button can be used to toggle the movement of the ball.

This event-handler stops the timer on first click, and resets the button so that it says "Start
instead of "Stop. The second time the button is clicked, the TimerEnabled is false, so the
else part is executed. n this case, the timer is enabled, which gets the object moving again,
and the button text is switched back to "Stop. For more information about ifeIse blocks, see
Chapter X. For a more complex example of interactive animation, check out Section 22.3, which
demonstrates a shooter being moved by titling the phone.
The animation samples described so far use a Clock component and specify that an object
should move each time the clock's timer event is triggered. The CIock.Timer event scheme is
the most general method of specifying animation: besides movement, you could have an object
change color over time, change its text (as if the app is typing), or have the app speak words at
a certain pace.

For object movement, App nventor does provide an alternative that doesn't require the use
of a Clock component. As you may have noticed, the ImageSprite and Ball components
have properties for Heading, Speed, and Interval. nstead of defining a CIock.Timer event
handler, you can set these properties in the Component designer or Blocks Editor to control how
a sprite moves.

As an example, let's reconsider the sample that moved a ball diagonally. The Heading property
of a sprite or ball has a range of 360 degrees, as seen in figure 17-12.

Figure 17-12. The Heading property has a range of 360 degrees.

f you set the Heading to 0, the ball will move left-to-right. f you set it to 90, it will move bottom
to top. f you set it to 180, it will move right-to-left. f you set it to 270, it will move top to bottom.
Of course you can set it to any number between 0 and 360. To move a ball diagonally from top-
left to bottom-right, you'd set the Heading to 315. You also need to set the Speed property to
non-zero. The Speed property really specifies the number of pixels the object will move per
time interval, where the interval is defined by the object's Interval property.
To test the properties out, create a test app with a Canvas and Ball and click Connect to Phone
to see your app. Then modify the Heading, Speed, and Interval property of the ball to see
how it moves.
f you wanted the program to continually move from top-left to bottom-right, then back, you'd
initialize the ball's Heading property to 315 in the Component Designer. You'd then add the
following BaII1.EdgeReached event-handler, shown in figure 17-13, to change the the ball's
direction when it reached either edge.
Figure 17-13. This event handler changes the ball's direction when either edge is reached.

Animation is an object being moved or otherwise transformed over time. App nventor provides
some high-level components and functionality to facilitate animation. By programming the Clock
component's Timer event, you can specify any type of animation including object movement.

The Canvas component allows you to define a subarea of the device's screen in which objects
can move around and interact. You can onlly put two types of components, ImageSprites
and Balls, within a Canvas. These components provide high-level functionality for handling
collisions and reaching a Canvas edge. They also have properties, Heading, Speed and
Interval, that provide an alternative method of movement.


Painting on a Canvas
An app can paint on the canvas using two primitive drawing functions, DrawLine and
DrawCircle. For example, these blocks draw a diagonal line of length 5 from the upper left
toward the bottom right corner of the canvas: