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

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

namespace NewGamePhysics.GraphicalElements
{
    using System;
    using System.Collections.Generic;
    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.Mathematics;
    using NewGamePhysics.Physics;
    using NewGamePhysics.GraphicalElements;
    using NewGamePhysics.PhysicalElements;
    using NewGamePhysics.Utilities;

    public enum ShootingGalleryTargetType
    {
        CopperBall,

        SilverBall,

        GoldBall,
    }

    public class ShootingGalleryTarget : GraphicalElementBase
    {
        private CircularObjectSimulation animatedCircularObject;

        private double width;

        private double height;

        Vector2 screenOrigin;

        double screenScale;

        Vector2 screenPosition;

        private Texture2D targetTexture;

        private bool visible;

        private bool animated;

        private double radius;

        Vector2 spriteScale;

        Vector2 spriteOrigin;

        public ShootingGalleryTarget(
            ScreenManager screenManager, 
            ShootingGalleryTargetType type, 
            double gravity,
            double atmosphereDensity,
            double simulationWidth,
            double simulationHeight,
            Vector2 screenOrigin, 
            double screenScale)
            : base(screenManager)
        {
            this.width = simulationWidth;
            this.height = simulationHeight;
            this.screenOrigin = screenOrigin;
            this.screenScale = screenScale;
            this.radius = Math.Min(width, height) / 2;
            double diameter = 2.0 * this.radius;
            this.screenPosition = new Vector2();
            
            this.visible = true;
            this.animated = false;

            string textureName = string.Empty;
            switch (type)
            {
                case ShootingGalleryTargetType.CopperBall:
                    this.animatedCircularObject =
                        new CircularObjectSimulation(diameter, 8.94, gravity, atmosphereDensity);
                    textureName = "copperball";
                    break;
                case ShootingGalleryTargetType.SilverBall:
                    this.animatedCircularObject =
                        new CircularObjectSimulation(diameter, 10.49, gravity, atmosphereDensity);
                    textureName = "silverball";
                    break;
                case ShootingGalleryTargetType.GoldBall:
                    this.animatedCircularObject =
                        new CircularObjectSimulation(diameter, 19.30, gravity, atmosphereDensity);
                    textureName = "goldball";
                    break;
            }

            // Prepare texture
            if (screenManager.Textures.ContainsKey(textureName))
            {
                this.targetTexture = screenManager.Textures[textureName];
            }
            else
            {
                throw new ArgumentException("Texture with name " + textureName + " not found");
            }

            float spriteScaleX = (float)(this.width * this.screenScale / this.targetTexture.Width);
            float spriteScaleY = (float)(this.height * this.screenScale / this.targetTexture.Height);
            this.spriteScale = new Vector2(spriteScaleX, spriteScaleY);
            this.spriteOrigin = new Vector2();
        }

        public bool Animated
        {
            get { return this.animated; }
            set { this.animated = value; }
        }

        public bool Visible
        {
            get { return this.visible; }
            set { this.visible = value; }
        }

        public Vector2 Position
        {
            get { return this.animatedCircularObject.GetPosition(); }
            set { this.animatedCircularObject.SetPosition(value); }
        }

        public void Move(double horizontalDisplacement)
        {
            if (this.visible)
            {
                Vector2 position = 
                    this.animatedCircularObject.GetPosition();
                position.X += (float)horizontalDisplacement;
                this.animatedCircularObject.SetPosition(position);
            }
        }

        public bool ShootAtTarget(Vector2 shotCenter, double bulletSize)
        {
            if (this.visible)
            {
                Vector2 targetPosition = 
                    this.animatedCircularObject.GetPosition();

                if (IntersectionTest.CircleInCircle2D(
                    targetPosition,
                    this.radius,
                    shotCenter,
                    bulletSize))
                {
                    this.animated = true;
                    return true;
                }
            }

            return false;
        }

        public void Update()
        {
            if (this.visible && this.animated)
            {
                // Let target fall
                this.animatedCircularObject.Animate();

                // Check if we left the screen
                UpdateScreenPosition();
                if (this.screenPosition.Y > (this.Viewport.Height + this.radius * this.screenScale))
                {
                    this.visible = false;
                }
            }
        }

        public void Draw(GameTime gameTime)
        {
            if (this.visible)
            {
                // Get fresh screen coordinates
                UpdateScreenPosition();

                // Draw target
                this.SpriteBatch.Begin(SpriteBlendMode.AlphaBlend);
                this.SpriteBatch.Draw(
                    this.targetTexture,
                    this.screenPosition,
                    null,
                    Color.White,
                    0.0f,
                    this.spriteOrigin,
                    this.spriteScale,
                    SpriteEffects.None, 
                    0.0f);  
                this.SpriteBatch.End();
            }
        }

        private void UpdateScreenPosition()
        {
            Vector2 targetPosition =
                this.animatedCircularObject.GetPosition();
            screenPosition.X = (float)(this.screenOrigin.X + this.screenScale * (targetPosition.X - this.width / 2));
            screenPosition.Y = (float)(this.screenOrigin.Y + this.screenScale * (targetPosition.Y - this.height / 2));
        }
    }
}

---