source: 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Units/Mobs/MobRanger.cs @ 4616

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using CastleMaster.Graphics;
using CastleMaster.World;
using CastleMaster.Players;
using IsometricEngineTest.Ai.Orders;
using CastleMaster.Entities;

namespace CastleMaster.Units.Mobs
{
    public class MobRanger : Mob
    {
        private enum OrderType { ATTACK, WALK, NONE }

        private const float ATTACK_RANGE = 60.0F;
        private const float ATTACK_RANGE_SQR = ATTACK_RANGE * ATTACK_RANGE;

        private Unit target;
        private OrderType currentOrderType = OrderType.NONE;
        private bool isAttacking = false;
        private int maxDamage = 5;
        private AnimationHelper hitAnimation;
        private int spriteX;
        private float pushPower = 5.0F;

        public MobRanger(Level level, Player owner)
            : base(level, owner)
        {
            HasHealth = true;
            maxHealth = 50;

            spriteSize.X = 17;
            spriteSize.Y = 20;
            screenRectOffset.Update(8, 12, 8 + spriteSize.X, 12 + spriteSize.Y);
            renderOffset.Y = 20;

            highlightOffset.X = 11;

            rectOffset.Update(-4.0F, -4.0F, 5.0F, 5.0F);
            isSolid = true;
            moveSpeed = 1.0F;
            hitAnimation = new AnimationHelper(10, 5, false, 3);
            hitAnimation.RoundEnded += delegate()
            {
                if (target != null)
                    level.AddEntity(new EntityArrow(level, 5, 2.0F, target, this, Owner.Team), X + (float)Math.Cos(Direction) * 2.0F, Z + (float)Math.Sin(Direction) * 2.0F);
            };
        }

        private void StartAttack()
        {
            isAttacking = true;
            hitAnimation.Start();
        }

        private void StopAttack()
        {
            isAttacking = false;
            target = null;
            currentOrderType = OrderType.NONE;
        }

        private void PauseAttack()
        {
            isAttacking = false;
            hitAnimation.Stop();
            hitAnimation.Reset();
        }

        private void CreateAttackOrder(Unit u)
        {
            currentOrderType = OrderType.ATTACK;
            SetOrder(new OrderMove(u.X, u.Z, ATTACK_RANGE, true));
            target = u;
        }

        public override void Damage(Unit attacker, int damage, float dir, float pushPower)
        {
            base.Damage(attacker, damage, dir, pushPower);
            if (!isAttacking && currentOrderType == OrderType.NONE)
                CreateAttackOrder(attacker);
        }

        protected override void OnOrderFinished()
        {
            base.OnOrderFinished();
            if (currentOrderType == OrderType.ATTACK)
                StartAttack();
            else if (currentOrderType == OrderType.WALK)
                currentOrderType = OrderType.NONE;
        }

        public override void OnFunctionClick(float x, float z)
        {
            Unit u = Owner.SelectUnit(Game.GetEnemyTeam(Owner.Team));
            if (u != null)
                CreateAttackOrder(u);
            else
            {
                if (target != null) StopAttack();
                currentOrderType = OrderType.WALK;
                SetOrder(new OrderMove(x, z));
            }
        }

        public override void Update()
        {
            base.Update();

            if (isAttacking)
            {
                if (DistanceToSqr(target.X, target.Z) > ATTACK_RANGE_SQR)
                {
                    isAttacking = false;
                    CreateAttackOrder(target);
                }
                else
                {
                    UpdateDir(target.X, target.Z);
                    hitAnimation.UpdateStep();
                    if (target.Removed)
                        StopAttack();
                }
            }
            else if (!isAttacking && currentOrderType == OrderType.NONE)
            {
                List<Unit> units = level.GetNearbyEnemyUnits(Game.GetEnemyTeam(Owner.Team), (int)(x / Viewport.TILESIZE), (int)(z / Viewport.TILESIZE), 4);
                if (units.Count > 0)
                    CreateAttackOrder(units[0]);
            }

            spriteX = isAttacking ? hitAnimation.CurrentFrame : walkingAnimation.CurrentFrame;
        }

        public override void Render(RenderHelper renderer)
        {
            base.Render(renderer);
            renderer.Render(ScreenPos, spriteX, dirID, Resources.SPRITESHEET_RANGER, colorizer, Viewport.ZOOM);
        }
    }
}