private static void onCreate(EntityEventArgs args)
 {
     var ent = args.Entity;
     if (!(ent is Projectile))
         return;
     //Projectile proj = ent as Projectile;
 }

        private void EntityRemoved(object sender, EntityEventArgs entityEventArgs)
        {
            var gameObj = entityEventArgs.Entity;
            if (gameObj.GetComponent<Collider>() == null) return;

            var collider = gameObj.GetComponent<Collider>();
            colliders.Remove(collider);
            grid.RemoveCollider(collider);
        }

        public void OnAddEntity(EntityEventArgs args)
        {
            var unit = args.Entity as Unit;

            if (unit == null || !unit.IsValid || !unit.IsControllable || unit.Team != heroTeam
                || (unit.IsIllusion && unit.ClassID != hero.ClassID) || unit.AttackCapability == AttackCapability.None
                || ignoredUnits.Contains(unit.ClassID) || unit.Equals(hero))
            {
                return;
            }

            var contrallable = new Controllable(unit);
            contrallable.OnCampChange += OnCampChange;
            controllableUnits.Add(contrallable);
        }

        public void OnAddEntity(EntityEventArgs args)
        {
            DelayAction.Add(
                1000f,
                () =>
                    {
                        var unit = args.Entity as Creep;

                        if (unit == null || !unit.IsValid || unit.Team == heroTeam)
                        {
                            return;
                        }

                        killableList.Add(new Classes.Creep(unit));
                    });
        }

    private void graphVisualization_OnEntityAdded(object sender, EntityEventArgs e) {
      IConnection connection = e.Entity as IConnection;
      if (connection != null && !this.connectionInfoConnectionMapping.ContainsSecond(connection)) {
        IConnector connectorFrom = connection.From.AttachedTo;
        IConnector connectorTo = connection.To.AttachedTo;
        this.RemoveConnection(connection); //is added again by the model events

        if (connectorFrom != null && connectorTo != null) {
          IShape shapeFrom = (IShape)connectorFrom.Parent;
          IShape shapeTo = (IShape)connectorTo.Parent;
          IShapeInfo shapeInfoFrom = this.shapeInfoShapeMapping.GetBySecond(shapeFrom);
          IShapeInfo shapeInfoTo = this.shapeInfoShapeMapping.GetBySecond(shapeTo);
          string connectorFromName = connectorFrom.Name;
          string connectorToName = connectorTo.Name;

          if (shapeInfoFrom != shapeInfoTo) //avoid self references
            this.Content.AddConnectionInfo(new ConnectionInfo(shapeInfoFrom, connectorFromName, shapeInfoTo, connectorToName));
        }
      }
    }

 private void ObjectManager_OnRemoveEntity(EntityEventArgs args)
 {
     predictions.OnRemoveEntity(args);
 }

 private void shape_OnEntityChange(object sender, EntityEventArgs e) {
   IShape shape = e.Entity as IShape;
   IShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(shape);
   this.DeregisterShapeInfoEvents(shapeInfo);
   shapeInfo.UpdateShapeInfo(shape);
   this.RegisterShapeInfoEvents(shapeInfo);
   this.graphVisualization.Invalidate();
 }

 private static void ObjectMgr_OnAddEntity(EntityEventArgs args)
 {
     if (me == null || !Game.IsInGame)
     {
         return;
     }
     var ent = args.Entity as Unit;
     if (ent == null)
     {
         return;
     }
     //if (ent is Hero && !ent.IsIllusion && ent.Team == me.GetEnemyTeam())
     //{
     //    Console.WriteLine("Heroadded");
     //    enemyHeroes =
     //        ObjectMgr.GetEntities<Hero>()
     //            .Where(x => x != null && x.IsValid && x.Team == me.GetEnemyTeam() && !x.IsIllusion);
     //}
     if ((ent.ClassID == ClassID.CDOTA_NPC_TechiesMines) && !remoteMinesDb.ContainsKey(ent))
     {
         remoteMinesDb.Add(ent, remoteMinesDmg);
     }
 }

        /// <summary>
        ///     The object manager on remove entity.
        /// </summary>
        /// <param name="args">
        ///     The args.
        /// </param>
        private static void ObjectMgr_OnRemoveEntity(EntityEventArgs args)
        {
            var tower = args.Entity as Building;
            if (tower == null)
            {
                return;
            }

            All.Remove(tower);
            if (tower.Team == Team.Dire)
            {
                Dire.Remove(tower);
            }
            else
            {
                Radiant.Remove(tower);
            }
        }

 void HandleTaskUpdated(object sender, EntityEventArgs<Task> e)
 {
     ITaskListItemViewModel item = Items.FirstOrDefault(i => i.Id == e.Entity.Id);
     if (item != null)
     {
         Task task = tasksModel.Get(e.Entity.Id);
         item.Update(task);
     }
     ItemsView.Refresh();
 }

 void mDefaultPage_OnEntityAdded(object sender, EntityEventArgs e)
 {
     //don't add it if it's already there or if it's a group (unless you want to deploy something special to emphasize a group shape).
     if (!mPaintables.Contains(e.Entity) && !(e.Entity is IGroup))
     {
         //set the new entity on top of the stack
         e.Entity.SceneIndex = mPaintables.Count;
         mPaintables.Add(e.Entity);
     }
     RaiseOnEntityAdded(e);
 }

		protected virtual void OnEntityRemoved(EntityEventArgs e)
		{
			if (EntityRemoved != null)
				EntityRemoved(this, e);
			OnModified(EventArgs.Empty);
		}

 void Model_OnEntityAdded(object sender, EntityEventArgs e)
 {
 }

 // ------------------------------------------------------------------
 /// <summary>
 /// Raises the OnSelect event.
 /// </summary>
 /// <param name="sender">The sender.</param>
 /// <param name="e">The 
 /// <see cref="T:Netron.Diagramming.Core.EntityEventArgs"/> instance 
 /// containing the event data.</param>
 // ------------------------------------------------------------------
 protected virtual void RaiseOnSelect(
     object sender,
     EntityEventArgs e) {
   if (OnEntitySelect != null) {
     OnEntitySelect(sender, e);
   }
 }

    private void graphVisualization_OnEntityRemoved(object sender, EntityEventArgs e) {
      IShape shape = e.Entity as IShape;
      if (shape != null && this.shapeInfoShapeMapping.ContainsSecond(shape)) {
        IShapeInfo shapeInfo = this.shapeInfoShapeMapping.GetBySecond(shape);
        this.Content.RemoveShapeInfo(shapeInfo);
      }

      IConnection connection = e.Entity as IConnection;
      if (connection != null && this.connectionInfoConnectionMapping.ContainsSecond(connection)) {
        IConnectionInfo connectionInfo = connectionInfoConnectionMapping.GetBySecond(connection);
        this.Content.RemoveConnectionInfo(connectionInfo);
      }
    }

 /// <summary>On entity added event triggered</summary>
 /// <param name="sender">Event sender.</param>
 /// <param name="e">Event args.</param>
 void OnEntityStateChanged(object sender, EntityEventArgs e)
 {
     if (e.State == EntityState.Added)
         Entities.Add(e.Entity);
     else if (e.State == EntityState.Removed)
         Entities.Remove(e.Entity);
 }

        public void OnAddEntity(EntityEventArgs args)
        {
            if (!Menu.Hotkeys.EnabledEvader)
            {
                return;
            }

            var unit = args.Entity as Unit;

            if (unit == null || !unit.IsValid)
            {
                return;
            }

            if (Menu.Debug.LogUnits)
            {
                Debugger.WriteLine("====", Debugger.Type.Units);
                Debugger.WriteLine("unit name: " + unit.Name, Debugger.Type.Units);
                Debugger.WriteLine("unit id: " + unit.ClassID, Debugger.Type.Units);
                Debugger.WriteLine("vision: " + unit.DayVision, Debugger.Type.Units);
                if (unit.Owner != null && unit.Owner.IsValid)
                {
                    Debugger.WriteLine("owner: " + unit.Owner.Name, Debugger.Type.Units);
                }
                else
                {
                    Debugger.WriteLine("owner not valid", Debugger.Type.Units);
                }
            }

            if (unit.ClassID != ClassID.CDOTA_BaseNPC || unit.AttackCapability != AttackCapability.None
                || unit.Team == HeroTeam)
            {
                return;
            }

            var dayVision = unit.DayVision;

            if (Menu.Debug.LogInformation && dayVision > 0)
            {
                Debugger.Write("  = >   Unit (" + unit.Name + ") with vision: " + dayVision + " // ");
                var closestHero =
                    ObjectManager.GetEntitiesParallel<Hero>()
                        .Where(x => x.IsValid && x.IsAlive)
                        .OrderBy(x => x.Distance2D(unit))
                        .FirstOrDefault();
                Debugger.WriteLine(closestHero.GetName() + " (" + closestHero.Distance2D(unit) + ")", showType: false);
            }

            var abilityNames = AdditionalAbilityData.Vision.Where(x => x.Value == dayVision).Select(x => x.Key).ToList();

            if (!abilityNames.Any())
            {
                if (Menu.Debug.LogInformation && dayVision > 0)
                {
                    Debugger.WriteLine("  = >   Ability name not found");
                }
                return;
            }

            var abilities = abilityUpdater.EvadableAbilities.Where(x => abilityNames.Contains(x.Name)).ToList();

            if (abilities.Count != 1)
            {
                if (abilities.Count < 1)
                {
                    return;
                }

                Debugger.Write("=> Same vision for: ");
                foreach (var ability in abilities)
                {
                    Debugger.Write(ability.Name + " ", showType: false);
                }
                Debugger.WriteLine(showType: false);

                return;
            }

            var unitAbility = abilities.FirstOrDefault() as IUnit;
            if (unitAbility == null)
            {
                return;
            }

            Debugger.WriteLine("  = >   Ability name: " + unitAbility.Name);
            unitAbility.AddUnit(unit);
        }

 void mModel_OnEntityRemoved(object sender, EntityEventArgs e)
 {
     RaiseOnEntityRemoved(e);
 }

 private static void ObjectMgr_OnRemoveEntity(EntityEventArgs args)
 {
     if (me == null || !Game.IsInGame)
     {
         return;
     }
     var ent = args.Entity as Unit;
     if (ent != null && (ent.ClassID == ClassID.CDOTA_NPC_TechiesMines) && remoteMinesDb.ContainsKey(ent))
     {
         remoteMinesDb.Remove(ent);
     }
 }

 /// <summary>
 /// Handles the OnEntityRemoved event of the Controller control.
 /// </summary>
 /// <param name="sender">The source of the event.</param>
 /// <param name="e">The <see cref="T:Netron.Diagramming.Core.EntityEventArgs"/> instance containing the event data.</param>
 void Controller_OnEntityRemoved(object sender, EntityEventArgs e)
 {
     RaiseOnEntityRemoved(e);
 }