public static ObjectGuid CreateBookWrittenCallback(object customData, ref Simulator.ObjectInitParameters initData, Quality quality)
        {
            BookWrittenData data = customData as BookWrittenData;
            if (data == null) return ObjectGuid.InvalidObjectGuid;

            try
            {
                Notify(data.Title);

                BookWritten book = GlobalFunctions.CreateObjectOutOfWorld("BookWritten") as BookWritten;
                if (book == null)
                {
                    return ObjectGuid.InvalidObjectGuid;
                }

                book.InitBookCommon(data);

                return book.ObjectId;
            }
            catch(Exception e)
            {
                Common.Exception(data.ID, e);
                return ObjectGuid.InvalidObjectGuid;
            }
        }

 private void Objects_OnObjectUpdated(Simulator simulator, ObjectUpdate update, ulong regionHandle, ushort timeDilation)
 {
     if (startTime == 0) return;
     if (update.LocalID == Client.Self.LocalID)
     {
         XYMovement();
         ZMovement();
         if (Client.Self.Movement.AtPos || Client.Self.Movement.AtNeg)
         {
             Client.Self.Movement.TurnToward(target);
             Debug("Flyxy ");
         }
         else if (Client.Self.Movement.UpPos || Client.Self.Movement.UpNeg)
         {
             Client.Self.Movement.TurnToward(target);
             //Client.Self.Movement.SendUpdate(false);
             Debug("Fly z ");
         }
         else if (Vector3.Distance(target, Client.Self.SimPosition) <= 2.0)
         {
             EndFlyto();
             Debug("At Target");
         }
     }
     if (Environment.TickCount - startTime > duration)
     {
         EndFlyto();
         Debug("End Flyto");
     }
 }

    /// <summary>First half builds the ring, second half tests the connection handler...</summary>
    public void RingTest() {
      Parameters p = new Parameters("Test", "Test");
      string[] args = "-b=.2 -c --secure_senders -s=50".Split(' ');
      Assert.AreNotEqual(-1, p.Parse(args), "Unable to parse" + p.ErrorMessage);
      Simulator sim = new Simulator(p);
      _sim = sim;
      Assert.IsTrue(sim.Complete(true), "Simulation failed to complete the ring");

      SimpleTimer.RunSteps(fifteen_mins, false);
      var nm0 = sim.TakenIDs.Values[0];
      int idx = 1;
      NodeMapping nm1 = null;
      do {
        nm1 = sim.TakenIDs.Values[idx++];
      } while(Simulator.AreConnected(nm0.Node, nm1.Node) && idx < sim.TakenIDs.Count);

      Assert.IsFalse(Simulator.AreConnected(nm0.Node, nm1.Node), "Sanity check");
      var ptype = new PType("chtest");
      var ch0 = new ConnectionHandler(ptype, (StructuredNode) nm0.Node);
      var ch1 = new ConnectionHandler(ptype, (StructuredNode) nm1.Node);
      ConnectionHandlerTest(nm0.Node, nm1.Node, ch0, ch1);

      SimpleTimer.RunSteps(fifteen_mins * 2, false);

      Assert.IsFalse(Simulator.AreConnected(nm0.Node, nm1.Node), "Sanity check0");
      ptype = new PType("chtest1");
      ch0 = new SecureConnectionHandler(ptype, (StructuredNode) nm0.Node, nm0.Sso);
      ch1 = new SecureConnectionHandler(ptype, (StructuredNode) nm1.Node, nm1.Sso);
      ConnectionHandlerTest(nm0.Node, nm1.Node, ch0, ch1);
    }

        public static UtilityFuncLib LoadUtilityFuncLib(string file, Simulator sim)
        {
            Assembly utilFile;
            UtilityFuncLib lib;

            try
            {
                utilFile = Assembly.LoadFrom(file);
                Type mainType;

                foreach (Type t in utilFile.GetTypes())
                {
                    if (t.Name == "UtilityFuncMain")
                    {
                        mainType = t;

                        lib = (UtilityFuncLib)Activator.CreateInstance(mainType, sim);

                        return lib;
                    }
                }
            }
            catch (ApplicationException ex)
            {
                // Error loading utility func library
            }

            return null;
        }

 public InfiniteWave(Simulator simulator, DescriptorInfiniteWaves descriptor)
 {
     Simulator = simulator;
     Descriptor = descriptor;
     NbWavesAsked = 0;
     ActualDifficulty = Descriptor.StartingDifficulty - Descriptor.DifficultyIncrement;
 }

 private static IGameObject CreateObjectWithOverrides(ulong instance, ProductVersion version, Vector3 initPos, int level, Vector3 initFwd, Hashtable overrides, Simulator.ObjectInitParameters initData)
 {
     GlobalFunctions.FillInInitData(initPos, level, initFwd, ref initData);
     IGameObject createdObject = CreateObjectInternal(instance, version, overrides, initData);
     GlobalFunctions.CheckForFailure(createdObject, "Missing object resource instance " + instance + Common.NewLine);
     return createdObject;
 }

        public Ai(Simulator simulator)
        {
            this.simulator = simulator;
            this.ticks = simulator.Ticks;
            kruispunten = new List<IKruispuntType>();

            // maak een initial state aan
            foreach (IKruispunt kruispunt in this.simulator.Kruispunten)
            {
                if (kruispunt is Type1)
                {
                    kruispunten.Add(new KruispuntType1(kruispunt, simulator));
                }

                else if (kruispunt is Type2)
                {
                    kruispunten.Add(new KruispuntType2(kruispunt, simulator));
                }

                else if (kruispunt is Type3)
                {
                    kruispunten.Add(new KruispuntType3(kruispunt, simulator));
                }

                else if (kruispunt is Type4)
                {
                    kruispunten.Add(new KruispuntType4(kruispunt, simulator));
                }
            }

            // register event handlers
            this.simulator.postSimulate += new EventHandler(simulator_postSimulate);
            this.simulator.preSimulate += new EventHandler(simulator_preSimulate);
        }

 public StandardInteractionProvider(Simulator simulator, AbstractWindowsEnvironment environmentInterface,
     out Action cancelCallback)
 {
     this.simulator = simulator;
     this.environmentInterface = environmentInterface;
     cancelCallback = HandleCancelCallback;
 }

 public SimulatorSpell (Simulator sim, string name)
     : base(name)
 {
     Contract.Requires(sim != null);
     Contract.Requires(!string.IsNullOrEmpty(name));
     
     Sim = sim;
 }

        public void ShouldFinishWithConclusiveMatch()
        {
            var match = A.Match.Build();
            var simulator = new Simulator(randomizer);
            simulator.Play(match);

            Assert.That(match.IsConclusive, Is.True);
        }

        public void ShouldFinishWithInactiveMatch()
        {
            var match = A.Match.Build();
            var simulator = new Simulator(randomizer);
            simulator.Play(match);

            Assert.That(match.IsActive, Is.False);
        }

        public void ShouldGenerateMatchResult()
        {
            var match = A.Match.Build();
            var simulator = new Simulator(randomizer);
            var result = simulator.Play(match);

            Assert.That(result, Is.Not.Null);
        }

        static void Main(string[] args)
        {
            var limitOrderBook = new StandardLimitOrderBook();
            var commsModule = SignalRCommunicationsHandler.Instance;
            var simulator = new Simulator(limitOrderBook, commsModule, commsModule);

            System.Console.ReadKey();
        }

 public SimulatorInputInterface(Simulator.OurSimulator os)
     : base()
 {
     //For conversion into controller units
     worldWidth = (os.Algo.dim[0] * 100) / this.scale;
     worldHeight = (os.Algo.dim[1] * 100) / this.scale;
     this.os = os;
 }

