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 ItemParser(IStringReader stringReader, DispatcherResources resources, bool forTesting, bool useBedrock)
{
StringReader = stringReader;
Resources = resources;
ForTesting = forTesting;
UseBedrock = useBedrock;
}
public EntitySelectorParser(IStringReader reader, DispatcherResources resources, bool useBedrock)
{
Reader = reader;
Start = reader.GetCursor();
Resources = resources;
UseBedrock = useBedrock;
}
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());
}
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 Team result)
{
ReadResults readResults = reader.ReadUnquotedString(out string team);
result = new Team(team);
return(readResults);
}
private static Dispatcher GetDispatcher(DispatcherResourcesBuilder dispatcherResources, VersionResources versionResources)
{
VersionResourceKeys keys = versionResources.GetResourceKeys();
RootNode commandRootNode = GetResources <CommandsBuilder, RootNode>(dispatcherResources.Commands, keys.GetCommandsKey());
DispatcherResources commandResources = new DispatcherResources()
{
Anchors = GetResources <AnchorsBuilder, Anchors>(dispatcherResources.Anchors, keys.GetAnchorsKey()),
Blocks = GetResources <BlocksBuilder, Blocks>(dispatcherResources.Blocks, keys.GetBlocksKey()),
Colours = GetResources <ColoursBuilder, Colours>(dispatcherResources.Colours, keys.GetColoursKey()),
Components = GetResources <ComponentsBuilder, Components>(dispatcherResources.Components, keys.GetComponentsKey()),
Enchantments = GetResources <EnchantmentsBuilder, Enchantments>(dispatcherResources.Enchantments, keys.GetEnchantmentsKey()),
Entities = GetResources <EntitiesBuilder, Entities>(dispatcherResources.Entities, keys.GetEntitiesKey()),
Gamemodes = GetResources <GamemodesBuilder, Gamemodes>(dispatcherResources.Gamemodes, keys.GetGamemodesKey()),
Items = GetResources <ItemsBuilder, Items>(dispatcherResources.Items, keys.GetItemsKey()),
ItemComponents = GetResources <ComponentsBuilder, Components>(dispatcherResources.ItemComponents, keys.GetItemComponentsKey()),
ItemSlots = GetResources <ItemSlotsBuilder, ItemSlots>(dispatcherResources.ItemSlots, keys.GetItemSlotsKey()),
MobEffects = GetResources <MobEffectsBuilder, MobEffects>(dispatcherResources.MobEffects, keys.GetMobEffectsKey()),
ObjectiveCriteria = GetResources <ObjectiveCriteriaBuilder, ObjectiveCriteria>(dispatcherResources.ObjectiveCriteria, keys.GetObjectiveCriteriaKey()),
Operations = GetResources <OperationsBuilder, Operations>(dispatcherResources.Operations, keys.GetOperationsKey()),
Particles = GetResources <ParticlesBuilder, Particles>(dispatcherResources.Particles, keys.GetParticlesKey()),
ScoreboardSlots = GetResources <ScoreboardSlotsBuilder, ScoreboardSlots>(dispatcherResources.ScoreboardSlots, keys.GetScoreboardSlotsKey()),
SelectorArguments = GetResources <SelectorArgumentsBuilder, EntitySelectorOptions>(dispatcherResources.SelectorArguments, keys.GetSelectorArgumentsKey()),
Sorts = GetResources <SortsBuilder, Sorts>(dispatcherResources.Sorts, keys.GetSortsKey()),
TimeScalars = GetResources <TimeScalarsBuilder, TimeScalars>(dispatcherResources.TimeScalars, keys.GetTimeScalarsKey()),
StructureRotations = GetResources <StructureRotationsBuilder, StructureRotations>(dispatcherResources.StructureRotations, keys.GetStructureRotationsKey()),
StructureMirrors = GetResources <StructureMirrorsBuilder, StructureMirrors>(dispatcherResources.StructureMirrors, keys.GetStructureMirrorsKey())
};
Dispatcher dispatcher = new Dispatcher(versionResources.GetName(), commandRootNode, commandResources, versionResources.GetUseBedrockStringReader());
return(dispatcher);
}
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 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());
}
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 ReadResults Parse(IStringReader reader, DispatcherResources resources, out Operation result)
{
result = default;
int start = reader.GetCursor();
while (!reader.AtEndOfArgument())
{
reader.Skip();
}
string operation = reader.GetString()[start..reader.GetCursor()];
public BlockParser(IStringReader stringReader, bool forTesting, DispatcherResources resources, bool useBedrock)
{
StringReader = stringReader;
ForTesting = forTesting;
Resources = resources;
UseBedrock = useBedrock;
Block = null;
IsTag = false;
}
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 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 Storage result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation storage);
if (readResults.Successful)
{
result = new Storage(storage);
}
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);
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Predicate result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation predicate);
if (readResults.Successful)
{
result = new Predicate(predicate);
}
return(readResults);
}
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 Bossbar result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation bossbar);
if (readResults.Successful)
{
result = new Bossbar(bossbar);
}
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 bool Read(string input, DispatcherResources resources)
{
if (string.IsNullOrEmpty(input))
{
return(ContentsOptional || Contents == ContentType.None);
}
string[] values = input.Substring(1).Split('.');
return(Contents switch
{
ContentType.None => string.IsNullOrEmpty(input),
ContentType.Colour => values.Length == 2 && "team".Equals(values[0]) && resources.Colours.Contains(values[1]),
_ => false
});
public bool Read(string contents, DispatcherResources resources)
{
bool successfulParse = ResourceLocation.TryParse(contents, out ResourceLocation resourceLocation);
return(CriterionType switch
{
CriterionType.None => string.IsNullOrEmpty(contents),
CriterionType.Colour => resources.Colours.Contains(contents),
CriterionType.Item => successfulParse && resources.Items.Contains(resourceLocation),
CriterionType.Block => successfulParse && resources.Blocks.ContainsBlock(resourceLocation),
CriterionType.Entity => successfulParse && resources.Entities.Contains(resourceLocation),
CriterionType.Statistic => resources.ObjectiveCriteria.ContainsCustomCriterion(contents),
_ => false
});
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Enchantment result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation enchantment);
if (!readResults.Successful)
{
return(readResults);
}
if (!resources.Enchantments.Contains(enchantment))
{
return(ReadResults.Failure(CommandError.UnknownEnchantment(enchantment)));
}
result = new Enchantment(enchantment);
return(ReadResults.Success());
}
public ReadResults Parse(IStringReader reader, DispatcherResources resources, out MobEffect result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation mobEffect);
if (!readResults.Successful)
{
return(readResults);
}
if (!resources.MobEffects.Contains(mobEffect))
{
return(ReadResults.Failure(CommandError.UnknownEffect(mobEffect)));
}
result = new MobEffect(mobEffect);
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 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));
}
