GenisysPro  for Minecraft PE/Windows 10 v1.1.x
Feature-rich server software for Minecraft PE and Windows 10 Edition
Public Member Functions | Static Public Member Functions | Data Fields
NBT Class Reference

Public Member Functions

 get ($len)
 
 put ($v)
 
 feof ()
 
 __construct ($endianness=self::LITTLE_ENDIAN)
 
 read ($buffer, $doMultiple=false, bool $network=false)
 
 readCompressed ($buffer, $compression=ZLIB_ENCODING_GZIP)
 
 readNetworkCompressed ($buffer, $compression=ZLIB_ENCODING_GZIP)
 
 write (bool $network=false)
 
 writeCompressed ($compression=ZLIB_ENCODING_GZIP, $level=7)
 
 writeNetworkCompressed ($compression=ZLIB_ENCODING_GZIP, $level=7)
 
 readTag (bool $network=false)
 
 writeTag (Tag $tag, bool $network=false)
 
 getByte ()
 
 putByte ($v)
 
 getShort ()
 
 putShort ($v)
 
 getInt (bool $network=false)
 
 putInt ($v, bool $network=false)
 
 getLong ()
 
 putLong ($v)
 
 getFloat ()
 
 putFloat ($v)
 
 getDouble ()
 
 putDouble ($v)
 
 getString (bool $network=false)
 
 putString ($v, bool $network=false)
 
 getArray ()
 
 setArray (array $data, callable $guesser=null)
 
 getData ()
 
 setData ($data)
 

Static Public Member Functions

static matchList (ListTag $tag1, ListTag $tag2)
 
static matchTree (CompoundTag $tag1, CompoundTag $tag2)
 
static combineCompoundTags (CompoundTag $tag1, CompoundTag $tag2, bool $override=false)
 
static parseJSON ($data, &$offset=0)
 
static fromArrayGuesser ($key, $value)
 

Data Fields

const LITTLE_ENDIAN = 0
 
const BIG_ENDIAN = 1
 
const TAG_End = 0
 
const TAG_Byte = 1
 
const TAG_Short = 2
 
const TAG_Int = 3
 
const TAG_Long = 4
 
const TAG_Float = 5
 
const TAG_Double = 6
 
const TAG_ByteArray = 7
 
const TAG_String = 8
 
const TAG_List = 9
 
const TAG_Compound = 10
 
const TAG_IntArray = 11
 
 $buffer
 
 $endianness
 

Detailed Description

Named Binary Tag encoder/decoder

Constructor & Destructor Documentation

◆ __construct()

__construct (   $endianness = self::LITTLE_ENDIAN)

NBT constructor.

Parameters
int$endianness
492  {
493  $this->offset = 0;
494  $this->endianness = $endianness & 0x01;
495  }

Member Function Documentation

◆ combineCompoundTags()

static combineCompoundTags ( CompoundTag  $tag1,
CompoundTag  $tag2,
bool  $override = false 
)
static
Parameters
CompoundTag$tag1
CompoundTag$tag2
bool$override
Returns
CompoundTag
159  : CompoundTag{
160  $tag1 = clone $tag1;
161  foreach($tag2 as $k => $v){
162  if(!($v instanceof Tag)){
163  continue;
164  }
165  if(!isset($tag1->{$k}) or (isset($tag1->{$k}) and $override)){
166  $tag1->{$k} = clone $v;
167  }
168  }
169  return $tag1;
170  }

◆ feof()

feof ( )
Returns
bool
483  {
484  return !isset($this->buffer{$this->offset});
485  }

◆ fromArrayGuesser()

static fromArrayGuesser (   $key,
  $value 
)
static
Parameters
$key
$value
Returns
null|ByteTag|FloatTag|IntTag|StringTag
804  {
805  if(is_int($value)){
806  return new IntTag($key, $value);
807  }elseif(is_float($value)){
808  return new FloatTag($key, $value);
809  }elseif(is_string($value)){
810  return new StringTag($key, $value);
811  }elseif(is_bool($value)){
812  return new ByteTag($key, $value ? 1 : 0);
813  }
814 
815  return null;
816  }

◆ get()

