예제 #1
0
 /**
  * Get Nether Wart at the given stage of growth.
  *
  * @param int $note Note the block should play (0-15)
  *
  * @throws \Exception
  */
 public function __construct($note)
 {
     $this->setBlockIDAndDataFor(Ref::NOTE_BLOCK);
     $this->checkValue($note, 0, 15, 'Invalid note for note block');
     $this->initEntityData('Music');
     $this->entityData->addChild(\Nbt\Tag::tagByte('note', $note));
 }
예제 #2
0
 /**
  * A flower pot, optionally containing a flower
  *
  * @param \MME\Block $contains The flower the block contains
  */
 public function __construct($contains = null)
 {
     // This is going to define the plant in the tile entity data
     // - which is to be done...
     $this->setBlockIDAndDataFor(Ref::FLOWER_POT);
     $this->initEntityData('FlowerPot');
     $this->entityData->addChild(\Nbt\Tag::tagString('Item', $contains ? Names::$list[$contains->ref] : ''));
     $this->entityData->addChild(\Nbt\Tag::tagInt('Data', $contains ? $contains->data : 0));
 }
예제 #3
0
 /**
  * Get a furnace facing in the given direction.
  *
  * @param int             $blockRef      Which furnace to use
  * @param int             $facing        The direction it faces; one of the class constants
  * @param \MME\Stack|null $input         Data for the stack in the input slot
  * @param \MME\Stack|null $fuel          Data for the stack in the fuel slot
  * @param \MME\Stack|null $output        Data for the stack in the output slot
  * @param int             $burnTime      Time left for fuel to burn
  * @param int             $cookTime      Time left for item to finish cooking
  * @param int             $cookTimeTotal Total time for item to cook
  *
  * @throws \Exception
  */
 public function __construct($blockRef, $facing, $input = null, $fuel = null, $output = null, $burnTime = 0, $cookTime = 0, $cookTimeTotal = 0)
 {
     $this->checkBlock($blockRef, Ref::getStartsWith('FURNACE'));
     $this->checkDataRefValidAll($facing, 'Invalid facing reference for furnace');
     $this->setBlockData($facing);
     $this->initEntityData('Furnace');
     $this->addItemsForSlots([0 => $input, 1 => $fuel, 2 => $output]);
     $this->entityData->addChild(\Nbt\Tag::tagShort('BurnTime', $burnTime));
     $this->entityData->addChild(\Nbt\Tag::tagShort('CookTime', $cookTime));
     $this->entityData->addChild(\Nbt\Tag::tagShort('CookTimeTotal', $cookTimeTotal));
 }
 /**
  * Get a comparator with the given settings.
  *
  * @param int $facing  Direction the comparator is facing; one of the FACING_ class constants
  * @param int $mode    Which mode the comparator is in; one of the MODE_ class constants
  * @param int $powered Either RedstoneComparator::UNPOWERED or RedstoneComparator::POWERED#
  * @param int $outputSignal Strength of output signal
  *
  * @throws \Exception
  */
 public function __construct($facing, $mode, $powered = self::UNPOWERED, $outputSignal = 0)
 {
     $this->setBlockIDFor(Ref::REDSTONE_COMPARATOR);
     $this->checkDataRefValidStartsWith($facing, 'FACING_', 'Invalid facing status for comparator');
     $this->checkDataRefValidStartsWith($mode, 'MODE_', 'Invalid mode for comparator');
     $this->checkInList($powered, [self::UNPOWERED, self::POWERED], 'Invalid powered setting for comparator');
     $this->setBlockData($facing | $mode | $powered);
     $this->initEntityData('Comparator');
     $this->checkValue($outputSignal, 0, 15, 'Invalid Output Signal Stregth for comparator');
     $this->entityData->addChild(\Nbt\Tag::tagInt('OutputSignal', $outputSignal));
 }
