The answer to this really depends on what you're doing. To a large degree, you'll need to just kind of figure out how you want to do it, and make it happen.
Having said that, here's a few thoughts that come to my mind. I'm assuming that you have different objects that are represented on the screen with images (Texture2Ds). I'd probably create a class for the objects, and if there's no difference between them, other than the image that you draw them with, that class might look something like this:
public class GameObject
{
public Vector2 Position { get; set; }
public ObjectType Type { get; set; }
}
I'd then create an enumeration of the available types. Something like this:
public enum ObjectType { Hamburger, Bucket, Torpedo, Jello } // These are the different kinds of objects that are being displayed. The class above is using this enumeration.
You'd also need to write code that will find the right Texture2D for a specific ObjectType. But having the game object store just an identifier for what it is using, rather than the actual texture to draw keeps good separation between the backend updating engine and the frontend drawing code, which is important and useful.
I'd then create a List<GameObject> to store all of the objects that you're keeping track of at any given point in time. As you generate objects, they'll get added to this list, and as objects leave the screen and they're removed.
So you asked the question about how to randomly generate these game objects. Well, you'll probably rely heavily on [[[random-number-generation | the Random class]] to pick random numbers for you. You'd use it to pick a type (random.Next(4) if you have four choices, etc.) and probably a random position. Just have it pick values for the x and y coordinate of the position that are a little bit off the screen. (I'm assuming you don't want objects to pop up in the middle of the screen, but drift onto the screen.) You may also need to randomly populate other properties of the object, like velocity or whatever else you want it to keep track of.
Your other question was about "collision detection". I'll admit, in this case, it is a bit of a misnomer. What people call collision detection should really just be called "intersection detection" instead. In the normal case, we'd be trying to detect whether two objects are intersecting with each other, which would denote a collision. In this case, all we really want is to know if the object we're drawing and the view area intersect or not. That's how you'd tell if the object is visible. You'll still be able to use collision detection code to do this, even though it isn't technically a collision. If you're simply using Texture2Ds, you can do basic rectangle collision detection with each object and a rectangle that represents the full screen.
Rectangle screenRectangle = new Rectangle(0, 0, graphics.PreferredBackBufferWidth, graphics.PreferredBackBufferHeight);
foreach (GameObject gameObject in gameObjects)
{
Texture2D texture = LookupTexture(gameObject.Type);
Rectangle objectRectangle = new Rectangle(
gameObject.Position.X - texture.Width / 2,
gameObject.Position.Y - texture.Height /2,
texture.Width,
texture.Height);
if (screenRectangle.Intersects(objectRectangle))
{
}
}
Like I said, you're the one making the game, and to some degree, you're going to need to figure out what, exactly, you want. But this should give you some ideas about where to go.
Lichii (guest) 20 Apr 2012 12:50