WSHCommon/Common/CommonAI/Zone/Data.cs


using System;
using System.IO;
using System.Text;
using System.Collections.Generic;
using System.Runtime.Serialization;
using CommonAI.RTS.Manhattan;
using CommonAI.RTS;
using CommonLang.Vector;
using CommonLang;
using CommonLang.ByteOrder;
using CommonLang.IO;
using CommonLang.IO.Attribute;
using CommonLang.Property;
using CommonAI.Zone.Attributes;
using CommonAI.Zone.UnitTriggers;
using CommonAI.Zone.Instance;
using CommonAI.Zone.ZoneEditor;
using CommonAI.Zone.Helper;
using CommonLang.Xml;
using static CommonAI.Zone.AttackProp;
using CommonLang.Log;
using CommonAI.Data;

namespace CommonAI.Zone
{
    //---------------------------------------------------------------------------------//
    [MessageType(0x4000)]
    public class Config
    {
        [DescAttribute("系统帧率（服务端）", "系统")]
        public int SYSTEM_FPS = 30;

        [DescAttribute("全局重力", "全局")]
        public float GLOBAL_GRAVITY = 9.8f;
        [DescAttribute("全局挤开移动最大递归深度", "全局")]
        public uint GLOBAL_MOVE_IMPACT_DEPTH = 10;

        [DescAttribute("超出此同步范围，立即将坐标修正", "客户端")]
        public float CLIENT_UNIT_MOVE_MODIFY_MAX_RANGE = 20f;

        [DescAttribute("单位移动最慢速度(低于最慢速度表示不能移动)", "移动")]
        public float OBJECT_MOVE_TO_MIN_STEP_SEC = 0.3f;
        [DescAttribute("单位攻击范围是否包含身体半径", "战斗")]
        public bool OBJECT_ATTACK_RANGE_INCLUDE_BODYSIZE = false;

        [DescAttribute("单位间无碰撞总开关", "战斗")]
        public bool OBJECT_NONE_TOUCH = false;
        [DescAttribute("玩家无碰撞", "战斗")]
        public bool PLAYER_NONE_TOUCH = false;

        [DescAttribute("宠物跟随距离（靠近主人多少停止）", "战斗")]
        public float PET_FOLLOW_DISTANCE_MIN = 1.5f;
        [DescAttribute("宠物跟随距离（离主人多远时跟随）", "战斗")]
        public float PET_FOLLOW_DISTANCE_MAX = 2.5f;
        [DescAttribute("宠物强制跟随距离（距离太远，直接瞬移到主人）", "战斗")]
        public float PET_FOLLOW_DISTANCE_LIMIT = 12f;

        [DescAttribute("队员跟随距离（靠近主人多少停止）", "战斗")]
        public float TEAMER_FOLLOW_DISTANCE_MIN = 2f;
        [DescAttribute("队员跟随距离（离主人多远时跟随）", "战斗")]
        public float TEAMER_FOLLOW_DISTANCE_MAX = 4f;
        [DescAttribute("队员强制跟随距离（距离太远，直接瞬移到主人）", "战斗")]
        public float TEAMER_FOLLOW_DISTANCE_LIMIT = 8f;

        [DescAttribute("单位默认转身速度（弧度/秒）", "战斗")]
        public float UNIT_TURN_SPEED_SEC = 3.14f;
        [DescAttribute("单位允许被鞭尸", "战斗")]
        public bool UNIT_CAN_WHIPLASH_BODY = false;

        [DescAttribute("单位被击飞向上速度", "受击")]
        public float OBJECT_DAMAGE_FLY_ZSPEED_SEC = 10.0f;
        [DescAttribute("单位被击飞速度(距离/秒)", "受击")]
        public float OBJECT_DAMAGE_FLY_SPEED_SEC = 10.0f;
        [DescAttribute("单位被击飞加速度(距离/秒) => (速度=速度+加速度)", "受击")]
        public float OBJECT_DAMAGE_FLY_SPEED_ADD = 0f;
        [DescAttribute("单位被击飞阻力(每秒递减速度百分比)", "受击")]
        public float OBJECT_DAMAGE_FLY_SPEED_ACC = 0f;
        [DescAttribute("单位被击飞各项参数浮动值百分比", "受击")]
        public float OBJECT_DAMAGE_FLY_ARGS_FACTOR_PCT = 0f;
        [DescAttribute("单位受击时间(毫秒)", "受击")]
        public int OBJECT_DAMAGE_TIME_MS = 1000;


        [DescAttribute("每隔一段时间检测一下是否要追(防止抖动)", "AI")]
        public int AI_FOLLOW_AND_ATTACK_HOLD_TIME_MS = 1000;
        [DescAttribute("尝试追击过程中，调整射击范围(逃离)的比率", "AI")]
        public float AI_FOLLOW_AND_ATTACK_ADJUST_ESCAPE_PCT = 50;
        [DescAttribute("观察一定范围的触发器，固定时间固定检测周围变化", "AI")]
        public int AI_VIEW_TRIGGER_CHECK_TIME_MS = 1000;
        [DescAttribute("移动过程中每次AI变化的停顿时间", "AI")]
        public int AI_MOVE_AI_HOLD_TIME_MS = 1000;
        [DescAttribute("NPC每隔多长毫秒检测一次最大警戒距离", "AI")]
        public int AI_NPC_CHECK_IN_GUARD_LIMIT_TIME_MS = 500;
        [DescAttribute("NPC攻击间歇时，有多少几率检测旁边有人，并散开，防止堆积在一个点。（百分比）", "AI")]
        public float AI_NPC_ATTACK_IDLE_SCATTER_PCT = 300;
		[DescAttribute("NPC散开检测间隔", "AI")]
		public int AI_NPC_ATTACK_IDLE_INTERVAL = 3000;

		[DescAttribute("仇恨列表上限", "AI")]
        public int AI_HATE_SYSTEM_CAPACITY_MS = 50;
    }


    [MessageType(0x410B)]
    [DescAttribute("地块定义信息")]
    [Expandable]
    public class TerrainDefinitionMap : IExternalizable, ICloneable
    {
        [DescAttribute("地块定义")]
        [Expandable]
        public class MapBlockBrush : ICloneable
        {
            [ColorValueAttribute]
            [Desc("颜色值ARGB", "Key")]
            public int Value = ColorValueAttribute.COLOR_GREEN;
            [Desc("是否阻挡", "Key")]
            public bool IsBlock = true;
            [Desc("名字")]
            public string Name = "";
            [Desc("注释")]
            public string Desc = "";
            [Desc("Tag")]
            public string Tag = "";

            public MapBlockBrush() { }
            public MapBlockBrush(int value, bool is_block, string name)
            {
                this.Value = value;
                this.IsBlock = is_block;
                this.Name = name;
            }

            public object Clone()
            {
                MapBlockBrush ret = new MapBlockBrush();
                ret.Value = this.Value;
                ret.IsBlock = this.IsBlock;
                ret.Name = this.Name;
                ret.Desc = this.Desc;
                ret.Tag = this.Tag;
                return ret;
            }

            public override string ToString()
            {
                return string.Format("[{1}] {2} : {0}", Value.ToString("X8"), IsBlock ? "Block" : "Cross", Name);
            }
        }

        [NotNull]
        [ListAttribute(typeof(MapBlockBrush))]
        [Desc("地块定义列表")]
        public List<MapBlockBrush> Brushes = new List<MapBlockBrush>();

        public TerrainDefinitionMap()
        {
            Brushes.Add(new MapBlockBrush(0, false, "NULL"));
            Brushes.Add(new MapBlockBrush(ColorValueAttribute.COLOR_GREEN, true, "Block"));
            Brushes.Add(new MapBlockBrush(ColorValueAttribute.COLOR_DARK_GRAY, false, "Safe"));
        }

        /// <summary>
        /// 去从
        /// </summary>
        public bool ContainsValue(int value)
        {
            foreach (var b in Brushes)
            {
                if (b.Value == value)
                {
                    return true;
                }
            }
            return false;
        }
        public MapBlockBrush GetMapBlockBrush(int value)
        {
            foreach (var b in Brushes)
            {
                if (b.Value == value)
                {
                    return b;
                }
            }
            return null;
        }

        public object Clone()
        {
            TerrainDefinitionMap ret = new TerrainDefinitionMap();
            ret.Brushes = CUtils.CloneList<MapBlockBrush>(this.Brushes);
            return ret;
        }

        public void WriteExternal(IOutputStream output)
        {
            output.PutS32(Brushes.Count);
            foreach (var v in this.Brushes)
            {
                output.PutS32(v.Value);
                output.PutBool(v.IsBlock);
                output.PutUTF(v.Name);
                output.PutUTF(v.Desc);
                output.PutUTF(v.Tag);
            }
        }

        public void ReadExternal(IInputStream input)
        {
            Brushes.Clear();
            int count = input.GetS32();
            for (int i = 0; i < count; i++)
            {
                var v = new MapBlockBrush();
                v.Value = input.GetS32();
                v.IsBlock = input.GetBool();
                v.Name = input.GetUTF();
                v.Desc = input.GetUTF();
                v.Tag = input.GetUTF();
                Brushes.Add(v);
            }
        }
    }


    [MessageType(0x410C)]
    [DescAttribute("动作定义信息")]
    [Expandable]
    public class UnitActionDefinitionMap : IExternalizable, ICloneable
    {
        [DescAttribute("动作定义")]
        [Expandable]
        public class UnitAction : ICloneable, IExternalizable
        {
            [DescAttribute("动作", "动作")]
            public UnitActionStatus Action = UnitActionStatus.Idle;

            [ListAttribute(typeof(UnitActionKeyFrame))]
            [DescAttribute("动作序列", "动作")]
            public List<UnitActionKeyFrame> ActionQueue = new List<UnitActionKeyFrame>();

            public void WriteExternal(IOutputStream output)
            {
                output.PutEnum8(this.Action);
                output.PutStructList(this.ActionQueue);
            }
            public void ReadExternal(IInputStream input)
            {
                this.Action = input.GetEnum8<UnitActionStatus>();
                this.ActionQueue = input.GetStructList<UnitActionKeyFrame>();
            }
            public object Clone()
            {
                UnitAction ret = new UnitAction();
                ret.Action = this.Action;
                ret.ActionQueue = CUtils.CloneList(this.ActionQueue);
                return ret;
            }
            public override string ToString()
            {
                return string.Format("{0} : {1}", Action, CUtils.ListToString(ActionQueue));
            }
        }
        [DescAttribute("动作帧定义")]
        [Expandable]
        public class UnitActionKeyFrame : ICloneable, IExternalizable
        {
            [DescAttribute("动作名")]
            public string ActionName = "f_idle";
            [DescAttribute("播放时间（如果多段动作，则需要指定每段时间）")]
            public int TimeMS = 0;
            [DescAttribute("是否循环")]
            public bool Cycle = false;
            [DescAttribute("是否淡出")]
            public bool CrossFade = false;
            [DescAttribute("播放速度")]
            public float Speed = 1f;
            [DescAttribute("Tag")]
            public string Tag = "";

            public override string ToString()
            {
                return ActionName;
            }
            public void WriteExternal(IOutputStream output)
            {
                output.PutUTF(this.ActionName);
                output.PutS32(this.TimeMS);
                output.PutBool(this.Cycle);
                output.PutBool(this.CrossFade);
                output.PutF32(this.Speed);
                output.PutUTF(this.Tag);
            }
            public void ReadExternal(IInputStream input)
            {
                this.ActionName = input.GetUTF();
                this.TimeMS = input.GetS32();
                this.Cycle = input.GetBool();
                this.CrossFade = input.GetBool();
                this.Speed = input.GetF32();
                this.Tag = input.GetUTF();
            }
            public object Clone()
            {
                UnitActionKeyFrame ret = new UnitActionKeyFrame();
                ret.ActionName = this.ActionName;
                ret.TimeMS = this.TimeMS;
                ret.Cycle = this.Cycle;
                ret.CrossFade = this.CrossFade;
                ret.Speed = this.Speed;
                ret.Tag = this.Tag;
                return ret;
            }
        }

        [ListAttribute(typeof(UnitAction))]
        [DescAttribute("动作集合")]
        public List<UnitAction> ActionMap = new List<UnitAction>();

        public void WriteExternal(IOutputStream output)
        {
            output.PutStructList(this.ActionMap);
        }
        public void ReadExternal(IInputStream input)
        {
            this.ActionMap = input.GetStructList<UnitAction>();
        }
        public object Clone()
        {
            UnitActionDefinitionMap ret = new UnitActionDefinitionMap();
            ret.ActionMap = CUtils.CloneList(this.ActionMap);
            return ret;
        }

    }



    //---------------------------------------------------------------------------------//
    /// <summary>
    /// 场景基础数据
    /// </summary>
    [MessageType(0x4001)]
    public class ZoneInfo : IExternalizable, ICloneable
    {
        public int TemplateID { get { return ID; } }

        [DescAttribute("ID", "", false)]
        public int ID;
        /// <summary>
        /// 地图总宽
        /// </summary>
        public int TotalWidth { get { return mXCount * mGridCellW; } }
        /// <summary>
        /// 地图总高
        /// </summary>
        public int TotalHeight { get { return mYCount * mGridCellH; } }
        /// <summary>
        /// 所有地图碰撞块信息
        /// </summary>
        public int[,] TerrainMatrix { get { return mTerrainMatrix; } }
        /// <summary>
        /// 地图碰撞格宽
        /// </summary>
        public int GridCellW { get { return mGridCellW; } }
        /// <summary>
        /// 地图碰撞格高
        /// </summary>
        public int GridCellH { get { return mGridCellH; } }
        /// <summary>
        /// 地图横向格子数
        /// </summary>
        public int XCount { get { return mXCount; } }
        /// <summary>
        /// 地图纵向格子数
        /// </summary>
        public int YCount { get { return mYCount; } }

        //------------------------------------------------------------
        [DescAttribute("", "", false)]
        public int[,] mTerrainMatrix;

        [DescAttribute("", "", false)]
        public int mXCount;
        [DescAttribute("", "", false)]
        public int mYCount;

        [DescAttribute("", "", false)]
        public int mGridCellW;
        [DescAttribute("", "", false)]
        public int mGridCellH;
        //------------------------------------------------------------

        public ZoneInfo(int xcount, int ycount, int gridW, int gridH)
        {
            this.mXCount = xcount;
            this.mYCount = ycount;
            this.mGridCellW = gridW;
            this.mGridCellH = gridH;
            this.mTerrainMatrix = new int[xcount, ycount];
        }
        public ZoneInfo() { }
        public int GetID()
        {
            return ID;
        }

        public object Clone()
        {
            ZoneInfo ret = new ZoneInfo();
            ret.ID = this.ID;
            ret.mXCount = this.mXCount;
            ret.mYCount = this.mYCount;
            ret.mGridCellW = this.mGridCellW;
            ret.mGridCellH = this.mGridCellH;
            ret.mTerrainMatrix = new int[mXCount, mYCount];
            for (int x = 0; x < mXCount; x++)
            {
                for (int y = 0; y < mYCount; y++)
                {
                    ret.mTerrainMatrix[x, y] = this.mTerrainMatrix[x, y];
                }
            }
            return ret;
        }
        public bool TryGetFlag(int bx, int by, out int flag)
        {
            if (bx < mXCount && bx >= 0 && by < mYCount && by >= 0)
            {
                flag = mTerrainMatrix[bx, by];
                return true;
            }
            flag = 0;
            return false;
        }

        public void WriteExternal(IOutputStream output)
        {
            output.PutS32(ID);
            output.PutS32(mXCount);
            output.PutS32(mYCount);
            output.PutS32(mGridCellW);
            output.PutS32(mGridCellH);
            for (int x = 0; x < mXCount; x++)
            {
                for (int y = 0; y < mYCount; y++)
                {
                    output.PutS32(mTerrainMatrix[x, y]);
                }
            }
        }
        public void ReadExternal(IInputStream input)
        {
            this.ID = input.GetS32();
            this.mXCount = input.GetS32();
            this.mYCount = input.GetS32();
            this.mGridCellW = input.GetS32();
            this.mGridCellH = input.GetS32();
            this.mTerrainMatrix = new int[mXCount, mYCount];
            for (int x = 0; x < mXCount; x++)
            {
                for (int y = 0; y < mYCount; y++)
                {
                    this.mTerrainMatrix[x, y] = input.GetS32();
                }
            }
        }
    }



    //---------------------------------------------------------------------------------//

    #region __Templates_Data__

    //---------------------------------------------------------------------------------//

    /// <summary>
    /// 单位模板数据
    /// </summary>
    [MessageType(0x4002)]
    [DescAttribute("单位模板数据")]
    [TableClassAttribute("ID")]
    public class UnitInfo : ICloneable, ITemplateData, IExternalizable
    {
		protected static readonly Logger log = LoggerFactory.GetDefLogger();
		public int TemplateID { get { return ID; } }
        [XmlSerializable()]
        public string EditorPath { get; set; }
        /// <summary>
        /// 单位类型
        /// </summary>
        public enum UnitType : byte
        {
            [DescAttribute("玩家")]
            TYPE_PLAYER = 1,
            [DescAttribute("NPC")]
            TYPE_NPC = 2,
            [DescAttribute("怪物")]
            TYPE_MONSTER = 3,
            [DescAttribute("宠物")]
            TYPE_PET = 4,
            [DescAttribute("召唤物")]
            TYPE_SUMMON = 5,
            [DescAttribute("建筑")]
            TYPE_BUILDING = 6,
            [DescAttribute("脚本控制")]
            TYPE_MANUAL = 7,
            [DescAttribute("触发机关")]
            TYPE_TRIGGER = 8,
            [DescAttribute("中立无敌意")]
            TYPE_NEUTRALITY = 9,
        }
        //------------------------------------
        /// <summary>
        /// 单位类型
        /// </summary>
        [DescAttribute("单位类型", "基础")]
        public UnitType UType = UnitType.TYPE_MONSTER;
        [DescAttribute(
            "单位类型"
            + "\n PLAYER=1"
            + "\n NPC=2"
            + "\n MONSTER=3"
            + "\n PET=4"
            + "\n SUMMON=5"
            + "\n BUILDING=6"
            + "\n MANUAL=7"
            + "\n TRIGGER=8"
            + "\n NEUTRALITY=9",
            "基础")]
        public int UTypeAsInt { get { return (int)UType; } }


		public bool IsSummon { get { return UType == UnitType.TYPE_SUMMON; } }
		[DescAttribute("召唤类型", "基础")]
		[DependOnProperty("IsSummon")]
		public SummonType SumType = SummonType.none;

		/// <summary>
		/// 模板ID
		/// </summary>
		[DescAttribute("ID", "", false)]
        public int ID;
        /// <summary>
        /// 单位名字
        /// </summary>
        [LocalizationTextAttribute]
        [DescAttribute("单位名字", "基础")]
        public string Name;

        [DescAttribute("是否为精英怪", "基础")]
        public bool IsElite;

        //------------------------------------
        /// <summary>
        /// 对应的模型文件名
        /// </summary>
        [DescAttribute("对应的模型文件名", "资源")]
        [ResourceIDAttribute]
        public string FileName;

        [DescAttribute("怪物产生时触发的特效", "资源")]
        public LaunchEffect SpawnEffect;

        [DescAttribute("怪物脚底的特效", "资源")]
        public LaunchEffect FootCircleEffect;

        [DescAttribute("怪物死亡时触发的特效", "资源")]
        public LaunchEffect DeadEffect;

        [DescAttribute("怪物死亡动作播放结束后触发的特效", "资源")]
        public LaunchEffect DeadAnimationEndEffect;

        [DescAttribute("怪物烂掉时触发的特效", "资源")]
        public LaunchEffect RemovedEffect;

        [DescAttribute("怪物击碎时触发的特效", "资源")]
        public LaunchEffect CrushEffect;

        [DescAttribute("怪物受击时触发的特效", "资源")]
        public LaunchEffect DamageEffect;

        [DescAttribute("缩放比率", "资源")]
        public float BodyScale = 1;

		[DescAttribute("切换阵营特效", "资源")]
		public LaunchEffect ChangeForceEffect;

		[DescAttribute("破碎比例", "资源")]
		public int HitBreakPrecent;

		[DescAttribute("破碎特效", "资源")]
		public LaunchEffect HitBreakEffect;

        [DescAttribute("预加载资源列表", "资源")]
        public string PreloadResources;

        //------------------------------------
        /// <summary>
        /// 身体高度
        /// </summary>
        [DescAttribute("身体高度", "战斗")]
        public float BodyHeight;
        /// <summary>
        /// 身体尺寸（半径）
        /// </summary>
        [DescAttribute("身体尺寸（半径）", "战斗")]
        public float BodySize = 1;
        /// <summary>
        /// 警戒距离范围
        /// </summary>
        [DescAttribute("身体受攻击尺寸（半径）", "战斗")]
        public float BodyHitSize = 1;
        //------------------------------------
        /// <summary>
        /// 警戒距离范围
        /// </summary>
        [DescAttribute("警戒距离范围", "战斗 - 警戒")]
        public float GuardRange = 5;
        [DescAttribute("最大警戒范围，超过此范围不追击，0表示无限", "战斗 - 警戒")]
        public float GuardRangeLimit = 20;
        [DescAttribute("分组警戒范围，如果此单位进入战斗，则传给相邻单位Add，0表示不传递", "战斗 - 警戒")]
        public float GuardRangeGroup = 5;

        public bool IdleRecover { get { return RecoveryIntervalMS > 0; } }

        [DescAttribute("恢复间隔(毫秒)，脱离战斗后回血间隔时间", "战斗 - 恢复")]
        public int RecoveryIntervalMS = 10000;
        [DescAttribute("血量恢复/秒", "战斗 - 恢复")]
        [DependOnProperty("IdleRecover")]
        public int HealthRecoveryPoint = 0;
        [DescAttribute("法力恢复/秒", "战斗 - 恢复")]
        [DependOnProperty("IdleRecover")]
        public int ManaRecoveryPoint = 0;
        //------------------------------------

        [DescAttribute("体重(>=100不能被击飞)", "战斗")]
        public int Weight = 1;

        [DescAttribute("是否可移动", "战斗")]
        public bool IsMoveable = true;

        [DescAttribute("是否可转向", "战斗")]
        public bool IsTurnable = true;

        //------------------------------------

        /// <summary>
        /// 移动距离，像素或者码
        /// </summary>
        [DescAttribute("移动速度(距离/每秒)", "战斗")]
        public float MoveSpeedSEC = 6f;

        [DescAttribute("转身速度（弧度/秒）", "战斗")]
        public float TurnSpeedSEC = float.NaN;

        [DescAttribute("受击时间(毫秒)", "战斗")]
        public int DamageTimeMS = 10;

        //------------------------------------
        /// <summary>
        /// 此单位普通攻击技能
        /// </summary>
        [DescAttribute("此单位普通攻击技能", "技能")]
        public LaunchSkill BaseSkillID = new LaunchSkill();
        /// <summary>
        /// 此单位绑定的所有技能ID
        /// </summary>
        [ListAttribute(typeof(LaunchSkill))]
        [DescAttribute("此单位绑定的所有技能ID", "技能")]
        public List<LaunchSkill> Skills = new List<LaunchSkill>();
        /// <summary>
        /// 触发类特效
        /// </summary>
        [ListAttribute(typeof(LaunchTrigger))]
        [DescAttribute("触发类", "技能")]
        public List<LaunchTrigger> Triggers = new List<LaunchTrigger>();
        //------------------------------------

        //------------------------------------
        [DescAttribute("法术发射高度（炮口高度）", "炮口")]
        public float LaunchSpellHeight;
        [DescAttribute("法术发射半径（炮口半径）", "炮口")]
        public float LaunchSpellRadius = 0;

