1. There is no general best practice.
If you got a lot of (complex shaped) elements, particles etc. in your game, the bitmap buffer approach is going to be much faster. The bitmap buffer will also scale better with increasing complexity of your sprites. The vector renderer will become slower with more complex shapes or tween (shape tween) animations, it has some other benefits though:
- You can freely scale your assets or even zoom into the scene without loss of quality.
- Rotation or other transformations like skewing will be much easier to perform on vector graphics
So in conclusion, it boils down to what kind of game you're building.
2. Using MovieClips instead of bitmap sprite-sheets
I guess you meant "bitmap sprite-sheets" and not the AS3 Sprite class?
This doesn't make a difference, really. You can always turn your MovieClip based animations into animated bitmaps. Either manually, by exporting the movie to frames and turn them into a sprite-sheet, or dynamically, by rendering a sprite sheet from your MovieClip at runtime. Here's how I would do this:
- Create an instance of the MovieClip and
- Create a
new BitmapData object with the same width and height as the Movieclip.
- Use the draw() method, to render the MovieClip to the BitmapData.
- Store the BitmapData object in an Array or Vector.
- Go to the next frame of your MovieClip and repeat Steps 2 - 4, do this until you reached the last frame of your MovieClip. It's also a good idea to update two variables with the max width and max height of your MovieClip frames (since these can change from frame to frame).
- Now you can combine all the stored BitmapData Objects into a Sprite-Sheet (use BitmapData.copyPixels())
3. Sprite-based animations
As mentioned in the answer to your first question, there's no definite answer to that. If you need to perform a lot of transformations with your objects, eg. scaling and rotating you're probably better off by using the flash native renderer. If you got pre-defined animations that can be baked to sprite-sheets (manually or dynamically), and if you need to display hundreds of sprites at the same time, then go for a bitmap-rendering engine.