Merge master into hotfix-0.13.1

.circleci/config.yml

             . venv/bin/activate
             mkdir test-reports
             pip freeze > test-reports/pip_versions.txt
-            pytest --cov=ml-agents --cov=ml-agents-envs --cov=gym-unity --cov-report html --junitxml=test-reports/junit.xml -p no:warnings
+            pytest -n 2 --cov=ml-agents --cov=ml-agents-envs --cov=gym-unity --cov-report html --junitxml=test-reports/junit.xml -p no:warnings
 
       - run:
           name: Verify there are no hidden/missing metafiles.

.gitignore

 /UnitySDK/Assets/AssetStoreTools*
 /UnitySDK/Assets/Plugins*
 /UnitySDK/Assets/Demonstrations*
+/UnitySDK/csharp_timers.json
 
 # Tensorflow Model Info
 /models

.yamato/csharp-tests.yml

   variables:
     UNITY_VERSION: {{ editor.version }}
   commands:
-    - ./run-tests-editmode-osx-editor.sh
+    - python -u -m ml-agents.tests.yamato.editmode_tests
   triggers:
     pull_requests:
       - targets:
             - "/hotfix-.*/"
+  artifacts:
+    unit:
+      paths:
+        - "artifacts/**"
 {% endfor %}

.yamato/standalone-build-test.yml

   variables:
     UNITY_VERSION: {{ editor.version }}
   commands:
-    - ./run-standalone-build-osx.sh
+    - python -u -m ml-agents.tests.yamato.standalone_build_tests
   triggers:
     pull_requests:
       - targets:

UnitySDK/Assets/ML-Agents/Editor/AgentEditor.cs

             var serializedAgent = serializedObject;
             serializedAgent.Update();
 
-            var actionsPerDecision = serializedAgent.FindProperty(
-                "agentParameters.numberOfActionsBetweenDecisions");
-            var isResetOnDone = serializedAgent.FindProperty(
-                "agentParameters.resetOnDone");
-            var isOdd = serializedAgent.FindProperty(
-                "agentParameters.onDemandDecision");
-
-
-            EditorGUILayout.PropertyField(
-                isResetOnDone,
-                new GUIContent(
-                    "Reset On Done",
-                    "If checked, the agent will reset on done. Else, AgentOnDone() will be called."));
-            EditorGUILayout.PropertyField(
-                isOdd,
-                new GUIContent(
-                    "On Demand Decisions",
-                    "If checked, you must manually request decisions."));
-            if (!isOdd.boolValue)
-            {
-                EditorGUILayout.PropertyField(
-                    actionsPerDecision,
-                    new GUIContent(
-                        "Decision Interval",
-                        "The agent will automatically request a decision every X" +
-                        " steps and perform an action at every step."));
-                actionsPerDecision.intValue = Mathf.Max(1, actionsPerDecision.intValue);
-            }
 
             serializedAgent.ApplyModifiedProperties();
 

UnitySDK/Assets/ML-Agents/Editor/DemonstrationImporter.cs

                 var texture = (Texture2D)
                     AssetDatabase.LoadAssetAtPath(k_IconPath, typeof(Texture2D));
 
-#if UNITY_2017_3_OR_NEWER
-#else
-                ctx.SetMainAsset(ctx.assetPath, demonstration);
-#endif
             }
             catch
             {

UnitySDK/Assets/ML-Agents/Editor/Tests/DemonstrationTests.cs

 using System.IO.Abstractions.TestingHelpers;
 using System.Reflection;
 using MLAgents.CommunicatorObjects;
+using MLAgents.Sensor;
+    [TestFixture]
+
+        [SetUp]
+        public void SetUp()
+        {
+            if (Academy.IsInitialized)
+            {
+                Academy.Instance.Dispose();
+            }
+        }
 
         [Test]
         public void TestSanitization()
                 storedVectorActions = new[] { 0f, 1f },
             };
 
-            demoStore.Record(agentInfo);
+            demoStore.Record(agentInfo, new System.Collections.Generic.List<ISensor>());
             demoStore.Close();
         }
 
             demoRecorder.record = true;
             demoRecorder.InitializeDemoStore(fileSystem);
 
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
-
-            var academyInitializeMethod = typeof(Academy).GetMethod("InitializeEnvironment",
-                BindingFlags.Instance | BindingFlags.NonPublic);
             var agentEnableMethod = typeof(Agent).GetMethod("OnEnable",
                 BindingFlags.Instance | BindingFlags.NonPublic);
             var agentSendInfo = typeof(Agent).GetMethod("SendInfo",
-            academyInitializeMethod?.Invoke(aca, new object[] { });
 
             // Step the agent
             agent1.RequestDecision();
                     Assert.AreEqual((float)i + 1, vecObs[i]);
                 }
             }
-
-
         }
     }
 }

UnitySDK/Assets/ML-Agents/Editor/Tests/EditModeTestInternalBrainTensorApplier.cs

 using System.Reflection;
 using Barracuda;
 using MLAgents.InferenceBrain;
+using System;
 
 namespace MLAgents.Tests
 {
             }
         }
 