get (   $len)
Parameters
$len
Returns
bool|string
462  {
463  if($len < 0){
464  $this->offset = strlen($this->buffer) - 1;
465  return "";
466  }elseif($len === true){
467  return substr($this->buffer, $this->offset);
468  }
469 
470  return $len === 1 ? $this->buffer{$this->offset++} : substr($this->buffer, ($this->offset += $len) - $len, $len);
471  }

◆ getArray()

getArray ( )
777  {
778  $data = [];
779  self::toArray($data, $this->data);
780  }

◆ getByte()

getByte ( )
Returns
int
663  {
664  return Binary::readByte($this->get(1));
665  }

◆ getData()

getData ( )
Returns
CompoundTag|array
859  {
860  return $this->data;
861  }

◆ getDouble()

getDouble ( )
Returns
mixed
743  {
744  return $this->endianness === self::BIG_ENDIAN ? Binary::readDouble($this->get(8)) : Binary::readLDouble($this->get(8));
745  }

◆ getFloat()

getFloat ( )
Returns
float
729  {
730  return $this->endianness === self::BIG_ENDIAN ? Binary::readFloat($this->get(4)) : Binary::readLFloat($this->get(4));
731  }

◆ getInt()

getInt ( bool  $network = false)
Parameters
bool$network
Returns
int
693  {
694  if($network === true){
695  return Binary::readVarInt($this);
696  }
697  return $this->endianness === self::BIG_ENDIAN ? Binary::readInt($this->get(4)) : Binary::readLInt($this->get(4));
698  }

◆ getLong()

getLong ( )
Returns
int|string
715  {
716  return $this->endianness === self::BIG_ENDIAN ? Binary::readLong($this->get(8)) : Binary::readLLong($this->get(8));
717  }

◆ getShort()

getShort ( )
Returns
int
677  {
678  return $this->endianness === self::BIG_ENDIAN ? Binary::readShort($this->get(2)) : Binary::readLShort($this->get(2));
679  }

◆ getString()

getString ( bool  $network = false)
Parameters
bool$network
Returns
bool|string
759  {
760  $len = $network ? Binary::readUnsignedVarInt($this) : $this->getShort();
761  return $this->get($len);
762  }

◆ matchList()

static matchList ( ListTag  $tag1,
ListTag  $tag2 
)
static
Parameters
ListTag$tag1
ListTag$tag2
Returns
bool
82  {
83  if($tag1->getName() !== $tag2->getName() or $tag1->getCount() !== $tag2->getCount()){
84  return false;
85  }
86 
87  foreach($tag1 as $k => $v){
88  if(!($v instanceof Tag)){
89  continue;
90  }
91 
92  if(!isset($tag2->{$k}) or !($tag2->{$k} instanceof $v)){
93  return false;
94  }
95 
96  if($v instanceof CompoundTag){
97  if(!self::matchTree($v, $tag2->{$k})){
98  return false;
99  }
100  }elseif($v instanceof ListTag){
101  if(!self::matchList($v, $tag2->{$k})){
102  return false;
103  }
104  }else{
105  if($v->getValue() !== $tag2->{$k}->getValue()){
106  return false;
107  }
108  }
109  }
110 
111  return true;
112  }

◆ matchTree()

static matchTree ( CompoundTag  $tag1,
CompoundTag  $tag2 
)
static
Parameters
CompoundTag$tag1
CompoundTag$tag2
Returns
bool
120  {
121  if($tag1->getName() !== $tag2->getName() or $tag1->getCount() !== $tag2->getCount()){
122  return false;
123  }
124 
125  foreach($tag1 as $k => $v){
126  if(!($v instanceof Tag)){
127  continue;
128  }
129 
130  if(!isset($tag2->{$k}) or !($tag2->{$k} instanceof $v)){
131  return false;
132  }
133 
134  if($v instanceof CompoundTag){
135  if(!self::matchTree($v, $tag2->{$k})){
136  return false;
137  }
138  }elseif($v instanceof ListTag){
139  if(!self::matchList($v, $tag2->{$k})){
140  return false;
141  }
142  }else{
143  if($v->getValue() !== $tag2->{$k}->getValue()){
144  return false;
145  }
146  }
147  }
148 
149  return true;
150  }

