internal void DispatchObjectAdded(DisplayObject target) { if (ObjectAdded != null) { ObjectAdded.Invoke(target); } }
/// <summary> /// Gets the currently selected objects. /// </summary> /// <param name="selectedObjs">The currently selected objects.</param> public void SetManySelected(IEnumerable <T> selectedObjs) { // Check if to clear instead if (selectedObjs == null || selectedObjs.IsEmpty()) { Clear(); return; } selectedObjs = selectedObjs.Distinct().ToImmutable(); // Ignore if we already have this exact set as the current selection if (selectedObjs.ContainSameElements(_selectedObjs)) { return; } // Set the new selected objects and update Clear(); foreach (var obj in selectedObjs) { _selectedObjs.Add(obj); OnObjectAdded(obj); if (ObjectAdded != null) { ObjectAdded.Raise(this, EventArgsHelper.Create(obj)); } } UpdateSelection(); }
/// <summary> /// Gets the currently selected object. /// </summary> /// <param name="selected">The currently selected object.</param> public void SetSelected(T selected) { // Check if to clear instead if (selected == null) { Clear(); return; } // Ignore if we already have this exact set as the current selection if (_selectedObjs.Count == 1 && _selectedObjs[0] == selected) { return; } // Set the new selected objects and update Clear(); _selectedObjs.Add(selected); OnObjectAdded(selected); if (ObjectAdded != null) { ObjectAdded.Raise(this, EventArgsHelper.Create(selected)); } UpdateSelection(); }
/// <summary> /// Sets the focused object. /// </summary> /// <param name="obj">The object to set as focused.</param> /// <param name="addIfMissing">If true, <paramref name="obj"/> will be added to the collection /// if it is not already in it.</param> /// <returns>True if the <paramref name="obj"/> was successfully set as the focused object; otherwise /// false.</returns> public bool SetFocused(T obj, bool addIfMissing = false) { if (obj == null) { return(false); } if (!_selectedObjs.Contains(obj)) { if (!addIfMissing) { return(false); } _selectedObjs.Add(obj); OnObjectAdded(obj); if (ObjectAdded != null) { ObjectAdded.Raise(this, EventArgsHelper.Create(obj)); } } Focused = obj; return(true); }
/// <summary> /// Loads and adds an object to the simulation. /// </summary> /// <param name="object">Object to add to simulation.</param> public void AddObject(SimulationObject @object) { @object.OnLoad(Editor); if (@object is Wall) { objects.Add(@object); } else { objects.Insert(0, @object); } if (@object is ISelectable selectable && selectable.Selectable) { SelectObject(selectable); } if (@object is IPersistent) { ObjectAdded?.Invoke(this, new EventArgs()); } // Cannon test if (@object is Cannon cannon) { cannon.Fired -= CannonFired; cannon.Fired += CannonFired; } }
/// <summary>Invokes <see cref="ObjectAdded"/> and <see cref="CollectionChanged"/> events.</summary> /// <param name="item">Added item.</param> protected virtual void InvokeObjectAdded(TObject item) { Verify.Argument.IsNotNull(item, nameof(item)); ObjectAdded?.Invoke(this, CreateEventArgs(item)); CollectionChanged?.Invoke(this, new NotifyCollectionChangedEventArgs( NotifyCollectionChangedAction.Add, item)); }
public void PlaceObject(string type, TilePos position, Dictionary <string, object> properties = null) { RemoveObject(position); _objects[position] = new PuzzleObject(type, position); if (properties != null) { properties.ToList().ForEach(x => SetProperty(position, x.Key, x.Value)); } ObjectAdded.CallEvent(type, position); }
private void CreateCustomObject() { var obj = new CustomModel(); obj.Config.ID.Generate(); obj.GenerateNewGeolayout(); ButtonItem item; if (ImportNewModel(obj)) { objBank.Models.Add(obj); item = AddItemToList(obj); item.RaiseClick(); ObjectAdded?.Invoke(this, new EventArgs()); } }
/// <summary> /// Sets the terrain at the given objects location to the given object, overwriting any terrain already present there. /// </summary> /// <param name="terrain">Terrain to replace the current terrain with. <paramref name="terrain"/> must have its /// <see cref="IGameObject.IsStatic"/> flag set to true and its <see cref="IHasLayer.Layer"/> must be 0, or an exception will be thrown.</param> public void SetTerrain(IGameObject terrain) { if (terrain.Layer != 0) { throw new ArgumentException($"Terrain for Map must reside on layer 0.", nameof(terrain)); } if (!terrain.IsStatic) { throw new ArgumentException($"Terrain for Map must be marked static via its {nameof(IGameObject.IsStatic)} flag.", nameof(terrain)); } if (terrain.CurrentMap != null) { throw new ArgumentException($"Cannot add terrain to more than one {nameof(Map)}.", nameof(terrain)); } if (!this.Contains(terrain.Position)) { throw new ArgumentException($"Terrain added to map must be within the bounds of that map."); } if (!terrain.IsWalkable) { foreach (var obj in Entities.GetItems(terrain.Position)) { if (!obj.IsWalkable) { throw new Exception("Tried to place non-walkable terrain at a location that already has another non-walkable item."); } } } var oldTerrain = _terrain[terrain.Position]; if (oldTerrain != null) { oldTerrain.OnMapChanged(null); ObjectRemoved?.Invoke(this, new ItemEventArgs <IGameObject>(oldTerrain, oldTerrain.Position)); } _terrain[terrain.Position] = terrain; terrain.OnMapChanged(this); ObjectAdded?.Invoke(this, new ItemEventArgs <IGameObject>(terrain, terrain.Position)); }
public void Insert <T>(T obj) where T : Sprite { if (obj == null) { return; } lock (Generator.Random) { obj.Serial = Generator.GenerateNumber(); } lock (syncLock) { if (obj is Aisling) { _aislings.Add(obj); } if (obj is Monster) { _monsters.Add(obj); } if (obj is Mundane) { _mundanes.Add(obj); } if (obj is Money) { _money.Add(obj); } if (obj is Item) { _items.Add(obj); } ObjectAdded?.Invoke(obj); } }
public static void ChangeMade(int id, Operation operation) { switch (operation) { case Operation.ADD: ObjectAdded?.Invoke(id); break; case Operation.REMOVE: ObjectDeleted?.Invoke(id); break; case Operation.VALUE_CHANGE: ValueChanged?.Invoke(id); break; default: break; } }
/// <summary> /// Adds a new object to the collection of selected objects. /// </summary> /// <param name="obj">The object to add.</param> public void Add(T obj) { if (obj == null) { return; } if (_selectedObjs.Contains(obj)) { return; } _selectedObjs.Add(obj); OnObjectAdded(obj); if (ObjectAdded != null) { ObjectAdded.Raise(this, EventArgsHelper.Create(obj)); } UpdateSelection(); }
public static T CreateNew() { //Edge case where we have not initialized the factory with a prefab. if (prefab == null) { Debug.LogError("Factory must be instantiated before use. No prefab set."); } if (managers.Count == 0) { Debug.LogError($"Factory for {typeof(T).ToString()} must be instantiated before use. No managers added."); } T script; if (cachedObjects.Count > 0) { script = cachedObjects.Dequeue(); script.gameObject.SetActive(true); script.Reset(); } else { var newObj = GameObject.Instantiate(prefab); script = FindScript(newObj); script.Destroyed += Script_Destroyed; } foreach (var manager in managers) { manager.Add(script); } ObjectAdded?.Invoke(script); return(script); }
public bool Add(ISimpleGameObject obj) { if (!AddToPrimaryRegionAndTiles(obj)) { return(false); } // Keeps track of objects that exist in the map obj.InWorld = true; RegisterObjectEventListeners(obj); // Add appropriate objects to the minimap IMiniMapRegionObject miniMapRegionObject = obj as IMiniMapRegionObject; if (miniMapRegionObject != null) { MiniMapRegions.Add(miniMapRegionObject); } // Post to channel ushort regionId = regionLocator.GetRegionIndex(obj); channel.Post("/WORLD/" + regionId, () => { var packet = new Packet(Command.ObjectAdd); packet.AddUInt16(regionId); PacketHelper.AddToPacket(obj, packet); return(packet); }); // Raise event ObjectAdded.Raise(this, new ObjectEvent(obj)); return(true); }
/// <summary> /// Constructor. Constructs map with the given terrain layer, determining width/height based on the width/height of that terrain layer. /// </summary> /// <remarks> /// Because of the way polymorphism works for custom classes in C#, the <paramref name="terrainLayer"/> parameter MUST be of type /// <see cref="ISettableMapView{IGameObject}"/>, rather than <see cref="ISettableMapView{T}"/> where T is a type that derives from or implements /// <see cref="IGameObject"/>. If you need to use a map view storing type T rather than IGameObject, use the /// <see cref="CreateMap{T}(ISettableMapView{T}, int, Distance, uint, uint, uint)"/> function to create the map. /// </remarks> /// <param name="terrainLayer">The <see cref="ISettableMapView{IGameObject}"/> that represents the terrain layer for this map. After the /// map has been created, you should use the <see cref="SetTerrain(IGameObject)"/> function to modify the values in this map view, rather /// than setting the values via the map view itself -- if you re-assign the value at a location via the map view, the /// <see cref="ObjectAdded"/>/<see cref="ObjectRemoved"/> events are NOT guaranteed to be called, and many invariants of map may not be properly /// enforced.</param> /// <param name="numberOfEntityLayers">Number of non-terrain layers for the map.</param> /// <param name="distanceMeasurement"><see cref="Distance"/> measurement to use for pathing/measuring distance on the map.</param> /// <param name="layersBlockingWalkability">Layer mask containing those layers that should be allowed to have items that block walkability. /// Defaults to all layers.</param> /// <param name="layersBlockingTransparency">Layer mask containing those layers that should be allowed to have items that block FOV. /// Defaults to all layers.</param> /// <param name="entityLayersSupportingMultipleItems">Layer mask containing those layers that should be allowed to have multiple objects at the same /// location on the same layer. Defaults to no layers.</param> public Map(ISettableMapView <IGameObject> terrainLayer, int numberOfEntityLayers, Distance distanceMeasurement, uint layersBlockingWalkability = uint.MaxValue, uint layersBlockingTransparency = uint.MaxValue, uint entityLayersSupportingMultipleItems = 0) { _terrain = terrainLayer; Explored = new ArrayMap <bool>(_terrain.Width, _terrain.Height); _entities = new LayeredSpatialMap <IGameObject>(numberOfEntityLayers, 1, entityLayersSupportingMultipleItems); LayersBlockingWalkability = layersBlockingWalkability; LayersBlockingTransparency = layersBlockingTransparency; _entities.ItemAdded += (s, e) => ObjectAdded?.Invoke(this, e); _entities.ItemRemoved += (s, e) => ObjectRemoved?.Invoke(this, e); _entities.ItemMoved += (s, e) => ObjectMoved?.Invoke(this, e); if (layersBlockingTransparency == 1) // Only terrain so we optimize { TransparencyView = new LambdaMapView <bool>(_terrain.Width, _terrain.Height, c => _terrain[c] == null || _terrain[c].IsTransparent); } else { TransparencyView = new LambdaMapView <bool>(_terrain.Width, _terrain.Height, FullIsTransparent); } if (layersBlockingWalkability == 1) // Similar, only terrain blocks, so optimize { WalkabilityView = new LambdaMapView <bool>(_terrain.Width, _terrain.Height, c => _terrain[c] == null || _terrain[c].IsWalkable); } else { WalkabilityView = new LambdaMapView <bool>(_terrain.Width, _terrain.Height, FullIsWalkable); } _fov = new FOV(TransparencyView); AStar = new AStar(WalkabilityView, distanceMeasurement); }
public void OnObjectAdded(Album a) { ObjectAdded?.Invoke(this, new ObjectAddedEventArgs <Album>(a)); }
public static void AddObject(GameObject gameObject) { sceneObjects.Add(gameObject); SceneObjectListChanged?.Invoke(gameObject, new EventArgs()); ObjectAdded?.Invoke(gameObject, new EventArgs()); }