/// <summary> /// When overridden in the derived class, handles performing drawing before the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="imap">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap imap) { base.HandleBeforeDrawMapGUI(spriteBatch, imap); if (!IsEnabled) { return; } if (IsSelecting) { return; } if ((Control.ModifierKeys & _placeLightKey) != 0) { if (imap == _mouseOverMap) { var lightSprite = SystemSprites.Lightblub; var pos = _mousePos - (lightSprite.Size / 2f); pos = GridAligner.Instance.Align(pos); lightSprite.Draw(spriteBatch, pos); } } }
/// <summary> /// Handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> containing the drawing event arguments.</param> void IMapDrawingExtension.DrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (!Enabled) return; if (map == null) { Debug.Fail("map is null."); return; } if (e.SpriteBatch == null) { Debug.Fail("spriteBatch is null."); return; } if (e.Camera == null) { Debug.Fail("camera is null."); return; } Debug.Assert(EnumHelper<MapRenderLayer>.IsDefined(e.Layer), "Invalid layer specified."); Debug.Assert(!e.SpriteBatch.IsDisposed, "spriteBatch is disposed."); HandleDrawAfterLayer(map, e); }
/// <summary> /// Handles drawing to the map before any layers are drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="DrawableMapDrawEventArgs"/> containing the drawing event arguments.</param> void IMapDrawingExtension.DrawBeforeMap(IDrawableMap map, DrawableMapDrawEventArgs e) { if (!Enabled) { return; } if (map == null) { Debug.Fail("map is null."); return; } if (e.SpriteBatch == null) { Debug.Fail("spriteBatch is null."); return; } if (e.Camera == null) { Debug.Fail("camera is null."); return; } Debug.Assert(!e.SpriteBatch.IsDisposed, "spriteBatch is disposed."); HandleDrawBeforeMap(map, e.SpriteBatch, e.Camera); }
public static void DrawSpawn(MapSpawnValues spawn, ISpriteBatch spriteBatch, IDrawableMap map, Font font) { var spawnArea = spawn.SpawnArea; // Only draw if it does not cover the whole map if (!spawnArea.X.HasValue && !spawnArea.Y.HasValue && !spawnArea.Width.HasValue && !spawnArea.Height.HasValue) { return; } // Draw spawn area Vector2 cameraOffset = map.Camera.Min; Rectangle rect = spawnArea.ToRectangle(map); rect.X -= (int)cameraOffset.X; rect.Y -= (int)cameraOffset.Y; RenderRectangle.Draw(spriteBatch, rect, new Color(0, 255, 0, 75), new Color(0, 0, 0, 125), 2); // Draw name CharacterTemplate charTemp = CharacterTemplateManager.Instance[spawn.CharacterTemplateID]; if (charTemp != null) { string text = string.Format("{0}x {1} [{2}]", spawn.SpawnAmount, charTemp.TemplateTable.Name, spawn.CharacterTemplateID); Vector2 textPos = new Vector2(rect.X, rect.Y); textPos -= new Vector2(0, font.MeasureString(text).Y); textPos = textPos.Round(); spriteBatch.DrawStringShaded(font, text, textPos, Color.White, Color.Black); } }
public static void DrawSpawn(MapSpawnValues spawn, ISpriteBatch spriteBatch, IDrawableMap map, Font font) { var spawnArea = spawn.SpawnArea; // Only draw if it does not cover the whole map if (!spawnArea.X.HasValue && !spawnArea.Y.HasValue && !spawnArea.Width.HasValue && !spawnArea.Height.HasValue) return; // Draw spawn area Vector2 cameraOffset = map.Camera.Min; Rectangle rect = spawnArea.ToRectangle(map); rect.X -= (int)cameraOffset.X; rect.Y -= (int)cameraOffset.Y; RenderRectangle.Draw(spriteBatch, rect, new Color(0, 255, 0, 75), new Color(0, 0, 0, 125), 2); // Draw name CharacterTemplate charTemp = CharacterTemplateManager.Instance[spawn.CharacterTemplateID]; if (charTemp != null) { string text = string.Format("{0}x {1} [{2}]", spawn.SpawnAmount, charTemp.TemplateTable.Name, spawn.CharacterTemplateID); Vector2 textPos = new Vector2(rect.X, rect.Y); textPos -= new Vector2(0, font.MeasureString(text).Y); textPos = textPos.Round(); spriteBatch.DrawStringShaded(font, text, textPos, Color.White, Color.Black); } }
/// <summary> /// When overridden in the derived class, handles performing drawing after the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { base.HandleAfterDrawMapGUI(spriteBatch, map); if (!IsEnabled) { return; } if (map != _mouseOverMap) { return; } var grh = GlobalState.Instance.Map.GrhToPlace; var worldPos = map.Camera.ToWorld(_mousePos); var drawPos = worldPos - map.Camera.Min; if (!Input.IsCtrlDown) { drawPos = GridAligner.Instance.Align(drawPos, true).Round(); } if (Input.IsShiftDown) { // Display tooltip of what would be selected var grhToSelect = MapGrhPencilTool.GetGrhToSelect(map, worldPos); MapGrhPencilTool.DrawMapGrhTooltip(spriteBatch, map, grhToSelect, worldPos); } else { grh.Update(map.GetTime()); grh.Draw(spriteBatch, drawPos, new Color(255, 255, 255, 180)); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { var msc = MapScreenControl.TryFindInstance(map); if (msc == null) { return; } var dm = msc.DrawingManager; if (dm == null) { return; } var lm = dm.LightManager; if (lm == null) { return; } var lightSprite = SystemSprites.Lightblub; var offset = lightSprite.Size / 2f; foreach (var light in lm) { lightSprite.Draw(spriteBatch, light.Center - offset); } }
/// <summary> /// Handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> containing the drawing event arguments.</param> void IMapDrawingExtension.DrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (!Enabled) { return; } if (map == null) { Debug.Fail("map is null."); return; } if (e.SpriteBatch == null) { Debug.Fail("spriteBatch is null."); return; } if (e.Camera == null) { Debug.Fail("camera is null."); return; } Debug.Assert(EnumHelper <MapRenderLayer> .IsDefined(e.Layer), "Invalid layer specified."); Debug.Assert(!e.SpriteBatch.IsDisposed, "spriteBatch is disposed."); HandleDrawAfterLayer(map, e); }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (e.Layer == MapRenderLayer.Chararacter) { _displayManager.Draw(e.SpriteBatch); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { // Draw emoticons after dynamic layer finishes if (e.Layer == MapRenderLayer.Dynamic) { _displayManager.Draw(e.SpriteBatch); } }
/// <summary> /// Notifies the <see cref="Tool"/> before a <see cref="IDrawableMap"/>'s GUI was drawn. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> internal void InvokeBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { if (IsDisposed) { return; } HandleBeforeDrawMapGUI(spriteBatch, map); }
/// <summary> /// Notifies the <see cref="Tool"/> after a <see cref="IDrawableMap"/>'s GUI was drawn. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> internal void InvokeAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { if (!IsEnabled || IsDisposed) { return; } HandleAfterDrawMapGUI(spriteBatch, map); }
/// <summary> /// Handles the <see cref="IDrawableMap.BeginDrawMap"/> event from the current map. /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawEventArgs"/> instance containing the event data.</param> void BeginDrawMapCallback(IDrawableMap sender, DrawableMapDrawEventArgs e) { Debug.Assert(Map == sender, "How did we get an event from the wrong map?"); Debug.Assert(e.SpriteBatch != null && !e.SpriteBatch.IsDisposed); foreach (var extension in _extensions) { extension.DrawBeforeMap(sender, e); } }
/// <summary> /// Handles the <see cref="IDrawableMap.EndDrawMapLayer"/> event from the current map. /// </summary> /// <param name="map">The map.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> void EndDrawMapLayerCallback(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { Debug.Assert(Map == map, "How did we get an event from the wrong map?"); Debug.Assert(e.SpriteBatch != null && !e.SpriteBatch.IsDisposed); foreach (var extension in _extensions) { extension.DrawAfterLayer(map, e); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { var p = Parent; if (p == null) { return; } // Ensure the map is valid var clientMap = map as EditorMap; if (clientMap == null) { return; } var viewArea = camera.GetViewArea(); // Draw the walls if (p.DrawWalls) { var visibleWalls = map.Spatial.GetMany <WallEntityBase>(viewArea); foreach (var wall in visibleWalls) { EntityDrawer.Draw(spriteBatch, camera, wall); } } // Draw the MapGrh walls if (p.DrawMapGrhWalls) { var mapGrhWalls = GlobalState.Instance.MapGrhWalls; var toDraw = clientMap.Spatial.GetMany <MapGrh>(viewArea); var tmpWall = new WallEntity(Vector2.Zero, Vector2.Zero); foreach (var mg in toDraw) { var boundWalls = mapGrhWalls[mg.Grh.GrhData]; if (boundWalls == null) { continue; } foreach (var wall in boundWalls) { tmpWall.Size = wall.Size != Vector2.Zero ? wall.Size * mg.Scale : mg.Size; tmpWall.Position = mg.Position + (wall.Position * mg.Scale); tmpWall.IsPlatform = wall.IsPlatform; EntityDrawer.Draw(spriteBatch, camera, tmpWall); } } } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (e.Layer != MapRenderLayer.SpriteForeground) return; var visibleArea = e.Camera.GetViewArea(); var visibleWalls = map.Spatial.GetMany<WallEntityBase>(visibleArea); foreach (var wall in visibleWalls) { EntityDrawer.Draw(e.SpriteBatch, e.Camera, wall); } }
/// <summary> /// When overridden in the derived class, handles performing drawing before the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="imap">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap imap) { base.HandleBeforeDrawMapGUI(spriteBatch, imap); if (!IsEnabled) { return; } var map = imap as EditorMap; if (map == null) { return; } var camera = map.Camera; if (camera == null) { return; } // Only draw for the map under the cursor if (map != _mouseOverMap) { return; } if (IsSelecting) { // Draw the selection area var a = camera.ToScreen(_selectionStart); var b = camera.ToScreen(_selectionEnd); if (a.QuickDistance(b) > _minSelectionAreaDrawSize) { var rect = Rectangle.FromPoints(a, b); RenderRectangle.Draw(spriteBatch, rect, _selectionAreaColorInner, _selectionAreaColorOuter); } } else { // Draw the tooltip var font = ToolTipFont; if (_toolTipObject != null && _toolTip != null && font != null) { spriteBatch.DrawStringShaded(font, _toolTip, _toolTipPos, Color.White, Color.Black); } } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (e.Layer != MapRenderLayer.SpriteForeground) return; if (MapSpawns == null) return; foreach (var item in MapSpawns) { var rect = item.SpawnArea.ToRectangle(map); if (e.Camera.InView(rect)) RenderRectangle.Draw(e.SpriteBatch, rect, _drawColor); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (e.Layer != MapRenderLayer.SpriteForeground) { return; } var visibleArea = e.Camera.GetViewArea(); var visibleWalls = map.Spatial.GetMany <WallEntityBase>(visibleArea); foreach (var wall in visibleWalls) { EntityDrawer.Draw(e.SpriteBatch, e.Camera, wall); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { var p = Parent; if (p == null) { return; } // Ensure the map is valid var clientMap = map as EditorMap; if (clientMap == null) { return; } var viewArea = camera.GetViewArea(); // Draw the walls if (p.DrawWalls) { var visibleWalls = map.Spatial.GetMany <WallEntityBase>(viewArea); foreach (var wall in visibleWalls) { EntityDrawer.Draw(spriteBatch, camera, wall); } } // Draw the MapGrh walls if (p.DrawMapGrhWalls) { var toDraw = clientMap.Spatial.GetMany <MapGrh>(viewArea); foreach (var mg in toDraw) { var boundWalls = GlobalState.Instance.MapGrhWalls[mg.Grh.GrhData]; if (boundWalls == null) { continue; } foreach (var wall in boundWalls) { EntityDrawer.Draw(spriteBatch, camera, wall, mg.Position); } } } }
/// <summary> /// Notifies the <see cref="Tool"/>s in this <see cref="ToolManager"/> about the corresponding event. /// It is the responsibility of the application to make sure this method is called at the appropriate time. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/>.</param> /// <param name="map">The <see cref="IDrawableMap"/>.</param> /// <exception cref="ArgumentNullException"><paramref name="spriteBatch"/> is null.</exception> /// <exception cref="ArgumentNullException"><paramref name="map"/> is null.</exception> public void InvokeBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { if (spriteBatch == null) { throw new ArgumentNullException("spriteBatch"); } if (map == null) { throw new ArgumentNullException("map"); } foreach (var t in EnabledTools) { t.InvokeBeforeDrawMapGUI(spriteBatch, map); } }
public static bool DrawMapGrhTooltip(ISpriteBatch spriteBatch, IDrawableMap map, MapGrh mapGrh, Vector2 worldPos) { if (mapGrh == null || mapGrh.Grh == null || mapGrh.Grh.GrhData == null) { return(false); } Vector2 drawPos = worldPos - map.Camera.Min; var font = GlobalState.Instance.DefaultRenderFont; string txt = mapGrh.Grh.GrhData.Categorization.ToString(); Vector2 txtSize = font.MeasureString(txt); Vector2 txtPos = drawPos.Max(Vector2.Zero).Min(map.Camera.Size - txtSize); spriteBatch.DrawStringShaded(font, txt, txtPos, Color.White, Color.Black); return(true); }
/// <summary> /// When overridden in the derived class, handles performing drawing after the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { base.HandleAfterDrawMapGUI(spriteBatch, map); if (_form == null || !_form.Visible) return; // Draw spawns var spawns = _form.GetMapSpawns(); if (spawns != null) { var font = GlobalState.Instance.DefaultRenderFont; foreach (var spawn in spawns) { EditorEntityDrawer.DrawSpawn(spawn, spriteBatch, map, font); } } }
/// <summary> /// When overridden in the derived class, handles performing drawing after the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { base.HandleAfterDrawMapGUI(spriteBatch, map); if (map != _mouseOverMap) { return; } if ((Control.ModifierKeys & _placeMapGrhKey) == 0) { return; } var grh = GlobalState.Instance.Map.GrhToPlace; grh.Draw(spriteBatch, GridAligner.Instance.Align(_mousePos, TileMode)); }
/// <summary> /// Gets the MapGrh to select at the given position. /// </summary> /// <param name="map">The map.</param> /// <param name="worldPos">The world position.</param> /// <param name="mustBeOnLayer">If not null, then only return a MapGrh on the specified layer.</param> /// <returns>The best MapGrh to be selected, or null if none found.</returns> public static MapGrh GetGrhToSelect(IDrawableMap map, Vector2 worldPos, MapRenderLayer?mustBeOnLayer = null) { // Get all MapGrhs as the position var mapGrhs = map.Spatial.GetMany <MapGrh>(worldPos); // Filter layer if (mustBeOnLayer.HasValue) { mapGrhs = mapGrhs.Where(x => x.MapRenderLayer == mustBeOnLayer.Value); } // Prioritize by draw order & distance from origin, then take the first mapGrhs = mapGrhs .OrderByDescending(x => (int)x.MapRenderLayer) .ThenByDescending(x => x.LayerDepth) .ThenBy(x => worldPos.QuickDistance(x.Position)); return(mapGrhs.FirstOrDefault()); }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (e.Layer != MapRenderLayer.SpriteForeground) return; // Get the visible area var visibleArea = e.Camera.GetViewArea(); // Get and draw all entities, skipping those that we will never draw () and those that // we will always draw (_alwaysDrawTypes) var toDraw = map.Spatial.GetMany<Entity>(visibleArea, GetEntitiesToDrawFilter); // Add the entities we will always draw toDraw = toDraw.Concat(map.Spatial.GetMany<Entity>(GetEntitiesToAlwaysDrawFilter)); // Draw foreach (var entity in toDraw) { EntityDrawer.Draw(e.SpriteBatch, e.Camera, entity); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (e.Layer != MapRenderLayer.SpriteForeground) { return; } if (MapSpawns == null) { return; } foreach (var item in MapSpawns) { var rect = item.SpawnArea.ToRectangle(map); if (e.Camera.InView(rect)) { RenderRectangle.Draw(e.SpriteBatch, rect, _drawColor); } } }
/// <summary> /// When overridden in the derived class, handles performing drawing after the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { base.HandleAfterDrawMapGUI(spriteBatch, map); if (_form == null || !_form.Visible) { return; } // Draw spawns var spawns = _form.GetMapSpawns(); if (spawns != null) { var font = GlobalState.Instance.DefaultRenderFont; foreach (var spawn in spawns) { EditorEntityDrawer.DrawSpawn(spawn, spriteBatch, map, font); } } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { var msc = MapScreenControl.TryFindInstance(map); if (msc == null) return; var dm = msc.DrawingManager; if (dm == null) return; var lm = dm.LightManager; if (lm == null) return; var lightSprite = SystemSprites.Lightblub; var offset = lightSprite.Size / 2f; foreach (var light in lm) { lightSprite.Draw(spriteBatch, light.Center - offset); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { if (e.Layer != MapRenderLayer.SpriteForeground) { return; } // Get the visible area var visibleArea = e.Camera.GetViewArea(); // Get and draw all entities, skipping those that we will never draw () and those that // we will always draw (_alwaysDrawTypes) var toDraw = map.Spatial.GetMany <Entity>(visibleArea, GetEntitiesToDrawFilter); // Add the entities we will always draw toDraw = toDraw.Concat(map.Spatial.GetMany <Entity>(GetEntitiesToAlwaysDrawFilter)); // Draw foreach (var entity in toDraw) { EntityDrawer.Draw(e.SpriteBatch, e.Camera, entity); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { _grid.Size = EditorSettings.Default.GridSize; _grid.Draw(spriteBatch, camera); }
/// <summary> /// When overridden in the derived class, handles drawing to the map before any of the map drawing starts. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected virtual void HandleDrawBeforeMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { }
/// <summary> /// When overridden in the derived class, handles performing drawing before the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected virtual void HandleBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { }
/// <summary> /// Handles drawing to the map before any layers are drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="DrawableMapDrawEventArgs"/> containing the drawing event arguments.</param> void IMapDrawingExtension.DrawBeforeMap(IDrawableMap map, DrawableMapDrawEventArgs e) { if (!Enabled) return; if (map == null) { Debug.Fail("map is null."); return; } if (e.SpriteBatch == null) { Debug.Fail("spriteBatch is null."); return; } if (e.Camera == null) { Debug.Fail("camera is null."); return; } Debug.Assert(!e.SpriteBatch.IsDisposed, "spriteBatch is disposed."); HandleDrawBeforeMap(map, e.SpriteBatch, e.Camera); }
/// <summary> /// When overridden in the derived class, handles drawing to the map before the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected virtual void HandleDrawBeforeLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { }
/// <summary> /// When overridden in the derived class, handles performing drawing after the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { base.HandleAfterDrawMapGUI(spriteBatch, map); if (!IsEnabled) return; if (map != _mouseOverMap) return; var grh = GlobalState.Instance.Map.GrhToPlace; var worldPos = map.Camera.ToWorld(_mousePos); var drawPos = worldPos - map.Camera.Min; if (!Input.IsCtrlDown) drawPos = GridAligner.Instance.Align(drawPos, true).Round(); if (Input.IsShiftDown) { // Display tooltip of what would be selected var grhToSelect = MapGrhPencilTool.GetGrhToSelect(map, worldPos); MapGrhPencilTool.DrawMapGrhTooltip(spriteBatch, map, grhToSelect, worldPos); } else { grh.Update(map.GetTime()); grh.Draw(spriteBatch, drawPos, new Color(255, 255, 255, 180)); } }
/// <summary> /// When overridden in the derived class, handles drawing to the map after the given <see cref="MapRenderLayer"/> is drawn. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="e">The <see cref="NetGore.Graphics.DrawableMapDrawLayerEventArgs"/> instance containing the event data.</param> protected override void HandleDrawAfterLayer(IDrawableMap map, DrawableMapDrawLayerEventArgs e) { // Draw after dynamic layer finishes if (e.Layer != MapRenderLayer.Dynamic) { return; } // Update the valid sprites var currentTime = map.GetTime(); if (QuestStartedIndicator != null) { QuestStartedIndicator.Update(currentTime); } if (QuestTurnInIndicator != null) { QuestTurnInIndicator.Update(currentTime); } if (QuestAvailableCannotStartIndicator != null) { QuestAvailableCannotStartIndicator.Update(currentTime); } if (QuestAvailableCanStartIndicator != null) { QuestAvailableCanStartIndicator.Update(currentTime); } // Get all the quest providers in the area of interest (visible area) foreach (var c in _getQuestProviders(map)) { // Get the provided quests we have not completed or if it's repeatable var incomplete = _getQuests(c).Where(x => !QuestInfo.CompletedQuests.Contains(x) || QuestInfo.RepeatableQuests.Contains(x)).ToImmutable(); // If they don't have any quests, continue if (incomplete.IsEmpty()) { continue; } // For each of the four indicators, start at the "highest priority" one and stop when we find // the first valid status that we can use if (CheckStatusTurnIn(incomplete)) { IndicatorDrawer(QuestTurnInIndicator, c, e.SpriteBatch); continue; } else if (CheckStatusCanStart(incomplete)) { IndicatorDrawer(QuestAvailableCanStartIndicator, c, e.SpriteBatch); continue; } else if (CheckStatusStarted(incomplete)) { IndicatorDrawer(QuestStartedIndicator, c, e.SpriteBatch); continue; } else if (CheckStatusCannotStart(incomplete)) { IndicatorDrawer(QuestAvailableCannotStartIndicator, c, e.SpriteBatch); continue; } } }
/// <summary> /// Notifies the <see cref="Tool"/> before a <see cref="IDrawableMap"/>'s GUI was drawn. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> internal void InvokeBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { if (!IsEnabled || IsDisposed) return; HandleBeforeDrawMapGUI(spriteBatch, map); }
/// <summary> /// When overridden in the derived class, handles performing drawing before the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="imap">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap imap) { base.HandleBeforeDrawMapGUI(spriteBatch, imap); var map = imap as EditorMap; if (map == null) return; var camera = map.Camera; if (camera == null) return; // Only draw for the map under the cursor if (map != _mouseOverMap) return; if (IsSelecting) { // Draw the selection area var a = camera.ToScreen(_selectionStart); var b = camera.ToScreen(_selectionEnd); if (a.QuickDistance(b) > _minSelectionAreaDrawSize) { var rect = Rectangle.FromPoints(a, b); RenderRectangle.Draw(spriteBatch, rect, _selectionAreaColorInner, _selectionAreaColorOuter); } } else { // Draw the tooltip var font = ToolTipFont; if (_toolTipObject != null && _toolTip != null && font != null) spriteBatch.DrawStringShaded(font, _toolTip, _toolTipPos, Color.White, Color.Black); } }
public static bool DrawMapGrhTooltip(ISpriteBatch spriteBatch, IDrawableMap map, MapGrh mapGrh, Vector2 worldPos) { if (mapGrh == null || mapGrh.Grh == null || mapGrh.Grh.GrhData == null) return false; Vector2 drawPos = worldPos - map.Camera.Min; var font = GlobalState.Instance.DefaultRenderFont; string txt = mapGrh.Grh.GrhData.Categorization.ToString(); Vector2 txtSize = font.MeasureString(txt); Vector2 txtPos = drawPos.Max(Vector2.Zero).Min(map.Camera.Size - txtSize); spriteBatch.DrawStringShaded(font, txt, txtPos, Color.White, Color.Black); return true; }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { var p = Parent; if (p == null) return; // Ensure the map is valid var clientMap = map as EditorMap; if (clientMap == null) return; var viewArea = camera.GetViewArea(); // Draw the walls if (p.DrawWalls) { var visibleWalls = map.Spatial.GetMany<WallEntityBase>(viewArea); foreach (var wall in visibleWalls) { EntityDrawer.Draw(spriteBatch, camera, wall); } } // Draw the MapGrh walls if (p.DrawMapGrhWalls) { var mapGrhWalls = GlobalState.Instance.MapGrhWalls; var toDraw = clientMap.Spatial.GetMany<MapGrh>(viewArea); var tmpWall = new WallEntity(Vector2.Zero, Vector2.Zero); foreach (var mg in toDraw) { var boundWalls = mapGrhWalls[mg.Grh.GrhData]; if (boundWalls == null) continue; foreach (var wall in boundWalls) { tmpWall.Size = wall.Size != Vector2.Zero ? wall.Size * mg.Scale : mg.Size; tmpWall.Position = mg.Position + (wall.Position * mg.Scale); tmpWall.IsPlatform = wall.IsPlatform; EntityDrawer.Draw(spriteBatch, camera, tmpWall); } } } }
/// <summary> /// Initializes a new instance of the <see cref="TimeDelayedMapEventBase"/> class. /// </summary> /// <param name="map">The <see cref="IDrawableMap"/> to add the <paramref name="mapGrhEffect"/> to.</param> /// <param name="mapGrhEffect">The <see cref="MapGrhEffect"/> to add when the time elapses.</param> /// <param name="delay">The delay in milliseconds before the <paramref name="mapGrhEffect"/> is added to the map.</param> public TimeDelayedMapGrhEffect(IDrawableMap map, MapGrhEffect mapGrhEffect, int delay) : base(delay) { _map = map; _effect = mapGrhEffect; }
/// <summary> /// Gets the MapGrh to select at the given position. /// </summary> /// <param name="map">The map.</param> /// <param name="worldPos">The world position.</param> /// <param name="mustBeOnLayer">If not null, then only return a MapGrh on the specified layer.</param> /// <returns>The best MapGrh to be selected, or null if none found.</returns> public static MapGrh GetGrhToSelect(IDrawableMap map, Vector2 worldPos, MapRenderLayer? mustBeOnLayer = null) { // Get all MapGrhs as the position var mapGrhs = map.Spatial.GetMany<MapGrh>(worldPos); // Filter layer if (mustBeOnLayer.HasValue) mapGrhs = mapGrhs.Where(x => x.MapRenderLayer == mustBeOnLayer.Value); // Prioritize by draw order & distance from origin, then take the first mapGrhs = mapGrhs .OrderByDescending(x => (int)x.MapRenderLayer) .ThenByDescending(x => x.LayerDepth) .ThenBy(x => worldPos.QuickDistance(x.Position)); return mapGrhs.FirstOrDefault(); }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { var p = Parent; if (p == null) return; // Ensure the map is valid var clientMap = map as EditorMap; if (clientMap == null) return; var viewArea = camera.GetViewArea(); // Draw the walls if (p.DrawWalls) { var visibleWalls = map.Spatial.GetMany<WallEntityBase>(viewArea); foreach (var wall in visibleWalls) { EntityDrawer.Draw(spriteBatch, camera, wall); } } // Draw the MapGrh walls if (p.DrawMapGrhWalls) { var toDraw = clientMap.Spatial.GetMany<MapGrh>(viewArea); foreach (var mg in toDraw) { var boundWalls = GlobalState.Instance.MapGrhWalls[mg.Grh.GrhData]; if (boundWalls == null) continue; foreach (var wall in boundWalls) { EntityDrawer.Draw(spriteBatch, camera, wall, mg.Position); } } } }
/// <summary> /// Initializes a new instance of the <see cref="TimeDelayedMapEventBase"/> class. /// </summary> /// <param name="map">The <see cref="IDrawableMap"/> to add the <paramref name="mapGrhEffect"/> to.</param> /// <param name="mapGrhEffect">The <see cref="MapGrhEffect"/> to add when the time elapses.</param> /// <param name="delay">The delay in milliseconds before the <paramref name="mapGrhEffect"/> is added to the map.</param> public TimeDelayedMapGrhEffect(IDrawableMap map, MapGrhEffect mapGrhEffect, int delay) : base(delay) { _map = map; _effect = mapGrhEffect; }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { _grid.Size = EditorSettings.Default.GridSize; _grid.Draw(spriteBatch, camera); }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { _border.Draw(spriteBatch, map, camera); }
/// <summary> /// When overridden in the derived class, handles drawing to the map before any of the map drawing starts. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected virtual void HandleDrawBeforeMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { }
/// <summary> /// When overridden in the derived class, handles performing drawing after the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { base.HandleAfterDrawMapGUI(spriteBatch, map); if (map != _mouseOverMap) return; if ((Control.ModifierKeys & _placeMapGrhKey) == 0) return; var grh = GlobalState.Instance.Map.GrhToPlace; grh.Draw(spriteBatch, GridAligner.Instance.Align(_mousePos, TileMode)); }
/// <summary> /// When overridden in the derived class, handles drawing to the map after all of the map drawing finishes. /// </summary> /// <param name="map">The map the drawing is taking place on.</param> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to draw to.</param> /// <param name="camera">The <see cref="ICamera2D"/> that describes the view of the map being drawn.</param> protected override void HandleDrawAfterMap(IDrawableMap map, ISpriteBatch spriteBatch, ICamera2D camera) { _border.Draw(spriteBatch, map, camera); }
/// <summary> /// When overridden in the derived class, handles performing drawing before the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="imap">The <see cref="IDrawableMap"/> being drawn.</param> protected override void HandleBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap imap) { base.HandleBeforeDrawMapGUI(spriteBatch, imap); if (IsSelecting) return; if ((Control.ModifierKeys & _placeLightKey) != 0) { if (imap == _mouseOverMap) { var lightSprite = SystemSprites.Lightblub; var pos = _mousePos - (lightSprite.Size / 2f); pos = GridAligner.Instance.Align(pos); lightSprite.Draw(spriteBatch, pos); } } }
/// <summary> /// Handles setting up the <see cref="SpriteBatch"/> and drawing the <paramref name="map"/>. This is where /// all the actual drawing to the preview map is done. /// </summary> /// <param name="sb">The <see cref="ISpriteBatch"/> to use for drawing.</param> /// <param name="map">The <see cref="IDrawableMap"/> to draw.</param> protected virtual void DrawMap(ISpriteBatch sb, IDrawableMap map) { sb.Begin(BlendMode.Alpha, map.Camera); map.Draw(sb); sb.End(); }
/// <summary> /// When overridden in the derived class, handles performing drawing before the GUI for a <see cref="IDrawableMap"/> has been draw. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> protected virtual void HandleBeforeDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { }
/// <summary> /// Notifies the <see cref="Tool"/> after a <see cref="IDrawableMap"/>'s GUI was drawn. /// </summary> /// <param name="spriteBatch">The <see cref="ISpriteBatch"/> to use to draw.</param> /// <param name="map">The <see cref="IDrawableMap"/> being drawn.</param> internal void InvokeAfterDrawMapGUI(ISpriteBatch spriteBatch, IDrawableMap map) { if (IsDisposed) return; HandleAfterDrawMapGUI(spriteBatch, map); }