C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/GraphicalElements/ShootingGallery.cs

//-----------------------------------------------------------------------------
// ShootingGallery.cs
// (A. Schiffler, 2009)
//-----------------------------------------------------------------------------

namespace NewGamePhysics.GraphicalElements
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Content;
    using Microsoft.Xna.Framework.Graphics;
    using Microsoft.Xna.Framework.Input;

    using NewGamePhysics.StateManager;
    using NewGamePhysics.Utilities;
    using NewGamePhysics.PhysicalElements;
    using NewGamePhysics.Mathematics;
    using NewGamePhysics.Physics;

    public class ShootingGallery : GraphicalElementBase
    {
        private int numTargets = 0;

        private int numActiveTargets = 0;

        Vector2 simulationOrigin;

        private double width;

        private double height;

        Vector2 screenOrigin;

        double screenScale;

        private ShootingGalleryTarget[] shootingGalleryTargets = null;

        private double targetConveyerSpeed = 0.001;

        public double TargetConveyerSpeed
        {
            get { return this.targetConveyerSpeed; }
            set { this.targetConveyerSpeed = value; }
        }

        public int NumTargets
        {
            get { return this.numTargets; }
        }

        public int NumActiveTargets
        {
            get { return this.numActiveTargets; }
        }

        public ShootingGallery(
            ScreenManager screenManager,
            Vector2 simulationOrigin,
            double width,
            double height,
            Vector2 screenOrigin,
            double screenScale)
            : base(screenManager)
        {
            this.simulationOrigin = simulationOrigin;
            this.width = width;
            this.height = height;
            this.screenOrigin = screenOrigin;
            this.screenScale = screenScale;
        }

        public void Reset(string[] targetTypes, double gravity, double atmosphereDensity)
        {
            if (targetTypes == null || targetTypes.Length == 0)
            {
                throw new ArgumentException(
                    "Can reset only to one or more targets",
                    "targetTypes");
            }

            this.numTargets = targetTypes.Length;

            if (gravity == 0.0)
            {
                throw new ArgumentException(
                    "Gravity must be non-zero.",
                    "gravity");
            }

            // Separation of targets
            double stepX = this.width / this.numTargets;
            if (stepX <= this.height)
            {
                throw new ArgumentException(
                    "Cannot fit that many targets into the width of the gallery without overlap.",
                    "numTargets");
            }

            this.numActiveTargets = this.numTargets;
            this.shootingGalleryTargets = new ShootingGalleryTarget[this.numTargets];
            for (int i = 0; i < this.numTargets; i++)
            {
                this.shootingGalleryTargets[i] = new ShootingGalleryTarget(
                    this.ScreenManager, 
                    (ShootingGalleryTargetType)Enum.Parse(
                        typeof(ShootingGalleryTargetType), 
                        targetTypes[i]),
                    gravity,
                    atmosphereDensity,
                    this.height,
                    this.height,
                    this.screenOrigin,
                    this.screenScale);
                this.shootingGalleryTargets[i].Position = 
                    new Vector2(
                        this.simulationOrigin.X + (float)(i * stepX), 
                        this.simulationOrigin.Y);
            }
        }
        
        public int ShootAtTargets(Vector2 shotCenter, double bulletSize)
        {
            int numberHits = 0;

            foreach (ShootingGalleryTarget shootingGalleryTarget in this.shootingGalleryTargets)
            {
                if (shootingGalleryTarget.Visible && !shootingGalleryTarget.Animated)
                {
                    if (shootingGalleryTarget.ShootAtTarget(shotCenter, bulletSize))
                    {
                        numberHits++;
                    }
                }
            }

            return numberHits;
        }

        public void Update(GameTime gameTime)
        {
            foreach (ShootingGalleryTarget shootingGalleryTarget in this.shootingGalleryTargets)
            {
                if (shootingGalleryTarget.Visible)
                {
                    if (shootingGalleryTarget.Animated)
                    {
                        shootingGalleryTarget.Update();
                        if (!shootingGalleryTarget.Visible)
                        {
                            this.numActiveTargets--;
                        }
                    }
                    else
                    {
                        shootingGalleryTarget.Move(this.targetConveyerSpeed);

                        // Wrap horizontal position around
                        Vector2 position = shootingGalleryTarget.Position;
                        if ((position.X - this.simulationOrigin.X) < 0.0)
                        {
                            position.X = this.simulationOrigin.X + (float)this.width;
                            shootingGalleryTarget.Position = position;
                        }
                        else if ((position.X - this.simulationOrigin.X) > (float)this.width)
                        {
                            position.X = this.simulationOrigin.X;
                            shootingGalleryTarget.Position = position;
                        }
                    }
                }
            }
        }

        public void Draw(GameTime gameTime)
        {
            foreach (ShootingGalleryTarget shootingGalleryTarget in this.shootingGalleryTargets)
            {
                shootingGalleryTarget.Draw(gameTime);
            }
        }
    }
}

---