-        List<Agent> GetFakeAgentInfos()
-        {
-            var goA = new GameObject("goA");
-            var agentA = goA.AddComponent<TestAgent>();
-            var goB = new GameObject("goB");
-            var agentB = goB.AddComponent<TestAgent>();
-
-            return new List<Agent> { agentA, agentB };
-        }
-
         [Test]
         public void Construction()
         {
                 shape = new long[] { 2, 3 },
                 data = new Tensor(2, 3, new float[] { 1, 2, 3, 4, 5, 6 })
             };
-            var agentInfos = GetFakeAgentInfos();
-            applier.Apply(inputTensor, agentInfos);
-            var agents = agentInfos;
+
+            var action0 = new AgentAction();
+            var action1 = new AgentAction();
+            var callbacks = new List<AgentIdActionPair>()
+            {
+                new AgentIdActionPair{agentId = 0, action = (a) => action0 = a},
+                new AgentIdActionPair{agentId = 1, action = (a) => action1 = a}
+            };
+
+            applier.Apply(inputTensor, callbacks);
+
-            var agent = agents[0] as TestAgent;
-            Assert.NotNull(agent);
-            var action = agent.GetAction();
-            Assert.AreEqual(action.vectorActions[0], 1);
-            Assert.AreEqual(action.vectorActions[1], 2);
-            Assert.AreEqual(action.vectorActions[2], 3);
+            Assert.AreEqual(action0.vectorActions[0], 1);
+            Assert.AreEqual(action0.vectorActions[1], 2);
+            Assert.AreEqual(action0.vectorActions[2], 3);
-            agent = agents[1] as TestAgent;
-            Assert.NotNull(agent);
-            action = agent.GetAction();
-            Assert.AreEqual(action.vectorActions[0], 4);
-            Assert.AreEqual(action.vectorActions[1], 5);
-            Assert.AreEqual(action.vectorActions[2], 6);
+            Assert.AreEqual(action1.vectorActions[0], 4);
+            Assert.AreEqual(action1.vectorActions[1], 5);
+            Assert.AreEqual(action1.vectorActions[2], 6);
         }
 
         [Test]
                     5,
                     new[] { 0.5f, 22.5f, 0.1f, 5f, 1f, 4f, 5f, 6f, 7f, 8f })
             };
-            var agentInfos = GetFakeAgentInfos();
-            applier.Apply(inputTensor, agentInfos);
-            var agents = agentInfos;
-            var agent = agents[0] as TestAgent;
-            Assert.NotNull(agent);
-            var action = agent.GetAction();
-            Assert.AreEqual(action.vectorActions[0], 1);
-            Assert.AreEqual(action.vectorActions[1], 1);
-
-            agent = agents[1] as TestAgent;
-            Assert.NotNull(agent);
-            action = agent.GetAction();
-            Assert.AreEqual(action.vectorActions[0], 1);
-            Assert.AreEqual(action.vectorActions[1], 2);
-            alloc.Dispose();
-        }
-
-        [Test]
-        public void ApplyValueEstimate()
-        {
-            var inputTensor = new TensorProxy()
+            var action0 = new AgentAction();
+            var action1 = new AgentAction();
+            var callbacks = new List<AgentIdActionPair>()
-                shape = new long[] { 2, 1 },
-                data = new Tensor(2, 1, new[] { 0.5f, 8f })
+                new AgentIdActionPair{agentId = 0, action = (a) => action0 = a},
+                new AgentIdActionPair{agentId = 1, action = (a) => action1 = a}
-            var agentInfos = GetFakeAgentInfos();
-            var applier = new ValueEstimateApplier();
-            applier.Apply(inputTensor, agentInfos);
-            var agents = agentInfos;
+            applier.Apply(inputTensor, callbacks);
-            var agent = agents[0] as TestAgent;
-            Assert.NotNull(agent);
-            var action = agent.GetAction();
-            Assert.AreEqual(action.value, 0.5f);
+            Assert.AreEqual(action0.vectorActions[0], 1);
+            Assert.AreEqual(action0.vectorActions[1], 1);
-            agent = agents[1] as TestAgent;
-            Assert.NotNull(agent);
-            action = agent.GetAction();
-            Assert.AreEqual(action.value, 8);
+            Assert.AreEqual(action1.vectorActions[0], 1);
+            Assert.AreEqual(action1.vectorActions[1], 2);
+            alloc.Dispose();
         }
     }
 }

UnitySDK/Assets/ML-Agents/Editor/Tests/EditModeTestInternalBrainTensorGenerator.cs

 
 namespace MLAgents.Tests
 {
+    [TestFixture]
-        static IEnumerable<Agent> GetFakeAgents()
+        [SetUp]
+        public void SetUp()
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
+            if (Academy.IsInitialized)
+            {
+                Academy.Instance.Dispose();
+            }
+        }
+        static List<Agent> GetFakeAgents()
+        {
             var goA = new GameObject("goA");
             var bpA = goA.AddComponent<BehaviorParameters>();
             bpA.brainParameters.vectorObservationSize = 3;
             {
                 var agentEnableMethod = typeof(Agent).GetMethod("OnEnableHelper",
                     BindingFlags.Instance | BindingFlags.NonPublic);
-                agentEnableMethod?.Invoke(agent, new object[] { aca });
+                agentEnableMethod?.Invoke(agent, new object[] { });
             }
             agentA.collectObservationsSensor.AddObservation(new Vector3(1, 2, 3));
             agentB.collectObservationsSensor.AddObservation(new Vector3(4, 5, 6));
 
             agentA.Info = infoA;
             agentB.Info = infoB;
-
             return agents;
         }
 
             generator.AddSensorIndex(0);
             generator.AddSensorIndex(1);
             generator.AddSensorIndex(2);
