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 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);
}
private static ReadResults ReadScores(EntitySelectorParser parser, IStringReader reader)
{
ReadResults readResults = reader.Expect('{');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
while (reader.CanRead() && reader.Peek() != '}')
{
reader.SkipWhitespace();
readResults = reader.ReadUnquotedString(out _);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.Expect('=');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = new RangeParser <int>(reader).Read(int.TryParse, CommandError.InvalidInteger, int.MinValue, int.MaxValue, false, out Range <int> range);
if (!readResults.Successful)
{
return(readResults);
}
parser.AddArgument(new ParsedArgument <Range <int> >(range, false));
reader.SkipWhitespace();
if (reader.CanRead())
{
char c = reader.Read();
if (c == ',')
{
continue;
}
if (c == '}')
{
return(ReadResults.Success());
}
}
return(ReadResults.Failure(CommandError.ExpectedCharacter('}').WithContext(reader)));
}
reader.SkipWhitespace();
return(reader.Expect('}'));
}
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 ReadResults Parse(IStringReader reader, DispatcherResources resources, out NbtPath result)
{
result = default;
int start = reader.GetCursor();
bool isRoot = true;
ReadResults readResults;
while (!reader.AtEndOfArgument())
{
readResults = ParseNode(reader, isRoot);
if (!readResults.Successful)
{
return(readResults);
}
isRoot = false;
if (!reader.CanRead())
{
continue;
}
char c = reader.Peek();
if (c == ' ' || c == '[' || c == '{')
{
continue;
}
readResults = reader.Expect('.');
if (!readResults.Successful)
{
return(readResults);
}
}
result = new NbtPath(reader.GetString()[start..reader.GetCursor()]);
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out ICoordinates result)
{
if (reader.CanRead() && reader.Peek() == '^')
{
return(new LocalCoordinatesParser(reader, UseBedrock).Parse(out result));
}
return(new WorldCoordinatesParser(reader, UseBedrock).ParseDouble(out result));
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out UUID result)
{
int start = reader.GetCursor();
while (reader.CanRead() && IsUuidPart(reader.Peek()))
{
reader.Skip();
}
string uuid = reader.GetString()[start..reader.GetCursor()];
public static ReadResults TryRead(IStringReader stringReader, out ResourceLocation result)
{
int start = stringReader.GetCursor();
while (stringReader.CanRead() && IsAllowedInResourceLocation(stringReader.Peek()))
{
stringReader.Skip();
}
string input = stringReader.GetString()[start..stringReader.GetCursor()];
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out StructureRotation result)
{
result = default;
int start = reader.GetCursor();
while (reader.CanRead() && IsUnquotedStringPart(reader.Peek()))
{
reader.Skip();
}
string structureRotation = reader.GetString()[start..reader.GetCursor()];
public ReadResults ReadInteger(out WorldCoordinate result)
{
result = default;
if (!StringReader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedBlockPosition().WithContext(StringReader)));
}
if (StringReader.Peek() == '^')
{
return(ReadResults.Failure(CommandError.MixedCoordinateType().WithContext(StringReader)));
}
bool isRelative = IsRelative();
double value = 0.0d;
if (!StringReader.AtEndOfArgument())
{
if (UseBedrock && !IsNumberPart(StringReader.Peek()))
{
result = new WorldCoordinate(value, isRelative);
return(ReadResults.Success());
}
ReadResults readResults;
if (isRelative)
{
readResults = StringReader.ReadDouble(out value);
}
else
{
readResults = StringReader.ReadInteger(out int integerValue);
value = integerValue;
}
if (!readResults.Successful)
{
return(readResults);
}
}
result = new WorldCoordinate(value, isRelative);
return(ReadResults.Success());
}
public ReadResults Parse(out Item result)
{
result = default;
ReadResults readResults = ReadTag(out bool isTag);
if (!readResults.Successful)
{
return(readResults);
}
readResults = ResourceLocation.TryRead(StringReader, out ResourceLocation item);
if (!readResults.Successful)
{
return(readResults);
}
// Temporary
if (UseBedrock)
{
result = new Item(item, null, isTag);
return(ReadResults.Success());
}
if (!isTag && !Resources.Items.Contains(item))
{
return(ReadResults.Failure(CommandError.UnknownItem(item)));
}
if (StringReader.CanRead() && StringReader.Peek() == '{')
{
readResults = new NbtParser(StringReader).ReadCompound(out INbtTag nbt);
if (readResults.Successful)
{
result = new Item(item, nbt, isTag);
}
return(readResults);
}
result = new Item(item, null, isTag);
return(ReadResults.Success());
}
public ReadResults Parse(out EntitySelector result)
{
result = default;
ReadResults readResults;
if (Reader.CanRead() && Reader.Peek() == '@')
{
Reader.Skip();
readResults = ParseSelector();
}
else
{
readResults = ParseNameOrUuid();
}
if (readResults.Successful)
{
result = GetSelector();
}
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 ReadResults ReadValue(out INbtTag result)
{
result = default;
Reader.SkipWhitespace();
if (!Reader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedValue().WithContext(Reader)));
}
char c = Reader.Peek();
if (c == '{')
{
return(ReadCompound(out result));
}
if (c == '[')
{
return(ReadList(out result));
}
return(ReadTypedValue(out result));
}
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 ReadResults Parse(IStringReader reader, DispatcherResources resources, out Component result)
{
result = default;
if (!reader.CanRead())
{
return(ReadResults.Failure(CommandError.IncorrectArgument().WithContext(reader)));
}
int start = reader.GetCursor();
ReadResults readResults = new JsonReader(reader).ReadAny(out IJsonArgument json);
if (!readResults.Successful)
{
return(readResults);
}
result = new Component(json);
return(new ComponentReader(reader, start, resources).ValidateFromRoot(json, resources.Components));
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Function result)
{
result = default;
bool isTag = false;
if (reader.CanRead() && reader.Peek() == '#')
{
reader.Skip();
isTag = true;
}
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation function);
if (readResults.Successful)
{
result = new Function(function, isTag);
}
return(readResults);
}
private ReadResults ReadDouble(out double result)
{
result = default;
if (!StringReader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedCoordinate().WithContext(StringReader)));
}
if (StringReader.Peek() != '^')
{
return(ReadResults.Failure(CommandError.MixedCoordinateType().WithContext(StringReader)));
}
StringReader.Skip();
if (StringReader.AtEndOfArgument() || (UseBedrock && !IsNumberPart(StringReader.Peek())))
{
result = 0.0d;
return(ReadResults.Success());
}
else
{
return(StringReader.ReadDouble(out result));
}
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out ScoreHolder result)
{
result = default;
if (reader.CanRead() && reader.Peek() == '@')
{
EntitySelectorParser entitySelectorParser = new EntitySelectorParser(reader, resources, UseBedrock);
ReadResults readResults = entitySelectorParser.Parse(out EntitySelector entitySelector);
if (!readResults.Successful)
{
return(readResults);
}
if (!Multiple && entitySelector.MaxResults > 1)
{
return(ReadResults.Failure(CommandError.SelectorTooManyEntities()));
}
result = new ScoreHolder(null, entitySelector);
return(ReadResults.Success());
}
if (UseBedrock)
{
ReadResults readResults = reader.ReadString(out string name);
if (!readResults.Successful)
{
return(readResults);
}
result = new ScoreHolder(name, null);
return(ReadResults.Success());
}
else
{
int start = reader.GetCursor();
while (!reader.AtEndOfArgument())
{
reader.Skip();
}
string name = reader.GetString()[start..reader.GetCursor()];
public ReadResults ReadAny(out IJsonArgument result)
{
result = new JsonNull();
SkipWhitespace();
if (!StringReader.CanRead())
{
return(ReadResults.Success());
}
ReadResults readResults;
switch (StringReader.Peek())
{
case OBJECT_OPEN_CHARACTER:
readResults = ReadObject(out JsonObject objectResult);
if (readResults.Successful)
{
result = objectResult;
}
return(readResults);
case ARRAY_OPEN_CHARACTER:
readResults = ReadArray(out JsonArray arrayResult);
if (readResults.Successful)
{
result = arrayResult;
}
return(readResults);
case STRING_CHARACTER:
readResults = ReadString(out JsonString stringResult);
if (readResults.Successful)
{
result = stringResult;
}
return(readResults);
default:
return(ReadSpecial(out result));
}
}
private static ReadResults ReadAdvancements(EntitySelectorParser parser, IStringReader reader)
{
ReadResults readResults = reader.Expect('{');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
while (reader.CanRead() && reader.Peek() != '}')
{
reader.SkipWhitespace();
readResults = ResourceLocation.TryRead(reader, out ResourceLocation advancement);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.Expect('=');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
if (reader.CanRead() && reader.Peek() == '{')
{
reader.Skip();
reader.SkipWhitespace();
while (reader.CanRead() && reader.Peek() != '}')
{
reader.SkipWhitespace();
readResults = reader.ReadUnquotedString(out _);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.Expect('=');
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
readResults = reader.ReadBoolean(out _);
if (!readResults.Successful)
{
return(readResults);
}
reader.SkipWhitespace();
if (reader.CanRead())
{
char c = reader.Read();
if (c == ',')
{
continue;
}
if (c == '}')
{
break;
}
}
}
}
else
{
readResults = reader.ReadBoolean(out _);
if (!readResults.Successful)
{
return(readResults);
}
}
parser.AddArgument(new ParsedArgument <Advancement>(new Advancement(advancement), false));
reader.SkipWhitespace();
if (reader.CanRead())
{
char c = reader.Read();
if (c == ',')
{
continue;
}
if (c == '}')
{
return(ReadResults.Success());
}
}
return(ReadResults.Failure(CommandError.ExpectedCharacter('}').WithContext(reader)));
}
reader.SkipWhitespace();
return(reader.Expect('}'));
}