        //------------------------------------

        [DescAttribute("死亡时释放法术（自爆）", "战斗")]
        public LaunchSpell DeadLaunchSpell = null;

        [DescAttribute("死亡时释放法术（灵魂出窍）", "战斗")]
        public LaunchSpell DeadDelayLaunchSpell = null;

        //------------------------------------
        [DescAttribute("血量", "战斗")]
        public int HealthPoint = 100;
        [DescAttribute("法力值", "战斗")]
        public int ManaPoint = 100;
        [DescAttribute("耐力值", "战斗")]
        public int StaminaPoint = 100;
        [DescAttribute("产生经验", "战斗")]
        public int GenExp;
        //------------------------------------
        /// <summary>
        /// 掉落道具列表
        /// </summary>
        [ListAttribute(typeof(DropItemList))]
        [DescAttribute("掉落道具", "掉落")]
        public List<DropItemList> DropItemsSet = new List<DropItemList>();

        [DescAttribute("被杀死直接获得金币", "掉落")]
        public int DropMoney;
        //------------------------------------

        [DescAttribute("单位背包数量", "背包")]
        public int InventorySize = 1;

        [ListAttribute(typeof(InventoryItem))]
        [DescAttribute("进入战斗携带的道具列表（比如血瓶）", "背包")]
        public List<InventoryItem> InventoryList = new List<InventoryItem>();

        //------------------------------------
        /// <summary>
        /// 若是召唤类，则表示存活时间
        /// </summary>
        [DescAttribute("若是召唤类，则表示存活时间(毫秒)", "战斗")]
        public int LifeTimeMS;
        /// <summary>
        /// 单位出生延时时间，通常播放出生动画
        /// </summary>
        [DescAttribute("单位出生延时时间，通常播放出生动画(毫秒)", "战斗")]
        public int SpawnTimeMS;
        /// <summary>
        /// 持续时间
        /// </summary>
        [DescAttribute("单位死亡持续时间，即死亡后多长时间内可继续鞭尸(毫秒)", "战斗")]
        public int DeadTimeMS;
        /// <summary>
        /// 
        /// </summary>
        [DescAttribute("单位死亡之后延迟时间(毫秒)，播放 DeadDelayLaunchSpell 特效", "战斗")]
        public int DeadDelayTimeMS;
        /// <summary>
        /// 
        /// </summary>
        [DescAttribute("播放 DeadDelayLaunchSpell 特效的数量", "战斗")]
        public int DeadDelaySpellNumber;

        public bool HasNumbers
        {
            get { return DeadDelaySpellNumber > 1; }
        }

        /// <summary>
        /// 
        /// </summary>
        [DescAttribute("播放每一个 DeadDelayLaunchSpell 间隔的时间(单位:毫秒)", "战斗")]
        [DependOnProperty("HasNumbers")]
        public int DeadDelaySpellIntervalMS;
        /// <summary>
        /// 复活时间
        /// </summary>
        [DescAttribute("死亡后多久复活，0表示不能复活(毫秒)", "战斗")]
        public int RebirthTimeMS;
        //------------------------------------
        [DescAttribute("用户自定义标志", "脚本")]
        public string UserTag;
        //------------------------------------

        [DescAttribute("是否为动态创建单位，比如PVP或者根据玩家等级创建的单位", "扩展")]
        public bool IsDynamic = false;

		[DescAttribute("是否随机名字", "扩展")]
		public bool IsRandomName = false;
		//------------------------------------

		[DescAttribute("单位绑定触发事件ID", "事件")]
        [TemplatesIDAttribute(typeof(UnitEventTemplate))]
        public List<int> Events = new List<int>();

        //------------------------------------
        /// <summary>
        /// 用户自定义扩展属性
        /// </summary>
        [DescAttribute("扩展属性", "扩展")]
        [Expandable]
        [NotNull]
        public IUnitProperties Properties;
        //------------------------------------

        [DescAttribute("自定义字段", "属性", true)]
        public string[] Attributes;
        //------------------------------------

        public UnitInfo()
        {
            Properties = TemplateManager.Factory.CreateUnitProperties();
        }
        public int GetID()
        {
            return ID;
        }
        public override string ToString()
        {
            return Name + "(" + ID + ")";
        }
        public object Clone()
        {
            UnitInfo ret = new UnitInfo();
            ret.EditorPath = this.EditorPath;

            ret.UType = this.UType;
            ret.ID = this.ID;
            ret.Name = this.Name;
            ret.IsElite = this.IsElite;
            ret.FileName = this.FileName;

            ret.SpawnEffect = CUtils.TryClone<LaunchEffect>(this.SpawnEffect);
            ret.FootCircleEffect = CUtils.TryClone<LaunchEffect>(this.FootCircleEffect);
            ret.DeadEffect = CUtils.TryClone<LaunchEffect>(this.DeadEffect);
            ret.RemovedEffect = CUtils.TryClone<LaunchEffect>(this.RemovedEffect);
            ret.DeadAnimationEndEffect = CUtils.TryClone<LaunchEffect>(this.DeadAnimationEndEffect);
            ret.CrushEffect = CUtils.TryClone<LaunchEffect>(this.CrushEffect);
            ret.DamageEffect = CUtils.TryClone<LaunchEffect>(this.DamageEffect);
            ret.BodyScale = this.BodyScale;

            ret.BodyHeight = this.BodyHeight;
            ret.BodySize = this.BodySize;
            ret.BodyHitSize = this.BodyHitSize;

            ret.GuardRange = this.GuardRange;
            ret.GuardRangeLimit = this.GuardRangeLimit;
            ret.GuardRangeGroup = this.GuardRangeGroup;
            ret.HealthRecoveryPoint = this.HealthRecoveryPoint;
            ret.ManaRecoveryPoint = this.ManaRecoveryPoint;
            ret.RecoveryIntervalMS = this.RecoveryIntervalMS;

            ret.Weight = this.Weight;
            ret.MoveSpeedSEC = this.MoveSpeedSEC;
            ret.TurnSpeedSEC = this.TurnSpeedSEC;
            ret.DamageTimeMS = this.DamageTimeMS;
            ret.IsMoveable = this.IsMoveable;
            ret.IsTurnable = this.IsTurnable;

            ret.BaseSkillID = CUtils.TryClone<LaunchSkill>(this.BaseSkillID);

            ret.Skills = CUtils.CloneList<LaunchSkill>(this.Skills);
            ret.Triggers = CUtils.CloneList<LaunchTrigger>(this.Triggers);

            ret.LaunchSpellHeight = this.LaunchSpellHeight;
            ret.LaunchSpellRadius = this.LaunchSpellRadius;
            ret.DeadLaunchSpell = this.DeadLaunchSpell;
            ret.DeadDelayLaunchSpell = this.DeadDelayLaunchSpell;

            ret.HealthPoint = this.HealthPoint;
            ret.ManaPoint = this.ManaPoint;
            ret.StaminaPoint = this.StaminaPoint;
            ret.GenExp = this.GenExp;

            ret.DropItemsSet = CUtils.CloneList<DropItemList>(this.DropItemsSet);

            ret.DropMoney = this.DropMoney;

            ret.InventorySize = this.InventorySize;
            ret.InventoryList = CUtils.CloneList<InventoryItem>(this.InventoryList);

            ret.LifeTimeMS = this.LifeTimeMS;
            ret.SpawnTimeMS = this.SpawnTimeMS;
            ret.DeadTimeMS = this.DeadTimeMS;
            ret.DeadDelayTimeMS = this.DeadDelayTimeMS;
            ret.DeadDelaySpellNumber = this.DeadDelaySpellNumber;
            ret.DeadDelaySpellIntervalMS = this.DeadDelaySpellIntervalMS;
            ret.RebirthTimeMS = this.RebirthTimeMS;
            ret.UserTag = this.UserTag;
            ret.IsDynamic = this.IsDynamic;

            ret.Events = new List<int>(this.Events);

            ret.Properties = CUtils.TryClone<IUnitProperties>(this.Properties);// (IUnitProperties)this.Properties.Clone();
            ret.Attributes = CUtils.CloneArray<string>(this.Attributes);
			ret.HitBreakPrecent = this.HitBreakPrecent;
			ret.HitBreakEffect = CUtils.TryClone<LaunchEffect>(this.HitBreakEffect);
			ret.ChangeForceEffect = CUtils.TryClone<LaunchEffect>(this.ChangeForceEffect);
			ret.HitBreakPrecent = this.HitBreakPrecent;
			ret.HitBreakEffect = this.HitBreakEffect;
			ret.IsRandomName = this.IsRandomName;
			ret.SumType = this.SumType;
            ret.PreloadResources = this.PreloadResources;
			return ret;
        }

        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.EditorPath);
            output.PutEnum8(this.UType);
            output.PutS32(this.ID);
            output.PutUTF(this.Name);
            output.PutBool(this.IsElite);
            output.PutUTF(this.FileName);

            output.PutExt(this.SpawnEffect);
            output.PutExt(this.FootCircleEffect);
            output.PutExt(this.DeadEffect);
            output.PutExt(this.RemovedEffect);
            output.PutExt(this.DeadAnimationEndEffect);
            output.PutExt(this.CrushEffect);
            output.PutExt(this.DamageEffect);
            output.PutF32(this.BodyScale);

            output.PutF32(this.BodyHeight);
            output.PutF32(this.BodySize);
            output.PutF32(this.BodyHitSize);

            output.PutF32(this.GuardRange);
            output.PutF32(this.GuardRangeLimit);
            output.PutF32(this.GuardRangeGroup);
            output.PutS32(this.RecoveryIntervalMS);
            output.PutS32(this.HealthRecoveryPoint);
            output.PutS32(this.ManaRecoveryPoint);

            output.PutS32(this.Weight);
            output.PutF32(this.MoveSpeedSEC);
            output.PutF32(this.TurnSpeedSEC);
            output.PutS32(this.DamageTimeMS);
            output.PutBool(this.IsMoveable);
            output.PutBool(this.IsTurnable);

            output.PutExt(this.BaseSkillID);

            output.PutList<LaunchSkill>(this.Skills, output.PutExt);
            output.PutList<LaunchTrigger>(this.Triggers, output.PutExt);

            output.PutF32(this.LaunchSpellHeight);
            output.PutF32(this.LaunchSpellRadius);
            output.PutExt(this.DeadLaunchSpell);
            output.PutExt(this.DeadDelayLaunchSpell);
            output.PutS32(this.HealthPoint);
            output.PutS32(this.ManaPoint);
            output.PutS32(this.StaminaPoint);
            output.PutS32(this.GenExp);

            output.PutList<DropItemList>(this.DropItemsSet, output.PutExt);

            output.PutS32(this.DropMoney);
            output.PutS32(this.InventorySize);
            output.PutList<InventoryItem>(this.InventoryList, output.PutExt);

            output.PutS32(this.LifeTimeMS);
            output.PutS32(this.SpawnTimeMS);
            output.PutS32(this.DeadTimeMS);
            output.PutS32(this.DeadDelayTimeMS);
            output.PutS32(this.DeadDelaySpellNumber);
            output.PutS32(this.DeadDelaySpellIntervalMS);
            output.PutS32(this.RebirthTimeMS);
            output.PutUTF(this.UserTag);
            output.PutBool(this.IsDynamic);

            output.PutList(this.Events, output.PutS32);
            output.PutArray(this.Attributes, output.PutUTF);

            output.PutExt(this.Properties);

			//破碎，切阵营
			output.PutExt(this.ChangeForceEffect);
			output.PutS32(this.HitBreakPrecent);
			output.PutExt(this.HitBreakEffect);

			// 随机名字
			output.PutBool(this.IsRandomName);
			output.PutEnum8(this.SumType);

