コード例 #1
0
        internal static void IdentifyItem(bool selected = false)
        {
            if (!selected)
            {
                DungeonGameEngine.ProcessMessageQueue(false, "What do you want to identify?");
                currentSelectionAction = SelectionActions.Identify;
            }

            else
            {
                DungeonGameEngine.ProcessMessageQueue(true); // Acknowledge the "What do you want to identify" prompt

                // Get old text before item gets renamed
                var listKey = currentItem.SortingValue;

                // Retrieving this property should cause the item to be identified as well
                DungeonGameEngine.ProcessMessageQueue(false, currentItem.IdentifyText);
                currentSelectionAction = SelectionActions.None;

                // Update inventory list text
                GameText textItem = inventoryList[listKey];
                textItem.Text = currentItem.InventoryTitle;
                inventoryList.Remove(listKey);
                inventoryList.Add(currentItem.SortingValue, textItem);

                closingWindow = true;
            }
        }
コード例 #2
0
ファイル: Monster.cs プロジェクト: jclovis3/DungeonGeek
        /// <summary>
        /// To be called with each new floor, identifies blocked tiles in the pathCounters array with
        /// a value of -1. When hero discovers hidden doors or bashes open locked doors, call this
        /// again to update the map so new routes can be plotted.
        /// </summary>
        internal static void InitializeDistanceMap()
        {
            pathCounters = new int[FloorGenerator.FloorWidth, FloorGenerator.FloorHeight];

            // DEBUG Feature
            if (GameConstants.DEBUG_MODE_DRAW_STEPS_TO_HERO)
            {
                pathCounterText = new GameText[FloorGenerator.FloorWidth, FloorGenerator.FloorHeight];
            }

            for (int x = 0; x < FloorGenerator.FloorWidth; x++)
            {
                for (int y = 0; y < FloorGenerator.FloorHeight; y++)
                {
                    pathCounters[x, y] = unmappedValue;
                    if (!FloorGenerator.TileIsPassible(FloorGenerator.GetTileAt(x, y)))
                    {
                        pathCounters[x, y] = -1;
                    }
                    // DEBUG Feature
                    if (GameConstants.DEBUG_MODE_DRAW_STEPS_TO_HERO)
                    {
                        pathCounterText[x, y] = new GameText(graphicsDevice);
                    }
                }
            }
        }
コード例 #3
0
 /// <summary>
 /// Allows player to rename some items
 /// </summary>
 /// <param name="item">Item to be renamed</param>
 /// <param name="receivedResponse">Result message returned to the player</param>
 private static void Rename(InventoryItem item, bool receivedResponse = false)
 {
     if (!receivedResponse)
     {
         usingRenameItemScreen  = true;
         resetInputWindow       = true;
         RenameItemScreen.Value = string.Empty;
     }
     else
     {
         string itemKey = inventoryList.ElementAt(selectedIndex).Key;
         if (item is INamable)
         {
             GameText gameText = inventoryList[itemKey];
             inventoryList.Remove(itemKey);
             (item as INamable).Rename(response);
             if (item is IWearable)
             {
                 gameText.Text = item.InventoryTitle + (item as IWearable).WornOn;
             }
             else
             {
                 gameText.Text = item.InventoryTitle;
             }
             inventoryList.Add(item.SortingValue, gameText);
         }
         usingRenameItemScreen = false;
     }
 }
コード例 #4
0
        internal static void Initialize(GraphicsDevice gd)
        {
            oldKeyboard = Keyboard.GetState();
            string prompt       = "How shall thou be remembered (enter your name)?";
            string instructions = "Enter - Except     Esc - Cancel";

            window.Initialize(gd, prompt, userResponse, instructions);
            userResponseText = new GameText(gd); // Used solely for measuring text length during input
        }
コード例 #5
0
 internal void Initialize(GraphicsDevice gd, string prompt, StringBuilder userInput, string instructions = "Esc - Exit")
 {
     viewPort = new Viewport();
     if (!initComplete)
     {
         Init(gd);
     }
     firstIndexToShowOnScreen = 0;
     userResponse             = userInput;
     userResponseText         = new GameText(gd);
     instructionText          = new GameText(instructions, new Point(), gd);
     promptText = new GameText(prompt, gd);
 }