◆ parseJSON()

static parseJSON (   $data,
&  $offset = 0 
)
static
Parameters
$data
int$offset
Returns
null|CompoundTag
Exceptions
179  {
180  $len = strlen($data);
181  for(; $offset < $len; ++$offset){
182  $c = $data{$offset};
183  if($c === "{"){
184  ++$offset;
185  $data = self::parseCompound($data, $offset);
186  return new CompoundTag("", $data);
187  }elseif($c !== " " and $c !== "\r" and $c !== "\n" and $c !== "\t"){
188  throw new \Exception("Syntax error: unexpected '$c' at offset $offset");
189  }
190  }
191 
192  return null;
193  }

◆ put()

put (   $v)
Parameters
$v
476  {
477  $this->buffer .= $v;
478  }

◆ putByte()

putByte (   $v)
Parameters
$v
670  {
671  $this->buffer .= Binary::writeByte($v);
672  }

◆ putDouble()

putDouble (   $v)
Parameters
$v
750  {
751  $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeDouble($v) : Binary::writeLDouble($v);
752  }

◆ putFloat()

putFloat (   $v)
Parameters
$v
736  {
737  $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeFloat($v) : Binary::writeLFloat($v);
738  }

◆ putInt()

putInt (   $v,
bool  $network = false 
)
Parameters
$v
bool$network
704  {
705  if($network === true){
706  $this->buffer .= Binary::writeVarInt($v);
707  }else{
708  $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeInt($v) : Binary::writeLInt($v);
709  }
710  }

◆ putLong()

putLong (   $v)
Parameters
$v
722  {
723  $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeLong($v) : Binary::writeLLong($v);
724  }

◆ putShort()

putShort (   $v)
Parameters
$v
684  {
685  $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeShort($v) : Binary::writeLShort($v);
686  }

◆ putString()

putString (   $v,
bool  $network = false 
)
Parameters
$v
bool$network
768  {
769  if($network === true){
770  $this->put(Binary::writeUnsignedVarInt(strlen($v)));
771  }else{
772  $this->putShort(strlen($v));
773  }
774  $this->buffer .= $v;
775  }

◆ read()

read (   $buffer,
  $doMultiple = false,
bool  $network = false 
)
Parameters
$buffer
bool$doMultiple
bool$network
502  {
503  $this->offset = 0;
504  $this->buffer = $buffer;
505  $this->data = $this->readTag($network);
506  if($doMultiple and $this->offset < strlen($this->buffer)){
507  $this->data = [$this->data];
508  do{
509  $this->data[] = $this->readTag($network);
510  }while($this->offset < strlen($this->buffer));
511  }
512  $this->buffer = "";
513  }

◆ readCompressed()

readCompressed (   $buffer,
  $compression = ZLIB_ENCODING_GZIP 
)
Parameters
$buffer
int$compression
519  {
520  $this->read(zlib_decode($buffer));
521  }

◆ readNetworkCompressed()

readNetworkCompressed (   $buffer,
  $compression = ZLIB_ENCODING_GZIP 
)
Parameters
$buffer
int$compression
527  {
528  $this->read(zlib_decode($buffer), false, true);
529  }

◆ readTag()

