public Block(ResourceLocation block, Dictionary <string, string> blockStates, INbtTag nbt, bool isTag)
{
Resource = block;
BlockStates = blockStates;
Nbt = nbt;
IsTag = isTag;
}
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());
}
private INbtTag GetCurrentTag(NbtTagType type, bool readName = true)
{
string name = string.Empty;
if (readName)
{
name = this.ReadString();
}
INbtTag tag = type switch
{
NbtTagType.Byte => new NbtTag <byte>(name, this.ReadByte()),
NbtTagType.Short => new NbtTag <short>(name, this.ReadInt16()),
NbtTagType.Int => new NbtTag <int>(name, this.ReadInt32()),
NbtTagType.Long => new NbtTag <long>(name, this.ReadInt64()),
NbtTagType.Float => new NbtTag <float>(name, this.ReadSingle()),
NbtTagType.Double => new NbtTag <double>(name, this.ReadDouble()),
NbtTagType.String => new NbtTag <string>(name, this.ReadString()),
NbtTagType.Compound => this.ReadCompoundTag(name),
NbtTagType.List => this.ReadListTag(name),
NbtTagType.ByteArray => this.ReadArray(name, type),
NbtTagType.IntArray => this.ReadArray(name, type),
NbtTagType.LongArray => this.ReadArray(name, type),
_ => null
};
return(tag);
}
public bool Add(INbtTag tag)
{
if (tag is IntegerNbtTag i)
{
Data.Add(i);
return(true);
}
return(false);
}
public bool Add(INbtTag tag)
{
if (tag is LongNbtTag l)
{
Data.Add(l);
return(true);
}
return(false);
}
public static INbtTag <T> As <T>(this INbtTag tag)
{
if (TagMatchesResultType(tag, typeof(T)))
{
return(tag as INbtTag <T>);
}
return(null);
}
public static INbtDictionary AsDictionary(this INbtTag tag)
{
if (TagMatchesResultType(tag, typeof(INbtDictionary)))
{
return(tag as INbtDictionary);
}
return(null);
}
public static INbtStream AsStream(this INbtTag tag)
{
if (TagMatchesResultType(tag, typeof(INbtStream)))
{
return(tag as INbtStream);
}
return(null);
}
private void WriteTag(INbtTag tag)
{
switch (tag.TagType)
{
case 1:
WriteByte(((NbtByte)tag).Value);
break;
case 2:
WriteShort(((NbtShort)tag).Value);
break;
case 3:
WriteInt(((NbtInt)tag).Value);
break;
case 4:
WriteLong(((NbtLong)tag).Value);
break;
case 5:
WriteFloat(((NbtFloat)tag).Value);
break;
case 6:
WriteDouble(((NbtFloat)tag).Value);
break;
case 7:
WriteByteArray(((NbtByteArray)tag).Value);
break;
case 8:
WriteString(((NbtString)tag).Value);
break;
case 9:
WriteList(((NbtList)tag).Value);
break;
case 10:
WriteCompound(((NbtCompound)tag).Value);
break;
case 11:
WriteIntArray(((NbtIntArray)tag).Value);
break;
case 12:
WriteLongArray(((NbtLongArray)tag).Value);
break;
default:
OutOfRangeTypeCodeThrow();
break;
}
}
public bool Add(INbtTag tag)
{
if (tag is ByteNbtTag b)
{
Data.Add(b);
return(true);
}
return(false);
}
private ReadResults ReadList(out INbtTag result)
{
if (Reader.CanRead(3) && !Reader.IsQuotedStringStart(Reader.Peek(1)) && Reader.Peek(2) == ';')
{
return(ReadArrayTag(out result));
}
else
{
return(ReadListTag(out result));
}
}
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 static INbtArrayTag <T> AsArray <T>(this INbtTag tag)
where T : struct
{
var list = tag as INbtList;
if (TagTypeMatchesType(list.Subtype, typeof(T)))
{
return(list as INbtArrayTag <T>);
}
return(null);
}
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 bool Add(INbtTag tag)
{
sbyte id = tag.GetId();
if (Type == null)
{
Type = id;
}
else if (Type != id)
{
return(false);
}
Data.Add(tag);
return(true);
}
public override bool Equals([AllowNull] INbtTag other)
{
if (other is not TagArray <T> tag || Value.Length != tag.Value.Length)
{
return(false);
}
for (int i = 0; i < Value.Length; i++)
{
if (!Value[i].Equals(tag.Value[i]))
{
return(false);
}
}
return(true);
}
public override bool Equals(INbtTag obj)
{
if (obj is not TagList <T> lst || lst.Count != Count)
{
return(false);
}
for (int i = 0; i < Count; i++)
{
if (!lst[i].Equals(Value[i]))
{
return(false);
}
}
return(true);
}
private ReadResults ReadArrayTag(out INbtTag result)
{
result = default;
ReadResults readResults = Reader.Expect('[');
if (!readResults.Successful)
{
return(readResults);
}
int start = Reader.GetCursor();
char type = Reader.Read();
Reader.Skip();
Reader.SkipWhitespace();
if (!Reader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedValue().WithContext(Reader)));
}
INbtCollectionTag list;
switch (type)
{
case 'B':
list = new ByteArrayNbtTag();
break;
case 'I':
list = new IntegerArrayNbtTag();
break;
case 'L':
list = new LongArrayNbtTag();
break;
default:
Reader.SetCursor(start);
return(ReadResults.Failure(CommandError.InvalidArrayType(type).WithContext(Reader)));
}
readResults = ReadListContents(ref list);
if (readResults.Successful)
{
result = list;
}
return(readResults);
}
private static bool TagMatchesResultType(INbtTag tag, Type type)
{
if (tag.Type == NbtTagType.List)
{
var interfaceType = type.GetInterfaces().Where(t => t.Name == "INbtTag" && t.GenericTypeArguments.Length > 0).FirstOrDefault();
if (interfaceType == null)
{
return(false);
}
var listSubtype = interfaceType.GenericTypeArguments[0];
var list = tag as INbtList;
return(TagTypeMatchesType(list.Subtype, listSubtype));
}
return(TagTypeMatchesType(tag.Type, type));
}
private ReadResults ReadListTag(out INbtTag result)
{
result = default;
ReadResults readResults = Reader.Expect('[');
if (!readResults.Successful)
{
return(readResults);
}
if (!Reader.CanRead())
{
return(ReadResults.Failure(CommandError.ExpectedValue().WithContext(Reader)));
}
INbtCollectionTag list = new ListNbtTag();
return(ReadListContents(ref list));
}
public NbtTag(string name, T value, INbtTag parent = null)
{
this.Name = name;
this.Parent = parent;
this.Value = value;
this.Type = value switch
{
bool => NbtTagType.Byte,
byte => NbtTagType.Byte,
short => NbtTagType.Short,
int => NbtTagType.Int,
long => NbtTagType.Long,
float => NbtTagType.Float,
double => NbtTagType.Double,
string => NbtTagType.String,
_ => throw new InvalidOperationException()
};
}
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));
}
public void WriteNbt(INbtTag nbt)
{
using var writer = new NbtWriter(BaseStream);
writer.WriteTag(nbt);
}
static void ExploreValue(INbtTag tag, int depth)
{
Console.Write("|-".PadRight(depth + 2, '-'));
Console.Write($" {tag.Type}: {tag.Name} = ");
switch (tag.Type)
{
case NbtTagType.Float32:
Console.WriteLine(tag.As <float>().Value);
break;
case NbtTagType.Float64:
Console.WriteLine(tag.As <double>().Value);
break;
case NbtTagType.Int16:
Console.WriteLine(tag.As <short>().Value);
break;
case NbtTagType.Int32:
Console.WriteLine(tag.As <int>().Value);
break;
case NbtTagType.Int64:
Console.WriteLine(tag.As <long>().Value);
break;
case NbtTagType.UInt8:
Console.WriteLine(tag.As <byte>().Value);
break;
case NbtTagType.Utf8String:
Console.WriteLine(tag.As <string>().Value);
break;
case NbtTagType.Int32Array:
WriteArray(tag.AsArray <int>(), depth + 1);
break;
case NbtTagType.Int64Array:
WriteArray(tag.AsArray <long>(), depth + 1);
break;
case NbtTagType.UInt8Array:
WriteArray(tag.AsArray <byte>(), depth + 1);
break;
case NbtTagType.List:
{
var listBase = tag as INbtList;
switch (listBase.Subtype)
{
case NbtTagType.Int16:
WriteSimpleList(listBase as INbtList <short>, depth + 1);
break;
case NbtTagType.Int32:
WriteSimpleList(listBase as INbtList <int>, depth + 1);
break;
case NbtTagType.Int64:
WriteSimpleList(listBase as INbtList <long>, depth + 1);
break;
case NbtTagType.UInt8:
WriteSimpleList(listBase as INbtList <byte>, depth + 1);
break;
case NbtTagType.Utf8String:
WriteSimpleList(listBase as INbtList <string>, depth + 1);
break;
case NbtTagType.Compound:
WriteCompoundList(listBase as INbtList <INbtStream>, depth + 1);
break;
default:
throw new NotSupportedException("Not yet supported.");
}
break;
}
case NbtTagType.Compound:
Console.WriteLine("(compound item)");
var stream = tag.AsStream();
while (stream.MoveNext())
{
ExploreValue(stream.CurrentValue, depth + 1);
}
break;
}
}
public override bool Equals([AllowNull] INbtTag other) => other switch
{
public BlockMetaBuilder AddBlockEntityTag(INbtTag tag)
{
this.BlockEntityTag.Add(tag);
return(this);
}
public bool TryGetValue(string key, out INbtTag tag) => tags_.TryGetValue(key, out tag);
public void Add(string key, INbtTag value)
{
Data[key] = value;
}
public bool MoveNext()
{
if (source_.Position >= source_.Length)
{
return(false);
}
long before = source_.Position;
try
{
NbtTagType nextTagType = (NbtTagType)reader_.ReadByte();
if (nextTagType == NbtTagType.EndTag)
{
currentTag_ = EndTag.Instance;
return(source_.Position < source_.Length);
}
ushort nextTagNameLength = reader_.ReadUInt16();
string nextTagName = "";
if (nextTagNameLength > 0)
{
byte[] utf8TagName = reader_.ReadBytes(nextTagNameLength);
nextTagName = Encoding.UTF8.GetString(utf8TagName);
}
switch (nextTagType)
{
case NbtTagType.Float32:
case NbtTagType.Float64:
case NbtTagType.Int16:
case NbtTagType.Int32:
case NbtTagType.Int64:
case NbtTagType.UInt8:
case NbtTagType.Utf8String:
currentTag_ = SimpleTag.FromReader(nextTagType, nextTagName, reader_);
return(true);
case NbtTagType.Int32Array:
case NbtTagType.Int64Array:
case NbtTagType.UInt8Array:
currentTag_ = NumberArrayTag.FromReader(nextTagType, nextTagName, reader_);
return(true);
case NbtTagType.List:
currentTag_ = ListTag.FromReaderAndStream(nextTagName, reader_, this);
return(true);
case NbtTagType.Compound:
currentTag_ = NbtCompoundTag.FromReader(nextTagName, this);
return(true);
default:
Debug.WriteLine($"Unrecognized NBT tag {((int)nextTagType):x2} at position 0x{before:x}");
throw new Exception($"Unrecognized NBT tag {((int)nextTagType):x2} at position 0x{before:x}");
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.StackTrace);
source_.Seek(before, SeekOrigin.Begin);
return(false);
}
}
public Item(ResourceLocation item, INbtTag nbt, bool isTag)
{
Resource = item;
Nbt = nbt;
IsTag = isTag;
}