コード例 #6
0
 internal void Initialize(GraphicsDevice gd, List <string> listSource, string header = "", string instructions = "Esc - Exit")
 {
     viewPort = new Viewport();
     if (!initComplete)
     {
         Init(gd);
     }
     firstIndexToShowOnScreen = 0;
     if (header != "")
     {
         headerText = new GameText(header, gd);
     }
     instructionText = new GameText(instructions, new Point(), gd);
     bodySource      = listSource;
 }
コード例 #7
0
 internal void Initialize(GraphicsDevice gd, SortedDictionary <string, GameText> sortedListSource, string header = "", string instructions = "Esc - Exit")
 {
     viewPort = new Viewport();
     if (!initComplete)
     {
         Init(gd);
     }
     firstIndexToShowOnScreen = 0;
     if (header != "")
     {
         headerText = new GameText(header, gd);
     }
     instructionText = new GameText(instructions, new Point(), gd);
     sortedList      = sortedListSource;
     bodySource      = new List <string>();
     selectable      = true; // The only class using the SortedDictionary is Inventory and it needs selectable enabled to work
 }
コード例 #8
0
        /// <summary>
        /// Attempts to put on a wearable InventoryItem if there is space. Does not remove items to do so.
        /// </summary>
        /// <param name="item">Item to put on</param>
        private static void Equip(InventoryItem item)
        {
            if (item == null || !(item is IWearable))
            {
                return;
            }
            var wornItem = item as IWearable;

            if (wornItem.Equipped)
            {
                return;
            }

            // Identify all items of the same class that are equiped. Most classes will have only
            // one item equiped at a time, but rings may have more than one. This list is used to
            // handle removing and replacing one worn item with another.
            List <InventoryItem> replaces = new List <InventoryItem>();

            foreach (var kvPair in inventoryContents) // UniqueID, InventoryItem
            {
                if (kvPair.Value.Class != item.Class)
                {
                    continue;
                }
                // If they are the same class, then assume IWearable
                if ((kvPair.Value as IWearable).Equipped)
                {
                    replaces.Add(kvPair.Value);
                }
            }


            string attemptResponse = wornItem.Equip(replaces);

            if (attemptResponse != string.Empty)
            {
                InventoryEffectManager.AddMessageToQueue(attemptResponse);
                closingWindow = true;
            }
            GameText inventoryText = inventoryList[searchString];

            inventoryText.Text = item.InventoryTitle + wornItem.WornOn;
            inventoryList.Remove(searchString);
            inventoryList.Add(item.SortingValue, inventoryText);
        }
コード例 #9
0
        /// <summary>
        /// Reduces length of text to fit within window. This should only be necessary for magical
        /// names produced in excess of the limits as user name changes will be guarded against over
        /// run.
        /// </summary>
        /// <param name="textToFit"></param>
        private void FitCurrentTextToWindow(GameText textToFit)
        {
            modifiedText.Clear();
            modifiedText.Append(textToFit.Text);
            currentText.Text = modifiedText.ToString();

            // If text is too wide to fit window, append elipses and keep reducing it
            // until it fits
            if (currentText.Width > GameConstants.INV_MAX_TITLE_WIDTH)
            {
                modifiedText.Append("...");
                currentText.Text = modifiedText.ToString();

                while (currentText.Width > GameConstants.INV_MAX_TITLE_WIDTH)
                {
                    modifiedText.Remove(modifiedText.Length - 4, 1);
                    currentText.Text = modifiedText.ToString();
                }
            }
        }
