c9831b9680
## Pressing `>` on a TextDefinition did nothing useful
`#1217` moved `TextDefinition` into the Server project for serialization support and added `[PropertyObject]` along the way. `PropsGump` checks that attribute **before** its parsable fallback, so from that commit on the button either drilled into a read-only `Number`/`String` page (both get-only since `#1221`, so no `>` buttons — a dead end) or, when the value was null, re-sent the same page and looked inert.
Worth being clear that `#765` — which replaced the hand-maintained type list with a generic `IsParsable` branch — was **not** the regression. At that commit `TextDefinition` was `[Parsable]` only, fell through to the new branch, and the editor worked. Only the later attribute hijacked the routing.
`TextDefinition` is now caught ahead of the `[PropertyObject]` branch and routed to `SetGump`, which has had `TextDefinition`-specific code at line 35 all along.
## `0` and `"0"` could not be told apart
`Commands.Split` strips quotes before any parser runs, so this was never fixable in `TextDefinition.Parse` alone — the information is gone two layers earlier. The markers now travel inside the value:
| Input | Result |
|---|---|
| `1060847` | cliloc (unchanged) |
| `#1060847` | cliloc, explicit — the form `ToString()` already writes |
| `@"1060847"` | the literal string |
| `hello` | string (unchanged) |
| `(-null-)` | null (unchanged) |
`GetValue()` quotes a string that would not survive the trip back. That check is a real round trip through the parser rather than a pattern match, so it cannot drift from it. `Types.TryParse` decodes the same escape for plain strings — which is what `[get` has always written for the literal `"null"` without `[set` ever reading it back.
**Saved data is untouched.** Serialization reads a discriminated flag plus int/string (`IGenericReader.cs:175`) and the JSON converter switches on token type; neither calls `Parse`, so a stored string `"1060847"` stays a string and spawner JSON is unchanged. The new syntax stays in the text and command layer, where it reaches `[set`, `[add`, spawner props, the props gump and Advanced Search.
## `where` still parsed its constants its own way
`#2625` carried the hand-rolled constant parser across to `PropertyExpressions.Parse` unchanged. It looks for a static `Parse` overload on the property type and gives up if there is none — and `Type` and `IEntity` have neither:
```
where Subject Kind = Static -> Unable to convert string "Static" into type 'System.Type'.
where Subject Owner = 0x1 -> Unable to convert string "0x1" into type 'Server.Mobile'.
```
Both resolve fine for every other command. Routing through `Types.TryParse` picks up type-name lookup, entity resolution by serial, and the `@"..."` literal convention, so a value that works in one place now works everywhere. It also deletes the duplicate parser (−56 lines in `PropertyExpressions`).
Two things are load-bearing and preserved. `where` has always spelled a null constant as a bare `null`, where `[set` uses `(-null-)`; the shared parser reads a bare `null` as the text, so the null case is handled ahead of it and `= null` keeps meaning null. And nullable targets still unwrap first, so `where <int? prop> = 5` is unaffected.
Bare and hex integers, enums, bools, strings, `Map`, and TextDefinition's `#` / `@"..."` markers all resolve exactly as before — 13 of the 15 tests in `WhereConstantParsingTests` pin that and passed before the change as well as after.
## Documentation
The generic command system had no documentation anywhere in the repo: scopes, `where` and its operators, dot notation, `order by` / `distinct` / `limit`, the value and quoting syntax, `[interface` and `[batch` were all learn-by-reading-the-source. `dev-docs/generic-commands.md` covers them, linked from `CLAUDE.md` and `commands-targeting.md`, and points at <https://muo.gg/commands> for the per-command list rather than duplicating it.
Two behaviours it records that were news to me while writing it:
- `Contained` honours conditions on the normal command path but never sets `SupportsConditionals`, and `[batch` is the only place that reads the flag — so the same condition works typed directly and is refused under batch.
- `Multi`, `Single`, `Self` and `Serial` do not parse modifiers at all, so a `where` clause there is passed to the command as ordinary arguments rather than rejected.
Comments in the changed code were trimmed to what is not evident from the code itself; the rationale they carried is either in the doc now or in the commit that introduced it.
## Behavior changes worth a reviewer's attention
Two things go beyond strict bug-fixing, both deliberate:
- **Hex now parses into a TextDefinition.** Consolidating the three `Parse` overloads onto one span codec means `[set Message 0x102CE7` is cliloc 1060847 rather than the string. Previously only the 1-arg `Parse(string)` did hex and nothing called it. This makes the props gump's own `1060847 (0x102CE7)` display typeable.
- **`@"..."` decodes generally for strings**, not only the exact token `@"null"`. So `[set Name @"hello"` sets `hello`. A half-working escape seemed more surprising than a general one, and the `where` path already decoded it — but narrowing it back is a one-line change if preferred.
## Testing
40 tests, each written first and watched fail for the right reason. They cover the props gump routing (populated and null), cliloc/string/quoted parsing and `GetValue` round trips, `where` constant resolution for Type- and entity-valued properties, and the bare-`null` vs `@"null"` distinction that must not drift.
One sort case is added that #2625 left uncovered: ordering a value-typed chain whose intermediate is null, which reads as `default(int)` rather than throwing. Two other tests from the pre-rebase branch were dropped as duplicates of `ConditionalCompilerEdgeTests`.
Rebased onto `535a09899`. `dotnet build` clean, 0 warnings. **902 UOContent** and **869 Server** tests pass, 0 failures.
## Known gaps
- `Nullable<T>` comparisons work via #2625's lifted operators; nothing here changes that.
- Spawner **Params** are split on plain spaces (`BaseSpawner.cs:1035`) rather than through `Commands.Split`, so a constructor argument still cannot contain one. Untouched here — a tokenizer issue, not a TextDefinition one.
- `Types.ParseStringNumericParamTypes` is now unreferenced. Left in place because it is public and shards may use it.
611 lines
19 KiB
C#
611 lines
19 KiB
C#
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);
|
|
}
|
|
else if (IsType(type, OfPoint3D))
|
|
{
|
|
from.SendGump(new SetPoint3DGump(prop, from, m_Object, this));
|
|
}
|
|
else if (IsType(type, OfPoint2D))
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|