            output.PutUTF(this.PreloadResources);
		}

        public void ReadExternal(IInputStream input)
        {
            this.EditorPath = input.GetUTF();
            this.UType = input.GetEnum8<UnitType>();
            this.ID = input.GetS32();
            this.Name = input.GetUTF();
            this.IsElite = input.GetBool();
            this.FileName = input.GetUTF();

            this.SpawnEffect = input.GetExt<LaunchEffect>();
            this.FootCircleEffect = input.GetExt<LaunchEffect>();
            this.DeadEffect = input.GetExt<LaunchEffect>();
            this.RemovedEffect = input.GetExt<LaunchEffect>();
            this.DeadAnimationEndEffect = input.GetExt<LaunchEffect>();
            this.CrushEffect = input.GetExt<LaunchEffect>();
            this.DamageEffect = input.GetExt<LaunchEffect>();
            this.BodyScale = input.GetF32();

            this.BodyHeight = input.GetF32();
            this.BodySize = input.GetF32();
            this.BodyHitSize = input.GetF32();

            this.GuardRange = input.GetF32();
            this.GuardRangeLimit = input.GetF32();
            this.GuardRangeGroup = input.GetF32();
            this.RecoveryIntervalMS = input.GetS32();
            this.HealthRecoveryPoint = input.GetS32();
            this.ManaRecoveryPoint = input.GetS32();


            this.Weight = input.GetS32();
            this.MoveSpeedSEC = input.GetF32();
            this.TurnSpeedSEC = input.GetF32();
            this.DamageTimeMS = input.GetS32();
            this.IsMoveable = input.GetBool();
            this.IsTurnable = input.GetBool();

            this.BaseSkillID = input.GetExt<LaunchSkill>();

            this.Skills = input.GetList<LaunchSkill>(input.GetExt<LaunchSkill>);
            this.Triggers = input.GetList<LaunchTrigger>(input.GetExt<LaunchTrigger>);

            this.LaunchSpellHeight = input.GetF32();
            this.LaunchSpellRadius = input.GetF32();
            this.DeadLaunchSpell = input.GetExt<LaunchSpell>();
            this.DeadDelayLaunchSpell = input.GetExt<LaunchSpell>();
            this.HealthPoint = input.GetS32();
            this.ManaPoint = input.GetS32();
            this.StaminaPoint = input.GetS32();
            this.GenExp = input.GetS32();

            this.DropItemsSet = input.GetList<DropItemList>(input.GetExt<DropItemList>);

            this.DropMoney = input.GetS32();
            this.InventorySize = input.GetS32();
            this.InventoryList = input.GetList<InventoryItem>(input.GetExt<InventoryItem>);

            this.LifeTimeMS = input.GetS32();
            this.SpawnTimeMS = input.GetS32();
            this.DeadTimeMS = input.GetS32();
            this.DeadDelayTimeMS = input.GetS32();
            this.DeadDelaySpellNumber = input.GetS32();
            this.DeadDelaySpellIntervalMS = input.GetS32();
            this.RebirthTimeMS = input.GetS32();
            this.UserTag = input.GetUTF();
            this.IsDynamic = input.GetBool();

            this.Events = input.GetList<int>(input.GetS32);
            this.Attributes = input.GetUTFArray();

            this.Properties = input.GetExt<IUnitProperties>(this.Properties);

			this.ChangeForceEffect = input.GetExt<LaunchEffect>();
			this.HitBreakPrecent = input.GetS32();
			this.HitBreakEffect = input.GetExt<LaunchEffect>();

			this.IsRandomName = input.GetBool();
			this.SumType = input.GetEnum8<SummonType>();

            this.PreloadResources = input.GetUTF();

			if (UType == UnitType.TYPE_NPC && this.RecoveryIntervalMS > 0)
			{
				log.Debug("NPC配置了恢复时间, 强行重置" + this.ID);
				this.RecoveryIntervalMS = 0;
			}
		}

        public LaunchSkill GetSkillByID(int skillID)
        {
            if (BaseSkillID != null && skillID == BaseSkillID.SkillID)
            {
                return BaseSkillID;
            }
            if (Skills != null)
            {
                for (int i = 0; i < Skills.Count; i++)
                {
                    if (Skills[i].SkillID == skillID)
                    {
                        return Skills[i];
                    }
                }
            }
            return null;
        }
    }

    //---------------------------------------------------------------------------------//


    /// <summary>
    /// 技能模板
    /// </summary>
    [MessageType(0x4003)]
    [DescAttribute("技能模板")]
    [TableClassAttribute("ID")]
    public class SkillTemplate : ICloneable, ITemplateData, IExternalizable
    {
        public int TemplateID { get { return ID; } }
        [XmlSerializable()]
        public string EditorPath { get; set; }

        // 技能ID
        [DescAttribute("ID", "", false)]
        public int ID;

        /// <summary>
        /// 技能名字
        /// </summary>
        [LocalizationTextAttribute]
        [DescAttribute("技能名字", "基础")]
        public string Name;

        [DescAttribute("技能冷却时间(毫秒)", "基础")]
        [DependOnProperty("IsCoolDownWithAction", false)]
        public int CoolDownMS = 6000;
        //------------------------------------
        [DescAttribute("技能图标", "资源")]
        public string IconName;
        //------------------------------------
        /// <summary>
        /// 攻击动作序列
        /// </summary>
        [DescAttribute("攻击动作序列", "动作")]
        [ListAttribute(typeof(UnitActionData))]
        public List<UnitActionData> ActionQueue = new List<UnitActionData>();

        [DescAttribute("以动作时间作为冷却时间, 普攻使用", "动作")]
        //只能普攻使用
        public bool IsCoolDownWithAction = false;
        [DescAttribute("可以打断其他技能和受击状态，受身技能", "动作")]
        public bool IsCounter = false;
        [DescAttribute("技能优先级，高优先级可打断低优先级", "动作")]
        public int ActionPriority = 0;

        [DescAttribute("动作播放速率", "动作")]
        public float ActionSpeedRate = 1f;

        [DescAttribute("技能释放期间，模型缩放（仅客户端有效）", "动作")]
        public float BodyScale = 1f;

        [DescAttribute("技能释放期间，可手动撤销", "动作")]
        public bool IsManuallyCancelable = false;

        [DescAttribute("忽略本技能释放中不可打断的时间段（只用作客户端显示用）", "动作")]
        public bool IgnoreMyUncancelable = false;

        //------------------------------------
        [DescAttribute("每次释放只做一个动作，多段攻击", "多段攻击")]
        public bool IsSingleAction = false;
        [DependOnProperty("IsSingleAction")]
        [DescAttribute("多段攻击间隔有效时间", "多段攻击")]
        public int SingleActionCoolDownMS = 500;
        //------------------------------------

        [DescAttribute("攻击距离", "攻击范围")]
        public float AttackRange = 3;
        [DescAttribute("攻击角度范围（弧度）\n如果角度为0，则为单体攻击", "攻击范围")]
        public float AttackAngle = 0;
        [DescAttribute("单体攻击，只在目标处于攻击范围才产生伤害", "攻击范围")]
        public bool AttackMustBeInRange = true;
        [DescAttribute("保持攻击距离（NPC会保持一段距离再攻击）大于0启效", "攻击范围")]
        public float AttackKeepRange = 0;
		[DescAttribute("自动战斗，跟随目标", "攻击范围")]
		public bool AutoFightFollower = false;

		//------------------------------------
		[DescAttribute("技能当前储存次数")]
        public short CurUseTimes = -1;

        [DescAttribute("法术是否从自己身上发出", "释放")]
        public bool IsLaunchBody = true;

        [DescAttribute("吟唱时间（毫秒）大于0启效", "释放")]
        public int ChantTimeMS = 0;
        //------------------------------------
        public enum CastTarget : byte
        {
            [DescAttribute("敌人")]
            Enemy = 0,
            [DescAttribute("友军")]
            Alias = 1,
            [DescAttribute("自己")]
            Self = 2,
            [DescAttribute("宠物为主人")]
            PetForMaster = 3,
            [DescAttribute("任何单位")]
            EveryOne = 4,
            [DescAttribute("无类型")]
            NA = 5,
            [DescAttribute("除自己之外友军")]
            AlliesExcludeSelf = 6,
            [DescAttribute("包括自己友军")]
            AlliesIncludeSelf = 7,
            [DescAttribute("除自己之外所有")]
            EveryOneExcludeSelf = 8,
			[DescAttribute("自己和敌人")]
			EnemyAndSelf = 9,
		}
        [DescAttribute("技能期望作用目标", "释放")]
        public CastTarget ExpectTarget = CastTarget.Enemy;

        //------------------------------------

        public enum SelectRange : byte
        {
            [DescAttribute("无")]
            NA,
            [DescAttribute("圆形区域")]
            Round,
            [DescAttribute("直线")]
            Line,
            [DescAttribute("矩形区域")]
            Rect,
            [DescAttribute("扇形区域")]
            Fan,
        }

        //------------------------------------

        [DescAttribute("释放时是否选择方向", "释放范围")]
        public bool IsSelectRange = false;
        [DependOnProperty("IsSelectRange")]
        [DescAttribute("选择方向类型", "释放范围")]
        public SelectRange SelectRangeType = SelectRange.NA;
        [DependOnProperty("IsSelectRange")]
        [DescAttribute("选择方向尺寸", "释放范围")]
        public float SelectRangeSize;


        //------------------------------------

        [DescAttribute("释放消耗血量", "消耗")]
        public int CostHP;
        [DescAttribute("释放消耗法力", "消耗")]
        public int CostMP;

        //------------------------------------
        /// <summary>
        /// 用户自定义扩展属性
        /// </summary>
        [DescAttribute("扩展属性", "扩展")]
        [Expandable]
        [NotNull]
        public ISkillProperties Properties = TemplateManager.Factory.CreateSkillProperties();
        //------------------------------------

        public SkillTemplate() { }
        public SkillTemplate(int id)
        {
            this.ID = id;
        }
        public int GetID()
        {
            return ID;
        }
        public override string ToString()
        {
            return Name + "(" + ID + ")";
        }

        public UnitActionData GetActionByName(string name)
        {
            foreach (UnitActionData act in ActionQueue)
            {
                if (name.Equals(act.ActionName))
                {
                    return act;
                }
            }
            return null;
        }
        public int ToUnitSkillTotalTime(float fastCastRate)
        {
            return (int)(this.CoolDownMS * Math.Max(0, 1f - fastCastRate));
        }

        public int ActionQueueTimeMS
        {
            get
            {
                int ret = 0;
                for (int i = 0; i < ActionQueue.Count; i++)
                {
                    ret += ActionQueue[i].TotalTimeMS;
                }
                return ret;
            }
        }

        public int[] ActionQueueTimeArray
        {
            get
            {
                int[] ret = new int[ActionQueue.Count];
                for (int i = ret.Length - 1; i >= 0; --i)
                {
                    ret[i] = ActionQueue[i].TotalTimeMS;
                }
                return ret;
            }
        }

        public object Clone()
        {
            SkillTemplate ret = new SkillTemplate();
            ret.EditorPath = this.EditorPath;
            ret.ID = this.ID;
            ret.Name = this.Name;
            ret.IconName = this.IconName;
            ret.ActionQueue = CUtils.CloneList<UnitActionData>(this.ActionQueue);
            ret.IsSingleAction = this.IsSingleAction;
            ret.SingleActionCoolDownMS = this.SingleActionCoolDownMS;
            ret.IsCoolDownWithAction = this.IsCoolDownWithAction;
            ret.IsCounter = this.IsCounter;
            ret.ActionPriority = this.ActionPriority;
            ret.CoolDownMS = this.CoolDownMS;
            ret.ActionSpeedRate = this.ActionSpeedRate;
            ret.IsManuallyCancelable = this.IsManuallyCancelable;
            ret.IgnoreMyUncancelable = this.IgnoreMyUncancelable;
            ret.BodyScale = this.BodyScale;

            ret.AttackRange = this.AttackRange;
            ret.AttackAngle = this.AttackAngle;
            ret.AttackMustBeInRange = this.AttackMustBeInRange;
            ret.AttackKeepRange = this.AttackKeepRange;
			ret.AutoFightFollower = this.AutoFightFollower;

			ret.IsLaunchBody = this.IsLaunchBody;
            ret.ChantTimeMS = this.ChantTimeMS;
            ret.IsSelectRange = this.IsSelectRange;
            ret.SelectRangeType = this.SelectRangeType;
            ret.SelectRangeSize = this.SelectRangeSize;
            ret.CostHP = this.CostHP;
            ret.CostMP = this.CostMP;
            ret.ExpectTarget = this.ExpectTarget;
            //ret.CurUseTimes = this.CurUseTimes;
            ret.Properties = CUtils.TryClone<ISkillProperties>(this.Properties);
            return ret;
        }

        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.EditorPath);
            output.PutS32(this.ID);
            output.PutUTF(this.Name);
            output.PutUTF(this.IconName);
            output.PutList(this.ActionQueue, output.PutExt);
            output.PutBool(this.IsSingleAction);
            output.PutS32(this.SingleActionCoolDownMS);
            output.PutBool(this.IsCoolDownWithAction);
            output.PutBool(this.IsCounter);
            output.PutS32(this.ActionPriority);
            output.PutS32(this.CoolDownMS);
            output.PutF32(this.ActionSpeedRate);
            output.PutBool(this.IsManuallyCancelable);
            output.PutBool(this.IgnoreMyUncancelable);
            output.PutF32(this.BodyScale);

            output.PutF32(this.AttackRange);
            output.PutF32(this.AttackAngle);
            output.PutBool(this.AttackMustBeInRange);
            output.PutF32(this.AttackKeepRange);
			output.PutBool(this.AutoFightFollower);

            output.PutBool(this.IsLaunchBody);
            output.PutS32(this.ChantTimeMS);
            output.PutBool(this.IsSelectRange);
            output.PutEnum8(this.SelectRangeType);
            output.PutF32(this.SelectRangeSize);
            output.PutS32(this.CostHP);
            output.PutS32(this.CostMP);
            output.PutEnum8(this.ExpectTarget);
            output.PutS16(this.CurUseTimes);
            output.PutExt(this.Properties);
        }

        public void ReadExternal(IInputStream input)
        {
            this.EditorPath = input.GetUTF();
            this.ID = input.GetS32();
            this.Name = input.GetUTF();
            this.IconName = input.GetUTF();
            this.ActionQueue = input.GetList<UnitActionData>(input.GetExt<UnitActionData>);
            this.IsSingleAction = input.GetBool();
            this.SingleActionCoolDownMS = input.GetS32();
            this.IsCoolDownWithAction = input.GetBool();
            this.IsCounter = input.GetBool();
            this.ActionPriority = input.GetS32();
            this.CoolDownMS = input.GetS32();
            this.ActionSpeedRate = input.GetF32();
            this.IsManuallyCancelable = input.GetBool();
            this.IgnoreMyUncancelable = input.GetBool();
            this.BodyScale = input.GetF32();

            this.AttackRange = input.GetF32();
            this.AttackAngle = input.GetF32();
            this.AttackMustBeInRange = input.GetBool();
            this.AttackKeepRange = input.GetF32();
			this.AutoFightFollower = input.GetBool();
			
			this.IsLaunchBody = input.GetBool();
            this.ChantTimeMS = input.GetS32();
            this.IsSelectRange = input.GetBool();
            this.SelectRangeType = input.GetEnum8<SelectRange>();
            this.SelectRangeSize = input.GetF32();
            this.CostHP = input.GetS32();
            this.CostMP = input.GetS32();
            this.ExpectTarget = input.GetEnum8<CastTarget>();
            this.CurUseTimes = input.GetS16();
            this.Properties = input.GetExt<ISkillProperties>(this.Properties);
        }


    }

    //---------------------------------------------------------------------------------//

    /// <summary>
    /// 单位动作模板
    /// </summary>
    [MessageType(0x4004)]
    [DescAttribute("单位动作")]
    [Expandable]
    public class UnitActionData : ICloneable, IExternalizable
    {
        [DescAttribute("总动作时间(毫秒)", "Action")]
        public int TotalTimeMS;
        [DescAttribute("动作播放速率增加（加法）", "动作")]
        public float ActionSpeedRate = 0.0f;
        [DescAttribute("单一动作类型,0-普通， 1，蓄力动作，2-多段式动作", "Action")]
        //蓄力动作，显示倒计时圈
        //多段式动作，显示倒计时圈 + 倒计时
        public ActionEnum SigleActionType;
        [DescAttribute("动作名字, IsSingleAction=false才有效", "Action")]
        public string ActionName;
        [DependOnProperty("IsControlMoveable", true)]
        [DescAttribute("移动动作名字", "Action")]
        public string MoveActionName;
        [DescAttribute("动作对应的特效，通常用作刀光", "Action")]
        [ResourceIDAttribute]
        public string ActionEffectFileName;
        [DescAttribute("动作是否循环", "Action")]
        public bool IsCycAction;
        [DescAttribute("显示蓄力倒计时条时间（毫秒）", "Action")]
        public int ShowChargeTimeMS = 0;


        [DescAttribute("移动可取消动作", "状态")]
        public bool IsCancelable = false;
        [DescAttribute("技能可取消动作", "状态")]
        public bool IsCancelableBySkill = false;
        [DescAttribute("技能能否被下一段替代", "状态")]
        public bool IsCancelBySkillNext = false;

        [DescAttribute("是否进入霸体状态，不会被打断", "状态")]
        public bool IsNoneBlock = false;
        [DescAttribute("动作期间是否无碰撞", "状态")]
        public bool IsNoneTouch = false;
        [DescAttribute("动作中是否面向目标", "状态")]
        public bool IsFaceToTarget = true;
        [DescAttribute("动作是否隐身", "状态")]
        public bool IsInvisible = false;
        [DescAttribute("动作中是否可以控制移动", "状态")]
        public bool IsControlMoveable = false;
        [DescAttribute("动作中可以控制转向", "状态")]
        public bool IsControlFaceable = false;

        //新增动作对应Icon
        [DescAttribute("是否换图", "资源")]
        public bool IsChangeIcon = false;
        [DescAttribute("图片名字", "资源")]
        [DependOnProperty("IsChangeIcon", true)]
        public string IconName;

        [DescAttribute("攻击范围改变", "攻击范围")]
        public AttackShape OverrideAttackShape;

        /// <summary>
        /// 所有关键帧
        /// </summary>
        [ListAttribute(typeof(KeyFrame))]
        [DescAttribute("所有关键帧", "关键帧")]
        public List<KeyFrame> KeyFrames = new List<KeyFrame>();

        public bool IsBodyHit
        {
            get
            {
                if (IsMoveToTarget) return false;
                if (IsJumpToTarget) return false;
                return BodyHit != null;
            }
        }
        /// <summary>
        /// 身体攻击判定
        /// </summary>
        [DependOnProperty("IsMoveToTarget", false)]
        [DependOnProperty("IsJumpToTarget", false)]
        [DescAttribute("身体攻击判定", "身体攻击")]
        public AttackProp BodyHit;
        [DependOnProperty("IsBodyHit")]
        [DescAttribute("身体攻击判定范围", "身体攻击")]
        public float BodyHitSize;
        [DependOnProperty("IsBodyHit")]
        [DescAttribute("身体攻击后立即切换动作", "身体攻击")]
        public bool BodyHitNextAction;

        [DescAttribute("移动到目标", "位移 - 冲锋")]
        public bool IsMoveToTarget = false;
        [DescAttribute("移动到目标速度", "位移 - 冲锋")]
        [DependOnProperty("IsMoveToTarget")]
        public float MoveToTargetSpeedSEC = 10;

        [DescAttribute("移动到目标根据(距离/动作时间)来算速度，如果目标在原地，则原地跳跃。", "位移 - 跳跃")]
        [DependOnProperty("IsMoveToTarget", false)]
        public bool IsJumpToTarget = false;
        [DescAttribute("跳跃高度", "位移 - 跳跃")]
        [DependOnProperty("IsJumpToTarget")]
        public float JumpToTargetHeightZ = 1;

        [DescAttribute("在攻击范围内，如果位移则挤开目标", "碰撞")]
        [DependOnProperty("IsMoveToTarget", false)]
        [DependOnProperty("IsJumpToTarget", false)]
        public bool BodyBlockOnAttackRange = false;

        [DescAttribute("显示技能引导光圈(必须先打开扩展属性中的ShowLaunchGuide)", "控制")]
        public bool IsShowSkillGuide = false;

        [DescAttribute("增加技能按钮遮罩", "资源")]
        public bool IsAddSkillBtnBlock = false;

        [DescAttribute("动作的音效文件名", "资源")]
        public string ActionAudioName;
        [DescAttribute("动作的音效文件是否循环播放", "资源")]
        public bool IsAudioLoop;

        public UnitActionData() { }
        public override string ToString()
        {
            return "动作: " + ActionName + " (" + TotalTimeMS + "(毫秒))";
        }
        public object Clone()
        {
            UnitActionData ret = new UnitActionData();
            ret.ShowChargeTimeMS = this.ShowChargeTimeMS;
            ret.TotalTimeMS = this.TotalTimeMS;
            ret.ActionName = this.ActionName;
            ret.ActionEffectFileName = this.ActionEffectFileName;
            ret.IsCycAction = this.IsCycAction;
            ret.IsCancelable = this.IsCancelable;
            ret.IsCancelableBySkill = this.IsCancelableBySkill;
            ret.IsCancelBySkillNext = this.IsCancelBySkillNext;
            ret.IsNoneBlock = this.IsNoneBlock;
            ret.IsNoneTouch = this.IsNoneTouch;
            ret.IsFaceToTarget = this.IsFaceToTarget;
            ret.IsInvisible = this.IsInvisible;
            ret.IsControlMoveable = this.IsControlMoveable;
            ret.IsControlFaceable = this.IsControlFaceable;
            ret.IsChangeIcon = this.IsChangeIcon;
            ret.IconName = this.IconName;

            ret.OverrideAttackShape = CUtils.TryClone<AttackShape>(this.OverrideAttackShape);
            ret.KeyFrames = CUtils.CloneList<KeyFrame>(this.KeyFrames);

            ret.BodyHit = CUtils.TryClone<AttackProp>(this.BodyHit);
            ret.BodyHitSize = this.BodyHitSize;
            ret.BodyHitNextAction = this.BodyHitNextAction;

            ret.IsMoveToTarget = this.IsMoveToTarget;
            ret.MoveToTargetSpeedSEC = this.MoveToTargetSpeedSEC;
            ret.IsJumpToTarget = this.IsJumpToTarget;
            ret.JumpToTargetHeightZ = this.JumpToTargetHeightZ;

            ret.BodyBlockOnAttackRange = this.BodyBlockOnAttackRange;
            ret.IsShowSkillGuide = this.IsShowSkillGuide;
            ret.SigleActionType = this.SigleActionType;
            ret.MoveActionName = this.MoveActionName;
            ret.ActionSpeedRate = this.ActionSpeedRate;
            ret.IsAddSkillBtnBlock = this.IsAddSkillBtnBlock;
            ret.ActionAudioName = this.ActionAudioName;
            ret.IsAudioLoop = this.IsAudioLoop;

            return ret;
        }
        public void WriteExternal(IOutputStream output)
        {
            output.PutS32(this.TotalTimeMS);
            output.PutS32(this.ShowChargeTimeMS);
            output.PutUTF(this.ActionName);
            output.PutUTF(this.ActionEffectFileName);
            output.PutBool(this.IsCycAction);
            output.PutBool(this.IsCancelable);
            output.PutBool(this.IsCancelableBySkill);
            output.PutBool(this.IsCancelBySkillNext);
            output.PutBool(this.IsNoneBlock);
            output.PutBool(this.IsNoneTouch);
            output.PutBool(this.IsFaceToTarget);
            output.PutBool(this.IsInvisible);
            output.PutBool(this.IsControlMoveable);
            output.PutBool(this.IsControlFaceable);
            output.PutBool(this.IsChangeIcon);
            output.PutUTF(this.IconName);

            output.PutExt(this.OverrideAttackShape);
            output.PutList<KeyFrame>(this.KeyFrames, output.PutExt);

            output.PutExt(this.BodyHit);
            output.PutF32(this.BodyHitSize);
            output.PutBool(this.BodyHitNextAction);

            output.PutBool(this.IsMoveToTarget);
            output.PutF32(this.MoveToTargetSpeedSEC);
            output.PutBool(this.IsJumpToTarget);
            output.PutF32(this.JumpToTargetHeightZ);

            output.PutBool(this.BodyBlockOnAttackRange);
            output.PutBool(this.IsShowSkillGuide);
            output.PutEnum8(this.SigleActionType);
            output.PutUTF(this.MoveActionName);
            output.PutF32(this.ActionSpeedRate);
            output.PutBool(this.IsAddSkillBtnBlock);
            output.PutUTF(this.ActionAudioName);
            output.PutBool(this.IsAudioLoop);
        }

        public void ReadExternal(IInputStream input)
        {
            this.TotalTimeMS = input.GetS32();
            this.ShowChargeTimeMS = input.GetS32();
            this.ActionName = input.GetUTF();
            this.ActionEffectFileName = input.GetUTF();
            this.IsCycAction = input.GetBool();
            this.IsCancelable = input.GetBool();
            this.IsCancelableBySkill = input.GetBool();
            this.IsCancelBySkillNext = input.GetBool();
            this.IsNoneBlock = input.GetBool();
            this.IsNoneTouch = input.GetBool();
            this.IsFaceToTarget = input.GetBool();
            this.IsInvisible = input.GetBool();
            this.IsControlMoveable = input.GetBool();
            this.IsControlFaceable = input.GetBool();
            this.IsChangeIcon = input.GetBool();
            this.IconName = input.GetUTF();

            this.OverrideAttackShape = input.GetExt<AttackShape>();
            this.KeyFrames = input.GetList<KeyFrame>(input.GetExt<KeyFrame>);

            this.BodyHit = input.GetExt<AttackProp>();
            this.BodyHitSize = input.GetF32();
            this.BodyHitNextAction = input.GetBool();

            this.IsMoveToTarget = input.GetBool();
            this.MoveToTargetSpeedSEC = input.GetF32();
            this.IsJumpToTarget = input.GetBool();
            this.JumpToTargetHeightZ = input.GetF32();

            this.BodyBlockOnAttackRange = input.GetBool();
            this.IsShowSkillGuide = input.GetBool();
            this.SigleActionType = input.GetEnum8<ActionEnum>();
            this.MoveActionName = input.GetUTF();
            this.ActionSpeedRate = input.GetF32();
            this.IsAddSkillBtnBlock = input.GetBool();
            this.ActionAudioName = input.GetUTF();
            this.IsAudioLoop = input.GetBool();
        }
        //------------------------------------------------------------
        /// <summary>
        /// 动作状态数据
        /// </summary>
        [MessageType(0x4107)]
        [DescAttribute("动作关键帧数据")]
        [Expandable]
        public class StatusChange : ICloneable, IExternalizable
        {
            [DescAttribute("移动可取消动作", "状态")]
            public bool IsCancelable = false;
            [DescAttribute("技能可取消动作", "状态")]
            public bool IsCancelableBySkill = false;

            [DescAttribute("是否进入霸体状态，不会被打断", "状态")]
            public bool IsNoneBlock = false;
            [DescAttribute("动作期间是否无碰撞", "状态")]
            public bool IsNoneTouch = false;
            [DescAttribute("动作中是否面向目标", "状态")]
            public bool IsFaceToTarget = false;

            [DescAttribute("动作是否隐身", "状态")]
            public bool IsInvisible = false;
            [DescAttribute("动作中是否可以控制移动", "状态")]

            public bool IsControlMoveable = false;
            [DescAttribute("动作中可以控制转向", "状态")]
            public bool IsControlFaceable = false;

            public override string ToString()
            {
                return string.Format("{0}{1}{2}{3}{4}{5}{6}{7}",
                    IsCancelable ? "移动可取消," : "",
                    IsCancelableBySkill ? "技能可取消," : "",
                    IsNoneBlock ? "霸体," : "",
                    IsNoneTouch ? "无碰撞," : "",
                    IsFaceToTarget ? "面向目标," : "",
                    IsInvisible ? "隐身," : "",
                    IsControlMoveable ? "可控制移动," : "",
                    IsControlFaceable ? "可控制转向," : "");
            }

            public object Clone()
            {
                StatusChange ret = new StatusChange();
                ret.IsCancelable = this.IsCancelable;
                ret.IsCancelableBySkill = this.IsCancelableBySkill;
                ret.IsNoneBlock = this.IsNoneBlock;
                ret.IsNoneTouch = this.IsNoneTouch;
                ret.IsFaceToTarget = this.IsFaceToTarget;
                ret.IsInvisible = this.IsInvisible;
                ret.IsControlMoveable = this.IsControlMoveable;
                ret.IsControlFaceable = this.IsControlFaceable;
                return ret;
            }
            public void WriteExternal(IOutputStream output)
            {
                output.PutBool(this.IsCancelable);
                output.PutBool(this.IsCancelableBySkill);
                output.PutBool(this.IsNoneBlock);
                output.PutBool(this.IsNoneTouch);
                output.PutBool(this.IsFaceToTarget);
                output.PutBool(this.IsInvisible);
                output.PutBool(this.IsControlMoveable);
                output.PutBool(this.IsControlFaceable);
            }

            public void ReadExternal(IInputStream input)
            {
                this.IsCancelable = input.GetBool();
                this.IsCancelableBySkill = input.GetBool();
                this.IsNoneBlock = input.GetBool();
                this.IsNoneTouch = input.GetBool();
                this.IsFaceToTarget = input.GetBool();
                this.IsInvisible = input.GetBool();
                this.IsControlMoveable = input.GetBool();
                this.IsControlFaceable = input.GetBool();
            }
        }

        //------------------------------------------------------------

        [MessageType(0x4108)]
        [DescAttribute("动作攻击范围")]
        [Expandable]
        public class AttackShape : ICloneable, IExternalizable
        {
            public enum Shape : byte
            {
                [DescAttribute("单体")]
                Single = CommonAI.Zone.Helper.AttackShape.Single,
                [DescAttribute("圆形")]
                Round = CommonAI.Zone.Helper.AttackShape.Round,
                [DescAttribute("扇形")]
                Fan = CommonAI.Zone.Helper.AttackShape.Fan,

                [DescAttribute("胶囊条状")]
                Strip = CommonAI.Zone.Helper.AttackShape.Strip,
                [DescAttribute("胶囊射线（以原点出去）")]
                StripRay = CommonAI.Zone.Helper.AttackShape.StripRay,
                [DescAttribute("胶囊射线，接触到最近")]
                StripRayTouchEnd = CommonAI.Zone.Helper.AttackShape.StripRayTouchEnd,

                [DescAttribute("方形条状")]
                RectStrip = CommonAI.Zone.Helper.AttackShape.RectStrip,
                [DescAttribute("方形射线（以原点出去）")]
                RectStripRay = CommonAI.Zone.Helper.AttackShape.RectStripRay,

                [DescAttribute("横向胶囊条状")]
                WideStrip = CommonAI.Zone.Helper.AttackShape.WideStrip,

                [DescAttribute("圆环，中间是空的")]
                Circle = CommonAI.Zone.Helper.AttackShape.Circle,
            }
            [DescAttribute("攻击范围类型", "攻击范围")]
            public Shape AShape = Shape.Round;

            [DescAttribute("半径（Round, Fan, Circle）长度(Strip, StripRay，StripRayTouchEnd, RectStrip, RectStripRay, LineToTarget, WideStrip)", "攻击范围")]
            public float AttackRange = 1;

            [DescAttribute("角度（Fan）", "攻击范围")]
            [DependOnProperty("IsShapeFan")]
            public float AttackAngle = 1;

            [DescAttribute("宽度，粗度(Strip, StripRay，StripRayTouchEnd，RectStrip, RectStripRay, WideStrip)，环粗度(Circle)", "攻击范围")]
            [DependOnProperty("IsShapeStrip")]
            public float StripWide = 1;

            [DescAttribute("初始点偏移", "身体")]
            public float OffsetRadius = 0;
            public bool IsSingle { get { return AShape == Shape.Single; } }
            public bool IsShapeFan { get { return AShape == Shape.Fan; } }
            public bool IsShapeStrip
            {
                get
                {
                    switch (AShape)
                    {
                        case Shape.Strip:
                        case Shape.StripRay:
                        case Shape.StripRayTouchEnd:
                        case Shape.Circle:
                        case Shape.RectStrip:
                        case Shape.RectStripRay:
                        case Shape.WideStrip:
                            return true;
                    }
                    return false;
                }
            }

            public override string ToString()
            {
                return string.Format("重定向攻击范围:{0}", AShape);
            }

            public object Clone()
            {
                AttackShape ret = new AttackShape();
                ret.AShape = this.AShape;
                ret.AttackRange = this.AttackRange;
                ret.AttackAngle = this.AttackAngle;
                ret.StripWide = this.StripWide;
                ret.OffsetRadius = this.OffsetRadius;
                return ret;
            }
            public void WriteExternal(IOutputStream output)
            {
                output.PutEnum8(this.AShape);
                output.PutF32(this.AttackRange);
                output.PutF32(this.AttackAngle);
                output.PutF32(this.StripWide);
                output.PutF32(this.OffsetRadius);
            }

            public void ReadExternal(IInputStream input)
            {
                this.AShape = input.GetEnum8<Shape>();
                this.AttackRange = input.GetF32();
                this.AttackAngle = input.GetF32();
                this.StripWide = input.GetF32();
                this.OffsetRadius = input.GetF32();
            }

        }
        //-------------------------------------------------------------------------------------

        //------------------------------------------------------------

        [MessageType(0x4109)]
        [DescAttribute("动作攻击范围")]
        [Expandable]
        public class ThrowTarget : ICloneable, IExternalizable
        {
            public override string ToString()
            {
                return string.Format("重定向攻击范");
            }

            public object Clone()
            {
                ThrowTarget ret = new ThrowTarget();
                return ret;
            }
            public void WriteExternal(IOutputStream output)
            {
            }

            public void ReadExternal(IInputStream input)
            {
            }

        }
        //-------------------------------------------------------------------------------------


        //------------------------------------------------------------
        /// <summary>
        /// 动作关键帧数据
        /// </summary>
        [MessageType(0x4104)]
        [DescAttribute("动作关键帧数据")]
        [Expandable]
        public class KeyFrame : BaseKeyFrame, ICloneable, IExternalizable
        {
            /// <summary>
            /// 关键帧产生的法术或远程道具单位模板ID
            /// </summary>
            [DescAttribute("关键帧产生的法术或远程道具单位模板ID")]
            public LaunchSpell Spell;

            /// <summary>
            /// 当前关键帧特效
            /// </summary>
            [DescAttribute("当前关键帧特效ID")]
            public LaunchEffect Effect;

            /// <summary>
            /// 攻击属性
            /// </summary>
            [DescAttribute("攻击属性ID")]
            public AttackProp Attack;

            /// <summary>
            /// 对自己产生BUFF
            /// </summary>
            [DescAttribute("对自己产生BUFF")]
            public LaunchBuff SelfBuff;

            /// <summary>
            /// 此动作关键帧产生的位移
            /// </summary>
            [DescAttribute("此动作关键帧产生的位移")]
            public StartMove Move;
            [DescAttribute("位移在有打击目标时是否生效")]
            public bool hitTargetMoveEnable = true;

            [DescAttribute("闪现位移")]
            public BlinkMove Blink;

            [DescAttribute("动作状态改变")]
            public StatusChange ChangeStatus;

            public KeyFrame() { }
            public override string ToString()
            {
                return "Frame: @" + FrameMS;
            }

            public object Clone()
            {
                KeyFrame ret = new KeyFrame();
                ret.FrameMS = base.FrameMS;
                ret.Spell = CUtils.TryClone<LaunchSpell>(this.Spell);
                ret.Effect = CUtils.TryClone<LaunchEffect>(this.Effect);
                ret.Attack = CUtils.TryClone<AttackProp>(this.Attack);
                ret.SelfBuff = CUtils.TryClone<LaunchBuff>(this.SelfBuff);
                ret.Move = CUtils.TryClone<StartMove>(this.Move);
                ret.hitTargetMoveEnable = this.hitTargetMoveEnable;
                ret.Blink = CUtils.TryClone<BlinkMove>(this.Blink);
                ret.ChangeStatus = CUtils.TryClone<StatusChange>(this.ChangeStatus);
                return ret;
            }


            public void WriteExternal(IOutputStream output)
            {
                output.PutS32(base.FrameMS);
                output.PutExt(this.Spell);
                output.PutExt(this.Effect);
                output.PutExt(this.Attack);
                output.PutExt(this.SelfBuff);
                output.PutExt(this.Move);
                output.PutBool(this.hitTargetMoveEnable);
                output.PutExt(this.Blink);
                output.PutExt(this.ChangeStatus);
            }

            public void ReadExternal(IInputStream input)
            {
                base.FrameMS = input.GetS32();
                this.Spell = input.GetExt<LaunchSpell>();
                this.Effect = input.GetExt<LaunchEffect>();
                this.Attack = input.GetExt<AttackProp>();
                this.SelfBuff = input.GetExt<LaunchBuff>();
                this.Move = input.GetExt<StartMove>();
                this.hitTargetMoveEnable = input.GetBool();
                this.Blink = input.GetExt<BlinkMove>();
                this.ChangeStatus = input.GetExt<StatusChange>();
            }
        }

    }
    //---------------------------------------------------------------------------------//

    /// <summary>
    /// 单位行为触发器
    /// </summary>
    [MessageType(0x4010)]
    [DescAttribute("单位行为触发器")]
    [TableClassAttribute("ID")]
    public class UnitTriggerTemplate : ICloneable, ITemplateData, IExternalizable
    {
        public int TemplateID { get { return ID; } }
        [XmlSerializable()]
        public string EditorPath { get; set; }

        [DescAttribute("ID", "基础", false)]
        public int ID;
        [LocalizationTextAttribute]
        [DescAttribute("触发器名字", "基础")]
        public string Name;

        [DescAttribute("触发器冷却时间", "基础")]
        public int CoolDownTimeMS = 10000;

        [DescAttribute("事件触发条件(所有的关系为与)", "条件")]
        [ListAttribute(typeof(UnitTriggers.BaseTriggerEvent))]
        public List<UnitTriggers.BaseTriggerEvent> Triggers = new List<UnitTriggers.BaseTriggerEvent>();

        [DescAttribute("释放技能", "动作")]
        public LaunchSkill DoSkill;
        [DescAttribute("产生Buff", "动作")]
        public LaunchBuff DoBuff;
        [DescAttribute("产生法术", "动作")]
        public LaunchSpell DoSpell;
        [DescAttribute("产生特效(图形)", "动作")]
        public LaunchEffect DoEffect;

		/// <summary>
		/// 召唤小弟
		/// </summary>
		[DescAttribute("召唤小弟", "动作")]
		public SummonUnit DoSummon;

		//------------------------------------
		/// <summary>
		/// 用户自定义扩展属性
		/// </summary>
		[DescAttribute("扩展属性", "扩展")]
        [Expandable]
        [NotNull]
        public IUnitTriggerProperties Properties = TemplateManager.Factory.CreateTriggerProperties();

        public override string ToString()
        {
            return Name + "(" + ID + ")";
        }

        public string FunctionText()
        {
            StringBuilder sb = new StringBuilder();
            if (Triggers.Count > 0)
            {
                foreach (UnitTriggers.BaseTriggerEvent e in Triggers)
                {
                    sb.Append(string.Format("{0}", e));
                    if (e != Triggers[Triggers.Count - 1])
                    {
                        sb.Append(" 并且 ");
                    }
                }
                if (DoSkill != null) sb.Append("，" + DoSkill);
                if (DoBuff != null) sb.Append("，" + DoBuff);
                if (DoSpell != null) sb.Append("，" + DoSpell);
                if (DoEffect != null) sb.Append("，" + DoEffect);
            }
            return sb.ToString();
        }

        public object Clone()
        {
            UnitTriggerTemplate ret = new UnitTriggerTemplate();
            ret.EditorPath = this.EditorPath;
            ret.ID = this.ID;
            ret.Name = this.Name;
            ret.CoolDownTimeMS = this.CoolDownTimeMS;
            ret.Triggers = CUtils.CloneList<UnitTriggers.BaseTriggerEvent>(this.Triggers);
            ret.DoSkill = CUtils.TryClone<LaunchSkill>(this.DoSkill);
            ret.DoBuff = CUtils.TryClone<LaunchBuff>(this.DoBuff);
            ret.DoSpell = CUtils.TryClone<LaunchSpell>(this.DoSpell);
            ret.DoEffect = CUtils.TryClone<LaunchEffect>(this.DoEffect);
			ret.DoSummon = CUtils.TryClone<SummonUnit>(this.DoSummon);
			return ret;
        }
        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.EditorPath);
            output.PutS32(this.ID);
            output.PutUTF(this.Name);
            output.PutS32(this.CoolDownTimeMS);
            output.PutList<UnitTriggers.BaseTriggerEvent>(this.Triggers, output.PutExt);
            output.PutExt(this.DoSkill);
            output.PutExt(this.DoBuff);
            output.PutExt(this.DoSpell);
            output.PutExt(this.DoEffect);
			output.PutExt(this.DoSummon);
		}
        public void ReadExternal(IInputStream input)
        {
            this.EditorPath = input.GetUTF();
            this.ID = input.GetS32();
            this.Name = input.GetUTF();
            this.CoolDownTimeMS = input.GetS32();
            this.Triggers = input.GetListAny<UnitTriggers.BaseTriggerEvent>();
            this.DoSkill = input.GetExt<LaunchSkill>();
            this.DoBuff = input.GetExt<LaunchBuff>();
            this.DoSpell = input.GetExt<LaunchSpell>();
            this.DoEffect = input.GetExt<LaunchEffect>();
			this.DoSummon = input.GetExt<SummonUnit>();
		}
    }


    //---------------------------------------------------------------------------------//


    /// <summary>
    /// 法术/飞行道具模板
    /// </summary>
    [MessageType(0x4005)]
    [DescAttribute("法术/飞行道具模板")]
    [TableClassAttribute("ID")]
    public class SpellTemplate : ICloneable, ITemplateData, IExternalizable
    {
        public int TemplateID { get { return ID; } }
        [XmlSerializable()]
        public string EditorPath { get; set; }

        public enum MotionType : byte
        {
            [DescAttribute("在原地不动")]
            Immovability = 1,
            [DescAttribute("按直线运动")]
            Straight = 2,
            [DescAttribute("跟随目标，直到击中")]
            Missile = 3,

            [DescAttribute("向周围扩散")]
            AOE = 4,

            [DescAttribute("绑定发射者")]
            Binding = 6,
            [DescAttribute("绑定被攻击者")]
            BindingTarget = 7,

            [DescAttribute("炮弹类")]
            Cannon = 8,
            [DescAttribute("直接在目标坐标生效")]
            SelectTarget = 9,

            [DescAttribute("先按直线运动，过程中锁定目标")]
            SeekerMissile = 10,

            [DescAttribute("向周围扩散，绑定发射者")]
            AOE_Binding = 11,
            [DescAttribute("向周围扩散，绑定被攻击者")]
            AOE_BindingTarget = 12,

            [DescAttribute("锁定并命中目标，和SeekerMissile区别是没有过程，直接命中。")]
            SeekerSelectTarget = 13,

            [DescAttribute("发射者和目标绑定（Distance必须在范围内）")]
            Chain = 14,

            [DescAttribute("直接在自身坐标生效")]
            SelectLauncher = 15,

            [DescAttribute("回旋镖路径1(最终返回到发射者)")]
            Boomerang1 = 16,

            [DescAttribute("回旋镖路径2(最终返回到发射点)")]
            Boomerang2 = 17,

            [DescAttribute("狐火路径")]
            Foxfire = 18,

            [DescAttribute("先直线，后停留")]
            StraightAndStop = 19,


			[DescAttribute("追踪，可击中路径上的敌人")]
			MissileAttackRoute = 20,

			[DescAttribute("曲线追踪")]
			CurveMissile = 21,
		}
        /// <summary>
        /// 往客户端推送，是否包含坐标
        /// </summary>
        public bool IsLaunchSpellEventSyncPos
        {
            get
            {
				// 脱离运动类型的一些特殊字段
				if(this.IsBindingOrbit)
				{
					return true;
				}

                switch (MType)
                {
                    case SpellTemplate.MotionType.AOE_Binding:
                    case SpellTemplate.MotionType.AOE_BindingTarget:
                    case SpellTemplate.MotionType.Binding:
                    case SpellTemplate.MotionType.BindingTarget:
                    case SpellTemplate.MotionType.Chain:
                        return false;
                    case SpellTemplate.MotionType.SelectLauncher:
                    case SpellTemplate.MotionType.SelectTarget:
                    case SpellTemplate.MotionType.Immovability:
                    case SpellTemplate.MotionType.Cannon:
                    case SpellTemplate.MotionType.AOE:
                    case SpellTemplate.MotionType.Straight:
                    case SpellTemplate.MotionType.Missile:
                    case SpellTemplate.MotionType.Boomerang1:
                    case SpellTemplate.MotionType.Boomerang2:
                    case SpellTemplate.MotionType.SeekerMissile:
                    case SpellTemplate.MotionType.SeekerSelectTarget:
                    case SpellTemplate.MotionType.StraightAndStop:
					case SpellTemplate.MotionType.MissileAttackRoute:
					case SpellTemplate.MotionType.CurveMissile:
					default:
                        return true;
                }
            }
        }

        [DescAttribute("ID", "", false)]
        public int ID;

        /// <summary>
        /// 法术名字
        /// </summary>
        [DescAttribute("法术名字")]
        [LocalizationTextAttribute]
        public string Name;

        /// <summary>
        /// 生命周期，帧
        /// </summary>
        [DescAttribute("生命周期(毫秒)")]
        public int LifeTimeMS = 1000;

        [DescAttribute("客户端是否可见")]
        public bool ClientVisible = true;
        //--------------------------------------------
        public enum Shape : byte
        {
            [DescAttribute("圆形（BodySize=半径尺寸）")]
            Round = AttackShape.Round,
            [DescAttribute("扇形（BodySize=半径尺寸；FanAngle=角度）")]
            Fan = AttackShape.Fan,

            [DescAttribute("胶囊条状（Distance=长度；RectWide=宽度）")]
            Strip = AttackShape.Strip,
            [DescAttribute("胶囊射线，以原点出去（Distance=长度；RectWide=宽度）")]
            StripRay = AttackShape.StripRay,
            [DescAttribute("胶囊射线，接触到最近（Distance=最大长度；RectWide=宽度）")]
            StripRayTouchEnd = AttackShape.StripRayTouchEnd,

            [DescAttribute("方形条状")]
            RectStrip = CommonAI.Zone.Helper.AttackShape.RectStrip,
            [DescAttribute("方形射线（以原点出去）")]
            RectStripRay = CommonAI.Zone.Helper.AttackShape.RectStripRay,

            [DescAttribute("横向胶囊条状")]
            WideStrip = CommonAI.Zone.Helper.AttackShape.WideStrip,

            [DescAttribute("连线类型（单体攻击），比如激光塔（Distance=判定距离）")]
            LineToTarget = AttackShape.LineToTarget,
            [DescAttribute("连线类型（单体攻击），比如伸出去的钩子（Distance=判定距离）")]
            LineToStart = AttackShape.LineToStart,
            [DescAttribute("圆环，中间是空的（BodySize=外环半径；BodySize-RectWide=内环半径）")]
            Circle = CommonAI.Zone.Helper.AttackShape.Circle,
        }
        public bool IsShapeFan { get { return BodyShape == Shape.Fan; } }
        public bool IsShapeStrip
        {
            get
            {
                switch (BodyShape)
                {
                    case Shape.Strip:
                    case Shape.StripRay:
                    case Shape.StripRayTouchEnd:
                    case Shape.Circle:
                    case Shape.RectStrip:
                    case Shape.RectStripRay:
                    case Shape.WideStrip:
                        return true;
                }
                return false;
            }
        }
        public bool IsShapeDistance
        {
            get
            {
                switch (BodyShape)
                {
                    case Shape.Strip:
                    case Shape.StripRay:
                    case Shape.StripRayTouchEnd:
                    case Shape.LineToTarget:
                    case Shape.LineToStart:
                    case Shape.RectStrip:
                    case Shape.RectStripRay:
                    case Shape.WideStrip:
                        return true;
                    default:
                        return false;
                }
            }
        }
        //--------------------------------------------
        [DescAttribute("攻击范围类型", "攻击范围")]
        public Shape BodyShape = Shape.Round;
        [DescAttribute("尺寸，半径（Round, Fan, Circle）", "攻击范围")]
        public float BodySize = 1;
        [DescAttribute("角度（Fan）", "攻击范围")]
        [DependOnProperty("IsShapeFan")]
        public float FanAngle;
        [DescAttribute("宽度，粗度(Strip, StripRay，StripRayTouchEnd，RectStrip, RectStripRay，Circle, WideStrip)", "攻击范围")]
        [DependOnProperty("IsShapeStrip")]
        public float RectWide = 1;
        [DescAttribute("长度(Strip, StripRay，StripRayTouchEnd, RectStrip, RectStripRay，LineToTarget, LineToStart, WideStrip)", "攻击范围")]
        [DependOnProperty("IsShapeDistance")]
        public float Distance = 10;
        //--------------------------------------------
        [DescAttribute("法术自身高度", "攻击范围")]
        public float BodyHeight = 0;
        //--------------------------------------------
        /// <summary>
        /// 运动类型
        /// </summary>
        [DescAttribute("运动类型", "运动")]
        public MotionType MType = MotionType.Straight;
        public bool IsMoveable
        {
            get
            {
                switch (MType)
                {
                    case MotionType.Cannon:
                    case MotionType.Missile:
                    case MotionType.SeekerMissile:
                    case MotionType.Straight:
                    case MotionType.AOE:
                    case MotionType.AOE_Binding:
                    case MotionType.AOE_BindingTarget:
                    case MotionType.Boomerang1:
                    case MotionType.Boomerang2:
                    case MotionType.Foxfire:
                    case MotionType.StraightAndStop:
					case MotionType.MissileAttackRoute:
					case MotionType.CurveMissile:
						return true;
                }
                return false;
            }
        }
        public bool IsBinding
        {
            get
            {
                switch (MType)
                {
                    case MotionType.Binding:
                    case MotionType.BindingTarget:
                    case MotionType.AOE_Binding:
                    case MotionType.AOE_BindingTarget:
                        return true;
                }
                return false;
            }
        }
        public bool IsSeekingTarget
        {
            get
            {
                switch (MType)
                {
                    case MotionType.SeekerMissile:
                    case MotionType.SeekerSelectTarget:
                    case MotionType.Foxfire:
					case MotionType.MissileAttackRoute:
					case MotionType.CurveMissile:
						return true;
                }
                return false;
            }
        }

        public bool IsAOE
        {
            get
            {
                switch (MType)
                {
                    case MotionType.AOE:
                    case MotionType.AOE_Binding:
                    case MotionType.AOE_BindingTarget:
                        return true;
                }
                return false;
            }
        }


        /// <summary>
        /// 运动速度,AOE或者扩散类，缩放速度
        /// </summary>
        [DescAttribute("运动速度,AOE或者扩散类，缩放速度(距离 / 每秒)", "运动")]
        [DependOnProperty("IsMoveable")]
        public float MSpeedSEC = 15f;
        [DescAttribute("加速度(距离/每秒)(最终速度=速度+加速度)", "运动")]
        [DependOnProperty("IsMoveable")]
        public float MSpeedAdd = 0f;
        [DescAttribute("阻力(每秒递减速度百分比)", "运动")]
        [DependOnProperty("IsMoveable")]
        public float MSpeedAcc = 0f;

        [DescAttribute("最大移动距离", "运动")]
        public float MaxMoveDistance = 0f;
        [DescAttribute("最大限速", "运动")]
        [DependOnProperty("IsMoveable")]
        public float MSpeed_MAX = 100f;
        [DescAttribute("最小限速", "运动")]
        [DependOnProperty("IsMoveable")]
        public float MSpeed_MIN = -100f;

        //--------------------------------------------
        public enum AoeMotionType : byte
        {
            [DescAttribute("线性，递增或递减")]
            Linear = 0,
            [DescAttribute("正弦，单次周期为PI，象限0～1")]
            Sine = 1,
        }
        [DescAttribute("AOE方式", "运动")]
        [DependOnProperty("IsAOE")]
        public AoeMotionType AOEMType = AoeMotionType.Linear;
        //--------------------------------------------
        /// <summary>
        /// 转动速度
        /// </summary>
        [DescAttribute("自转转动速度(距离/每秒)", "运动")]
        public float RotateSpeedSEC;
        [DescAttribute("抛物线高度", "运动")]
        public float ParabolaHeight = 0;

        /// <summary>
        /// 
        /// </summary>
        [DescAttribute("暂时只给灵魂出窍的技能使用", "运动")]
        public bool HeightUpdate;

        //--------------------------------------------
        public enum SeekingExpect : byte
        {
            [DescAttribute("搜索随机单位")]
            Random,
            [DescAttribute("搜索最近单位")]
            Nearest,
            [DescAttribute("搜索最远单位")]
            Farthest,
            [DescAttribute("搜索随机单位(忽略链中)")]
            RandomIgnoreInChain,
            [DescAttribute("搜索最近单位(忽略链中)")]
            NearestIgnoreInChain,
            [DescAttribute("搜索最远单位(忽略链中)")]
            FarthestIgnoreInChain,
        }
        //--------------------------------------------

        [DescAttribute("如果是自动搜敌导弹SeekerMissile，则表示搜索范围，如果是LineToTarget则表示伤害距离", "运动-自动跟踪")]
        [DependOnProperty("IsSeekingTarget")]
        public float SeekingRange = 10;
        [DescAttribute("自动锁敌冷却时间（毫秒）", "运动-自动跟踪")]
        [DependOnProperty("IsSeekingTarget")]
        public int SeekingCooldownMS = 1000;
        [DescAttribute("自动锁敌运动时，转角距离", "运动-自动跟踪")]
        [DependOnProperty("IsSeekingTarget")]
        public float SeekingTurningAngleSEC = 3f;
        [DescAttribute("自动锁敌检测方式", "运动-自动跟踪")]
        [DependOnProperty("IsSeekingTarget")]
        public SeekingExpect SeekingExpectTarget = SeekingExpect.Random;

        //--------------------------------------------
        [DescAttribute("如果是绑定则围绕绑定者公转", "运动-绑定")]
        [DependOnProperty("IsBinding")]
        public bool IsBindingOrbit = false;
        [DescAttribute("绑定公转距离", "运动-绑定")]
        [DependOnProperty("IsBinding")]
        public float OrbitDistance;
        [DescAttribute("如果为绑定，是否绑定方向", "运动-绑定")]
        [DependOnProperty("IsBinding")]
        public bool IsBindingDirection = false;
        //--------------------------------------------
        //--------------------------------------------

        [DescAttribute("最大影响（受击）单位，0表示无限制")]
        public int MaxAffectUnit = 0;
        //--------------------------------------------
        /// <summary>
        /// 击中就消失
        /// </summary>
        [DescAttribute("击中就消失(爆炸)，和HitIntervalMS冲突", "关键帧")]
        public bool HitOnExplosion;
        [DescAttribute("击中就消失(爆炸)关键帧，适用于打到就爆和Cannon类法术", "关键帧")]
        [DependOnProperty("HitOnExplosion")]
        public KeyFrame HitOnExplosionKeyFrame;

        /// <summary>
        /// 每间隔多少帧就触发一次，0代表只造成一次伤害或效果
        /// </summary>
        [DescAttribute("每间隔多少时间就触发一次，0 适用于穿透性，但只对单位造成一次伤害（毫秒）", "关键帧")]
        public int HitIntervalMS;
        [DescAttribute("只造成一次触发的关键帧 or 每隔一段时间触发的关键帧", "关键帧")]
        public KeyFrame HitIntervalKeyFrame;

        /// <summary>
        /// 按顺序触发的所有关键帧
        /// </summary>
        [ListAttribute(typeof(KeyFrame))]
        [DescAttribute("按顺序触发的所有关键帧", "关键帧")]
        public List<KeyFrame> KeyFrames = new List<KeyFrame>();
        //--------------------------------------------
        /// <summary>
        /// 模型名字或者Perfab名字
        /// </summary>
        [DescAttribute("模型名字或者Perfab名字", "资源")]
        [ResourceIDAttribute]
        public string FileName;
        [DescAttribute("模型名字或者Perfab名字（起始）", "资源")]
        [ResourceIDAttribute]
        public string FileNameSpawn;
        [DescAttribute("模型名字或者Perfab名字（结束）", "资源")]
        [ResourceIDAttribute]
        public string FileNameDestory;
        [DescAttribute("是否循环播放动画", "资源")]
        public bool IsCycAnim = true;

        [DescAttribute("缩放比率", "资源")]
        public float FileBodyScale = 1;


        [DescAttribute("法术释放时，在目标点释放特效，可作为技能提示", "特效")]
        public LaunchEffect TargetEffect;

        [DescAttribute("法术期望作用目标", "目标")]
        public SkillTemplate.CastTarget ExpectTarget = SkillTemplate.CastTarget.Enemy;
        //------------------------------------
        [DescAttribute("绑定目标不可操控时移除自己", "移除条件")]
        public bool RemoveOnBindingUncontrollable = false;
        [DescAttribute("绑定目标非技能状态时移除自己", "移除条件")]
        public bool RemoveOnBindingSkillOver = false;
        [DescAttribute("当Spell被移除停止释放它的技能", "移除条件")]
        public bool StopBindingSkillOnRemoved = false;
        //------------------------------------

        //--------------------------------------------
        public enum SpecialAdditionalEffect : byte
        {
            [DescAttribute("无")]
            None = 0,
            [DescAttribute("黑洞效果,牵引碰到的怪物")]
            DarkHole = 1,
            [DescAttribute("路径牵引效果")]
            DragPath = 2,
        }

        public bool IsCanAddSpecialEffect
        {
            get
            {
                switch (MType)
                {
                    case MotionType.Missile:
                    case MotionType.SeekerMissile:
                    case MotionType.Cannon:
                    case MotionType.Chain:
                    case MotionType.Boomerang1:
                    case MotionType.Boomerang2:
					case MotionType.MissileAttackRoute:
					case MotionType.CurveMissile:
						return false;
                }
                return true;
            }
        }

        [DescAttribute("法术的特殊效果", "特殊效果")]
        [DependOnProperty("IsCanAddSpecialEffect")]
        public SpecialAdditionalEffect SpecialEffect = SpecialAdditionalEffect.None;
        [DescAttribute("特殊效果参数(黑洞的牵引速度)", "特殊效果")]
        [DependOnProperty("IsCanAddSpecialEffect")]
        public float SpecialEffectParam = 0;

        // -- 

        [DescAttribute("飞行时间(毫秒)", "运动(回旋路径, 滞空)")]
        //[DependOnProperty("IsBoomerang")]
        public int BoomerangFlyTime = 1000;
        [DescAttribute("滞空时间(毫秒)", "运动(回旋路径, 滞空)")]
        //[DependOnProperty("IsBoomerang")]
        public int BoomerangHangtime = 1000;

        public bool IsBoomerang
        {
            get
            {
                return MType == MotionType.Boomerang1 || MType == MotionType.Boomerang2;
            }
        }

        /// <summary>
        /// 用户自定义扩展属性
        /// </summary>
        [DescAttribute("扩展属性", "扩展")]
        [Expandable]
        [NotNull]
        public ISpellProperties Properties = TemplateManager.Factory.CreateSpellProperties();
        //------------------------------------

        [DescAttribute("速度（原始动画/特效速度 * 速度）", "特效加速")]
        public float EffectAddSpeed = 1;
        [DescAttribute("特效中存在的动画，动画的名字", "特效加速")]
        public string AnimtionName;

        [DescAttribute("音效文件名", "音效")]
        public string AudioName;
        [DescAttribute("音效文件是否循环", "音效")]
        public bool IsAudioLoop;

        public SpellTemplate() { }
        public int GetID()
        {
            return ID;
        }
        public override string ToString()
        {
            return Name + "(" + ID + ")";
        }

        public object Clone()
        {
            SpellTemplate ret = new SpellTemplate();
            ret.EditorPath = this.EditorPath;
            ret.ID = this.ID;
            ret.Name = this.Name;
            ret.LifeTimeMS = this.LifeTimeMS;
            ret.ClientVisible = this.ClientVisible;
            ret.BodyShape = this.BodyShape;
            ret.BodySize = this.BodySize;
            ret.FanAngle = this.FanAngle;
            ret.RectWide = this.RectWide;
            ret.BodyHeight = this.BodyHeight;
            ret.Distance = this.Distance;

            ret.MType = this.MType;
            ret.MSpeedSEC = this.MSpeedSEC;
            ret.MSpeedAdd = this.MSpeedAdd;
            ret.MSpeedAcc = this.MSpeedAcc;
            ret.MaxMoveDistance = this.MaxMoveDistance;
            ret.MSpeed_MAX = this.MSpeed_MAX;
            ret.MSpeed_MIN = this.MSpeed_MIN;
            ret.RotateSpeedSEC = this.RotateSpeedSEC;
            ret.ParabolaHeight = this.ParabolaHeight;
            ret.HeightUpdate = this.HeightUpdate;
            ret.AOEMType = this.AOEMType;

            ret.SeekingRange = this.SeekingRange;
            ret.SeekingCooldownMS = this.SeekingCooldownMS;
            ret.SeekingTurningAngleSEC = this.SeekingTurningAngleSEC;
            ret.SeekingExpectTarget = this.SeekingExpectTarget;


            ret.MaxAffectUnit = this.MaxAffectUnit;
            ret.IsBindingOrbit = this.IsBindingOrbit;
            ret.OrbitDistance = this.OrbitDistance;
            ret.IsBindingDirection = this.IsBindingDirection;
            ret.HitOnExplosion = this.HitOnExplosion;
            ret.HitOnExplosionKeyFrame = CUtils.TryClone<KeyFrame>(this.HitOnExplosionKeyFrame);
            ret.HitIntervalMS = this.HitIntervalMS;
            ret.HitIntervalKeyFrame = CUtils.TryClone<KeyFrame>(this.HitIntervalKeyFrame);
            ret.KeyFrames = CUtils.CloneList<KeyFrame>(this.KeyFrames);
            ret.FileName = this.FileName;
            ret.FileNameSpawn = this.FileNameSpawn;
            ret.FileNameDestory = this.FileNameDestory;
            ret.IsCycAnim = this.IsCycAnim;
            ret.FileBodyScale = this.FileBodyScale;
            ret.TargetEffect = CUtils.TryClone<LaunchEffect>(this.TargetEffect);
            ret.ExpectTarget = this.ExpectTarget;
            ret.RemoveOnBindingUncontrollable = this.RemoveOnBindingUncontrollable;
            ret.RemoveOnBindingSkillOver = this.RemoveOnBindingSkillOver;
            ret.StopBindingSkillOnRemoved = this.StopBindingSkillOnRemoved;
            ret.Properties = CUtils.TryClone<ISpellProperties>(this.Properties);
            ret.SpecialEffect = this.SpecialEffect;
            ret.SpecialEffectParam = this.SpecialEffectParam;
            ret.BoomerangFlyTime = this.BoomerangFlyTime;
            ret.BoomerangHangtime = this.BoomerangHangtime;
            ret.EffectAddSpeed = this.EffectAddSpeed;
            ret.AnimtionName = this.AnimtionName;
            ret.AudioName = this.AudioName;
            ret.IsAudioLoop = this.IsAudioLoop;
            return ret;
        }
        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.EditorPath);
            output.PutS32(this.ID);
            output.PutUTF(this.Name);
            output.PutS32(this.LifeTimeMS);
            output.PutBool(this.ClientVisible);
            output.PutEnum8(this.BodyShape);
            output.PutF32(this.BodySize);
            output.PutF32(this.FanAngle);
            output.PutF32(this.RectWide);
            output.PutF32(this.BodyHeight);
            output.PutF32(this.Distance);

            output.PutEnum8(this.MType);
            output.PutF32(this.MSpeedSEC);
            output.PutF32(this.MSpeedAdd);
            output.PutF32(this.MSpeedAcc);
            output.PutF32(this.MaxMoveDistance);
            output.PutF32(this.MSpeed_MAX);
            output.PutF32(this.MSpeed_MIN);
            output.PutF32(this.RotateSpeedSEC);
            output.PutF32(this.ParabolaHeight);
            output.PutBool(this.HeightUpdate);
            output.PutEnum8(this.AOEMType);

            output.PutF32(this.SeekingRange);
            output.PutS32(this.SeekingCooldownMS);
            output.PutF32(this.SeekingTurningAngleSEC);
            output.PutEnum8(this.SeekingExpectTarget);
            output.PutS32(this.MaxAffectUnit);
            output.PutBool(this.IsBindingOrbit);
            output.PutF32(this.OrbitDistance);
            output.PutBool(this.IsBindingDirection);
            output.PutBool(this.HitOnExplosion);
            output.PutExt(this.HitOnExplosionKeyFrame);
            output.PutS32(this.HitIntervalMS);
            output.PutExt(this.HitIntervalKeyFrame);
            output.PutList<KeyFrame>(this.KeyFrames, output.PutExt);
            output.PutUTF(this.FileName);
            output.PutUTF(this.FileNameSpawn);
            output.PutUTF(this.FileNameDestory);
            output.PutBool(this.IsCycAnim);
            output.PutF32(this.FileBodyScale);
            output.PutExt(this.TargetEffect);
            output.PutEnum8(this.ExpectTarget);
            output.PutBool(this.RemoveOnBindingUncontrollable);
            output.PutBool(this.RemoveOnBindingSkillOver);
            output.PutBool(this.StopBindingSkillOnRemoved);
            output.PutExt(this.Properties);
            output.PutEnum8(this.SpecialEffect);
            output.PutF32(this.SpecialEffectParam);
            output.PutS32(this.BoomerangFlyTime);
            output.PutS32(this.BoomerangHangtime);
            output.PutF32(this.EffectAddSpeed);
            output.PutUTF(this.AnimtionName);
            output.PutUTF(this.AudioName);
            output.PutBool(this.IsAudioLoop);
        }

        public void ReadExternal(IInputStream input)
        {
            this.EditorPath = input.GetUTF();
            this.ID = input.GetS32();
            this.Name = input.GetUTF();
            this.LifeTimeMS = input.GetS32();
            this.ClientVisible = input.GetBool();
            this.BodyShape = input.GetEnum8<Shape>();
            this.BodySize = input.GetF32();
            this.FanAngle = input.GetF32();
            this.RectWide = input.GetF32();
            this.BodyHeight = input.GetF32();
            this.Distance = input.GetF32();

            this.MType = input.GetEnum8<MotionType>();
            this.MSpeedSEC = input.GetF32();
            this.MSpeedAdd = input.GetF32();
            this.MSpeedAcc = input.GetF32();
            this.MaxMoveDistance = input.GetF32();
            this.MSpeed_MAX = input.GetF32();
            this.MSpeed_MIN = input.GetF32();
            this.RotateSpeedSEC = input.GetF32();
            this.ParabolaHeight = input.GetF32();
            this.HeightUpdate = input.GetBool();
            this.AOEMType = input.GetEnum8<AoeMotionType>();

            this.SeekingRange = input.GetF32();
            this.SeekingCooldownMS = input.GetS32();
            this.SeekingTurningAngleSEC = input.GetF32();
            this.SeekingExpectTarget = input.GetEnum8<SeekingExpect>();
            this.MaxAffectUnit = input.GetS32();
            this.IsBindingOrbit = input.GetBool();
            this.OrbitDistance = input.GetF32();
            this.IsBindingDirection = input.GetBool();
            this.HitOnExplosion = input.GetBool();
            this.HitOnExplosionKeyFrame = input.GetExt<KeyFrame>();
            this.HitIntervalMS = input.GetS32();
            this.HitIntervalKeyFrame = input.GetExt<KeyFrame>();
            this.KeyFrames = input.GetList<KeyFrame>(input.GetExt<KeyFrame>);
            this.FileName = input.GetUTF();
            this.FileNameSpawn = input.GetUTF();
            this.FileNameDestory = input.GetUTF();
            this.IsCycAnim = input.GetBool();
            this.FileBodyScale = input.GetF32();
            this.TargetEffect = input.GetExt<LaunchEffect>();
            this.ExpectTarget = input.GetEnum8<SkillTemplate.CastTarget>();
            this.RemoveOnBindingUncontrollable = input.GetBool();
            this.RemoveOnBindingSkillOver = input.GetBool();
            this.StopBindingSkillOnRemoved = input.GetBool();
            this.Properties = input.GetExt<ISpellProperties>(this.Properties);
            this.SpecialEffect = input.GetEnum8<SpecialAdditionalEffect>();
            this.SpecialEffectParam = input.GetF32();
            this.BoomerangFlyTime = input.GetS32();
            this.BoomerangHangtime = input.GetS32();
            this.EffectAddSpeed = input.GetF32();
            this.AnimtionName = input.GetUTF();
            this.AudioName = input.GetUTF();
            this.IsAudioLoop = input.GetBool();
        }
        //------------------------------------------------------------

        //------------------------------------------------------------


        /// <summary>
        /// 法术伤害或特效关键帧
        /// </summary>
        [MessageType(0x4105)]
        [DescAttribute("法术伤害或特效关键帧")]
        [Expandable]
        public class KeyFrame : BaseKeyFrame, ICloneable, IExternalizable
        {
            /// <summary>
            /// 触发的特效
            /// </summary>
            [DescAttribute("触发的特效")]
            public LaunchEffect Effect;

            /// <summary>
            /// 触发新的法术
            /// </summary>
            [DescAttribute("触发新的法术")]
            public LaunchSpell Spell;

            /// <summary>
            /// 攻击伤害
            /// </summary>
            [DescAttribute("攻击伤害")]
            public AttackProp Attack;

            /// <summary>
            /// 召唤小弟
            /// </summary>
            [DescAttribute("召唤小弟")]
            public SummonUnit Summon;


            public KeyFrame() { }

            public override string ToString()
            {
                if (Spell == null)
                {
                    return "Frame: @" + FrameMS;
                }

                return "Frame: @" + FrameMS + ", " + Spell.ToString();
            }

            public object Clone()
            {
                KeyFrame ret = new KeyFrame();
                ret.FrameMS = this.FrameMS;
                ret.Spell = CUtils.TryClone<LaunchSpell>(this.Spell);
                ret.Effect = CUtils.TryClone<LaunchEffect>(this.Effect);
                ret.Attack = CUtils.TryClone<AttackProp>(this.Attack);
                ret.Summon = CUtils.TryClone<SummonUnit>(this.Summon);
                return ret;
            }


            public void WriteExternal(IOutputStream output)
            {
                output.PutS32(base.FrameMS);
                output.PutExt(this.Spell);
                output.PutExt(this.Effect);
                output.PutExt(this.Attack);
                output.PutExt(this.Summon);
            }

            public void ReadExternal(IInputStream input)
            {
                base.FrameMS = input.GetS32();
                this.Spell = input.GetExt<LaunchSpell>();
                this.Effect = input.GetExt<LaunchEffect>();
                this.Attack = input.GetExt<AttackProp>();
                this.Summon = input.GetExt<SummonUnit>();
            }
        }

    }

    //---------------------------------------------------------------------------------//
    /// <summary>
    /// BUFF类数据结构
    /// </summary>
    [MessageType(0x4006)]
    [DescAttribute("BUFF类数据结构")]
    [TableClassAttribute("ID")]
    public class BuffTemplate : ICloneable, ITemplateData, IExternalizable
    {
        public int TemplateID { get { return ID; } }
        [XmlSerializable()]
        public string EditorPath { get; set; }

        [DescAttribute("ID", "", false)]
        public int ID;

        [LocalizationTextAttribute]
        [DescAttribute("Buff名字")]
        public string Name;
        [DescAttribute("技能图标", "资源")]
        public string IconName;

        [DescAttribute("需要同步客户端")]
        public bool ClientVisible = true;

        [DescAttribute("生命周期(毫秒)")]
        public int LifeTimeMS;

        //--------------------------------------------------------------

        [DescAttribute("每间隔多少毫秒就触发一次", "关键帧")]
        public int HitIntervalMS;

        [DescAttribute("第0帧是否有效", "关键帧")]
        public bool FirstTimeEnable = true;

        [DescAttribute("每间隔时间触发一次的时候起效", "关键帧")]
        public KeyFrame HitKeyFrame;

        [ListAttribute(typeof(KeyFrame))]
        [DescAttribute("所有关键帧", "关键帧")]
        public List<KeyFrame> KeyFrames = new List<KeyFrame>();

        [DescAttribute("Buff结束关键帧", "关键帧")]
        public KeyFrame EndKeyFrame;

        //--------------------------------------------------------------

        [DescAttribute("是否有害(Debuff)，否则为有益(Buff)", "BUFF")]
        public bool IsHarmful = false;
        [DescAttribute("Buff是否可以主动取消", "BUFF")]
        public bool IsCancelBySelf = false;
        [DescAttribute("Buff是否允许多个实例", "BUFF")]
        public bool IsDuplicating = false;
        [DescAttribute("Buff施放者死亡立即移除", "BUFF")]
        public bool IsRemoveOnSenderRemoved = true;
		[DescAttribute("死亡立即移除", "BUFF")]
		public bool IsRemoveOnDead = false;

		//--------------------------------------------------------------
		[DescAttribute("BUFF期间，强制单位进入BUFF特殊动作（即不会被其他动作打断）", "状态")]
        public string LockStateAction;

        [DescAttribute("是否隐身", "状态")]
        public bool IsInvisible = false;
        [DescAttribute("是否无敌", "状态")]
        public bool IsInvincible = false;
        [DescAttribute("是否沉默（只能释放BaseSkill）", "状态")]
        public bool IsSilent = false;
        [DescAttribute("是否沉默允许移动", "状态")]
        public bool IsCanMove = true;
        [DescAttribute("产生眩晕", "状态")]
        public bool MakeStun = false;
		[DescAttribute("免疫控制", "状态")]
		public bool IgnoreControl = false;

		[DescAttribute("单位被动触发系，一直绑定关系", "状态")]
        public LaunchTrigger UnitTrigger;

        //--------------------------------------------------------------
        [DescAttribute("允许变身", "变身 - 造型")]
        public bool MakeAvatar = false;

        [DescAttribute("单位变身的模型文件名", "变身 - 造型")]
        [ResourceIDAttribute]
        [DependOnProperty("MakeAvatar")]
        public string UnitFileName;
        //--------------------------------------------------------------
        [DescAttribute("允许改变技能", "变身 - 技能")]
        public bool UnitChangeSkills = false;

        [DescAttribute("此单位变身普通攻击技能", "变身 - 技能")]
        [DependOnProperty("UnitChangeSkills")]
        public LaunchSkill UnitBaseSkillID;

        [ListAttribute(typeof(LaunchSkill))]
        [DescAttribute("此单位变身绑定的所有技能ID", "变身 - 技能")]
        [DependOnProperty("UnitChangeSkills")]
        public List<LaunchSkill> UnitSkills = new List<LaunchSkill>();

        [DescAttribute("变身改变技能时，保留的技能ID", "变身 - 技能")]
        [TemplatesIDAttribute(typeof(SkillTemplate))]
        [DependOnProperty("UnitChangeSkills")]
        public List<int> UnitKeepSkillsID = new List<int>();
        //--------------------------------------------------------------

        //--------------------------------------------------------------

        [DescAttribute("是否可堆叠层数", "堆叠")]
        public bool IsOverlay = false;
        [DescAttribute("最高可堆叠层数", "堆叠")]
        [DependOnProperty("IsOverlay")]
        public byte MaxOverlay = 1;

        [DescAttribute("是否为被动系，则不显示在面板")]
        public bool IsPassive = false;

        public enum BindingPlayType : byte
        {
            [DescAttribute("一次性全部播放，配置多少，播放多少")]
            All = 0,
            [DescAttribute("根据层数去播放，那一层播放那一个")]
            AppointOverLayer = 1,
            [DescAttribute("包含层数，如果层数是2，会同时播放1和2的特效")]
            IncludeOverLayer = 2,
        }

        [DescAttribute("BindingEffectList的播放模式（客户端用）", "特效")]
        public BindingPlayType PlayType = BindingPlayType.All;

        [DescAttribute("BUFF期间绑定特效（客户端用）", "特效")]
        public LaunchEffect BindingEffect;

        [ListAttribute(typeof(LaunchEffect))]
        [DescAttribute("BUFF期间绑定特效集合（客户端用）", "特效")]
        public List<LaunchEffect> BindingEffectList = new List<LaunchEffect>();

        [ListAttribute(typeof(LaunchEffect))]
        [DescAttribute("BUFF期间每层绑定特效（每层对应一个特效，客户端用）", "特效")]
        [DependOnProperty("IsOverlay")]
        public List<LaunchEffect> OverlayBindingEffect = new List<LaunchEffect>();
        //--------------------------------------------------------------

        [DescAttribute("互斥类型，同类型不能出现两个(非0有效)", "互斥")]
        public int ExclusiveCatgory;
        [DescAttribute("互斥优先级，如果优先级相等，则替换", "互斥")]
        public int ExclusivePriority;

        //--------------------------------------------------------------

        [DescAttribute("Buff用户自定义扩展属性", "扩展")]
        [Expandable]
        [NotNull]
        public IBuffProperties Properties;

        [DescAttribute("自定义字段", "属性", true)]
        public string[] Attributes;

		//内部使用的一些字段，
		[DescAttribute("强制加，跳过boss免控限制", "属性", true)]
		public bool forceAdd;

        public BuffTemplate()
        {
            this.Properties = TemplateManager.Factory.CreateBuffProperties();
        }
        public int GetID()
        {
            return ID;
        }
        public override string ToString()
        {
            return Name + "(" + ID + ")";
        }

        public object Clone()
        {
            BuffTemplate ret = new BuffTemplate();
            ret.EditorPath = this.EditorPath;
            ret.ID = this.ID;
            ret.Name = this.Name;
            ret.IconName = this.IconName;
            ret.ClientVisible = this.ClientVisible;
            ret.LifeTimeMS = this.LifeTimeMS;
            ret.HitIntervalMS = this.HitIntervalMS;
            ret.FirstTimeEnable = this.FirstTimeEnable;
            ret.HitKeyFrame = CUtils.TryClone<KeyFrame>(this.HitKeyFrame);
            ret.KeyFrames = CUtils.CloneList<KeyFrame>(this.KeyFrames);

            ret.IsHarmful = this.IsHarmful;
            ret.IsCancelBySelf = this.IsCancelBySelf;
            ret.IsDuplicating = this.IsDuplicating;

            ret.EndKeyFrame = CUtils.TryClone<KeyFrame>(this.EndKeyFrame);
            ret.IsInvisible = this.IsInvisible;
            ret.IsInvincible = this.IsInvincible;
            ret.IsSilent = this.IsSilent;
            ret.IsCanMove = this.IsCanMove;
            ret.MakeStun = this.MakeStun;
			ret.IgnoreControl = this.IgnoreControl;
			ret.IsRemoveOnSenderRemoved = this.IsRemoveOnSenderRemoved;
			ret.IsRemoveOnDead = this.IsRemoveOnDead;

			ret.LockStateAction = this.LockStateAction;
            ret.UnitTrigger = CUtils.TryClone<LaunchTrigger>(this.UnitTrigger);

            ret.MakeAvatar = this.MakeAvatar;
            ret.UnitFileName = this.UnitFileName;
            ret.UnitChangeSkills = this.UnitChangeSkills;
            ret.UnitBaseSkillID = CUtils.TryClone<LaunchSkill>(this.UnitBaseSkillID);
            ret.UnitSkills = CUtils.CloneList<LaunchSkill>(this.UnitSkills);
            ret.UnitKeepSkillsID = new List<int>(this.UnitKeepSkillsID);

            ret.IsOverlay = this.IsOverlay;
            ret.MaxOverlay = this.MaxOverlay;
            ret.IsPassive = this.IsPassive;
            ret.BindingEffect = CUtils.TryClone<LaunchEffect>(this.BindingEffect);
            ret.PlayType = this.PlayType;
            ret.BindingEffectList = CUtils.CloneList<LaunchEffect>(this.BindingEffectList);
            ret.OverlayBindingEffect = CUtils.CloneList<LaunchEffect>(this.OverlayBindingEffect);

            ret.ExclusiveCatgory = this.ExclusiveCatgory;
            ret.ExclusivePriority = this.ExclusivePriority;

            ret.Properties = CUtils.TryClone<IBuffProperties>(this.Properties);
            ret.Attributes = CUtils.CloneArray<string>(this.Attributes);
			ret.forceAdd = this.forceAdd;

			return ret;
        }
        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.EditorPath);
            output.PutS32(this.ID);
            output.PutUTF(this.Name);
            output.PutUTF(this.IconName);
            output.PutS32(this.LifeTimeMS);
            output.PutBool(this.ClientVisible);
            output.PutS32(this.HitIntervalMS);
            output.PutBool(this.FirstTimeEnable);
            output.PutExt(this.HitKeyFrame);
            output.PutList(this.KeyFrames, output.PutExt);
            output.PutExt(this.EndKeyFrame);

            output.PutBool(this.IsHarmful);
            output.PutBool(this.IsCancelBySelf);
            output.PutBool(this.IsDuplicating);

            output.PutBool(this.IsInvisible);
            output.PutBool(this.IsInvincible);
            output.PutBool(this.IsSilent);
            output.PutBool(this.IsCanMove);
            output.PutBool(this.MakeStun);
			output.PutBool(this.IgnoreControl);
            output.PutBool(this.IsRemoveOnSenderRemoved);
			output.PutBool(this.IsRemoveOnDead);

            output.PutUTF(this.LockStateAction);
            output.PutExt(this.UnitTrigger);

            output.PutBool(this.MakeAvatar);
            output.PutUTF(this.UnitFileName);
            output.PutBool(this.UnitChangeSkills);
            output.PutExt(this.UnitBaseSkillID);
            output.PutList(this.UnitSkills, output.PutExt);
            output.PutList(this.UnitKeepSkillsID, output.PutS32);

            output.PutBool(this.IsOverlay);
            output.PutU8(this.MaxOverlay);
            output.PutBool(this.IsPassive);
            output.PutExt(this.BindingEffect);
            output.PutEnum8(this.PlayType);
            output.PutList(this.BindingEffectList, output.PutExt);
            output.PutList(this.OverlayBindingEffect, output.PutExt);

            output.PutS32(this.ExclusiveCatgory);
            output.PutS32(this.ExclusivePriority);

            output.PutExt(this.Properties);
            output.PutArray(this.Attributes, output.PutUTF);
			output.PutBool(this.forceAdd);
        }
        public void ReadExternal(IInputStream input)
        {
            this.EditorPath = input.GetUTF();
            this.ID = input.GetS32();
            this.Name = input.GetUTF();
            this.IconName = input.GetUTF();
            this.LifeTimeMS = input.GetS32();
            this.ClientVisible = input.GetBool();
            this.HitIntervalMS = input.GetS32();
            this.FirstTimeEnable = input.GetBool();
            this.HitKeyFrame = input.GetExt<KeyFrame>();
            this.KeyFrames = input.GetList<KeyFrame>(input.GetExt<KeyFrame>);
            this.EndKeyFrame = input.GetExt<KeyFrame>();

            this.IsHarmful = input.GetBool();
            this.IsCancelBySelf = input.GetBool();
            this.IsDuplicating = input.GetBool();

            this.IsInvisible = input.GetBool();
            this.IsInvincible = input.GetBool();
            this.IsSilent = input.GetBool();
            this.IsCanMove = input.GetBool();
            this.MakeStun = input.GetBool();
			this.IgnoreControl = input.GetBool();
			this.IsRemoveOnSenderRemoved = input.GetBool();
			this.IsRemoveOnDead = input.GetBool();

			this.LockStateAction = input.GetUTF();
            this.UnitTrigger = input.GetExt<LaunchTrigger>();

            this.MakeAvatar = input.GetBool();
            this.UnitFileName = input.GetUTF();
            this.UnitChangeSkills = input.GetBool();
            this.UnitBaseSkillID = input.GetExt<LaunchSkill>();
            this.UnitSkills = input.GetList<LaunchSkill>(input.GetExt<LaunchSkill>);
            this.UnitKeepSkillsID = input.GetList<int>(input.GetS32);

            this.IsOverlay = input.GetBool();
            this.MaxOverlay = input.GetU8();
            this.IsPassive = input.GetBool();
            this.BindingEffect = input.GetExt<LaunchEffect>();
            this.PlayType = input.GetEnum8<BindingPlayType>();
            this.BindingEffectList = input.GetList<LaunchEffect>(input.GetExt<LaunchEffect>);
            this.OverlayBindingEffect = input.GetList<LaunchEffect>(input.GetExt<LaunchEffect>);

            this.ExclusiveCatgory = input.GetS32();
            this.ExclusivePriority = input.GetS32();

            this.Properties = input.GetExt<IBuffProperties>(this.Properties);
            this.Attributes = input.GetUTFArray();
			this.forceAdd = input.GetBool();
        }
        //--------------------------------------------


        //--------------------------------------------

        /// <summary>
        /// BUFF伤害或特效关键帧
        /// </summary>
        [MessageType(0x4106)]
        [DescAttribute("BUFF伤害或特效关键帧")]
        [Expandable]
        public class KeyFrame : BaseKeyFrame, ICloneable, IExternalizable
        {
            /// <summary>
            /// 触发的特效
            /// </summary>
            [DescAttribute("触发的特效")]
            public LaunchEffect Effect;

            /// <summary>
            /// 触发新的法术
            /// </summary>
            [DescAttribute("触发新的法术")]
            public LaunchSpell Spell;

            /// <summary>
            /// 攻击伤害
            /// </summary>
            [DescAttribute("攻击伤害")]
            public AttackProp Attack;

            /// <summary>
            /// 直接使用道具
            /// </summary>
            [DescAttribute("直接使用道具")]
            public UseItem Item;

			/// <summary>
			/// 直接使用道具
			/// </summary>
			[DescAttribute("场景添加道具")]
			public BuffAddItem addItem;

			public KeyFrame() { }

            public override string ToString()
            {
                return "Frame: @" + FrameMS;
            }


            public object Clone()
            {
                KeyFrame ret = new KeyFrame();
                ret.FrameMS = this.FrameMS;
                ret.Spell = CUtils.TryClone<LaunchSpell>(this.Spell);
                ret.Effect = CUtils.TryClone<LaunchEffect>(this.Effect);
                ret.Attack = CUtils.TryClone<AttackProp>(this.Attack);
                ret.Item = CUtils.TryClone<UseItem>(this.Item);
				ret.addItem = CUtils.TryClone<BuffAddItem>(this.addItem);

				return ret;
            }


            public void WriteExternal(IOutputStream output)
            {
                output.PutS32(base.FrameMS);
                output.PutExt(this.Spell);
                output.PutExt(this.Effect);
                output.PutExt(this.Attack);
                output.PutExt(this.Item);
				output.PutExt(this.addItem);
            }

            public void ReadExternal(IInputStream input)
            {
                base.FrameMS = input.GetS32();
                this.Spell = input.GetExt<LaunchSpell>();
                this.Effect = input.GetExt<LaunchEffect>();
                this.Attack = input.GetExt<AttackProp>();
                this.Item = input.GetExt<UseItem>();
				this.addItem = input.GetExt<BuffAddItem>();
            }
        }

    }

    //---------------------------------------------------------------------------------//

    //---------------------------------------------------------------------------------//
    /// <summary>
    /// 掉落道具类数据结构
    /// </summary>
    [MessageType(0x4007)]
    [DescAttribute("掉落道具类数据结构")]
    [TableClassAttribute("ID")]
    public class ItemTemplate : ICloneable, ITemplateData, IExternalizable
    {
        public int TemplateID { get { return ID; } }
        [XmlSerializable()]
        public string EditorPath { get; set; }

        [DescAttribute("ID", "", false)]
        public int ID;

        [LocalizationTextAttribute]
        [DescAttribute("掉落道具名字", "道具")]
        public string Name;
        [DescAttribute("掉落道具名字", "道具")]
        public string IconName;
        [DescAttribute("使用间隔时间（毫秒）", "道具")]
        public int UseCoolDownTimeMS = 0;
		[DescAttribute("场景显示的名字", "道具")]
		public string DisplayName;

		[DescAttribute("道具是否可被手动检取（如果手动检取，则不能直接走上去获得）", "捡取")]
        public bool Pickable = false;
        [DescAttribute("手动检取读条时间（毫秒）", "捡取")]
        [DependOnProperty("Pickable")]
        public int PickTimeMS = 2000;
        [DescAttribute("拾取后删除", "捡取")]
        public bool RemoveOnFinishPick = true;

        [DescAttribute("最大拾取人数", "捡取")]
        public byte maxPickPlayers = 0;
        [DescAttribute("单人最大拾取次数", "捡取")]
        public short maxPickTimes = 0;

        [DescAttribute("掉落后多久可以获得（毫秒）", "掉落")]
        public int GotCoolDownTimeMS = 500;
        [DescAttribute("掉落道具全阵营有效", "掉落")]
        public bool DropForAll;
        [DescAttribute("掉落道具仅玩家有效", "掉落")]
        public bool PlayerOnly = true;
        [DescAttribute("获得即使用", "掉落")]
        public bool GotOnUse = true;
        [DescAttribute("掉落金币最小值", "掉落")]
        public int DropMoneyMin = 0;
        [DescAttribute("掉落金币最大值", "掉落")]
        public int DropMoneyMax = 0;

        [DescAttribute("获得后的特效(检取者)", "特效")]
        public LaunchEffect GotEffect;
        [DescAttribute("获得后的特效(自身)", "特效")]
        public LaunchEffect GotEffectSelf;
        [DescAttribute("掉落时的特效", "特效")]
        public LaunchEffect DropEffect;

        [ResourceIDAttribute]
        [DescAttribute("资源模型名字", "资源")]
        public string FileName;
        [DescAttribute("拾取范围，半径", "资源")]
        public float BodySize = 1f;
        [DescAttribute("客户端可见", "资源")]
        public bool ClientVisible = true;
        
        [DescAttribute("道具产生后，持续时间(毫秒)", "掉落")]
        public int LifeTimeMS = 10000;

        [DescAttribute("道具产生后，显示截止时间戳(秒)", "掉落")]
        public int LifeEndTime = 0;

        [DescAttribute("道具飞到拾取者身上的插值(仅客户端表现用)", "掉落")]
        public float FlyLerp = 0.1f;

        [DescAttribute("是否显示持续时间 ", "掉落")]
        public bool showLifeTime = false;

        [DescAttribute("物品掉落的动画时长(毫秒)", "掉落")]
        public float AnimatorTime = -1.0f;

		[DescAttribute("仅做显示用", "掉落")]
		public bool OnlyForShow = false;

        [DescAttribute("模型上是否显示品质光柱", "掉落")]
        public bool ShowQualityEffect = true;

        [DescAttribute("使用后的特效", "特效")]
        public LaunchEffect UseEffect;

        [DescAttribute("使用后释放一个法术", "使用")]
        public LaunchSpell UseSpell;
        [DescAttribute("使用后召唤单位", "使用")]
        public SummonUnit UseSummon;

        [DescAttribute("使用后增加BUFF列表", "使用")]
        [ListAttribute(typeof(LaunchBuff))]
        public List<LaunchBuff> UseBuffs = new List<LaunchBuff>();
        [DescAttribute("装备后增加BUFF列表", "装备")]
        [ListAttribute(typeof(LaunchBuff))]
        public List<LaunchBuff> EquipBuffs = new List<LaunchBuff>();

        [DescAttribute("在背包内最大堆叠数量", "背包")]
        public int MaxStackCount = 100;
        [DescAttribute("最大持有数量，0表示无上限", "背包")]
        public int HoldingLimit = 0;
        [DescAttribute("是否在背包内可使用", "背包")]
        public bool IsInventoryUseable = true;
        [DescAttribute("是否可携带多个(包括堆叠)", "背包")]
        public bool IsDuplicateInventory = true;
        [DescAttribute("同步到服务器（可持久化保存的道具）", "背包")]
        public bool SyncToServer = false;
        [DescAttribute("背包道具使用读条(毫秒)", "背包")]
        public int UseInProgressTimeMS = 0;

        [DescAttribute("购买花费金币", "购买")]
        public bool BuyCostMoney;
        [DescAttribute("出售花费金币", "购买")]
        public bool SellGotMoney;

        [DescAttribute("是否弹出非物品类的二级面板", "显示")]
        public bool IsPopPanel = false;

        [ListAttribute(typeof(FlyEffect))]
        [DescAttribute("飞行特效", "妖气修为")]
        public List<FlyEffect> Fly;

        /// <summary>
        /// 道具扩展属性
        /// </summary>
        [DescAttribute("道具扩展属性", "扩展")]
        [Expandable]
        [NotNull]
        public IItemProperties Properties;

        public ItemTemplate()
        {
            this.Properties = TemplateManager.Factory.CreateItemProperties();
        }
        public ItemTemplate(int id)
        {
            this.ID = id;
            this.Properties = TemplateManager.Factory.CreateItemProperties();
        }
        public int GetID()
        {
            return ID;
        }
        public override string ToString()
        {
            return Name + "(" + ID + ")";
        }

        public object Clone()
        {
            ItemTemplate ret = new ItemTemplate();
            ret.EditorPath = this.EditorPath;
            ret.ID = this.ID;
            ret.Name = this.Name;
            ret.IconName = this.IconName;

            ret.Pickable = this.Pickable;
            ret.PickTimeMS = this.PickTimeMS;
            ret.RemoveOnFinishPick = this.RemoveOnFinishPick;

            ret.GotCoolDownTimeMS = this.GotCoolDownTimeMS;
            ret.DropForAll = this.DropForAll;
            ret.PlayerOnly = this.PlayerOnly;
            ret.GotOnUse = this.GotOnUse;
            ret.DropMoneyMin = this.DropMoneyMin;
            ret.DropMoneyMax = this.DropMoneyMax;
            ret.GotEffect = CUtils.TryClone<LaunchEffect>(this.GotEffect);
            ret.GotEffectSelf = CUtils.TryClone<LaunchEffect>(this.GotEffectSelf);
            ret.DropEffect = CUtils.TryClone<LaunchEffect>(this.DropEffect);

            ret.FileName = this.FileName;
            ret.BodySize = this.BodySize;
            ret.ClientVisible = this.ClientVisible;
            ret.LifeTimeMS = this.LifeTimeMS;

            ret.UseEffect = CUtils.TryClone<LaunchEffect>(this.UseEffect);
            ret.UseSpell = CUtils.TryClone<LaunchSpell>(this.UseSpell);
            ret.UseSummon = CUtils.TryClone<SummonUnit>(this.UseSummon);
            ret.UseBuffs = CUtils.CloneList<LaunchBuff>(this.UseBuffs);
            ret.EquipBuffs = CUtils.CloneList<LaunchBuff>(this.EquipBuffs);

            ret.MaxStackCount = this.MaxStackCount;
            ret.HoldingLimit = this.HoldingLimit;
            ret.IsInventoryUseable = this.IsInventoryUseable;
            ret.UseCoolDownTimeMS = this.UseCoolDownTimeMS;
            ret.IsDuplicateInventory = this.IsDuplicateInventory;
            ret.SyncToServer = this.SyncToServer;
            ret.UseInProgressTimeMS = this.UseInProgressTimeMS;
            ret.FlyLerp = this.FlyLerp;
            ret.showLifeTime = this.showLifeTime;
            ret.AnimatorTime = this.AnimatorTime;
            ret.LifeEndTime = this.LifeEndTime;
            ret.IsPopPanel = this.IsPopPanel;

            ret.Fly = CUtils.CloneList<FlyEffect>(this.Fly);
            ret.Properties = CUtils.TryClone<IItemProperties>(this.Properties);

			ret.maxPickPlayers = this.maxPickPlayers;
			ret.maxPickTimes = this.maxPickTimes;

			ret.OnlyForShow = this.OnlyForShow;
			ret.DisplayName = this.DisplayName;
            ret.ShowQualityEffect = this.ShowQualityEffect;


            return ret;
        }
        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.EditorPath);
            output.PutS32(this.ID);
            output.PutUTF(this.Name);
            output.PutUTF(this.IconName);

            output.PutBool(this.Pickable);
            output.PutS32(this.PickTimeMS);
            output.PutBool(this.RemoveOnFinishPick);

            output.PutS32(this.GotCoolDownTimeMS);
            output.PutBool(this.DropForAll);
            output.PutBool(this.PlayerOnly);
            output.PutBool(this.GotOnUse);
            output.PutS32(this.DropMoneyMin);
            output.PutS32(this.DropMoneyMax);
            output.PutExt(this.GotEffect);
            output.PutExt(this.GotEffectSelf);
            output.PutExt(this.DropEffect);

            output.PutUTF(this.FileName);
            output.PutF32(this.BodySize);
            output.PutBool(this.ClientVisible);
            output.PutS32(this.LifeTimeMS);

            output.PutExt(this.UseEffect);
            output.PutExt(this.UseSpell);
            output.PutExt(this.UseSummon);
            output.PutList(this.UseBuffs, output.PutExt);
            output.PutList(this.EquipBuffs, output.PutExt);

            output.PutS32(this.MaxStackCount);
            output.PutS32(this.HoldingLimit);
            output.PutBool(this.IsInventoryUseable);
            output.PutS32(this.UseCoolDownTimeMS);
            output.PutBool(this.IsDuplicateInventory);
            output.PutBool(this.SyncToServer);
            output.PutS32(this.UseInProgressTimeMS);

            output.PutExt(this.Properties);
            output.PutBool(this.showLifeTime);
            output.PutF32(this.FlyLerp);
            if (this.showLifeTime)
            {
                output.PutS32(this.LifeEndTime);
            }
            output.PutF32(this.AnimatorTime);
            output.PutBool(this.IsPopPanel);
            output.PutList<FlyEffect>(this.Fly, output.PutExt);
			output.PutS16(this.maxPickTimes);
			output.PutU8(this.maxPickPlayers);
			output.PutBool(this.OnlyForShow);
			output.PutUTF(this.DisplayName);
            output.PutBool(this.ShowQualityEffect);
        }
        public void ReadExternal(IInputStream input)
        {
            this.EditorPath = input.GetUTF();
            this.ID = input.GetS32();
            this.Name = input.GetUTF();
            this.IconName = input.GetUTF();

            this.Pickable = input.GetBool();
            this.PickTimeMS = input.GetS32();
            this.RemoveOnFinishPick = input.GetBool();

            this.GotCoolDownTimeMS = input.GetS32();
            this.DropForAll = input.GetBool();
            this.PlayerOnly = input.GetBool();
            this.GotOnUse = input.GetBool();
            this.DropMoneyMin = input.GetS32();
            this.DropMoneyMax = input.GetS32();
            this.GotEffect = input.GetExt<LaunchEffect>();
            this.GotEffectSelf = input.GetExt<LaunchEffect>();
            this.DropEffect = input.GetExt<LaunchEffect>();

            this.FileName = input.GetUTF();
            this.BodySize = input.GetF32();
            this.ClientVisible = input.GetBool();
            this.LifeTimeMS = input.GetS32();

            this.UseEffect = input.GetExt<LaunchEffect>();
            this.UseSpell = input.GetExt<LaunchSpell>();
            this.UseSummon = input.GetExt<SummonUnit>();
            this.UseBuffs = input.GetList<LaunchBuff>(input.GetExt<LaunchBuff>);
            this.EquipBuffs = input.GetList<LaunchBuff>(input.GetExt<LaunchBuff>);

            this.MaxStackCount = input.GetS32();
            this.HoldingLimit = input.GetS32();
            this.IsInventoryUseable = input.GetBool();
            this.UseCoolDownTimeMS = input.GetS32();
            this.IsDuplicateInventory = input.GetBool();
            this.SyncToServer = input.GetBool();
            this.UseInProgressTimeMS = input.GetS32();

            this.Properties = input.GetExt<IItemProperties>(this.Properties);
            this.showLifeTime = input.GetBool();
            this.FlyLerp = input.GetF32();
            if (this.showLifeTime)
            {
                this.LifeEndTime = input.GetS32();
            }
            this.AnimatorTime = input.GetF32();
            this.IsPopPanel = input.GetBool();
            this.Fly = input.GetList<FlyEffect>(input.GetExt<FlyEffect>);

			this.maxPickTimes = input.GetS16();
			this.maxPickPlayers = input.GetU8();
			this.OnlyForShow = input.GetBool();
			this.DisplayName = input.GetUTF();
            this.ShowQualityEffect = input.GetBool();
		}
    }

    [MessageType(0x4018)]
    [DescAttribute("物品飞行特效")]
    [Expandable]
    public class FlyEffect : ICloneable, IExternalizable
    {
        [DescAttribute("特效名字")]
        public string Name;
        [DescAttribute("特效时长(秒数)")]
        public float Time;
        [DescAttribute("以玩家为目标点")]
        public bool isActorPos;
        [DescAttribute("是否绑定在节点上")]
        public bool isBindPart;
        [DescAttribute("特效飞至的部位")]
        public string PartName;
        [DescAttribute("特效拉升的高度")]
        public float Height;
        [DescAttribute("特效速度")]
        public float Speed;
        [DescAttribute("运行方向 0:原点 1:上  2：下  3：左  4：右  5：前  6：后")]
        public byte RunDirection = 0;
        [DescAttribute("音效文件名")]
        public string AudioName;
        [DescAttribute("是否到达玩家位置就删除特效")]
        public bool IsGoToActorPosAndRemove;
        [DescAttribute("特效和玩家之间的最小距离，小于等于这个距离，这个特效将会移除")]
        [DependOnProperty("IsGoToActorPosAndRemove")]
        public float MinDistance = 0.05f;
        [DescAttribute("基于此节点激活间隔时长")]
        public bool IsBeginActiveIntervalTime = false;
        [DescAttribute("间隔时长，基于激活后的时间间隔")]
        public float IntervalTime = -1;
        [DescAttribute("此特效移除后，关联下一个特效的index")]
        public int NextEffectIndex = -1;
        [DescAttribute("此特效生成时，基于那个index特效的坐标")]
        public int PosIndex = -1;


        public object Clone()
        {
            FlyEffect ret = new FlyEffect();
            ret.Name = this.Name;
            ret.Time = this.Time;
            ret.PartName = this.PartName;
            ret.Height = this.Height;
            ret.isActorPos = this.isActorPos;
            ret.isBindPart = this.isBindPart;
            ret.Speed = this.Speed;
            ret.RunDirection = this.RunDirection;
            ret.AudioName = this.AudioName;
            ret.IsGoToActorPosAndRemove = this.IsGoToActorPosAndRemove;
            ret.IsBeginActiveIntervalTime = this.IsBeginActiveIntervalTime;
            ret.IntervalTime = this.IntervalTime;
            ret.NextEffectIndex = this.NextEffectIndex;
            ret.PosIndex = this.PosIndex;
            return ret;
        }

        public void ReadExternal(IInputStream input)
        {
            this.Name = input.GetUTF();
            this.Time = input.GetF32();
            this.PartName = input.GetUTF();
            this.Height = input.GetF32();
            this.isActorPos = input.GetBool();
            this.isBindPart = input.GetBool();
            this.Speed = input.GetF32();
            this.RunDirection = input.GetU8();
            this.AudioName = input.GetUTF();
            this.IsGoToActorPosAndRemove = input.GetBool();
            this.IsBeginActiveIntervalTime = input.GetBool();
            this.IntervalTime = input.GetF32();
            this.NextEffectIndex = input.GetS32();
            this.PosIndex = input.GetS32();
        }

        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.Name);
            output.PutF32(this.Time);
            output.PutUTF(this.PartName);
            output.PutF32(this.Height);
            output.PutBool(this.isActorPos);
            output.PutBool(this.isBindPart);
            output.PutF32(this.Speed);
            output.PutU8(this.RunDirection);
            output.PutUTF(this.AudioName);
            output.PutBool(this.IsGoToActorPosAndRemove);
            output.PutBool(this.IsBeginActiveIntervalTime);
            output.PutF32(this.IntervalTime);
            output.PutS32(this.NextEffectIndex);
            output.PutS32(this.PosIndex);
        }
    }

    //---------------------------------------------------------------------------------//

    [MessageType(0x4015)]
    [DescAttribute("单位事件触发")]
    [TableClassAttribute("ID")]
    public class UnitEventTemplate : ICloneable, ITemplateData, IExternalizable
    {
        public int TemplateID { get { return ID; } }
        [XmlSerializable()]
        public string EditorPath { get; set; }

        [DescAttribute("ID", "", false)]
        public int ID;
        [LocalizationTextAttribute]
        [DescAttribute("单位事件触发名字", "基础")]
        public string Name;

        [ListAttribute(typeof(UnitEvent))]
        [DescAttribute("所有事件", "基础", false)]
        public List<UnitEvent> Events = new List<UnitEvent>();

        public override string ToString()
        {
            return Name + "(" + ID + ")";
        }
        public object Clone()
        {
            UnitEventTemplate ret = new UnitEventTemplate();
            ret.EditorPath = this.EditorPath;
            ret.ID = this.ID;
            ret.Name = this.Name;
            ret.Events = CUtils.CloneList<UnitEvent>(this.Events);
            return ret;
        }
        public void WriteExternal(IOutputStream output)
        {
            output.PutUTF(this.EditorPath);
            output.PutS32(this.ID);
            output.PutUTF(this.Name);

            output.PutList(this.Events, output.PutExt);
        }
        public void ReadExternal(IInputStream input)
        {
            this.EditorPath = input.GetUTF();
            this.ID = input.GetS32();
            this.Name = input.GetUTF();
            this.Events = input.GetList(input.GetExt<UnitEvent>);
        }
        public UnitEvent GetEvent(string name)
        {
            foreach (var e in Events)
            {
                if (e.Name == name) { return e; }
            }
            return null;
        }
    }


    #endregion

    //---------------------------------------------------------------------------------//

    #region __Launch_Objects__

    public abstract class BaseKeyFrame
    {
        [DescAttribute("关键帧时间(毫秒)")]
        public int FrameMS;
    }

    /// <summary>
    /// 技能或者法术产生的攻击属性
    /// </summary>
    [MessageType(0x4008)]
    [DescAttribute("技能或者法术产生的攻击属性")]
    [Expandable]
    public class AttackProp : ISNData, ICloneable
    {
        /// <summary>
        /// 攻击力
        /// </summary>
        [DescAttribute("攻击力")]
        public int Attack;

        [DescAttribute("产生受击", "Mask")]
        public bool MaskDamage = false;
        [DescAttribute("产生击飞", "Mask")]
        [DependOnProperty("MaskDamage")]
        public bool MaskHitFly = false;
        [DescAttribute("产生击倒", "Mask")]
        [DependOnProperty("MaskDamage")]
        public bool MaskKnockDown = false;
        [DescAttribute("此次攻击必命中，即使命中为0", "Mask")]
        public bool MaskMustHit = false;
        [DescAttribute("此次攻击必暴击，即使暴击为0", "Mask")]
        public bool MaskMustCritical = false;


        [DescAttribute("击中力度(大于目标体重才会产生受击)", "受击")]
        [DependOnProperty("MaskDamage")]
        public int Weight = 1;
        [DescAttribute("单位被(受击、击倒、眩晕、混乱)持续时间(毫秒)" +
            "\n * 此时间如果为0，首先选用单位DamageTimeMS，否则然后采用Config环境参数OBJECT_DAMAGE_TIME_MS替代之。" +
            "\n * HitMove运动时间不计算在KnockOutTimeMS内。", "受击")]
        [DependOnProperty("MaskDamage")]
        public int KnockOutTimeMS = 0;
        [DescAttribute("受击动作名", "受击")]
        [DependOnProperty("MaskDamage")]
        public string DamageActionName = null;
        [DescAttribute("受击时，不再遭受其他攻击", "受击")]
        [DependOnProperty("MaskDamage")]
        public bool IsDamageProtect = false;


        public bool IsHitMove { get { return MaskDamage && HitMove != null; } }
        [DescAttribute("被击中后向后移动距离(包括击飞控制)", "受击")]
        [DependOnProperty("MaskDamage")]
        public StartMove HitMove;
        public enum HitMoveType : byte
        {
            [DescAttribute("根据攻击者位置（台球碰撞）")]
            BySenderPosition,
            [DescAttribute("根据攻击者朝向（单向）")]
            BySenderDirection,
            [DescAttribute("根据攻击者朝向的左右边（摩西分海）")]
            BySenderLeftRight,
            [DescAttribute("位移至攻击者中心（向里吸）")]
            ToSenderCenter,
            [DescAttribute("位移至攻击者身边（向里吸）")]
            ToSenderBodySize,
            [DescAttribute("位移至攻击固定范围外")]
            BySenderRange,
        }
        [DescAttribute("受击位移计算方式", "受击")]
        [DependOnProperty("IsHitMove")]
        public HitMoveType HitMoveMType = HitMoveType.BySenderPosition;
        [DescAttribute("受击位移时对其他单位产生伤害", "受击")]
        [DependOnProperty("IsHitMove")]
        public AttackProp HitMoveBodyAttack;
        [DescAttribute("基于被攻击者身体范围的增加范围", "受击")]
        [DependOnProperty("IsHitMove")]
        public float HitMoveBodyAttackSize = 1;
        [DescAttribute("被击飞落地后产生伤害，或者位移结束产生伤害", "受击")]
        [DependOnProperty("MaskDamage")]
        [DependOnProperty("MaskHitFly")]
        public AttackProp FlyFallenDownAttack;


        [DescAttribute("被击中特效", "被击中")]
        public LaunchEffect Effect;
        [DescAttribute("被击中触发一个BUFF", "被击中")]
        public LaunchBuff Buff;
        [DescAttribute("被击中触发一个Spell", "被击中")]
        public LaunchSpell Spell;


        [DescAttribute("百分比概率击碎目标", "击碎")]
        public float CrushPercent = 0;
        [DescAttribute("击碎目标效果", "击碎")]
        public LaunchEffect CrushEffect;

        [DescAttribute("定帧时长", "客户端")]
        public int StopFrameMS = 0;
        [DescAttribute("定帧类型", "客户端")]
        public string StopFrameAction;

        /// <summary>
        /// 用户自定义扩展属性
        /// </summary>
        [DescAttribute("用户自定义扩展属性", "扩展")]
        [Expandable]
        [NotNull]
        public IAttackProperties Properties;
        [DescAttribute("打死小怪是否击退", "受击")]
        public KillHitMove killHitMove;

        public AttackProp()
        {
            Properties = TemplateManager.Factory.CreateAttackProperties();
        }
        /// <summary>
        /// 是否产生受击
        /// </summary>
        /// <returns></returns>
        public bool IsDamage()
        {
            return MaskDamage || MaskHitFly || MaskKnockDown;
        }
        public override string ToString()
        {
            return "攻击";
        }


        public object Clone()
        {
            AttackProp ret = new AttackProp();
            ret.SerialNumber = this.SerialNumber;
            ret.Attack = this.Attack;
            ret.MaskDamage = this.MaskDamage;
            ret.MaskHitFly = this.MaskHitFly;
            ret.MaskKnockDown = this.MaskKnockDown;
            ret.MaskMustHit = this.MaskMustHit;
            ret.MaskMustCritical = this.MaskMustCritical;

            ret.Weight = this.Weight;
            ret.KnockOutTimeMS = this.KnockOutTimeMS;
            ret.IsDamageProtect = this.IsDamageProtect;
            ret.DamageActionName = this.DamageActionName;

            ret.Effect = CUtils.TryClone<LaunchEffect>(this.Effect);
            ret.Buff = CUtils.TryClone<LaunchBuff>(this.Buff);
            ret.Spell = CUtils.TryClone<LaunchSpell>(this.Spell);

            ret.HitMove = CUtils.TryClone<StartMove>(this.HitMove);
            ret.HitMoveMType = this.HitMoveMType;
            ret.HitMoveBodyAttack = CUtils.TryClone<AttackProp>(this.HitMoveBodyAttack);
            ret.HitMoveBodyAttackSize = this.HitMoveBodyAttackSize;
            ret.FlyFallenDownAttack = CUtils.TryClone<AttackProp>(this.FlyFallenDownAttack);

            ret.StopFrameMS = this.StopFrameMS;
            ret.StopFrameAction = this.StopFrameAction;

            ret.CrushPercent = this.CrushPercent;
            ret.CrushEffect = CUtils.TryClone<LaunchEffect>(this.CrushEffect);
            ret.Properties = CUtils.TryClone<IAttackProperties>(this.Properties);
            ret.killHitMove = CUtils.TryClone<KillHitMove>(this.killHitMove);
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(this.Attack);
            output.PutBool(this.MaskDamage);
            output.PutBool(this.MaskHitFly);
            output.PutBool(this.MaskKnockDown);
            output.PutBool(this.MaskMustHit);
            output.PutBool(this.MaskMustCritical);

            output.PutS32(this.Weight);
            output.PutS32(this.KnockOutTimeMS);
            output.PutBool(this.IsDamageProtect);
            output.PutUTF(this.DamageActionName);

            output.PutExt(this.Effect);
            output.PutExt(this.Buff);
            output.PutExt(this.Spell);

            output.PutExt(this.HitMove);
            output.PutEnum8(this.HitMoveMType);
            output.PutExt(this.HitMoveBodyAttack);
            output.PutF32(this.HitMoveBodyAttackSize);
            output.PutExt(this.FlyFallenDownAttack);

            output.PutS32(this.StopFrameMS);
            output.PutUTF(this.StopFrameAction);

            output.PutF32(this.CrushPercent);
            output.PutExt(this.CrushEffect);
            output.PutExt(this.Properties);
            output.PutExt(this.killHitMove);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.Attack = input.GetS32();
            this.MaskDamage = input.GetBool();
            this.MaskHitFly = input.GetBool();
            this.MaskKnockDown = input.GetBool();
            this.MaskMustHit = input.GetBool();
            this.MaskMustCritical = input.GetBool();

            this.Weight = input.GetS32();
            this.KnockOutTimeMS = input.GetS32();
            this.IsDamageProtect = input.GetBool();
            this.DamageActionName = input.GetUTF();

            this.Effect = input.GetExt<LaunchEffect>();
            this.Buff = input.GetExt<LaunchBuff>();
            this.Spell = input.GetExt<LaunchSpell>();

            this.HitMove = input.GetExt<StartMove>();
            this.HitMoveMType = input.GetEnum8<HitMoveType>();
            this.HitMoveBodyAttack = input.GetExt<AttackProp>();
            this.HitMoveBodyAttackSize = input.GetF32();
            this.FlyFallenDownAttack = input.GetExt<AttackProp>();

            this.StopFrameMS = input.GetS32();
            this.StopFrameAction = input.GetUTF();

            this.CrushPercent = input.GetF32();
            this.CrushEffect = input.GetExt<LaunchEffect>();
            this.Properties = input.GetExt<IAttackProperties>(this.Properties);
            this.killHitMove = input.GetExt<KillHitMove>();
        }
    }

    //---------------------------------------------------------------------------------//

    /// <summary>
    /// 触发特效，一般只用于显示
    /// </summary>
    [MessageType(0x4009)]
    [DescAttribute("触发特效，一般只用于显示")]
    [Expandable]
    public class LaunchEffect : ISNData, ICloneable
    {
        public enum RunType : byte
        {
            [DescAttribute("默认，沒有運行")]
            None = 0,
            [DescAttribute("圓形，以綁定點未中心")]
            Cycle_BindName = 1,
        }

        [DescAttribute("触发的特效名字")]
        [ResourceIDAttribute]
        public string Name;
        [DescAttribute("触发特效是否绑定在特定单位")]
        public bool BindBody = true;
        [DescAttribute("绑定挂载点位置")]
        public string BindPartName;
        [DescAttribute("如果不为0，则特效以该尺寸缩放")]
        public float ScaleToBodySize;
        [DescAttribute("特效高度的偏移量")]
        public float EffectHight = 0;
        [DescAttribute("特效水平方向的偏移量x")]
        public float EffectOffsetX = 0;
        [DescAttribute("特效水平方向的偏移量x")]
        public float EffectOffsetY = 0;

        [DescAttribute("音效")]
        [ResourceIDAttribute]
        public string SoundName;
        [DescAttribute("震屏时长(毫秒)", "震屏")]
        public int EarthQuakeMS;
        [DescAttribute("震屏幅度", "震屏")]
        public float EarthQuakeXYZ;
        [DescAttribute("自定义字段", "特效扩展")]
        public string Tag;
        [DescAttribute("摄像机动画名字")]
        public string CameraAnimation;

        [DescAttribute("特效持续时间，0表示只播放一次")]
        public int EffectTimeMS = 0;
        [DescAttribute("是否循环")]
        public bool IsLoop = false;
        [DescAttribute("是否同步施法者的Rotation")]
        public bool IsSyncSenderRotation = false;
        [DescAttribute("速度（原始动画/特效速度 * 速度）", "特效加速")]
        public float EffectAddSpeed = 1;
        [DescAttribute("特效中存在的动画，动画的名字", "特效加速")]
        public string AnimtionName;
        [DescAttribute("Buff運行方式")]
        public RunType RType = RunType.None;

        [DescAttribute("圆形运行参数设置")]
        public CricleSpeedMode CricleMode;

        public override string ToString()
        {
            return "触发特效:" + Name;
        }

        public object Clone()
        {
            LaunchEffect ret = new LaunchEffect();
            ret.SerialNumber = this.SerialNumber;
            ret.Name = this.Name;
            ret.BindBody = this.BindBody;
            ret.BindPartName = this.BindPartName;
            ret.ScaleToBodySize = this.ScaleToBodySize;
            ret.EffectHight = this.EffectHight;
            ret.EffectOffsetX = this.EffectOffsetX;
            ret.EffectOffsetY = this.EffectOffsetY;
            ret.SoundName = this.SoundName;
            ret.EarthQuakeMS = this.EarthQuakeMS;
            ret.EarthQuakeXYZ = this.EarthQuakeXYZ;
            ret.Tag = this.Tag;
            ret.CameraAnimation = this.CameraAnimation;
            ret.EffectTimeMS = this.EffectTimeMS;
            ret.IsLoop = this.IsLoop;
            ret.IsSyncSenderRotation = this.IsSyncSenderRotation;
            ret.EffectAddSpeed = this.EffectAddSpeed;
            ret.AnimtionName = this.AnimtionName;
            ret.RType = this.RType;
            ret.CricleMode = CUtils.TryClone<CricleSpeedMode>(this.CricleMode);
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutUTF(this.Name);
            output.PutBool(this.BindBody);
            output.PutUTF(this.BindPartName);
            output.PutF32(this.ScaleToBodySize);
            output.PutF32(this.EffectHight);
            output.PutF32(this.EffectOffsetX);
            output.PutF32(this.EffectOffsetY);
            output.PutUTF(this.SoundName);
            output.PutS32(this.EarthQuakeMS);
            output.PutF32(this.EarthQuakeXYZ);
            output.PutUTF(this.Tag);
            output.PutUTF(this.CameraAnimation);
            output.PutS32(this.EffectTimeMS);
            output.PutBool(this.IsLoop);
            output.PutBool(this.IsSyncSenderRotation);
            output.PutF32(this.EffectAddSpeed);
            output.PutUTF(this.AnimtionName);
            output.PutEnum8(this.RType);
            output.PutExt(this.CricleMode);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.Name = input.GetUTF();
            this.BindBody = input.GetBool();
            this.BindPartName = input.GetUTF();
            this.ScaleToBodySize = input.GetF32();
            this.EffectHight = input.GetF32();
            this.EffectOffsetX = input.GetF32();
            this.EffectOffsetY = input.GetF32();
            this.SoundName = input.GetUTF();
            this.EarthQuakeMS = input.GetS32();
            this.EarthQuakeXYZ = input.GetF32();
            this.Tag = input.GetUTF();
            this.CameraAnimation = input.GetUTF();
            this.EffectTimeMS = input.GetS32();
            this.IsLoop = input.GetBool();
            this.IsSyncSenderRotation = input.GetBool();
            this.EffectAddSpeed = input.GetF32();
            this.AnimtionName = input.GetUTF();
            this.RType = input.GetEnum8<RunType>();
            this.CricleMode = input.GetExt<CricleSpeedMode>();
        }
    }

    [MessageType(0x4017)]
    [DescAttribute("围绕中心点圆形运行(美术工程有testpos脚本，方便快速调试)")]
    [Expandable]
    public class CricleSpeedMode : ISNData, ICloneable
    {
        [DescAttribute("挂节点的半径")]
        public string[] EffectName;
        [DescAttribute("挂节点的半径")]
        public float Radius = 0;
        [DescAttribute("点间距")]
        public float Gap = 0;
        [DescAttribute("弧度")]
        public float Radian = 0;
        [DescAttribute("圆点距离")]
        public float CircleCenterDis = 0;
        [DescAttribute("圆点距离2")]
        public float CircleCenterDis2 = 0;
        [DescAttribute("互斥度")]
        public float Mutual = 0;
        [DescAttribute("高度")]
        public float Height = 0;
        [DescAttribute("x轴弧度")]
        public float X_Direction = 0;
        [DescAttribute("y轴弧度")]
        public float Y_Direction = 0;
        [DescAttribute("z轴弧度")]
        public float Z_Direction = 0;
        [DescAttribute("旋转速度")]
        public float RotationSpeed = 0;

        public object Clone()
        {
            CricleSpeedMode ret = new CricleSpeedMode();
            ret.SerialNumber = this.SerialNumber;
            ret.EffectName = CUtils.CloneArray<string>(this.EffectName);
            ret.Radius = this.Radius;
            ret.Gap = this.Gap;
            ret.Radian = this.Radian;
            ret.CircleCenterDis = this.CircleCenterDis;
            ret.CircleCenterDis2 = this.CircleCenterDis2;
            ret.Mutual = this.Mutual;
            ret.Height = this.Height;
            ret.X_Direction = this.X_Direction;
            ret.Y_Direction = this.Y_Direction;
            ret.Z_Direction = this.Z_Direction;
            ret.RotationSpeed = this.RotationSpeed;
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutArray(this.EffectName, output.PutUTF);
            output.PutF32(this.Radius);
            output.PutF32(this.Gap);
            output.PutF32(this.Radian);
            output.PutF32(this.CircleCenterDis);
            output.PutF32(this.CircleCenterDis2);
            output.PutF32(this.Mutual);
            output.PutF32(this.Height);
            output.PutF32(this.X_Direction);
            output.PutF32(this.Y_Direction);
            output.PutF32(this.Z_Direction);
            output.PutF32(this.RotationSpeed);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.EffectName = input.GetUTFArray();
            this.Radius = input.GetF32();
            this.Gap = input.GetF32();
            this.Radian = input.GetF32();
            this.CircleCenterDis = input.GetF32();
            this.CircleCenterDis2 = input.GetF32();
            this.Mutual = input.GetF32();
            this.Height = input.GetF32();
            this.X_Direction = input.GetF32();
            this.Y_Direction = input.GetF32();
            this.Z_Direction = input.GetF32();
            this.RotationSpeed = input.GetF32();
        }
    }
    //---------------------------------------------------------------------------------//

    /// <summary>
    /// 发起法术或者飞行道具
    /// </summary>
    [MessageType(0x400A)]
    [DescAttribute("释技能")]
    [Expandable]
    public class LaunchSkill : ISNData, ICloneable
    {
        [DescAttribute("SkillID")]
        [TemplateIDAttribute(typeof(SkillTemplate))]
        public int SkillID;

        [DescAttribute("释放技能权值-弃用")]
        public int Priority;

        [DescAttribute("AI自动释放技能-内部使用，不能设置")]
        public bool AutoLaunch = true;

        public LaunchSkill() { }
        public LaunchSkill(int skillID, bool autoLaunch = true)
        {
            this.SkillID = skillID;
			this.AutoLaunch = autoLaunch;
        }
        public override string ToString()
        {
            return "触发技能:" + SkillID;
        }

        public object Clone()
        {
            LaunchSkill ret = new LaunchSkill();
            ret.SerialNumber = this.SerialNumber;
            ret.SkillID = this.SkillID;
            ret.Priority = this.Priority;
            ret.AutoLaunch = this.AutoLaunch;
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(SkillID);
            output.PutS32(Priority);
            output.PutBool(AutoLaunch);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.SkillID = input.GetS32();
            this.Priority = input.GetS32();
            this.AutoLaunch = input.GetBool();
        }
    }

    //---------------------------------------------------------------------------------//

    /// <summary>
    /// 发起法术或者飞行道具
    /// </summary>
    [MessageType(0x400B)]
    [DescAttribute("释放法术或者飞行道具")]
    [Expandable]
    public class LaunchSpell : ISNData, ICloneable
    {
        public enum PosType : byte
        {
            /// <summary>
            /// 默认释放一个法术
            /// </summary>
            POS_TYPE_DEFAULT_SINGLE = 0,
            /// <summary>
            /// 随机范围内目标施放法术
            /// </summary>
            POS_TYPE_RANDOM_FOR_SPELL = 1,
			/// <summary>
			/// 打出圆环多个法术
			/// </summary>
			POS_TYPE_CYCLE = 2,
			/// <summary>
			/// 打出扇形多个法术
			/// </summary>
			POS_TYPE_FAN = 3,
            /// <summary>
            /// 随机方向
            /// </summary>
            POS_TYPE_RANDOM_DIRECTION = 4,
            /// <summary>
            /// 范围
            /// </summary>
            POS_TYPE_AREA = 5,
            /// <summary>
            /// 向同一个目标发射三个锁定法术
            /// </summary>
            POS_TYPE_TOSAMETARGET = 6,
			/// <summary>
			/// X型法术
			/// </summary>
			POS_TYPE_X = 7,
			/// <summary>
			/// 随机范围内施放法术
			/// </summary>
			POS_TYPE_RANDOM_POS = 8,

			/// <summary>
			/// 火箭飞弹
			/// 
			/// </summary>
			POS_TYPE_MANY_CANNON = 9,
		}

        /// <summary>
        /// 触发新的法术
        /// </summary>
        [DescAttribute("触发新的法术")]
        [TemplateIDAttribute(typeof(SpellTemplate))]
        public int SpellID;

        [DescAttribute("触发百分比")]
        public float LaunchPercent = 100f;

        /// <summary>
        /// 触发新的法术运行方式
        /// </summary>
        [DescAttribute("触发新的法术运行方式")]
        public PosType PType = PosType.POS_TYPE_DEFAULT_SINGLE;

        /// <summary>
        /// 触发新的法术数量
        /// </summary>
        [DescAttribute("法术范围")]
        [DependOnProperty("HasSpellRange")]
        public int SpellRange = 1;

        public bool MultiLaunch { get { return PType != PosType.POS_TYPE_DEFAULT_SINGLE; } }

		public bool HasSpellRange { get { return PType == PosType.POS_TYPE_RANDOM_FOR_SPELL || PType == PosType.POS_TYPE_RANDOM_POS; } }

		/// <summary>
		/// 触发新的法术数量
		/// </summary>
		[DescAttribute("触发新的法术数量")]
        [DependOnProperty("MultiLaunch")]
        public int Count = 1;

        /// <summary>
        /// 如果触发为扇形，则定义扇形范围
        /// </summary>
        [DescAttribute("扇形:扇形范围；X型：小角值")]
        [DependOnProperty("MultiLaunch")]
        public float Angle = 0;

        [DescAttribute("发射初始角度")]
        [DependOnProperty("MultiLaunch")]
        public float StartAngle = 0;

        public enum LaunchSpllSenderUnit : byte
        {
            [DescAttribute("默认")]
            Sender = 0,
            [DescAttribute("强制为施法者")]
            Launcher = 1,
            [DescAttribute("强制为被攻击者（只在Attack Launch Spell有效）")]
            DamagedUnit = 2,
			[DescAttribute("攻击者（在Buff中，buff的释加者）")]
			AttackerUnit = 3,
		}
        [DescAttribute("发射者", "发射者")]
        public LaunchSpllSenderUnit SenderUnit = LaunchSpllSenderUnit.Sender;


        [DescAttribute("填True，下面无效，发射口是否以单位炮口作为参考", "炮口")]
        public bool FromUnitBody = true;
        [DescAttribute("法术发射高度（炮口高度）", "炮口")]
        [DependOnProperty("FromUnitBody", false)]
        public float LaunchSpellHeight;
        [DescAttribute("法术发射半径（炮口半径）", "炮口")]
        [DependOnProperty("FromUnitBody", false)]
        public float LaunchSpellRadius = 0;

		[DescAttribute("位置偏移类型")]
		public XYModifyType xyModifyType = XYModifyType.Relative;
		[DescAttribute("位置偏移X")]
		public float xModify;
		[DescAttribute("位置偏移Y")]
		public float yModify;

		[DescAttribute("连锁等级，只在技能中LaunchSpell有效（闪电链类数量，如果Spell launch spell ID一致，则传递此值）", "连锁")]
        public int ChainLevel = 0;

        [DescAttribute("自动锁定范围内目标", "自动锁定")]
        public bool IsAutoSeekingTarget = false;
        [DescAttribute("自动锁定范围内目标（范围）", "自动锁定")]
        [DependOnProperty("IsAutoSeekingTarget")]
        public float SeekingTargetRange = 10f;
        [DescAttribute("自动锁定范围内目标（方式）", "自动锁定")]
        [DependOnProperty("IsAutoSeekingTarget")]
        public SpellTemplate.SeekingExpect SeekingTargetExpect = SpellTemplate.SeekingExpect.Random;


		//是否是程序创建的法师
		private bool mIsCodeCreate = false;

        public LaunchSpell() { }

		public LaunchSpell(bool codeCreate)
		{
			this.mIsCodeCreate = codeCreate;
		}

		public bool IsCodeCreate()
		{
			return this.mIsCodeCreate;
		}

		public override string ToString()
        {
            //return "( " + SpellID + ", " + Count + " )";
            return "法术:" + this.SpellID + " 数量:" + Count;
        }


        public object Clone()
        {
            LaunchSpell ret = new LaunchSpell();
            ret.SerialNumber = this.SerialNumber;
            ret.SpellID = this.SpellID;
            ret.LaunchPercent = this.LaunchPercent;
            ret.PType = this.PType;
            ret.Count = this.Count;
            ret.Angle = this.Angle;
            ret.StartAngle = this.StartAngle;
            ret.FromUnitBody = this.FromUnitBody;
            ret.LaunchSpellHeight = this.LaunchSpellHeight;
            ret.LaunchSpellRadius = this.LaunchSpellRadius;
            ret.ChainLevel = this.ChainLevel;
            ret.SenderUnit = this.SenderUnit;
            ret.IsAutoSeekingTarget = this.IsAutoSeekingTarget;
            ret.SeekingTargetRange = this.SeekingTargetRange;
            ret.SeekingTargetExpect = this.SeekingTargetExpect;
            ret.SpellRange = this.SpellRange;
			ret.xModify = this.xModify;
			ret.yModify = this.yModify;
			ret.xyModifyType = this.xyModifyType;
			ret.mIsCodeCreate = this.mIsCodeCreate;
			return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(this.SpellID);
            output.PutF32(this.LaunchPercent);
            output.PutEnum8(this.PType);
            output.PutS32(this.Count);
            output.PutF32(this.Angle);
            output.PutF32(this.StartAngle);
            output.PutBool(this.FromUnitBody);
            output.PutF32(this.LaunchSpellHeight);
            output.PutF32(this.LaunchSpellRadius);
            output.PutS32(this.ChainLevel);
            output.PutEnum8(this.SenderUnit);

            output.PutBool(this.IsAutoSeekingTarget);
            output.PutF32(this.SeekingTargetRange);
            output.PutEnum8(this.SeekingTargetExpect);
            output.PutS32(this.SpellRange);
			output.PutF32(this.xModify);
			output.PutF32(this.yModify);
			output.PutEnum8(this.xyModifyType);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.SpellID = input.GetS32();
            this.LaunchPercent = input.GetF32();
            this.PType = input.GetEnum8<PosType>();
            this.Count = input.GetS32();
            this.Angle = input.GetF32();
            this.StartAngle = input.GetF32();
            this.FromUnitBody = input.GetBool();
            this.LaunchSpellHeight = input.GetF32();
            this.LaunchSpellRadius = input.GetF32();
            this.ChainLevel = input.GetS32();
            this.SenderUnit = input.GetEnum8<LaunchSpllSenderUnit>();
            this.IsAutoSeekingTarget = input.GetBool();
            this.SeekingTargetRange = input.GetF32();
            this.SeekingTargetExpect = input.GetEnum8<SpellTemplate.SeekingExpect>();
            this.SpellRange = input.GetS32();
			this.xModify = input.GetF32();
			this.yModify = input.GetF32();
			this.xyModifyType = input.GetEnum8<XYModifyType>();

		}

		public void GetXModify(InstanceUnit launcher, out float xChange, out float yChange)
		{
			if ((this.xModify != 0 || this.yModify != 0) && this.xyModifyType == Data.XYModifyType.Relative && launcher != null)
			{
				float degree = MathVector.getDegree(this.xModify, this.yModify);
				float distance = (float)Math.Sqrt(this.xModify * this.xModify + this.yModify * this.yModify);
				xChange = (float)(distance * Math.Cos(degree + launcher.Direction));
				yChange = (float)(distance * Math.Sin(degree + launcher.Direction));
				return;
			}
			else if (this.xyModifyType == Data.XYModifyType.Absolutely)
			{
				//不做处理
			}

			xChange = this.xModify;
			yChange = this.yModify;
		}
	}

    //---------------------------------------------------------------------------------//

    /// <summary>
    /// 发起BUFF
    /// </summary>
    [MessageType(0x400C)]
    [DescAttribute("发起BUFF")]
    [Expandable]
    public class LaunchBuff : ISNData, ICloneable
    {
        /// <summary>
        /// Buff模板ID
        /// </summary>
        [DescAttribute("Buff模板ID, 一般用BindEventID")]
        [TemplateIDAttribute(typeof(BuffTemplate))]
        public int BuffID;

        [DescAttribute("触发百分比-废弃")]
        public float LaunchPercent = 100f;

		[DescAttribute("绑定事件id：有则去读事件表，忽视BuffID")]
		[DependOnProperty("IsBindEventID")]
		public int BindEventID;

		public bool IsBindEventID { get { return this.BuffID == 0; } }

		public LaunchBuff() { }
        public LaunchBuff(int buffID) { this.BuffID = buffID; }

        public override string ToString()
        {
            return "BUFF:" + BuffID + "_@_" + BindEventID;
        }

        public object Clone()
        {
            LaunchBuff ret = new LaunchBuff();
            ret.SerialNumber = this.SerialNumber;
            ret.BuffID = this.BuffID;
			ret.BindEventID = this.BindEventID;

			ret.LaunchPercent = this.LaunchPercent;
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(BuffID);
            output.PutF32(LaunchPercent);
			output.PutS32(BindEventID);
		}

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.BuffID = input.GetS32();
            this.LaunchPercent = input.GetF32();
			this.BindEventID = input.GetS32();
		}
    }

    /// <summary>
    /// 召唤单位
    /// </summary>
    [MessageType(0x400D)]
    [DescAttribute("召唤单位")]
    [Expandable]
    public class SummonUnit : ISNData, ICloneable
    {
        [DescAttribute("召唤单位模板")]
        [TemplateIDAttribute(typeof(UnitInfo))]
        public int UnitTemplateID;

        [DescAttribute("召唤单位等级")]
        [TemplateLevelAttribute]
        public int UnitLevel = 0;

        [DescAttribute("召唤处产生数量")]
        public int Count = 1;

        [DescAttribute("召唤处产生特效")]
        public LaunchEffect Effect;

		public SummonUnit() { }
        public SummonUnit(int templateID)
        {
            this.UnitTemplateID = templateID;
        }

        public override string ToString()
        {
            return "召唤单位:" + UnitTemplateID + " 数量:" + Count;
        }

        public object Clone()
        {
            SummonUnit ret = new SummonUnit();
            ret.SerialNumber = this.SerialNumber;
            ret.UnitTemplateID = this.UnitTemplateID;
            ret.UnitLevel = this.UnitLevel;
            ret.Count = this.Count;
            ret.Effect = CUtils.TryClone<LaunchEffect>(this.Effect);
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(UnitTemplateID);
            output.PutS32(UnitLevel);
            output.PutS32(Count);
            output.PutExt(Effect);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.UnitTemplateID = input.GetS32();
            this.UnitLevel = input.GetS32();
            this.Count = input.GetS32();
            this.Effect = input.GetExt<LaunchEffect>();
        }
    }

    [MessageType(0x4016)]
    [DescAttribute("闪现移动")]
    [Expandable]
    public class BlinkMove : ICloneable, IExternalizable
    {
        [DescAttribute("移动距离", "移动")]
        public float Distance = 5;
        [DescAttribute("角度偏移", "移动")]
        public float DirectionOffset;
        [DescAttribute("移动方式", "移动")]
        public BlinkMoveType MType = BlinkMoveType.MoveToForward;

        [DescAttribute("忽略地形", "碰撞")]
        public bool NoneTouchMap = false;
        [DescAttribute("忽略单位", "碰撞")]
        public bool NoneTouchObj = true;

        [DescAttribute("闪现起始点特效", "特效")]
        public LaunchEffect BeginEffect;
        [DescAttribute("闪现目标点特效", "特效")]
        public LaunchEffect TargetEffect;

        public enum BlinkMoveType : byte
        {
            [DescAttribute("向身前移动")]
            MoveToForward,
            [DescAttribute("向身后移动")]
            MoveToBackward,
            [DescAttribute("向技能释放目标点移动")]
            MoveToTargetPos,
            [DescAttribute("向技能释放目标单位移动(面前)")]
            MoveToTargetUnitFace,
            [DescAttribute("向技能释放目标单位移动(背后)")]
            MoveToTargetUnitBack,
        }
        public object Clone()
        {
            BlinkMove ret = new BlinkMove();
            ret.Distance = this.Distance;
            ret.DirectionOffset = this.DirectionOffset;
            ret.MType = this.MType;
            ret.NoneTouchMap = this.NoneTouchMap;
            ret.NoneTouchObj = this.NoneTouchObj;
            ret.BeginEffect = CUtils.TryClone<LaunchEffect>(this.BeginEffect);
            ret.TargetEffect = CUtils.TryClone<LaunchEffect>(this.TargetEffect);
            return ret;
        }
        public void WriteExternal(IOutputStream output)
        {
            output.PutF32(this.Distance);
            output.PutF32(this.DirectionOffset);
            output.PutEnum8(this.MType);
            output.PutBool(this.NoneTouchMap);
            output.PutBool(this.NoneTouchObj);
            output.PutExt(this.BeginEffect);
            output.PutExt(this.TargetEffect);
        }
        public void ReadExternal(IInputStream input)
        {
            this.Distance = input.GetF32();
            this.DirectionOffset = input.GetF32();
            this.MType = input.GetEnum8<BlinkMoveType>();
            this.NoneTouchMap = input.GetBool();
            this.NoneTouchObj = input.GetBool();
            this.BeginEffect = input.GetExt<LaunchEffect>();
            this.TargetEffect = input.GetExt<LaunchEffect>();
        }
        public override string ToString()
        {
            return "闪现移动";
        }
    }

    /// <summary>
    /// 移动距离
    /// </summary>
    [MessageType(0x400E)]
    [DescAttribute("移动距离")]
    [Expandable]
    public class StartMove : ISNData, ICloneable
    {
        [DescAttribute("速度(距离/每秒)", "位移")]
        public float SpeedSEC = 10f;
        [DescAttribute("加速度(距离/每秒)(最终速度=速度+加速度)", "位移")]
        public float SpeedAdd = 0f;
        [DescAttribute("阻力(每秒递减速度百分比)", "位移")]
        public float SpeedAcc = 0f;
        [DescAttribute("被击飞的向上速度(距离/每秒)", "位移")]
        public float ZSpeedSEC = 0f;
        [DescAttribute("被击飞的向上移动最大距离（天花板高度）", "位移")]
        [DependOnProperty("HasFly")]
        public float ZLimit = 0f;
        [DescAttribute("重设重力（非0有效）", "位移")]
        [DependOnProperty("HasFly")]
        public float OverrideGravity = 0f;
        [DescAttribute("起始移动方向修正", "位移")]
        public float Direction;
        [DescAttribute("移动过程中是否忽略碰撞", "位移")]
        public bool IsNoneTouch = false;

        [DescAttribute("自身转动速度(距离/每秒)", "旋转")]
        public float RotateSpeedSEC;

        [DescAttribute("持续时间(毫秒)，如果是击飞此处无效，击飞时间按落地时间计算，运动时间不计算在DamageTime内", "时间")]
        [DependOnProperty("HasFly", false)]
        public int KeepTimeMS = 500;
        [DescAttribute("", "", false)]
        public float ArgsFactor = 0;

        public bool HasFly { get { return ZSpeedSEC != 0; } }
        public StartMove() { }
        public override string ToString()
        {
            return "移动速度:" + SpeedSEC + "(每秒) 持续:" + KeepTimeMS + "(毫秒)";
        }

        public object Clone()
        {
            StartMove ret = new StartMove();
            ret.SerialNumber = this.SerialNumber;
            ret.SpeedSEC = this.SpeedSEC;
            ret.SpeedAdd = this.SpeedAdd;
            ret.SpeedAcc = this.SpeedAcc;
            ret.ZSpeedSEC = this.ZSpeedSEC;
            ret.ZLimit = this.ZLimit;
            ret.OverrideGravity = this.OverrideGravity;
            ret.Direction = this.Direction;
            ret.IsNoneTouch = this.IsNoneTouch;
            ret.RotateSpeedSEC = this.RotateSpeedSEC;
            ret.KeepTimeMS = this.KeepTimeMS;
            ret.ArgsFactor = this.ArgsFactor;
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutF32(this.SpeedSEC);
            output.PutF32(this.SpeedAdd);
            output.PutF32(this.SpeedAcc);
            output.PutF32(this.ZSpeedSEC);
            output.PutF32(this.ZLimit);
            output.PutF32(this.OverrideGravity);
            output.PutF32(this.Direction);
            output.PutBool(this.IsNoneTouch);
            output.PutF32(this.RotateSpeedSEC);
            output.PutS32(this.KeepTimeMS);
            output.PutF32(this.ArgsFactor);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.SpeedSEC = input.GetF32();
            this.SpeedAdd = input.GetF32();
            this.SpeedAcc = input.GetF32();
            this.ZSpeedSEC = input.GetF32();
            this.ZLimit = input.GetF32();
            this.OverrideGravity = input.GetF32();
            this.Direction = input.GetF32();
            this.IsNoneTouch = input.GetBool();
            this.RotateSpeedSEC = input.GetF32();
            this.KeepTimeMS = input.GetS32();
            this.ArgsFactor = input.GetF32();
        }
    }


    /// <summary>
    /// 道具掉落
    /// </summary>
    [MessageType(0x400F)]
    [DescAttribute("道具掉落")]
    [Expandable]
    public class DropItem : ISNData, ICloneable
    {
        /// <summary>
        /// 掉落道具模板ID
        /// </summary>
        [DescAttribute("掉落道具模板ID")]
        [TemplateIDAttribute(typeof(ItemTemplate))]
        public int ItemTemplateID;
        /// <summary>
        /// 掉落数量
        /// </summary>
        [DescAttribute("掉落数量")]
        public int DropCount = 1;
        /// <summary>
        /// 掉落道具百分比
        /// </summary>
        [DescAttribute("掉落道具百分比")]
        public float DropPercent;

        [DescAttribute("掉落位置随机范围点")]
        public float DropPosRange = 0;

        public DropItem() { }
        public DropItem(int itemID, float percent)
        {
            this.ItemTemplateID = itemID;
            this.DropPercent = percent;
        }
        public override string ToString()
        {
            return "道具掉落:" + ItemTemplateID + " 掉率:" + DropPercent + "%";
        }

        public object Clone()
        {
            DropItem ret = new DropItem();
            ret.SerialNumber = this.SerialNumber;
            ret.ItemTemplateID = this.ItemTemplateID;
            ret.DropCount = this.DropCount;
            ret.DropPercent = this.DropPercent;
            ret.DropPosRange = this.DropPosRange;
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(ItemTemplateID);
            output.PutS32(DropCount);
            output.PutF32(DropPercent);
            output.PutF32(DropPosRange);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.ItemTemplateID = input.GetS32();
            this.DropCount = input.GetS32();
            this.DropPercent = input.GetF32();
            this.DropPosRange = input.GetF32();
        }
    }


    /// <summary>
    /// 道具掉落
    /// </summary>
    [MessageType(0x4013)]
    [DescAttribute("道具掉落列表")]
    [Expandable]
    public class DropItemList : ISNData, ICloneable
    {
        /// <summary>
        /// 掉落道具模板ID
        /// </summary>
        [ListAttribute(typeof(DropItem))]
        [DescAttribute("掉落道具模板列表")]
        public List<DropItem> DropItems = new List<DropItem>();

        public DropItemList() { }

        public override string ToString()
        {
            return "道具掉落:" + DropItems.Count + "个物品中的一个";
        }

        public object Clone()
        {
            DropItemList ret = new DropItemList();
            ret.SerialNumber = this.SerialNumber;
            ret.DropItems = CUtils.CloneList<DropItem>(this.DropItems);
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutList<DropItem>(DropItems, output.PutExt);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.DropItems = input.GetList<DropItem>(input.GetExt<DropItem>);
        }
    }



    [MessageType(0x4012)]
    [DescAttribute("道具使用")]
    [Expandable]
    public class UseItem : ISNData, ICloneable
    {
        /// <summary>
        /// 掉落道具模板ID
        /// </summary>
        [DescAttribute("道具模板ID")]
        [TemplateIDAttribute(typeof(ItemTemplate))]
        public int ItemTemplateID;

        public UseItem() { }
        public UseItem(int itemID)
        {
            this.ItemTemplateID = itemID;
        }
        public override string ToString()
        {
            return "使用道具:" + ItemTemplateID;
        }

        public object Clone()
        {
            UseItem ret = new UseItem();
            ret.SerialNumber = this.SerialNumber;
            ret.ItemTemplateID = this.ItemTemplateID;
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(this.ItemTemplateID);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.ItemTemplateID = input.GetS32();
        }
    }

	/// <summary>
	/// 击杀击退
	/// </summary>
	[MessageType(0x4027)]
    [DescAttribute("击杀击退")]
    [Expandable]
    public class KillHitMove : ISNData, ICloneable
    {
        [DescAttribute("是否生效")]
        public bool enable = false;
        [DependOnProperty("enable")]
        [DescAttribute("受击位移计算方式", "受击")]
        public HitMoveType moveType = HitMoveType.BySenderDirection;
        public object Clone()
        {
            KillHitMove ret = new KillHitMove();
            ret.enable = this.enable;
            ret.moveType = this.moveType;
            return ret;
        }
        public override string ToString()
        {
            return "是否生效:" + enable;
        }
        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutBool(this.enable);
            output.PutEnum8(this.moveType);
            //output.PutEnum32
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.enable = input.GetBool();
            this.moveType = input.GetEnum8<HitMoveType>();
        }
    }

	[MessageType(0x4028)]
	[DescAttribute("场景增加道具")]
	[Expandable]
	public class BuffAddItem : ISNData, ICloneable
	{
		public enum PosType : byte
		{
			[DescAttribute("buff触发位置")]
			HitBuffPos = 1,
			[DescAttribute("绑定者位置")]
			BindUnitPos = 2,
			[DescAttribute("指定位置")]
			PointPos = 3,
		}
		/// </summary>
		[DescAttribute("生成类型")]
		public PosType posType = PosType.HitBuffPos;

		/// <summary>
		/// 掉落道具模板ID
		/// </summary>
		[DescAttribute("道具模板ID")]
		[TemplateIDAttribute(typeof(ItemTemplate))]
		public int ItemTemplateID;

		public bool IsPointXY { get { return posType == PosType.PointPos; } }

		//记录位置信息
		[DependOnProperty("IsPointXY")]
		[DescAttribute("指定位置X")]
		public float pointX;
		[DependOnProperty("IsPointXY")]
		[DescAttribute("指定位置Y")]
		public float pointY;

		public BuffAddItem() { }

		public override string ToString()
		{
			return "生成道具:" + ItemTemplateID;
		}

		public object Clone()
		{
			BuffAddItem ret = new BuffAddItem();
			ret.SerialNumber = this.SerialNumber;
			ret.ItemTemplateID = this.ItemTemplateID;
			ret.pointX = this.pointX;
			ret.pointY = this.pointY;
			ret.posType = this.posType;

			return ret;
		}

		public override void WriteExternal(IOutputStream output)
		{
			base.WriteExternal(output);
			output.PutS32(this.ItemTemplateID);
			output.PutEnum8(this.posType);
			output.PutF32(this.pointX);
			output.PutF32(this.pointY);
		}

		public override void ReadExternal(IInputStream input)
		{
			base.ReadExternal(input);
			this.ItemTemplateID = input.GetS32();
			this.posType = input.GetEnum8<PosType>();
			this.pointX = input.GetF32();
			this.pointY = input.GetF32();
		}
	}

	/// <summary>
	/// 单位被动触发
	/// </summary>
	[MessageType(0x4011)]
    [DescAttribute("单位被动触发")]
    [Expandable]
    public class LaunchTrigger : ISNData, ICloneable
    {
        [DescAttribute("触发器ID")]
        [TemplateIDAttribute(typeof(UnitTriggerTemplate))]
        public int TriggerTemplateID;

        [DescAttribute("开启")]
        public bool Active = true;

        public LaunchTrigger() { }
        public LaunchTrigger(int id)
        {
            this.TriggerTemplateID = id;
        }
        public override string ToString()
        {
            return "单位触发:" + TriggerTemplateID;
        }

        public object Clone()
        {
            LaunchTrigger ret = new LaunchTrigger();
            ret.SerialNumber = this.SerialNumber;
            ret.TriggerTemplateID = this.TriggerTemplateID;
            ret.Active = this.Active;
            return ret;
        }

        public override void WriteExternal(IOutputStream output)
        {
            base.WriteExternal(output);
            output.PutS32(TriggerTemplateID);
            output.PutBool(Active);
        }

        public override void ReadExternal(IInputStream input)
        {
            base.ReadExternal(input);
            this.TriggerTemplateID = input.GetS32();
            this.Active = input.GetBool();
        }
    }

    /// <summary>
    /// 携带道具
    /// </summary>
    [MessageType(0x4014)]
    [DescAttribute("单位携带道具")]
    [Expandable]
    public class InventoryItem : IExternalizable, ICloneable
    {
        [TemplateIDAttribute(typeof(ItemTemplate))]
        [DescAttribute("道具模板ID")]
        public int ItemTemplateID;

        [DescAttribute("数量ID")]
        public int Count;

        public override string ToString()
        {
            return "携带道具:" + ItemTemplateID + "x" + Count;
        }
        public object Clone()
        {
            InventoryItem ret = new InventoryItem();
            ret.ItemTemplateID = this.ItemTemplateID;
            ret.Count = this.Count;
            return ret;
        }

        public void WriteExternal(IOutputStream output)
        {
            output.PutS32(ItemTemplateID);
            output.PutS32(Count);
        }

        public void ReadExternal(IInputStream input)
        {
            this.ItemTemplateID = input.GetS32();
            this.Count = input.GetS32();
        }


    }


    [MessageType(0x410A)]
    [DescAttribute("单位组阵型")]
    [Expandable]
    public class TeamFormation : IExternalizable, ICloneable
    {
        public enum Formation : byte
        {
            [DescAttribute("随机")]
            Random = 0,
            [DescAttribute("方阵")]
            Square = 1,
            [DescAttribute("以中心点放射出去的圆阵")]
            Round = 2,
            [DescAttribute("圆环")]
            Cycle = 3,
            [DescAttribute("蜂窝阵")]
            Beehive = 4,
            [DescAttribute("直线")]
            Line = 5,
        }
        public bool IsSquare { get { return this.TFormation == Formation.Square; } }


        [DescAttribute("阵型")]
        public Formation TFormation = Formation.Random;
        [DescAttribute("单位间距，间距不计算身体半径，0表示按最大身体计算")]
        public float SpacingSize = 5;

        [DescAttribute("方阵: 每行固定人数，0表示行列相等")]
        [DependOnProperty("IsSquare")]
        public int SquareEachRowCount = 0;

        public object Clone()
        {
            TeamFormation ret = new TeamFormation();
            ret.TFormation = this.TFormation;
            ret.SpacingSize = this.SpacingSize;
            ret.SquareEachRowCount = this.SquareEachRowCount;
            return ret;
        }

        public void WriteExternal(IOutputStream output)
        {
            output.PutEnum8(this.TFormation);
            output.PutF32(this.SpacingSize);
            output.PutS32(this.SquareEachRowCount);
        }

        public void ReadExternal(IInputStream input)
        {
            this.TFormation = input.GetEnum8<Formation>();
            this.SpacingSize = input.GetF32();
            this.SquareEachRowCount = input.GetS32();
        }

        public override string ToString()
        {
            return string.Format("阵型:{0}", TFormation);
        }
    }


    #endregion

    //---------------------------------------------------------------------------------//
}