-            generator.Generate(inputTensor, batchSize, agentInfos);
+            var agent0 = agentInfos[0];
+            var agent1 = agentInfos[1];
+            var inputs = new List<AgentInfoSensorsPair>
+            {
+                new AgentInfoSensorsPair{agentInfo = agent0.Info, sensors = agent0.sensors},
+                new AgentInfoSensorsPair{agentInfo = agent1.Info, sensors = agent1.sensors},
+            };
+            generator.Generate(inputTensor, batchSize, inputs);
             Assert.IsNotNull(inputTensor.data);
             Assert.AreEqual(inputTensor.data[0, 0], 1);
             Assert.AreEqual(inputTensor.data[0, 2], 3);
             var agentInfos = GetFakeAgents();
             var alloc = new TensorCachingAllocator();
             var generator = new PreviousActionInputGenerator(alloc);
-
-            generator.Generate(inputTensor, batchSize, agentInfos);
+            var agent0 = agentInfos[0];
+            var agent1 = agentInfos[1];
+            var inputs = new List<AgentInfoSensorsPair>
+            {
+                new AgentInfoSensorsPair{agentInfo = agent0.Info, sensors = agent0.sensors},
+                new AgentInfoSensorsPair{agentInfo = agent1.Info, sensors = agent1.sensors},
+            };
+            generator.Generate(inputTensor, batchSize, inputs);
             Assert.IsNotNull(inputTensor.data);
             Assert.AreEqual(inputTensor.data[0, 0], 1);
             Assert.AreEqual(inputTensor.data[0, 1], 2);
             var agentInfos = GetFakeAgents();
             var alloc = new TensorCachingAllocator();
             var generator = new ActionMaskInputGenerator(alloc);
-            generator.Generate(inputTensor, batchSize, agentInfos);
+
+            var agent0 = agentInfos[0];
+            var agent1 = agentInfos[1];
+            var inputs = new List<AgentInfoSensorsPair>
+            {
+                new AgentInfoSensorsPair{agentInfo = agent0.Info, sensors = agent0.sensors},
+                new AgentInfoSensorsPair{agentInfo = agent1.Info, sensors = agent1.sensors},
+            };
+
+            generator.Generate(inputTensor, batchSize, inputs);
             Assert.IsNotNull(inputTensor.data);
             Assert.AreEqual(inputTensor.data[0, 0], 1);
             Assert.AreEqual(inputTensor.data[0, 4], 1);

UnitySDK/Assets/ML-Agents/Editor/Tests/MLAgentsEditModeTest.cs

 
 namespace MLAgents.Tests
 {
-    public class TestAcademy : Academy
-    {
-        public int initializeAcademyCalls;
-        public int AcademyStepCalls;
-
-        public override void InitializeAcademy()
-        {
-            initializeAcademyCalls += 1;
-        }
-
-        public override void AcademyReset()
-        {
-        }
-
-        public override void AcademyStep()
-        {
-            AcademyStepCalls += 1;
-        }
-    }
     public class TestAgent : Agent
     {
         public int initializeAgentCalls;
-        public int agentOnDoneCalls;
         public override void InitializeAgent()
         {
             initializeAgentCalls += 1;
             agentResetCalls += 1;
         }
 
-        public override void AgentOnDone()
-        {
-            agentOnDoneCalls += 1;
-        }
-
+
     }
 
     public class TestSensor : ISensor
             sensorName = n;
         }
 
-        public int[] GetFloatObservationShape()
+        public int[] GetObservationShape()
         {
             return new[] { 0 };
         }
         public void Update() { }
     }
 
+    [TestFixture]
+        [SetUp]
+        public void SetUp()
+        {
+            if (Academy.IsInitialized)
+            {
+                Academy.Instance.Dispose();
+            }
+        }
+
-            // Use the Assert class to test conditions.
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
+            var aca = Academy.Instance;
-            Assert.AreEqual(0, aca.initializeAcademyCalls);
+            Assert.AreEqual(0, aca.GetTotalStepCount());
         }
 
         [Test]
         }
     }
 
