public NativeFieldInfo(TargetType type, string name, int index,
					bool has_const_value, int const_value)
            : base(type, name, index, false, TargetMemberAccessibility.Public,
				0, 0, has_const_value)
        {
            this.const_value = const_value;
        }

 public TargetAuraMinTimeLeftCondition(TargetType target, int auraId, TimeSpan minTimeLeft)
 {
     Target = target;
     AuraId = auraId;
     CreatorGuid = StyxWoW.Me.Guid;
     MinTimeLeft = minTimeLeft;
 }

        public Network WithDest(string dest)
        {
            _destType = GetTargetType(dest);
            _dest = dest;

            return this;
        }

 public DtsTask(SourceType sourceType, string sourceName, TargetType targetType, ITarget target)
 {
     SourceType = sourceType;
     SourceName = sourceName;
     TargetType = targetType;
     Target = target;
 }

	private void clear()
	{
		targetType = TargetType.Type_Null;
		targetArrived = null;
		goTarget = null;

	}

 public CMakeTarget(TargetType type, bool isImported)
 {
     Type = type;
     IMPORTED = isImported;
     sources = new HashSet<FileInfo>();
     properties = new CMakeTargetPropertyCollection();
 }

 public TargetAuraMaxTimeLeftCondition(TargetType target, int auraId, WoWGuid creatorGuid, TimeSpan maxTimeLeft)
 {
     Target = target;
     AuraId = auraId;
     CreatorGuid = creatorGuid;
     MaxTimeLeft = maxTimeLeft;
 }

 public Item(string name, string desc, ItemType type, TargetType targetType)
 {
     _name = name;
     _desc = desc;
     _type = type;
     _targetType = targetType;
 }

 public void Initialize (Transform targ, TargetType targType, float maxTTL, float expRadius, float dmg ) {
     target = targ;
     targetType = targType;
     maxTimeToLive = maxTTL;
     explosionRadius = expRadius;
     damage = dmg;
 }

 public TargetInfo(string name, string target, TargetType type, bool safe)
 {
     this.name = name;
     this.target = target;
     this.type = type;
     this.safe = safe;
 }

 public static Obj_AI_Hero GetBestTarget(TargetType type, float range)
 {
     var List = HeroManager.Enemies.Where(x => !x.IsDead && x.Distance(Player.Position) <= range);
     if (type == TargetType.LowestHealth)
     {
         return List.OrderBy(x => x.Health).FirstOrDefault();
     }
     if (type == TargetType.MaxHealth)
     {
         return List.OrderBy(x => x.MaxHealth).FirstOrDefault();
     }
     if (type == TargetType.BestDamage)
     {
         return List.OrderBy(x => x.TotalMagicalDamage + x.TotalAttackDamage ).LastOrDefault();
     }
     if (type == TargetType.Closest)
     {
         return List.OrderBy(x => x.Distance(Player.Position)).FirstOrDefault();
     }
     if (type == TargetType.Tankiest)
     {
         return List.OrderBy(x => x.Armor + x.FlatMagicReduction).FirstOrDefault();
     }
     if (type == TargetType.MostHealth)
     {
         return List.OrderBy(x => x.Health).LastOrDefault();
     }
     else return TargetSelector.GetTarget(range, TargetSelector.DamageType.Physical);
 }

        public MonoVariable(string name, TargetType type, bool is_local, bool is_byref,
				     Method method, VariableInfo info, int start_scope_offset,
				     int end_scope_offset)
            : this(name, type, is_local, is_byref, method, info)
        {
            if (is_local) {
                start_scope = method.StartAddress + start_scope_offset;
                end_scope = method.StartAddress + end_scope_offset;
            } else if (method.HasMethodBounds) {
                start_scope = method.MethodStartAddress;
                end_scope = method.MethodEndAddress;
            } else {
                start_scope = method.StartAddress;
                end_scope = method.EndAddress;
            }

            if (has_liveness_info) {
                if (start_liveness < start_scope)
                    start_liveness = start_scope;
                if (end_liveness > end_scope)
                    end_liveness = end_scope;
            } else {
                start_liveness = start_scope;
                end_liveness = end_scope;
                has_liveness_info = true;
            }
        }

    public static bool IsValidTarget(TargetType targetType, GameObject target, GameObject me)
    {
        Team targetTeam = target.GetComponent<Team>();
        Team myTeam = me.GetComponent<Team>();

        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        switch (targetType) {
          case TargetType.Self:
        if(target == me) {
          return true;
        }
        break;
          case TargetType.Ally:
        if(myTeam.m_teamNumber == targetTeam.m_teamNumber) {
          return true;
        }
        break;
          case TargetType.Enemy:
        if(myTeam.m_teamNumber != targetTeam.m_teamNumber) {
          return true;
        }
        break;
          case TargetType.All:
        return true;
          default:
        return false;
        };
        //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        return false;
    }

        /// <summary>
        /// 将分类类别转换为TreeNodes
        /// </summary>
        /// <param name="categoryService">扩展类：CategoryService</param>
        /// <param name="categories">要转换成节点分类集合</param>
        /// <param name="targetType">点击分类时打开新页还是在本页打开</param>
        /// <param name="idPrefix">节点ID前缀</param>
        /// <param name="checkedCategoryId">当前选中的CategoryId</param>
        /// <param name="openLevel">默认打开的层级</param>
        /// <returns>TreeNodes列表</returns>
        public static IList<TreeNode> CategoriesToTreeNodes(this CategoryService<Category> categoryService, IList<Category> categories, TargetType targetType, string idPrefix, long? checkedCategoryId, int? openLevel)
        {
            //本方法将分类转换成TreeNodes，其中，哪些节点展开还是闭合的逻辑较为复杂，如下：
            //关于哪些节点展开哪些节点闭合，逻辑实现如下：
            //1 首先，若checkedCategoryId有值，则这个分类的所有父级分类展开，其他分类全部折叠；
            //2 其次，若checkedCategoryId无值，openLevel有着，则深度小于等于openLevel的分类展开，其他分类折叠；
            //3 若若checkedCategoryId和openLevel都没有值，则所有分类折叠。

            IList<TreeNode> nodes = new List<TreeNode>();
            if (categories != null && categories.Count > 0)
            {
                //若当前有选中的分类，则获取其所有的父级分类Id集合
                List<long> checkedCategoryIds = new List<long>();
                if (checkedCategoryId.HasValue && checkedCategoryId.Value > 0)
                    GetParentCategoryIDs(categoryService, checkedCategoryId.Value, checkedCategoryIds);

                //通过Category组装TreeNode
                foreach (Category category in categories)
                {
                    TreeNode node = new TreeNode();
                    node.Id = idPrefix + category.CategoryId.ToString();
                    node.IsChecked = (checkedCategoryId == category.CategoryId);
                    node.IsOpened = IsOpenedNode(category, checkedCategoryIds, openLevel);
                    node.IsParent = category.ChildCount > 0;
                    node.Name = category.CategoryName;
                    node.ParentId = idPrefix + category.ParentId.ToString();
                    node.Target = targetType;
                    node.Url = string.Empty;
                    nodes.Add(node);
                }
            }
            return nodes;
        }

 public TargetHasAuraMinStacksCondition(TargetType target, int auraId, int minStackCount)
 {
     Target = target;
     AuraId = auraId;
     MinStackCount = minStackCount;
     CreatorGuid = StyxWoW.Me.Guid;
 }

        public void PropertySetPreservedAndSourceNotModified()
        {
            const string ValueFoo = "hello";
            var valueBar = new DateTime(2013, 12, 1, 23, 0, 0);
            var valueBaz = new object();
            var valueFuu = new TargetType();

            dynamic source = new ExpandoObject();
            source.Foo = ValueFoo;
            source.Bar = valueBar;
            source.Baz = valueBaz;
            source.Fuu = valueFuu;
            
            dynamic result = ((object)source).ToExpando();
            
            Assert.AreNotSame(source, result);
            
            Assert.AreEqual(source.Foo, result.Foo);
            Assert.AreEqual(source.Bar, result.Bar);
            Assert.AreEqual(source.Baz, result.Baz);
            Assert.AreEqual(source.Fuu, result.Fuu);

            Assert.AreEqual(ValueFoo, source.Foo);
            Assert.AreEqual(valueBar, source.Bar);
            Assert.AreEqual(valueBaz, source.Baz);
            Assert.AreEqual(valueFuu, source.Fuu);
        }

        public StructureDiscoveryCommand Instantiate(Target target, TargetType type, IEnumerable<CaptionFilter> filters)
        {
            if (!(connection is AdomdConnection))
                throw new ArgumentException();

            var builder = InstantiateBuilder(target, type);
            builder.Build(filters);

            var cmd = connection.CreateCommand();
            cmd.CommandText = builder.GetCommandText();
            var postFilters = builder.GetPostFilters();

            var description = new CommandDescription(target, filters);

            OlapCommand command = null;
            if ((target == Target.MeasureGroups && type == TargetType.Object) || target == Target.Perspectives)
                command = new DistinctOlapCommand(cmd, postFilters, description);
            else if (target == Target.Dimensions && type == TargetType.Object)
                command = new DimensionCommand(cmd, postFilters, description);
            else if (target == Target.Dimensions && type == TargetType.Relation)
                command = new DimensionRelationCommand(cmd, postFilters, description);
            else
                command = new OlapCommand(cmd, postFilters, description);

            return command;
        }

        public MonoGenericInstanceType(MonoClassType container, TargetType[] type_args,
						TargetAddress class_ptr)
            : base(container.File.MonoLanguage)
        {
            this.Container = container;
            this.type_args = type_args;
            this.class_ptr = class_ptr;

            struct_type = new MonoStructType (container.File, this, container.Type);

            StringBuilder sb = new StringBuilder (container.BaseName);
            sb.Append ('<');
            for (int i = 0; i < type_args.Length; i++) {
                if (i > 0)
                    sb.Append (',');
                sb.Append (type_args [i].Name);
            }
            sb.Append ('>');
            full_name = sb.ToString ();

            bool is_compiler_generated;
            DebuggerBrowsableState? browsable_state;
            MonoSymbolFile.CheckCustomAttributes (container.Type,
                                  out browsable_state,
                                  out debugger_display,
                                  out type_proxy,
                                  out is_compiler_generated);
        }

        protected override IDiscoveryCommandBuilder InstantiateBuilder(Target target, TargetType type)
        {
            if (type != TargetType.Object)
                throw new ArgumentOutOfRangeException();

            switch (target)
            {
                case Target.Perspectives:
                    return new PerspectiveDiscoveryCommandBuilder();
                case Target.MeasureGroups:
                    return new MeasureGroupDiscoveryCommandBuilder();
                case Target.Measures:
                    return new MeasureDiscoveryCommandBuilder();
                case Target.Dimensions:
                    return new DimensionDiscoveryCommandBuilder();
                case Target.Hierarchies:
                    return new HierarchyDiscoveryCommandBuilder();
                case Target.Levels:
                    return new LevelDiscoveryCommandBuilder();
                case Target.Properties:
                    return new PropertyDiscoveryCommandBuilder();
                case Target.Tables:
                    return new TableDiscoveryCommandBuilder();
                case Target.Columns:
                    return new ColumnDiscoveryCommandBuilder();
                case Target.Sets:
                    return new SetDiscoveryCommandBuilder();
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }

        private static IList<WarMagicData> CreateAbnormalConditionMagic(MagicData magic, bool isChipEffect, IAbnormalCondition cond, TargetType targetType)
        {
            var name = magic.Name;
            var description = magic.Description;
            var cores = magic.Cores;
            var magicDatas = new List<WarMagicData>(cores.Length);
            foreach (var core in cores)
            {
                // 行為の範囲や対象を設定する
                IScope scope;
                if (core.Area != 0)
                    scope = new DefaultScope(core.Range, core.Area, targetType);
                else
                    scope = new WholeScope(targetType);

                // 画面効果を設定する
                var screenEffect = CreateScreenEffect(magic, isChipEffect);

                // 消費MPの設定
                var consumption = new MPCost(core.MPCost);

                // 行為の設定
                var action = new GiveAbnormalConditionAction(scope, consumption, screenEffect, cond);

                // 魔法データを作成する
                var magicData = new WarMagicData(name, description, action, core.MPCost, core.Area, core.Range);
                magicDatas.Add(magicData);
            }
            return magicDatas;
        }