Beispiel #1
0
 public void StartSimulating(ISimulatable obj)
 {
     if (!_objectsToSimulate.ContainsKey(obj.Id))
     {
         _objectsToSimulate.Add(obj.Id, obj);
         obj.IsLocalSim = true;
     }
 }
Beispiel #2
0
 public void AddNewContent(ISimulatable content)
 {
     if (content == null)
     {
         throw new ArgumentNullException();
     }
     components.Add(content);
 }
Beispiel #3
0
        public void StopSimulating(ISimulatable obj)
        {
            if (_objectsToSimulate.ContainsKey(obj.Id))
            {
                _objectsToSimulate.Remove(obj.Id);
            }

            obj.IsLocalSim = false;
        }
Beispiel #4
0
 /// <summary>
 /// Adds a concretion of ISimulatable to the repository of simulation models
 /// and adds the argument instance
 /// </summary>
 /// <param name="simulator">simulation model instance</param>
 /// <param name="args">The argument instance for the model</param>
 /// <returns>Gives the model back</returns>
 public override ISimulatable RegisterSimulator(ISimulatable simulator, ArgumentsBase args)
 {
     simulator.With(args);
     if (Simulators.Contains(simulator))
     {
         _log.Error($"The Simulation model '{simulator.Name}' must not registered twice.");
         return(simulator);
     }
     Simulators.Add(simulator);
     return(simulator);
 }
        private bool ValidateChannelArguments(ISimulatable sim)
        {
            AdaptedFriisArgs args = sim.Arguments as AdaptedFriisArgs;

            if (args.AttenuationExponent <= 1)
            {
                return(false);
            }
            if (args.AttenuationOffset < 0)
            {
                return(false);
            }

            // all okay
            return(true);
        }
Beispiel #6
0
 public abstract ISimulatable RegisterSimulator(ISimulatable simulator, ArgumentsBase args);
Beispiel #7
0
 public bool Contains(ISimulatable simulator)
 {
     return(_items.Contains(simulator));
 }
Beispiel #8
0
        // -- methods

        public void Add(ISimulatable simulator)
        {
            _items.Add(simulator);
        }
Beispiel #9
0
 public SimulatorException(ISimulatable simulator, string message) : base($"{simulator.Arguments.Name} failed: {message}")
 {
 }
Beispiel #10
0
 void AddSpawnedSimulatableToSimulationManager(ISimulatable spawnedSimulatable, ISimulatable originalsSimulatable)
 {
     m_CopiedToOriginalSimulatables[spawnedSimulatable] = GetOriginalSimulatable(originalsSimulatable);
 }
Beispiel #11
0
        /// <summary>
        /// Returns the simulation scene copy of an ISimulatable, if there is one
        /// </summary>
        /// <param name="original">The original version of a copied ISimulatable</param>
        /// <returns></returns>
        public ISimulatable GetCopiedSimulatable(ISimulatable original)
        {
            ISimulatable copy;

            return(m_OriginalToCopiedSimulatables.TryGetValue(original, out copy) ? copy : null);
        }
Beispiel #12
0
 internal void AddSimulatedCopy(ISimulatable copiedSimulatable, ISimulatable originalSimulatable)
 {
     m_CopiedToOriginalSimulatables[copiedSimulatable]   = originalSimulatable;
     m_OriginalToCopiedSimulatables[originalSimulatable] = copiedSimulatable;
 }
 /// <summary>
 /// Initializes a new instance of a Simulator
 /// </summary>
 /// <param name="x">The Schematic you want to simulate</param>
 public Simulator(ISimulatable[] x)
 {
     _Schematic = x;
 }
Beispiel #14
0
        /// <summary>
        /// Returns the original version of an ISimulatable copied to the simulation scene, if there is one
        /// </summary>
        /// <param name="copy">The ISimulatable in the simulation scene</param>
        /// <returns>The original version of the copied object</returns>
        public ISimulatable GetOriginalSimulatable(ISimulatable copy)
        {
            ISimulatable original;

            return(m_CopiedToOriginalSimulatables.TryGetValue(copy, out original) ? original : null);
        }
Beispiel #15
0
 public void RegisterSimulatable(ISimulatable s)
 {
     AllSimulatableObjects.AddOrUpdate(s.Id, (ISimulatable)s, (k, v) => (ISimulatable)s);
 }
 /// <summary>
 /// Initializes a new instance of a Simulator of a standard Controller Schematic
 /// </summary>
 /// <param name="Controller">The Controller of your Schematic</param>
 /// <param name="Jamming">The Jamming of your Schematic</param>
 /// <param name="Control_loop">The Control-Loop of your Schematic</param>
 public Simulator(ISimulatable Controller, Step Jamming, ISimulatable Control_loop)
 {
     _Schematic = new ISimulatable[] { new Adder(new string[] { "+1", "-1" }), Controller, Jamming ,Control_loop };
     _Schematic[1].connect_this_Input_with(_Schematic[0]);
     _Schematic[2].connect_this_Input_with(_Schematic[1]);
     _Schematic[3].connect_this_Input_with(_Schematic[2]);
     _Schematic[0].connect_this_Input_with(_Schematic[3]);
 }
        /// <summary>
        /// Replaces the ISimulatable Object at the specified position in the Schematic
        /// </summary>
        /// <param name="position">The Position you want to replace</param>
        /// <param name="x">The ISimulatable Object</param>
        /// <returns></returns>
        public bool replace_in_Schematic_at_pos(int position, ISimulatable x)
        {
            int kdh = _Schematic.Length;
            if ((_Schematic.Length - 1 > position) && position > 0)
            {
                //Step 1: Disconnect both old connections
                _Schematic[position].disconnect_this_Input_from(_Schematic[position - 1]);
                _Schematic[position + 1].disconnect_this_Input_from(_Schematic[position]);

                //Step 2: Set new Object to the position
                _Schematic[position] = x;

                //Step 3: new connections
                _Schematic[position].connect_this_Input_with(_Schematic[position - 1]);
                _Schematic[position + 1].connect_this_Input_with(_Schematic[position]);
                return true;
            }
            else if ((_Schematic.Length - 1 == position) && position > 0)                         //Last position in Schematic
            {
                //Step 1: Disconnect both old connections
                _Schematic[position].disconnect_this_Input_from(_Schematic[position - 1]);
                _Schematic[0].disconnect_this_Input_from(_Schematic[position]);

                //Step 2: Set new Object to the position
                _Schematic[position] = x;

                //Step 3: new connections
                _Schematic[position].connect_this_Input_with(_Schematic[position - 1]);
                _Schematic[0].connect_this_Input_with(_Schematic[position]);
                return true;
            }
            else
                return false;
        }
 /// <summary>
 /// Disconnect this Input from Target Output.
 /// </summary>
 /// <param name="Target_output">The Target Output you want to disconnect</param>
 public void disconnect_this_Input_from(ISimulatable Target_output)
 {
     ((ISimulatable)Target_output).I_am_finish -= ConnectEventHandler;
 }
 /// <summary>
 /// Connect this input with the output of another ISimulatable object in your Schematic.
 /// </summary>
 /// <param name="Target_output">You want to connect with</param>
 public void connect_this_Input_with(ISimulatable Target_output)
 {
     ((ISimulatable)Target_output).I_am_finish += ConnectEventHandler;
 }