+    [TestFixture]
+        [SetUp]
+        public void SetUp()
+        {
+            if (Academy.IsInitialized)
+            {
+                Academy.Instance.Dispose();
+            }
+        }
+
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
-            Assert.AreEqual(0, aca.initializeAcademyCalls);
-            Assert.AreEqual(0, aca.GetStepCount());
-            Assert.AreEqual(0, aca.GetEpisodeCount());
-            //This will call the method even though it is private
-            var academyInitializeMethod = typeof(Academy).GetMethod("InitializeEnvironment",
-                BindingFlags.Instance | BindingFlags.NonPublic);
-            academyInitializeMethod?.Invoke(aca, new object[] { });
-            Assert.AreEqual(1, aca.initializeAcademyCalls);
+            Assert.AreEqual(false, Academy.IsInitialized);
+            var aca = Academy.Instance;
+            Assert.AreEqual(true, Academy.IsInitialized);
+
+            // Check that init is idempotent
+            aca.LazyInitialization();
+            aca.LazyInitialization();
+
-            Assert.AreEqual(0, aca.AcademyStepCalls);
+            Assert.AreEqual(0, aca.GetTotalStepCount());
+            Assert.AreNotEqual(null, aca.FloatProperties);
+
+            // Check that Dispose is idempotent
+            aca.Dispose();
+            Assert.AreEqual(false, Academy.IsInitialized);
+            aca.Dispose();
+        }
+
+        [Test]
+        public void TestAcademyDispose()
+        {
+            var floatProperties1 = Academy.Instance.FloatProperties;
+            Academy.Instance.Dispose();
+
+            var floatProperties2 = Academy.Instance.FloatProperties;
+            Academy.Instance.Dispose();
+
+            Assert.AreNotEqual(floatProperties1, floatProperties2);
         }
 
         [Test]
             var agentGo2 = new GameObject("TestAgent");
             agentGo2.AddComponent<TestAgent>();
             var agent2 = agentGo2.GetComponent<TestAgent>();
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
 
             Assert.AreEqual(false, agent1.IsDone());
             Assert.AreEqual(false, agent2.IsDone());
 
             var agentEnableMethod = typeof(Agent).GetMethod("OnEnableHelper",
                 BindingFlags.Instance | BindingFlags.NonPublic);
-            var academyInitializeMethod = typeof(Academy).GetMethod("InitializeEnvironment",
-                BindingFlags.Instance | BindingFlags.NonPublic);
-
-            agentEnableMethod?.Invoke(agent2, new object[] { aca });
-            academyInitializeMethod?.Invoke(aca, new object[] { });
-            agentEnableMethod?.Invoke(agent1, new object[] { aca });
+            agentEnableMethod?.Invoke(agent2, new object[] { });
+            agentEnableMethod?.Invoke(agent1, new object[] { });
 
             Assert.AreEqual(false, agent1.IsDone());
             Assert.AreEqual(false, agent2.IsDone());
         }
     }
 
+    [TestFixture]
+        [SetUp]
+        public void SetUp()
+        {
+            if (Academy.IsInitialized)
+            {
+                Academy.Instance.Dispose();
+            }
+        }
+
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
-            var academyInitializeMethod = typeof(Academy).GetMethod("InitializeEnvironment",
-                BindingFlags.Instance | BindingFlags.NonPublic);
-            academyInitializeMethod?.Invoke(aca, new object[] { });
-
-            var academyStepMethod = typeof(Academy).GetMethod("EnvironmentStep",
-                BindingFlags.Instance | BindingFlags.NonPublic);
+            var aca = Academy.Instance;
-                Assert.AreEqual(1, aca.initializeAcademyCalls);
-                Assert.AreEqual(i, aca.AcademyStepCalls);
 
                 // The reset happens at the beginning of the first step
                 if (i == 0)
-                academyStepMethod?.Invoke(aca, new object[] { });
+                Academy.Instance.EnvironmentStep();
+        public void TestAcademyAutostep()
+        {
+            var aca = Academy.Instance;
+            Assert.IsTrue(aca.IsAutomaticSteppingEnabled);
+            aca.DisableAutomaticStepping(true);
+            Assert.IsFalse(aca.IsAutomaticSteppingEnabled);
+            aca.EnableAutomaticStepping();
+            Assert.IsTrue(aca.IsAutomaticSteppingEnabled);
+        }
+
+        [Test]
         public void TestAgent()
         {
             var agentGo1 = new GameObject("TestAgent");
             agentGo2.AddComponent<TestAgent>();
             var agent2 = agentGo2.GetComponent<TestAgent>();
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
+            var aca = Academy.Instance;
-            var academyInitializeMethod = typeof(Academy).GetMethod(
-                "InitializeEnvironment", BindingFlags.Instance | BindingFlags.NonPublic);
-            // We use event based so the agent will now try to send anything to the brain
-            agent1.agentParameters.onDemandDecision = false;
-            agent1.agentParameters.numberOfActionsBetweenDecisions = 2;
+            var decisionRequester = agent1.gameObject.AddComponent<DecisionRequester>();
+            decisionRequester.DecisionPeriod = 2;
+            decisionRequester.Awake();
-            agent2.agentParameters.onDemandDecision = true;
-            agentEnableMethod?.Invoke(agent1, new object[] { aca });
-            academyInitializeMethod?.Invoke(aca, new object[] { });
-
-            var academyStepMethod = typeof(Academy).GetMethod(
-                "EnvironmentStep", BindingFlags.Instance | BindingFlags.NonPublic);
+            agentEnableMethod?.Invoke(agent1, new object[] { });
 
             var numberAgent1Reset = 0;
             var numberAgent2Initialization = 0;
                 //Agent 2 is only initialized at step 2
                 if (i == 2)
                 {
-                    agentEnableMethod?.Invoke(agent2, new object[] { aca });
+                    agentEnableMethod?.Invoke(agent2, new object[] { });
                     numberAgent2Initialization += 1;
                 }
 
                     requestAction += 1;
                     agent2.RequestAction();
                 }
