Ejemplo n.º 1
0
        /// <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));
            }
        }
Ejemplo n.º 2
0
        /// <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;
                }
            }
        }