diff options
Diffstat (limited to 'source/ui')
27 files changed, 2356 insertions, 0 deletions
diff --git a/source/ui/Rect.cs b/source/ui/Rect.cs new file mode 100644 index 0000000..c26ba8b --- /dev/null +++ b/source/ui/Rect.cs @@ -0,0 +1,188 @@ +using System; +using Microsoft.Xna.Framework; + +namespace Celesteia.UI { + public struct Rect { + public static Rect AbsoluteZero = new Rect(AbsoluteUnit.WithValue(0f)); + public static Rect AbsoluteOne = new Rect(AbsoluteUnit.WithValue(1f)); + public static Rect ScreenFull = new Rect( + new ScreenSpaceUnit(0f, ScreenSpaceUnit.ScreenSpaceOrientation.Horizontal), + new ScreenSpaceUnit(0f, ScreenSpaceUnit.ScreenSpaceOrientation.Vertical), + new ScreenSpaceUnit(1f, ScreenSpaceUnit.ScreenSpaceOrientation.Horizontal), + new ScreenSpaceUnit(1f, ScreenSpaceUnit.ScreenSpaceOrientation.Vertical) + ); + public static Rect RelativeFull(Rect parent) => new Rect( + new RelativeUnit(0f, parent, RelativeUnit.Orientation.Horizontal), + new RelativeUnit(0f, parent, RelativeUnit.Orientation.Vertical), + new RelativeUnit(1f, parent, RelativeUnit.Orientation.Horizontal), + new RelativeUnit(1f, parent, RelativeUnit.Orientation.Vertical) + ); + + public IInterfaceUnit X; + public IInterfaceUnit Y; + public IInterfaceUnit Width; + public IInterfaceUnit Height; + + public Rect(IInterfaceUnit uniform) : this (uniform, uniform, uniform, uniform) { } + + public Rect(IInterfaceUnit x, IInterfaceUnit y, IInterfaceUnit width, IInterfaceUnit height) { + this.X = x; + this.Y = y; + this.Width = width; + this.Height = height; + } + + public Rect SetX(IInterfaceUnit x) { + X = x; + return this; + } + + public Rect SetY(IInterfaceUnit y) { + Y = y; + return this; + } + + public Rect SetWidth(IInterfaceUnit w) { + Width = w; + return this; + } + + public Rect SetHeight(IInterfaceUnit h) { + Height = h; + return this; + } + + public float[] Resolve() { + return new float[] { X.Resolve(), Y.Resolve(), Width.Resolve(), Height.Resolve() }; + } + + public bool Contains(Point point) { + return ( + point.X >= this.X.Resolve() && + point.Y >= this.Y.Resolve() && + point.X <= this.X.Resolve() + this.Width.Resolve() && + point.Y <= this.Y.Resolve() + this.Height.Resolve() + ); + } + + public bool Contains(int x, int y) { + return Contains(new Point(x, y)); + } + + public override string ToString() { + return $"{X.Resolve().ToString("0.00")} {Y.Resolve().ToString("0.00")} {Width.Resolve().ToString("0.00")} {Height.Resolve().ToString("0.00")}"; + } + + public Rectangle ResolveRectangle() + { + float[] resolved = this.Resolve(); + return new Rectangle( + (int) MathF.Floor(resolved[0]), + (int) MathF.Floor(resolved[1]), + (int) MathF.Floor(resolved[2]), + (int) MathF.Floor(resolved[3]) + ); + } + } + + public interface IInterfaceUnit { + public float Resolve(); + + public void SetValue(float value); + } + + public struct AbsoluteUnit : IInterfaceUnit + { + public float value { get; private set; } + + public AbsoluteUnit(float value) { + this.value = value; + } + + public static AbsoluteUnit WithValue(float value) { + return new AbsoluteUnit(value); + } + + public void SetValue(float value) { + this.value = value; + } + + public float Resolve() + { + return value; + } + } + + public struct ScreenSpaceUnit : IInterfaceUnit + { + public float value { get; private set; } + public ScreenSpaceOrientation orientation { get; private set; } + + public ScreenSpaceUnit(float value, ScreenSpaceOrientation orientation) { + this.value = value; + this.orientation = orientation; + } + + public void SetValue(float value) { + this.value = value; + } + + public void SetOrientation(ScreenSpaceOrientation orientation) { + this.orientation = orientation; + } + + public float Resolve() + { + if (UIReferences.gameWindow != null) { + switch (orientation) { + case ScreenSpaceOrientation.Horizontal: + return value * UIReferences.gameWindow.ClientBounds.Width; + case ScreenSpaceOrientation.Vertical: + return value * UIReferences.gameWindow.ClientBounds.Height; + } + } + return 0f; + } + + public enum ScreenSpaceOrientation { + Horizontal, Vertical + } + } + + public struct RelativeUnit : IInterfaceUnit + { + public float value { get; private set; } + public Rect parent { get; private set; } + public Orientation orientation { get; private set; } + + public RelativeUnit(float value, Rect parent, Orientation orientation) { + this.value = value; + this.parent = parent; + this.orientation = orientation; + } + + public void SetValue(float value) { + this.value = value; + } + + public void SetOrientation(Orientation orientation) { + this.orientation = orientation; + } + + public float Resolve() + { + switch (orientation) { + case Orientation.Horizontal: + return value * parent.Resolve()[2]; + case Orientation.Vertical: + return value * parent.Resolve()[3]; + default: + return 0f; + } + } + + public enum Orientation { + Horizontal, Vertical + } + } +}
\ No newline at end of file diff --git a/source/ui/TextAlignment.cs b/source/ui/TextAlignment.cs new file mode 100644 index 0000000..1f92828 --- /dev/null +++ b/source/ui/TextAlignment.cs @@ -0,0 +1,10 @@ +using System; + +[Flags] +public enum TextAlignment { + Center = 0, + Left = 1, + Right = 2, + Top = 4, + Bottom = 8 +}
\ No newline at end of file diff --git a/source/ui/UI.cs b/source/ui/UI.cs new file mode 100644 index 0000000..39f4136 --- /dev/null +++ b/source/ui/UI.cs @@ -0,0 +1,81 @@ +using Celesteia.Resources.Management; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.TextureAtlases; + +namespace Celesteia { + public static class UIReferences { + public static GameWindow gameWindow; + public static bool GUIEnabled = true; + public static int Scaling = 3; + } + + public static class TextUtilities { + public static void DrawAlignedText(SpriteBatch spriteBatch, Rectangle rect, FontType font, string text, Color color, TextAlignment textAlignment, float targetSize) { + // Credit for text alignment: https://stackoverflow.com/a/10263903 + + // Measure the text's size from the sprite font. + Vector2 size = font.Font.MeasureString(text); + + // Get the origin point at the center. + Vector2 origin = 0.5f * size; + + if (textAlignment.HasFlag(TextAlignment.Left)) + origin.X += rect.Width / 2f - size.X / 2f; + + if (textAlignment.HasFlag(TextAlignment.Right)) + origin.X -= rect.Width / 2f - size.X / 2f; + + if (textAlignment.HasFlag(TextAlignment.Top)) + origin.Y += rect.Height / 2f - size.Y / 2f; + + if (textAlignment.HasFlag(TextAlignment.Bottom)) + origin.Y -= rect.Height / 2f - size.Y / 2f; + + spriteBatch.DrawString(font.Font, text, new Vector2(rect.Center.X, rect.Center.Y), color, 0f, origin, font.Scale(targetSize), SpriteEffects.None, 0f); + } + + public static void DrawAlignedText(SpriteBatch spriteBatch, Rectangle rect, TextProperties textProperties) { + DrawAlignedText(spriteBatch, rect, textProperties.GetFont(), textProperties.GetText(), textProperties.GetColor(), textProperties.GetAlignment(), textProperties.GetFontSize()); + } + } + + public static class ImageUtilities { + private static int xLeft(Rectangle rectangle, int patchSize) => rectangle.X; + private static int xMiddle(Rectangle rectangle, int patchSize) => rectangle.X + (patchSize * UIReferences.Scaling); + private static int xRight(Rectangle rectangle, int patchSize) => rectangle.X + rectangle.Width - (patchSize * UIReferences.Scaling); + private static int yTop(Rectangle rectangle, int patchSize) => rectangle.Y; + private static int yMiddle(Rectangle rectangle, int patchSize) => rectangle.Y + (patchSize * UIReferences.Scaling); + private static int yBottom(Rectangle rectangle, int patchSize) => rectangle.Y + rectangle.Height - (patchSize * UIReferences.Scaling); + + public static void DrawPatched(SpriteBatch spriteBatch, Rectangle rectangle, TextureAtlas patches, int patchSize, Color color) { + int y; + int scaled = patchSize * UIReferences.Scaling; + + // Top + y = yTop(rectangle, patchSize); + { + spriteBatch.Draw(patches.GetRegion(0), new Rectangle(xLeft(rectangle, patchSize), y, scaled, scaled), color); // Top left + spriteBatch.Draw(patches.GetRegion(1), new Rectangle(xMiddle(rectangle, patchSize), y, rectangle.Width - (2 * scaled), scaled), color); // Top center + spriteBatch.Draw(patches.GetRegion(2), new Rectangle(xRight(rectangle, patchSize), y, scaled, scaled), color); // Top right + } + + // Center + y = yMiddle(rectangle, patchSize); + { + spriteBatch.Draw(patches.GetRegion(3), new Rectangle(xLeft(rectangle, patchSize), y, scaled, rectangle.Height - (2 * scaled)), color); // Left center + spriteBatch.Draw(patches.GetRegion(4), new Rectangle(xMiddle(rectangle, patchSize), y, rectangle.Width - (2 * scaled), rectangle.Height - (2 * scaled)), color); // Center + spriteBatch.Draw(patches.GetRegion(5), new Rectangle(xRight(rectangle, patchSize), y, scaled, rectangle.Height - (2 * scaled)), color); // Right center + } + + // Bottom + y = yBottom(rectangle, patchSize); + { + spriteBatch.Draw(patches.GetRegion(6), new Rectangle(xLeft(rectangle, patchSize), y, scaled, scaled), color); // Bottom left + spriteBatch.Draw(patches.GetRegion(7), new Rectangle(xMiddle(rectangle, patchSize), y, rectangle.Width - (2 * scaled), scaled), color); // Bottom center + spriteBatch.Draw(patches.GetRegion(8), new Rectangle(xRight(rectangle, patchSize), y, scaled, scaled), color); // Bottom right + } + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/Button.cs b/source/ui/elements/Button.cs new file mode 100644 index 0000000..81a6aed --- /dev/null +++ b/source/ui/elements/Button.cs @@ -0,0 +1,173 @@ +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.Input; +using MonoGame.Extended.TextureAtlases; + +namespace Celesteia.UI.Elements { + public class Button : Clickable { + public Button(Rect rect) { + SetRect(rect); + } + + public Button SetNewRect(Rect rect) { + SetRect(rect); + return this; + } + + public Button SetPivotPoint(Vector2 pivot) { + SetPivot(pivot); + return this; + } + + // TEXT PROPERTIES + + private TextProperties _text; + + public Button SetTextProperties(TextProperties text) { + _text = text; + return this; + } + + public Button SetText(string text) { + _text.SetText(text); + return this; + } + + // COLOR PROPERTIES + + private ButtonColorGroup _colorGroup = new ButtonColorGroup(Color.White); + private Color ButtonColor = Color.White; + private bool ButtonEnabled = true; + + public Button SetColorGroup(ButtonColorGroup colorGroup) { + _colorGroup = colorGroup; + return this; + } + + public Button SetButtonEnabled(bool enabled) { + ButtonEnabled = enabled; + return this; + } + + // CLICKING PROPERTIES + + private ClickEvent _onMouseDown = null; + private ClickEvent _onMouseUp = null; + + public Button SetOnMouseDown(ClickEvent func) { + _onMouseDown = func; + return this; + } + + public Button SetOnMouseUp(ClickEvent func) { + _onMouseUp = func; + return this; + } + + public override void OnMouseDown(MouseButton button, Point position) { + base.OnMouseDown(button, position); + _onMouseDown?.Invoke(button, position); + } + + public override void OnMouseUp(MouseButton button, Point position) { + base.OnMouseUp(button, position); + _onMouseUp?.Invoke(button, position); + } + + // DRAWING PROPERTIES + + private Texture2D _texture; + private TextureAtlas _patches; + private int _patchSize; + + public Button SetTexture(Texture2D texture) { + _texture = texture; + return this; + } + + public Button MakePatches(int size) { + if (_texture != null) { + _patchSize = size; + _patches = TextureAtlas.Create("buttonPatches", _texture, _patchSize, _patchSize); + } + return this; + } + + // https://gamedev.stackexchange.com/a/118255 + private float _colorAmount = 0.0f; + private bool _prevMouseOver = false; + private bool _prevClicked = false; + public override void Update(GameTime gameTime, out bool clickedAnything) { + clickedAnything = false; + if (ButtonColor == GetTargetColor()) return; + + if (_prevMouseOver != GetMouseOver() || _prevClicked != GetClicked()) _colorAmount = 0.0f; + + _colorAmount += (float)gameTime.ElapsedGameTime.TotalSeconds / 0.5f; + + if (_colorAmount > 1.0f) + _colorAmount = 0.0f; + + ButtonColor = Color.Lerp(ButtonColor, GetTargetColor(), _colorAmount); + + _prevMouseOver = GetMouseOver(); + _prevClicked = GetClicked(); + } + + Rectangle rectangle; + public override void Draw(SpriteBatch spriteBatch) + { + rectangle = GetRectangle(); + + // Draw the button's texture. + if (_patches != null) ImageUtilities.DrawPatched(spriteBatch, rectangle, _patches, _patchSize, ButtonColor); + else spriteBatch.Draw(GetTexture(spriteBatch), rectangle, null, ButtonColor); + + TextUtilities.DrawAlignedText(spriteBatch, rectangle, _text); + } + + public Texture2D GetTexture(SpriteBatch spriteBatch) { + if (_texture == null) { + _texture = new Texture2D(spriteBatch.GraphicsDevice, 1, 1); + _texture.SetData(new[] { Color.Gray }); + } + + return _texture; + } + + private Color GetTargetColor() { + return ButtonEnabled ? (GetMouseOver() ? (GetClicked() ? _colorGroup.Active : _colorGroup.Hover) : _colorGroup.Normal) : _colorGroup.Disabled; + } + + public Button Clone() { + return new Button(GetRect()) + .SetPivotPoint(GetPivot()) + .SetOnMouseDown(_onMouseDown) + .SetOnMouseUp(_onMouseUp) + .SetTexture(_texture) + .MakePatches(_patchSize) + .SetTextProperties(_text) + .SetColorGroup(_colorGroup); + } + } + + public struct ButtonColorGroup { + public Color Normal; + public Color Disabled; + public Color Hover; + public Color Active; + + public ButtonColorGroup(Color normal, Color disabled, Color hover, Color active) { + Normal = normal; + Disabled = disabled; + Hover = hover; + Active = active; + } + + public ButtonColorGroup(Color normal, Color disabled, Color hover) : this (normal, disabled, hover, normal) {} + + public ButtonColorGroup(Color normal, Color disabled) : this (normal, disabled, normal, normal) {} + public ButtonColorGroup(Color normal) : this (normal, normal, normal, normal) {} + } +}
\ No newline at end of file diff --git a/source/ui/elements/Clickable.cs b/source/ui/elements/Clickable.cs new file mode 100644 index 0000000..01436a3 --- /dev/null +++ b/source/ui/elements/Clickable.cs @@ -0,0 +1,21 @@ +using Microsoft.Xna.Framework; +using MonoGame.Extended.Input; + +namespace Celesteia.UI.Elements { + public class Clickable : Element, IClickable + { + private bool _clicked; + + public override void OnMouseOut() { + _clicked = false; + base.OnMouseOut(); + } + public virtual void OnMouseDown(MouseButton button, Point position) => _clicked = true; + public virtual void OnMouseUp(MouseButton button, Point position) => _clicked = false; + + public bool GetClicked() => _clicked; + } + + public delegate void HoverEvent(); + public delegate void ClickEvent(MouseButton button, Point position); +}
\ No newline at end of file diff --git a/source/ui/elements/Container.cs b/source/ui/elements/Container.cs new file mode 100644 index 0000000..9080999 --- /dev/null +++ b/source/ui/elements/Container.cs @@ -0,0 +1,91 @@ +using System.Collections.Generic; +using Celesteia.Game.Input; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.Input; + +namespace Celesteia.UI.Elements { + public class Container : Element, IContainer + { + private List<IElement> Children; + + public Container(Rect rect) { + SetRect(rect); + Children = new List<IElement>(); + } + + public void AddChild(IElement element) { + Children.Add(element); + element.SetParent(this); + } + + public List<IElement> GetChildren() => Children; + + public override void Draw(SpriteBatch spriteBatch) + { + Children.ForEach(element => { if (element.GetEnabled()) element.Draw(spriteBatch); }); + } + + private Point _mousePosition; + + public override void Update(GameTime gameTime, out bool clickedAnything) + { + clickedAnything = false; + if (!UIReferences.GUIEnabled) return; + + foreach (IElement element in Children) { + element.Update(gameTime, out clickedAnything); + } + + _mousePosition = MouseHelper.Position; + + if (MouseHelper.Pressed(MouseButton.Left)) clickedAnything = ResolveMouseDown(MouseButton.Left); + else if (MouseHelper.Pressed(MouseButton.Right)) clickedAnything = ResolveMouseDown(MouseButton.Right); + + if (MouseHelper.Released(MouseButton.Left)) clickedAnything = ResolveMouseUp(MouseButton.Left); + else if (MouseHelper.Released(MouseButton.Right)) clickedAnything = ResolveMouseUp(MouseButton.Right); + + ResolveMouseOver(); + } + + public bool ResolveMouseDown(MouseButton button) { + bool clicked = false; + Children.FindAll(x => x is Clickable).ForEach(element => { + if (!element.GetEnabled()) return; + Clickable clickable = element as Clickable; + + if (clicked = clickable.GetRectangle().Contains(_mousePosition)) + clickable.OnMouseDown(button, _mousePosition); + }); + return clicked; + } + + public bool ResolveMouseUp(MouseButton button) { + bool clicked = false; + Children.FindAll(x => x is Clickable).ForEach(element => { + if (!element.GetEnabled()) return; + Clickable clickable = element as Clickable; + + if (clickable.GetRectangle().Contains(_mousePosition)) { + clicked = true; + clickable.OnMouseUp(button, _mousePosition); + } + }); + return clicked; + } + + public void ResolveMouseOver() { + Children.ForEach(element => { + if (!element.GetEnabled()) return; + bool over = element.GetRectangle().Contains(_mousePosition); + if (over && !element.GetMouseOver()) { + element.OnMouseIn(); + } else if (!over && element.GetMouseOver()) element.OnMouseOut(); + }); + } + + public void Dispose() { + Children.Clear(); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/Element.cs b/source/ui/elements/Element.cs new file mode 100644 index 0000000..b95a693 --- /dev/null +++ b/source/ui/elements/Element.cs @@ -0,0 +1,53 @@ +using System; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.UI.Elements { + public class Element : IElement + { + private bool _enabled = true; + private Rect _rect; + private bool _isMouseOver; + private IContainer _parent; + private Vector2 _pivot; + + public virtual bool GetEnabled() => _enabled && (_parent == null || _parent.GetEnabled()); + public virtual IContainer GetParent() => _parent; + public virtual Vector2 GetPivot() => _pivot; + public virtual Rect GetRect() => _rect; + public virtual void MoveTo(Point point) { + _rect.SetX(AbsoluteUnit.WithValue(point.X)); + _rect.SetY(AbsoluteUnit.WithValue(point.Y)); + } + + // Get element rectangle with pivot. + public virtual Rectangle GetRectangle() { + Rectangle r = GetRect().ResolveRectangle(); + + if (GetParent() != null) { + r.X += GetParent().GetRectangle().X; + r.Y += GetParent().GetRectangle().Y; + } + + r.X -= (int)MathF.Round(_pivot.X * r.Width); + r.Y -= (int)MathF.Round(_pivot.Y * r.Height); + + return r; + } + + // Interface setters. + public virtual bool SetEnabled(bool value) => _enabled = value; + public virtual void SetParent(IContainer container) => _parent = container; + public virtual void SetPivot(Vector2 pivot) => _pivot = pivot; + public virtual void SetRect(Rect rect) => _rect = rect; + + // Mouse functions + public virtual void OnMouseIn() => _isMouseOver = true; + public virtual void OnMouseOut() => _isMouseOver = false; + public virtual bool GetMouseOver() => _isMouseOver; + + // Engine functions. + public virtual void Update(GameTime gameTime, out bool clickedAnything) { clickedAnything = false; } + public virtual void Draw(SpriteBatch spriteBatch) { } + } +}
\ No newline at end of file diff --git a/source/ui/elements/IClickable.cs b/source/ui/elements/IClickable.cs new file mode 100644 index 0000000..19c2848 --- /dev/null +++ b/source/ui/elements/IClickable.cs @@ -0,0 +1,9 @@ +using Microsoft.Xna.Framework; +using MonoGame.Extended.Input; + +namespace Celesteia.UI.Elements { + public interface IClickable : IElement { + void OnMouseDown(MouseButton button, Point position); + void OnMouseUp(MouseButton button, Point position); + } +}
\ No newline at end of file diff --git a/source/ui/elements/IContainer.cs b/source/ui/elements/IContainer.cs new file mode 100644 index 0000000..0d3550c --- /dev/null +++ b/source/ui/elements/IContainer.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; + +namespace Celesteia.UI.Elements { + public interface IContainer : IElement, IDisposable { + // Get the element's children. + List<IElement> GetChildren(); + + // Add to the element's children. + void AddChild(IElement element); + } +}
\ No newline at end of file diff --git a/source/ui/elements/IElement.cs b/source/ui/elements/IElement.cs new file mode 100644 index 0000000..094d7b7 --- /dev/null +++ b/source/ui/elements/IElement.cs @@ -0,0 +1,52 @@ +using System.Collections.Generic; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.UI.Elements { + public interface IElement { + // Is the element enabled? + bool GetEnabled(); + + // Set whether the element is enabled. + bool SetEnabled(bool value); + + // Get the containing rect of the element. + Rect GetRect(); + + // Set the containing rect of the element. + void SetRect(Rect rect); + + // Move to a point. + void MoveTo(Point point); + + // Get the rectangle with a pivot point. + Rectangle GetRectangle(); + + // Gets the pivot point of the element; + Vector2 GetPivot(); + + // Sets the pivot point of the element; + void SetPivot(Vector2 pivot); + + // Called when the mouse position is within the element's containing rect. + void OnMouseIn(); + + // Called when the mouse position is within the element's containing rect. + void OnMouseOut(); + + // Get if the element has the mouse over it. + bool GetMouseOver(); + + // Update the element. + void Update(GameTime gameTime, out bool clickedAnything); + + // Draw the element. + void Draw(SpriteBatch spriteBatch); + + // Get the element's parent. + IContainer GetParent(); + + // Set the element's parent. + void SetParent(IContainer container); + } +}
\ No newline at end of file diff --git a/source/ui/elements/Image.cs b/source/ui/elements/Image.cs new file mode 100644 index 0000000..de661e8 --- /dev/null +++ b/source/ui/elements/Image.cs @@ -0,0 +1,59 @@ +using System; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.TextureAtlases; + +namespace Celesteia.UI.Elements { + public class Image : Element { + private Texture2D _texture; + public Color _color; + + public Image(Rect rect) { + SetRect(rect); + } + + public Image SetTexture(Texture2D texture) { + _texture = texture; + return this; + } + + public Image SetColor(Color color) { + _color = color; + return this; + } + + public Image SetPivotPoint(Vector2 pivot) { + SetPivot(pivot); + return this; + } + + private TextureAtlas _patches; + private int _patchSize; + public Image MakePatches(int size) { + if (_texture != null) { + _patchSize = size; + _patches = TextureAtlas.Create("patches", _texture, _patchSize, _patchSize); + } + return this; + } + + public override void Draw(SpriteBatch spriteBatch) + { + if (_patches != null) ImageUtilities.DrawPatched(spriteBatch, GetRectangle(), _patches, _patchSize, _color); + else spriteBatch.Draw(GetTexture(spriteBatch), GetRectangle(), null, _color); + } + + public Texture2D GetTexture(SpriteBatch spriteBatch) + { + if (_texture == null) { + // Make a new texture. + _texture = new Texture2D(spriteBatch.GraphicsDevice, 1, 1); + + // Set the default texture to one gray pixel. + _texture.SetData(new[] { Color.Gray }); + } + + return _texture; + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/Label.cs b/source/ui/elements/Label.cs new file mode 100644 index 0000000..c875791 --- /dev/null +++ b/source/ui/elements/Label.cs @@ -0,0 +1,62 @@ +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.UI.Elements { + public class Label : Element { + private Texture2D _background; + private TextProperties _text; + + public Label(Rect rect) { + SetRect(rect); + } + + public Label SetNewRect(Rect rect) { + SetRect(rect); + return this; + } + + public Label SetPivotPoint(Vector2 pivot) { + SetPivot(pivot); + return this; + } + + public Label SetBackground(Texture2D background) { + SetTexture(background); + return this; + } + + public Label SetText(string text) { + _text.SetText(text); + return this; + } + + public Label SetColor(Color color) { + _text.SetColor(color); + return this; + } + + public Label SetTextProperties(TextProperties text) { + _text = text; + return this; + } + + public override void Draw(SpriteBatch spriteBatch) + { + // Draw the label's background, if present. + if (_background != null) spriteBatch.Draw(GetTexture(), GetRectangle(), null, Color.White); + + TextUtilities.DrawAlignedText(spriteBatch, GetRectangle(), _text); + } + + public Texture2D GetTexture() => _background; + public void SetTexture(Texture2D background) => _background = background; + + public Label Clone() { + return new Label(GetRect()) + .SetPivotPoint(GetPivot()) + .SetBackground(GetTexture()) + .SetTextProperties(_text); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/CraftingRecipeSlot.cs b/source/ui/elements/game/CraftingRecipeSlot.cs new file mode 100644 index 0000000..72101d8 --- /dev/null +++ b/source/ui/elements/game/CraftingRecipeSlot.cs @@ -0,0 +1,173 @@ +using System; +using Celesteia.Game.Components.Items; +using Celesteia.Resources.Types; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.Input; +using MonoGame.Extended.TextureAtlases; + +namespace Celesteia.UI.Elements.Game { + public class CraftingRecipeSlot : Clickable { + public const float SLOT_SIZE = 64f; + public const float SLOT_SPACING = 16f; + + public Inventory referenceInv; + + public CraftingRecipeSlot(Rect rect) { + SetRect(rect); + } + + public CraftingRecipeSlot SetNewRect(Rect rect) { + SetRect(rect); + return this; + } + + // RECIPE REFERENCE PROPERTIES + private Recipe _recipe; + public CraftingRecipeSlot SetRecipe(Recipe recipe) { + _recipe = recipe; + return this; + } + + // DRAWING PROPERTIES + + private Texture2D _texture; + private TextureAtlas _patches; + private int _patchSize; + + public CraftingRecipeSlot SetTexture(Texture2D texture) { + _texture = texture; + return this; + } + + public CraftingRecipeSlot SetPatches(TextureAtlas patches, int size) { + if (_texture != null) { + _patchSize = size; + _patches = patches; + } + return this; + } + + // TEXT PROPERTIES + + private TextProperties _text; + + public CraftingRecipeSlot SetTextProperties(TextProperties text) { + _text = text; + return this; + } + + public CraftingRecipeSlot SetText(string text) { + _text.SetText(text); + return this; + } + + // CLICKING PROPERTIES + + private ClickEvent _onMouseDown = null; + private ClickEvent _onMouseUp = null; + public delegate void CraftHoverEvent(Recipe recipe); + private CraftHoverEvent _onMouseIn = null; + private HoverEvent _onMouseOut = null; + + public CraftingRecipeSlot SetOnMouseDown(ClickEvent func) { + _onMouseDown = func; + return this; + } + + public CraftingRecipeSlot SetOnMouseUp(ClickEvent func) { + _onMouseUp = func; + return this; + } + + public CraftingRecipeSlot SetOnMouseIn(CraftHoverEvent func) { + _onMouseIn = func; + return this; + } + + public CraftingRecipeSlot SetOnMouseOut(HoverEvent func) { + _onMouseOut = func; + return this; + } + + public override void OnMouseDown(MouseButton button, Point position) { + base.OnMouseDown(button, position); + _onMouseDown?.Invoke(button, position); + } + + public override void OnMouseUp(MouseButton button, Point position) { + base.OnMouseUp(button, position); + _onMouseUp?.Invoke(button, position); + } + + public override void OnMouseIn() { + base.OnMouseIn(); + if (_recipe != null) _onMouseIn?.Invoke(_recipe); + } + + public override void OnMouseOut() { + base.OnMouseOut(); + _onMouseOut?.Invoke(); + } + + private Rectangle GetScaledTriangle(Rectangle r, float scale) { + int newWidth = (int)Math.Round(r.Width * scale); + int newHeight = (int)Math.Round(r.Height * scale); + return new Rectangle( + (int)Math.Round(r.X + ((r.Width - newWidth) / 2f)), + (int)Math.Round(r.Y + ((r.Height - newHeight) / 2f)), + newWidth, + newHeight + ); + } + + Color color; + public override void Update(GameTime gameTime, out bool clickedAnything) { + base.Update(gameTime, out clickedAnything); + + if (!this.GetEnabled()) return; + color = _recipe.Craftable(referenceInv) ? Color.White : Color.Gray; + } + + Rectangle rectangle; + Rectangle itemRectangle; + Rectangle textRectangle; + public override void Draw(SpriteBatch spriteBatch) + { + if (_recipe == null) return; + + rectangle = GetRectangle(); + itemRectangle = GetScaledTriangle(rectangle, .6f); + textRectangle = GetScaledTriangle(rectangle, .4f); + + // Draw the slot's texture. + if (_patches != null) ImageUtilities.DrawPatched(spriteBatch, rectangle, _patches, _patchSize, color); + else spriteBatch.Draw(GetTexture(spriteBatch), rectangle, null, color); + + spriteBatch.Draw(_recipe.Result.GetItemType().Sprite, itemRectangle, color); + TextUtilities.DrawAlignedText(spriteBatch, textRectangle, _text.GetFont(), _recipe.Result.Amount + "", _text.GetColor(), _text.GetAlignment(), _text.GetFontSize()); + } + + public Texture2D GetTexture(SpriteBatch spriteBatch) { + if (_texture == null) { + _texture = new Texture2D(spriteBatch.GraphicsDevice, 1, 1); + _texture.SetData(new[] { Color.Gray }); + } + + return _texture; + } + + public CraftingRecipeSlot Clone() { + return new CraftingRecipeSlot(GetRect()) + .SetRecipe(_recipe) + .SetOnMouseDown(_onMouseDown) + .SetOnMouseUp(_onMouseUp) + .SetOnMouseIn(_onMouseIn) + .SetOnMouseOut(_onMouseOut) + .SetTextProperties(_text) + .SetTexture(_texture) + .SetPatches(_patches, _patchSize); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/CraftingWindow.cs b/source/ui/elements/game/CraftingWindow.cs new file mode 100644 index 0000000..e5bcc71 --- /dev/null +++ b/source/ui/elements/game/CraftingWindow.cs @@ -0,0 +1,62 @@ +using System; +using System.Collections.Generic; +using Celesteia.Game.Components.Items; +using Celesteia.GUIs.Game; +using Celesteia.Resources; +using Celesteia.Resources.Management; +using Celesteia.Resources.Types; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.UI.Elements.Game { + public class CraftingWindow : Container { + private Inventory _referenceInventory; + private Image background; + private GameGUI _gameGui; + + public CraftingWindow(GameGUI gameGui, Rect rect, Texture2D backgroundImage, Inventory inventory, CraftingRecipeSlot template) : base(rect) { + _gameGui = gameGui; + + _referenceInventory = inventory; + + background = new Image(Rect.RelativeFull(rect)).SetTexture(backgroundImage).MakePatches(4).SetColor(Color.White); + AddChild(background); + + AddRecipes(27, template); + } + + int columns = 9; + private void AddRecipes(int amountPerPage, CraftingRecipeSlot template) { + int rows = (int)Math.Ceiling(amountPerPage / (double)columns); + + float o = CraftingRecipeSlot.SLOT_SPACING; + int index = 0; + int i = 0; + for (int row = 0; row < rows; row++) + for (int column = 0; column < columns; column++) { + if (i >= ResourceManager.Recipes.Recipes.Count) break; + + int slotNumber = i; + Recipe recipe = ResourceManager.Recipes.Recipes[index]; + CraftingRecipeSlot slot = template.Clone() + .SetNewRect(template.GetRect() + .SetX(AbsoluteUnit.WithValue(column * CraftingRecipeSlot.SLOT_SIZE + (column * CraftingRecipeSlot.SLOT_SPACING) + o)) + .SetY(AbsoluteUnit.WithValue(row * CraftingRecipeSlot.SLOT_SIZE + (row * CraftingRecipeSlot.SLOT_SPACING) + o)) + ) + .SetRecipe(recipe) + .SetOnMouseUp((button, point) => { + if (button == MonoGame.Extended.Input.MouseButton.Left) { + recipe.Craft(_referenceInventory); + } + }); + slot.referenceInv = _referenceInventory; + slot.SetPivot(new Vector2(0f, 0f)); + + index++; + i++; + + AddChild(slot); + } + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/InventorySlot.cs b/source/ui/elements/game/InventorySlot.cs new file mode 100644 index 0000000..01663b4 --- /dev/null +++ b/source/ui/elements/game/InventorySlot.cs @@ -0,0 +1,191 @@ +using System; +using Celesteia.Game.Components.Items; +using Celesteia.Resources.Types; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.Input; +using MonoGame.Extended.TextureAtlases; + +namespace Celesteia.UI.Elements.Game { + public class InventorySlot : Clickable { + public const float SLOT_SIZE = 64f; + public const float SLOT_SPACING = 16f; + + public InventorySlot(Rect rect) { + SetRect(rect); + } + + public InventorySlot SetNewRect(Rect rect) { + SetRect(rect); + return this; + } + + // SELECTION + + private bool _selected = false; + public InventorySlot SetSelected(bool selected) { + _selected = selected; + return this; + } + + public bool GetSelected() { + return _selected; + } + + + // INVENTORY REFERENCE PROPERTIES + + private Inventory _inventory; + private int _slot; + + public InventorySlot SetReferenceInventory(Inventory inventory) { + _inventory = inventory; + return this; + } + + public InventorySlot SetSlot(int slot) { + _slot = slot; + return this; + } + + // DRAWING PROPERTIES + + private Texture2D _texture; + private TextureAtlas _patches; + private int _patchSize; + + public InventorySlot SetTexture(Texture2D texture) { + _texture = texture; + return this; + } + + public InventorySlot SetPatches(TextureAtlas patches, int size) { + if (_texture != null) { + _patchSize = size; + _patches = patches; + } + return this; + } + + // TEXT PROPERTIES + + private TextProperties _text; + + public InventorySlot SetTextProperties(TextProperties text) { + _text = text; + return this; + } + + public InventorySlot SetText(string text) { + _text.SetText(text); + return this; + } + + // CLICKING PROPERTIES + + private ClickEvent _onMouseDown = null; + private ClickEvent _onMouseUp = null; + public delegate void ItemHoverEvent(ItemType type); + private ItemHoverEvent _onMouseIn = null; + private HoverEvent _onMouseOut = null; + + public InventorySlot SetOnMouseDown(ClickEvent func) { + _onMouseDown = func; + return this; + } + + public InventorySlot SetOnMouseUp(ClickEvent func) { + _onMouseUp = func; + return this; + } + + public InventorySlot SetOnMouseIn(ItemHoverEvent func) { + _onMouseIn = func; + return this; + } + + public InventorySlot SetOnMouseOut(HoverEvent func) { + _onMouseOut = func; + return this; + } + + public override void OnMouseDown(MouseButton button, Point position) { + base.OnMouseDown(button, position); + _onMouseDown?.Invoke(button, position); + } + + public override void OnMouseUp(MouseButton button, Point position) { + base.OnMouseUp(button, position); + _onMouseUp?.Invoke(button, position); + } + + public override void OnMouseIn() { + base.OnMouseIn(); + if (_inventory.GetSlot(_slot) != null) _onMouseIn?.Invoke(_inventory.GetSlot(_slot).Type); + } + + public override void OnMouseOut() { + base.OnMouseOut(); + _onMouseOut?.Invoke(); + } + + private Rectangle GetScaledTriangle(Rectangle r, float scale) { + int newWidth = (int)Math.Round(r.Width * scale); + int newHeight = (int)Math.Round(r.Height * scale); + return new Rectangle( + (int)Math.Round(r.X + ((r.Width - newWidth) / 2f)), + (int)Math.Round(r.Y + ((r.Height - newHeight) / 2f)), + newWidth, + newHeight + ); + } + + Rectangle rectangle; + Rectangle itemRectangle; + Rectangle textRectangle; + ItemStack inSlot; + Color slightlyTransparent = new Color(255, 255, 255, 100); + public override void Draw(SpriteBatch spriteBatch) + { + if (_inventory == null) return; + + rectangle = GetRectangle(); + itemRectangle = GetScaledTriangle(rectangle, .6f); + textRectangle = GetScaledTriangle(rectangle, .4f); + + // Draw the slot's texture. + if (_patches != null) ImageUtilities.DrawPatched(spriteBatch, rectangle, _patches, _patchSize, _selected ? Color.DarkViolet : Color.White); + else spriteBatch.Draw(GetTexture(spriteBatch), rectangle, null, Color.White); + + // Draw item if present. + inSlot = _inventory.GetSlot(_slot); + if (inSlot != null) { + spriteBatch.Draw(inSlot.Type.Sprite, itemRectangle, Color.White); + if (inSlot.Amount > 1) TextUtilities.DrawAlignedText(spriteBatch, textRectangle, _text.GetFont(), $"{inSlot.Amount}", _text.GetColor(), _text.GetAlignment(), _text.GetFontSize()); + } else TextUtilities.DrawAlignedText(spriteBatch, rectangle, _text.GetFont(), $"{_slot + 1}", slightlyTransparent, TextAlignment.Center, 24f); + } + + public Texture2D GetTexture(SpriteBatch spriteBatch) { + if (_texture == null) { + _texture = new Texture2D(spriteBatch.GraphicsDevice, 1, 1); + _texture.SetData(new[] { Color.Gray }); + } + + return _texture; + } + + public InventorySlot Clone() { + return new InventorySlot(GetRect()) + .SetReferenceInventory(_inventory) + .SetOnMouseDown(_onMouseDown) + .SetOnMouseUp(_onMouseUp) + .SetOnMouseIn(_onMouseIn) + .SetOnMouseOut(_onMouseOut) + .SetSlot(_slot) + .SetTextProperties(_text) + .SetTexture(_texture) + .SetPatches(_patches, _patchSize); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/InventoryWindow.cs b/source/ui/elements/game/InventoryWindow.cs new file mode 100644 index 0000000..c8dba41 --- /dev/null +++ b/source/ui/elements/game/InventoryWindow.cs @@ -0,0 +1,56 @@ +using System; +using Celesteia.Game.Components.Items; +using Celesteia.GUIs.Game; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.UI.Elements.Game { + public class InventoryWindow : Container { + private Inventory _referenceInventory; + private Image background; + private GameGUI _gameGui; + + public InventoryWindow(GameGUI gameGui, Rect rect, Texture2D backgroundImage, Inventory inventory, int slots, int offset, InventorySlot template) : base(rect) { + _gameGui = gameGui; + + background = new Image(Rect.RelativeFull(rect)).SetTexture(backgroundImage).MakePatches(4).SetColor(Color.White); + AddChild(background); + + _referenceInventory = inventory; + + AddSlots(slots, offset, template); + } + + int columns = 9; + private void AddSlots(int amount, int offset, InventorySlot template) { + int rows = (int)Math.Ceiling(amount / (double)columns); + + float o = InventorySlot.SLOT_SPACING; + int i = 0; + for (int row = 0; row < rows; row++) + for (int column = 0; column < 9; column++) { + if (i > amount) break; + + int slotNumber = i + offset; + InventorySlot slot = template.Clone() + .SetNewRect(template.GetRect() + .SetX(AbsoluteUnit.WithValue(column * InventorySlot.SLOT_SIZE + (column * InventorySlot.SLOT_SPACING) + o)) + .SetY(AbsoluteUnit.WithValue(row * InventorySlot.SLOT_SIZE + (row * InventorySlot.SLOT_SPACING) + o)) + ) + .SetSlot(slotNumber) + .SetOnMouseUp((button, point) => { + ItemStack itemInSlot = _referenceInventory.GetSlot(slotNumber); + if ((int)_gameGui.State > 0) { + _referenceInventory.SetSlot(slotNumber, _gameGui.CursorItem); + _gameGui.CursorItem = itemInSlot; + } + }); + slot.SetPivot(new Vector2(0f, 0f)); + + i++; + + AddChild(slot); + } + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/PauseMenu.cs b/source/ui/elements/game/PauseMenu.cs new file mode 100644 index 0000000..39281ee --- /dev/null +++ b/source/ui/elements/game/PauseMenu.cs @@ -0,0 +1,74 @@ +using Celesteia.Game.Components.Items; +using Celesteia.GUIs.Game; +using Celesteia.Resources; +using Celesteia.Screens; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; + +namespace Celesteia.UI.Elements.Game { + public class PauseMenu : Container { + private Image background; + private IContainer centerMenu; + private GameGUI _gameGui; + + private float buttonRow(int number) => number * (buttonHeight + buttonSpacing); + private float buttonHeight = 56f; + private float buttonSpacing = 10f; + + public PauseMenu(GameGUI gameGui, Rect rect, Button buttonTemplate) : base(rect) { + _gameGui = gameGui; + + background = new Image(Rect.RelativeFull(rect)).SetColor(new Color(0, 0, 0, 100)); + AddChild(background); + + centerMenu = new Container(new Rect( + new RelativeUnit(0.5f, GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(0.5f, GetRect(), RelativeUnit.Orientation.Vertical), + AbsoluteUnit.WithValue(350f), + AbsoluteUnit.WithValue(2 * (buttonHeight + buttonSpacing) - buttonSpacing) + )); + AddChild(centerMenu); + + AddButtons(buttonTemplate); + } + + private void AddButtons(Button template) { + centerMenu.AddChild(new Label(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(buttonRow(-1)), + new RelativeUnit(1f, centerMenu.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(buttonHeight) + )) + .SetPivotPoint(new Vector2(0.5f, 0.5f)) + .SetTextProperties(new TextProperties().SetColor(Color.White).SetFont(ResourceManager.Fonts.GetFontType("Hobo")).SetFontSize(24f).SetTextAlignment(TextAlignment.Center)) + .SetText("Paused") + ); + + centerMenu.AddChild(template.Clone() + .SetNewRect(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(buttonRow(0)), + new RelativeUnit(1f, centerMenu.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(buttonHeight) + )) + .SetText("Back to Game") + .SetOnMouseUp((button, point) => { + _gameGui.TogglePause(); + }) + ); + + centerMenu.AddChild(template.Clone() + .SetNewRect(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(buttonRow(1)), + new RelativeUnit(1f, centerMenu.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(buttonHeight) + )) + .SetText("Return to Title") + .SetOnMouseUp((button, point) => { + _gameGui.Game.LoadScreen(new MainMenuScreen(_gameGui.Game),new MonoGame.Extended.Screens.Transitions.FadeTransition(_gameGui.Game.GraphicsDevice, Color.Black)); + }) + ); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/controls/ControlTips.cs b/source/ui/elements/game/controls/ControlTips.cs new file mode 100644 index 0000000..904b3cc --- /dev/null +++ b/source/ui/elements/game/controls/ControlTips.cs @@ -0,0 +1,51 @@ +using System.Collections.Generic; +using Celesteia.Game.Input; +using Celesteia.Resources; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using Microsoft.Xna.Framework.Input; + +namespace Celesteia.UI.Elements.Game.Controls { + public class ControlTips : Container { + private TextProperties _properties; + private Dictionary<Keys, string> _keyboardControls = new Dictionary<Keys, string>(); + private List<string> _lines = new List<string>(); + private List<Label> _labels = new List<Label>(); + + public ControlTips(Rect rect) : base(rect) { + _properties = new TextProperties() + .SetColor(Color.White) + .SetFont(ResourceManager.Fonts.DEFAULT) + .SetFontSize(12f) + .SetTextAlignment(TextAlignment.Left); + } + + private int lineHeight = 16; + private Rect LineRect(int line) => new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(line * lineHeight), + new RelativeUnit(1f, GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(lineHeight) + ); + + private void UpdateLines() { + _labels.Clear(); + + foreach (Keys keys in _keyboardControls.Keys) _lines.Add($"[{keys}] {_keyboardControls[keys]}"); + + for (int i = 0; i < _lines.Count; i++) { + Label label = new Label(LineRect(i - (_lines.Count / 2))) + .SetTextProperties(_properties) + .SetText(_lines[i]); + label.SetParent(this); + _labels.Add(label); + } + } + + public override void Draw(SpriteBatch spriteBatch) + { + foreach (Label l in _labels) l.Draw(spriteBatch); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/tooltips/CraftingTooltipDisplay.cs b/source/ui/elements/game/tooltips/CraftingTooltipDisplay.cs new file mode 100644 index 0000000..a7c6e2f --- /dev/null +++ b/source/ui/elements/game/tooltips/CraftingTooltipDisplay.cs @@ -0,0 +1,97 @@ +using Celesteia.Resources.Types; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.UI.Elements.Game.Tooltips { + public class CraftingTooltipDisplay : TooltipDisplay + { + private const float OUTER_SPACING = 16f; + private const float INNER_SPACING = 8f; + public readonly Container Content; + public readonly Label Title; + public readonly ItemDisplay Item; + public Container Recipe; + + public CraftingTooltipDisplay(Rect rect, Texture2D background) : base(rect) { + AddChild(new Image(Rect.RelativeFull(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(256f + (2 * OUTER_SPACING)), + AbsoluteUnit.WithValue(64f + (1 * INNER_SPACING) + (2 * OUTER_SPACING)) + ))).SetTexture(background).MakePatches(4).SetColor(Color.White)); + + Content = new Container(new Rect( + AbsoluteUnit.WithValue(OUTER_SPACING), + AbsoluteUnit.WithValue(OUTER_SPACING), + AbsoluteUnit.WithValue(256f), + AbsoluteUnit.WithValue(64f + (1 * INNER_SPACING)) + )); + + Container titleCard = new Container(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + new RelativeUnit(1f, Content.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(32f) + )); + titleCard.AddChild(Item = new ItemDisplay(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(32f), + AbsoluteUnit.WithValue(32f) + )) { + Text = new TextProperties().Standard().SetTextAlignment(TextAlignment.Bottom | TextAlignment.Right) + }); + titleCard.AddChild(Title = new Label(new Rect( + AbsoluteUnit.WithValue(72f), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(150f), + AbsoluteUnit.WithValue(32f) + )).SetTextProperties(new Properties.TextProperties().Standard().SetTextAlignment(TextAlignment.Left)).SetPivotPoint(new Vector2(0f, 0f))); + Content.AddChild(titleCard); + + Recipe = new Container(new Rect( + new RelativeUnit(.5f, Content.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(32f + INNER_SPACING), + new RelativeUnit(1f, Content.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(32f) + )); + Content.AddChild(Recipe); + + AddChild(Content); + + SetEnabled(false); + } + + public void SetRecipe(Recipe recipe) { + Item.Item = recipe.Result.GetItemType(); + Title.SetText(recipe.Result.GetItemType().Name); + + if (Recipe != null) Recipe.Dispose(); + Recipe = new Container(new Rect( + new RelativeUnit(0f, Content.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(32f + INNER_SPACING), + new RelativeUnit(1f, Content.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(32f) + )); + Recipe.SetPivot(new Vector2(0f, 0f)); + + for (int i = 0; i < recipe.Ingredients.Count; i++) + Recipe.AddChild(new ItemDisplay(new Rect( + AbsoluteUnit.WithValue((i * INNER_SPACING) + (i * 32)), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(32f), + AbsoluteUnit.WithValue(32f) + )) { + Item = recipe.Ingredients[i].GetItemType(), + Amount = recipe.Ingredients[i].Amount, + Text = new TextProperties().Standard() + .SetTextAlignment(TextAlignment.Bottom | TextAlignment.Right) + .SetFontSize(12f) + .SetText(recipe.Ingredients[i].Amount.ToString()) + }); + + Content.AddChild(Recipe); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/tooltips/ItemDisplay.cs b/source/ui/elements/game/tooltips/ItemDisplay.cs new file mode 100644 index 0000000..d3b1524 --- /dev/null +++ b/source/ui/elements/game/tooltips/ItemDisplay.cs @@ -0,0 +1,21 @@ +using Celesteia.Resources.Types; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.TextureAtlases; + +namespace Celesteia.UI.Elements.Game.Tooltips { + public class ItemDisplay : Element { + public ItemType Item; + public int Amount; + public TextProperties Text; + + public ItemDisplay(Rect rect) => SetRect(rect); + + public override void Draw(SpriteBatch spriteBatch) + { + spriteBatch.Draw(Item.Sprite, GetRectangle(), Color.White, null); + if (Amount > 1) TextUtilities.DrawAlignedText(spriteBatch, GetRectangle(), Text); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/tooltips/ItemTooltipDisplay.cs b/source/ui/elements/game/tooltips/ItemTooltipDisplay.cs new file mode 100644 index 0000000..9b62af4 --- /dev/null +++ b/source/ui/elements/game/tooltips/ItemTooltipDisplay.cs @@ -0,0 +1,62 @@ +using Celesteia.Resources.Types; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.UI.Elements.Game.Tooltips { + public class ItemTooltipDisplay : TooltipDisplay + { + private const float OUTER_SPACING = 16f; + private const float INNER_SPACING = 8f; + public readonly Container Content; + public readonly Label Title; + public readonly ItemDisplay Item; + + public ItemTooltipDisplay(Rect rect, Texture2D background) : base(rect) { + AddChild(new Image(Rect.RelativeFull(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(256f + (2 * OUTER_SPACING)), + AbsoluteUnit.WithValue(32f + (2 * OUTER_SPACING)) + ))).SetTexture(background).MakePatches(4).SetColor(Color.White)); + + Content = new Container(new Rect( + AbsoluteUnit.WithValue(OUTER_SPACING), + AbsoluteUnit.WithValue(OUTER_SPACING), + AbsoluteUnit.WithValue(256f), + AbsoluteUnit.WithValue(32f) + )); + + Container titleCard = new Container(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + new RelativeUnit(1f, Content.GetRect(), RelativeUnit.Orientation.Horizontal), + AbsoluteUnit.WithValue(32f) + )); + titleCard.AddChild(Item = new ItemDisplay(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(32f), + AbsoluteUnit.WithValue(32f) + )) { + Text = new TextProperties().Standard().SetTextAlignment(TextAlignment.Bottom | TextAlignment.Right) + }); + titleCard.AddChild(Title = new Label(new Rect( + AbsoluteUnit.WithValue(72f), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(150f), + AbsoluteUnit.WithValue(32f) + )).SetTextProperties(new Properties.TextProperties().Standard().SetTextAlignment(TextAlignment.Left)).SetPivotPoint(new Vector2(0f, 0f))); + Content.AddChild(titleCard); + + AddChild(Content); + + SetEnabled(false); + } + + public void SetItem(ItemType type) { + Item.Item = type; + Title.SetText(type.Name); + } + } +}
\ No newline at end of file diff --git a/source/ui/elements/game/tooltips/TooltipDisplay.cs b/source/ui/elements/game/tooltips/TooltipDisplay.cs new file mode 100644 index 0000000..2ff051d --- /dev/null +++ b/source/ui/elements/game/tooltips/TooltipDisplay.cs @@ -0,0 +1,8 @@ +using Microsoft.Xna.Framework; + +namespace Celesteia.UI.Elements.Game.Tooltips { + public class TooltipDisplay : Container + { + public TooltipDisplay(Rect rect) : base(rect) {} + } +}
\ No newline at end of file diff --git a/source/ui/guis/DebugGUI.cs b/source/ui/guis/DebugGUI.cs new file mode 100644 index 0000000..7ee44ae --- /dev/null +++ b/source/ui/guis/DebugGUI.cs @@ -0,0 +1,66 @@ +using System.Diagnostics; +using Celesteia.Resources; +using Celesteia.UI; +using Celesteia.UI.Elements; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Content; +using MonoGame.Extended; + +namespace Celesteia.GUIs { + public class DebugGUI : GUI { + private new GameInstance Game => (GameInstance) base.Game; + public DebugGUI(GameInstance game) : base(game, Rect.ScreenFull) {} + + private Label updateLabel; + private Label drawLabel; + + public override void LoadContent(ContentManager Content) { + float fontSize = 12f; + + Label template = new Label(new Rect( + AbsoluteUnit.WithValue(10), + AbsoluteUnit.WithValue(10), + AbsoluteUnit.WithValue(200), + AbsoluteUnit.WithValue(50) + )) + .SetTextProperties(new TextProperties() + .SetColor(Color.White) + .SetFont(ResourceManager.Fonts.GetFontType("Hobo")) + .SetFontSize(fontSize) + .SetTextAlignment(TextAlignment.Top | TextAlignment.Left) + ); + float textSpacing = 4f; + float textRow(int number) => 10f + number * (fontSize + textSpacing); + + Root.AddChild(template.Clone().SetNewRect(template.GetRect().SetY(AbsoluteUnit.WithValue(textRow(0)))).SetText($"Celesteia {GameInstance.Version}")); + Root.AddChild(updateLabel = template.Clone().SetNewRect(template.GetRect().SetY(AbsoluteUnit.WithValue(textRow(1)))).SetText("")); + Root.AddChild(drawLabel = template.Clone().SetNewRect(template.GetRect().SetY(AbsoluteUnit.WithValue(textRow(2)))).SetText("")); + + Debug.WriteLine("Loaded Debug GUI."); + } + + private double updateTime; + private double lastUpdate; + public override void Update(GameTime gameTime, out bool clickedAnything) { + clickedAnything = false; + + updateTime = gameTime.TotalGameTime.TotalMilliseconds - lastUpdate; + lastUpdate = gameTime.TotalGameTime.TotalMilliseconds; + + updateLabel.SetText($"Update: {updateTime.ToString("0.00")}ms"); + } + + private double drawTime; + private double lastDraw; + public override void Draw(GameTime gameTime) + { + drawTime = gameTime.TotalGameTime.TotalMilliseconds - lastDraw; + lastDraw = gameTime.TotalGameTime.TotalMilliseconds; + + drawLabel.SetText($"Draw: {drawTime.ToString("0.00")}ms"); + + if (GameInstance.DebugMode) base.Draw(gameTime); + } + } +}
\ No newline at end of file diff --git a/source/ui/guis/GUI.cs b/source/ui/guis/GUI.cs new file mode 100644 index 0000000..6d00070 --- /dev/null +++ b/source/ui/guis/GUI.cs @@ -0,0 +1,48 @@ +using System.Diagnostics; +using Celesteia.UI; +using Celesteia.UI.Elements; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.GUIs { + public class GUI { + public GameInstance Game; + + public IContainer Root; + + public GUI(GameInstance Game, Rect rect) { + this.Game = Game; + this.Root = new Container(rect); + } + + public virtual void LoadContent(ContentManager Content) { + Debug.WriteLine("Loaded GUI."); + } + + public virtual void Update(GameTime gameTime, out bool clickedAnything) { + if (!Game.IsActive) { + clickedAnything = false; + return; + } + + Root.Update(gameTime, out clickedAnything); + } + + // Draw all elements. + public virtual void Draw(GameTime gameTime) { + + Game.SpriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied, SamplerState.PointWrap, null, null, null); + + if (UIReferences.GUIEnabled) Root.Draw(Game.SpriteBatch); + + Game.SpriteBatch.End(); + } + + // If the menu is referred to as a boolean, return whether it is non-null (true) or null (false). + public static implicit operator bool(GUI gui) + { + return !object.ReferenceEquals(gui, null); + } + } +}
\ No newline at end of file diff --git a/source/ui/guis/MainMenu.cs b/source/ui/guis/MainMenu.cs new file mode 100644 index 0000000..dd03d5a --- /dev/null +++ b/source/ui/guis/MainMenu.cs @@ -0,0 +1,225 @@ +using System.Diagnostics; +using Celesteia.Game.ECS; +using Celesteia.Resources; +using Celesteia.Screens; +using Celesteia.UI; +using Celesteia.UI.Elements; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.Graphics; + +namespace Celesteia.GUIs { + public class MainMenu : GUI { + public MainMenu(GameInstance game) : base(game, Rect.ScreenFull) {} + + private Texture2D logo; + private Texture2D buttonTexture; + + private IContainer MainScreen; + private IContainer OptionsScreen; + private IContainer NewWorldScreen; + + private IContainer LogoPivot; + private Label Progress; + + private Button buttonTemplate; + private float buttonRow(int number) => number * (buttonHeight + buttonSpacing); + private float buttonHeight = 56f; + private float buttonSpacing = 10f; + + public override void LoadContent(ContentManager Content) { + logo = Game.Content.Load<Texture2D>("celesteia/logo"); + buttonTexture = Game.Content.Load<Texture2D>("sprites/ui/button"); + + buttonTemplate = new Button(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(buttonRow(0)), + AbsoluteUnit.WithValue(250f), + AbsoluteUnit.WithValue(56f) + )) + .SetPivotPoint(new Vector2(.5f)) + .SetTexture(buttonTexture) + .MakePatches(4) + .SetTextProperties(new TextProperties() + .SetColor(Color.White) + .SetFont(ResourceManager.Fonts.GetFontType("Hobo")) + .SetFontSize(24f) + .SetTextAlignment(TextAlignment.Center)) + .SetColorGroup(new ButtonColorGroup(Color.White, Color.Black, Color.Violet, Color.DarkViolet)); + + // Load all the screens. + LoadMainScreen(); + LoadOptionsScreen(); + LoadNewWorldScreen(); + LoadGlobals(); + + base.LoadContent(Content); + } + + private void LoadMainScreen() { + Root.AddChild(MainScreen = new Container(Rect.ScreenFull)); + MainScreen.SetEnabled(true); + + IContainer menu = new Container(new Rect( + new ScreenSpaceUnit(.5f, ScreenSpaceUnit.ScreenSpaceOrientation.Horizontal), + new ScreenSpaceUnit(.5f, ScreenSpaceUnit.ScreenSpaceOrientation.Vertical), + AbsoluteUnit.WithValue(250f), + AbsoluteUnit.WithValue(0f) + )); + + menu.AddChild(LogoPivot = new Container(new Rect( + AbsoluteUnit.WithValue(0f), + new ScreenSpaceUnit(-.25f, ScreenSpaceUnit.ScreenSpaceOrientation.Vertical), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f) + ))); + + float logoRatio = logo.Height / (float) logo.Width; + LogoPivot.AddChild( + new Image(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + new ScreenSpaceUnit(.4f, ScreenSpaceUnit.ScreenSpaceOrientation.Horizontal), + new ScreenSpaceUnit(.4f * logoRatio, ScreenSpaceUnit.ScreenSpaceOrientation.Horizontal) + )) + .SetTexture(logo) + .SetColor(Color.White) + .SetPivotPoint(new Vector2(.5f)) + ); + + menu.AddChild( + buttonTemplate.Clone() + .SetNewRect(buttonTemplate.GetRect() + .SetY(AbsoluteUnit.WithValue(buttonRow(0))) + .SetWidth(new RelativeUnit(1f, menu.GetRect(), RelativeUnit.Orientation.Horizontal)) + ) + .SetOnMouseUp(async (button, position) => { + ShowNewWorldScreen(); + Debug.WriteLine("Generating world..."); + GameWorld _gameWorld = await Game.Worlds.LoadNewWorld((progressReport) => { + Progress.SetText(progressReport); + Debug.WriteLine(" " + progressReport); + }); + Game.LoadScreen( + new GameplayScreen(Game, _gameWorld), + new MonoGame.Extended.Screens.Transitions.FadeTransition(Game.GraphicsDevice, Color.Black) + ); + }) + .SetText("Start Game") + ); + + menu.AddChild( + buttonTemplate.Clone() + .SetNewRect(buttonTemplate.GetRect() + .SetY(AbsoluteUnit.WithValue(buttonRow(1))) + .SetWidth(new RelativeUnit(1f, menu.GetRect(), RelativeUnit.Orientation.Horizontal)) + ) + .SetOnMouseUp((button, position) => { ShowOptionsScreen(); }) + .SetText("Options") + ); + + menu.AddChild( + buttonTemplate.Clone() + .SetNewRect(buttonTemplate.GetRect() + .SetY(AbsoluteUnit.WithValue(buttonRow(2))) + .SetWidth(new RelativeUnit(1f, menu.GetRect(), RelativeUnit.Orientation.Horizontal)) + ) + .SetOnMouseUp((button, position) => { Game.Exit(); }) + .SetText("Quit Game") + .SetColorGroup(new ButtonColorGroup(Color.White, Color.Black, Color.Red, Color.DarkRed)) + ); + + MainScreen.AddChild(menu); + } + private void ShowMainScreen() { + MainScreen.SetEnabled(true); + OptionsScreen.SetEnabled(false); + NewWorldScreen.SetEnabled(false); + } + + private void LoadOptionsScreen() { + Root.AddChild(OptionsScreen = new Container(Rect.ScreenFull)); + OptionsScreen.SetEnabled(false); + + IContainer menu = new Container(new Rect( + new ScreenSpaceUnit(.5f, ScreenSpaceUnit.ScreenSpaceOrientation.Horizontal), + new ScreenSpaceUnit(.5f, ScreenSpaceUnit.ScreenSpaceOrientation.Vertical), + AbsoluteUnit.WithValue(450f), + AbsoluteUnit.WithValue(0f) + )); + + menu.AddChild( + buttonTemplate.Clone() + .SetNewRect(buttonTemplate.GetRect() + .SetY(AbsoluteUnit.WithValue(buttonRow(0))) + .SetWidth(new RelativeUnit(1f, menu.GetRect(), RelativeUnit.Orientation.Horizontal)) + ) + .SetOnMouseUp((button, position) => { ShowMainScreen(); }) + .SetText("Back to Main Menu") + ); + + OptionsScreen.AddChild(menu); + } + private void ShowOptionsScreen() { + MainScreen.SetEnabled(false); + OptionsScreen.SetEnabled(true); + NewWorldScreen.SetEnabled(false); + } + + private void LoadNewWorldScreen() { + Root.AddChild(NewWorldScreen = new Container(Rect.ScreenFull)); + NewWorldScreen.SetEnabled(false); + + NewWorldScreen.AddChild(Progress = new Label( + new Rect( + new ScreenSpaceUnit(.5f, ScreenSpaceUnit.ScreenSpaceOrientation.Horizontal), + new ScreenSpaceUnit(.5f, ScreenSpaceUnit.ScreenSpaceOrientation.Vertical), + AbsoluteUnit.WithValue(200), + AbsoluteUnit.WithValue(50) + )) + .SetPivotPoint(new Vector2(0.5f, 0.5f)) + .SetTextProperties(new TextProperties() + .SetColor(Color.White) + .SetFont(ResourceManager.Fonts.DEFAULT) + .SetFontSize(24f) + .SetTextAlignment(TextAlignment.Center) + ) + .SetText("") + ); + } + private void ShowNewWorldScreen() { + MainScreen.SetEnabled(false); + OptionsScreen.SetEnabled(false); + NewWorldScreen.SetEnabled(true); + } + + private void LoadGlobals() { + Container copyPivot = new Container(new Rect( + new RelativeUnit(.5f, Root.GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(1f, Root.GetRect(), RelativeUnit.Orientation.Vertical), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(12f) + )); + copyPivot.SetPivot(new Vector2(.5f, 1f)); + Root.AddChild(copyPivot); + + copyPivot.AddChild(new Label( + new Rect( + AbsoluteUnit.WithValue(12f), + AbsoluteUnit.WithValue(0f), + new RelativeUnit(1f, Root.GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(1f, copyPivot.GetRect(), RelativeUnit.Orientation.Vertical) + ) + ) + .SetTextProperties(new TextProperties() + .SetFont(ResourceManager.Fonts.DEFAULT) + .SetColor(Color.White) + .SetFontSize(12f) + .SetTextAlignment(TextAlignment.Bottom | TextAlignment.Center) + ) + .SetText("(c) leafal.io 2022-2023, all rights reserved.") + .SetPivotPoint(new Vector2(0.5f, 1f))); + } + } +}
\ No newline at end of file diff --git a/source/ui/guis/game/GameGUI.cs b/source/ui/guis/game/GameGUI.cs new file mode 100644 index 0000000..b8e6f4a --- /dev/null +++ b/source/ui/guis/game/GameGUI.cs @@ -0,0 +1,349 @@ +using System.Collections.Generic; +using System.Diagnostics; +using Celesteia.Game.Components.Items; +using Celesteia.Game.Input; +using Celesteia.Resources; +using Celesteia.UI; +using Celesteia.UI.Elements; +using Celesteia.UI.Elements.Game; +using Celesteia.UI.Elements.Game.Controls; +using Celesteia.UI.Elements.Game.Tooltips; +using Celesteia.UI.Properties; +using Microsoft.Xna.Framework; +using Microsoft.Xna.Framework.Content; +using Microsoft.Xna.Framework.Graphics; +using MonoGame.Extended.TextureAtlases; + +namespace Celesteia.GUIs.Game { + public class GameGUI : GUI + { + private new GameInstance Game => (GameInstance) base.Game; + public GameGUI(GameInstance Game) : base(Game, Rect.ScreenFull) { } + + + public ItemStack CursorItem; + + private IContainer _pauseMenu; + + public ControlTips Controls { get; private set; } + + private IContainer ItemManagement; + + private InventorySlot _slotTemplate; + private CraftingRecipeSlot _recipeTemplate; + private IContainer Hotbar; + + + private Texture2D slotTexture; + private TextureAtlas slotPatches; + private Texture2D windowTexture; + private Texture2D tooltipTexture; + + private Inventory _inventory; + private List<InventorySlot> _slots; + + private int _hotbarSelection = 0; + public int HotbarSelection { + get => _hotbarSelection; + set { + _hotbarSelection = MathHelper.Clamp(value, 0, HotbarSlots - 1); + UpdateSelected(); + } + } + public readonly int HotbarSlots = 9; + + private IContainer _mousePivot; + private IContainer _inventoryScreen; + private IContainer _craftingScreen; + + private InventoryScreenState _state; + public InventoryScreenState State { + get => _state; + set { + _state = value; + _inventoryScreen.SetEnabled((int)_state > 0); + _craftingScreen.SetEnabled((int)_state > 1); + + if ((int)_state < 1 && CursorItem != null) { + ItemStack item = CursorItem; + CursorItem = null; + + _inventory.AddItem(item); + } + } + } + + private ItemTooltipDisplay _itemDisplay; + private bool _itemDisplayEnabled = false; + private CraftingTooltipDisplay _craftingDisplay; + private bool _craftingDisplayEnabled = false; + + public void SetReferenceInventory(Inventory inventory) { + _inventory = inventory; + + _slotTemplate.SetReferenceInventory(_inventory); + + LoadHotbar(); + LoadInventoryScreen(); + LoadCraftingScreen(); + + State = _state; + } + + public override void LoadContent(ContentManager Content) + { + Root.AddChild(Controls = new ControlTips(new Rect( + AbsoluteUnit.WithValue(8f), + new RelativeUnit(0.5f, Root.GetRect(), RelativeUnit.Orientation.Vertical), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f) + ))); + + slotTexture = Content.Load<Texture2D>("sprites/ui/button"); + windowTexture = Content.Load<Texture2D>("sprites/ui/button"); + tooltipTexture = Content.Load<Texture2D>("sprites/ui/window"); + slotPatches = TextureAtlas.Create("patches", slotTexture, 4, 4); + + LoadTooltipDisplays(Content); + LoadPauseMenu(Content); + + _slotTemplate = new InventorySlot(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(-InventorySlot.SLOT_SPACING), + AbsoluteUnit.WithValue(InventorySlot.SLOT_SIZE), + AbsoluteUnit.WithValue(InventorySlot.SLOT_SIZE) + )) + .SetTexture(slotTexture) + .SetPatches(slotPatches, 4) + .SetTextProperties(new TextProperties() + .SetColor(Color.White) + .SetFont(ResourceManager.Fonts.GetFontType("Hobo")) + .SetFontSize(16f) + .SetTextAlignment(TextAlignment.Bottom | TextAlignment.Center) + ) + .SetOnMouseIn((item) => { + if ((int)State < 1) return; + _itemDisplay.SetItem(item); + _itemDisplayEnabled = true; + }) + .SetOnMouseOut(() => _itemDisplayEnabled = false); + + _recipeTemplate = new CraftingRecipeSlot(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(-CraftingRecipeSlot.SLOT_SPACING), + AbsoluteUnit.WithValue(CraftingRecipeSlot.SLOT_SIZE), + AbsoluteUnit.WithValue(CraftingRecipeSlot.SLOT_SIZE) + )) + .SetTexture(slotTexture) + .SetPatches(slotPatches, 4) + .SetTextProperties(new TextProperties() + .SetColor(Color.White) + .SetFont(ResourceManager.Fonts.GetFontType("Hobo")) + .SetFontSize(16f) + .SetTextAlignment(TextAlignment.Bottom | TextAlignment.Right) + ) + .SetOnMouseIn((recipe) => { + if ((int)State < 2) return; + _craftingDisplay.SetRecipe(recipe); + _craftingDisplayEnabled = true; + }) + .SetOnMouseOut(() => _craftingDisplayEnabled = false); + + _slots = new List<InventorySlot>(); + + ItemManagement = new Container(Rect.ScreenFull); + Root.AddChild(ItemManagement); + + LoadHotbar(); + + Debug.WriteLine("Loaded Game GUI."); + } + + public bool Paused { get; private set; } + public void TogglePause() { + Paused = !Paused; + UpdatePauseMenu(); + } + + private void LoadPauseMenu(ContentManager Content) { + _pauseMenu = new PauseMenu(this, Rect.ScreenFull, + new Button(new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(250f), + AbsoluteUnit.WithValue(56f) + )) + .SetPivotPoint(new Vector2(.5f)) + .SetTexture(Content.Load<Texture2D>("sprites/ui/button")) + .MakePatches(4) + .SetTextProperties(new TextProperties() + .SetColor(Color.White) + .SetFont(ResourceManager.Fonts.GetFontType("Hobo")) + .SetFontSize(24f) + .SetTextAlignment(TextAlignment.Center)) + .SetColorGroup(new ButtonColorGroup(Color.White, Color.Black, Color.Violet, Color.DarkViolet)) + ); + + Root.AddChild(_pauseMenu); + + UpdatePauseMenu(); + } + + private void LoadTooltipDisplays(ContentManager Content) { + _mousePivot = new Container(new Rect( + AbsoluteUnit.WithValue(0f) + )); + + _itemDisplay = new ItemTooltipDisplay(new Rect( + AbsoluteUnit.WithValue(16f), + AbsoluteUnit.WithValue(16f), + AbsoluteUnit.WithValue(256f), + AbsoluteUnit.WithValue(64f) + ), tooltipTexture); + _itemDisplay.SetPivot(new Vector2(0f, 1f)); + + _mousePivot.AddChild(_itemDisplay); + + _craftingDisplay = new CraftingTooltipDisplay(new Rect( + AbsoluteUnit.WithValue(16f), + AbsoluteUnit.WithValue(16f), + AbsoluteUnit.WithValue(256f), + AbsoluteUnit.WithValue(64f) + ), tooltipTexture); + _craftingDisplay.SetPivot(new Vector2(0f, 0f)); + + _mousePivot.AddChild(_craftingDisplay); + } + + private void LoadHotbar() { + if (Hotbar != null) { + Hotbar.Dispose(); + _slots.Clear(); + } + + Hotbar = new Container(new Rect( + new RelativeUnit(0.5f, ItemManagement.GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(1f, ItemManagement.GetRect(), RelativeUnit.Orientation.Vertical), + AbsoluteUnit.WithValue((HotbarSlots * InventorySlot.SLOT_SIZE) + ((HotbarSlots - 1) * InventorySlot.SLOT_SPACING)), + AbsoluteUnit.WithValue(InventorySlot.SLOT_SIZE) + )); + Hotbar.SetPivot(new Vector2(0.5f, 1f)); + + for (int i = 0; i < HotbarSlots; i++) { + int slotNumber = i; + InventorySlot slot = _slotTemplate.Clone() + .SetNewRect(_slotTemplate.GetRect().SetX(AbsoluteUnit.WithValue(i * InventorySlot.SLOT_SIZE + (i * InventorySlot.SLOT_SPACING)))) + .SetSlot(slotNumber) + .SetOnMouseUp((button, point) => { + if ((int)State < 1) { + HotbarSelection = slotNumber; + UpdateSelected(); + } else { + ItemStack itemInSlot = _inventory.GetSlot(slotNumber); + + _inventory.SetSlot(slotNumber, CursorItem); + CursorItem = itemInSlot; + } + }); + slot.SetPivot(new Vector2(0f, 0f)); + slot.SetEnabled(true); + + _slots.Add(slot); + Hotbar.AddChild(slot); + } + + UpdateSelected(); + + ItemManagement.AddChild(Hotbar); + } + + private void LoadInventoryScreen() { + int remainingSlots = _inventory.Capacity - HotbarSlots; + int rows = (remainingSlots / HotbarSlots); + + Container pivot = new Container(new Rect( + new RelativeUnit(0.5f, ItemManagement.GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(1f, ItemManagement.GetRect(), RelativeUnit.Orientation.Vertical), + new AbsoluteUnit((HotbarSlots * InventorySlot.SLOT_SIZE) + ((HotbarSlots + 1) * InventorySlot.SLOT_SPACING)), + new AbsoluteUnit((rows * InventorySlot.SLOT_SIZE) + ((rows + 1) * InventorySlot.SLOT_SPACING)) + )); + + _inventoryScreen = new InventoryWindow(this, new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(-(InventorySlot.SLOT_SIZE + (2 * InventorySlot.SLOT_SPACING))), + new RelativeUnit(1f, pivot.GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(1f, pivot.GetRect(), RelativeUnit.Orientation.Vertical) + ), windowTexture, _inventory, remainingSlots, HotbarSlots, _slotTemplate); + _inventoryScreen.SetPivot(new Vector2(0.5f, 1f)); + + pivot.AddChild(_inventoryScreen); + ItemManagement.AddChild(pivot); + } + + private void LoadCraftingScreen() { + int remainingSlots = _inventory.Capacity - HotbarSlots; + int rows = (remainingSlots / HotbarSlots); + + Container pivot = new Container(new Rect( + new RelativeUnit(0.5f, ItemManagement.GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(0f, ItemManagement.GetRect(), RelativeUnit.Orientation.Vertical), + new AbsoluteUnit((HotbarSlots * CraftingRecipeSlot.SLOT_SIZE) + ((HotbarSlots + 1) * CraftingRecipeSlot.SLOT_SPACING)), + new AbsoluteUnit((rows * CraftingRecipeSlot.SLOT_SIZE) + ((rows + 1) * CraftingRecipeSlot.SLOT_SPACING)) + )); + + _craftingScreen = new CraftingWindow(this, new Rect( + AbsoluteUnit.WithValue(0f), + AbsoluteUnit.WithValue(CraftingRecipeSlot.SLOT_SPACING), + new RelativeUnit(1f, pivot.GetRect(), RelativeUnit.Orientation.Horizontal), + new RelativeUnit(1f, pivot.GetRect(), RelativeUnit.Orientation.Vertical) + ), windowTexture, _inventory, _recipeTemplate); + _craftingScreen.SetPivot(new Vector2(0.5f, 0f)); + + pivot.AddChild(_craftingScreen); + ItemManagement.AddChild(pivot); + } + + public override void Update(GameTime gameTime, out bool clickedAnything) + { + _mousePivot.MoveTo(MouseHelper.Position); + _itemDisplay.SetEnabled(_itemDisplayEnabled && (int)_state > 0); + _craftingDisplay.SetEnabled(_craftingDisplayEnabled && (int)_state > 1); + + base.Update(gameTime, out clickedAnything); + } + + private Color _slightlyTransparent = new Color(255, 255, 255, 175); + private Vector2 scale = new Vector2(2f); + public override void Draw(GameTime gameTime) + { + base.Draw(gameTime); + + Game.SpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied, SamplerState.PointClamp, null, null, null); + + if (CursorItem != null) Game.SpriteBatch.Draw(CursorItem.Type.Sprite, MouseHelper.Position.ToVector2(), _slightlyTransparent, 0f, Vector2.Zero, scale, SpriteEffects.None, 0f); + else { + _itemDisplay.Draw(Game.SpriteBatch); + _craftingDisplay.Draw(Game.SpriteBatch); + } + + Game.SpriteBatch.End(); + } + + public ItemStack GetSelectedItem() { + return _inventory.GetSlot(HotbarSelection); + } + + private void UpdateSelected() { + _slots.ForEach(slot => slot.SetSelected(false)); + _slots[HotbarSelection].SetSelected(true); + } + + private void UpdatePauseMenu() { + _pauseMenu.SetEnabled(Paused); + } + } + + public enum InventoryScreenState { + Closed, Inventory, Crafting + } +}
\ No newline at end of file diff --git a/source/ui/properties/TextProperties.cs b/source/ui/properties/TextProperties.cs new file mode 100644 index 0000000..2ee4deb --- /dev/null +++ b/source/ui/properties/TextProperties.cs @@ -0,0 +1,62 @@ +using Celesteia.Resources; +using Celesteia.Resources.Management; +using Microsoft.Xna.Framework; + +namespace Celesteia.UI.Properties { + public struct TextProperties { + private string _text; + private FontType _font; + private Color _textColor; + private float _fontSize; + private TextAlignment _textAlignment; + + public TextProperties Standard() { + _text = ""; + _font = ResourceManager.Fonts.DEFAULT; + _textColor = Color.White; + _fontSize = 16f; + _textAlignment = TextAlignment.Center; + + return this; + } + + public TextProperties SetText(string text) { + _text = text; + return this; + } + public string GetText() => _text; + + public TextProperties SetFont(FontType font) { + _font = font; + return this; + } + public FontType GetFont() => _font; + + public TextProperties SetColor(Color textColor) { + _textColor = textColor; + return this; + } + public Color GetColor() => _textColor; + + public TextProperties SetFontSize(float fontSize) { + _fontSize = fontSize; + return this; + } + public float GetFontSize() => _fontSize; + + public TextProperties SetTextAlignment(TextAlignment textAlignment) { + _textAlignment = textAlignment; + return this; + } + public TextAlignment GetAlignment() => _textAlignment; + + public TextProperties Clone() { + return new TextProperties() + .SetColor(_textColor) + .SetFont(_font) + .SetFontSize(_fontSize) + .SetText(_text) + .SetTextAlignment(_textAlignment); + } + } +}
\ No newline at end of file |