/** * Get a 'redstone rail' (powered, activator, detector), with the given * orientation and active status. * * @param int $blockRef One of the Ref constants * @param int $orientation One of the ORIENT_ class constants (in StraightRail) * @param int $active Either RedstoneRail::INACTIVE or RedstoneRail::ACTIVE * * @throws \Exception */ public function __construct($blockRef, $orientation, $active = self::INACTIVE) { $this->checkBlock($blockRef, Ref::getStartsWith('RAIL_')); $this->checkDataRefValidStartsWith($orientation, 'ORIENT_', 'Invalid orientation for redstone rail'); $this->checkInList($active, [self::INACTIVE, self::ACTIVE], 'Invalid active setting for redstone rail'); $this->setBlockData($orientation | $active); }
/** * Get a slab, positioned either top or bottom of the block. * * @param int $blockRef Block reference from Block\Ref * @param int $position Position of slab; one of the class constants * * @throws \Exception */ public function __construct($blockRef, $position) { $block = $this->checkBlock($blockRef, Ref::getStartsWith('SLAB_')); // Check the orientation is valid $this->checkDataRefValidAll($position, 'Invalid position for slab'); $this->setBlockData($block[1] | $position); }
/** * Get a repeater, with the given orientation and delay ticks. * * @param int $blockRef Which repeater (on/off) * @param int $facing One of the FACING_ class constants * @param int $delay One of the DELAY_ class constants * * @throws \Exception */ public function __construct($blockRef, $facing, $delay) { $this->checkBlock($blockRef, Ref::getStartsWith('REDSTONE_REPEATER_')); $this->checkDataRefValidStartsWith($facing, 'FACING_', 'Invalid facing setting for redstone repeater'); $this->checkDataRefValidStartsWith($delay, 'DELAY_', 'Invalid delay setting for redstone repeater'); $this->setBlockData($facing | $delay); }
/** * Get a button, in the given position. * * @param int $blockRef One of the BUTTON_ blockRefs * @param int $position The position of the button; one of the POSITION_ class constants * @param int $active [Optional] Either Button::INACTIVE or Button::ACTIVE * * @throws \Exception */ public function __construct($blockRef, $position, $active = self::INACTIVE) { $this->checkBlock($blockRef, Ref::getStartsWith('BUTTON_')); $this->checkDataRefValidStartsWith($position, 'ATTACH_', 'Invalid position for button'); $this->checkInList($active, [self::INACTIVE, self::ACTIVE], 'Invalid active setting for button'); $this->setBlockData($position | $active); }
/** * Get stairs, with the given orientation and way up. * * @param int $blockRef Which type of stairs * @param int $orientation One of the ORIENT_ class constants * @param int $wayUp [Optional] Either Stairs::RIGHT_WAY_UP or Stairs::UPSIDE_DOWN */ public function __construct($blockRef, $orientation, $wayUp = self::RIGHT_WAY_UP) { $this->checkBlock($blockRef, Ref::getStartsWith('STAIRS_')); $this->checkDataRefValidStartsWith($orientation, 'ORIENT_', 'Invalid orientation for stairs'); $this->checkInList($wayUp, [self::RIGHT_WAY_UP, self::UPSIDE_DOWN], 'Invalid way up for stairs'); $this->setBlockData($orientation | $wayUp); }
/** * Get the given fence gate, with the given direction and state. * * @param int $blockRef BlockRef for the fence gate * @param int $facing Direction the gate is facing; one of the FACING_ class constants * @param int $open Either FenceGate::CLOSED or FenceGate::OPEN * * @throws \Exception */ public function __construct($blockRef, $facing, $open) { $this->checkBlock($blockRef, Ref::getRegexp('/^FENCE_GATE_/')); $this->checkDataRefValidStartsWith($facing, 'FACING_', 'Invalid facing for fence gate'); $this->checkInList($open, [self::CLOSED, self::OPEN], 'Invalid open for fence gate'); $this->setBlockData($facing | $open); }
private function find_by_name($ref_type, $ref_name) { $data = array(); if (!empty($ref_name)) { $data = RKUtils::model_to_array(Ref::where_ref_type($ref_type)->where('ref_name', 'like', $ref_name . '%')->get(array('ref_name')), 'ref_name'); } return $data; }
/** * Get a trap door, with the given hinge side, top/bottom, and state. * * @param type $blockRef Which trap door * @param type $hinge One of the HINGE_ class constants * @param type $half One of the ON_ class constants * @param type $state One of the DOOR_ class constants * * @throws \Exception */ public function __construct($blockRef, $hinge, $half, $state = self::STATE_CLOSED) { $this->checkBlock($blockRef, Ref::getStartsWith('TRAPDOOR_')); $this->checkDataRefValidStartsWith($hinge, 'HINGE_', 'Invalid hinge setting for trapdoor'); $this->checkDataRefValidStartsWith($half, 'ON_', 'Invalid top/bottom setting for trapdoor'); $this->checkDataRefValidStartsWith($state, 'STATE_', 'Invalid state for trapdoor'); $this->setBlockData($hinge | $half | $state); }
/** * 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 chest, facing in the given direction. * * @param int $blockRef Chest block reference * @param int $direction Direction the chest is facing; one of the class constants * @param \MME\Stack[] $items Items in the chest, with pre-set slots (0-26). * 0 is the top-left corner. * @param string $customName Custom name for the chest, appears in GUI * @param string $lock Lock the chest so it can only be opened if the player * is holding an item whose name matches this string * * @throws \Exception */ public function __construct($blockRef, $direction, $items = [], $customName = null, $lock = null) { $this->checkBlock($blockRef, Ref::getStartsWith('CHEST')); $this->checkDataRefValidAll($direction, 'Invalid direction for chest'); $this->setBlockData($direction); if ($blockRef == Ref::CHEST_ENDER) { $this->initEntityData('EnderChest'); // No more data for Ender Chests. } else { $this->initEntityData('Chest'); $this->addItemStacks($items); $this->setCustomName($customName); $this->setLock($lock); } }
static function import($export_filename, $owner = NULL) { $rep = @user_config($export_filename . '.0'); if (!$rep) { return NULL; } $rep = $rep[0]; $obj = unserialize($rep); if ($owner) { $obj->__owner = ref($owner); } $obj->is_imported = TRUE; Ref::resolve_back_references(); return ref($obj); }
/** * Get half of a door. Certain settings are used on certain halves, but we * ask for them all anyway. Saves two separate functions. * * @param int $blockRef BlockRef for the type of door * @param int $half Which half of the door; one of the HALF_ class consts * @param int $hinge Which side the door is hinged on; one of the HINGE_ class constants * @param int $state Whether the door is open or closed; one of the STATE_ class constants * @param int $facing Which direction the door faces when closed; one of the FACING_ class constants * @param int $power Whether the door is powered or not; one of the POWER_ class constants * * @throws \Exception */ public function __construct($blockRef, $half, $hinge, $state, $facing, $power) { $this->checkBlock($blockRef, Ref::getStartsWith('DOOR_')); $this->checkDataRefValidStartsWith($half, 'HALF_', 'Invalid half for door'); $this->checkDataRefValidStartsWith($hinge, 'HINGE_', 'Invalid hinge for door'); $this->checkDataRefValidStartsWith($state, 'STATE_', 'Invalid state for door'); $this->checkDataRefValidStartsWith($facing, 'FACING_', 'Invalid facing for door'); $this->checkDataRefValidStartsWith($power, 'POWER_', 'Invalid power for door'); switch ($half) { case self::HALF_BOTTOM: $this->setBlockData($half | $facing | $state); break; case self::HALF_TOP: $this->setBlockData($half | $hinge | $power); break; } }
/** * Get a simple block - one with no fancy settings. * * @param int $blockRef Block reference - one of the BlockRef class constants. * * @throws \Exception */ public function __construct($blockRef) { // The 3rd value in the array shows if it's a simple block or not. // Here, we're only dealing with simple blocks. $block = IDs::$list[$blockRef]; if (!isset($block[2])) { $this->setBlockID($block[0]); $this->setBlockData($block[1]); $this->setBlockRef($blockRef); } else { $blockName = Ref::getNameFor($blockRef); if ($blockName !== false) { $exceptionMessage = 'Cannot declare block ' . $blockName . ' in Simple; use ' . $block[2] . ' instead'; } else { $exceptionMessage = 'Unknown block reference'; } throw new \Exception($exceptionMessage, E_ERROR); } }
/** * Get the given pressure plate, active or not. * * @param int $blockRef The appropriate PRESSURE_PLATE_ reference * @param int $active One of the class constants * * @throws \Exception */ public function __construct($blockRef, $active = self::INACTIVE) { $this->checkBlock($blockRef, Ref::getStartsWith('PRESSURE_PLATE_')); $this->checkDataRefValidAll($active, 'Invalid active setting for pressure plate'); $this->setBlockData($active); }
{ } class B { public function __construct(\stdClass $abc, $xyz = 123) { echo $xyz; } } class C { public function __construct(\Jelly $abc1, $xyz1 = 123456) { echo $xyz1; var_dump($abc1); } } $obj = new Ref(); try { //$jelly = $obj->build('Jelly', array(1111, 222)); } catch (Exception $e) { echo $e->getMessage(); } //$obj->build('Jelly');exit; try { //$jelly = $obj->build('B', array(new stdClass)); $jelly = $obj->build('C', array($obj->build('Jelly'))); //$jelly = $obj->build('C'); } catch (Exception $e) { echo $e->getMessage(); }
/** * Get a crop (wheat, carrots, potatoes) at the given growth. * * @param int $blockRef Block reference for the required crop * @param int $growth Growth level, 0-7 */ public function __construct($blockRef, $growth) { $this->checkBlock($blockRef, [Ref::WHEAT, Ref::CARROTS, Ref::POTATOES]); $this->checkValue($growth, 0, 7, 'Invalid growth for crop ' . Ref::getNameFor($blockRef)); }
/** * Flowing water or lava. Set the level - 0 is the highest, to 7 the lowest. * If level is 8, then it's a full block that is falling and only spreads downwards. * * @param int $blockRef Block reference * @param int $level Level of liquid * * @throws \Exception */ public function __construct($blockRef, $level) { $this->checkBlock($blockRef, [Ref::LAVA_FLOWING, Ref::WATER_FLOWING]); $this->checkValue($level, 0, 15, 'Invalid level for ' . Ref::getNameFor($blockRef)); }
/** * Get a stem with the given growth setting (7 = ready to spawn item). * * @param int $blockRef Which stem to place * @param int $growth Growth level, 0-7 * * @throws \Exception */ public function __construct($blockRef, $growth) { $this->checkBlock($blockRef, Ref::getStartsWith('STEM_')); $this->checkValue($growth, 0, 7, 'Invalid growth for stem'); }
public function get_auto_type_name() { return Ref::ref_name_by_id($this->auto_type); }
} // add file pointer to array if (strstr($fp, '.xml') && $fp != 'blank.xml') { $files[$lang][] = $fp; } } } else { echo 'Could not open directory ' . $lang; } } echo 'parsing xml files<br/>'; $names = array(); // create Ref objects for each file foreach ($files as $lang => $array) { foreach ($array as $file) { $ref = new Ref(CONTENTDIR . "api_{$lang}/" . $file); $names[$ref->name] = $ref->name(); } } echo '<table>'; foreach ($names as $name => $file) { echo '<tr>'; echo "<td width=\"200\">{$name}</td>"; echo "<td>{$file}</td>"; echo "<td>" . convertToFilename($name, $lang == 'zh') . "</td>"; echo '</tr>'; } echo '</table>'; /* echo '<table>'; foreach ($names as $name) {
public static function ref_name_by_id($for_id) { $ref = Ref::where_ref_id($for_id)->first(array('ref_name')); return $ref->ref_name; }
/** * Get a colored block. * * @param int $blockRef One of the blocks that can be different colors * @param int $color One of the class constants * * @throws \Exception */ public function __construct($blockRef, $color) { $block = $this->checkBlock($blockRef, [Ref::WOOL, Ref::CARPET, Ref::CLAY_STAINED, Ref::GLASS_STAINED, Ref::GLASS_PANE_STAINED]); $this->checkDataRefValidAll($color, 'Invalid color for ' . Ref::getNameFor($blockRef)); $this->setBlockData($color); }
/** * Get a daylight sensor (regular or inverted) with the given power. * * @param int $blockRef The Daylight sensor type * @param int $power Power level (0-15) * * @throws \Exception */ public function __construct($blockRef, $power) { $this->checkBlock($blockRef, Ref::getStartsWith('DAYLIGHT_SENSOR')); $this->checkValue($power, 0, 15, 'Invalid power for Daylight Sensor'); $this->initEntityData('DLDetector'); }
/** * Get a mushroom block of the given type with the given texture layout. * * @param int $blockRef One of the MUSHROOM_BLOCKs * @param int $texture One of the class constants */ public function __construct($blockRef, $texture) { $this->checkBlock($blockRef, Ref::getStartsWith('MUSHROOM_BLOCK_')); $this->checkDataRefValidAll($texture, 'Invalid texture setting for mushroom block'); $this->setBlockData($texture); }
public function source($name) { $recs = Ref::by_model_name($name); $this->data['source'] = $recs; return $this; }
/** * Get a double slab block. Optionally set the block to use the top texture * on all sides. * * @param int $blockRef Block reference from Block\Ref * @param bool $topTexture [Optional] Use the top texture on all sides? * One of the TEXTURE_ class constants * * @throws \Exception */ public function __construct($blockRef, $topTexture = self::TEXTURE_NORMAL) { $block = $this->checkBlock($blockRef, Ref::getStartsWith('DOUBLE_SLAB')); $this->checkDataRefValidStartsWith($topTexture, 'TEXTURE_', 'Invalid texture setting for double slab'); $this->setBlockData($block[1] | $topTexture); }