-                academyStepMethod?.Invoke(aca, new object[] { });
+                aca.EnvironmentStep();
+    [TestFixture]
+        [SetUp]
+        public void SetUp()
+        {
+            if (Academy.IsInitialized)
+            {
+                Academy.Instance.Dispose();
+            }
+        }
+
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
-            var academyInitializeMethod = typeof(Academy).GetMethod(
-                "InitializeEnvironment", BindingFlags.Instance | BindingFlags.NonPublic);
-            academyInitializeMethod?.Invoke(aca, new object[] { });
-
-            var academyStepMethod = typeof(Academy).GetMethod(
-                "EnvironmentStep", BindingFlags.Instance | BindingFlags.NonPublic);
+            var aca = Academy.Instance;
 
             var numberReset = 0;
             var stepsSinceReset = 0;
-                Assert.AreEqual(1, aca.initializeAcademyCalls);
-                Assert.AreEqual(i, aca.AcademyStepCalls);
+                Assert.AreEqual(i, aca.GetTotalStepCount());
                 // Academy resets at the first step
                 if (i == 0)
                 {
                 stepsSinceReset += 1;
-                academyStepMethod.Invoke(aca, new object[] { });
+                aca.EnvironmentStep();
             }
         }
 
             var agentGo2 = new GameObject("TestAgent");
             agentGo2.AddComponent<TestAgent>();
             var agent2 = agentGo2.GetComponent<TestAgent>();
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
+            var aca = Academy.Instance;
-            var academyInitializeMethod = typeof(Academy).GetMethod(
-                "InitializeEnvironment", BindingFlags.Instance | BindingFlags.NonPublic);
-
-            var academyStepMethod = typeof(Academy).GetMethod(
-                "EnvironmentStep", BindingFlags.Instance | BindingFlags.NonPublic);
-            // We use event based so the agent will now try to send anything to the brain
-            agent1.agentParameters.onDemandDecision = false;
-            agent1.agentParameters.numberOfActionsBetweenDecisions = 2;
-            // agent1 will take an action at every step and request a decision every 2 steps
-            agent2.agentParameters.onDemandDecision = true;
+            var decisionRequester = agent1.gameObject.AddComponent<DecisionRequester>();
+            decisionRequester.DecisionPeriod = 2;
-            agentEnableMethod?.Invoke(agent2, new object[] { aca });
-            academyInitializeMethod?.Invoke(aca, new object[] { });
+            agentEnableMethod?.Invoke(agent2, new object[] { });
 
             var numberAgent1Reset = 0;
             var numberAgent2Reset = 0;
             for (var i = 0; i < 5000; i++)
             {
                 Assert.AreEqual(acaStepsSinceReset, aca.GetStepCount());
-                Assert.AreEqual(1, aca.initializeAcademyCalls);
-                Assert.AreEqual(i, aca.AcademyStepCalls);
+                Assert.AreEqual(i, aca.GetTotalStepCount());
 
                 Assert.AreEqual(agent2StepSinceReset, agent2.GetStepCount());
                 Assert.AreEqual(numberAgent1Reset, agent1.agentResetCalls);
                 //Agent 1 is only initialized at step 2
                 if (i == 2)
                 {
-                    agentEnableMethod?.Invoke(agent1, new object[] { aca });
+                    agentEnableMethod?.Invoke(agent1, new object[] { });
                 }
                 // Set agent 1 to done every 11 steps to test behavior
                 if (i % 11 == 5)
                     // Request an action without decision regularly
                     agent2.RequestAction();
                 }
-                if (agent1.IsDone() && (((acaStepsSinceReset) % agent1.agentParameters.numberOfActionsBetweenDecisions == 0)))
+                if (agent1.IsDone())
                 {
                     numberAgent1Reset += 1;
                 }
                 //Agent 1 is only initialized at step 2
                 if (i < 2)
                 { }
