To execute MonoBehaviour scripts continuously within the Unity Editor without entering playmode, attach the [ExecuteAlways] attribute to your class definition. This directive forces lifecycle methods like Update to run during editor idle cycles, allowing real-time adjustments for custom interface tools.

[ExecuteAlways]
public class EditorRuntimeHandler : MonoBehaviour
{
    private void Update()
    {
        if (!Application.isPlaying)
            Debug.Log("Editor script loop active");
    }
}

A reliable custom UI system frequently adopts nine-point alignment strategies. This mathematical model decouples element placement from absolute screen coordinates, enabling seamless adaptation across varying display resolutions. The core requirement involves a lightweight, non-MonoBehaviour data structure that resolves positional vectors independently.

Define an enumeration to map anchor points across the viewport perimeter:

public enum AnchorDirection
{
    Top,
    Bottom,
    Left,
    Right,
    Center,
    TopLeft,
    BottomLeft,
    TopRight,
    BottomRight
}

Construct a serializible container to hold layout parameters. Marking the type with [System.Serializable] exposes its properties in the Inspector for designer-level tweaking. The structure calculates pivot-relative offsets dynamically based on the chosen alignment mode.

[System.Serializable]
public struct LayoutCoordinateConfig
{
    public AnchorDirection ScreenOrigin;
    public AnchorDirection InternalPivot;
    
    public Vector2 ManualOffset;
    public float DimensionX;
    public float DimensionY;
    
    // Resolves the directional shift required to align the internal pivot
    private void CalculatePivotShift()
    {
        float halfW = DimensionX * 0.5f;
        float halfH = DimensionY * 0.5f;
        
        switch (InternalPivot)
        {
            case AnchorDirection.Top:
                ManualOffset = new Vector2(-halfW, 0);
                break;
            case AnchorDirection.Bottom:
                ManualOffset = new Vector2(-halfW, -DimensionY);
                break;
            case AnchorDirection.Left:
                ManualOffset = new Vector2(0, -halfH);
                break;
            case AnchorDirection.Right:
                ManualOffset = new Vector2(-DimensionX, -halfH);
                break;
            case AnchorDirection.Center:
            default:
                ManualOffset = new Vector2(-halfW, -halfH);
                break;
            case AnchorDirection.TopLeft:
                ManualOffset = Vector2.zero;
                break;
            case AnchorDirection.BottomLeft:
                ManualOffset = new Vector2(0, -DimensionY);
                break;
            case AnchorDirection.TopRight:
                ManualOffset = new Vector2(-DimensionX, 0);
                break;
            case AnchorDirection.BottomRight:
                ManualOffset = new Vector2(-DimensionX, -DimensionY);
                break;
        }
    }
    
    public Rect GenerateBoundedArea(Vector2 baseCoordinate)
    {
        CalculatePivotShift();
        return new Rect(
            baseCoordinate.x + ManualOffset.x,
            baseCoordinate.y + ManualOffset.y,
            DimensionX,
            DimensionY
        );
    }
}

This configuration pattern separates coordinate mathematics from rendering calls. By feeding a base screen vector into the bounding area generator, the system automatically applies the calculated pivot shifts, ensuring consistent element distribution regardless of underlying canvas transformations.