예제 #5
0
 /**
  * Get a hopper, with the output in the given direction.
  *
  * @param int                         $output           Output direction; one of the OUTPUT_ class constants
  * @param \MME\Stack[] $items            Items in the dropper, with pre-set slots (0-8).
  *                                                      0 is the top-left corner.
  * @param int                         $active           [Optional] Either Hopper:INACTIVE or Hopper::ACTIVE
  * @param string                      $customName       Custom name for the chest, appears in GUI
  * @param string                      $lock             Lock the dropper so it can only be opened if the player
  *                                                      is holding an item whose name matches this string
  * @param int                         $transferCooldown Time to next transfer in game ticks.
  *
  * @throws \Exception
  */
 public function __construct($output, $items = [], $active = self::ACTIVE, $customName = null, $lock = null, $transferCooldown = 0)
 {
     $this->setBlockIDFor(Ref::HOPPER);
     $this->checkDataRefValidStartsWith($output, 'OUTPUT_', 'Invalid output reference for hopper');
     $this->checkInList($active, [self::ACTIVE, self::DISABLED], 'Invalid active reference for hopper');
     $this->setBlockData($output | $active);
     $this->initEntityData('Hopper');
     $this->addItemStacks($items);
     $this->setCustomName($customName);
     $this->setLock($lock);
     $this->entityData->addChild(\Nbt\Tag::tagInt('TransferCooldown', $transferCooldown));
 }
 /**
  * Add a command block.
  *
  * @param string         $command      Command that the block will run
  * @param int            $trackOutput  [optional] Either CommandBlock::TRACK_OUTPUT or CommandBlock::NO_TRACK_OUTPUT
  * @param \Nbt\Node|null $commandStats [optional] Command stats compound tag, if required.
  * @param string|null    $customName   [optional]
  * @param string|null    $lock         [optional]
  *
  * @throws \Exception
  */
 public function __construct($command, $trackOutput = self::TRACK_OUTPUT, $commandStats = null, $customName = null, $lock = null)
 {
     $this->setBlockIDAndDataFor(Ref::COMMAND_BLOCK);
     $this->initEntityData('Control');
     $this->entityData->addChild(\Nbt\Tag::tagString('Command', $command));
     $this->entityData->addChild(\Nbt\Tag::tagByte('TrackOutput', $trackOutput));
     $this->setCustomName($customName);
     $this->setLock($lock);
     if ($commandStats !== null) {
         $this->entityData->addChild($commandStats);
     }
 }
예제 #7
0
 /**
  * Add a list of item stacks to the 'Items' list tag.
  *
  * @param \MME\Stack[] $items
  */
 protected function addItemStacks($items)
 {
     if (count($items)) {
         $payload = \Nbt\Tag::TAG_COMPOUND;
     } else {
         $payload = \Nbt\Tag::TAG_END;
     }
     $itemsList = \Nbt\Tag::tagList('Items', $payload, []);
     $this->entityData->addChild($itemsList);
     foreach ($items as $item) {
         $itemsList->addChild($item->node);
     }
 }
예제 #8
0
 /**
  * Check the orientation of the mob head based on the placement.
  *
  * @param int $placement
  * @param int $orientation
  */
 protected function checkOrientation($placement, $orientation)
 {
     $rotValue = 0;
     switch ($placement) {
         case self::PLACE_WALL:
             $this->checkWallOrientation($orientation);
             break;
         case self::PLACE_FLOOR:
             $this->setBlockData(1);
             $rotValue = $orientation;
             break;
     }
     $this->entityData->addChild(\Nbt\Tag::tagByte('Rot', $rotValue));
 }
예제 #9
0
 /**
  * Set the patterns for the banner.
  *
  * @param array $patterns
  */
 protected function bannerPatterns($patterns)
 {
     if (count($patterns)) {
         // Set up the pattern list
         $patternList = \Nbt\Tag::tagList('Patterns', \Nbt\Tag::TAG_COMPOUND, []);
         $this->entityData->addChild($patternList);
         foreach ($patterns as $pattern) {
             // Check the pattern details are valid
             $this->checkDataRefValidStartsWith($pattern['color'], 'COLOR_', 'Invalid base color for banner pattern');
             $this->checkDataRefValidStartsWith($pattern['pattern'], 'PATTERN_', 'Invalid pattern reference for banner pattern');
             // Add the pattern to the list
             $patternList->addChild(\Nbt\Tag::tagCompound('', [\Nbt\Tag::tagInt('Color', $this->bannerConvertColor($pattern['color'])), \Nbt\Tag::tagString('Pattern', $pattern['pattern'])]));
         }
     }
 }
