public StoreGet(Environment environment, Action<Event> callback)
     : base(environment)
 {
     CallbackList.Add(callback);
       Time = environment.Now;
       Process = environment.ActiveProcess;
 }

        public static SExp Cond(SExp[] vals, Environment env)
        {
            SExp res = new Undefined();
              foreach (SExp exp in vals)
              {
            if (!(exp is Cell))
            {
              string msg = "cond: malformed clauses.";
              throw new TypeNotMatchException(msg);
            }

            SExp test = (exp as Cell).Car;

            if (!((exp as Cell).Cdr is Cell))
            {
              string msg = "cond: malformed clauses.";
              throw new TypeNotMatchException(msg);
            }

            SExp[] body = ((exp as Cell).Cdr as Cell).ToArray();

            if (Utilities.CanRegardAsTrue(Utilities.Eval(test, env)))
            {
              res = Utilities.Eval(body, env);
              break;

            }
              }
              return res;
        }

        public void Environment_Constructor_Sets_Properties_Correctly()
        {
            var environment = new Environment("en-gb")
            {
                CharacterSet = "iso-8550-1",
                FlashVersion = "11.0.1b",
                ScreenColorDepth = 32,
                IpAddress = "127.0.0.1",
                JavaEnabled = true,
                ScreenHeight = 1050,
                ScreenWidth = 1920,
                ViewportHeight = 768,
                ViewportWidth = 1024
            };

            Assert.AreEqual("iso-8550-1", environment.CharacterSet);
            Assert.AreEqual("en-gb", environment.LanguageCode);
            Assert.AreEqual("11.0.1b", environment.FlashVersion);
            Assert.AreEqual(32u, environment.ScreenColorDepth);
            Assert.AreEqual("127.0.0.1", environment.IpAddress);
            Assert.AreEqual(true, environment.JavaEnabled);
            Assert.AreEqual(1050u, environment.ScreenHeight);
            Assert.AreEqual(1920u, environment.ScreenWidth);
            Assert.AreEqual(768u, environment.ViewportHeight);
            Assert.AreEqual(1024u, environment.ViewportWidth);
        }

        public PanningBackground()
        {
            m_parallaxEnvironments = new LinkedList<ParallaxEnvironment>();
            m_random = new Random(DateTime.Now.Millisecond);
            float t_houseDistance = Game.getInstance().getResolution().X / 10;
            m_background = Game.getInstance().Content.Load<Texture2D>("Images//Background//starry_sky_01");

            for (int i = 0; i < 50; i++)
            {
                m_parallaxEnvironments.AddLast(new ParallaxEnvironment(
                    new Vector2(t_houseDistance * i - Game.getInstance().m_camera.getRectangle().Width, -300),
                    "Images//Background//Parallax//bg_house_0" + randomNumber(1, 7).ToString(),
                    0.950f
                ));
                m_parallaxEnvironments.Last().setParrScroll(randomNumber(50, 600));
            }
            for (int i = 0; i < 25; i++)
            {
                m_parallaxEnvironments.AddLast(new ParallaxEnvironment(
                    new Vector2(t_houseDistance * i - Game.getInstance().m_camera.getRectangle().Width, randomNumber(-300, 200)),
                    "Images//Background//Parallax//clouds_0" + randomNumber(1, 4).ToString(),
                    0.950f
                ));
                m_parallaxEnvironments.Last().setParrScroll(randomNumber(50, 600));
            }
            m_logo = new Environment(new Vector2(-400, -250), "Images//GUI//logotext", 0.800f);
        }

        void ICanModifyContext.PopulateContext(Environment env, string ns)
        {
            AST ast;
            for (int i = 0; i < elems.Count; i++) {
                ast = (AST) elems [i];
                if (ast is FunctionDeclaration) {
                    string name = ((FunctionDeclaration) ast).func_obj.name;
                    AST binding = (AST) env.Get (ns, Symbol.CreateSymbol (name));

                    if (binding == null)
                        SemanticAnalyser.Ocurrences.Enter (ns, Symbol.CreateSymbol (name), new DeleteInfo (i, this));
                    else {
                        DeleteInfo delete_info = (DeleteInfo) SemanticAnalyser.Ocurrences.Get (ns, Symbol.CreateSymbol (name));
                        if (delete_info != null) {
                            delete_info.Block.elems.RemoveAt (delete_info.Index);
                            SemanticAnalyser.Ocurrences.Remove (ns, Symbol.CreateSymbol (name));
                            if (delete_info.Block == this)
                                if (delete_info.Index < i)
                                    i--;

                            SemanticAnalyser.Ocurrences.Enter (ns, Symbol.CreateSymbol (name), new DeleteInfo (i, this));
                        }
                    }
                }
                if (ast is ICanModifyContext)
                    ((ICanModifyContext) ast).PopulateContext (env, ns);
            }
        }

        public BasicLoopWord(string definingWordName, Environment env)
            : base(definingWordName, env)
        {
            CycleWord = new ControlFlowWord("cycle", env);

            PrimitiveExecuteAction = executeLoop;
        }

 /// <summary>
 /// Initializes a new instance of the EvaluateTimeBase class.
 /// </summary>
 /// <param name="expr">The expression to evaluate.</param>
 /// <param name="count">The number of times to evaluate.</param>
 /// <param name="env">The evaluation environment</param>
 /// <param name="caller">The caller.  Return to this when done.</param>
 protected EvaluateTimeBase(SchemeObject expr, int count, Environment env, Evaluator caller)
     : base(InitialStep, expr, env, caller)
 {
     this.counter = count;
     this.startMem = GC.GetTotalMemory(true);
     this.stopwatch = Stopwatch.StartNew();
 }

        // AudioContexts are per process and not per thread
        public static Environment Instance()
        {
            if (env == null)
                    env = new Environment();

                return env;
        }

        //Constructor that initializes variables with default values
        public Environment copy()
        {
            Environment newenv = new Environment();
              newenv.seed=seed;
              newenv.AOIRectangle = new Rectangle(AOIRectangle.X,AOIRectangle.Y,AOIRectangle.Width,AOIRectangle.Height);
              newenv.group_orientation = group_orientation;
              newenv.goal_point = new Point2D(goal_point);
              newenv.start_point = new Point2D(start_point);
              newenv.robot_heading = robot_heading;
              newenv.robot_spacing = robot_spacing;
              newenv.maxDistance=maxDistance;
              newenv.name=name;
              newenv.view_scale=view_scale;
              newenv.view_x=view_x;
              newenv.view_y=view_y;

            foreach (Wall w in walls) {
             newenv.walls.Add(new Wall(w));
            }
            foreach (Prey p in preys) {
              newenv.preys.Add(new Prey(p));
            }
            foreach (Point p in POIPosition) {
             newenv.POIPosition.Add(new Point(p.X,p.Y));
            }
              newenv.rng = new SharpNeatLib.Maths.FastRandom(seed);
             return newenv;
        }

 public GrabComponent(Entity parent, Environment environment, float baseDamage, float maxDamage)
     : base(parent, "GrabComponent")
 {
     this.environment = environment;
     this.baseDamage = baseDamage;
     this.maxDamage = maxDamage;
 }

 public override Node eval(Node t, Environment env)
 {
     Node clauseList = t.getCdr();
     Node clause = clauseList.getCar();
     while(clause != Nil.getInstance())
     {
         Node predicate = clause.getCar().eval(env);
         if(predicate == BoolLit.getInstance(true) || predicate.getName() == "else")
         {
             Node expressionList = clause.getCdr();
             //evaluate all expressions and return the result of the last evaluation
             Node lastEval = expressionList.getCar().eval(env);
             //If there are more expressions to evaluate
             while(expressionList.getCdr() != Nil.getInstance())
             {
                 expressionList = expressionList.getCdr();
                 lastEval = expressionList.getCar().eval(env);
             }
             return lastEval;
         }
         clauseList = clauseList.getCdr();
         clause = clauseList.getCar();
     }
     //Does not yet handle else's
     return Nil.getInstance();
 }

 public void play(Environment e, UsefulMethods odd, Player player)
 {
     Random rand = new Random();
     int randNum = rand.Next(0, 0); // update for number of missions
     if (randNum == 0)
         environment_1(e, odd, player);
 }

 internal SamplingRecordProvider(Environment environment, IEnvironmentService service,
     IRecordable recordable, int id, bool recordPeriodEnabled, TimeSpan recordPeriod)
     : base(environment, service, recordable, id)
 {
     this.recordPeriodEnabled = recordPeriodEnabled;
     this.recordPeriod = recordPeriod;
 }

        /// <summary>
        /// This method create the initial scene
        /// </summary>
        protected override void CreateScene()
        {
            #region Basics
            physics = new Physics();

            robot = new Robot(mSceneMgr);
            robot.setPosition(new Vector3(000, 0, 300));
            environment = new Environment(mSceneMgr, mWindow);
            playerModel = new PlayerModel(mSceneMgr);
            playerModel.setPosition(new Vector3(0, -80, 50));
            playerModel.hRotate(new Vector3(600, 0, 0));
            #endregion

            #region Camera
            cameraNode = mSceneMgr.CreateSceneNode();
            cameraNode.AttachObject(mCamera);
            playerModel.AddChild(cameraNode);
            inputsManager.PlayerModel = playerModel;
            #endregion

            #region Part 9
            PlayerStats playerStats = new PlayerStats();
            gameHMD = new GameInterface(mSceneMgr, mWindow, playerStats);
            #endregion

            robots = new List<Robot>();
            robots.Add(robot);
            robotsToRemove = new List<Robot>();
            bombs = new List<Bomb>();
            bombsToRemove = new List<Bomb>();
            physics.StartSimTimer();
        }

 private DeviceProvider(Environment environment, IEnvironmentService service,
     Guid id, string name, string description)
     : base(id, name, description)
 {
     this.environment = environment;
     this.service = service;
 }

        public void LoadData()
        {
            environment = World.Instance.Environment;
            environment.SkyBox.Create(device);

            ShaderConstants.LightDirection = new Vector4(environment.Stars[0].LightDirection.X,
                environment.Stars[0].LightDirection.Y,
                environment.Stars[0].LightDirection.Z,
                0);
            //environment = null;
            //Vector4 v=new Vector4(0, -0.5f, -1, 0);
            //v.Normalize();
            //ShaderConstants.LightDirection = v;
            ShaderConstants.Projection = device.Transform.Projection;

            ShaderConstants.LightColor = new ColorValue(1, 1, 1);

            //foreach (IGameObject obj in World.Instance.GameObjects)
            //{
            //    //if (obj is Ship)
            //    //{
            //    //    EngineEmitter em=new EngineEmitter(particleSystem);
            //    //    this.particleSystem.AddEmitter(em);
            //    //    shipEngineEmitters.Add(obj as Ship, em);
            //    //}
            //}

            World.Instance.OnObjectAdded += new ObjectEventHandler(World_OnObjectAdded);
            World.Instance.OnObjectRemoved += new ObjectEventHandler(World_OnObjectRemoved);

            World.Instance.OnCharacterAdded += new CharacterEventHandler(World_OnShipAdded);
            World.Instance.OnCharacterRemoved += new CharacterEventHandler(World_OnShipRemoved);
        }

        public int TransformDirectory(string path, Environment targetEnvironment, bool deleteTemplate = true)
        {
            Log.DebugFormat("Transform templates for environment {1} ind {0} {2} deleting templates", path, targetEnvironment.Name, deleteTemplate ? "with" : "without");

            VariableResolver = new VariableResolver(targetEnvironment.Variables);

            int templateCounter = 0;

            foreach (var templateFile in _fileSystem.EnumerateDirectoryRecursive(path, "*.template.*", SearchOption.AllDirectories))
            {
                ++templateCounter;
                Log.Info(string.Format("  Transform template {0}", templateFile));

                var templateText = _fileSystem.ReadFile(templateFile);
                var transformed = VariableResolver.TransformVariables(templateText);

                _fileSystem.OverwriteFile(templateFile.Replace(".template.", ".").Replace(".Template.", "."), transformed);

                if (deleteTemplate)
                {
                    _fileSystem.DeleteFile(templateFile);
                }
            }

            Log.DebugFormat("Transformed {0} template(s) in {1}.", templateCounter, path);

            return templateCounter;
        }

 void incrementFitness(Environment environment, instance_pack ip) 
 {
     // Schrum: Added to avoid magic numbers and make purpose clear
     float MAX_DISTANCE = 300.0f;
     // Schrum: Last POI is actually goal: Return to start
     for (int i = 0; i < reachedPOI.Length; i++)
     {
         if (reachedPOI[i])
         {
             fitness += 1.0f;
         }
         else if (i == 3) { // Schrum: Hack: Last POI is actually the goal
             double gain = (1.0f - ip.robots[0].location.manhattenDistance(environment.goal_point) / MAX_DISTANCE);
             //Console.WriteLine("Goal Gain = " + gain);
             fitness += gain;
             break;
         }
         else
         {
             // Schrum: From HardMaze
             //fitness += (1.0f - ip.robots[0].location.distance(new Point2D(environment.POIPosition[i].X, environment.POIPosition[i].Y)) / 650.0f);
             // Schrum: Guessing at distance to divide by
             // Schrum: Switched to Manhattan distance since Team Patrol uses it
             double gain = (1.0f - ip.robots[0].location.manhattenDistance(new Point2D(environment.POIPosition[i].X, environment.POIPosition[i].Y)) / MAX_DISTANCE);
             //Console.WriteLine("Gain = " + gain);
             fitness += gain;
             break;
         }
     }
 }

        public MultiAgentExperiment()
        {
            benchmark=false;
            multibrain = false;
            evolveSubstrate = false;

            collisionPenalty = false;
            //heterogenous trams by default
            homogeneousTeam = false;

            scriptFile = "";
            numberRobots = 1;
            //how many range finders
            rangefinderSensorDensity = 11; /*<------THIS MUST BE CHANGED FOR EACH ROBOT MODEL!!!*/
            timestep = 0.16f;

            evaluationTime = 100;

            explanatoryText = "Multi-Agent Experiment";
            //Environment = new List<Environment>();

            //Create an empty environment
            environment = new Environment();
            robots = new List<Robot>();

            fitnessFunctionName = "SingleGoalPoint";
            behaviorCharacterizationName = "EndPointBC";
            robotModelName = "PackBotModel";

            initialized = false;
            running = false;
        }

		void ICanModifyContext.PopulateContext (Environment env, string ns)
		{
			Symbol _id = Symbol.CreateSymbol (id);

			if (!env.InCurrentScope (ns, _id))
				env.Enter (ns, _id, this);
		}