-                academyStepMethod?.Invoke(aca, new object[] { });
+                aca.EnvironmentStep();
+    [TestFixture]
-        [Test]
-        public void TestResetOnDone()
-        {
-            var agentGo1 = new GameObject("TestAgent");
-            agentGo1.AddComponent<TestAgent>();
-            var agent1 = agentGo1.GetComponent<TestAgent>();
-            var agentGo2 = new GameObject("TestAgent");
-            agentGo2.AddComponent<TestAgent>();
-            var agent2 = agentGo2.GetComponent<TestAgent>();
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
-
-            var agentEnableMethod = typeof(Agent).GetMethod(
-                "OnEnableHelper", BindingFlags.Instance | BindingFlags.NonPublic);
-            var academyInitializeMethod = typeof(Academy).GetMethod(
-                "InitializeEnvironment", BindingFlags.Instance | BindingFlags.NonPublic);
-
-            var academyStepMethod = typeof(Academy).GetMethod(
-                "EnvironmentStep", BindingFlags.Instance | BindingFlags.NonPublic);
-
-            agent1.agentParameters = new AgentParameters();
-            agent2.agentParameters = new AgentParameters();
-            // We use event based so the agent will now try to send anything to the brain
-            agent1.agentParameters.onDemandDecision = false;
-            // agent1 will take an action at every step and request a decision every steps
-            agent1.agentParameters.numberOfActionsBetweenDecisions = 1;
-            // agent2 will request decisions only when RequestDecision is called
-            agent2.agentParameters.onDemandDecision = true;
-            agent1.agentParameters.maxStep = 20;
-            //Here we specify that the agent does not reset when done
-            agent1.agentParameters.resetOnDone = false;
-            agent2.agentParameters.resetOnDone = false;
-
-            agentEnableMethod?.Invoke(agent2, new object[] { aca });
-            academyInitializeMethod?.Invoke(aca, new object[] { });
-            agentEnableMethod?.Invoke(agent1, new object[] { aca });
-
-            var agent1ResetOnDone = 0;
-            var agent2ResetOnDone = 0;
-            var agent1StepSinceReset = 0;
-            var agent2StepSinceReset = 0;
-
-            for (var i = 0; i < 50; i++)
+        [SetUp]
+        public void SetUp()
+        {
+            if (Academy.IsInitialized)
-                Assert.AreEqual(i, aca.AcademyStepCalls);
-
-                Assert.AreEqual(agent1StepSinceReset, agent1.GetStepCount());
-                Assert.AreEqual(agent2StepSinceReset, agent2.GetStepCount());
-                Assert.AreEqual(agent1ResetOnDone, agent1.agentOnDoneCalls);
-                Assert.AreEqual(agent2ResetOnDone, agent2.agentOnDoneCalls);
-
-                // we request a decision at each step
-                agent2.RequestDecision();
-                if (agent1ResetOnDone == 0)
-                    agent1StepSinceReset += 1;
-                if (agent2ResetOnDone == 0)
-                    agent2StepSinceReset += 1;
-
-                if ((i > 2) && (i % 21 == 0))
-                {
-                    agent1ResetOnDone = 1;
-                }
-
-                if (i == 31)
-                {
-                    agent2ResetOnDone = 1;
-                    agent2.Done();
-                }
-
-
-                academyStepMethod?.Invoke(aca, new object[] { });
+                Academy.Instance.Dispose();
             }
         }
 
             var agentGo2 = new GameObject("TestAgent");
             agentGo2.AddComponent<TestAgent>();
             var agent2 = agentGo2.GetComponent<TestAgent>();
-            var acaGo = new GameObject("TestAcademy");
-            acaGo.AddComponent<TestAcademy>();
-            var aca = acaGo.GetComponent<TestAcademy>();
-
+            var aca = Academy.Instance;
-            var academyInitializeMethod = typeof(Academy).GetMethod(
-                "InitializeEnvironment", BindingFlags.Instance | BindingFlags.NonPublic);
-
-            var academyStepMethod = typeof(Academy).GetMethod(
-                "EnvironmentStep", BindingFlags.Instance | BindingFlags.NonPublic);
-
-            // We use event based so the agent will now try to send anything to the brain
-            agent1.agentParameters.onDemandDecision = false;
-            agent1.agentParameters.numberOfActionsBetweenDecisions = 3;
-            // agent1 will take an action at every step and request a decision every 2 steps
-            agent2.agentParameters.onDemandDecision = true;
-            // agent2 will request decisions only when RequestDecision is called
+
+            var decisionRequester = agent1.gameObject.AddComponent<DecisionRequester>();
+            decisionRequester.DecisionPeriod = 2;
+            decisionRequester.Awake();
+
-            agentEnableMethod?.Invoke(agent2, new object[] { aca });
-            academyInitializeMethod?.Invoke(aca, new object[] { });
-            agentEnableMethod?.Invoke(agent1, new object[] { aca });
+            agentEnableMethod?.Invoke(agent2, new object[] { });
+            agentEnableMethod?.Invoke(agent1, new object[] { });
 
 
             var j = 0;
                 Assert.LessOrEqual(Mathf.Abs(i * 0.1f - agent2.GetCumulativeReward()), 0.05f);
 
 
-                academyStepMethod?.Invoke(aca, new object[] { });
+                aca.EnvironmentStep();
                 agent1.AddReward(10f);
 
                 if ((i % 21 == 0) && (i > 0))

UnitySDK/Assets/ML-Agents/Editor/Tests/Sensor/StackingSensorTests.cs

             ISensor wrapped = new VectorSensor(4);
             ISensor sensor = new StackingSensor(wrapped, 4);
             Assert.AreEqual("StackingSensor_size4_VectorSensor_size4", sensor.GetName());
-            Assert.AreEqual(sensor.GetFloatObservationShape(), new [] {16});
+            Assert.AreEqual(sensor.GetObservationShape(), new [] {16});
         }
 
         [Test]

UnitySDK/Assets/ML-Agents/Editor/Tests/Sensor/VectorSensorTests.cs

             Assert.AreEqual(fill, output[0]);
 
             WriteAdapter writer = new WriteAdapter();
-            writer.SetTarget(output, 0);
+            writer.SetTarget(output, sensor.GetObservationShape(), 0);
 
             // Make sure WriteAdapter didn't touch anything
             Assert.AreEqual(fill, output[0]);

UnitySDK/Assets/ML-Agents/Editor/Tests/Sensor/WriterAdapterTests.cs

         {
             WriteAdapter writer = new WriteAdapter();
             var buffer = new[] { 0f, 0f, 0f };
+            var shape = new[] { 3 };
-            writer.SetTarget(buffer, 0);
+            writer.SetTarget(buffer, shape, 0);
             // Elementwise writes
             writer[0] = 1f;
             writer[2] = 2f;
-            writer.SetTarget(buffer, 1);
+            writer.SetTarget(buffer, shape, 1);
-            writer.SetTarget(buffer, 0);
+            writer.SetTarget(buffer, shape, 0);
-            writer.SetTarget(buffer, 1);
+            writer.SetTarget(buffer, shape, 1);
             writer.AddRange(new [] {6f, 7f});
             Assert.AreEqual(new[] { 4f, 6f, 7f }, buffer);
         }
                 valueType = TensorProxy.TensorType.FloatingPoint,
                 data = new Tensor(2, 3)
             };