//    [Test]
    public void CompleteTheDtlsRing() {
      Parameters p = new Parameters("Test", "Test");
      string[] args = "-b=.2 --dtls -c --secure_edges -s=25".Split(' ');
      Assert.AreNotEqual(-1, p.Parse(args), "Unable to parse" + p.ErrorMessage);;
      Simulator sim = new Simulator(p);
      Assert.IsTrue(sim.Complete(true), "Simulation failed to complete the ring");
      sim.Disconnect();
    }

        private void UpdateMiniMap(Simulator sim)
        {
            if (this.InvokeRequired) this.BeginInvoke((MethodInvoker)delegate { UpdateMiniMap(sim); });
            else
            {
                Bitmap bmp = new Bitmap(256, 256);
                Graphics g = Graphics.FromImage(bmp);
                //SolidBrush brush = new SolidBrush(Color.FromArgb(90, 32, 32, 32));

                g.Clear(this.BackColor);

                g.FillRectangle(Brushes.White, 0f, 0f, 256f, 256f);

                if (sim.PositionIndexYou == -1 || sim.PositionIndexYou >= sim.AvatarPositions.Count) return;

                int i = 0;

                Vector3 myPos = sim.AvatarPositions[sim.PositionIndexYou];

                _Client.Network.CurrentSim.AvatarPositions.ForEach(delegate(Vector3 pos)
                {
                    int x = (int)pos.X;
                    int y = 255 - (int)pos.Y;
                    if (i == _Client.Network.CurrentSim.PositionIndexYou)
                    {
                        g.FillEllipse(Brushes.PaleGreen, x - 5, y - 5, 10, 10);
                        g.DrawEllipse(Pens.Green, x - 5, y - 5, 10, 10);
                    }
                    else
                    {
                        if (myPos.Z - (pos.Z * 4) > 5)
                        {
                            Point[] points = new Point[3] { new Point(x - 6, y - 6), new Point(x + 6, y - 6), new Point(x, y + 6) };
                            g.FillPolygon(Brushes.Red, points);
                            g.DrawPolygon(Pens.DarkRed, points);
                        }

                        else if (myPos.Z - (pos.Z * 4) < -5)
                        {
                            Point[] points = new Point[3] { new Point(x - 6, y + 6), new Point(x + 6, y + 6), new Point(x, y - 6) };
                            g.FillPolygon(Brushes.Red, points);
                            g.DrawPolygon(Pens.DarkRed, points);
                        }

                        else
                        {
                            g.FillEllipse(Brushes.Red, x - 5, y - 5, 10, 10);
                            g.DrawEllipse(Pens.DarkRed, x - 5, y - 5, 10, 10);
                        }
                    }
                    i++;
                });

                g.DrawImage(bmp, 0, 0);
                this.Image = bmp;
            }
        }

        public StimuliForm()
        {
            InitializeComponent();
            this.FormClosed += StimuliForm_FormClosed;

            this.simulator = SimulatorAccessor.simulator;

            Refresh();
        }

 void Network_OnCurrentSimChanged(Simulator PreviousSimulator)
 {
     GridRegion region;
     if (Client.Grid.GetGridRegion(Client.Network.CurrentSim.Name, GridLayerType.Objects, out region))
     {
         _MapImageID = region.MapImageID;
         Client.Assets.RequestImage(_MapImageID, ImageType.Baked);
     }
 }

 public AutoAttack (Simulator sim, Func<TimeSpan> swingTimer)
 {
     Contract.Requires(sim != null);
     Contract.Requires(swingTimer != null);
     
     Sim = sim;
     _swingTimer = swingTimer;
     
     NextSwing = TimeSpan.Zero;
 }

 public Ability(Simulator sim, string name, 
                 Func<TimeSpan> cooldown = null,
                 Func<TimeSpan> gcd = null,
                 Func<bool> isUsable = null)
     : base(sim, name)
 {
     _cooldown = cooldown ?? (() => TimeSpan.Zero);
     _gcd = gcd ?? (() => TimeSpan.FromSeconds(1.5));
     _isUsable = isUsable ?? (() => true);
 }