コード例 #10
0
        /// <summary>
        /// Separates a consumable from the stack (if stackable) and consumes it triggering its effect.
        /// The weight is adjusted with the loss of the item and the item is removed from the list if it
        /// is the last of its kind in the stack or otherwise not stackable. Consumed items do not get dropped
        /// to the floor.
        /// </summary>
        /// <param name="item">Item to be consumed.</param>
        private static void Consume(InventoryItem item)
        {
            if (item == null || !(item is IConsumable))
            {
                return;
            }


            IConsumable consumedItem;
            bool        lastOfStack = false;



            if (item is IStackable && (item as IStackable).Qty > 1)
            {
                // Preserve old inventoryList Dictionary values on item
                var oldItemSortingValue      = item.SortingValue;
                var oldItemInventoryGameText = inventoryList[oldItemSortingValue];

                // Remove old item from inventoryList (not contents though)
                inventoryList.Remove(oldItemSortingValue);

                // Get the consumed item by removing it from the stack
                consumedItem = (IConsumable)((item as IStackable).Remove());

                // Update the GameText object using the new InventoryTitle (incorperates qty change)
                oldItemInventoryGameText.Text = item.InventoryTitle;

                // Insert the updated data back into the Dictionary (because the key is different, we couldn't just change it)
                inventoryList.Add(item.SortingValue, oldItemInventoryGameText);
            }

            else
            {
                consumedItem = item as IConsumable;
                lastOfStack  = true;
            }


            string listKey = item.SortingValue; // Preserve old key in case using an item renames it.

            // Consume the item and get the string response from it for the message log
            // Note, that in order for remaining items in the stack to get the new name, Consume must be
            // called on the stack, not the item being tossed away.
            string attemptResponse = (item as IConsumable).Consume();

            if (attemptResponse != string.Empty)
            {
                InventoryEffectManager.AddMessageToQueue(attemptResponse);
            }
            if (InventoryEffectManager.HasMessages && currentSelectionAction == SelectionActions.None)
            {
                closingWindow = true;
            }

            // If last in the stack, remove the stack and update inventory weight
            if (lastOfStack && inventoryContents.Remove(item.UniqueID))
            {
                inventoryList.Remove(listKey);
                weight -= item.InventoryWeight;
            }
            else   // otherwise just update the inventory weight and text
            if (!lastOfStack)
            {
                weight -= (consumedItem as InventoryItem).InventoryWeight;
                if (item.SortingValue != listKey)
                {
                    GameText textItem = inventoryList[listKey];
                    textItem.Text = item.InventoryTitle;
                    inventoryList.Remove(listKey);
                    inventoryList.Add(item.SortingValue, textItem);
                }
            }

            else
            {
                throw new IndexOutOfRangeException("Item to be removed not found in the Inventory's Contents List");
            }
            UpdateCurrentItem();
        }
