C# TargetModifiers.HasModifier方法代码示例

		public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, ref TargetModifiers modifiers, ref string cursor)
		{
			var type = target.Type;
			if (type != TargetType.Actor && type != TargetType.FrozenActor)
				return false;

			cursor = this.cursor;
			IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

			if (ForceAttack != null && modifiers.HasModifier(TargetModifiers.ForceAttack) != ForceAttack)
				return false;

			var owner = type == TargetType.FrozenActor ? target.FrozenActor.Owner : target.Actor.Owner;
			var playerRelationship = self.Owner.Stances[owner];

			if (!modifiers.HasModifier(TargetModifiers.ForceAttack) && playerRelationship == Stance.Ally && !targetAllyUnits)
				return false;

			if (!modifiers.HasModifier(TargetModifiers.ForceAttack) && playerRelationship == Stance.Enemy && !targetEnemyUnits)
				return false;

			return type == TargetType.FrozenActor ?
				CanTargetFrozenActor(self, target.FrozenActor, modifiers, ref cursor) :
				CanTargetActor(self, target.Actor, modifiers, ref cursor);
		}

        public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, ref TargetModifiers modifiers, ref string cursor)
        {
            if (target.Type != TargetType.Actor)
                return false;

            IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);
            cursor = this.cursor();

            return self == target.Actor;
        }

		public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, TargetModifiers modifiers, ref string cursor)
		{
			if (target.Type != TargetType.Actor)
				return false;

			IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);
			cursor = useDeployCursor() ? "deploy" : "deploy-blocked";

			return self == target.Actor;
		}

		public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, ref TargetModifiers modifiers, ref string cursor)
		{
			if (target.Type != TargetType.Terrain)
				return false;

			var location = self.World.Map.CellContaining(target.CenterPosition);
			var explored = self.Owner.Shroud.IsExplored(location);
			cursor = self.World.Map.Contains(location) ?
				(self.World.Map.GetTerrainInfo(location).CustomCursor ?? "move") :
				"move-blocked";

			IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

			if (!explored && !info.MoveIntoShroud)
				cursor = "move-blocked";

			return true;
		}

            public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
            {
                var hut = target.TraitOrDefault<BridgeHut>();
                if (hut == null)
                    return false;

                // Require force attack to heal partially damaged bridges to avoid unnecessary cursor noise
                var damage = hut.BridgeDamageState;
                if (!modifiers.HasModifier(TargetModifiers.ForceAttack) && damage != DamageState.Dead)
                    return false;

                // Obey force moving onto bridges
                if (modifiers.HasModifier(TargetModifiers.ForceMove))
                    return false;

                // Can't repair a bridge that is undamaged, already under repair, or dangling
                if (damage == DamageState.Undamaged || hut.Repairing || hut.Bridge.IsDangling)
                    cursor = info.TargetBlockedCursor;

                return true;
            }

            public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, ref TargetModifiers modifiers, ref string cursor)
            {
                if (target.Type != TargetType.Terrain)
                    return false;

                var location = self.World.Map.CellContaining(target.CenterPosition);
                if (!self.World.Map.Contains(location))
                    return false;

                cursor = "ability";
                IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

                return !othersAtTarget.Any() && modifiers.HasModifier(TargetModifiers.ForceAttack);
            }

            public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, TargetModifiers modifiers, ref string cursor)
            {
                if (target.Type != TargetType.Terrain)
                    return false;

                if (modifiers.HasModifier(TargetModifiers.ForceMove))
                    return false;

                var location = self.World.Map.CellContaining(target.CenterPosition);
                // Don't leak info about resources under the shroud
                if (!self.Owner.Shroud.IsExplored(location))
                    return false;

                var res = self.World.WorldActor.Trait<ResourceLayer>().GetRenderedResource(location);
                var info = self.Info.Traits.Get<HarvesterInfo>();

                if (res == null || !info.Resources.Contains(res.Info.Name))
                    return false;

                cursor = "harvest";
                IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

                return true;
            }

			bool CanTargetLocation(Actor self, CPos location, List<Actor> actorsAtLocation, TargetModifiers modifiers, ref string cursor)
			{
				if (!self.World.Map.Contains(location))
					return false;

				IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

				cursor = ab.info.Cursor;

				if (negativeDamage)
					return false;

				if (!ab.HasAnyValidWeapons(Target.FromCell(self.World, location)))
					return false;

				if (modifiers.HasModifier(TargetModifiers.ForceAttack))
				{
					var maxRange = ab.GetMaximumRange().Range;
					var targetRange = (self.World.Map.CenterOfCell(location) - self.CenterPosition).HorizontalLengthSquared;
					if (targetRange > maxRange * maxRange)
						cursor = ab.info.OutsideRangeCursor;

					return true;
				}

				return false;
			}

			bool CanTargetActor(Actor self, Target target, TargetModifiers modifiers, ref string cursor)
			{
				IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

				var a = ab.ChooseArmamentForTarget(target);
				cursor = a != null && !target.IsInRange(self.CenterPosition, a.Weapon.Range)
					? ab.info.OutsideRangeCursor
					: ab.info.Cursor;

				if (target.Type == TargetType.Actor && target.Actor == self)
					return false;

				if (!ab.HasAnyValidWeapons(target))
					return false;

				if (modifiers.HasModifier(TargetModifiers.ForceAttack))
					return true;

				if (modifiers.HasModifier(TargetModifiers.ForceMove))
					return false;

				if (target.RequiresForceFire)
					return false;

				var targetableRelationship = negativeDamage ? Stance.Ally : Stance.Enemy;

				var owner = target.Type == TargetType.FrozenActor ? target.FrozenActor.Owner : target.Actor.Owner;
				return self.Owner.Stances[owner] == targetableRelationship;
			}

            public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
            {
                // Obey force moving onto bridges
                if (modifiers.HasModifier(TargetModifiers.ForceMove))
                    return false;

                return target.TraitsImplementing<IDemolishable>().Any(i => i.IsValidTarget(target, self));
            }

        public bool CanTarget(Actor self, Target target, List<Actor> othersAtTarget, ref TargetModifiers modifiers, ref string cursor)
        {
            // TODO: When target modifiers are configurable this needs to be revisited
            if (modifiers.HasModifier(TargetModifiers.ForceMove) || modifiers.HasModifier(TargetModifiers.ForceQueue))
            {
                var xy = self.World.Map.CellContaining(target.CenterPosition);

                IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

                if (self.IsInWorld && self.Owner.Shroud.IsExplored(xy))
                {
                    cursor = targetCursor;
                    return true;
                }

                return false;
            }

            return false;
        }

 public bool TargetOverridesSelection(TargetModifiers modifiers)
 {
     return modifiers.HasModifier(TargetModifiers.ForceMove);
 }

            bool CanTargetLocation(Actor self, CPos location, List<Actor> actorsAtLocation, TargetModifiers modifiers, ref string cursor)
            {
                if (!self.World.Map.IsInMap(location))
                    return false;

                IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

                cursor = self.Info.Traits.Get<AttackBaseInfo>().Cursor;

                if (negativeDamage)
                    return false;

                if (!self.Trait<AttackBase>().HasAnyValidWeapons(Target.FromCell(location)))
                    return false;

                if (modifiers.HasModifier(TargetModifiers.ForceAttack))
                    return true;

                return false;
            }

            bool CanTargetActor(Actor self, Target target, TargetModifiers modifiers, ref string cursor)
            {
                IsQueued = modifiers.HasModifier(TargetModifiers.ForceQueue);

                cursor = self.Info.Traits.Get<AttackBaseInfo>().Cursor;

                if (target.Type == TargetType.Actor && target.Actor == self)
                    return false;

                if (!self.Trait<AttackBase>().HasAnyValidWeapons(target))
                    return false;

                if (modifiers.HasModifier(TargetModifiers.ForceAttack))
                    return true;

                if (modifiers.HasModifier(TargetModifiers.ForceMove))
                    return false;

                var targetableRelationship = negativeDamage ? Stance.Ally : Stance.Enemy;

                var owner = target.Type == TargetType.FrozenActor ? target.FrozenActor.Owner : target.Actor.Owner;
                return self.Owner.Stances[owner] == targetableRelationship;
            }

            public override bool CanTargetActor(Actor self, Actor target, TargetModifiers modifiers, ref string cursor)
            {
                // Obey force moving onto bridges
                if (modifiers.HasModifier(TargetModifiers.ForceMove))
                    return false;

                var demolishable = target.TraitOrDefault<IDemolishable>();
                if (demolishable == null || !demolishable.IsValidTarget(target, self))
                    return false;

                return true;
            }