Example #1
0
 private static void onCreate(EntityEventArgs args)
 {
     var ent = args.Entity;
     if (!(ent is Projectile))
         return;
     //Projectile proj = ent as Projectile;
 }
Example #2
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <BillOfMaterials, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((BillOfMaterials)sender, args);
                }
            }
            private void onNewProxy(object sender, EntityEventArgs args)
            {
                EventHandler <PurchaseOrderDetail, EntityEventArgs> handler = onNew;

                if ((object)handler != null)
                {
                    handler.Invoke((PurchaseOrderDetail)sender, args);
                }
            }
Example #4
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <SalesTerritory, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((SalesTerritory)sender, args);
                }
            }
Example #5
0
        public static void OnRemoveEntity(EntityEventArgs args)
        {
            var entity = args.Entity;

            if (entity.Team == Core.Me.Team && entity.ClassId == ClassId.CDOTA_NPC_TechiesMines)
            {
                Remove((Unit)entity);
            }
        }
            private void onDeleteProxy(object sender, EntityEventArgs args)
            {
                EventHandler <SalesPersonQuotaHistory, EntityEventArgs> handler = onDelete;

                if ((object)handler != null)
                {
                    handler.Invoke((SalesPersonQuotaHistory)sender, args);
                }
            }
Example #7
0
            private void onDeleteProxy(object sender, EntityEventArgs args)
            {
                EventHandler <Customer, EntityEventArgs> handler = onDelete;

                if ((object)handler != null)
                {
                    handler.Invoke((Customer)sender, args);
                }
            }
Example #8
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <AddressType, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((AddressType)sender, args);
                }
            }
Example #9
0
            private void onDeleteProxy(object sender, EntityEventArgs args)
            {
                EventHandler <JobCandidate, EntityEventArgs> handler = onDelete;

                if ((object)handler != null)
                {
                    handler.Invoke((JobCandidate)sender, args);
                }
            }
Example #10
0
            private void onDeleteProxy(object sender, EntityEventArgs args)
            {
                EventHandler <MovieReview, EntityEventArgs> handler = onDelete;

                if ((object)handler != null)
                {
                    handler.Invoke((MovieReview)sender, args);
                }
            }
Example #11
0
            private void onNewProxy(object sender, EntityEventArgs args)
            {
                EventHandler <SpecialOffer, EntityEventArgs> handler = onNew;

                if ((object)handler != null)
                {
                    handler.Invoke((SpecialOffer)sender, args);
                }
            }
Example #12
0
            private void onDeleteProxy(object sender, EntityEventArgs args)
            {
                EventHandler <ProductProductPhoto, EntityEventArgs> handler = onDelete;

                if ((object)handler != null)
                {
                    handler.Invoke((ProductProductPhoto)sender, args);
                }
            }
            private void onNewProxy(object sender, EntityEventArgs args)
            {
                EventHandler <EmployeeDepartmentHistory, EntityEventArgs> handler = onNew;

                if ((object)handler != null)
                {
                    handler.Invoke((EmployeeDepartmentHistory)sender, args);
                }
            }
Example #14
0
            private void onDeleteProxy(object sender, EntityEventArgs args)
            {
                EventHandler <Department, EntityEventArgs> handler = onDelete;

                if ((object)handler != null)
                {
                    handler.Invoke((Department)sender, args);
                }
            }
Example #15
0
            private void onNewProxy(object sender, EntityEventArgs args)
            {
                EventHandler <ProductDescription, EntityEventArgs> handler = onNew;

                if ((object)handler != null)
                {
                    handler.Invoke((ProductDescription)sender, args);
                }
            }
Example #16
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <Illustration, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((Illustration)sender, args);
                }
            }
        /// <inheritdoc />
        public void SendEntityNetworkMessage(IEntity entity, EntityEventArgs message)
        {
            var msg = _network.CreateNetMessage <MsgEntity>();

            msg.Type          = EntityMessageType.EntityMessage;
            msg.EntityUid     = entity.Uid;
            msg.EntityMessage = message;
            _network.ClientSendMessage(msg);
        }
Example #18
0
            private void onDeleteProxy(object sender, EntityEventArgs args)
            {
                EventHandler <SalesReason, EntityEventArgs> handler = onDelete;

                if ((object)handler != null)
                {
                    handler.Invoke((SalesReason)sender, args);
                }
            }
