// the perception is created and generated here public Percept(SimulationState state, int agentID, bool inProlog = true) { //SimulationEngineComponentScript.ss.stdout.Send("entro al constructor de Percept"); if (inProlog){ auxList = new List<string>(); auxList.Add("time("+SimulationState.getInstance().gameTime+")"); if (state.agents.ContainsKey(agentID)) { state.agents[agentID].agentController.perceive(this); foreach(IPerceivableEntity e in elements){ aux = e.toProlog(); auxList.Add(aux); } //auxList.Add(state.agents[agentID].agentController.selfProperties()); p = PrologList.AtomList<string>(auxList); } else { Debug.LogError("Percept creation fail."); } } else{ // xml throw new NotImplementedException(); } }
public string Serialize(SimulationState state) { States.Add(state); var average = state.Individuals.Select(a => a.Fitness).Average(); return string.Format("{{ \"average_fitness\": {0}, \"processing_time\": {1} }}", average, state.ProcessingTime); }
static void Start() { quit = false; ss = new SimulationState("config.xml"); se = new SimulationEngine(ss); Console.WriteLine("Press press any key to stop the simulation engine."); Console.WriteLine("Note: there is no ANY key on your keyboard."); se.start(); }
public override void Start() { base.Start(); this._type = "inn"; this.ss = (GameObject.FindGameObjectWithTag("GameController"). GetComponent(typeof(SimulationEngineComponentScript)) as SimulationEngineComponentScript).engine as SimulationState; this.ss.addInn(this); forbiddenEntry = new Dictionary<Agent, Interval>(); }
public GameLoop(int idleTimer) { playBehaviour = new PlayBehaviour(); deathBehaviour = new DeathBehaviour(); this.idleTimer = idleTimer; this.defaultIdleTimer = idleTimer; InputQueue = new Queue<Command>(); simulationState = SimulationState.Idling; }
public override void Start() { SimulationState.getInstance().stdout.Send("entro Start"); base.Start(); this._type = "home"; this.ss = (GameObject.FindGameObjectWithTag("GameController"). GetComponent(typeof(SimulationEngineComponentScript)) as SimulationEngineComponentScript).engine as SimulationState; this.ss.addHome(this); gameObject.renderer.material.color = color; texture = Agent.MakeTex(2, 2, color); }
public ConnectionHandler(SimulationState ss) { // NETWORK & OPERATION tcpListener = new TcpListener(IPAddress.Parse("127.0.0.1"), 8888); connectionHandlerThread = new Thread(new ThreadStart(this.run)); connectionHandlerThread.IsBackground = true; // SIMULATION quit = false; simulationState = ss; agentConnections = new List<AgentConnection>(); instantiationResults = new MailBox<bool>(false); }
public AgentConnection(SimulationState ss, TcpClient tcpc) { // NETWORK & OPERATION tcpClient = tcpc; networkStream = tcpc.GetStream(); streamReader = new StreamReader(networkStream); streamWriter = new StreamWriter(networkStream); agentConnectionThread = new Thread(new ThreadStart(this.run)); agentConnectionThread.IsBackground = true; // SIMULATION quit = false; simulationState = ss; }
// Use this for initialization void Awake() { ss = new SimulationState("C:\\config.xml", goldPrefab, potionPrefab); SimulationState.getInstance().stdout.Send("entro Awake Sim Engine"); se = new SimulationEngine(ss); //ss.initialize(); InvokeRepeating( "DoWork", 0, 0.1f ); // Instantiate dummy agent for testing purposes /* se.instantiateDummyAgent("dummy1", agentPrefab); AgentState dummy1AgState = se.simulationState.agents[se.simulationState.agentIDs["dummy1"]]; dummy1AgState.agentController.pickupPosCon(Gold.Create(new Vector3(0,0,0))); dummy1AgState.agentController.pickupPosCon(Gold.Create(new Vector3(0,0,0))); dummy1AgState.agentController.pickupPosCon(Potion.Create(new Vector3(0,0,0))); dummy1AgState.agentController.pickupPosCon(Potion.Create(new Vector3(0,0,0))); dummy1AgState.agentController.pickupPosCon(Potion.Create(new Vector3(0,0,0))); //se.instantiateDummyAgent("dummy2", agentPrefab); */ se.start(); }
public void CreatingState(ref SimulationState simulationState) { }
/// <summary> /// Writes a new state to the stream. /// </summary> /// <param name="state">New state</param> public void Write(SimulationState state) { serializer.Write(BlockType.FrameStart); int[] keys; #region Framestart // The first call creates the frame if (frame == null) { // Create new frame frame = new Frame(state); serializer.Write(BlockType.Frame, frame); } else { // Send frame-update FrameUpdate update = frame.GenerateUpdate(state); if (update != null) { serializer.Write(BlockType.FrameUpdate, update); } } #endregion #region Teams and ColonyStates #region ant-reset // reset alive-flag foreach (Ant ant in antList.Values) { ant.IsAlive = false; } #endregion #region marker-reset // reset alive-flag foreach (Marker marker in markerList.Values) { marker.IsAlive = false; } #endregion // Teams are static and need no update // enumerate all teams foreach (TeamState teamState in state.TeamStates) { // Check, if team is known if (teamList.ContainsKey(teamState.Id)) { // No Teamupdate needed } else { Team team = new Team(teamState); serializer.Write(BlockType.Team, team); teamList.Add(teamState.Id, team); } // ColonyStates are static and need no update // enumerate all colonies foreach (ColonyState colonyState in teamState.ColonyStates) { // Check, if colony is known if (colonyList.ContainsKey(colonyState.Id)) { // colony-update ColonyUpdate update = colonyList[colonyState.Id].GenerateUpdate(colonyState); if (update != null) { serializer.Write(BlockType.ColonyUpdate, update); } colonyList[colonyState.Id].Interpolate(); } else { // new colony Colony colony = new Colony(colonyState, teamState.Id); serializer.Write(BlockType.Colony, colony); colonyList.Add(colonyState.Id, colony); casteList.Add(colonyState.Id, new Dictionary <int, Caste>()); #region Castes // Casts are static and need no update Dictionary <int, Caste> castes = casteList[colonyState.Id]; // enumerate casts for (ushort i = 0; i < colonyState.CasteStates.Count; i++) { // Check, if caste is known if (!castes.ContainsKey(i)) { // add caste Caste caste = new Caste(colonyState.CasteStates[i]); serializer.Write(BlockType.Caste, caste); } } #endregion #region Anthills // Anthills are static and need no update // enumerate anthills foreach (AnthillState anthill in colonyState.AnthillStates) { if (!anthillList.ContainsKey(anthill.Id)) { Anthill hill = new Anthill(anthill); serializer.Write(BlockType.Anthill, hill); anthillList.Add(anthill.Id, hill); } } #endregion } #region Ants // enumerate ants foreach (AntState antState in colonyState.AntStates) { // Check, if ant is known if (antList.ContainsKey(antState.Id)) { // ant-update AntUpdate update = antList[antState.Id].GenerateUpdate(antState); if (update != null) { serializer.Write(BlockType.AntUpdate, update); } antList[antState.Id].Interpolate(); } else { // create ant Ant ant = new Ant(antState); serializer.Write(BlockType.Ant, ant); antList.Add(ant.Id, ant); } antList[antState.Id].IsAlive = true; } #endregion #region Marker // enumerate marker foreach (MarkerState markerState in colonyState.MarkerStates) { // Check, if marker is known if (markerList.ContainsKey(markerState.Id)) { // marker-update MarkerUpdate update = markerList[markerState.Id].GenerateUpdate(markerState); if (update != null) { serializer.Write(BlockType.MarkerUpdate, update); } markerList[markerState.Id].Interpolate(); } else { // create marker Marker marker = new Marker(markerState); serializer.Write(BlockType.Marker, marker); markerList.Add(markerState.Id, marker); } markerList[markerState.Id].IsAlive = true; } #endregion } } #region Ant-Cleanup // remove dead ants keys = new int[antList.Keys.Count]; antList.Keys.CopyTo(keys, 0); for (int i = 0; i < keys.Length; i++) { if (!antList[keys[i]].IsAlive) { serializer.Write(BlockType.AntLost, new Lost(keys[i])); antList.Remove(keys[i]); } } #endregion #region Marker-Cleanup // remove dead marker keys = new int[markerList.Keys.Count]; markerList.Keys.CopyTo(keys, 0); for (int i = 0; i < keys.Length; i++) { if (!markerList[keys[i]].IsAlive) { serializer.Write(BlockType.MarkerLost, new Lost(keys[i])); markerList.Remove(keys[i]); } } #endregion #endregion #region Fruit // reset alive-flag foreach (Fruit fruit in fruitList.Values) { fruit.IsAlive = false; } // enumerate fruit foreach (FruitState fruitState in state.FruitStates) { // Check, if fruit is known if (fruitList.ContainsKey(fruitState.Id)) { // fruit-update FruitUpdate update = fruitList[fruitState.Id].GenerateUpdate(fruitState); if (update != null) { serializer.Write(BlockType.FruitUpdate, update); } fruitList[fruitState.Id].Interpolate(); } else { // create fruit Fruit fruit = new Fruit(fruitState); serializer.Write(BlockType.Fruit, fruit); fruitList.Add(fruitState.Id, fruit); } fruitList[fruitState.Id].IsAlive = true; } // remove dead fruits keys = new int[fruitList.Keys.Count]; fruitList.Keys.CopyTo(keys, 0); for (int i = 0; i < keys.Length; i++) { if (!fruitList[keys[i]].IsAlive) { serializer.Write(BlockType.FruitLost, new Lost(keys[i])); fruitList.Remove(keys[i]); } } #endregion #region Sugar // reset alive-flag foreach (Sugar sugar in sugarList.Values) { sugar.IsAlive = false; } // enumerate sugar foreach (SugarState sugarState in state.SugarStates) { // Check, if sugar is known if (sugarList.ContainsKey(sugarState.Id)) { // sugar-update SugarUpdate update = sugarList[sugarState.Id].GenerateUpdate(sugarState); if (update != null) { serializer.Write(BlockType.SugarUpdate, update); } sugarList[sugarState.Id].Interpolate(); } else { // create sugar Sugar sugar = new Sugar(sugarState); serializer.Write(BlockType.Sugar, sugar); sugarList.Add(sugarState.Id, sugar); } sugarList[sugarState.Id].IsAlive = true; } // remove dead sugar keys = new int[sugarList.Keys.Count]; sugarList.Keys.CopyTo(keys, 0); for (int i = 0; i < keys.Length; i++) { if (!sugarList[keys[i]].IsAlive) { serializer.Write(BlockType.SugarLost, new Lost(keys[i])); sugarList.Remove(keys[i]); } } #endregion #region Bugs // reset alive-flag foreach (Bug bug in bugList.Values) { bug.IsAlive = false; } // enumerate bugs foreach (BugState bugState in state.BugStates) { // Check, if bug is known if (bugList.ContainsKey(bugState.Id)) { // bug-update BugUpdate update = bugList[bugState.Id].GenerateUpdate(bugState); if (update != null) { serializer.Write(BlockType.BugUpdate, update); } bugList[bugState.Id].Interpolate(); } else { // create bug Bug bug = new Bug(bugState); serializer.Write(BlockType.Bug, bug); bugList.Add(bugState.Id, bug); } bugList[bugState.Id].IsAlive = true; } // remove dead bugs keys = new int[bugList.Keys.Count]; bugList.Keys.CopyTo(keys, 0); for (int i = 0; i < keys.Length; i++) { if (!bugList[keys[i]].IsAlive) { serializer.Write(BlockType.BugLost, new Lost(keys[i])); bugList.Remove(keys[i]); } } #endregion serializer.Write(BlockType.FrameEnd); }
private void callback_OnSimulationChanged(SimulationState state, byte framerate) { // Server State changed from running to stopped if (_serverState != SimulationState.Stopped && state == SimulationState.Stopped) { // Trash Deserializer if (_deserializer != null) { _deserializer.Dispose(); _deserializer = null; } // Remove last State _currentState = null; } //// Server State changed from stopped to running //if (_serverState == SimulationState.Stopped && state != SimulationState.Stopped) //{ // if (_deserializer == null) // { // _deserializer = new StateDeserializer(); // } //} // Set local Properties _serverState = state; _rate = framerate; // Drop Event if (OnSimulationChanged != null) OnSimulationChanged(this, state, framerate); }
/// <summary> /// Reads a new simulation-state out of stream. /// </summary> /// <returns>New simulation-state or null, if stream is over</returns> public SimulationState Read() { // if stream is at his end, return null if (complete) { return(null); } // first block have to be a frame-start ISerializable block; BlockType blockType = serializer.Read(out block); // detect stream-end if (blockType == BlockType.StreamEnd) { complete = true; return(null); } // unexpected block-type if (blockType != BlockType.FrameStart) { throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, Resource.AntvideoReaderInvalidBlockType, blockType)); } // block-loop while (blockType != BlockType.FrameEnd) { blockType = serializer.Read(out block); switch (blockType) { case BlockType.Ant: Ant ant = (Ant)block; antList.Add(ant.Id, ant); break; case BlockType.Anthill: Anthill anthill = (Anthill)block; anthillList.Add(anthill.Id, anthill); break; case BlockType.AntLost: Lost antLost = (Lost)block; antList.Remove(antLost.Id); break; case BlockType.AntUpdate: AntUpdate antUpdate = (AntUpdate)block; antList[antUpdate.Id].Update(antUpdate); break; case BlockType.Bug: Bug bug = (Bug)block; bugList.Add(bug.Id, bug); break; case BlockType.BugLost: Lost bugLost = (Lost)block; bugList.Remove(bugLost.Id); break; case BlockType.BugUpdate: BugUpdate bugUpdate = (BugUpdate)block; bugList[bugUpdate.Id].Update(bugUpdate); break; case BlockType.Caste: Caste caste = (Caste)block; casteList[caste.ColonyId].Add(caste.Id, caste); break; case BlockType.Team: Team team = (Team)block; teamList.Add(team.Id, team); colonyList.Add(team.Id, new Dictionary <int, Colony>()); break; case BlockType.Colony: Colony colony = (Colony)block; colonyList[colony.TeamId].Add(colony.Id, colony); casteList.Add(colony.Id, new Dictionary <int, Caste>()); break; case BlockType.ColonyUpdate: ColonyUpdate colonyUpdate = (ColonyUpdate)block; colonyList[colonyUpdate.TeamId][colonyUpdate.Id].Update(colonyUpdate); break; case BlockType.Frame: frame = (Frame)block; break; case BlockType.FrameUpdate: FrameUpdate frameUpdate = (FrameUpdate)block; frame.Update(frameUpdate); break; case BlockType.Fruit: Fruit fruit = (Fruit)block; fruitList.Add(fruit.Id, fruit); break; case BlockType.FruitLost: Lost fruitLost = (Lost)block; fruitList.Remove(fruitLost.Id); break; case BlockType.FruitUpdate: FruitUpdate fruitUpdate = (FruitUpdate)block; fruitList[fruitUpdate.Id].Update(fruitUpdate); break; case BlockType.Marker: Marker marker = (Marker)block; markerList.Add(marker.Id, marker); break; case BlockType.MarkerLost: Lost markerLost = (Lost)block; markerList.Remove(markerLost.Id); break; case BlockType.MarkerUpdate: MarkerUpdate markerUpdate = (MarkerUpdate)block; markerList[markerUpdate.Id].Update(markerUpdate); break; case BlockType.Sugar: Sugar sugar = (Sugar)block; sugarList.Add(sugar.Id, sugar); break; case BlockType.SugarLost: Lost sugarLost = (Lost)block; sugarList.Remove(sugarLost.Id); break; case BlockType.SugarUpdate: SugarUpdate sugarUpdate = (SugarUpdate)block; sugarList[sugarUpdate.Id].Update(sugarUpdate); break; } } // Detect streamend if ((BlockType)serializer.Peek() == BlockType.StreamEnd) { complete = true; } // Interpolate all elements and buildup state frame.Interpolate(); SimulationState state = frame.GenerateState(); foreach (Bug bug in bugList.Values) { bug.Interpolate(); state.BugStates.Add(bug.GenerateState()); } foreach (Fruit fruit in fruitList.Values) { fruit.Interpolate(); state.FruitStates.Add(fruit.GenerateState()); } foreach (Sugar sugar in sugarList.Values) { sugar.Interpolate(); state.SugarStates.Add(sugar.GenerateState()); } foreach (Team team in teamList.Values) { TeamState teamState = team.GenerateState(); state.TeamStates.Add(teamState); foreach (Colony colony in colonyList[team.Id].Values) { colony.Interpolate(); ColonyState colonyState = colony.GenerateState(); teamState.ColonyStates.Add(colonyState); foreach (Caste caste in casteList[colony.Id].Values) { colonyState.CasteStates.Add(caste.GenerateState()); } foreach (Anthill anthill in anthillList.Values) { if (anthill.ColonyId == colony.Id) { colonyState.AnthillStates.Add(anthill.GenerateState()); } } foreach (Ant ant in antList.Values) { if (ant.ColonyId == colony.Id) { ant.Interpolate(); colonyState.AntStates.Add(ant.GenerateState()); } } foreach (Marker marker in markerList.Values) { if (marker.ColonyId == colony.Id) { marker.Interpolate(); colonyState.MarkerStates.Add(marker.GenerateState()); } } } } // deliver return(state); }
/// <summary> /// Called at the end of every attempt. /// </summary> private void EndAttempt() { // Stop the ball. _ball.Stop(_world); // Don't load a new ball if the player ran out of balls. if (_attemptsLeft > 0) { _launcher.LoadBall(Ball); } else { _currentState = SimulationState.Failed; Console.WriteLine("You lose!"); // Do anything that needs to be done when the level is failed. if (OnFailure != null) { OnFailure(); } } }
//UI thread /// <summary> /// Starts simulation for specified number of steps. /// </summary> /// <param name="stepCount">How many steps of simulation shall be performed (0 means unlimited).</param> public void StartSimulation(uint stepCount) { bool doFixedNumberOfSteps = (stepCount > 0); if (State == SimulationState.STOPPED) { MyLog.INFO.WriteLine("Scheduling..."); Simulation.Schedule(Project); MyLog.INFO.WriteLine("Initializing tasks..."); Simulation.Init(); MyLog.INFO.WriteLine("Allocating memory..."); Simulation.AllocateMemory(); PrintMemoryInfo(); MyLog.INFO.WriteLine("Starting simulation..."); } else { MyLog.INFO.WriteLine("Resuming simulation..."); } State = doFixedNumberOfSteps ? SimulationState.RUNNING_STEP : SimulationState.RUNNING; m_stepsToPerform = stepCount; m_lastProgressChangedStep = 0; // Clean up breakpoints. Simulation.CleanTemporaryBlockData(); MyKernelFactory.Instance.SetCurrent(MyKernelFactory.Instance.DevCount - 1); m_workedCompleted.Reset(); m_worker.RunWorkerAsync(); }
/// <summary> /// Updates UI /// </summary> /// <param name="state">current state of simulation</param> public void UpdateUI(SimulationState state) { }
public SessionSendSimulationStatePacket(SimulationState simulationState, ulong playerUID) { SimulationState = simulationState; PlayerUID = playerUID; }
public void Or(string input, string regex, SimulationState expectedResult) { SimulationState result = RegexEngine.Simulate(regex, input); Assert.AreEqual(expectedResult, result); }
/// <summary> /// Just run the sim /// </summary> public void RunSimulation() { // running this.SimulationState = SimulationState.Running; // notify SimulatorOutput.WriteLine("Simulation Started"); // start thread Thread d = new Thread(Simulate); d.Priority = ThreadPriority.AboveNormal; d.IsBackground = true; d.Start(); // state this.simulationMain.SimulationModeLabel.Text = "Simulation Running"; this.simulationMain.SimulationModeLabel.Image = global::Simulator.Properties.Resources.Light_Bulb_On_16_n_p; }
/// <summary> /// End simulation /// </summary> public void EndSimulation() { // stop sim this.SimulationState = SimulationState.Stopped; // notify SimulatorOutput.WriteLine("Simulation Stopped"); // state this.simulationMain.SimulationModeLabel.Text = "Simulation Stopped"; this.simulationMain.SimulationModeLabel.Image = global::Simulator.Properties.Resources.Light_Bulb_Off_16_n_p; }
//UI thread void m_worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { if (e.Cancelled && !doPause) { DoStop(); } else { MyLog.INFO.WriteLine("Paused."); State = SimulationState.PAUSED; Project.World.DoPause(); } }
private void DoStop() { MyLog.INFO.WriteLine("Cleaning up world..."); Project.World.Cleanup(); MyLog.INFO.WriteLine("Freeing memory..."); Simulation.FreeMemory(); PrintMemoryInfo(); MyKernelFactory.Instance.RecoverContexts(); MyLog.INFO.WriteLine("Clearing simulation..."); Simulation.Clear(); MyLog.INFO.WriteLine("Stopped after "+this.SimulationStep+" steps."); State = SimulationState.STOPPED; }
public override void Start() { SimulationState.getInstance().stdout.Send("entro Start"); base.Start(); this._type = "grave"; this.ss = (GameObject.FindGameObjectWithTag("GameController"). GetComponent(typeof(SimulationEngineComponentScript)) as SimulationEngineComponentScript).engine as SimulationState; this.ss.addGrave(this); initializeContent(); }
/// <summary> /// Restarts the simulation phase. /// </summary> public void Restart() { // Reset the number of attempts, the various statistics, and lets the user provide input again. _attemptsLeft = _startingAttempts; _elapsedTime = 0f; _collectedTreasures = 0; _bounces = 0; _currentState = SimulationState.Active; // Restore all breakable platforms and treasures. foreach (Platform platform in _platforms) { platform.Reset(); } foreach (Platform platform in _moveablePlatforms) { platform.Reset(); } foreach (Treasure treasure in _treasures) { treasure.Reset(); } // If the ball happens to be moving, stop it and put it back into // the launcher. if (!_launcher.Movable) { _ball.Stop(_world); _launcher.LoadBall(Ball); } }
void SimulationStateChangedHandler(object sender, SimulationState newState) { CheckSimulationState(); }
/// <summary> /// Executes one single step in simulation and returns hostState. /// </summary> /// <returns>Summery of the executed simulationStep</returns> public SimulatorHostState Step(ref SimulationState simulationState) { if (environment == null) { throw new InvalidOperationException(Resource.SimulationCoreHostEnvironmentNotInit); } // Reset of times stepWatch.Reset(); foreach (TeamInfo team in configuration.Teams) { foreach (PlayerInfo spieler in team.Player) { playerTimes[spieler.Guid] = 0; } } // Init Step-Thread exception = null; lastSimulationState = simulationState; Thread stepThread = new Thread(step); stepWatch.Start(); stepThread.Start(); if (configuration.IgnoreTimeouts) { // Wait without any timeout stepThread.Join(); } else { // Wait for thread with timeout if (!stepThread.Join(configuration.RoundTimeout)) { throw new TimeoutException(Resource.SimulationCoreHostRoundTimeout); } } stepWatch.Stop(); // Bei Exceptions null zurück liefern, um Fehler zu signalisieren if (exception != null) { return(null); } // Add player-times lastHostState.ElapsedRoundTime = stepWatch.ElapsedTicks; for (int i = 0; i < configuration.Teams.Count; i++) { for (int j = 0; j < configuration.Teams[i].Player.Count; j++) { Guid guid = configuration.Teams[i].Player[j].Guid; if (!lastHostState.ElapsedPlayerTimes.ContainsKey(guid)) { lastHostState.ElapsedPlayerTimes.Add(guid, playerTimes[guid]); } } } // deliver host-state return(lastHostState); }
private void OnFinishedSimulation(GameStateManager gameStateManager, IGameTime gameTime) { this.simulationState = SimulationState.Idling; gameStateManager.CreateTimestamp(gameTime.TotalGameTime.TotalMilliseconds); EventArgs e = new EventArgs(); if(FinishedSimulation != null) { FinishedSimulation(this, e); } }
public StateEventArgs(SimulationState oldState, SimulationState newState) { OldState = oldState; NewState = newState; }
// NOT UI thread void m_worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { if (ProgressChanged != null && m_lastProgressChangedStep != SimulationStep) { ProgressChanged(this, null); } if (e.Cancelled && !doPause) { DoStop(); } else { // This means we're either pausing, or this was a single simulation step. MyLog.INFO.WriteLine("Paused."); State = SimulationState.PAUSED; } m_workedCompleted.Set(); }
private static IEnumerable <bool> AddPatch(VesselState startingState) { if (null == Trajectories.AttachedVessel.patchedConicSolver) { Util.LogWarning("patchedConicsSolver is null, Skipping."); yield break; } CelestialBody body = startingState.ReferenceBody; Patch patch = new Patch { StartingState = startingState, IsAtmospheric = false, SpaceOrbit = startingState.StockPatch ?? CreateOrbitFromState(startingState) }; patch.EndTime = patch.StartingState.Time + patch.SpaceOrbit.period; // the flight plan does not always contain the first patches (before the first maneuver node), // so we populate it with the current orbit and associated encounters etc. List <Orbit> flightPlan = new List <Orbit>(); for (Orbit orbit = Trajectories.AttachedVessel.orbit; orbit != null && orbit.activePatch; orbit = orbit.nextPatch) { if (Trajectories.AttachedVessel.patchedConicSolver.flightPlan.Contains(orbit)) { break; } flightPlan.Add(orbit); } foreach (Orbit orbit in Trajectories.AttachedVessel.patchedConicSolver.flightPlan) { flightPlan.Add(orbit); } Orbit nextPatch = null; if (startingState.StockPatch == null) { nextPatch = patch.SpaceOrbit.nextPatch; } else { int planIdx = flightPlan.IndexOf(startingState.StockPatch); if (planIdx >= 0 && planIdx < flightPlan.Count - 1) { nextPatch = flightPlan[planIdx + 1]; } } if (nextPatch != null) { patch.EndTime = nextPatch.StartUT; } double maxAtmosphereAltitude = RealMaxAtmosphereAltitude(body); if (!body.atmosphere) { maxAtmosphereAltitude = body.pqsController.mapMaxHeight; } double minAltitude = patch.SpaceOrbit.PeA; if (patch.SpaceOrbit.timeToPe < 0 || patch.EndTime < startingState.Time + patch.SpaceOrbit.timeToPe) { minAltitude = Math.Min( patch.SpaceOrbit.getRelativePositionAtUT(patch.EndTime).magnitude, patch.SpaceOrbit.getRelativePositionAtUT(patch.StartingState.Time + 1.0).magnitude ) - body.Radius; } if (minAltitude < maxAtmosphereAltitude) { double entryTime; if (startingState.Position.magnitude <= body.Radius + maxAtmosphereAltitude) { // whole orbit is inside the atmosphere entryTime = startingState.Time; } else { entryTime = FindOrbitBodyIntersection( patch.SpaceOrbit, startingState.Time, startingState.Time + patch.SpaceOrbit.timeToPe, body.Radius + maxAtmosphereAltitude); } if (entryTime > startingState.Time + 0.1 || !body.atmosphere) { if (body.atmosphere) { // add the space patch before atmospheric entry patch.EndTime = entryTime; patchesBackBuffer_.Add(patch); AddPatch_outState = new VesselState { Position = Util.SwapYZ(patch.SpaceOrbit.getRelativePositionAtUT(entryTime)), ReferenceBody = body, Time = entryTime, Velocity = Util.SwapYZ(patch.SpaceOrbit.getOrbitalVelocityAtUT(entryTime)) }; yield break; } else { // the body has no atmosphere, so what we actually computed is the entry // inside the "ground sphere" (defined by the maximal ground altitude) // now we iterate until the inner ground sphere (minimal altitude), and // check if we hit the ground along the way double groundRangeExit = FindOrbitBodyIntersection( patch.SpaceOrbit, startingState.Time, startingState.Time + patch.SpaceOrbit.timeToPe, body.Radius - maxAtmosphereAltitude); if (groundRangeExit <= entryTime) { groundRangeExit = startingState.Time + patch.SpaceOrbit.timeToPe; } double iterationSize = (groundRangeExit - entryTime) / 100.0; double t; bool groundImpact = false; for (t = entryTime; t < groundRangeExit; t += iterationSize) { Vector3d pos = patch.SpaceOrbit.getRelativePositionAtUT(t); double groundAltitude = GetGroundAltitude(body, CalculateRotatedPosition(body, Util.SwapYZ(pos), t)) + body.Radius; if (pos.magnitude < groundAltitude) { t -= iterationSize; groundImpact = true; break; } } if (groundImpact) { patch.EndTime = t; patch.RawImpactPosition = Util.SwapYZ(patch.SpaceOrbit.getRelativePositionAtUT(t)); patch.ImpactPosition = CalculateRotatedPosition(body, patch.RawImpactPosition.Value, t); patch.ImpactVelocity = Util.SwapYZ(patch.SpaceOrbit.getOrbitalVelocityAtUT(t)); patchesBackBuffer_.Add(patch); AddPatch_outState = null; yield break; } else { // no impact, just add the space orbit patchesBackBuffer_.Add(patch); if (nextPatch != null) { AddPatch_outState = new VesselState { Position = Util.SwapYZ(patch.SpaceOrbit.getRelativePositionAtUT(patch.EndTime)), Velocity = Util.SwapYZ(patch.SpaceOrbit.getOrbitalVelocityAtUT(patch.EndTime)), ReferenceBody = nextPatch == null ? body : nextPatch.referenceBody, Time = patch.EndTime, StockPatch = nextPatch }; yield break; } else { AddPatch_outState = null; yield break; } } } } else { if (patch.StartingState.ReferenceBody != Trajectories.AttachedVessel.mainBody) { // currently, we can't handle predictions for another body, so we stop AddPatch_outState = null; yield break; } // simulate atmospheric flight (drag and lift), until impact or atmosphere exit // (typically for an aerobraking maneuver) assuming a constant angle of attack patch.IsAtmospheric = true; patch.StartingState.StockPatch = null; // lower dt would be more accurate, but a trade-off has to be found between performances and accuracy double dt = Settings.IntegrationStepSize; // some shallow entries can result in very long flight. For performances reasons, // we limit the prediction duration int maxIterations = (int)(60.0 * 60.0 / dt); int chunkSize = 128; // time between two consecutive stored positions (more intermediate positions are computed for better accuracy), // also used for ground collision checks double trajectoryInterval = 10.0; List <Point[]> buffer = new List <Point[]> { new Point[chunkSize] }; int nextPosIdx = 0; SimulationState state; state.position = Util.SwapYZ(patch.SpaceOrbit.getRelativePositionAtUT(entryTime)); state.velocity = Util.SwapYZ(patch.SpaceOrbit.getOrbitalVelocityAtUT(entryTime)); // Initialize a patch with zero acceleration Vector3d currentAccel = new Vector3d(0.0, 0.0, 0.0); double currentTime = entryTime; double lastPositionStoredUT = 0; Vector3d lastPositionStored = new Vector3d(); bool hitGround = false; int iteration = 0; int incrementIterations = 0; int minIterationsPerIncrement = maxIterations / Settings.MaxFramesPerPatch; #region Acceleration Functor // function that calculates the acceleration under current parameters Func <Vector3d, Vector3d, Vector3d> accelerationFunc = (position, velocity) => { Profiler.Start("accelerationFunc inside"); // gravity acceleration double R_ = position.magnitude; Vector3d accel_g = position * (-body.gravParameter / (R_ * R_ * R_)); // aero force Vector3d vel_air = velocity - body.getRFrmVel(body.position + position); double aoa = DescentProfile.GetAngleOfAttack(body, position, vel_air) ?? 0d; Profiler.Start("GetForces"); Vector3d force_aero = aerodynamicModel_.GetForces(body, position, vel_air, aoa); Profiler.Stop("GetForces"); Vector3d accel = accel_g + force_aero / aerodynamicModel_.Mass; Profiler.Stop("accelerationFunc inside"); return(accel); }; #endregion #region Integration Loop while (true) { ++iteration; ++incrementIterations; if (incrementIterations > minIterationsPerIncrement && incrementTime_.ElapsedMilliseconds > MaxIncrementTime) { yield return(false); incrementIterations = 0; } double R = state.position.magnitude; double altitude = R - body.Radius; double atmosphereCoeff = altitude / maxAtmosphereAltitude; if (hitGround || atmosphereCoeff <= 0.0 || atmosphereCoeff >= 1.0 || iteration == maxIterations || currentTime > patch.EndTime) { //Util.PostSingleScreenMessage("atmo force", "Atmospheric accumulated force: " + accumulatedForces.ToString("0.00")); if (hitGround || atmosphereCoeff <= 0.0) { patch.RawImpactPosition = state.position; patch.ImpactPosition = CalculateRotatedPosition(body, patch.RawImpactPosition.Value, currentTime); patch.ImpactVelocity = state.velocity; } patch.EndTime = Math.Min(currentTime, patch.EndTime); int totalCount = (buffer.Count - 1) * chunkSize + nextPosIdx; patch.AtmosphericTrajectory = new Point[totalCount]; int outIdx = 0; foreach (Point[] chunk in buffer) { foreach (Point p in chunk) { if (outIdx == totalCount) { break; } patch.AtmosphericTrajectory[outIdx++] = p; } } if (iteration == maxIterations) { ScreenMessages.PostScreenMessage("WARNING: trajectory prediction stopped, too many iterations"); patchesBackBuffer_.Add(patch); AddPatch_outState = null; yield break; } else if (atmosphereCoeff <= 0.0 || hitGround) { patchesBackBuffer_.Add(patch); AddPatch_outState = null; yield break; } else { patchesBackBuffer_.Add(patch); AddPatch_outState = new VesselState { Position = state.position, Velocity = state.velocity, ReferenceBody = body, Time = patch.EndTime }; yield break; } } Vector3d lastAccel = currentAccel; SimulationState lastState = state; Profiler.Start("IntegrationStep"); // Verlet integration (more precise than using the velocity) // state = VerletStep(state, accelerationFunc, dt); state = RK4Step(state, accelerationFunc, dt, out currentAccel); currentTime += dt; // KSP presumably uses Euler integration for position updates. Since RK4 is actually more precise than that, // we try to reintroduce an approximation of the error. // The local truncation error for euler integration is: // LTE = 1/2 * h^2 * y''(t) // https://en.wikipedia.org/wiki/Euler_method#Local_truncation_error // // For us, // h is the time step of the outer simulation (KSP), which is the physics time step // y''(t) is the difference of the velocity/acceleration divided by the physics time step state.position += 0.5 * TimeWarp.fixedDeltaTime * currentAccel * dt; state.velocity += 0.5 * TimeWarp.fixedDeltaTime * (currentAccel - lastAccel); Profiler.Stop("IntegrationStep"); // calculate gravity and aerodynamic force Vector3d gravityAccel = lastState.position * (-body.gravParameter / (R * R * R)); Vector3d aerodynamicForce = (currentAccel - gravityAccel) / aerodynamicModel_.Mass; // acceleration in the vessel reference frame is acceleration - gravityAccel maxAccelBackBuffer_ = Math.Max( (float)(aerodynamicForce.magnitude / aerodynamicModel_.Mass), maxAccelBackBuffer_); #region Impact Calculation Profiler.Start("AddPatch#impact"); double interval = altitude < 10000.0 ? trajectoryInterval * 0.1 : trajectoryInterval; if (currentTime >= lastPositionStoredUT + interval) { double groundAltitude = GetGroundAltitude(body, CalculateRotatedPosition(body, state.position, currentTime)); if (lastPositionStoredUT > 0) { // check terrain collision, to detect impact on mountains etc. Vector3 rayOrigin = lastPositionStored; Vector3 rayEnd = state.position; double absGroundAltitude = groundAltitude + body.Radius; if (absGroundAltitude > rayEnd.magnitude) { hitGround = true; float coeff = Math.Max(0.01f, (float)((absGroundAltitude - rayOrigin.magnitude) / (rayEnd.magnitude - rayOrigin.magnitude))); state.position = rayEnd * coeff + rayOrigin * (1.0f - coeff); currentTime = currentTime * coeff + lastPositionStoredUT * (1.0f - coeff); } } lastPositionStoredUT = currentTime; if (nextPosIdx == chunkSize) { buffer.Add(new Point[chunkSize]); nextPosIdx = 0; } Vector3d nextPos = state.position; if (Settings.BodyFixedMode) { nextPos = CalculateRotatedPosition(body, nextPos, currentTime); } buffer.Last()[nextPosIdx].aerodynamicForce = aerodynamicForce; buffer.Last()[nextPosIdx].orbitalVelocity = state.velocity; buffer.Last()[nextPosIdx].groundAltitude = (float)groundAltitude; buffer.Last()[nextPosIdx].time = currentTime; buffer.Last()[nextPosIdx++].pos = nextPos; lastPositionStored = state.position; } Profiler.Stop("AddPatch#impact"); #endregion } #endregion } } else { // no atmospheric entry, just add the space orbit patchesBackBuffer_.Add(patch); if (nextPatch != null) { AddPatch_outState = new VesselState { Position = Util.SwapYZ(patch.SpaceOrbit.getRelativePositionAtUT(patch.EndTime)), Velocity = Util.SwapYZ(patch.SpaceOrbit.getOrbitalVelocityAtUT(patch.EndTime)), ReferenceBody = nextPatch == null ? body : nextPatch.referenceBody, Time = patch.EndTime, StockPatch = nextPatch }; yield break; } else { AddPatch_outState = null; yield break; } } }
/// <summary> /// Create new game scene based on given simulation state /// </summary> public GameScene(SceneStack sceneStack, InputManager inputManager, ResourceManager resourceManager, SimulationState state) : base(sceneStack, inputManager, resourceManager) { this.Initialize(state); }
public void OnFrame(Bot bot) { List <Unit> simulatedUnits = new List <Unit>(); foreach (Task task in bot.TaskManager.Tasks) { task.AddCombatSimulationUnits(simulatedUnits); } foreach (Unit unit in bot.EnemyManager.LastSeen.Values) { if (unit.UnitType == UnitTypes.SIEGE_TANK_SIEGED || unit.UnitType == UnitTypes.WIDOW_MINE_BURROWED) { continue; } if (bot.EnemyManager.LastSeen.ContainsKey(unit.Tag) && bot.Frame - bot.EnemyManager.LastSeenFrame[unit.Tag] > 112) { continue; } if (UnitTypes.CombatUnitTypes.Contains(unit.UnitType)) { simulatedUnits.Add(unit); } } foreach (UnitLocation unit in bot.EnemyMineManager.Mines) { if (bot.EnemyManager.LastSeen.ContainsKey(unit.Tag)) { simulatedUnits.Add(bot.EnemyManager.LastSeen[unit.Tag]); } } foreach (UnitLocation unit in bot.EnemyTankManager.Tanks) { if (bot.EnemyManager.LastSeen.ContainsKey(unit.Tag)) { simulatedUnits.Add(bot.EnemyManager.LastSeen[unit.Tag]); } } List <List <Unit> > simulationGroups = GroupUnits(simulatedUnits); HashSet <uint> myUpgrades = new HashSet <uint>(); if (bot.Observation.Observation.RawData.Player.UpgradeIds != null) { foreach (uint upgrade in bot.Observation.Observation.RawData.Player.UpgradeIds) { myUpgrades.Add(upgrade); } } HashSet <uint> enemyUpgrades = new HashSet <uint>(); bool logSimulation = bot.Frame % 22 == 0 && simulationGroups.Count > 0 && Debug; if (ShowStats) { bot.DrawText("Simulations: " + simulationGroups.Count); } if (logSimulation) { FileUtil.Debug("Simulations: " + simulationGroups.Count); } bool printState = false; if (Bot.Debug && bot.Observation.Chat != null && bot.Observation.Chat.Count > 0) { foreach (ChatReceived message in bot.Observation.Chat) { if (message.Message == "s") { printState = true; break; } } } MyStartResources = 0; MyFinalResources = 0; EnemyStartResources = 0; EnemyFinalResources = 0; int i = 0; foreach (List <Unit> simulationGroup in simulationGroups) { SimulationState state = GetState(bot, simulationGroup, myUpgrades, enemyUpgrades, false); if (printState) { state.SafeToFile("SimulationState-" + bot.Frame + "-" + i + ".txt"); } float myResources = GetResources(state, true); float enemyResources = GetResources(state, false); if (printState) { TestCombatSim.TestCombat(state, SimulationLength); } else { state.Simulate(SimulationLength); } float myNewResources = GetResources(state, true); float enemyNewResources = GetResources(state, false); if (ShowStats) { bot.DrawText("SimulationResult me: " + myResources + " -> " + myNewResources + " his: " + enemyResources + " -> " + enemyNewResources); } if (logSimulation) { FileUtil.Debug("SimulationResult me: " + myResources + " -> " + myNewResources + " his: " + enemyResources + " -> " + enemyNewResources); } if (myResources > 0 && enemyResources > 0) { MyStartResources += myResources; MyFinalResources += myNewResources; EnemyStartResources += enemyResources; EnemyFinalResources += enemyNewResources; } MakeDecision(simulationGroup, state, myResources, myNewResources, enemyResources, enemyNewResources, myUpgrades, enemyUpgrades); i++; } if (logSimulation) { FileUtil.Debug(""); } }
public void MakeMove(SimulationState state) { _children[state.PlayerPosition[state.ActivePlayer]].MakeMove(state); }
private void MakeDecision(List <Unit> simulationGroup, SimulationState state, float myResources, float myNewResources, float enemyResources, float enemyNewResources, HashSet <uint> myUpgrades, HashSet <uint> enemyUpgrades) { if (myResources == 0) { return; } if (enemyResources == 0) { ApplyDecision(simulationGroup, CombatSimulationDecision.None); return; } int prevProceed = 0; int prevFallBack = 0; foreach (Unit unit in simulationGroup) { if (Bot.Main.UnitManager.Agents.ContainsKey(unit.Tag) && Bot.Main.Frame - Bot.Main.UnitManager.Agents[unit.Tag].CombatSimulationDecisionFrame < 10) { if (Bot.Main.UnitManager.Agents[unit.Tag].CombatSimulationDecision == CombatSimulationDecision.Proceed) { prevProceed++; } else if (Bot.Main.UnitManager.Agents[unit.Tag].CombatSimulationDecision == CombatSimulationDecision.FallBack) { prevFallBack++; } } } float partProceed; if (prevFallBack + prevProceed == 0) { partProceed = 0; } else { partProceed = (float)prevProceed / (prevProceed + prevFallBack); } if (ShowStats) { Bot.Main.DrawText("Proceed: " + partProceed); } if (enemyResources - enemyNewResources >= (myResources - myNewResources) * (1.1 - 0.3 * partProceed)) { ApplyDecision(simulationGroup, CombatSimulationDecision.Proceed); } else { SimulationState fleeState = GetState(Bot.Main, simulationGroup, myUpgrades, enemyUpgrades, true); state.Simulate(100); float myFleeResources = GetResources(fleeState, true); if (enemyResources - enemyNewResources >= (myFleeResources - myNewResources) * (1.1 - 0.3 * partProceed)) { ApplyDecision(simulationGroup, CombatSimulationDecision.Proceed); } else { ApplyDecision(simulationGroup, CombatSimulationDecision.FallBack); } } }
/// <summary> /// Call for user-interface-updates. /// </summary> /// <param name="state">current state</param> public void UpdateUI(SimulationState state) { renderForm.SimulationState = state; }
public GameState GetCurrentState() { this.SimState = SimulationState.PAUSED; ulong[] loopsDone = new ulong[regionManagers.Length]; List <EntityOnMap <HealthyEntity> >[] populationHealthy = new List <EntityOnMap <HealthyEntity> > [regionManagers.Length]; List <EntityOnMap <SickEntity> >[] populationSick = new List <EntityOnMap <SickEntity> > [regionManagers.Length]; pipelines.ForEach(x => x.updateTimeScale(timeScale)); for (int i = 0; i < regionManagers.Length; ++i) { regionManagers[i].SimState = SimulationState.PAUSED; } // Asynchronously extract the current state from each running task Task[] waitingData = new Task[regionManagers.Length]; for (int i = 0; i < regionManagers.Length; ++i) { int procIndex = i; waitingData[procIndex] = new Task(() => { var item = regionManagers[procIndex].getEntities(); populationSick[procIndex] = item.Item1; populationHealthy[procIndex] = item.Item2; loopsDone[procIndex] = item.Item3; }); waitingData[procIndex].Start(); } Task.WaitAll(waitingData); outOfBoundsLock.WaitOne(); var populationHealthyList = populationHealthy .Aggregate( new List <EntityOnMap <HealthyEntity> >(), (current, next) => { current.AddRange(next); return(current); } ) .Concat(outOfBoundsPopulationHealthy) .ToList(); var populationSickList = populationSick .Aggregate( new List <EntityOnMap <SickEntity> >(), (current, next) => { current.AddRange(next); return(current); } ) .Concat(outOfBoundsPopulationSick) .ToList(); outOfBoundsLock.ReleaseMutex(); this.SimState = SimulationState.RUNNING; for (int i = 0; i < regionManagers.Length; ++i) { regionManagers[i].SimState = SimulationState.RUNNING; } var sickPeople = (ushort)populationSickList.Count(); var healthyPeople = (ushort)populationHealthyList.Count(); return(new GameState { loopsDone = loopsDone, items = (populationSickList, populationHealthyList), sickPeople = sickPeople, healthyPeople = healthyPeople, });
/// <summary> /// Completes the level. /// </summary> private void Complete() { // Stop the ball and don't accept any more input for the simulation. _currentState = SimulationState.Completed; _ball.Stop(_world); // Do anything that needs to be done when the level is completed. if (OnCompletion != null) { OnCompletion(CreateScoreData()); } }
public override void act(SimulationState state) { MovementVetorX = 0; MovementVetorY = 0; if (State == VehicleState.NoIntersection) { spawnFromEdgeWithNoIntersectionToNewEdge(state.intersections.SelectMany(ip => ip.intersectionPipes).ToList(), state.edgePipes); rotateTexture(); } else if (NextEdge != null && State == VehicleState.OnIntersection) { moveToNewConnectors(); rotateTexture(); return; } var restEdges = state.edgePipes .Where(e => e.ID == CurrentEdge.PipeID) .FirstOrDefault().Edges .Where(e => e.ID != CurrentEdge.ID); foreach (var vehicle in state.vehicles) { if (State == VehicleState.InIntersectionQueue || State == VehicleState.NoIntersection || !restEdges.Where(re => re.PipeID == vehicle.CurrentEdge.PipeID).Any()) { continue; } setCloserPositionToOutrunNewPosition(); bool isOnIntersection = isVehicleOnIntersection(); CurrentConnectorY = CurrentEdge.To.Y; CurrentConnectorX = CurrentEdge.To.X; if (isOnIntersection) { OldVelocity = Velocity; Velocity = 0; bool noIntersection = !state.intersections .Any(ip => ip.intersectionPipes .Any(p => p.EdgeRoad.ID == CurrentEdge.ID && p.IntersectionType == IntersectionPipeType.In)); if (noIntersection) { State = VehicleState.NoIntersection; } else { CurrentIntersectionID = state.intersections.SingleOrDefault(ip => ip.intersectionPipes.Any(p => p.EdgeRoad.ID == CurrentEdge.ID && p.IntersectionType == IntersectionPipeType.In)).ID; State = VehicleState.InIntersectionQueue; } continue; } if (vehicle.ID == ID) { continue; } if (vehicle.CurrentEdge.ID == CurrentEdge.ID && isVehicleInFront(vehicle) && isVehicleNCarWidthInFrontAtLeast(2, vehicle)) { Velocity = vehicle.Velocity; if (restEdges.Count() == 0) { continue; } EdgeRoad closestEdge = null; setClosestEdgeRoad(ref closestEdge, restEdges); if (isNextLaneFreeForOutrun(closestEdge, state.vehicles)) { setNewPositionForOutrun(ref closestEdge); CurrentEdge = closestEdge; Velocity += 1; } } } prepareMovementVector(); Position.X += MovementVetorX; Position.Y += MovementVetorY; }
public void UpdateUI(SimulationState state) { window.Update(state); }
public virtual void OnFrame(SimulationState state, CombatUnit unit) { }
/// <summary> /// Load settings from SimulationState. /// </summary> /// <param name="state">TState to load from.</param> public void LoadSettings(SimulationState state) { Paused = state.Paused; BackgroundColour = state.BackgroundColour; Projectile.GravitationalAcceleration = state.Gravity; }
/// <summary> /// Setzt eine pausierte Simulation wieder fort. /// </summary> public void ResumeSimulation() { // Nur reagieren, falls der Pause-Mode aktiv ist if (state != SimulationState.Paused) return; // state melden und setzen state = SimulationState.Running; if (OnSimulationState != null) OnSimulationChanged(this, state, rate); }
/// <summary> /// Calculates the next step and deliver through parameter. /// </summary> /// <param name="simulationState">empty <see cref="SimulationState"/></param> public void Step(ref SimulationState simulationState) { lastSimulationState = simulationState; switch (state) { case SimulatorState.Ready: case SimulatorState.Simulating: // Create proxy if (proxy == null) { proxy = new SimulatorProxy(); proxy.Init(configuration); currentLoop++; currentRound = 0; loopTime = 0; for (int i = 0; i < configuration.Teams.Count; i++) { for (int j = 0; j < configuration.Teams[i].Player.Count; j++) { totalPlayerTime[configuration.Teams[i].Player[j]] = 0; } } state = SimulatorState.Simulating; } // Calculate step currentRound++; lastHostState = proxy.Step(ref lastSimulationState); simulationState = lastSimulationState; // Calculate times roundTime = lastHostState.ElapsedRoundTime; loopTime += lastHostState.ElapsedRoundTime; totalTime += lastHostState.ElapsedRoundTime; for (int i = 0; i < configuration.Teams.Count; i++) { for (int j = 0; j < configuration.Teams[i].Player.Count; j++) { // TODO: Fix Dictionary-Problem with time-list PlayerInfo info = configuration.Teams[i].Player[j]; //totalPlayerTime[info] += lastHostState.ElapsedPlayerTimes[info]; } } // After one loop, unload appdomain if (currentRound >= configuration.RoundCount) { proxy.Unload(); proxy = null; GC.Collect(); } // Mark Simulator as finished after all loops if (currentRound >= configuration.RoundCount && currentLoop >= configuration.LoopCount) { state = SimulatorState.Finished; } break; case SimulatorState.Finished: // Throw exception, if step was called on a finished simulator throw new InvalidOperationException( Resource.SimulationCoreSimulatorRestartFailed); } lastSimulationState = null; }
/// <summary> /// Stoppt eine laufende Anwendung. /// </summary> public void StopSimulation() { // Nicht reagieren, falls ohnehin eine Simulation läuft. if (state == SimulationState.Stopped) return; // State ändern und kurz auf den Thread warten. state = SimulationState.Stopped; if (thread.Join(2000)) thread.Abort(); if (OnSimulationChanged != null) OnSimulationChanged(this, state, rate); }
public double[] Simulate(double t, double[] values) { SimulationState st = new SimulationState { VX = values[3], VY = values[4], VZ = values[5], Phi = values[6], Theta = values[7], PhiDot = values[8], ThetaDot = values[9], GammaDot = values[10], Gamma = values[11], }; //double CLo, CLa, CDo, CDa, CMo, CMa; //double CL_data, CD_data, CM_data; double[] CRr_rad = new[] { -0.0873, -0.0698, -0.0524, -0.0349, -0.0175, 0.0000, 0.0175, 0.0349, 0.0524, 0.0698, 0.0873, 0.1047, 0.1222, 0.1396, 0.1571, 0.1745, 0.1920, 0.2094, 0.2269, 0.2443, 0.2618, 0.5236 }; double[] CRr_AdvR = new[] { 2, 1.04, 0.69, 0.35, 0.17, 0 }; double[,] CRr_data = new [, ] { { -0.0172, -0.0192, -0.018, -0.0192, -0.018, -0.0172, -0.0172, -0.0168, -0.0188, -0.0164, -0.0136, -0.01, -0.0104, -0.0108, -0.0084, -0.008, -0.008, -0.006, -0.0048, -0.0064, -0.008, -0.003 }, { -0.0112, -0.0132, -0.012, -0.0132, -0.012, -0.0112, -0.0112, -0.0108, -0.0128, -0.0104, -0.0096, -0.0068, -0.0072, -0.0076, -0.0052, -0.0048, -0.0048, -0.0028, -0.0032, -0.0048, -0.0064, -0.003 }, { -0.0056, -0.0064, -0.0064, -0.0068, -0.0064, -0.0064, -0.0052, -0.0064, -0.0028, -0.0028, -0.004, -0.002, -0.004, -0.002, -0.0016, 0, 0, 0, 0, -0.002, -0.0048, -0.003 }, { -0.0012, -0.0016, -0.0004, -0.0028, -0.0016, -0.0016, -0.0004, 0.0004, 0.0004, 0.0008, 0.0004, 0.0008, 0.0012, 0.0008, 0.002, 0.0028, 0.0032, 0.0024, 0.0028, 0.0004, -0.0012, -0.003 }, { -0.0012, -0.0012, -0.0016, -0.0016, -0.0012, -0.0004, 0.0004, 0.0008, 0.0008, 0.0016, 0.0004, 0.002, 0.0004, 0.0016, 0.002, 0.002, 0.002, 0.0012, 0.0012, 0, -0.0012, -0.003 }, { -0.0012, -0.0012, -0.0004, -0.0008, -0.0008, -0.0008, 0.0004, 0.0004, 0.0004, 0.0008, 0.0004, 0.0008, -0.0004, 0, 0, 0.0004, 0, 0, 0.0004, -0.002, -0.0012, -0.003 } }; const double CMq = -0.005; const double CRp = -0.0055; const double CNr = 0.0000071; double diameter = 2 * Math.Sqrt(Area / Math.PI); // Rotation matrix: http://s-mat-pcs.oulu.fi/~mpa/matreng/eem1_3-7.htm // y // ------------------> x ^ // |\ | // | \ | // | \ | // | \ theta = pitch | gamma = yaw // | | // v --------------------> x // z // z // ^ // | // | // | // | phi = roll // | // ------------------> y // // 3D homogenous transformation matrix // // g = gamma = yaw // t = theta = pitch // p = phi = roll // // http://en.wikipedia.org/wiki/Rotation_matrix // http://www.gregslabaugh.name/publications/euler.pdf // -- -- // | cos(g)*cos(t), cos(g)*sin(t)*sin(p)-sin(g)*cos(p), cos(g)*sin(t)*cos(p)+sin(g)*sin(p) | // | | // T = | sin(g)*cos(t), sin(g)*sin(t)*sin(p)-cos(g)*cos(p), sin(g)*sin(t)*cos(p)+cos(g)*sin(p) | // | | // | -sin(t) , cos(t)*sin(p) , cos(t)*cos(p) | // -- -- // // With g = yaw = 0 and sin(t) = -sin(t) since z is positive downward // // -- -- // | cos(t) , sin(t)*sin(p) , sin(t)*cos(p) | // | | // T = | 0 , cos(p) , sin(p) | // | | // | -sin(t) , cos(t)*sin(p) , cos(t)*cos(p) | // -- -- Matrix <double> transformation = new SparseMatrix(new [, ] { { st.CosTheta, st.SinTheta * st.SinPhi, -st.SinTheta * st.CosPhi }, { 0, st.CosPhi, st.SinPhi }, { st.SinTheta, -st.CosTheta * st.SinPhi, st.CosTheta * st.CosPhi } }); // Eigenvector & eigenvalue // -- // | x1 // X = | x2 // | x3 // -- // // -- // | a11, a12, a13 // A = | a21, a22, a23 // | a31, a32, a33 // -- // // // Usually, the multiplication of a vector x by a square matrix A changes both the magnitude and the direction // of the vector upon which it acts; but in the special case where it changes only the scale (magnitude) of the // vector and leaves the direction unchanged, or switches the vector to the opposite direction, then that vector // is called an eigenvector of that matrix (the term "eigenvector" is meaningless except in relation to some // particular matrix). When multiplied by a matrix, each eigenvector of that matrix changes its magnitude by a // factor, called the eigenvalue corresponding to that eigenvector. // // // See local frame vs global frame: // Evd evd = new UserEvd(transformation); //Matrix<double> eigenVectors = evd.EigenVectors(); Vector <Complex> temp = evd.EigenValues(); Vector <double> eigenValues = new SparseVector(3); eigenValues[0] = temp[0].Real; eigenValues[1] = temp[1].Real; eigenValues[1] = temp[1].Real; //eigenValues.Norm // // If you have Theta and Phi = 0 you have a transformation matrix like this: // // | 1, 0, 0 | // | 0, 1, 0 | // | 0, 0, 1 | // // So each row represents the rotated X, Y or Z axis expressed as N-Frame coordinates. In this case, // there is no rotation so you have the axis (1,0,0), (0,1,0), (0,0,1). // For example, the first row represents the X Axis after the rotation. Since the rotation is 0, // the X axis is a vector (1,0,0) in the N-Frame. // // // // //SparseVector c1 = new SparseVector(transformation.Row(0)); //SparseVector c2 = new SparseVector(transformation.Row(1)); SparseVector c3 = new SparseVector(transformation.Row(2)); SparseVector velocity = new SparseVector(new [] { st.VX, st.VY, st.VZ }); double velocityMagnitude = velocity.Norm(2); double velocityC3 = velocity.DotProduct(c3); Vector <double> vp = velocity.Subtract(c3.Multiply(velocityC3)); double vpMagnitude = vp.Norm(2); double alpha = Math.Atan(velocityC3 / vp.Norm(2)); double adp = Area * Rho * velocityMagnitude * velocityMagnitude / 2; Vector <double> unitVelocity = velocity.Divide(velocityMagnitude); Vector <double> unitVp = vp.Divide(vpMagnitude); //c3. Vector <double> unitLat = ConvertVector(Vector3D.CrossProduct(ConvertVector(c3), ConvertVector(unitVp))); Matrix <double> omegaD_N_inC = new SparseMatrix(new [, ] { { st.PhiDot *st.CosTheta, st.ThetaDot, st.PhiDot *st.SinTheta + st.GammaDot } }); // expressed in c1,c2,c3 Vector <double> omegaD_N_inN = transformation.Transpose().Multiply(omegaD_N_inC.Transpose()).Column(0); // expressed in c1,c2,c3 double omegaVp = omegaD_N_inN.DotProduct(unitVp); double omegaLat = omegaD_N_inN.DotProduct(unitLat); double omegaSpin = omegaD_N_inN.DotProduct(c3); double aDvR = diameter * omegaSpin / 2 / vpMagnitude; LinearSplineInterpolation interpolation = new LinearSplineInterpolation(m_xCL, m_yCL); double CL = interpolation.Interpolate(alpha); interpolation = new LinearSplineInterpolation(m_xCD, m_yCD); double CD = interpolation.Interpolate(alpha); interpolation = new LinearSplineInterpolation(m_xCM, m_yCM); double CM = interpolation.Interpolate(alpha); alglib.spline2d.spline2dinterpolant interpolant = new alglib.spline2d.spline2dinterpolant(); alglib.spline2d.spline2dbuildbilinear(CRr_rad, CRr_AdvR, CRr_data, 6, 22, interpolant); double CRr = alglib.spline2d.spline2dcalc(interpolant, alpha, aDvR); Vector <double> mvp = unitVp.Multiply(adp * diameter * (CRr * diameter * omegaSpin / 2 / velocityMagnitude + CRp * omegaVp)); // Roll moment, expressed in N double lift = CL * adp; double drag = CD * adp; Vector <double> unitLift = -ConvertVector(Vector3D.CrossProduct(ConvertVector(unitVelocity), ConvertVector(unitLat))); Vector <double> unitDrag = -unitVelocity; Vector <double> forceAerodynamic = unitLift.Multiply(lift).Add(unitDrag.Multiply(drag)); Vector <double> gravityForceN = new SparseVector(new[] { 0, 0, m * g }); Vector <double> force = forceAerodynamic.Add(gravityForceN); Vector <double> mLat = unitLat.Multiply(adp * diameter * (CM + CMq * omegaLat)); Vector <double> mSpin = new SparseVector(new [] { 0, 0, CNr * omegaSpin }); // TODO: Check if missing element Vector <double> mvpInC = transformation.Multiply(mvp); Vector <double> mLatInC = transformation.Multiply(mLat); Vector <double> moment = mvpInC.Add(mLatInC).Add(mSpin); Vector <double> acceleration = force.Divide(m); double[] result = new double[12]; result[0] = velocity[0]; result[1] = velocity[1]; result[2] = velocity[2]; result[3] = acceleration[0]; result[4] = acceleration[1]; result[5] = acceleration[2]; result[6] = -st.PhiDot; result[7] = st.ThetaDot; result[8] = (moment[0] + Id * st.ThetaDot * st.PhiDot * st.SinTheta - Ia * st.ThetaDot * (st.PhiDot * st.SinTheta + st.GammaDot) + Id * st.ThetaDot * st.PhiDot * st.SinTheta) / Id / st.CosTheta; result[9] = (moment[1] + Ia * st.PhiDot * st.CosTheta * (st.PhiDot * st.SinTheta + st.GammaDot) - Id * st.PhiDot * st.PhiDot * st.CosTheta * st.SinTheta) / Id; result[10] = (moment[2] - Ia * (result[9] * st.SinTheta + st.ThetaDot * st.PhiDot * st.CosTheta)) / Ia; result[11] = result[10]; return(result); }
private void OnStartingSimulation() { this.simulationState = SimulationState.Simulating; EventArgs e = new EventArgs(); if(StartingSimulation != null) { StartingSimulation(this, e); } }
/// <summary> /// Останавливает симуляцию. /// </summary> public void Stop() { State = SimulationState.Stopped; ResetLevelTo(_initialLevel); }
private void PauseSimulation(object sender, EventArgs e) { _simulationState = SimulationState.Paused; _computing = false; EnableButtons(); }
public void CreatedState(ref SimulationState state) { }
//UI thread /// <summary> /// Starts simulation /// </summary> /// <param name="oneStepOnly">Only one step of simulation is performed when true</param> public void StartSimulation(bool oneStepOnly) { if (State == SimulationState.STOPPED) { MyLog.INFO.WriteLine("Scheduling..."); Simulation.Schedule(Project); MyLog.INFO.WriteLine("Initializing tasks..."); Simulation.Init(); MyLog.INFO.WriteLine("Allocating memory..."); Simulation.AllocateMemory(); PrintMemoryInfo(); MyLog.INFO.WriteLine("Starting simulation..."); } else { MyLog.INFO.WriteLine("Resuming simulation..."); } State = oneStepOnly ? SimulationState.RUNNING_STEP : SimulationState.RUNNING; MyKernelFactory.Instance.SetCurrent(MyKernelFactory.Instance.DevCount - 1); m_worker.RunWorkerAsync(); }
/// <summary> /// Pausiert eine laufende Anwendung oder tut nichts, falls gestoppt. /// </summary> public void PauseSimulation() { // Nicht reagieren, falls die Simulation nicht läuft. if (state == SimulationState.Running) { state = SimulationState.Paused; if (OnSimulationState != null) OnSimulationChanged(this, state, rate); } }
/// <summary> /// Constructor for the PreferencesEditor. /// </summary> /// <param name="preferences">The preferences for the Editor.</param> /// <param name="showSimulationProperties">Should the form show properties about the simulation.</param> /// <param name="simulationState">The state of the simulation.</param> public PreferencesEditor(EditorPreferences preferences, bool showSimulationProperties, SimulationState simulationState = default) { InitializeComponent(); Preferences = preferences; propertiesPanel.Visible = showSimulationProperties; if (showSimulationProperties) { propertyGrid.SelectedObject = simulationState; } }
/// <summary> /// Startet die Simulation, sofern alle Daten vollständig sind. /// </summary> /// <param name="result">Eventuelle Fehlermeldung</param> /// <returns>Erfolgsmeldung</returns> public bool StartSimulation() { // Im Falle des Pause-Modes wird einfach fortgesetzt if (state == SimulationState.Paused) { ResumeSimulation(); return true; } // Simulation läuft bereits if (state == SimulationState.Running) { return true; } // Prüfen, ob ein Level vorhanden ist if (level == null) { throw new Exception("There is not Level set"); } // Player zählen int count = 0; for (int i = 0; i < AntMe.Level.MAX_SLOTS; i++) { if (players[i] != null) { // Prüfen, ob player bereit ist if (!slots[i].ReadyState) { throw new Exception("Player " + (i + 1) + " is not ready"); } // Prüfen, ob Faction Filter aktiv ist var filter = level.FactionFilter.Where(f => f.SlotIndex == i); if (filter.Count() > 0) { if (filter.Where(f => f.Type.TypeName == players[i].FactionType).Count() == 0) { throw new Exception("Player " + i + " does not match the Faction filter"); } } count++; } } // prüfen, ob genügend Player vorhanden sind if (count < level.LevelDescription.MinPlayerCount) { throw new Exception("Not enougth player"); } if (count > level.LevelDescription.MaxPlayerCount) { throw new Exception("Too many player"); } // State ändern state = SimulationState.Running; if (OnSimulationChanged != null) OnSimulationChanged(this, state, rate); // Thread erzeugen thread = new Thread(SimulationLoop); thread.IsBackground = true; thread.Priority = ThreadPriority.Lowest; thread.Start(); return true; }
public void OnSimulationStateChanged(SimulationState simulationState) { SetInactiveMsgState(simulationState == SimulationState.Disabled); }
private void SimulationLoop() { try { InitSimulation(0, level, players, slots); } catch (Exception ex) { // Event werfen if (OnError != null) OnError(this, ex.Message); // Simulation stoppen StopSimulation(); } while (state != SimulationState.Stopped) { // Pausemodus skippen if (state == SimulationState.Paused || rate <= 0) { Thread.Sleep(1); continue; } // Messung starten watch.Restart(); // State erzeugen currentState = UpdateSimulation(); // Das EventLog füttern log.Update(currentState); if (currentState.Mode > LevelMode.Running) { state = SimulationState.Stopped; continue; } if (OnSimulationState != null) OnSimulationState(this, currentState); // Wartezeit zwischen Frames while (state != SimulationState.Stopped && watch.ElapsedMilliseconds < (int)(1000 / rate)) { Thread.Sleep(1); } } FinalizeSimulation(); }
private void CurrentClient_OnSimulationChanged(ISimulationClient client, SimulationState simulationState, byte frames) { framesToolButton.Text = string.Format("{0} fps", frames); // throw new NotImplementedException(); }
private void DoStop() { // TODO(HonzaS): This is hacky, it needs to be redone properly. // 1) Stop the simulation if needed. // 2) Set the state to STOPPED => notifies the nodes to clean up. // 3) Clear everything else if we're quitting. var stopping = false; if (State != SimulationState.STOPPED) { stopping = true; MyLog.INFO.WriteLine("Cleaning up world..."); Project.World.Cleanup(); MyLog.INFO.WriteLine("Freeing memory..."); Simulation.FreeMemory(); PrintMemoryInfo(); MyKernelFactory.Instance.RecoverContexts(); // This needs to be set before Clear is called so that nodes can be notified about the state change. State = SimulationState.STOPPED; } if (m_closeCallback != null) Simulation.Finish(); if (stopping) { MyLog.INFO.WriteLine("Clearing simulation..."); // This will destroy the collection that holds the nodes, so it has to be the last thing. Simulation.Clear(); MyLog.INFO.WriteLine("Stopped after "+this.SimulationStep+" steps."); if (SimulationStopped != null) { var args = new SimulationStoppedEventArgs { Exception = m_simulationStoppedException, StepCount = SimulationStep }; SimulationStopped(this, args); } } // Cleanup and invoke the callback action. if (m_closeCallback != null) m_closeCallback(); }
public abstract void MakeMove(SimulationState state);
/// <summary> /// Create new game scene based on given simulation state /// </summary> public GameScene(Scene parent, SimulationState state) : base(parent) { this.Initialize(state); }