readTag ( bool  $network = false)
Parameters
bool$network
Returns
ByteArrayTag|ByteTag|DoubleTag|FloatTag|IntTag|LongTag|ShortTag
588  {
589  if($this->feof()){
590  $tagType = -1; //prevent crashes for empty tags
591  }else{
592  $tagType = $this->getByte();
593  }
594  switch($tagType){
595  case NBT::TAG_Byte:
596  $tag = new ByteTag($this->getString($network));
597  $tag->read($this, $network);
598  break;
599  case NBT::TAG_Short:
600  $tag = new ShortTag($this->getString($network));
601  $tag->read($this, $network);
602  break;
603  case NBT::TAG_Int:
604  $tag = new IntTag($this->getString($network));
605  $tag->read($this, $network);
606  break;
607  case NBT::TAG_Long:
608  $tag = new LongTag($this->getString($network));
609  $tag->read($this, $network);
610  break;
611  case NBT::TAG_Float:
612  $tag = new FloatTag($this->getString($network));
613  $tag->read($this, $network);
614  break;
615  case NBT::TAG_Double:
616  $tag = new DoubleTag($this->getString($network));
617  $tag->read($this, $network);
618  break;
619  case NBT::TAG_ByteArray:
620  $tag = new ByteArrayTag($this->getString($network));
621  $tag->read($this, $network);
622  break;
623  case NBT::TAG_String:
624  $tag = new StringTag($this->getString($network));
625  $tag->read($this, $network);
626  break;
627  case NBT::TAG_List:
628  $tag = new ListTag($this->getString($network));
629  $tag->read($this, $network);
630  break;
631  case NBT::TAG_Compound:
632  $tag = new CompoundTag($this->getString($network));
633  $tag->read($this, $network);
634  break;
635  case NBT::TAG_IntArray:
636  $tag = new IntArrayTag($this->getString($network));
637  $tag->read($this, $network);
638  break;
639 
640  case NBT::TAG_End: //No named tag
641  default:
642  $tag = new EndTag;
643  break;
644  }
645  return $tag;
646  }

◆ setArray()

setArray ( array  $data,
callable  $guesser = null 
)
Parameters
array$data
callable | null$guesser
851  {
852  $this->data = new CompoundTag("", []);
853  self::fromArray($this->data, $data, $guesser === null ? [self::class, "fromArrayGuesser"] : $guesser);
854  }

◆ setData()

setData (   $data)
Parameters
CompoundTag | array$data
866  {
867  $this->data = $data;
868  }

◆ write()

write ( bool  $network = false)
Parameters
bool$network
Returns
string|bool
537  {
538  $this->offset = 0;
539  $this->buffer = "";
540 
541  if($this->data instanceof CompoundTag){
542  $this->writeTag($this->data, $network);
543 
544  return $this->buffer;
545  }elseif(is_array($this->data)){
546  foreach($this->data as $tag){
547  $this->writeTag($tag, $network);
548  }
549  return $this->buffer;
550  }
551 
552  return false;
553  }

◆ writeCompressed()

writeCompressed (   $compression = ZLIB_ENCODING_GZIP,
  $level = 7 
)
Parameters
int$compression
int$level
Returns
bool|string
561  {
562  if(($write = $this->write()) !== false){
563  return zlib_encode($write, $compression, $level);
564  }
565 
566  return false;
567  }

◆ writeNetworkCompressed()

writeNetworkCompressed (   $compression = ZLIB_ENCODING_GZIP,
  $level = 7 
)
Parameters
int$compression
int$level
Returns
bool|string
575  {
576  if(($write = $this->write(true)) !== false){
577  return zlib_encode($write, $compression, $level);
578  }
579 
580  return false;
581  }

◆ writeTag()

writeTag ( Tag  $tag,
bool  $network = false 
)
Parameters
Tag$tag
bool$network
652  {
653  $this->putByte($tag->getType());
654  if($tag instanceof NamedTag){
655  $this->putString($tag->getName(), $network);
656  }
657  $tag->write($this, $network);
658  }

Field Documentation

◆ $buffer

$buffer

◆ $endianness

$endianness

◆ BIG_ENDIAN

const BIG_ENDIAN = 1

◆ LITTLE_ENDIAN

const LITTLE_ENDIAN = 0

◆ TAG_Byte

const TAG_Byte = 1

◆ TAG_ByteArray

const TAG_ByteArray = 7

◆ TAG_Compound

const TAG_Compound = 10

◆ TAG_Double

const TAG_Double = 6

◆ TAG_End

const TAG_End = 0

◆ TAG_Float

const TAG_Float = 5

◆ TAG_Int

const TAG_Int = 3

◆ TAG_IntArray

const TAG_IntArray = 11

◆ TAG_List

const TAG_List = 9

◆ TAG_Long

const TAG_Long = 4

◆ TAG_Short

const TAG_Short = 2

◆ TAG_String

const TAG_String = 8
The documentation for this class was generated from the following file: