//[MethodImpl(MethodImplOptions.Synchronized)] // single threaded
 public void Check(IGameObject me, FrameUpdateEventArgs e)
 {
     Rect rme = me.Shape;
     bool hitsGround = false;
     foreach (var other in Obstacles)
     {
         if (other != me)
         {
             Rect rother = other.Shape;
             if (rme.IntersectsWith(rother))
             {
                 Rect overlap = Rect.Intersect(rme,rother);
                 if (other is GroundObject)
                     hitsGround = true;
                 if (other.IsObstacle)
                 {
                     ProcessCollision(me, other, overlap, rme, rother, e.ElapsedMilliseconds / 1000);
                 }
                 me.RaiseOnCollision(me, other, true); // bool: me = caller of CheckCollision
                 other.RaiseOnCollision(other, me, false);
             }
         }
     }
     me.IsGrounded = hitsGround;
 }

 public static bool Contains(this ILayer layer, IGameObject gameObject)
 {
     foreach (IReference<IGameObject> reference in layer.GameObjectReferences)
         if (reference.Target == gameObject)
             return true;
     return false;
 }

 public bool Equals(IGameObject other)
 {
     return
         TypeIsSame(other) &&
         FieldNumIsSame(((IChessBoard)other).GetAllFields()) &&
         FieldsAreEqual(((IChessBoard) other).GetAllFields());
 }

    private void ObjectsChanged(Sector sector, IGameObject Object)
    {
        if((Object is IObject) || (Object is Tilemap))
            return;

        UpdateList();
    }

        public override void MailedSuccesfully(Mailbox box, IGameObject obj)
        {
            try
            {
                Metal metal = obj as Metal;
                Collecting collecting = Actor.SkillManager.AddElement(SkillNames.Collecting) as Collecting;
                if (metal != null)
                {
                    // Custom
                    if (!collecting.mMetalData.ContainsKey(metal.Guid))
                    {
                        collecting.mMetalData.Add(metal.Guid, new Collecting.MetalStats(0));
                    }
                }

                base.MailedSuccesfully(box, obj);
            }
            catch (ResetException)
            {
                throw;
            }
            catch (Exception e)
            {
                Common.Exception(Actor, Target, e);
            }
        }

 public Fireball(Image image, GameWorld gameWorld, IGameObject source)
 {
     this.source = source;
     gw = gameWorld;
     Image = image;
     Init();
 }

        public static bool AddHuntableToInventory(DogHuntingSkill ths, IGameObject huntable)
        {
            if (huntable == null)
            {
                return false;
            }

            bool flag = false;

            if (SimTypes.IsSelectable(ths.SkillOwner))
            {
                flag = Inventories.TryToMove(huntable, ths.SkillOwner.CreatedSim);
            }
            else
            {
                // Add the item to head of family
                SimDescription head = SimTypes.HeadOfFamily(ths.SkillOwner.Household);
                if (head != null)
                {
                    flag = Inventories.TryToMove(huntable, head.CreatedSim);
                }
            }

            if (!flag)
            {
                huntable.RemoveFromWorld();
                huntable.Destroy();
            }
            else
            {
                StoryProgression.Main.Skills.Notify("SniffOut", ths.SkillOwner.CreatedSim, Common.Localize("SniffOut:Success", ths.SkillOwner.IsFemale, new object[] { ths.SkillOwner, huntable.GetLocalizedName() }));
            }

            return flag;
        }

 public EventEntry(IGameObject owner, string name)
 {
     Owner = new WeakReference(owner);
     Name = name;
     _comparison = owner.Id;
     _hashCode = Name.GetHashCode() ^ Owner.GetHashCode();
 }

        public static void Raise(string eventName, IGameObject sender, EventArgs args)
        {
            var key = new EventEntry(sender, eventName);
            if(!Entries.ContainsKey(key))
            {
                Log.Warning("A handler for the event '{0}' was not found while attempting to raise the event.", eventName);
                return;
            }

            var list = Entries[key];
            var removes = new List<WeakReference>();
            foreach (var weakRef in list)
            {
                if (!weakRef.IsAlive || weakRef.Target != null)
                {
                    removes.Add(weakRef);
                    continue;
                }
                var action = (Action<IGameObject, EventArgs>) weakRef.Target;
                if (action == null)
                    continue;
                action(sender, args);
            }

            foreach (var weakReference in removes)
            {
                Entries[key].Remove(weakReference);
            }
        }

        public static void DrawObject(this Graphics g, IGameObject obj, Bitmap bitmap, Camera camera)
        {
            var location = obj.Body.Position - camera.Body.Position;
            g.DrawImage(bitmap, location.X, location.Y);

            g.DrawAABB(obj, camera);
        }

 public GrowingImageDrawBehavior(IGameObject gameObject)
 {
     GameObject = gameObject;
     size = new Size(50, 50);
     SpeedX = 1;
     SpeedY = 1;
 }

 public Window(Game game, Vector2 position, int width, int height)
     : base(game)
 {
     _GameRef = (IGameObject)game;
     ScreenPosition = position;
     WindowSize = new Rectangle(0, 0, width, height);
 }

 public static bool IGameObjectCollisionCheck(IGameObject object1, IGameObject object2)
 {
     if (object1.Rect.Intersects(object2.Rect))
         return true;
     else
         return false;
 }

 public Collision(IGameObject gameObject)
 {
     ColliderComponent = gameObject.ColliderComponent;
     GameObject = gameObject;
     RigidBody = GameObject.RigidBody;
     Transform = GameObject.Transform;
 }

 public override void UpdateGameObject(IGameObject gameObject)
 {
     if (!this.Equals(gameObject))
     {
         this.chessBoard = gameObject as IChessBoard;
     }
 }

        ///// <summary>
        ///// Расчитать расход топлива для прыжка
        ///// </summary>
        ///// <returns></returns>
        //public long CalculateFuelForJump(IGameObject obj, IGameObject targetLoc)
        //{
        //    var d = DistanceFor(obj, targetLoc);

        //}

        public double DistanceFor(IGameObject a, IGameObject b)
        {
            LocalPosition alp = LocalPosition.Empty, blp= LocalPosition.Empty;
            var ls = a.Ask(LocalSystem.Query.ResolvePosition)
                .Cast<QueryResponse<LocalPosition>>()
                .FirstOrDefault();
            if (ls != null)
                alp = ls.Value;
            ls = b.Ask(LocalSystem.Query.ResolvePosition)
                .Cast<QueryResponse<LocalPosition>>()
                .FirstOrDefault();
            if (ls != null)
                blp = ls.Value;
            while (!alp.Unknown && !blp.Unknown)
            {
                if (alp.LocalSystem.Level > blp.LocalSystem.Level)
                    alp = alp.LocalSystem.TranslateUp(alp.Coords);
                else if (alp.LocalSystem.Level < blp.LocalSystem.Level)
                    blp = blp.LocalSystem.TranslateUp(blp.Coords);
                if (alp.LocalSystem.Level == blp.LocalSystem.Level)
                    if (alp.LocalSystem != blp.LocalSystem)
                    {
                        alp = alp.LocalSystem.TranslateUp(alp.Coords);
                        blp = blp.LocalSystem.TranslateUp(blp.Coords);
                    }
                    else
                    {
                        
                        return alp.Coords.Distance(blp.Coords) * alp.LocalSystem.Resolution;
                    }
            }
            return double.PositiveInfinity;
        }

        public void ResolveOverlap(IGameObject overlappingObject, ICollisionSide side) {
            int xCoordinate = (int)overlappingObject.VectorCoordinates.X;
            int yCoordinate = (int)overlappingObject.VectorCoordinates.Y;

            Rectangle hitBoxA = new Rectangle((int)gameObjectA.VectorCoordinates.X, (int)gameObjectA.VectorCoordinates.Y, (int)gameObjectA.Sprite.SpriteDimensions.X, (int)gameObjectA.Sprite.SpriteDimensions.Y);
            Rectangle hitBoxB = new Rectangle((int)gameObjectB.VectorCoordinates.X, (int)gameObjectB.VectorCoordinates.Y, (int)gameObjectB.Sprite.SpriteDimensions.X, (int)gameObjectB.Sprite.SpriteDimensions.Y);

            collisionRectangle = Rectangle.Intersect(hitBoxA, hitBoxB);   
            
            if (side is LeftSideCollision) {
                xCoordinate -= collisionRectangle.Width;
                Vector2 newLocation = new Vector2(xCoordinate, yCoordinate );
                overlappingObject.VectorCoordinates = newLocation;
            }
            else if (side is RightSideCollision) {
                xCoordinate += collisionRectangle.Width;
                Vector2 newLocation = new Vector2(xCoordinate, yCoordinate);
                overlappingObject.VectorCoordinates = newLocation;
            }
            else if (side is TopSideCollision)
            {
                yCoordinate -= collisionRectangle.Height;
                Vector2 newLocation = new Vector2(xCoordinate, yCoordinate);
                overlappingObject.VectorCoordinates = newLocation;
            }
            else if (side is BottomSideCollision)
            {
                yCoordinate += collisionRectangle.Height;
                Vector2 newLocation = new Vector2(xCoordinate, yCoordinate);
                overlappingObject.VectorCoordinates = newLocation;
            }
        }

 public Collision(IGameObject self, IGameObject contact, Vector2f resulVelocity, Vector2f eject)
 {
     Subject = contact;
     Eject = eject;
     Velocity = resulVelocity;
     ContactPoint = self.Body.Incircle.Center + Normal * self.Body.Incircle.Radius;
 }

 public CircleMotionBehavior(IGameObject gameObject, GameWorld gw, DecimalPoint center)
     : base(gameObject, gw)
 {
     Center = center;
     Range = 200;
     angle = 0;
 }

 public void registerObject(IGameObject iCollided)
 {
     if (iCollided.left <= _middle.X)
     {
         if (iCollided.top < _middle.Y)
         {
             topLeft.Add(iCollided);
         }
         else
         {
             bottomLeft.Add(iCollided);
         }
     }
     else
     {
         if (iCollided.top < _middle.Y)
         {
             topRight.Add(iCollided);
         }
         else
         {
             bottomRight.Add(iCollided);
         }
     }
 }