예제 #10
0
 /**
  * Create a mob spawner. There's no checking of the information passed yet.
  * I don't know the valid values, etc; proper error checking is still to come.
  * Test your creations well!
  *
  * @param \Nbt\Node|null $spawnPotentials     List of potential spawns
  * @param string         $entityID            Entity name to spawn
  * @param \Nbt\Node|null $spawnData           Data to pass to the spawned mobs
  * @param int            $spawnCount          Number of mobs to attempt to spawn
  * @param int            $spawnRange          Radius of the spawn range
  * @param int            $delay               Ticks until next spawn
  * @param int            $minSpawnDelay       Minimum random delay to the next spawn
  * @param int            $maxSpawnDelay       Maximum random delay to the next spawn
  * @param int            $maxNearbyEntities   Can override the max number of entities nearby
  * @param int            $requiredPlayerRange Override the activation radius
  *
  * @throws \Exception
  */
 public function __construct($spawnPotentials, $entityID, $spawnData, $spawnCount, $spawnRange, $delay, $minSpawnDelay, $maxSpawnDelay, $maxNearbyEntities, $requiredPlayerRange)
 {
     $this->setBlockIDAndDataFor(Ref::MOB_SPAWNER);
     $this->initEntityData('MobSpawner');
     if ($spawnPotentials) {
         $this->entityData->addChild($spawnPotentials);
     }
     $this->entityData->addChild(\Nbt\Tag::tagString('EntityId', $entityID));
     if ($spawnData) {
         $this->entityData->addChild($spawnData);
     }
     $this->entityData->addChild(\Nbt\Tag::tagShort('SpawnCount', $spawnCount));
     $this->entityData->addChild(\Nbt\Tag::tagShort('SpawnRange', $spawnRange));
     $this->entityData->addChild(\Nbt\Tag::tagShort('Delay', $delay));
     $this->entityData->addChild(\Nbt\Tag::tagShort('MinSpawnDelay', $minSpawnDelay));
     $this->entityData->addChild(\Nbt\Tag::tagShort('MaxSpawnDelay', $maxSpawnDelay));
     $this->entityData->addChild(\Nbt\Tag::tagShort('MaxNearbyEntities', $maxNearbyEntities));
     $this->entityData->addChild(\Nbt\Tag::tagShort('RequiredPlayerRange', $requiredPlayerRange));
 }
 /**
  * Get a brewing stand with the given bottles in place.
  *
  * @param \MME\Stack|null $eastItem       Data for the stack in the east bottle slot
  * @param \MME\Stack|null $southWestItem  Data for the stack in the south west bottle slot
  * @param \MME\Stack|null $northWestItem  Data for the stack in the north west bottle slot
  * @param \MME\Stack|null $ingredientItem Data for the stack in the ingredient slot
  * @param int                            $brewTime       The number of ticks the potions have been brewing for
  * @param string|null                    $customName     Custom name for the container, shows in GUI
  * @param string|null                    $lock           Lock the brewing stand so it can only be opened if the player
  *                                                       is holding an item whose name matches this string
  *
  * @throws \Exception
  */
 public function __construct($eastItem, $southWestItem, $northWestItem, $ingredientItem, $brewTime, $customName = null, $lock = null)
 {
     $this->setBlockIDFor(Ref::BREWING_STAND);
     $data = 0;
     if ($eastItem) {
         $data |= 0b1;
     }
     if ($southWestItem) {
         $data |= 0b10;
     }
     if ($northWestItem) {
         $data |= 0b100;
     }
     $this->setBlockData($data);
     // Yes, this says Cauldron, it's on purpose, it's how it's coded in the game
     $this->initEntityData('Cauldron');
     $this->entityData->addChild(\Nbt\Tag::tagInt('BrewTime', $brewTime));
     $this->setCustomName($customName);
     $this->setLock($lock);
     $this->addItemsForSlots([0 => $eastItem, 1 => $northWestItem, 2 => $southWestItem, 3 => $ingredientItem]);
 }
예제 #12
0
 /**
  * Get the correct section from within the Sections tag (based on Y index).
  *
  * @param int $yRef
  *
  * @return \Nbt\Node
  */
 private function getSection($yRef)
 {
     if (isset($this->sectionsList[$yRef])) {
         return $this->sectionsList[$yRef];
     }
     foreach ($this->sectionsTag->getChildren() as $childNode) {
         if ($childNode->findChildByName('Y')->getValue() == $yRef) {
             $this->prepareSection($childNode);
             $this->sectionsList[$yRef] = $childNode;
             return $childNode;
         }
     }
     // If we didn't find one, we must create one
     // Doesn't need a name, it's part of a list
     $newY = \Nbt\Tag::tagCompound('', [\Nbt\Tag::tagByte('Y', $yRef), \Nbt\Tag::tagByteArray('Blocks', array_fill(0, 4096, 0)), \Nbt\Tag::tagByteArray('Data', array_fill(0, 2048, 0)), \Nbt\Tag::tagByteArray('BlockLight', array_fill(0, 2048, 0)), \Nbt\Tag::tagByteArray('SkyLight', array_fill(0, 2048, 0))]);
     // Add it to the list
     $this->sectionsTag->addChild($newY);
     $this->sectionsList[$yRef] = $newY;
     return $newY;
 }
예제 #13
0
파일: TagTest.php 프로젝트: rickselby/nbt
 public function providerTestTagCompound()
 {
     return [['CompoundTag', [\Nbt\Tag::tagByte('b1', 0x1), \Nbt\Tag::tagString('s2', 'astring')]]];
 }
예제 #14
0
 /**
  * Add the 'tag' compount tag, if it doesn't already exist.
  */
 protected function addTag()
 {
     if (!isset($this->tag)) {
         $this->tag = \Nbt\Tag::tagCompound('tag', []);
         $this->node->addChild($this->tag);
     }
 }