public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Message result)
{
result = default;
string message = reader.GetRemaining();
Dictionary <int, EntitySelector> selectors = new Dictionary <int, EntitySelector>();
while (reader.CanRead())
{
if (reader.Peek() == '@')
{
if (reader.CanRead(2) && "parse".Contains(reader.Peek(1)))
{
int start = reader.GetCursor();
ReadResults readResults = new EntitySelectorParser(reader, resources, UseBedrock).Parse(out EntitySelector entitySelector);
if (!readResults.Successful)
{
return(readResults);
}
selectors.Add(start, entitySelector);
}
else
{
reader.Skip(2);
}
continue;
}
reader.Skip();
}
result = new Message(message, selectors);
return(ReadResults.Success());
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Team result)
{
ReadResults readResults = reader.ReadUnquotedString(out string team);
result = new Team(team);
return(readResults);
}
public ReadResults Read(out Angle result)
{
result = default;
if (!StringReader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedAngle().WithContext(StringReader)));
}
if (StringReader.Peek() == '^')
{
return(ReadResults.Failure(CommandError.MixedCoordinateType().WithContext(StringReader)));
}
bool isRelative = IsRelative();
if (StringReader.AtEndOfArgument())
{
result = new Angle(0.0f, isRelative);
return(ReadResults.Success());
}
ReadResults readResults = StringReader.ReadFloat(out float value);
if (readResults.Successful)
{
result = new Angle(value, isRelative);
}
return(readResults);
}
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 ReadString(out JsonString result)
{
result = default;
string actualString = "";
if (!StringReader.CanRead() || StringReader.Peek() != STRING_CHARACTER)
{
return(ReadResults.Failure(JsonCommandError.MalformedJson().WithContext(StringReader)));
}
StringReader.Skip();
bool escaped = false;
while (StringReader.CanRead())
{
char c = StringReader.Read();
if (escaped)
{
if (c == UNICODE_CHARACTER)
{
if (!StringReader.CanRead(4))
{
return(ReadResults.Failure(JsonCommandError.UnterminatedEscapeSequence().WithContext(StringReader)));
}
string unicode = StringReader.Read(4);
if (!short.TryParse(unicode, NumberStyles.HexNumber, NumberFormatInfo.InvariantInfo, out _))
{
return(ReadResults.Failure(JsonCommandError.InvalidUnicodeCharacter(unicode).WithContext(StringReader)));
}
escaped = false;
actualString += c + unicode;
}
else if (ESCAPABLE_CHARACTERS.Contains(c))
{
escaped = false;
actualString += c;
}
else
{
return(ReadResults.Failure(JsonCommandError.InvalidEscapeSequence().WithContext(StringReader)));
}
}
else if (c == ESCAPE_CHARACTER)
{
escaped = true;
actualString += c;
}
else if (c == STRING_CHARACTER)
{
result = new JsonString(actualString);
return(ReadResults.Success());
}
else
{
actualString += c;
}
}
return(ReadResults.Failure(JsonCommandError.UnterminatedString().WithContext(StringReader)));
}
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());
}
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);
}
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());
}
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 ReadDouble(out WorldCoordinate result)
{
result = default;
if (!StringReader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedCoordinate().WithContext(StringReader)));
}
if (StringReader.Peek() == '^')
{
return(ReadResults.Failure(CommandError.MixedCoordinateType().WithContext(StringReader)));
}
bool isRelative = IsRelative();
int start = StringReader.GetCursor();
if (StringReader.AtEndOfArgument() || (UseBedrock && !IsNumberPart(StringReader.Peek())))
{
result = new WorldCoordinate(isRelative ? 0.0d : 0.5d, isRelative);
return(ReadResults.Success());
}
ReadResults readResults = StringReader.ReadDouble(out double value);
if (!readResults.Successful)
{
return(readResults);
}
string number = StringReader.GetString()[start..StringReader.GetCursor()];
private ReadResults ReadListContents(ref INbtCollectionTag list)
{
ReadResults readResults;
while (Reader.CanRead() && Reader.Peek() != ']')
{
int start = Reader.GetCursor();
readResults = ReadValue(out INbtTag tag);
if (!readResults.Successful)
{
return(readResults);
}
if (!list.Add(tag))
{
Reader.SetCursor(start);
return(ReadResults.Failure(CommandError.NbtCannotInsert(tag, list).WithContext(Reader)));
}
if (!HasElementSeparator())
{
break;
}
if (Reader.CanRead())
{
continue;
}
return(ReadResults.Failure(CommandError.ExpectedValue().WithContext(Reader)));
}
return(Reader.Expect(']'));
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Objective result)
{
result = default;
ReadResults readResults;
string objective;
if (UseBedrock)
{
readResults = reader.ReadString(out objective);
}
else
{
readResults = reader.ReadUnquotedString(out objective);
}
if (!readResults.Successful)
{
return(readResults);
}
if (objective.Length > 16)
{
return(ReadResults.Failure(CommandError.ObjectiveNameTooLong()));
}
result = new Objective(objective);
return(ReadResults.Success());
}
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());
}
public ReadResults ParseIntegerFlat(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.Vec2CoordinatesIncomplete().WithContext(StringReader)));
}
StringReader.Skip();
}
readResults = worldCoordinateParser.ReadInteger(out WorldCoordinate z);
if (readResults.Successful)
{
result = new WorldCoordinates(x, new WorldCoordinate(0.0d, true), z);
}
return(readResults);
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Time result)
{
result = default;
ReadResults readResults = reader.ReadFloat(out float time);
if (!readResults.Successful)
{
return(readResults);
}
if (time < 0.0f)
{
return(ReadResults.Failure(CommandError.InvalidTickCount()));
}
if (!reader.AtEndOfArgument())
{
if (resources.TimeScalars.TryGetScalar(reader.Peek(), out int scalar))
{
time *= scalar;
reader.Skip();
}
else
{
return(ReadResults.Failure(CommandError.InvalidTimeUnit().WithContext(reader)));
}
}
result = new Time((int)time);
return(ReadResults.Success());
}
private ReadResults ReadTypedValue(out INbtTag result)
{
result = default;
Reader.SkipWhitespace();
int start = Reader.GetCursor();
ReadResults readResults;
if (Reader.IsQuotedStringStart(Reader.Peek()))
{
readResults = Reader.ReadQuotedString(out string quotedString);
if (readResults.Successful)
{
result = new StringNbtTag(quotedString);
}
return(readResults);
}
readResults = Reader.ReadUnquotedString(out string s);
if (!readResults.Successful)
{
return(readResults);
}
if (string.IsNullOrEmpty(s))
{
Reader.SetCursor(start);
return(ReadResults.Failure(CommandError.ExpectedValue()));
}
result = GetType(s);
return(ReadResults.Success());
}
public ReadResults Handle(EntitySelectorParser parser, DispatcherResources resources, string name, int start, bool useBedrock)
{
IStringReader reader = parser.GetReader();
bool negated = false;
if (AllowInverse)
{
negated = parser.ShouldInvertValue();
}
ReadResults readResults = Option switch
{
Option.SetLimit => SetLimit(parser, reader),
Option.SetExecutor => SetExecutor(parser, reader, negated, name, start, resources, useBedrock),
Option.Advancements => ReadAdvancements(parser, reader),
Option.Scores => ReadScores(parser, reader),
Option.Gamemode => ReadGamemode(parser, reader, resources),
Option.Sort => ReadSort(parser, reader, name, start, resources),
_ => CheckComponents(parser, reader, resources)
};
if (readResults.Successful)
{
parser.Apply(name, negated);
}
return(readResults);
}
protected Task InvokeUnaryRequestAsync()
{
_httpContext !.Response.Headers.Clear();
_trailers !.Clear();
_requestPipe !.ReadResults.Add(new ValueTask <ReadResult>(new ReadResult(new ReadOnlySequence <byte>(_requestMessage), false, true)));
return(_callHandler !.HandleCallAsync(_httpContext));
}
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 ValidateObject(JsonObject json, Components components)
{
ReadResults readResults = ValidatePrimary(json, components);
if (readResults.Successful)
{
readResults = ValidateOptional(json, components);
}
return(readResults);
}
private ReadResults ReadKey(out string result)
{
Reader.SkipWhitespace();
if (!Reader.CanRead())
{
result = default;
return(ReadResults.Failure(CommandError.ExpectedKey().WithContext(Reader)));
}
return(Reader.ReadString(out result));
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out ItemModifier result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation itemModifier);
if (readResults.Successful)
{
result = new ItemModifier(itemModifier);
}
return(readResults);
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Dimension result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation dimension);
if (readResults.Successful)
{
result = new Dimension(dimension);
}
return(readResults);
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Storage result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation storage);
if (readResults.Successful)
{
result = new Storage(storage);
}
return(readResults);
}
public ReadResults Parse(out Block result)
{
result = default;
ReadResults readResults = ReadTag();
if (!readResults.Successful)
{
return(readResults);
}
readResults = ResourceLocation.TryRead(StringReader, out Block);
if (!readResults.Successful)
{
return(readResults);
}
// Temporary
if (UseBedrock)
{
result = new Block(Block, null, null, IsTag);
return(ReadResults.Success());
}
if (!IsTag && !Resources.Blocks.ContainsBlock(Block))
{
return(ReadResults.Failure(CommandError.UnknownBlock(Block)));
}
Dictionary <string, string> blockStates = null;
if (StringReader.CanRead() && StringReader.Peek() == '[')
{
readResults = ReadBlockStates(out blockStates);
if (!readResults.Successful)
{
return(readResults);
}
}
INbtTag nbt = null;
if (StringReader.CanRead() && StringReader.Peek() == '{')
{
readResults = new NbtParser(StringReader).ReadCompound(out nbt);
if (!readResults.Successful)
{
return(readResults);
}
}
result = new Block(Block, blockStates, nbt, IsTag);
return(ReadResults.Success());
}
public void NbtParser_ParseListShouldFail_BecauseInvalidListItem()
{
// Arrange
IStringReader reader = new StringReader("[1, 3L]");
// Act
ReadResults readResults = NbtReader.ReadArray(reader, out _);
// Assert
Assert.IsFalse(readResults.Successful);
}
public void NbtParser_ParseArrayShouldFail_BecauseInvalidArrayType()
{
// Arrange
IStringReader reader = new StringReader("[M; 1, 2, 3]");
// Act
ReadResults readResults = NbtReader.ReadArray(reader, out _);
// Assert
Assert.IsFalse(readResults.Successful);
}
public void NbtParser_ParseCompoundShouldFail_BecauseExpectedValue()
{
// Arrange
IStringReader reader = new StringReader("{foo:}");
// Act
ReadResults readResults = NbtReader.ReadCompound(reader, out _);
// Assert
Assert.IsFalse(readResults.Successful);
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Advancement result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation advancement);
if (readResults.Successful)
{
result = new Advancement(advancement);
}
return(readResults);
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out LootTable result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation lootTable);
if (readResults.Successful)
{
result = new LootTable(lootTable);
}
return(readResults);
}
