v5.0.0 - Added failsafe screen space constraint enforcing for widgets

Author: hamstar0

HUDElementsLib/Elements/VanillaHUDElement.cs

@@ -67,7 +67,7 @@ internal VanillaHUDElement( VanillaHUDElementDefinition def )
 		public override Vector2 GetHUDComputedPosition( bool applyDisplacement ) {
 			(Vector2 relPos, Vector2 percPos) = this.DynamicIntendedPosition();
 
-			this.CurrentRelativePosition = relPos;
+			this.CurrentPositionOffset = relPos;
 			this.CurrentPositionPercent = percPos;
 
 			return base.GetHUDComputedPosition( applyDisplacement );

HUDElementsLib/HUDElement.cs

@@ -22,12 +22,12 @@ public partial class HUDElement : UIElement {
 		/// <summary>
 		/// Original starting screen offset amount from percent anchors. Element will return here when user sets it to reset.
 		/// </summary>
-		protected Vector2 OriginalRelativePosition;
+		protected Vector2 OriginalPositionOffset;
 		/// <summary></summary>
 		protected Vector2 OriginalPositionPercent;
 
 		/// <summary>Get screen offset amount from percent anchors.</summary>
-		protected Vector2 CurrentRelativePosition;
+		protected Vector2 CurrentPositionOffset;
 		/// <summary></summary>
 		protected Vector2 CurrentPositionPercent;
 
@@ -68,8 +68,8 @@ public HUDElement(
 					Func<bool> enabler ) : base() {
 			this.Name = name;
 
-			this.OriginalRelativePosition = positionOffset;
-			this.CurrentRelativePosition = positionOffset;
+			this.OriginalPositionOffset = positionOffset;
+			this.CurrentPositionOffset = positionOffset;
 
 			this.OriginalPositionPercent = positionPercent;
 			this.CurrentPositionPercent = positionPercent;
@@ -128,7 +128,7 @@ public virtual bool ConsumesCursor() {
 		////////////////
 
 		public void ResetPositionToDefault() {
-			this.CurrentRelativePosition = this.OriginalRelativePosition;
+			this.CurrentPositionOffset = this.OriginalPositionOffset;
 		}
 	}
 }

HUDElementsLib/HUDElement_Physicality.cs

@@ -5,6 +5,34 @@
 
 namespace HUDElementsLib {
 	public partial class HUDElement : UIElement {
+		public static Vector2 ComputeScreenPosition( Vector2 positionOffset, Vector2 positionPercent ) {
+			return new Vector2(
+				(positionPercent.X * (float)Main.screenWidth ) + (float)positionOffset.X,
+				(positionPercent.Y * (float)Main.screenHeight ) + (float)positionOffset.Y
+			);
+		}
+
+		public static void FitOffsetToScreen( ref Vector2 positionOffset, Vector2 positionPercent, Vector2 dim ) {
+			Vector2 origScrPos = HUDElement.ComputeScreenPosition( positionOffset, positionPercent );
+			Vector2 origEdges = origScrPos + dim;
+
+			if( origScrPos.X < 0f ) {
+				positionOffset.X += -origScrPos.X;
+			} else if( origEdges.X > Main.screenWidth ) {
+				positionOffset.X += origEdges.X - Main.screenWidth;
+			}
+
+			if( origScrPos.Y < 0f ) {
+				positionOffset.Y += -origScrPos.Y;
+			} else if( origEdges.Y > Main.screenHeight ) {
+				positionOffset.Y += origEdges.Y - Main.screenHeight;
+			}
+		}
+
+
+
+		////////////////
+
 		public virtual bool AutoAnchors() {
 			return true;
 		}
@@ -17,18 +45,15 @@ public virtual bool AutoAnchors() {
 		/// </summary>
 		/// <returns></returns>
 		public virtual (Vector2 relative, Vector2 percent) GetIntendedPosition() {
-			return (this.CurrentRelativePosition, this.CurrentPositionPercent);
+			return (this.CurrentPositionOffset, this.CurrentPositionPercent);
 		}
 
 		/// <summary>
 		/// Gets intended screen position of element.
 		/// </summary>
 		/// <returns></returns>
 		public virtual Vector2 GetComputedIntendedPosition() {
-			return new Vector2(
-				(this.CurrentPositionPercent.X * (float)Main.screenWidth) + (float)this.CurrentRelativePosition.X,
-				(this.CurrentPositionPercent.Y * (float)Main.screenHeight) + (float)this.CurrentRelativePosition.Y
-			);
+			return HUDElement.ComputeScreenPosition( this.CurrentPositionOffset, this.CurrentPositionPercent );
 		}
 
 		/// <summary>
@@ -37,12 +62,12 @@ public virtual Vector2 GetComputedIntendedPosition() {
 		/// <param name="applyDisplacement">Gets the position of the element after being displaced by collisions.</param>
 		/// <returns></returns>
 		public virtual Vector2 GetHUDComputedPosition( bool applyDisplacement ) {
-			Vector2 pos = this.GetComputedIntendedPosition();
+			Vector2 scrPos = this.GetComputedIntendedPosition();
 
 			if( applyDisplacement && this.DisplacedOffset.HasValue ) {
-				return pos + this.DisplacedOffset.Value;
+				return scrPos + this.DisplacedOffset.Value;
 			} else {
-				return pos;
+				return scrPos;
 			}
 		}
 
@@ -105,7 +130,7 @@ public void SetIntendedPosition( Vector2 screenPos, bool conveyPercent ) {
 		/// <param name="relPos"></param>
 		/// <param name="percPos"></param>
 		public void SetIntendedPosition( Vector2 relPos, Vector2 percPos ) {
-			this.CurrentRelativePosition = relPos;
+			this.CurrentPositionOffset = relPos;
 			this.CurrentPositionPercent = percPos;
 		}
 

HUDElementsLib/HUDElement_Update.cs

@@ -47,6 +47,10 @@ private void UpdateHUD() {
 		////
 
 		private void UpdateHUDPosition() {
+			this.UpdateScreenSpaceConstraints();
+
+			//
+
 			Vector2 pos = this.GetHUDComputedPosition( true );
 			Vector2 dim = this.GetHUDComputedDimensions();
 
@@ -58,9 +62,20 @@ private void UpdateHUDPosition() {
 
 
 		////////////////
-
+		
 		protected virtual void PreUpdateWhileActive() { }
 
 		protected virtual void PostUpdateWhileActive() { }
+
+
+		////////////////
+
+		private void UpdateScreenSpaceConstraints() {
+			Vector2 dim = this.GetHUDComputedDimensions();
+
+			HUDElement.FitOffsetToScreen( ref this.OriginalPositionOffset, this.OriginalPositionPercent, dim );
+
+			HUDElement.FitOffsetToScreen( ref this.CurrentPositionOffset, this.CurrentPositionPercent, dim );
+		}
 	}
 }