warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ModernUO/Projects/UOContent/Gumps/Props/PropsGump.cs
Kamron Batman 459674ce3b
fix(commands): parse and edit IPoint2D/IPoint3D properties (#2646) 
## Symptom

`[set TargetLocation (x, y)` (quoted or not) answers **"That is not properly formatted."**, and in `[props` the `>` next to `TargetLocation` does nothing when the value is null — which is its normal idle state (`BaseAI.cs:650` clears it).

This looked like a `Point3D` parsing regression from #2624/#2625, but `Point3D`/`Point2D`-typed properties (`Location`, etc.) were never affected. The only `[CommandProperty]` in the tree declared as an **interface** is `BaseCreature.TargetLocation : IPoint2D` (`BaseCreature.cs:1111`), and both code paths only knew the structs. `git log -S"IPoint"` over the parser and gump files hits nothing but the initial import — the gap is inherited from RunUO, not recent.

## Root cause

- **`[set`** — `Types.TryParse` has no branch for `IPoint2D`/`IPoint3D`. An interface has no static `Parse`, so `GetParseMethod` returns null and the value falls into `Convert.ChangeType("(x, y)", typeof(IPoint2D))`, which throws → "not properly formatted".
- **Props gump** — `PropsGump` routes on `obj?.GetType() ?? prop.PropertyType` (since #2180). With a null value the type is `IPoint2D`; `Point2D.IsAssignableFrom(IPoint2D)` is false, no branch matches, and the click is inert. It only worked when the slot already held a `Point2D`, because the runtime type is then the struct.

## Fix

- `Types.TryParse`: `IPoint3D`/`IPoint2D` targets resolve to the concrete struct — `Point3D` first, then `Point2D` for an `IPoint2D` target (a 3-tuple is a valid `IPoint2D`). `(-null-)` still clears; the existing null branch runs first.
- `PropsGump`: the interface types route to `SetPoint3DGump`/`SetPoint2DGump`. The entity branch stays ahead of them — `TargetLocation` legitimately holds a Mobile too (`ShepherdsCrook.cs:148`, herding toward the shepherd), and that case still opens `SetObjectGump`.
- `SetPoint2DGump`/`SetPoint3DGump`: seed the text entries from `value is IPoint2D/IPoint3D` rather than a hard cast, so a `Point3D` sitting in an `IPoint2D` slot cannot `InvalidCast`.

## Not covered

`[set TargetLocation 0x40001234` (assigning a mobile by serial) still reports "not properly formatted" — the entity branch keys on the *target* type being `IEntity`, which `IPoint2D` isn't. Real state, but niche; left out to keep this to the reported symptom.

## Testing

Five cases in `InterfacePointParseTests`, watched fail before the change (three returned the error string; two pin existing behaviour that must survive): tuple → `Point3D` for both interfaces, pair → `Point2D`, pair rejected for `IPoint3D`, `(-null-)` clears.

`dotnet build` 0 warnings. **1059 UOContent** and **891 Server** tests pass, 0 failures. The gump routing is a one-line branch with no automated test — needs an in-game check: `[props` a creature with a null `TargetLocation`, press `>`, expect the Point2D editor.
2026-09-14 21:20:22 -07:00

613 lines
19 KiB
C#
Raw Blame History

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Server.Commands.Generic;
using Server.Network;
using static Server.Types;
using static Server.Attributes;
using static Server.Gumps.PropsConfig;
namespace Server.Gumps
{
public class StackEntry
{
public object m_Object;
public PropertyInfo m_Property;
public StackEntry(object obj, PropertyInfo prop)
{
m_Object = obj;
m_Property = prop;
}
}
public class PropertiesGump : Gump
{
private const int NameWidth = 107;
private const int ValueWidth = 128;
private const int MaxEntriesPerPage = 15;
private const int TypeWidth = NameWidth + OffsetSize + ValueWidth;
private const int TotalWidth = OffsetSize + NameWidth + OffsetSize + ValueWidth + OffsetSize + SetWidth + OffsetSize;
protected const int BackWidth = BorderSize + TotalWidth + BorderSize;
protected readonly List<object> m_List;
protected readonly Mobile m_Mobile;
protected readonly object m_Object;
protected readonly Stack<StackEntry> m_Stack;
protected readonly Type m_Type;
protected int m_Page;
protected int m_EntryCount;
protected virtual int TotalHeight => OffsetSize + (EntryHeight + OffsetSize) * (m_EntryCount + 1);
public PropertiesGump(Mobile mobile, object o) : base(GumpOffsetX, GumpOffsetY)
{
m_Mobile = mobile;
m_Object = o;
m_Type = o.GetType();
m_List = BuildList();
Initialize(0);
}
public PropertiesGump(Mobile mobile, object o, Stack<StackEntry> stack, StackEntry parent) : base(
GumpOffsetX,
GumpOffsetY
)
{
m_Mobile = mobile;
m_Object = o;
m_Type = o.GetType();
m_Stack = stack;
m_List = BuildList();
if (parent != null)
{
m_Stack ??= new Stack<StackEntry>();
m_Stack.Push(parent);
}
Initialize(0);
}
public PropertiesGump(Mobile mobile, object o, Stack<StackEntry> stack, List<object> list, int page) : base(
GumpOffsetX,
GumpOffsetY
)
{
m_Mobile = mobile;
m_Object = o;
if (o != null)
{
m_Type = o.GetType();
}
m_List = list;
m_Stack = stack;
Initialize(page);
}
protected virtual void Initialize(int page)
{
m_Page = page;
var indexOnPage = m_Page * MaxEntriesPerPage;
m_EntryCount = Math.Clamp(m_List.Count - indexOnPage, 0, MaxEntriesPerPage);
var lastIndex = indexOnPage + m_EntryCount - 1;
if (lastIndex >= 0 && lastIndex < m_List.Count && m_List[lastIndex] == null)
{
--m_EntryCount;
}
AddPage(0);
this.AddPropsFrame(TotalWidth, m_EntryCount + 1, out var x, out var y);
var title = m_Type != null && m_Object is ISerializable serializable
? $"{m_Type.Name} ({serializable.Serial})".Center(0xFAFAFA)
: m_Type?.Name.Center(0xFAFAFA);
this.AddPropsHeader(
TotalWidth, ref x, ref y,
title,
page > 0, 1,
(page + 1) * MaxEntriesPerPage < m_List.Count, 2,
nextType: GumpButtonType.Reply, nextParam: 1
);
for (int i = 0, index = page * MaxEntriesPerPage; i < m_EntryCount && index < m_List.Count; ++i, ++index)
{
PropsLayout.NextRow(ref x, ref y);
var o = m_List[index];
if (o == null)
{
this.AddPropsEntryBlank(x, y, TotalWidth);
}
else if (o is Type type)
{
this.AddPropsEntryType(ref x, ref y, TypeWidth, type.Name);
}
else if (o is PropertyInfo prop)
{
var cpa = GetCPA(prop);
var canModify = cpa?.ReadOnly == false && m_Mobile.AccessLevel >= cpa.WriteLevel && (prop.CanWrite || cpa.CanModify);
this.AddPropsEntryNameValue(
ref x, ref y, NameWidth, ValueWidth,
prop.Name, ValueToString(prop),
canModify, i + 3
);
}
}
}
public override void OnResponse(NetState state, in RelayInfo info)
{
var from = state.Mobile;
if (!BaseCommand.IsAccessible(from, m_Object))
{
from.SendMessage("You may no longer access their properties.");
return;
}
switch (info.ButtonID)
{
case 0: // Closed
{
if (m_Stack?.Count > 0)
{
var entry = m_Stack.Pop();
from.SendGump(new PropertiesGump(from, entry.m_Object, m_Stack, null));
}
break;
}
case 1: // Previous
{
if (m_Page > 0)
{
from.SendGump(new PropertiesGump(from, m_Object, m_Stack, m_List, m_Page - 1));
}
break;
}
case 2: // Next
{
if ((m_Page + 1) * MaxEntriesPerPage < m_List.Count)
{
from.SendGump(new PropertiesGump(from, m_Object, m_Stack, m_List, m_Page + 1));
}
break;
}
default:
{
var index = m_Page * MaxEntriesPerPage + (info.ButtonID - 3);
if (index < 0 || index >= m_List.Count)
{
break;
}
var prop = m_List[index] as PropertyInfo;
if (prop == null)
{
return;
}
var cpa = GetCPA(prop);
if (cpa == null || !(prop.CanWrite || cpa.CanModify) || cpa.ReadOnly ||
from.AccessLevel < cpa.WriteLevel)
{
return;
}
var obj = prop.GetValue(m_Object, null);
var type = obj?.GetType() ?? prop.PropertyType;
if (IsType(type, OfEntity))
{
from.SendGump(new SetObjectGump(prop, from, m_Object, type, this));
}
else if (IsType(type, OfType))
{
from.Target = new SetObjectTarget(prop, from, m_Object, type, this);
}
// A null interface-typed value (TargetLocation : IPoint2D) routes on the
// declared type; a held entity was already caught above.
else if (IsType(type, OfPoint3D) || type == OfIPoint3D)
{
from.SendGump(new SetPoint3DGump(prop, from, m_Object, this));
}
else if (IsType(type, OfPoint2D) || type == OfIPoint2D)
{
from.SendGump(new SetPoint2DGump(prop, from, m_Object, this));
}
else if (IsType(type, OfTimeSpan))
{
from.SendGump(new SetTimeSpanGump(prop, from, m_Object, this));
}
else if (IsCustomEnum(type))
{
from.SendGump(
new SetCustomEnumGump(
prop,
from,
m_Object,
this,
GetCustomEnumNames(type)
)
);
}
else if (IsType(type, OfEnum))
{
from.SendGump(
new SetListOptionGump(
prop,
from,
m_Object,
this,
Enum.GetNames(type),
GetObjects(Enum.GetValues(type))
)
);
}
else if (IsType(type, OfBool))
{
from.SendGump(
new SetListOptionGump(
prop,
from,
m_Object,
this,
BoolNames,
BoolValues
)
);
}
else if (IsType(type, OfPoison))
{
from.SendGump(
new SetListOptionGump(
prop,
from,
m_Object,
this,
PoisonNames,
PoisonValues
)
);
}
else if (IsType(type, OfMap))
{
from.SendGump(
new SetListOptionGump(
prop,
from,
m_Object,
this,
Map.GetMapNames(),
Map.GetMapValues().ToArray<object>()
)
);
}
else if (IsType(type, OfSkills) && m_Object is Mobile mobile)
{
from.SendGump(new PropertiesGump(from, mobile, m_Stack, m_List, m_Page));
from.SendGump(new SkillsGump(from, mobile));
}
// Must stay ahead of [PropertyObject]: TextDefinition carries that
// attribute, but Number and String are get-only so drilling in is a dead end.
else if (IsType(type, OfText))
{
from.SendGump(new SetGump(prop, from, m_Object, this));
}
else if (HasAttribute(type, OfPropertyObject, true))
{
from.SendGump(
obj != null
? new PropertiesGump(from, obj, m_Stack, new StackEntry(m_Object, prop))
: new PropertiesGump(from, m_Object, m_Stack, m_List, m_Page)
);
}
else if (IsType(type, OfString) || IsParsable(type))
{
from.SendGump(new SetGump(prop, from, m_Object, this));
}
break;
}
}
}
public virtual void SendPropertiesGump() =>
m_Mobile.SendGump(new PropertiesGump(m_Mobile, m_Object, m_Stack, m_List, m_Page));
private static object[] GetObjects(Array a)
{
var list = new object[a.Length];
for (var i = 0; i < list.Length; ++i)
{
list[i] = a.GetValue(i);
}
return list;
}
private static bool IsCustomEnum(Type type) => type.IsDefined(OfCustomEnum, false);
public void OnValueChanged(object obj, PropertyInfo prop)
{
if (m_Stack == null || m_Stack.Count == 0)
{
return;
}
if (!prop.PropertyType.IsValueType)
{
return;
}
var peek = m_Stack.Peek();
if (peek.m_Property.CanWrite)
{
peek.m_Property.SetValue(peek.m_Object, obj, null);
}
}
private static string[] GetCustomEnumNames(Type type)
{
var attrs = type.GetCustomAttributes(OfCustomEnum, false);
if (attrs.Length == 0)
{
return [];
}
if (attrs[0] is not CustomEnumAttribute ce)
{
return [];
}
return ce.Names;
}
private static bool HasAttribute(Type type, Type check, bool inherit) =>
type.GetCustomAttributes(check, inherit).Length > 0;
private string ValueToString(PropertyInfo prop) => ValueToString(m_Object, prop);
public static string ValueToString(object obj, PropertyInfo prop)
{
try
{
return ValueToString(prop.GetValue(obj, null));
}
catch (Exception e)
{
return $"!{e.GetType()}!";
}
}
private static string ValueToString(object o)
{
if (o == null)
{
return "-null-";
}
if (o is string s)
{
return $"\"{s}\"";
}
if (o is bool)
{
return o.ToString();
}
if (o is char c)
{
return $"0x{(int)c:X} '{c}'";
}
if (o is Serial serial)
{
if (serial.IsValid)
{
if (serial.IsItem)
{
return $"(I) {serial}";
}
if (serial.IsMobile)
{
return $"(M) {serial}";
}
}
return $"(?) {serial}";
}
if (o is byte or sbyte or short or ushort or int or uint or long or ulong)
{
return $"{o} (0x{o:X})";
}
if (o is Mobile mobile)
{
return $"(M) {mobile.Serial} \"{mobile.Name}\"";
}
if (o is Item item)
{
return $"(I) {item.Serial}";
}
if (o is Type type)
{
return type.Name;
}
if (o is TextDefinition definition)
{
return definition.Format() ?? "-empty-";
}
return o.ToString();
}
private List<object> BuildList()
{
var list = new List<object>();
if (m_Type == null)
{
return list;
}
var props = m_Type.GetProperties(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public);
var groups = GetGroups(m_Type, props);
for (var i = 0; i < groups.Count; ++i)
{
var kvp = groups[i];
if (!HasAttribute(kvp.Key, OfNoSort, false))
{
kvp.Value.Sort(PropertySorter.Instance);
}
if (i != 0)
{
list.Add(null);
}
list.Add(kvp.Key);
foreach (var item in kvp.Value)
{
if (ShowAttribute(item.Name))
{
list.Add(item);
}
}
}
return list;
}
protected virtual bool ShowAttribute(string name) => true;
private List<KeyValuePair<Type, List<PropertyInfo>>> GetGroups(Type objectType, PropertyInfo[] props)
{
var groups = new Dictionary<Type, List<PropertyInfo>>();
for (var i = 0; i < props.Length; ++i)
{
var prop = props[i];
if (prop.CanRead)
{
var attr = GetCPA(prop);
if (attr != null && m_Mobile.AccessLevel >= attr.ReadLevel)
{
var type = prop.DeclaringType;
while (true)
{
var baseType = type?.BaseType;
if (baseType == OfObject || baseType?.GetProperty(prop.Name, prop.PropertyType) == null)
{
break;
}
type = baseType;
}
if (type != null)
{
if (groups.TryGetValue(type, out var result))
{
result.Add(prop);
}
else
{
groups[type] = [prop];
}
}
}
}
}
var list = groups.ToList();
list.Sort(new GroupComparer(objectType));
return list;
}
private class PropertySorter : IComparer<PropertyInfo>
{
public static readonly PropertySorter Instance = new();
private PropertySorter()
{
}
public int Compare(PropertyInfo x, PropertyInfo y)
{
if (x == null && y == null)
{
return 0;
}
if (x == null)
{
return -1;
}
return x.Name.CompareOrdinal(y?.Name);
}
}
private class GroupComparer : IComparer<KeyValuePair<Type, List<PropertyInfo>>>
{
private readonly Type m_Start;
public GroupComparer(Type start) => m_Start = start;
public int Compare(KeyValuePair<Type, List<PropertyInfo>> x, KeyValuePair<Type, List<PropertyInfo>> y) =>
GetDistance(x.Key).CompareTo(GetDistance(y.Key));
private int GetDistance(Type type)
{
var current = m_Start;
int dist;
for (dist = 0; current != null && current != OfObject && current != type; ++dist)
{
current = current.BaseType;
}
return dist;
}
}
}
}
Reference in a new issue View git blame Copy permalink