Warning: This is a rather long post, as I have a few ideas that I want to mention. 
There are two main parts: A game idea for the tutorial, and suggestions for the tutorial itself. I’ve separated them from this section and each other for easier navigation.
First of all, however, I want to say that I think that such a tutorial could well be a very good idea indeed. 
My own idea for a game is a simple one in which the player controls a basic model that moves over the ground, directed using the WASD control system for forwards, backwards and strafing movement, and the mouse to control direction, and with the camera following the player. The player avatar has a basic animation that loops continuously.
The player would be tasked with destroying some small number of turrets, which fire repeatedly. The player avatar and turrets have one animation each. Instead of using the particle system (which I've found to be problematic), turrets produce a non-lit and coloured sphere when destroyed that expands and then contracts.
The player can collide with the turrets, and with the environment walls. Shots collide with the player, turrets and the environment walls.
The environment should include obstacles, to allow the player to take cover and pop out to shoot.
This should teach, in some sort of sequence, very basic avatar control, reparenting, basic animation, some task-use, basic collision, and a few other things, I believe. It should also be possible for interested readers to build it up into something more fun.
Simple, not pretty, but fairly easy, I think, and I believe that it can be built up in parts reasonably well. I imagine that a sequence something like this should work:
[code]
- Reader implements the initial tutorial in the manual.
- Reader implements a simple "GameObject" class, to be used
for the player avatar and enemies. This has the following
properties:
- An Actor (the representation of the object)
- A "weapon cooldown" value
- A "max weapon cooldown" value
- Reader replaces the interval controlling the panda with key
control, using "accept", a key setting function, an update
function, setPos and getPos.
- Reader re-parents the camera to the panda, and implements
mouse-based turning.
- Reader replaces the panda and manual tutorial environment with
the player-avatar and environment for this tutorial.
- Reader implements player-to-environment collision.
- Reader implements shooting, including bullet-to-environment
collision.
- Reader implements enemies and enemy "logic", which consists
of looking at the player and shooting whenever the cooldown
value is at or below zero. When enemies fire, they also start
a "shooting" animation.
- Reader implements bullet-to-player and bullet-to-enemy collision.
- When a bullet hits the player, the game ends and a game loss
screen appears.
- When a bullet hits an enemy, it is destroyed, and a sphere is
created, as described above, which is itself destroyed at the
end of its sequence.
- When there are no more enemies, a game win screen is shown.
[/code]
Note that in this case I intend that enemy logic be placed in the main game update loop. This isn't wonderful design, but it allows me to use one class for both players and enemies, without dealing with getting weaponsfire out of the object or taking the player's position in, which keeps things simple.
As I said, ugly, but simple.
I should be able to give more detail on most of those points, if desired, I think.
I also have a few suggestions regarding the tutorial itself:
1) Make certain assumptions about your readers, but, importantly, I believe, be explicit at the start of the tutorial about what you’re assuming.
Try to limit the scope of the tutorial to avoid treading ground already more thoroughly covered by other tutorials.
I would recommend assuming (as mentioned above) that the readers have basic knowledge of Python and object-orientation, and are capable of basic modelling (enough for the purposes of the tutorial, at least), basic image editing, and basic use of the programs being used. However, do mention any common stumbling blocks, such as (in my impression) the use of UV-mapping instead of automatic texture mapping in Blender.
Instead, link to external tutorials for the programs used. I’ve used the following tutorials, I believe; there may be better, but these should at least provide something to start with, I think:
Blender 3D: Noob to Pro.
Python Tutorial
I’ve also found this Python 2.5 Quick Reference to be useful as well.
2) Include descriptions of at least part of the workflow for the modeller and graphics program, but don’t focus heavily on either.
As I said, assume that readers already know how to model, and instead show them how to do things directly related to Panda for the most part - for example, getting Chicken up and running if Blender is used - as well as any common stumbling points.
3) Provide for download the (basic) models and textures.
This allows the user to get started easily, as well as look at a (presumably) working copy, so that they can hopefully more easily test whether a problem is related to their model, or their other methods.
I would recommend doing this in both engine-ready (.egg and .png, for example), and the formats of whichever modelling and image-editing programs are used, such as .blend and .xcf for Blender and The Gimp respectively.
4) Link to the programs used.
Personally, I use Blender more often than not these days, but I’ve also found Wings to be good, and, to second Cyan’s statement, I recall Wings being rather easier to learn. The GIMP is, I think, a pretty good choice of image editor; if another editor is chosen, I would suggest that it be one that can handle layers and store them in some format.
5) Finally, be careful to explain what you’re doing, and take things step-by-step.
Avoid the potential pitfall of giving some amount of text, and then just dumping a large quantity of code on the reader. (Which I seem to recall hearing about being done in at least one tutorial.)
).
). It’s my understanding (and I’ll admit, as I have before, that I’m still fairly new with Panda myself) that 3D is the default rendering mode for Panda, with 2D being an available non-main case. 2D in Panda would also call, I think, for learning about such things as texture cards. Finally, the tutorial given in the manual is in 3D, is very simple, and is, I think, a good base on which to build.