コード例 #11
0
        internal void Draw(SpriteBatch spriteBatch, Rectangle viewPortBounds)
        {
            Color fontColor;

            viewPort.Bounds         = viewPortBounds;
            graphicsDevice.Viewport = viewPort;

            spriteBatch.Begin();

            // Draw black canvas with frame over viewport
            Rectangle frame       = new Rectangle(0, 0, viewPortBounds.Width, viewPortBounds.Height);
            Rectangle blackCanvas = new Rectangle(2, 2, frame.Width - 4, frame.Height - 4);

            spriteBatch.Draw(pixel, frame, frameColor);
            spriteBatch.Draw(pixel, blackCanvas, Color.Black);
            int nextTextTop = blackCanvas.Top + GameConstants.TOP_MARGIN;

            // Displays a header if used
            if (headerText != null)
            {
                // Show header text with underline
                headerText.Y         = nextTextTop;
                headerText.ForeColor = headerFontColor;
                headerText.Scale     = new Vector2(1.5f, 1.25f);
                headerText.X         = blackCanvas.Left + GameConstants.HEAD_FOOT_LEFT;
                nextTextTop         += (int)(headerText.Height * headerText.Scale.Y);
                headerText.Draw(spriteBatch);


                underline.X      = headerText.X;
                underline.Y      = nextTextTop;
                underline.Width  = (int)(headerText.Width * headerText.Scale.X);
                underline.Height = (int)(headerText.Height * GameConstants.UNDERLINE_RATIO);
                spriteBatch.Draw(pixel, underline, headerFontColor);
                nextTextTop += underline.Height + (int)(headerText.Height * 0.25f) + GameConstants.LINE_SPACING;
            }

            // First, decide which list is provided and update bodySource if sorted dictionary
            if (sortedList != null)
            {
                bodySource.Clear();
                foreach (var kvPair in sortedList)
                {
                    bodySource.Add(kvPair.Value.Text);
                }
            }

            // Display body text when used (May only be a portion of the full list)
            if (bodySource != null)
            {
                // Count how many items will fit in the current view, leaving room at the bottom for instructions
                viewableListItems = (int)Math.Floor((decimal)(viewPortBounds.Height - nextTextTop) / (bodyText[0].Height + GameConstants.LINE_SPACING)) - 3;

                //If current selection is below range, move range down
                if (firstIndexToShowOnScreen < 0 && bodySource.Count > 0)
                {
                    firstIndexToShowOnScreen = 0;
                }
                while (selectedIndex > firstIndexToShowOnScreen + viewableListItems - 1)
                {
                    firstIndexToShowOnScreen++;
                }
                //and the reverse if it is above the range
                while (selectedIndex < firstIndexToShowOnScreen)
                {
                    firstIndexToShowOnScreen--;
                }



                // Iterate through the list of text to display
                for (int i = firstIndexToShowOnScreen;
                     i > -1 && i < bodySource.Count && i < firstIndexToShowOnScreen + viewableListItems; i++)
                {
                    fontColor = selectedIndex == i && selectable ? selectedFontColor : normalFontColor;
                    if (bodyText.Count < i + 1)
                    {
                        bodyText.Add(new GameText(graphicsDevice));
                    }
                    currentText = bodyText[i];           // Gives currentText a reference to an existing reusable object
                    FitCurrentTextToWindow(bodyText[i]); // changes currentText.Text
                    currentText = new GameText(bodySource[i], graphicsDevice)
                    {
                        X = GameConstants.LIST_LEFT,
                        Y = nextTextTop
                    };
                    nextTextTop          += currentText.Height + GameConstants.LINE_SPACING;
                    currentText.ForeColor = fontColor;
                    currentText.Draw(spriteBatch);
                }
            }

            // Display prompt when used
            if (promptText != null)
            {
                promptText.Y         = nextTextTop;
                promptText.ForeColor = normalFontColor;
                promptText.X         = blackCanvas.Left + GameConstants.HEAD_FOOT_LEFT;
                nextTextTop         += promptText.Height + GameConstants.LINE_SPACING;
                promptText.Draw(spriteBatch);
            }

            // Display user typed text when used
            if (userResponse != null)
            {
                userResponseText.Text      = userResponse.ToString().Length == 0 ? " " : userResponse.ToString();
                userResponseText.ForeColor = normalFontColor;
                userResponseText.X         = blackCanvas.X + blackCanvas.Width / 2 - userResponseText.Width / 2;
                userResponseText.Y         = nextTextTop;
                nextTextTop += userResponseText.Height + GameConstants.LINE_SPACING;
                userResponseText.Draw(spriteBatch);

                underline.Y = nextTextTop;
                int minWidth = 100;
                underline.Width  = MathHelper.Max(minWidth, (int)(userResponseText.Width * userResponseText.Scale.X));
                underline.Height = (int)(userResponseText.Height * GameConstants.UNDERLINE_RATIO);
                underline.X      = blackCanvas.X + blackCanvas.Width / 2 - underline.Width / 2;
                spriteBatch.Draw(pixel, underline, userResponseText.ForeColor);
                nextTextTop += underline.Height + (int)(userResponseText.Height * 0.25f) + GameConstants.LINE_SPACING;
            }

            // Display current screen instructions
            instructionText.Y         = (blackCanvas.Top + blackCanvas.Height - instructionText.Height - GameConstants.LINE_SPACING);
            instructionText.X         = blackCanvas.Left + GameConstants.HEAD_FOOT_LEFT;
            instructionText.ForeColor = screenInstructionFontColor;
            instructionText.Draw(spriteBatch);

            spriteBatch.End();
        }