Probably the most dramatic addition to TI-Nspire's Lua capabilities (and possibly to the entire TI-Nspire platform) accompanying the 3.2 update lies in the new Lua Physics Engine. Based upon the open-source 2D physics Chipmunk engine, this new library adds enormously powerful simulation capabilities. Tools are provided to model not only objects moving under different forces, but a huge range of modelling possibilities for mechanics, physics and much more.

As with everything that has gone before, it takes a very experienced programmer to get the most out of this new feature set. Nonetheless, there is still much that amateurs (like me) can explore and make good use of. These last few lessons in our series offer some basic insights and direction in getting started with the Nspire Lua Chipmunk Physics Engine. For a glimpse of where I plan to end up, have a look at the accompanying movie (developed by Alfredo Rodriguez from TI).

Our first Chipmunk project will, naturally, be less ambitious than the dazzling display above. We will begin by sending a single ball bouncing around the screen.

You might (correctly) observe that this can be achieved without the need for a physics engine - the magic of the timer can get things moving without too much trouble, and we could create a circle class that has its location controlled by the timer.

So what does this Physics Engine offer that makes it worth all the hype?

You may remember when we first encountered classes, and the powerful realization that these objects "knew" where they were on the screen. This opens all sorts of doors and makes many things, which might otherwise be very complicated, much simpler.

So it is with Chipmunk. Like classes, we define objects (and these objects exist within a "space") but the key lies in the attributes that these objects may possess - they possess a body and a shape (the part we see), both of which carry attributes, from simple things like mass, and gravity, and velocity to more interesting things like moments of inertia (the tendency of a body to turn or spin while moving) right through to friction and elasticity, and support for collisions, damped rotary springs, pivot and ratchet joints and simple motors.

Let me be clear at the outset that I do not plan to be your guide to all of these far off and exotic places - but we will learn enough about things closer to home to get you started, and from there - well, that is up to you.

If you have not already done so, copy the script from your browser window and paste it into the TI-Nspire Script Editor, Set it by pressing ctrl-s and enjoy the show. You should see a blue circle bouncing around the screen.

Since the physics engine is a feature only available in OS 3.2, then the APILevel must be set to 2.0. Critically important in 3.2 is the new require command which currently supports a couple of options - require "physics" (which provides access to the physics library) and require "color" (which provides access to a library of pre-defined basic colours). Here we focus on the first of these, but will demonstrate the second later.

Next we define the space in which our body will live - an essential part of the physics world. Within this space, we will later define such things as gravity but for now, gravity will be assumed to be 0.

Most importantly, we define the body that our object will occupy. Note that this has no visual element - think of it as an empty shell which possesses attributes, and which will eventually require a shape in which it can be cloaked (the shape may also carry with it attributes such as elasticity (properly called restitution in this physics world) and friction - more on that later). The physics.Body command takes two inputs - mass (here set as 100) and inertia, set as 0. Change these values and see the effect.

Now we define the velocity of our body. Velocity (like position and quite a few other physics commands) takes as its argument a vector, which makes sense when you think about it since a vector carries both direction and magnitude, measured initially from the origin. So when we define velocity as newBody:setVel(physics.Vect(1000,1000)) imagine a vector from (0, 0) to the point (1000, 1000) which gives both the initial direction of motion (45 degrees down from the horizontal), and the speed as the length of the vector. The initial position is set by default as (0, 0).

Finally, for the physics part, we add this body to our space: space:addBody(newBody). It is now defined and ready to be used. Things like position and velocity, of course, can be changed at any point, which is what we do in our on.paint function.

3. Painting the Visuals and the Action

Top of Page