Example #19
0
            private void onNewProxy(object sender, EntityEventArgs args)
            {
                EventHandler <Genre, EntityEventArgs> handler = onNew;

                if ((object)handler != null)
                {
                    handler.Invoke((Genre)sender, args);
                }
            }
Example #20
0
            private void onNewProxy(object sender, EntityEventArgs args)
            {
                EventHandler <TransactionHistoryArchive, EntityEventArgs> handler = onNew;

                if ((object)handler != null)
                {
                    handler.Invoke((TransactionHistoryArchive)sender, args);
                }
            }
Example #21
0
 /// <summary>
 /// Sets initial ground level of an entity to its y-attribute. This is as when just added the entity the
 /// client may not yet have determined the ground level (as no ray was cast). To avoid setting the entity
 /// to a wrong level, it is just kept where it is until the first ray is cast
 /// </summary>
 /// <param name="sender">The World</param>
 /// <param name="e">Entity Added event arguments</param>
 private void HandleEntityAdded(Object sender, EntityEventArgs e)
 {
     if (e.Entity.ContainsComponent("avatar"))
     {
         // Initialise entities without gravity
         float initialGroundlevel = ((Vector)e.Entity["location"]["position"].Value).y;
         e.Entity["avatarCollision"]["groundLevel"].Suggest(initialGroundlevel);
     }
 }
Example #22
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <TransactionHistory, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((TransactionHistory)sender, args);
                }
            }
Example #23
0
        private void Entity_OnAddAfterCommit(object sender, EntityEventArgs e)
        {
            var intercepts = e.Entity.Intercepts.Where(x => x.Metadata.Stage == Stage.OnAddAfterCommit).OrderBy(x => x.Metadata.Order);

            foreach (var intercept in intercepts)
            {
                intercept.Intercept.Execute(e.Entity, e.DataService);
            }
        }
Example #24
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <ShoppingCartItem, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((ShoppingCartItem)sender, args);
                }
            }
Example #25
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <Vendor, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((Vendor)sender, args);
                }
            }
Example #26
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <ProductCategory, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((ProductCategory)sender, args);
                }
            }
Example #27
0
            private void onSaveProxy(object sender, EntityEventArgs args)
            {
                EventHandler <EmployeePayHistory, EntityEventArgs> handler = onSave;

                if ((object)handler != null)
                {
                    handler.Invoke((EmployeePayHistory)sender, args);
                }
            }
Example #28
0
        private void OnRemoveEntity(EntityEventArgs args)
        {
            var unit = args.Entity as Unit;

            if (unit != null)
            {
                attacks.Remove(unit);
            }
        }
Example #29
0
        /// <summary>
        ///     The object manager on remove entity.
        /// </summary>
        /// <param name="args">
        ///     The args.
        /// </param>
        private static void ObjectMgr_OnRemoveEntity(EntityEventArgs args)
        {
            var tree = args.Entity as Tree;

            if (tree != null)
            {
                all.Remove(tree);
            }
        }
        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);
        }
Example #31
0
            private void onNewProxy(object sender, EntityEventArgs args)
            {
                EventHandler <Restaurant, EntityEventArgs> handler = onNew;

                if ((object)handler != null)
                {
                    handler.Invoke((Restaurant)sender, args);
                }
            }
Example #32
0
        private void OnAddEntity(EntityEventArgs args)
        {
            try
            {
                var unit = args.Entity as Unit;
                if (unit == null || unit.Team == this.allyTeam)
                {
                    return;
                }

                if (this.abilityData.Units.TryGetValue(unit.Name, out var data))
                {
                    data.AddDrawableAbility(this.drawableAbilities, unit, this.notificationsEnabled ? this.notificator : null);
                }
                else
                {
                    if (unit.NetworkName != "CDOTA_BaseNPC")
                    {
                        return;
                    }

                    var vision = unit.DayVision;
                    if (vision <= 0)
                    {
                        return;
                    }

                    var ids = this.abilityData.AbilityUnitVision.Where(x => x.Value.Vision == unit.DayVision)
                              .ToDictionary(x => x.Key, x => x.Value);
                    var abilities = EntityManager9.Abilities.Where(
                        x => x.Owner.Team != this.allyTeam && x.Owner.CanUseAbilities && ids.ContainsKey(x.Id) &&
                        (!x.Owner.IsVisible || x.TimeSinceCasted < 0.5f + x.ActivationDelay))
                                    .ToList();

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

                    if (!ids.TryGetValue(abilities[0].Id, out data))
                    {
                        return;
                    }

                    data.AddDrawableAbility(
                        this.drawableAbilities,
                        abilities[0],
                        unit,
                        this.notificationsEnabled ? this.notificator : null);
                }
            }
            catch (Exception e)
            {
                Logger.Error(e);
            }
        }
