source: 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Units/Unit.cs @ 4581

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CastleMaster.Entities;
using CastleMaster.World;
using CastleMaster.Players;
using CastleMaster.Physics;
using Microsoft.Xna.Framework;
using CastleMaster.Graphics;

namespace CastleMaster.Units
{
    public class Unit : Entity
    {
        protected bool isSelectable, isSelected;
        protected BoundingRectangle screenRect;
        protected BoundingRectangle screenRectOffset;
        protected Vector2 highlightOffset = Vector2.Zero;
        protected Point spriteSize;
        private float timer = -MathHelper.TwoPi, arrowSpeed = 0.1F;
        private Vector2 arrowOffs = Vector2.Zero;
        private Player owner;

        public Unit(Level level, Player owner)
            : base(level)
        {
            this.owner = owner;

            spriteSize = new Point(32, 32);
            screenRectOffset = new BoundingRectangle(0, 0, spriteSize.X, spriteSize.Y, null);
            isSelectable = true;
            isSelected = false;
        }

        public bool IsSelectable { get { return isSelectable; } }

        public Player Owner { get { return owner; } }

        public override void Init()
        {
            base.Init();
        }

        public virtual void OnSelectGain()
        {
            isSelected = true;
        }

        public virtual void OnSelectLost()
        {
            isSelected = false;
        }

        public virtual void OnFunctionClick() { }

        public override void Update()
        {
            if (isSelected)
            {
                timer += arrowSpeed;
                if (timer >= MathHelper.TwoPi) timer = -MathHelper.TwoPi;
                arrowOffs.Y = (float)Math.Sin(timer) * 2.0F;
            }
        }

        public bool IntersectsWithScreenSpace(float x0, float y0, float x1, float y1)
        {
            if (!isSelectable) return false;
            screenRect = new BoundingRectangle(screenPos.X, screenPos.Y, screenPos.X, screenPos.Y, this).AddSelf(screenRectOffset).Scale(Viewport.ZOOM);
            return screenRect.Intersects(x0, y0, x1, y1);
        }

        public float DistanceTo(float x, float z)
        {
            float xd = X - x;
            float zd = Z - z;

            return (float)(Math.Sqrt(xd * xd + zd * zd));
        }

        public float DistanceFromScreenSpaceSqr(float x, float y)
        {
            float dx = screenPos.X * Viewport.ZOOM - x;
            float dy = screenPos.Y * Viewport.ZOOM - y;

            return dx * dx + dy * dy;
        }

        public virtual void RenderHighLight(RenderHelper renderer)
        {
            renderer.Render((screenPos + highlightOffset + arrowOffs) * Viewport.ZOOM, 1, 0, Resources.SPRITESHEET_ICONS, Viewport.ZOOM);
        }

        public override void Render(RenderHelper renderer)
        {
            if (isSelected)
                RenderHighLight(renderer);
        }
    }
}