+
             writer.SetTarget(t, 0, 0);
             Assert.AreEqual(0f, t.data[0, 0]);
             writer[0] = 1f;

UnitySDK/Assets/ML-Agents/Editor/Tests/StandaloneBuildTest.cs

 using System;
 using UnityEditor;
 using UnityEngine;
-#if UNITY_2018_1_OR_NEWER
-#endif
 
 namespace MLAgents
 {
         {
             string[] scenes = { "Assets/ML-Agents/Examples/3DBall/Scenes/3DBall.unity" };
             var buildResult = BuildPipeline.BuildPlayer(scenes, "testPlayer", BuildTarget.StandaloneOSX, BuildOptions.None);
-#if UNITY_2018_1_OR_NEWER
             var isOk = buildResult.summary.result == BuildResult.Succeeded;
             var error = "";
             foreach (var stepInfo in buildResult.steps)
                     }
                 }
             }
-#else
-            var error = buildResult;
-            var isOk = string.IsNullOrEmpty(error);
-#endif
             if (isOk)
             {
                 EditorApplication.Exit(0);

UnitySDK/Assets/ML-Agents/Examples/3DBall/Prefabs/3DBall.prefab

 %YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
---- !u!1001 &100100000
-Prefab:
-  m_ObjectHideFlags: 1
-  serializedVersion: 2
-  m_Modification:
-    m_TransformParent: {fileID: 0}
-    m_Modifications: []
-    m_RemovedComponents: []
-  m_ParentPrefab: {fileID: 0}
-  m_RootGameObject: {fileID: 1321468028730240}
-  m_IsPrefabParent: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
   m_Component:
   - component: {fileID: 4259352808153402}
   - component: {fileID: 33399516572863624}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
+--- !u!4 &4259352808153402
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1036225416237908}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 4.31, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 4679453577574622}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!33 &33399516572863624
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1036225416237908}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!135 &135693586603893602
+SphereCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1036225416237908}
+  m_Material: {fileID: 13400000, guid: 56162663048874fd4b10e065f9cf78b7, type: 2}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Radius: 0.5
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &23610325484096200
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1036225416237908}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: cf2a3769e6d5446698f2e3f5aab68915, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!54 &54597526346971362
+Rigidbody:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1036225416237908}
+  serializedVersion: 2
+  m_Mass: 1
+  m_Drag: 0
+  m_AngularDrag: 0.01
+  m_UseGravity: 1
+  m_IsKinematic: 0
+  m_Interpolate: 0
+  m_Constraints: 0
+  m_CollisionDetection: 0
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
   m_Component:
   - component: {fileID: 4082575947564308}
   - component: {fileID: 33986757750372936}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
+--- !u!4 &4082575947564308
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1218265376493012}
+  m_LocalRotation: {x: -0, y: 1, z: -0, w: 0}
+  m_LocalPosition: {x: 0.29999995, y: 0.07399994, z: 0.50040054}
+  m_LocalScale: {x: 0.29457998, y: 0.29457998, z: 0.29457998}
+  m_Children: []
+  m_Father: {fileID: 4294419716796784}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 180, z: 0}
+--- !u!33 &33986757750372936
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1218265376493012}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &23248495933290848
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1218265376493012}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: f731be6866ce749fd8349e67ae81f76a, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
   m_Component:
   - component: {fileID: 4679453577574622}
   m_Layer: 0
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 1
+--- !u!4 &4679453577574622
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1321468028730240}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 5}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 4259352808153402}
+  - {fileID: 4780098186595842}
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  - component: {fileID: 1306725529891448089}
   m_Layer: 0
   m_Name: Agent
   m_TagString: Untagged
   m_IsActive: 1
+--- !u!4 &4780098186595842
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1424713891854676}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 5, y: 5, z: 5}
+  m_Children:
+  - {fileID: 4294419716796784}
+  m_Father: {fileID: 4679453577574622}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!65 &65010516625723872
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1424713891854676}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!114 &114368073295828880
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1424713891854676}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5d1c4e0b1822b495aa52bc52839ecb30, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_BrainParameters:
+    vectorObservationSize: 8
+    numStackedVectorObservations: 1
+    vectorActionSize: 02000000
+    vectorActionDescriptions: []
+    vectorActionSpaceType: 1
+  m_Model: {fileID: 11400000, guid: 20a7b83be6b0c493d9271c65c897eb9b, type: 3}
+  m_InferenceDevice: 0
+  m_BehaviorType: 0
+  m_BehaviorName: 3DBall
+  m_TeamID: 0
+  m_useChildSensors: 1
+--- !u!114 &114715123104194396
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1424713891854676}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: aaba48bf82bee4751aa7b89569e57f73, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  agentParameters:
+    maxStep: 5000
+    onDemandDecision: 0
+    numberOfActionsBetweenDecisions: 5
+  ball: {fileID: 1036225416237908}
+--- !u!114 &1306725529891448089
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1424713891854676}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 3a5c9d521e5ef4759a8246a07d52221e, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  DecisionPeriod: 5
+  RepeatAction: 1
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
   m_Component:
   - component: {fileID: 4667923401885968}
   - component: {fileID: 20793118999710892}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
   m_IsActive: 0
