private ReadResults ParseNameOrUuid()
{
ReadResults readResults = Reader.ReadString(out string s);
if (!readResults.Successful)
{
return(readResults);
}
if (UUID.TryParse(s, out _))
{
IncludesEntities = true;
}
else
{
if (string.IsNullOrEmpty(s) || s.Length > 16)
{
Reader.SetCursor(Start);
return(ReadResults.Failure(CommandError.InvalidNameOrUuid().WithContext(Reader)));
}
IncludesEntities = false;
}
MaxResults = 1;
SelectorType = SelectorType.None;
return(ReadResults.Success());
}
protected ReadResults ValidateChildren(JsonObject obj, string key, ComponentReader componentReader, Components components, IStringReader reader, int start, DispatcherResources resources)
{
ReadResults readResults;
foreach (KeyValuePair <string, ComponentArgument> child in Children)
{
if (obj.ContainsKey(child.Key))
{
readResults = child.Value.Validate(obj, child.Key, componentReader, components, reader, start, resources);
if (MatchFirst || !readResults.Successful)
{
return(readResults);
}
}
else if (!child.Value.Optional && !MatchFirst)
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.IncompleteComponent(key, this).WithContext(reader)));
}
}
if (MatchFirst)
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.UnknownComponent(obj).WithContext(reader)));
}
return(ReadResults.Success());
}
public override ReadResults Validate(JsonObject obj, string key, ComponentReader componentReader, Components components, IStringReader reader, int start, DispatcherResources resources)
{
if (obj.GetChild(key) is not JsonArray actualArray)
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.InvalidComponent(key, JsonArgumentType.Array, obj.GetChild(key).GetArgumentType()).WithContext(reader)));
}
if (actualArray.GetLength() == 0 && !MayBeEmpty)
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.EmptyComponent().WithContext(reader)));
}
ReadResults readResults;
foreach (IJsonArgument child in actualArray.GetChildren())
{
if (ArrayContents is not null && child.GetArgumentType() != ArrayContents)
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.InvalidComponentArray(key, ArrayContents.Value, child.GetArgumentType()).WithContext(reader)));
}
readResults = componentReader.ValidateContents(child, components);
if (!readResults.Successful)
{
return(readResults);
}
}
return(ReadResults.Success());
}
private static ReadResults ReadSort(EntitySelectorParser parser, IStringReader reader, string originalName, int previousStart, DispatcherResources resources)
{
if (parser.IsSorted())
{
reader.SetCursor(previousStart);
return(ReadResults.Failure(CommandError.InapplicableOption(originalName).WithContext(reader)));
}
int start = reader.GetCursor();
ReadResults readResults = reader.ReadUnquotedString(out string sort);
if (!readResults.Successful)
{
return(readResults);
}
if (resources.Sorts.Contains(sort))
{
parser.AddArgument(new ParsedArgument <Literal>(new Literal(sort), false));
return(ReadResults.Success());
}
else
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownSort(sort).WithContext(reader)));
}
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out EntitySelector result)
{
int start = reader.GetCursor();
EntitySelectorParser entitySelectorParser = new EntitySelectorParser(reader, resources, UseBedrock);
ReadResults readResults = entitySelectorParser.Parse(out result);
if (!readResults.Successful)
{
return(readResults);
}
if (result.MaxResults > 1 && SingleEntity)
{
reader.SetCursor(start);
if (PlayersOnly)
{
return(ReadResults.Failure(CommandError.SelectorTooManyPlayers().WithContext(reader)));
}
else
{
return(ReadResults.Failure(CommandError.SelectorTooManyEntities().WithContext(reader)));
}
}
if (result.IncludesEntities && PlayersOnly && !result.IsSelf)
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.SelectorPlayersOnly().WithContext(reader)));
}
return(ReadResults.Success());
}
public ReadResults Parse(out ICoordinates result)
{
result = default;
ReadResults readResults = ReadDouble(out double left);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = ReadDouble(out double up);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = ReadDouble(out double forwards);
if (readResults.Successful)
{
result = new LocalCoordinates(left, up, forwards);
}
return(readResults);
}
public override ReadResults Validate(JsonObject obj, string key, ComponentReader componentReader, Components components, IStringReader reader, int start, DispatcherResources resources)
{
if (!IsText(obj.GetChild(key)))
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.InvalidComponent(key, JsonArgumentType.String, obj.GetChild(key).GetArgumentType()).WithContext(reader)));
}
if (!UUID.TryParse(obj.GetChild(key).ToString(), out _))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidUuid().WithContext(reader)));
}
return(ReadResults.Success());
}
public ReadResults ReadCompound(out INbtTag result)
{
CompoundNbtTag compound;
result = compound = new CompoundNbtTag();
ReadResults readResults = Reader.Expect('{');
if (!readResults.Successful)
{
return(readResults);
}
Reader.SkipWhitespace();
while (Reader.CanRead() && Reader.Peek() != '}')
{
int start = Reader.GetCursor();
readResults = ReadKey(out string key);
if (!readResults.Successful)
{
return(readResults);
}
if (string.IsNullOrEmpty(key))
{
Reader.SetCursor(start);
return(ReadResults.Failure(CommandError.ExpectedKey().WithContext(Reader)));
}
readResults = Reader.Expect(':');
if (!readResults.Successful)
{
return(readResults);
}
readResults = ReadValue(out INbtTag value);
if (!readResults.Successful)
{
return(readResults);
}
compound.Add(key, value);
if (!HasElementSeparator())
{
break;
}
if (Reader.CanRead())
{
continue;
}
return(ReadResults.Failure(CommandError.ExpectedKey().WithContext(Reader)));
}
return(Reader.Expect('}'));
}
public ReadResults Parse(out Rotation result)
{
result = default;
AngleParser angleParser = new AngleParser(StringReader);
ReadResults readResults = angleParser.Read(out Angle yRotation);
if (!readResults.Successful)
{
return(readResults);
}
if (!StringReader.AtEndOfArgument())
{
if (!UseBedrock)
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.RotationIncomplete().WithContext(StringReader)));
}
}
else
{
StringReader.Skip();
}
readResults = angleParser.Read(out Angle xRotation);
if (readResults.Successful)
{
result = new Rotation(yRotation, xRotation);
}
return(readResults);
}
private static ReadResults SetExecutor(EntitySelectorParser parser, IStringReader reader, bool negated, string originalName, int previousStart, DispatcherResources resources, bool useBedrock)
{
if (parser.IsTypeLimited())
{
reader.SetCursor(previousStart);
return(ReadResults.Failure(CommandError.InapplicableOption(originalName).WithContext(reader)));
}
int start = reader.GetCursor();
bool isTag = false;
if (reader.CanRead() && reader.Peek() == '#')
{
reader.Skip();
isTag = true;
}
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation entity);
if (!readResults.Successful)
{
return(readResults);
}
if (ResourceLocation.PLAYER_ENTITY.Equals(entity) && !negated)
{
parser.SetIncludesEntities(false);
}
else if (useBedrock)
{
// Temporary
return(ReadResults.Success());
}
else if (!isTag)
{
if (!resources.Entities.Contains(entity))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidEntityType(entity).WithContext(reader)));
}
}
parser.AddArgument(new ParsedArgument <Entity>(new Entity(entity, isTag), false));
return(ReadResults.Success());
}
public override ReadResults Validate(JsonObject obj, string key, ComponentReader componentReader, Components components, IStringReader reader, int start, DispatcherResources resources)
{
if (obj.GetChild(key) is not JsonNumber)
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.InvalidComponent(key, JsonArgumentType.Number, obj.GetChild(key).GetArgumentType()).WithContext(reader)));
}
return(ReadResults.Success());
}
public ReadResults ValidateContents(IJsonArgument json, Components components)
{
if (json is JsonNull)
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(ComponentCommandError.UnknownComponent(json).WithContext(StringReader)));
}
else if (json is JsonObject jsonObject)
{
return(ValidateObject(jsonObject, components));
}
else if (json is JsonArray jsonArray)
{
return(ValidateArray(jsonArray, components));
}
else
{
return(ReadResults.Success());
}
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out long result)
{
int start = reader.GetCursor();
ReadResults readResults = reader.ReadLong(out result);
if (readResults.Successful)
{
if (result < Minimum)
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.LongTooLow(result, Minimum).WithContext(reader)));
}
if (result > Maximum)
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.LongTooHigh(result, Maximum).WithContext(reader)));
}
}
return(readResults);
}
public ReadResults Read(Converter <string> function, Func <string, CommandError> invalidNumberErrorProvider, T minimum, T maximum, bool loopable, out Range <T> result)
{
result = default;
if (!StringReader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedValueOrRange().WithContext(StringReader)));
}
int start = StringReader.GetCursor();
T? right;
ReadResults readResults = ReadNumber(function, invalidNumberErrorProvider, out T? left);
if (!readResults.Successful)
{
return(readResults);
}
if (StringReader.CanRead(2) && StringReader.Peek() == '.' && StringReader.Peek(1) == '.')
{
StringReader.Skip(2);
readResults = ReadNumber(function, invalidNumberErrorProvider, out right);
if (!readResults.Successful)
{
return(readResults);
}
}
else
{
right = left;
}
if (left == null && right == null)
{
return(ReadResults.Failure(CommandError.ExpectedValueOrRange().WithContext(StringReader)));
}
if (left == null)
{
left = minimum;
}
if (right == null)
{
right = maximum;
}
if (!loopable && ((T)left).CompareTo((T)right) > 0)
{
StringReader.SetCursor(start);
return(ReadResults.Failure(CommandError.RangeMinBiggerThanMax().WithContext(StringReader)));
}
result = new Range <T>((T)left, (T)right);
return(ReadResults.Success());
}
public override ReadResults Validate(JsonObject obj, string key, ComponentReader componentReader, Components components, IStringReader reader, int start, DispatcherResources resources)
{
ComponentArray componentArray = new ComponentArray();
int end = reader.GetCursor();
ReadResults readResults = componentArray.Validate(obj, key, componentReader, components, reader, start, resources);
if (!readResults.Successful)
{
reader.SetCursor(end);
ComponentRoot componentRoot = new ComponentRoot();
return(componentRoot.Validate(obj, key, componentReader, components, reader, start, resources));
}
return(ReadResults.Success());
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Angle result)
{
int start = reader.GetCursor();
ReadResults readResults = new AngleParser(reader).Read(out result);
if (!readResults.Successful)
{
return(readResults);
}
if (float.IsNaN(result.Value) || float.IsInfinity(result.Value))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidAngle().WithContext(reader)));
}
return(ReadResults.Success());
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out HashSet <char> result)
{
result = new HashSet <char>();
int start = reader.GetCursor();
while (!reader.AtEndOfArgument())
{
char c = reader.Read();
if (!Characters.Contains(c) || result.Contains(c))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidSwizzle(Characters).WithContext(reader)));
}
result.Add(c);
}
return(ReadResults.Success());
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out string result)
{
if (Type == StringType.GREEDY)
{
result = reader.GetRemaining();
reader.SetCursor(reader.GetLength());
return(ReadResults.Success());
}
else if (Type == StringType.WORD)
{
return(reader.ReadUnquotedString(out result));
}
else
{
return(reader.ReadString(out result));
}
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out GameType result)
{
result = default;
int start = reader.GetCursor();
ReadResults readResults = reader.ReadUnquotedString(out string gamemode);
if (!readResults.Successful)
{
return(readResults);
}
if (!resources.Gamemodes.TryGet(gamemode, out result))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownGamemode(gamemode).WithContext(reader)));
}
return(ReadResults.Success());
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out ItemSlot result)
{
result = default;
int start = reader.GetCursor();
ReadResults readResults = reader.ReadUnquotedString(out string slot);
if (!readResults.Successful)
{
return(readResults);
}
if (!resources.ItemSlots.Contains(slot))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownSlot(slot).WithContext(reader)));
}
result = new Results.Arguments.ItemSlot(slot);
return(ReadResults.Success());
}
public ReadResults ParseInteger(out ICoordinates result)
{
result = default;
WorldCoordinateParser worldCoordinateParser = new WorldCoordinateParser(StringReader, UseBedrock);
ReadResults readResults = worldCoordinateParser.ReadInteger(out WorldCoordinate x);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = worldCoordinateParser.ReadInteger(out WorldCoordinate y);
if (!readResults.Successful)
{
return(readResults);
}
if (UseBedrock)
{
StringReader.SkipWhitespace();
}
else
{
if (!StringReader.AtEndOfArgument())
{
StringReader.SetCursor(Start);
return(ReadResults.Failure(CommandError.Vec3CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = worldCoordinateParser.ReadInteger(out WorldCoordinate z);
if (readResults.Successful)
{
result = new WorldCoordinates(x, y, z);
}
return(readResults);
}
public override ReadResults Validate(JsonObject obj, string key, ComponentReader componentReader, Components components, IStringReader reader, int start, DispatcherResources resources)
{
if (!obj.ContainsKey(BindTo))
{
return(ReadResults.Success());
}
if (!IsText(obj.GetChild(BindTo)))
{
reader.SetCursor(start);
return(ReadResults.Failure(ComponentCommandError.InvalidComponent(key, JsonArgumentType.String, obj.GetChild(BindTo).GetArgumentType()).WithContext(reader)));
}
string binding = obj.GetChild(BindTo).ToString();
if (Values.TryGetValue(binding, out ComponentArgument argument))
{
return(argument.Validate(obj, key, componentReader, components, reader, start, resources));
}
return(ReadResults.Success());
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Anchor result)
{
result = default;
int start = reader.GetCursor();
ReadResults readResults = reader.ReadUnquotedString(out string anchor);
if (!readResults.Successful)
{
return(readResults);
}
if (!resources.Anchors.Contains(anchor))
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidEntityAnchor(anchor).WithContext(reader)));
}
result = new Anchor(anchor);
return(ReadResults.Success());
}
private static ReadResults ReadGamemode(EntitySelectorParser parser, IStringReader reader, DispatcherResources resources)
{
int start = reader.GetCursor();
ReadResults readResults = reader.ReadUnquotedString(out string gamemode);
if (!readResults.Successful)
{
return(readResults);
}
if (resources.Gamemodes.TryGet(gamemode, out _))
{
parser.AddArgument(new ParsedArgument <Literal>(new Literal(gamemode), false));
return(ReadResults.Success());
}
else
{
reader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownGamemode(gamemode).WithContext(reader)));
}
}
private ReadResults ReadBlockStates(out Dictionary <string, string> result)
{
result = new Dictionary <string, string>();
ReadResults readResults = StringReader.Expect('[');
if (!readResults.Successful)
{
return(readResults);
}
StringReader.SkipWhitespace();
while (StringReader.CanRead() && StringReader.Peek() != ']')
{
StringReader.SkipWhitespace();
int start = StringReader.GetCursor();
readResults = StringReader.ReadString(out string property);
if (!readResults.Successful)
{
return(readResults);
}
if (result.ContainsKey(property))
{
StringReader.SetCursor(start);
return(ReadResults.Failure(CommandError.DuplicateBlockProperty(Block, property).WithContext(StringReader)));
}
if (!IsTag && !Resources.Blocks.ContainsProperty(Block, property))
{
StringReader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownBlockProperty(Block, property).WithContext(StringReader)));
}
StringReader.SkipWhitespace();
start = StringReader.GetCursor();
if (!StringReader.CanRead() || StringReader.Peek() != '=')
{
return(ReadResults.Failure(CommandError.ExpectedValueForBlockProperty(Block, property)));
}
StringReader.Skip();
StringReader.SkipWhitespace();
readResults = StringReader.ReadString(out string value);
if (!readResults.Successful)
{
return(readResults);
}
if (!IsTag && !Resources.Blocks.PropertyContainsValue(Block, property, value))
{
StringReader.SetCursor(start);
return(ReadResults.Failure(CommandError.UnknownBlockPropertyValue(Block, property, value).WithContext(StringReader)));
}
result.Add(property, value);
StringReader.SkipWhitespace();
if (StringReader.CanRead() && StringReader.Peek() == ',')
{
StringReader.Skip();
continue;
}
break;
}
if (!StringReader.CanRead() || StringReader.Peek() != ']')
{
return(ReadResults.Failure(CommandError.UnclosedBlockStateProperties().WithContext(StringReader)));
}
StringReader.Skip();
return(ReadResults.Success());
}
