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 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 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(IStringReader reader, DispatcherResources resources, out Particle result)
{
result = default;
ReadResults readResults = ResourceLocation.TryRead(reader, out ResourceLocation particle);
if (!readResults.Successful)
{
return(readResults);
}
if (!resources.Particles.TryGetNodes(particle, out Dictionary <string, Node> nodes))
{
return(ReadResults.Failure(CommandError.UnknownParticle(particle)));
}
Dictionary <string, ParsedArgument> arguments = new Dictionary <string, ParsedArgument>();
CommandContext context;
foreach (KeyValuePair <string, Node> pair in nodes)
{
readResults = reader.Expect(' ');
if (!readResults.Successful)
{
return(readResults);
}
context = new CommandContext(0);
readResults = pair.Value.Parse(reader, context, resources);
if (!readResults.Successful)
{
return(readResults);
}
arguments.Add(pair.Key, context.Results[0]);
}
result = new Particle(particle, arguments);
return(ReadResults.Success());
}
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('}'));
}
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());
}