Example #33
0
        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);
        }
Example #34
0
        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));
                    });
        }
Example #35
0
 private void ObjectManager_OnRemoveEntity(EntityEventArgs args)
 {
     predictions.OnRemoveEntity(args);
 }
 void mModel_OnEntityRemoved(object sender, EntityEventArgs e)
 {
     RaiseOnEntityRemoved(e);
 }
Example #37
0
 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);
 }
Example #38
0
 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();
 }
Example #39
0
 void Model_OnEntityAdded(object sender, EntityEventArgs e)
 {
 }
Example #40
0
		protected virtual void OnEntityRemoved(EntityEventArgs e)
		{
			if (EntityRemoved != null)
				EntityRemoved(this, e);
			OnModified(EventArgs.Empty);
		}
    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);
      }
    }
Example #42
0
 private static void onDelete(EntityEventArgs args)
 {
 }
 // ------------------------------------------------------------------
 /// <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);
   }
 }
Example #44
0
 /// <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);
 }
Example #45
0
 private void ObjectManager_OnRemoveEntity(EntityEventArgs args)
 {
     lastHitMarker.OnRemoveEntity(args);
 }
Example #46
0
        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);
        }
 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();
 }
 public void RaiseOnClick(EntityEventArgs e)
 {
     if (OnClick != null)
         OnClick(this, e);
 }
    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));
        }
      }
    }
 protected internal void RaiseOnChange(object sender, EntityEventArgs e)
 {
     if (OnEntityChange != null)
         OnEntityChange(sender, e);
 }
 /// <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);
 }
 protected internal void RaiseOnSelect(object sender, EntityEventArgs e)
 {
     if (OnEntitySelect != null)
         OnEntitySelect(sender, e);
 }
Example #53
0
 /// <summary>
 ///     The object mgr_ on add entity.
 /// </summary>
 /// <param name="args">
 ///     The args.
 /// </param>
 private void ObjectMgr_OnAddEntity(EntityEventArgs args)
 {
     DelayAction.Add(
         2000, 
         () =>
             {
                 var hero = args.Entity as Hero;
                 if (hero != null)
                 {
                     this.SetHeroTogglers();
                 }
             });
 }
