source: 2013/30/DenisZ/CastleMaster/CastleMaster/CastleMaster/Units/Mobs/Mob.cs @ 4592

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

namespace CastleMaster.Units.Mobs
{
    public class Mob : Unit
    {
        private Order currentOrder;
        private float dir = 0.0F;
        private AStar pathFinder;
        protected int dirID;
        protected AnimationHelper walkingAnimation;
        protected float pushResistance;
        protected bool canBePushed;
        private bool isPushed;
        private float pushDir, pushPower;

        public Mob(Level level, Player owner)
            : base(level, owner)
        {
            currentOrder = new Order();
            pathFinder = new AStar(level, this);
            walkingAnimation = new AnimationHelper(10, 2).Start();
            immunityTime = 20;
            canBePushed = true;
            pushResistance = 0.0F;
        }

        protected float Direction { get { return dir; } }

        public AStar PathFinder { get { return pathFinder; } }

        //public override bool IsSolidTo(Entity ent)
        //{
        //    Mob mob = ent as Mob;
        //    if (mob != null)
        //        return mob.Owner != Owner;
        //    return base.IsSolidTo(ent);
        //}

        public override void Update()
        {
            base.Update();
            if (!(currentOrder is OrderIdle))
            {
                currentOrder.Update();
                if (currentOrder.Finished)
                {
                    StopCurrentOrder();
                }
            }

            if (isPushed)
            {
                MoveTo(dir, pushPower);
                isPushed = false;
            }
        }

        protected void StopCurrentOrder()
        {
            OnOrderFinished();
            SetOrder(GetNextOrder());
        }

        protected virtual void OnOrderFinished()
        {
            walkingAnimation.Reset();
        }

        public void SetOrder(Order order)
        {
            currentOrder = order;
            order.Initialize(this);
        }

        public override void OnDamage(Unit attacker, int damage, float dir, float pushPower)
        {
            base.OnDamage(attacker, damage, dir, pushPower);
            if (canBePushed)
                Push(dir, pushPower);
        }

        private void Push(float dir, float pushPower)
        {
            isPushed = true;
            pushDir = dir;
            this.pushPower = pushPower - pushResistance;
        }

        private void MoveTo(float dir, float amount)
        {
            float moveX = (float)Math.Cos(dir) * amount;
            float moveZ = (float)Math.Sin(dir) * amount;

            Move(moveX, moveZ);
        }

        public bool MoveForward()
        {
            float moveX = (float)Math.Cos(dir) * moveSpeed;
            float moveZ = (float)Math.Sin(dir) * moveSpeed;

            if (Move(moveX, moveZ))
            {
                walkingAnimation.UpdateStep();
                return true;
            }

            return false;
        }

        public virtual Order GetNextOrder()
        {
            return new Order();
        }

        public bool TurnTowards(float x, float z)
        {
            float angleTowards = (float)Math.Atan2(z - Z, x - X);

            dir = MathHelper.WrapAngle(dir);

            float angleDifferece = angleTowards - dir;
            angleDifferece = MathHelper.WrapAngle(angleDifferece);

            float maxTurn = 0.2F;
            float near = 1.0F;
            bool turnDone = angleDifferece * angleDifferece < near * near;
            if (angleDifferece < -maxTurn) angleDifferece = -maxTurn;
            if (angleDifferece > maxTurn) angleDifferece = maxTurn;
            dir += angleDifferece;
            dirID = GetDirectionID();

            return turnDone;
        }

        protected void UpdateDir(float x, float z)
        {
            dir = (float)Math.Atan2(z - Z, x - X);
            dirID = GetDirectionID();
        }

        public int GetDirectionID()
        {
            return (int)(Math.Floor(dir * 8 / MathHelper.TwoPi + 0.5F)) & 7;
        }
    }
}