---- !u!1 &1619100162539582
-GameObject:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 4425897039098228}
-  - component: {fileID: 33259119028337980}
-  - component: {fileID: 23108868206887546}
-  m_Layer: 0
-  m_Name: mouth
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!1 &1854695166504686
-GameObject:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 4300192163442926}
-  - component: {fileID: 33165976320323760}
-  - component: {fileID: 23468552506669568}
-  m_Layer: 0
-  m_Name: Headband
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!1 &1859240399150782
-GameObject:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 4294419716796784}
-  - component: {fileID: 33973749152356522}
-  - component: {fileID: 23340305563606254}
-  m_Layer: 0
-  m_Name: AgentCube_Blue
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!1 &1999020414315134
-GameObject:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 4144856465265480}
-  - component: {fileID: 33069174244444078}
-  - component: {fileID: 23048386147321498}
-  m_Layer: 0
-  m_Name: eye
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &4082575947564308
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1218265376493012}
-  m_LocalRotation: {x: -0, y: 1, z: -0, w: 0}
-  m_LocalPosition: {x: 0.29999995, y: 0.07399994, z: 0.50040054}
-  m_LocalScale: {x: 0.29457998, y: 0.29457998, z: 0.29457998}
-  m_Children: []
-  m_Father: {fileID: 4294419716796784}
-  m_RootOrder: 1
-  m_LocalEulerAnglesHint: {x: 0, y: 180, z: 0}
---- !u!4 &4144856465265480
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1999020414315134}
-  m_LocalRotation: {x: -0, y: 1, z: -0, w: 0}
-  m_LocalPosition: {x: -0.29999995, y: 0.07399994, z: 0.50040054}
-  m_LocalScale: {x: 0.29457998, y: 0.29457998, z: 0.29457998}
-  m_Children: []
-  m_Father: {fileID: 4294419716796784}
-  m_RootOrder: 2
-  m_LocalEulerAnglesHint: {x: 0, y: 180, z: 0}
---- !u!4 &4259352808153402
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1036225416237908}
-  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: 0, y: 4.31, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 4679453577574622}
-  m_RootOrder: 0
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!4 &4294419716796784
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1859240399150782}
-  m_LocalRotation: {x: 0, y: 1, z: 0, w: 0}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children:
-  - {fileID: 4667923401885968}
-  - {fileID: 4082575947564308}
-  - {fileID: 4144856465265480}
-  - {fileID: 4425897039098228}
-  - {fileID: 4300192163442926}
-  m_Father: {fileID: 4780098186595842}
-  m_RootOrder: 0
-  m_LocalEulerAnglesHint: {x: 0, y: 180, z: 0}
---- !u!4 &4300192163442926
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1854695166504686}
-  m_LocalRotation: {x: -0, y: -0, z: 0.016506119, w: 0.9998638}
-  m_LocalPosition: {x: 0, y: 0.341, z: 0}
-  m_LocalScale: {x: 1.0441425, y: 0.19278127, z: 1.0441422}
-  m_Children: []
-  m_Father: {fileID: 4294419716796784}
-  m_RootOrder: 4
-  m_LocalEulerAnglesHint: {x: 0, y: -179.99998, z: 1.8920001}
---- !u!4 &4425897039098228
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1619100162539582}
-  m_LocalRotation: {x: -0, y: 1, z: -0, w: 0}
-  m_LocalPosition: {x: 0, y: -0.18299997, z: 0.50040054}
-  m_LocalScale: {x: 0.27602, y: 0.042489994, z: 0.13891}
-  m_Children: []
-  m_Father: {fileID: 4294419716796784}
-  m_RootOrder: 3
-  m_LocalEulerAnglesHint: {x: 0, y: 180, z: 0}
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
   m_GameObject: {fileID: 1533320402322554}
   m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: 0.15}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!4 &4679453577574622
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1321468028730240}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 5}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children:
-  - {fileID: 4259352808153402}
-  - {fileID: 4780098186595842}
-  m_Father: {fileID: 0}
-  m_RootOrder: 0
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!4 &4780098186595842
-Transform:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1424713891854676}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 5, y: 5, z: 5}
-  m_Children:
-  - {fileID: 4294419716796784}
-  m_Father: {fileID: 4679453577574622}
-  m_RootOrder: 1
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_projectionMatrixMode: 1
+  m_SensorSize: {x: 36, y: 24}
+  m_LensShift: {x: 0, y: 0}
+  m_GateFitMode: 2
+  m_FocalLength: 50
   m_NormalizedViewPortRect:
     serializedVersion: 2
     x: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
---- !u!23 &23048386147321498
-MeshRenderer:
-  m_ObjectHideFlags: 1
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 100100000}
-  m_GameObject: {fileID: 1999020414315134}
-  m_Enabled: 1
-  m_CastShadows: 1
-  m_ReceiveShadows: 1
-  m_DynamicOccludee: 1
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_Materials:
-  - {fileID: 2100000, guid: f731be6866ce749fd8349e67ae81f76a, type: 2}
-  m_StaticBatchInfo: