Return to Answer

added 1156 characters in body

Source Link

edited Sep 10, 2012 at 23:49

It can also be convenient to maintain several different lists of objects based upon their type, so for example, one list of all the ducks, one of all the turtles, and one of all the clouds, but the reasons for this are likely beyond the scope of this question (one example: to minimize the amount of graphics state that must be changed between 'batches').

Quick code example:

Now, all of the drawing is called from a single place in your application.

EDIT: One benefit to using this approach is that Draw calls aren't scattered about. Another (more important) benefit is that each class handles the drawing of its instances. So your main application doesn't need to know (or care) how a ball is drawn - all it knows is that (because of the Drawable interface) a ball CAN be drawn (by calling ballObject.Draw(g)). Instead, the Ball class is the only file that holds the code which specifically describes how a ball is drawn. So if you want to change this later on, you only have to modify that one function in the Ball class, nowhere else.

Wheather you maintain one unified list of Drawables, or multiple lists of objects, you absolutely should define a "Draw" function in the specific class, for the above-mentioned reasons. It might seem like it's adding more code right now while the drawing routines are simple, but once you start having drawing lines that consume pages and pages of code, you'll be very glad that that code is sequestered away in a specific place, not littered about your main game loop with everything else.

Quick code example:

Now, all of the drawing is called from a single place in your application.

Quick code example:

Now, all of the drawing is called from a single place in your application.

Source Link

answered Sep 10, 2012 at 23:26

bfishman

I like to create an interface that defines a "Draw" method. Whenever a class implements that interface, it means that regardless of what else the class can do, it MUST provide the exact "Draw" method as specified in the interface.

Therefore, even if you have a bunch of different objects - a ball, a player, a field - so long as each of them implement the "Drawable" interface, you can iterate through each one of them and call "Draw".

Of course, each class will have to specify what exactly that draw call will do - the interface does not provide this information.

From there, I make a large list of all of my drawable game objects, iterate through it, and call "Draw" on each object.

Quick code example:

Drawable.java:

interface Drawable{
    public void Draw(Graphics g);
}

Ball.java:

class Ball implements Drawable{
    int positionX;
    int positionY;

    public void Draw(Graphics g){
        g.drawOval(positionX, positionY, 5, 5);
    }
}

In your application (main class, likely), have the following:

DrawableStuff = new ArrayList<Drawable>();
DrawableStuff.add(new Ball());
DrawableStuff.add(new Ball());
DrawableStuff.add(new Ball());
DrawableStuff.add(new Duck());
DrawableStuff.add(new Cloud());

Then, in your Component or Canvas' draw function (this depends on your exact implementation, of course):

public void paint(Graphics g){
    for (Drawable d : DrawableStuff){
        d.Draw(g);
    }
}

Now, all of the drawing is called from a single place in your application.

This is a very broad topic, but hopefully that gives you an idea of where you can start.