internal Cavebot(Objects.Client c)
        {
            this.Client = c;
            InitializeComponent();
            this.Icon = Properties.Resources.icon;
            this.timerStatusWatcher.Start();

            // set default UI values
            comboboxWaypointsOffset.SelectedIndex = 0;
            comboboxWaypointsType.SelectedIndex = 0;
            comboboxTargetingFightMode.SelectedIndex = 0;
            comboboxTargetingMinCount.SelectedIndex = 0;
            comboboxTargetingSpellRune.SelectedIndex = 0;
            comboboxTargetingStance.SelectedIndex = 0;
            comboboxLootingDestination.SelectedIndex = 1;

            // set default settings
            checkboxSettingsDebugMode.Checked = true;
            checkboxSettingsCanUseMagicRope.Checked = true;
            checkboxSettingsEatFood.Checked = true;
            checkboxSettingsStickToCreature.Checked = true;
            checkboxSettingsStopAttackingWhenOutOfRange.Checked = true;
            checkboxSettingsUseAlternateNodeFinder.Checked = true;

            // set up events
            this.Client.Modules.Cavebot.WaypointAdded += new Modules.Cavebot.WaypointHandler(Cavebot_WaypointAdded);
            this.Client.Modules.Cavebot.WaypointInserted += new Modules.Cavebot.WaypointInsertedHandler(Cavebot_WaypointInserted);
            this.Client.Modules.Cavebot.WaypointRemoved += new Modules.Cavebot.WaypointHandler(Cavebot_WaypointRemoved);
            this.Client.Modules.Cavebot.TargetAdded += new Modules.Cavebot.TargetHandler(Cavebot_TargetAdded);
            this.Client.Modules.Cavebot.TargetRemoved += new Modules.Cavebot.TargetHandler(Cavebot_TargetRemoved);
            this.Client.Modules.Cavebot.LootAdded += new Modules.Cavebot.LootHandler(Cavebot_LootAdded);
            this.Client.Modules.Cavebot.LootRemoved += new Modules.Cavebot.LootHandler(Cavebot_LootRemoved);
            this.Client.Modules.Cavebot.StatusChanged += new Modules.Cavebot.StatusChangedHandler(Cavebot_StatusChanged);
        }

 public MapGrid(int x, int y, bool walkable, Objects.Location location)
 {
     _x = x;
     _y = y;
     _walkable = walkable;
     _location = location;
 }

        void element_BeforeRendering(object sender, Objects.RenderEventArgs e)
        {
            vec3 currentVector = this.camera.Position - this.camera.Target;
            vec3 defaultVector = ScientificCamera.defaultPosition - ScientificCamera.defaultTarget;
            currentVector.Normalize();
            defaultVector.Normalize();

            float cosAngle = currentVector.ScalarProduct(defaultVector);// / 1.0f;
            float angle = (float)Math.Acos(cosAngle);
            //vec3 axis = currentVector.VectorProduct(defaultVector);
            vec3 axis = defaultVector.VectorProduct(currentVector);
            //mat4 translate = glm.translate(mat4.identity(), new vec3(0.2f, 0.2f, 0.2f));
            mat4 modelMatrix = glm.rotate(angle, axis);

            //mat4 modelMatrix = mat4.identity();
            mat4 viewMatrix = this.camera.GetViewMat4();
            mat4 projectionMatrix = this.camera.GetProjectionMat4();

            ShaderProgram shaderProgram = element.shaderProgram;
            shaderProgram.Bind();

            shaderProgram.SetUniformMatrix4(PyramidElement.strprojectionMatrix, projectionMatrix.to_array());
            shaderProgram.SetUniformMatrix4(PyramidElement.strviewMatrix, viewMatrix.to_array());
            shaderProgram.SetUniformMatrix4(PyramidElement.strmodelMatrix, modelMatrix.to_array());
        }

		public override void Update(Objects.View3D view)
		{
			base.Update(view);

			SlimDX.Direct3D11.DeviceContext context = GameEnvironment.Device.ImmediateContext; 

			//DataStream stream = Instances.Map(MapMode.WriteDiscard, SlimDX.Direct3D11.MapFlags.None);

			DataBox box = context.MapSubresource(Instances, MapMode.WriteDiscard, MapFlags.None);
			DataStream stream = box.Data; 

			Random rand = new Random();

			float Dist = 300f;
			float HalfDist = Dist * 0.5f;

			for (int i = 0; i < MaxCount; i++)
			{
				stream.Write(new StarInstanceVertex()
				{
					Color = new Vector4((float)rand.NextDouble(), (float)rand.NextDouble(), (float)rand.NextDouble(), (float)rand.NextDouble()),
					Position = new Vector3((float)(rand.NextDouble() * Dist) - HalfDist,
											(float)(rand.NextDouble() * Dist) - HalfDist,
											(float)(rand.NextDouble() * Dist) - HalfDist)
				});

			}

			this.InstanceCount = MaxCount; 

			//Instances.Unmap(); 
			context.UnmapSubresource(Instances, 0); 
		}

        internal static void CastAoe(string parSpellName, Objects.Location parSpellPos)
        {
            lock (Inject.inject_Lock)
            {
                DoString("CastSpellByName('" + parSpellName + "')");

                uint posStruc = BmWrapper.memory.AllocateMemory(12);

                if (posStruc != 0)
                {
                    bool b1 = BmWrapper.memory.WriteFloat(posStruc, parSpellPos.x);
                    bool b2 = BmWrapper.memory.WriteFloat(posStruc + 4, parSpellPos.y);
                    bool b3 = BmWrapper.memory.WriteFloat(posStruc + 8, parSpellPos.z);

                    if (b1 && b2 && b3)
                    {

                        // Write the asm stuff for Lua_DoString
                        String[] asm = new String[]
                        {
                            "mov eax, 0x40",
                            "mov [0xCECAC0], eax",

                            "mov eax, [" + Inject.PlayerPtr + "]",
                            "mov ecx, " + (uint)posStruc,
                            "call " + (uint)0x6E60F0,
                            "retn",
                        };
                        Inject.InjectAndExecute(asm, true);
                    }
                    BmWrapper.memory.FreeMemory(posStruc);
                }
            }
        }

		public static void Get(Objects.User user, Action<Objects.User> callback)
		{
			var parameters = new Dictionary<string, string>();
			if(user.Name != null && user.Name != string.Empty)
			{
				parameters.Add ("username", user.Name.ToLower());
			}
			else if (user.ID != 0)
			{
				parameters.Add ("user_id", user.ID.ToString());
			}

			Core.Request.Get(Constants.API_USERS_FETCH, parameters, (Core.Response response) => {
				if(response.success)
				{
					user.BulkUpdate(response.json["users"][0].AsObject);
				}
				else
				{
					user = null;
				}

				if (callback != null)
				{
					callback(user);
				}
			}, false);
		}

        public TurnPacket(Objects.Client c, Constants.Direction direction)
            : base(c)
        {
            Direction = direction;

            switch (direction)
            {
                case Tibia.Constants.Direction.Down:
                    Type = OutgoingPacketType.TurnDown;
                    break;
                case Tibia.Constants.Direction.Up:
                    Type = OutgoingPacketType.TurnUp;
                    break;
                case Tibia.Constants.Direction.Right:
                    Type = OutgoingPacketType.TurnRight;
                    break;
                case Tibia.Constants.Direction.Left:
                    Type = OutgoingPacketType.TurnLeft;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(
                        "direction",
                        "Valid directions for turning are Up, Right, Down, and Left.");
            }

            Destination = PacketDestination.Server;
        }

 public NetworkMessage(Objects.Client client, int size)
 {
     bufferSize = size;
     buffer = new byte[bufferSize];
     Client = client;
     position = GetPacketHeaderSize() + 2;
 }

 public mainProcess(Objects.UserObject cUser,ref  List<Objects.MsgObject> list)
 {
     currentUser = cUser;
     mainProcess._globalMsgList = list;
     string userName = currentUser.FirstName + " " + currentUser.LastName;
     chatRobot = new msgCenter.Operators.ChatRobotOperator(userName);
 }

        void legacyUIRect_BeforeRendering(object sender, Objects.RenderEventArgs e)
        {
            LegacySimpleUIRect element = sender as LegacySimpleUIRect;

            IUILayoutArgs args = element.GetArgs();

            GL.MatrixMode(GL.GL_PROJECTION);
            GL.PushMatrix();
            GL.LoadIdentity();
            GL.Ortho((float)args.left, (float)args.right, (float)args.bottom, (float)args.top, element.Param.zNear, element.Param.zFar);
            //GL.Ortho(args.left / 2, args.right / 2, args.bottom / 2, args.top / 2, element.Param.zNear, element.Param.zFar);

            IViewCamera camera = e.Camera;

            if (camera == null)
            {
                GL.gluLookAt(0, 0, 1, 0, 0, 0, 0, 1, 0);
                //throw new Exception("Camera not set!");
            }
            else
            {
                vec3 position = camera.Position - camera.Target;
                position.Normalize();
                GL.gluLookAt(position.x, position.y, position.z,
                    0, 0, 0,
                    camera.UpVector.x, camera.UpVector.y, camera.UpVector.z);
            }

            GL.MatrixMode(GL.GL_MODELVIEW);
            GL.PushMatrix();
            GL.Scale(args.UIWidth / 2, args.UIHeight / 2, args.UIWidth);

        }

 public static bool Send(Objects.Client client, PipeConstantType constantType, uint value)
 {
     SetConstantPacket p = new SetConstantPacket(client);
     p.ConstantType = constantType;
     p.Value = value;
     return p.Send();
 }

        static void Main(string[] args)
        {
            //Console
            int speed = 100;
            int playFieldWidth = 15;
            Console.BufferHeight = Console.WindowHeight = 30;
            Console.BufferWidth = Console.WindowWidth = 35;

            Objects userDwarf = new Objects();
            userDwarf.x = 2;
            userDwarf.y = Console.WindowHeight - 1;
            userDwarf.c = '@';
            userDwarf.color = ConsoleColor.White;

            List<Objects> objectss = new List<Objects>();
            Random randomGenerator = new Random();

            while (true)
            {
                if (speed >= 400)
                {
                    speed = 400;
                }
                Objects newEnemy = new Objects();
                newEnemy.color = ConsoleColor.Green;
                newEnemy.x = randomGenerator.Next(0, playFieldWidth); // 0-5
                newEnemy.y = 0; // poqvqva se nai-otgore
                newEnemy.c = '#';
                // newCar.c = randomGenerator.Next(randomKoli4ki[0],randomKoli4ki[duljina]);
                objectss.Add(newEnemy);
            }
        }

        public static void tryCaptureTower(Objects.playerObject player)
        {
            List<Grid.GridObjectInterface> list = GameController.Grid.checkNeighbouringBlocks(player);

            foreach (Grid.GridObjectInterface item in list)
            {
                if (item is Objects.Turret && (item.Position - player.Position).Length() <= MAX_CAPTURE_DISTANCE)
                {
                    Objects.Turret turret = ((Objects.Turret)item);
                    if (turret.Team.Equals(Objects.Team.neutral))
                    {
                        turret.changeTeam(player.Team);
                        GameController.AIController.registerTurretOnTeam(turret, player.Team);
                        if (player.Team == Objects.Team.Red)
                        {
                            Controller.GameController.Team1Gold.Add(TradingInformation.creditsForCapturingTower.ToString());
                            Controller.GameController.team1.teamCredits += TradingInformation.creditsForCapturingTower;
                        }
                        else
                        {
                            Controller.GameController.Team2Gold.Add(TradingInformation.creditsForCapturingTower.ToString());
                            Controller.GameController.team2.teamCredits += TradingInformation.creditsForCapturingTower;
                        }
                        break;
                    }
                }
            }
        }

 /// <summary>
 /// Constructor for an item in the player's inventory.
 /// </summary>
 /// <param name="item"></param>
 public ItemLocation(Objects.Item item)
 {
     this.WorldLocation = item.ToLocation();
     this.ItemID = item.ID;
     this.ItemCount = item.Count;
     this.StackIndex = item.Slot;
 }

        public static bool Send(Objects.Client client, EventType eventType)
        {
            EventTriggerPacket p = new EventTriggerPacket(client);

            p.eventType = eventType;

            return p.Send();
        }

		void Mapper( Objects.ClassWithProperties instance )
		{
			var mapped = instance.MapInto<ClassWithProperties>();
			Assert.Equal( instance.PropertyOne, mapped.PropertyOne );
			Assert.Equal( instance.PropertyTwo, mapped.PropertyTwo );
			Assert.Equal( instance.PropertyThree, mapped.PropertyThree );
			Assert.Equal( instance.PropertyFour, mapped.PropertyFour );
		}

 public void Feed(Objects.Data data)
 {
     // thread safe
     mutex.WaitOne();
     foreach (SubscriptionRegistration registration in registrations.Values)
         registration.Notify(data);
     mutex.ReleaseMutex();
 }

 public Projectile(Game game, Objects.Enemy target, int level)
     : base(game)
 {
     m_ModelName = "Projectiles/Sphere";
     Scale = 0.05f;
     m_Target = target;
     m_Level = level;
 }

 public static Image GetSpriteImage(Objects.Client client, int spriteId)
 {
     return GetSpriteImage(
         Path.Combine(
             Path.GetDirectoryName(client.Process.MainModule.FileName),
             "Pokemon.spr"),
         spriteId);
 }

 public static bool SessionCheck(Objects.Gebruiker g)
 {
     if (!SQLInjectionCheck(g.GebruikersNaam) || !SQLInjectionCheck(g.WachtWoord) || g.GebruikersNaam == "" || g.WachtWoord == "" || g.GebruikersNaam.Length < 8 || g.WachtWoord.Length < 8)
     {
         return false;
     }
     return true;
 }