Example #54
0
        public static void ObjectMgr_OnRemoveEntity(EntityEventArgs args)
        {
            try
            {
                var a = args.Entity;
                if (a == null || NameManager.Name(a) == null || MainMenu.Menu == null)
                {
                    return;
                }

                var name = NameManager.Name(a);
                var data = AbilityDatabase.Find(name);
                if (data == null || a.Owner == null || !a.Owner.Equals(AbilityMain.Me))
                {
                    return;
                }

                MainMenu.ComboKeysMenu.Item("comboAbilitiesToggler").GetValue<AbilityToggler>().Remove(name);

                // if (AbilityMain.Me.ClassID == ClassID.CDOTA_Unit_Hero_Rubick)
                // {
                // if (!Rubick.MyCdDictionary.ContainsKey(name))
                // {
                // Rubick.MyCdDictionary.Add(name, Environment.TickCount + ((a as Ability).Cooldown * 1000));
                // }
                // }
                RangeDrawing.RemoveRange(a as Ability);
                if (data.IsPurge || data.WeakensEnemy || data.TrueSight)
                {
                    MainMenu.Menu.Item("specialsToggler").GetValue<AbilityToggler>().Remove(name);
                    Specials.SpecialsMenuDictionary.Remove(name);
                    Specials.SpecialsMenu.RemoveSubMenu(name);
                    MyAbilities.OffensiveAbilities.Remove(name + "special");
                }

                if (data.IsBuff)
                {
                    MainMenu.Menu.Item("buffsToggler").GetValue<AbilityToggler>().Remove(name);
                    Buffs.BuffsMenuDictionary.Remove(name);
                    Buffs.BuffsMenu.RemoveSubMenu(name);
                    MyAbilities.OffensiveAbilities.Remove(name + "buff");
                }

                if (data.IsNuke)
                {
                    MainMenu.Menu.Item("nukesToggler").GetValue<AbilityToggler>().Remove(name);
                    Nukes.NukesMenuDictionary.Remove(name);
                    Nukes.NukesMenu.RemoveSubMenu(name);
                    MyAbilities.OffensiveAbilities.Remove(name + "nuke");
                }

                if (data.IsDisable)
                {
                    MainMenu.Menu.Item("disablesToggler").GetValue<AbilityToggler>().Remove(name);
                    Disables.DisablesMenuDictionary.Remove(name);
                    Disables.DisablesMenu.RemoveSubMenu(name);
                    MyAbilities.OffensiveAbilities.Remove(name + "disable");
                }

                if (data.IsSlow)
                {
                    MainMenu.Menu.Item("slowsToggler").GetValue<AbilityToggler>().Remove(name);
                    Slows.SlowsMenuDictionary.Remove(name);
                    Slows.SlowsMenu.RemoveSubMenu(name);
                    MyAbilities.OffensiveAbilities.Remove(name + "slow");
                }

                if (data.IsHarras)
                {
                    MainMenu.Menu.Item("harrasesToggler").GetValue<AbilityToggler>().Remove(name);
                    Harrases.HarrasesMenuDictionary.Remove(name);
                    Harrases.HarrasesMenu.RemoveSubMenu(name);
                    MyAbilities.OffensiveAbilities.Remove(name + "harras");
                }

                if (data.IsSilence)
                {
                    MainMenu.Menu.Item("silencesToggler").GetValue<AbilityToggler>().Remove(name);
                    Silences.SilencesMenuDictionary.Remove(name);
                    Silences.SilencesMenu.RemoveSubMenu(name);
                    MyAbilities.OffensiveAbilities.Remove(name + "silence");
                }

                if (data.IsHeal)
                {
                    MainMenu.Menu.Item("healsToggler").GetValue<AbilityToggler>().Remove(name);
                    Heals.HealsMenuDictionary.Remove(name);
                    Heals.HealsMenu.RemoveSubMenu(name);
                    MyAbilities.DeffensiveAbilities.Remove(name + "heal");
                }

                if (data.IsShield)
                {
                    MainMenu.Menu.Item("shieldsToggler").GetValue<AbilityToggler>().Remove(name);
                    Shields.ShieldsMenuDictionary.Remove(name);
                    Shields.ShieldsMenu.RemoveSubMenu(name);
                    MyAbilities.DeffensiveAbilities.Remove(name + "shield");
                }
            }
            catch (Exception)
            {
                // e.GetBaseException();
            }
        }
Example #55
0
 void HandleTaskAdded(object sender, EntityEventArgs<Task> e)
 {
     Items.Add(CreateItemViewModel(e.Entity));
 }
Example #56
0
 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);
     }
 }
Example #57
0
 protected virtual void RaiseOnEntityRemoved(EntityEventArgs e)
 {
     EventHandler<EntityEventArgs> handler = OnEntityRemoved;
     if (handler != null)
     {
         handler(this, e);
     }
 }
Example #58
0
        /// <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);
            }
        }
Example #59
0
 void mDefaultPage_OnEntityRemoved(object sender, EntityEventArgs e)
 {
     if(mPaintables.Contains(e.Entity))
     {
         //shift the entities above the one to be removed
         int index = e.Entity.SceneIndex;
         foreach(IDiagramEntity entity in mPaintables)
         {
             if(entity.SceneIndex > index)
                 entity.SceneIndex--;
         }
         mPaintables.Remove(e.Entity);
     }
     //if the selection contains the shape we have to remove it from the selection
     if (Selection.SelectedItems.Contains(e.Entity))
     {
         Selection.SelectedItems.Remove(e.Entity);
     }
     RaiseOnEntityRemoved(e);
 }
Example #60
0
 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);
     }
 }