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 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 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);
}
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());
}
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('}'));
}
private ReadResults CheckComponents(EntitySelectorParser parser, IStringReader reader, DispatcherResources resources)
{
if (Contents != null)
{
CommandContext context = new CommandContext(reader.GetCursor());
ReadResults readResults = Contents.Parse(reader, context, resources);
if (readResults.Successful)
{
parser.AddArgument(context.Results[0]);
}
return(readResults);
}
return(ReadResults.Success());
}
private static ReadResults SetLimit(EntitySelectorParser parser, IStringReader reader)
{
ReadResults readResults = reader.ReadInteger(out int number);
if (!readResults.Successful)
{
return(readResults);
}
if (number < 1)
{
return(ReadResults.Failure(CommandError.SelectorLimitTooLow().WithContext(reader)));
}
parser.SetMaxResults(number);
parser.AddArgument(new ParsedArgument <int>(number, false));
return(ReadResults.Success());
}
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());
}
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)));
}
}
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()];
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('}'));
}
