using CommonAI.Zone.Attributes;
using CommonAI.Zone.Formula;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CommonAI.Zone.Instance
{
    partial class InstanceUnit
    {
        /// <summary>
        /// 单位更新触发 
        /// </summary>
        /// <param name="unit"></param>
        public delegate void UpdateHandler(InstanceUnit unit);
        /// <summary>
        /// 收到网络协议
        /// </summary>
        /// <param name="unit"></param>
        /// <param name="act"></param>
        public delegate void HandleActionHandler(InstanceUnit unit, ObjectAction act);

        /// <summary>
        /// 单位添加到场景
        /// </summary>
        /// <param name="unit"></param>
        public delegate void AddedHandler(InstanceUnit unit);

        /// <summary>
        /// 单位被移除触发 
        /// </summary>
        /// <param name="unit"></param>
        public delegate void RemovedHandler(InstanceUnit unit);

        /// <summary>
        /// 当单位可攻击时触发，如果单位有出生动画，则动画完结后触发。
        /// </summary>
        /// <param name="unit"></param>
        public delegate void ActivatedHandler(InstanceUnit unit);

        /// <summary>
        /// 单位死亡触发
        /// </summary>
        /// <param name="unit"></param>
        /// <param name="attacker"></param>
        public delegate void DeadHandler(InstanceUnit unit, InstanceUnit attacker);

        /// <summary>
        /// 单位重生触发
        /// </summary>
        /// <param name="unit"></param>
        public delegate void RebirthHandler(InstanceUnit unit);

        /// <summary>
        /// 单位受到攻击触发
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="attacker"></param>
        /// <param name="hp"></param>
        /// <param name="source"></param>
        public delegate void DamageHandler(InstanceUnit obj, InstanceUnit attacker, int hp, AttackSource source);

        /// <summary>
        /// 单位打到别人触发
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="target"></param>
        /// <param name="hp"></param>
        /// <param name="source"></param>
        public delegate void AttackHandler(InstanceUnit obj, InstanceUnit target, int hp, AttackSource source);

        public delegate void GotInstanceItemHandler(InstanceUnit obj, InstanceItem item);

        public delegate void GotInventoryItemHandler(InstanceUnit obj, ItemTemplate item);
        public delegate void LostInventoryItemHandler(InstanceUnit obj, ItemTemplate item);

        public delegate void UseItemHandler(InstanceUnit obj, ItemTemplate item, InstanceUnit item_creater);

        public delegate void GotBuffHandler(InstanceUnit obj, InstanceUnit.BuffState buff);

        public delegate void LostBuffHandler(InstanceUnit obj, InstanceUnit.BuffState buff);
        /// <summary>
        /// 单位状态机切换
        /// </summary>
        /// <param name="old_state"></param>
        /// <param name="new_state"></param>
        public delegate void StateChangedHandler(InstanceUnit obj, State old_state, State new_state);

        /// <summary>
        /// 技能改变
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="baseSkill"></param>
        /// <param name="skills"></param>
        public delegate void SkillChangedHandler(InstanceUnit obj, SkillState baseSkill, SkillState[] skills);

        public delegate void OnLaunchSkillHandler(InstanceUnit obj, SkillState skill);

		// 单位区域传送触发
		public delegate void OnRegionTransportHandler();

		/// <summary>
		/// 尝试Pick单位
		/// </summary>
		/// <param name="obj"></param>
		/// <param name="picking"></param>
		/// <returns></returns>
		public delegate bool TryPickUnitHandler(InstanceUnit obj, InstanceUnit picking);

        /// <summary>
        /// 单位和其他单位产生交互
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="pickable"></param>
        public delegate void PickUnitHandler(InstanceUnit obj, InstanceUnit pickable);

        /// <summary>
        /// 单位尝试添加技能，可重置技能属性
        /// </summary>
        /// <param name="unit"></param>
        /// <param name="sk"></param>
        /// <returns></returns>
        public delegate bool TryAddSkill(InstanceUnit unit, ref SkillTemplate sk);
        public delegate void SkillAdded(InstanceUnit unit, SkillState sk);
        public delegate void SkillRemoved(InstanceUnit unit, SkillState sk);

        /// <summary>
        /// 技能打中目标，每关键帧(带attack)调用一次，也就是每次attack不管命中多少个人，只执行一次
        /// </summary>
        public delegate void SkillHitTargetHandler();

        //----------------------------------------------------------------------------------------------------
        private UpdateHandler mOnUpdate;
        private HandleActionHandler mOnHandleObjectAction;
        private AddedHandler mOnAdded;
        private RemovedHandler mOnRemoved;
        private ActivatedHandler mOnActivated;
        private DeadHandler mOnDead;
        private DamageHandler mOnDamage;
        private AttackHandler mOnAttack;
        private RebirthHandler mOnRebirth;
        private GotInstanceItemHandler mOnGotInstanceItem;
        private GotInventoryItemHandler mOnGotInventoryItem;
        private LostInventoryItemHandler mOnLostInventoryItem;
        private UseItemHandler mOnUseItem;
        private GotBuffHandler mOnGotBuff;
        private LostBuffHandler mOnLostBuff;
        private StateChangedHandler mOnStateChanged;
        private SkillChangedHandler mOnSkillChanged;
        private OnLaunchSkillHandler mOnLaunchSkill;
        private PickUnitHandler mOnPickUnit;
        private TryPickUnitHandler mOnTryPickUnit;
        private TryAddSkill mOnTryAddSkill;
        private SkillAdded mOnSkillAdded;
        private SkillRemoved mOnSkillRemoved;
        private SkillHitTargetHandler mOnSkillHitTarger;
		private OnRegionTransportHandler mOnRegionTransport;

		protected override void clearEvents()
        {
            base.clearEvents();

            this.mOnUpdate = null;
            this.mOnHandleObjectAction = null;
            this.mOnAdded = null;
            this.mOnRemoved = null;
            this.mOnActivated = null;
            this.mOnDead = null;
            this.mOnDamage = null;
            this.mOnAttack = null;
            this.mOnRebirth = null;
            this.mOnGotInstanceItem = null;
            this.mOnGotInventoryItem = null;
            this.mOnLostInventoryItem = null;
            this.mOnUseItem = null;
            this.mOnGotBuff = null;
            this.mOnLostBuff = null;
            this.mOnStateChanged = null;
            this.mOnSkillChanged = null;
            this.mOnLaunchSkill = null;
            this.mOnTryPickUnit = null;
            this.mOnPickUnit = null;
            this.mOnTryAddSkill = null;
            this.mOnSkillAdded = null;
            this.mOnSkillRemoved = null;
            this.mOnSkillHitTarger = null;
        }
        //----------------------------------------------------------------------------------------------------

        public event UpdateHandler OnUpdate { add { mOnUpdate += value; } remove { mOnUpdate -= value; } }
        public event HandleActionHandler OnHandleAction { add { mOnHandleObjectAction += value; } remove { mOnHandleObjectAction -= value; } }

        [EventTriggerDescAttribute("单位添加到场景时触发")]
        public event AddedHandler OnAdded { add { mOnAdded += value; } remove { mOnAdded -= value; } }
        [EventTriggerDescAttribute("单位被移除时触发")]
        public event RemovedHandler OnRemoved { add { mOnRemoved += value; } remove { mOnRemoved -= value; } }
        [EventTriggerDescAttribute("当单位可攻击时触发，如果单位有出生动画(SpawnTimeMS>0)，则动画完结后触发")]
        public event ActivatedHandler OnActivated { add { mOnActivated += value; } remove { mOnActivated -= value; } }

        [EventTriggerDescAttribute("单位死亡时触发")]
        public event DeadHandler OnDead { add { mOnDead += value; } remove { mOnDead -= value; } }
        [EventTriggerDescAttribute("单位受到伤害时触发")]
        public event DamageHandler OnDamage { add { mOnDamage += value; } remove { mOnDamage -= value; } }
        [EventTriggerDescAttribute("单位攻击别人时触发")]
        public event AttackHandler OnAttack { add { mOnAttack += value; } remove { mOnAttack -= value; } }
        [EventTriggerDescAttribute("单位复活时触发")]
        public event RebirthHandler OnRebirth { add { mOnRebirth += value; } remove { mOnRebirth -= value; } }

        [EventTriggerDescAttribute("单位获得物品时触发")]
        public event GotInstanceItemHandler OnGotInstanceItem { add { mOnGotInstanceItem += value; } remove { mOnGotInstanceItem -= value; } }
        [EventTriggerDescAttribute("单位获得物品进入背包时触发")]
        public event GotInventoryItemHandler OnGotInventoryItem { add { mOnGotInventoryItem += value; } remove { mOnGotInventoryItem -= value; } }
        [EventTriggerDescAttribute("单位丢掉背包中的物品时触发")]
        public event LostInventoryItemHandler OnLostInventoryItem { add { mOnLostInventoryItem += value; } remove { mOnLostInventoryItem -= value; } }
        [EventTriggerDescAttribute("单位使用物品时触发(包括捡到物品立即使用)")]
        public event UseItemHandler OnUseItem { add { mOnUseItem += value; } remove { mOnUseItem -= value; } }

        [EventTriggerDescAttribute("单位获得BUFF时触发")]
        public event GotBuffHandler OnGotBuff { add { mOnGotBuff += value; } remove { mOnGotBuff -= value; } }
        [EventTriggerDescAttribute("单位失去BUFF时触发")]
        public event LostBuffHandler OnLostBuff { add { mOnLostBuff += value; } remove { mOnLostBuff -= value; } }
        [EventTriggerDescAttribute("单位状态机改变时触发")]
        public event StateChangedHandler OnStateChanged { add { mOnStateChanged += value; } remove { mOnStateChanged -= value; } }
        [EventTriggerDescAttribute("单位技能发生变化时触发")]
        public event SkillChangedHandler OnSkillChanged { add { mOnSkillChanged += value; } remove { mOnSkillChanged -= value; } }
        [EventTriggerDescAttribute("单位释放技能")]
        public event OnLaunchSkillHandler OnLaunchSkill { add { mOnLaunchSkill += value; } remove { mOnLaunchSkill -= value; } }

		[EventTriggerDescAttribute("区域传送触发")]
		public event OnRegionTransportHandler OnRegionTransport { add { mOnRegionTransport += value; } remove { mOnRegionTransport -= value; } }
		

		[EventTriggerDescAttribute("尝试Pick单位")]
        public event TryPickUnitHandler TryPickUnit { add { mOnTryPickUnit += value; } remove { mOnTryPickUnit -= value; } }
        [EventTriggerDescAttribute("单位和其他单位产生交互时触发")]
        public event PickUnitHandler OnPickUnit { add { mOnPickUnit += value; } remove { mOnPickUnit -= value; } }

        [EventTriggerDescAttribute("单位尝试添加技能，可重置技能属性")]
        public event TryAddSkill OnTryAddSkill { add { mOnTryAddSkill += value; } remove { mOnTryAddSkill -= value; } }
        [EventTriggerDescAttribute("单位获得技能")]
        public event SkillAdded OnSkillAdded { add { mOnSkillAdded += value; } remove { mOnSkillAdded -= value; } }
        [EventTriggerDescAttribute("单位移除技能")]
        public event SkillRemoved OnSkillRemoved { add { mOnSkillRemoved += value; } remove { mOnSkillRemoved -= value; } }

        [EventTriggerDescAttribute("技能击中目标")]
        public event SkillHitTargetHandler OnSkillHitTarget { add { mOnSkillHitTarger += value; } remove { mOnSkillHitTarger -= value; } }

    }
}