public RunParameters(string exePath, string workingDirectory, string parameters, IAgent agent)
 {
     this.exePath = exePath;
     this.workingDirectory = workingDirectory;
     this.parameters = parameters;
     this.agent = agent;
 }

        public User(IAgent agent)
        {
            this._Agent = agent;

            this._Updater = new Updater();
            this._User = new Remoting.User(this._Agent);
        }

 //добавляем одного агента в общий каталог
 public static void AddOneAgent(IAgent agent)
 {
     lock (agentDictionary)
     {
         agentDictionary.Add(agent.GetId(), agent);
     }
 }

 static double Evaluate(IAgent model, IAgent benchmark, GridGameParameters _params)
 {
     double score = 0;
     Console.WriteLine("Starting games as player 1..");
     for (int i = 0; i < _params.MatchesPerOpponent; i++)
     {
         var game = _params.GameFunction(model, benchmark);
         game.PlayToEnd();
         if (game.Winner == 1)
             score += _params.WinReward;
         else if (game.Winner == 0)
             score += _params.TieReward;
         else
             score += _params.LossReward;
     }
     Console.WriteLine("Starting games as player 2..");
     for (int i = 0; i < _params.MatchesPerOpponent; i++)
     {
         var game = _params.GameFunction(benchmark, model);
         game.PlayToEnd();
         if (game.Winner == -1)
             score += _params.WinReward;
         else if (game.Winner == 0)
             score += _params.TieReward;
         else
             score += _params.LossReward;
     }
     Console.WriteLine("Done!");
     return score;
 }

        /// <summary>
        /// Combines wandering and separation
        /// </summary>
        public static void Wander(IAgent agent, IAgent[] otherAgents, ref Steering.SteerParameters steerParams)
        {
            // add up the steering forces
            Vector3 wander = Steering.WanderForce(agent, ref steerParams);
            Vector3 separation = Vector3.Zero;
            Vector3 bounds = Steering.WorldBoundsForce(agent, steerParams);

            int avoiding = 0;
            for (int i = 0; i < otherAgents.Length; i++)
            {
                IAgent otherAgent = otherAgents[i];

                if (agent != otherAgent)
                {
                    float separationDistance = Vector3.Distance(agent.Position, otherAgent.Position);
                    if (separationDistance < steerParams.SeparationRange)
                    {
                        separation += Steering.SeparationForce(agent, otherAgent, steerParams, separationDistance);
                        avoiding++;
                    }
                }
            }

            agent.Direction = Vector3.Normalize(agent.Direction + wander + separation + bounds);
        }

        public override IEnumerable<Term> FindTargetTerms(IAgent agent, Func<Term, bool> predicate)
        {
            Func<Term, bool> whereClause = t => t.Level > 0 && t.Level < 3 && predicate(t);
            var results = agent.SelectTargetTerms(whereClause);

            return results;
        }

        public void SetAgent(IAgent aAgent)
        {
            // detach existing agent
              if (mAgent != null) {
            if (mAgent is Agent) {
              var agent = mAgent as Agent;
              agent.KeyListChanged -= AgentKeyListChangeHandler;
              agent.Locked -= AgentLockHandler;
            }
              }

              mAgent = aAgent;

              if (mAgent is Agent) {
            var agent = mAgent as Agent;
            mKeyNodeView.Columns[0].Visible = true;
            mKeyNodeView.Columns[1].Visible = true;
            agent.KeyListChanged += AgentKeyListChangeHandler;
            agent.Locked += AgentLockHandler;
            //buttonTableLayoutPanel.Controls.Remove(refreshButton);
            //buttonTableLayoutPanel.ColumnCount = 5;
              } else {
            mKeyNodeView.Columns[0].Visible = false;
            mKeyNodeView.Columns[1].Visible = false;
            //buttonTableLayoutPanel.ColumnCount = 6;
            //buttonTableLayoutPanel.Controls.Add(refreshButton, 5, 0);
              }
              ReloadKeyListView();
        }

        public override IEnumerable<Term> FindTargetTerms(IAgent agent, Func<Term, bool> predicate)
        {
            var results = agent.SelectTargetTerms(
                t => (t is Assignment || t is OvertimeAssignment) && predicate(t));

            return results;
        }

        static void PerformGameBenchmarking()
        {
            Dictionary<int, int> wins = new Dictionary<int, int>(4);

            for (int i = 0; i < 1000; i++)
            {
                var controller = new GameController();
                var agents = new IAgent[] { new StarterAgent(), new StarterAgent(), new StarterAgent() }; // new HumanAgent()
                int intWinner = controller.StartGame(agents, i, i, false, false);
                //var winner = agents[intWinner];

                if (wins.ContainsKey(intWinner))
                {
                    wins[intWinner] = wins[intWinner] + 1;
                }
                else
                {
                    wins.Add(intWinner, 1);
                }
                Console.WriteLine(i + ": P " + intWinner + " wins.");
            }

            Console.WriteLine();
            wins.OrderBy(w => w.Key).ForEach(kv => Console.WriteLine("Player " + kv.Key + ": " + kv.Value + " wins."));
        }

 private void _ToGaming(IAgent agent)
 {
     var stage = new LocalGamingStage(agent, WorldPrefab, ControllerPrefab);
     stage.DoneEvent += _ToSetting;
     _DrawWindow = stage.DrawWindow;
     _Machine.Push(stage);
 }

        public DeaWinService(ILog log, IAgent agent)
        {
            this.log = log;
            this.agent = agent;

            agentTask = new Task(() => agent.Start());
            agentMonitorTimer = new Timer(agentMonitor);
        }

    public void addAgent(IAgent a, System.String startLocation)
    {
		// Ensure the agent state information is tracked before
		// adding to super, as super will notify the registered
		// EnvironmentViews that is was added.
		state.setAgentLocationAndTravelDistance(a, startLocation, 0.0);
		base.addAgent(a);
	}

 public User(IAgent agent)
 {
     _Agent = agent;
     _ConnectProvider = new TProvider<IConnect>();
     _OnlineProvider = new TProvider<IOnline>();
     _Machine = new StageMachine();
     _Updater = new Updater();
 }

        //---------------------------------------------------------------------
        ///<summary>
        ///Calculate the Site Resource Dominance (SRD) for all active sites.
        ///The SRD averages the resources for each species as defined in the
        ///BDA species table.
        ///SRD ranges from 0 - 1.
        ///</summary>
        //---------------------------------------------------------------------
        public static void SiteResourceDominance(IAgent agent, int ROS)
        {
            PlugIn.ModelCore.Log.WriteLine("   Calculating BDA Site Resource Dominance.");

            foreach (ActiveSite site in PlugIn.ModelCore.Landscape) {

                double sumValue = 0.0;
                double maxValue = 0.0;
                int    ageOldestCohort= 0;
                int    numValidSpp = 0;
                double speciesHostValue = 0;

                foreach (ISpecies species in PlugIn.ModelCore.Species)
                {
                    ageOldestCohort = Util.GetMaxAge(SiteVars.Cohorts[site][species]);
                    ISppParameters sppParms = agent.SppParameters[species.Index];
                    if (sppParms == null)
                        continue;

                    bool negList = false;
                    foreach (ISpecies negSpp in agent.NegSppList)
                    {
                        if (species == negSpp)
                            negList = true;
                    }

                    if ((ageOldestCohort > 0) && (! negList))
                    {
                        numValidSpp++;
                        speciesHostValue = 0.0;

                        if (ageOldestCohort >= sppParms.MinorHostAge)
                            //speciesHostValue = 0.33;
                            speciesHostValue = sppParms.MinorHostSRD;

                        if (ageOldestCohort >= sppParms.SecondaryHostAge)
                            //speciesHostValue = 0.66;
                            speciesHostValue = sppParms.SecondaryHostSRD;

                        if (ageOldestCohort >= sppParms.PrimaryHostAge)
                            //speciesHostValue = 1.0;
                            speciesHostValue = sppParms.PrimaryHostSRD;


                        sumValue += speciesHostValue;
                        maxValue = System.Math.Max(maxValue, speciesHostValue);
                    }
                }

                if (agent.SRDmode == SRDmode.mean)
                    SiteVars.SiteResourceDom[site] = sumValue / (double) numValidSpp;

                if (agent.SRDmode == SRDmode.max)
                    SiteVars.SiteResourceDom[site] = maxValue;

            }

        }  //end siteResourceDom

 public Game(IMapGenerator generator, IEnumerable<IAction> coreActions, IAgent agent)
 {
     _initialiseHooks = new List<IInitialiseHook>();
     _addedActions = new List<IAction>();
     _actionHooks = new Dictionary<string, List<IActionHook>>();
     _coreActions = coreActions;
     _generator = generator;
     Reset(agent);
 }

 public XenGuestServices(IAgent agent)
 {
     xgsc = agent;
     uuid = xgsc.GetUuid();
     domid = xgsc.GetDomId();
     showSwitcher = xgsc.GetShowSwitcher();
     vmsEventName = xgsc.RegisterVmsEvent();
     alertsEventName = xgsc.RegisterAlertsEvent();
 }

        void world_PlantEaten(object sender, IAgent eater, Plant eaten)
        {
            // Only update the observed reward if it was a result of our action
            if (eater != this)
                return;

            // If we receive a reward for taking a step, record it
            reward += eaten.Reward;
        }

        public User(IAgent agent)
        {
            _Agent = agent;
            _Updater = new Updater();
            _User = new Regulus.Remoting.User(_Agent);

            _Version = typeof(IVerify).Assembly.GetName()
                                    .Version.ToString();
        }

        public void TryDispatch(IAgent agent, Func<Term, bool> filter, Action<Term, TimeBox> action, Action<ITerm, string, bool> callback)
        {
            _dispatchedCallback = callback;
            _customValidation = filter;

            var newSubEvent = Term.New(SearchDate, SelectedEventType, _length);
            //newSubEvent.Tag = comments;
            action(newSubEvent, agent.Schedule);
        }

 public ActionResult DoSpecial(string action, IAgent agent)
 {
     return new ActionResult()
                {
                    Message = string.Empty,
                    MoveSuccessful = true,
                    Special = false,
                    GameOver = true
                };
 }