OneNightDuel/ONDClient/GUI/UIElement.cs

using System;
using System.Collections.Generic;
using System.Net.Mime;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using MonoGameLibrary;
using MonoGameLibrary.Graphics;
using MonoGameLibrary.Input;

namespace ONDClient.GUI;

public class UIElement {
    
    public bool Active { get; set; } = true;
    public bool Pressable { get; set; } = false;
    public bool Visible { get; set; } = true;
    public int DrawPriority { get; } = 0;

    protected (Point, Point) _bounds;
    public (Point, Point) Bounds{
        get => _bounds;
        protected set { _bounds = value; UpdateBounds(); }
    }
    
    protected (Point, Point) screenSpaceBounds;
    public List<TextureRegion> Textures = new();
    protected int currentTextureId = 0;

    private float _scaleMultiplier = 1;
    public float ScaleMultiplier{
        get{
            return _scaleMultiplier;
        }
        set{
            _scaleMultiplier = value;
            LoadPixelScaleMultiplier();
        }
    }
    protected int pixelScaleMultiplier = 1;
    private void LoadPixelScaleMultiplier() {
        pixelScaleMultiplier = (int)(UIManager.GlobalPixelMultiplier * _scaleMultiplier); // TODO: move GlobalPixelMultiplier somewhere where it would make sense
        UpdateBounds();
    }

    protected virtual void UpdateBounds() {
        _bounds = (Bounds.Item1, (Bounds.Item2 - Bounds.Item1).MultiplyByScalar(ScaleMultiplier) + Bounds.Item1);
        screenSpaceBounds = (Bounds.Item1.MultiplyByScalar(pixelScaleMultiplier), Bounds.Item2.MultiplyByScalar(pixelScaleMultiplier));
    }
    
    public UIElement(TextureRegion texture, Point position, int drawPriority = 0) {
        Textures.Add(texture);
        Bounds = (position, position + new Point(texture.Width, texture.Height));
        DrawPriority = drawPriority;
        LoadPixelScaleMultiplier();
    }
    public UIElement(TextureRegion[] textures, Point position, int drawPriority = 0) {
        this.Textures.AddRange(textures);
        Bounds = (position, position + new Point(textures[0].Width, textures[0].Height));
        DrawPriority = drawPriority;
        LoadPixelScaleMultiplier();
    }

    public UIElement(Point corner1, Point corner2) {
        Bounds = (corner1, corner2);
        Visible = false;
        LoadPixelScaleMultiplier();
    }
    
    public virtual void SetTexture(int textureId) {
        if (textureId >= Textures.Count){
            Console.WriteLine($"WARNING: TEXTURE {textureId} OUT OF BOUNDS");
            return;
        }
            
        currentTextureId = textureId;
    }
    public virtual void Update() { }

    public bool IsWithinBounds(Point pos) {
        return pos.X >= Math.Min(screenSpaceBounds.Item1.X, screenSpaceBounds.Item2.X) && pos.X <= Math.Max(screenSpaceBounds.Item1.X, screenSpaceBounds.Item2.X) &&
               pos.Y >= Math.Min(screenSpaceBounds.Item1.Y, screenSpaceBounds.Item2.Y) && pos.Y <= Math.Max(screenSpaceBounds.Item1.Y, screenSpaceBounds.Item2.Y);
    }

    public Action OnMousePress{ get; set; } 
    
    // public virtual void OnMousePress() { }
    
    public virtual void OnMouseRelease() { }
    
    public virtual void OnMouseHold() { }

    public virtual void Draw(SpriteBatch spriteBatch) {
        if (!Visible || !Active || Textures.Count == 0){
            return;
        }
        
        Textures[currentTextureId].Draw(spriteBatch, screenSpaceBounds.Item1.ToVector2(), Color.White, 0, Vector2.Zero, pixelScaleMultiplier, SpriteEffects.None, 0);
        // texture.Draw(spriteBatch, bounds.Item1.ToVector2(), Color.White);
    }
    
    public void SetPosition(Point position) {
        Bounds = (position, position + new Point(Textures[0].Width, Textures[0].Height));
    }

    public UIElement Clone() {
        return new UIElement(Textures.ToArray(), Bounds.Item1);
    }
    
    public TextureRegion[] GetTextures() => Textures.ToArray();
}