public bool HasVisited(ITarget target)
 {
     if (Visited != null && Visited.Contains(target))
         return true;
     else
         return false;
 }

 public void UnregisterTarget(ITarget target) {
     GetAppropriateListForTarget(target).Remove(target);
     if (attackers.Count == 0 && attackersSpawners.TrueForAll(spawner => spawner.IsSpawnEnded())) {
         StopRound();
         GameManager.NextRound();
     }
 }

 /// <summary>
 /// Gets the value to inject into the specified target.
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="target">The target.</param>
 /// <returns>The value to inject into the specified target.</returns>
 public object GetValue(IContext context, ITarget target)
 {
     var parameter = context
         .Parameters.OfType<IConstructorArgument>()
         .SingleOrDefault(p => p.AppliesToTarget(context, target));
     return parameter != null ? parameter.GetValue(context, target) : target.ResolveWithin(context);
 }

        /// <summary>
        /// Gets the position of the specified <see cref="FuncConstructorArgument"/> relative to the
        /// other <see cref="FuncConstructorArgument"/> of the same type in the specified context.
        /// </summary>
        /// <param name="argument">The argument for which the position is calculated.</param>
        /// <param name="context">The context of the argument.</param>
        /// <param name="target">The target.</param>
        /// <returns>
        ///     -1 if the parameter does not exist in the context or if another constructor argument applies for the target.
        ///     Otherwise the position of the specified <see cref="FuncConstructorArgument"/> within the other <see cref="FuncConstructorArgument"/> 
        ///     of the same type contained in context.Parameters.
        /// </returns>
        public int GetPositionOfFuncConstructorArgument(FuncConstructorArgument argument, IContext context, ITarget target)
        {
            int currentPosition = 0;
            int position = -1;
            foreach (var constructorArgumentParameter in context.Parameters.OfType<IConstructorArgument>())
            {
                var funcArgumentParameter = constructorArgumentParameter as FuncConstructorArgument;
                if (funcArgumentParameter != null)
                {
                    if (ReferenceEquals(argument, funcArgumentParameter))
                    {
                        position = currentPosition;
                    }
                    else
                    {
                        if (funcArgumentParameter.ArgumentType == target.Type)
                        {
                            currentPosition++;
                        }
                    }
                }
                else
                {
                    if (constructorArgumentParameter.AppliesToTarget(context, target))
                    {
                        return -1;
                    }
                }
            }

            return position;
        }

 public void Initialize(IAttackableTarget sourceParam, ITarget targetParam, SpellData data) {
     source = sourceParam;
     target = targetParam;
     baseData = data;
     InitializeData(data);
     InitView();
 }

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

 public virtual void Initialize(BaseBattleData dataParam, bool isDefenderParam, ITarget parentParam) {
     data = dataParam;
     isDefender = isDefenderParam;
     parent = parentParam;
     InitializeData();
     BattleManager.RegisterTarget(parent);
 }

 public static IList<ITarget> CreateTree(ITarget target)
 {
     var final = new List<ITarget>();
     final.AddRange(BuildDependancyTree(target.DependsOn));
     final.Add(target);
     return final;
 }

        /// <summary>
        /// Constructs the Debugger for the specified Target.
        /// </summary>
        /// <param name="target">The target to be debugged.</param>
        public Debugger(ITarget target)
        {
            if (target == null) throw new ArgumentNullException();

            Target = target;
            Breakpoints = new BreakpointManager(this);
            DebugInformation = new DebugInformation();
        }

        /// <summary>
        /// Constructor</summary>
        /// <param name="target">The ITarget whose information will be displayed</param>
        /// <param name="protocol">The target's protocol</param>
        public TargetViewModel(ITarget target, IProtocol protocol)
        {
            Requires.NotNull(target, "target");
            Requires.NotNull(protocol, "protocol");

            Target = target;
            m_protocol = protocol;
        }

    // When the player has entered the action they are using this turn
    public void SubmitActionRound(IAction action, Player player, ITarget target)
    {
        if (action is Card) {
            CastCard(action as Card, player, target);
        }

        PromptNextPlayer();
    }

        /// <summary>
        /// Gets the value to inject into the specified target.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="target">The target.</param>
        /// <returns>The value to inject into the specified target.</returns>
        public object GetValue(IContext context, ITarget target)
        {
            Ensure.ArgumentNotNull(context, "context");
            Ensure.ArgumentNotNull(target, "target");

            var parameter = context.Parameters.OfType<PropertyValue>().Where(p => p.Name == target.Name).SingleOrDefault();
            return parameter != null ? parameter.GetValue(context) : target.ResolveWithin(context);
        }

 protected void CastCard(Card card, Player origin, ITarget target)
 {
     card.CastOrigin = origin;
     card.CastTarget = target;
     CardStack.Push (card);
     if (target is Player) {
         AlertPlayerForResponse(target as Player, origin, card);
     }
 }

		/*----------------------------------------------------------------------------------------*/
		#region Constructors
		/// <summary>
		/// Creates a new Argument.
		/// </summary>
		/// <param name="target">The argument's injection point.</param>
		/// <param name="resolver">The argument's dependency marker.</param>
		/// <param name="optional">A value indicating whether the argument is optional.</param>
		public Argument(ITarget target, IResolver resolver, bool optional)
		{
			Ensure.ArgumentNotNull(target, "target");
			Ensure.ArgumentNotNull(resolver, "dependency");

			Target = target;
			Resolver = resolver;
			Optional = optional;
		}

		public SimpleProvider (ITarget[] targets) {
			this.targets = new Hashtable ();

			if (targets == null)
				return;

			foreach (ITarget t in targets)
				AddTarget (t);
		}

		public ImageLoaderTask(IDownloadCache downloadCache, IMainThreadDispatcher mainThreadDispatcher, IMiniLogger miniLogger, TaskParameter parameters, nfloat imageScale, ITarget<UIImage, ImageLoaderTask> target, bool clearCacheOnOutOfMemory)
			: base(mainThreadDispatcher, miniLogger, parameters, true, clearCacheOnOutOfMemory)
		{
			if (target == null)
				throw new ArgumentNullException(nameof(target));
			
			_target = target;
			DownloadCache = downloadCache;
		}

		public TargetObjectBaseCore(ITarget builtFrom,
				IIdentifiableRetrievalManager retrievalManager) : base(builtFrom) {
			this.referenceValues = new List<IReferenceValueBase>();
			this.builtFrom = builtFrom;
			/* foreach */
			foreach (IReferenceValue referenceValue  in  builtFrom.ReferenceValues) {
				referenceValues.Add(new ReferenceValueObjectBaseCore(referenceValue, retrievalManager));
			}
		}

 /// <summary>
 /// Plots a direct course to the target and notifies the ship of the outcome via the
 /// onCoursePlotSuccess/Failure events if set. The actual location is adjusted for the ship's
 /// position within the fleet's formation.
 /// </summary>
 /// <param name="target">The target.</param>
 /// <param name="speed">The speed.</param>
 public override void PlotCourse(ITarget target, float speed) {
     base.PlotCourse(target, speed);
     if (CheckApproachTo(Destination)) {
         OnCoursePlotSuccess();
     }
     else {
         OnCoursePlotFailure();
     }
 }

 public Policy(string id, 
     ITarget target, 
     ICombiningAlgorithm combiningAlgorithm, 
     IEnumerable<IRule> rules)
 {
     Id = id;
     Target = target;
     CombiningAlgorithm = combiningAlgorithm;
     Rules = rules;
 }

 public IOutputWriter Create(TargetType targetType, BlockingCollection<Block> outputQueue, ITarget target)
 {
     switch (targetType)
     {
         case TargetType.Callback:
             return new CallbackWriter(outputQueue, target);
         default:
             throw new ArgumentOutOfRangeException("targetType");
     }
 }