Created
April 23, 2014 03:11
-
-
Save PEMapModder/11201658 to your computer and use it in GitHub Desktop.
All of PocketMine, archieved
This file has been truncated, but you can view the full file.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <?php | |
| $web = 'index.php'; | |
| if (in_array('phar', stream_get_wrappers()) && class_exists('Phar', 0)) { | |
| Phar::interceptFileFuncs(); | |
| set_include_path('phar://' . __FILE__ . PATH_SEPARATOR . get_include_path()); | |
| Phar::webPhar(null, $web); | |
| include 'phar://' . __FILE__ . '/' . Extract_Phar::START; | |
| return; | |
| } | |
| if (@(isset($_SERVER['REQUEST_URI']) && isset($_SERVER['REQUEST_METHOD']) && ($_SERVER['REQUEST_METHOD'] == 'GET' || $_SERVER['REQUEST_METHOD'] == 'POST'))) { | |
| Extract_Phar::go(true); | |
| $mimes = array( | |
| 'phps' => 2, | |
| 'c' => 'text/plain', | |
| 'cc' => 'text/plain', | |
| 'cpp' => 'text/plain', | |
| 'c++' => 'text/plain', | |
| 'dtd' => 'text/plain', | |
| 'h' => 'text/plain', | |
| 'log' => 'text/plain', | |
| 'rng' => 'text/plain', | |
| 'txt' => 'text/plain', | |
| 'xsd' => 'text/plain', | |
| 'php' => 1, | |
| 'inc' => 1, | |
| 'avi' => 'video/avi', | |
| 'bmp' => 'image/bmp', | |
| 'css' => 'text/css', | |
| 'gif' => 'image/gif', | |
| 'htm' => 'text/html', | |
| 'html' => 'text/html', | |
| 'htmls' => 'text/html', | |
| 'ico' => 'image/x-ico', | |
| 'jpe' => 'image/jpeg', | |
| 'jpg' => 'image/jpeg', | |
| 'jpeg' => 'image/jpeg', | |
| 'js' => 'application/x-javascript', | |
| 'midi' => 'audio/midi', | |
| 'mid' => 'audio/midi', | |
| 'mod' => 'audio/mod', | |
| 'mov' => 'movie/quicktime', | |
| 'mp3' => 'audio/mp3', | |
| 'mpg' => 'video/mpeg', | |
| 'mpeg' => 'video/mpeg', | |
| 'pdf' => 'application/pdf', | |
| 'png' => 'image/png', | |
| 'swf' => 'application/shockwave-flash', | |
| 'tif' => 'image/tiff', | |
| 'tiff' => 'image/tiff', | |
| 'wav' => 'audio/wav', | |
| 'xbm' => 'image/xbm', | |
| 'xml' => 'text/xml', | |
| ); | |
| header("Cache-Control: no-cache, must-revalidate"); | |
| header("Pragma: no-cache"); | |
| $basename = basename(__FILE__); | |
| if (!strpos($_SERVER['REQUEST_URI'], $basename)) { | |
| chdir(Extract_Phar::$temp); | |
| include $web; | |
| return; | |
| } | |
| $pt = substr($_SERVER['REQUEST_URI'], strpos($_SERVER['REQUEST_URI'], $basename) + strlen($basename)); | |
| if (!$pt || $pt == '/') { | |
| $pt = $web; | |
| header('HTTP/1.1 301 Moved Permanently'); | |
| header('Location: ' . $_SERVER['REQUEST_URI'] . '/' . $pt); | |
| exit; | |
| } | |
| $a = realpath(Extract_Phar::$temp . DIRECTORY_SEPARATOR . $pt); | |
| if (!$a || strlen(dirname($a)) < strlen(Extract_Phar::$temp)) { | |
| header('HTTP/1.0 404 Not Found'); | |
| echo "<html>\n <head>\n <title>File Not Found<title>\n </head>\n <body>\n <h1>404 - File ", $pt, " Not Found</h1>\n </body>\n</html>"; | |
| exit; | |
| } | |
| $b = pathinfo($a); | |
| if (!isset($b['extension'])) { | |
| header('Content-Type: text/plain'); | |
| header('Content-Length: ' . filesize($a)); | |
| readfile($a); | |
| exit; | |
| } | |
| if (isset($mimes[$b['extension']])) { | |
| if ($mimes[$b['extension']] === 1) { | |
| include $a; | |
| exit; | |
| } | |
| if ($mimes[$b['extension']] === 2) { | |
| highlight_file($a); | |
| exit; | |
| } | |
| header('Content-Type: ' .$mimes[$b['extension']]); | |
| header('Content-Length: ' . filesize($a)); | |
| readfile($a); | |
| exit; | |
| } | |
| } | |
| class Extract_Phar | |
| { | |
| static $temp; | |
| static $origdir; | |
| const GZ = 0x1000; | |
| const BZ2 = 0x2000; | |
| const MASK = 0x3000; | |
| const START = 'index.php'; | |
| const LEN = 6685; | |
| static function go($return = false) | |
| { | |
| $fp = fopen(__FILE__, 'rb'); | |
| fseek($fp, self::LEN); | |
| $L = unpack('V', $a = (binary)fread($fp, 4)); | |
| $m = (binary)''; | |
| do { | |
| $read = 8192; | |
| if ($L[1] - strlen($m) < 8192) { | |
| $read = $L[1] - strlen($m); | |
| } | |
| $last = (binary)fread($fp, $read); | |
| $m .= $last; | |
| } while (strlen($last) && strlen($m) < $L[1]); | |
| if (strlen($m) < $L[1]) { | |
| die('ERROR: manifest length read was "' . | |
| strlen($m) .'" should be "' . | |
| $L[1] . '"'); | |
| } | |
| $info = self::_unpack($m); | |
| $f = $info['c']; | |
| if ($f & self::GZ) { | |
| if (!function_exists('gzinflate')) { | |
| die('Error: zlib extension is not enabled -' . | |
| ' gzinflate() function needed for zlib-compressed .phars'); | |
| } | |
| } | |
| if ($f & self::BZ2) { | |
| if (!function_exists('bzdecompress')) { | |
| die('Error: bzip2 extension is not enabled -' . | |
| ' bzdecompress() function needed for bz2-compressed .phars'); | |
| } | |
| } | |
| $temp = self::tmpdir(); | |
| if (!$temp || !is_writable($temp)) { | |
| $sessionpath = session_save_path(); | |
| if (strpos ($sessionpath, ";") !== false) | |
| $sessionpath = substr ($sessionpath, strpos ($sessionpath, ";")+1); | |
| if (!file_exists($sessionpath) || !is_dir($sessionpath)) { | |
| die('Could not locate temporary directory to extract phar'); | |
| } | |
| $temp = $sessionpath; | |
| } | |
| $temp .= '/pharextract/'.basename(__FILE__, '.phar'); | |
| self::$temp = $temp; | |
| self::$origdir = getcwd(); | |
| @mkdir($temp, 0777, true); | |
| $temp = realpath($temp); | |
| if (!file_exists($temp . DIRECTORY_SEPARATOR . md5_file(__FILE__))) { | |
| self::_removeTmpFiles($temp, getcwd()); | |
| @mkdir($temp, 0777, true); | |
| @file_put_contents($temp . '/' . md5_file(__FILE__), ''); | |
| foreach ($info['m'] as $path => $file) { | |
| $a = !file_exists(dirname($temp . '/' . $path)); | |
| @mkdir(dirname($temp . '/' . $path), 0777, true); | |
| clearstatcache(); | |
| if ($path[strlen($path) - 1] == '/') { | |
| @mkdir($temp . '/' . $path, 0777); | |
| } else { | |
| file_put_contents($temp . '/' . $path, self::extractFile($path, $file, $fp)); | |
| @chmod($temp . '/' . $path, 0666); | |
| } | |
| } | |
| } | |
| chdir($temp); | |
| if (!$return) { | |
| include self::START; | |
| } | |
| } | |
| static function tmpdir() | |
| { | |
| if (strpos(PHP_OS, 'WIN') !== false) { | |
| if ($var = getenv('TMP') ? getenv('TMP') : getenv('TEMP')) { | |
| return $var; | |
| } | |
| if (is_dir('/temp') || mkdir('/temp')) { | |
| return realpath('/temp'); | |
| } | |
| return false; | |
| } | |
| if ($var = getenv('TMPDIR')) { | |
| return $var; | |
| } | |
| return realpath('/tmp'); | |
| } | |
| static function _unpack($m) | |
| { | |
| $info = unpack('V', substr($m, 0, 4)); | |
| $l = unpack('V', substr($m, 10, 4)); | |
| $m = substr($m, 14 + $l[1]); | |
| $s = unpack('V', substr($m, 0, 4)); | |
| $o = 0; | |
| $start = 4 + $s[1]; | |
| $ret['c'] = 0; | |
| for ($i = 0; $i < $info[1]; $i++) { | |
| $len = unpack('V', substr($m, $start, 4)); | |
| $start += 4; | |
| $savepath = substr($m, $start, $len[1]); | |
| $start += $len[1]; | |
| $ret['m'][$savepath] = array_values(unpack('Va/Vb/Vc/Vd/Ve/Vf', substr($m, $start, 24))); | |
| $ret['m'][$savepath][3] = sprintf('%u', $ret['m'][$savepath][3] | |
| & 0xffffffff); | |
| $ret['m'][$savepath][7] = $o; | |
| $o += $ret['m'][$savepath][2]; | |
| $start += 24 + $ret['m'][$savepath][5]; | |
| $ret['c'] |= $ret['m'][$savepath][4] & self::MASK; | |
| } | |
| return $ret; | |
| } | |
| static function extractFile($path, $entry, $fp) | |
| { | |
| $data = ''; | |
| $c = $entry[2]; | |
| while ($c) { | |
| if ($c < 8192) { | |
| $data .= @fread($fp, $c); | |
| $c = 0; | |
| } else { | |
| $c -= 8192; | |
| $data .= @fread($fp, 8192); | |
| } | |
| } | |
| if ($entry[4] & self::GZ) { | |
| $data = gzinflate($data); | |
| } elseif ($entry[4] & self::BZ2) { | |
| $data = bzdecompress($data); | |
| } | |
| if (strlen($data) != $entry[0]) { | |
| die("Invalid internal .phar file (size error " . strlen($data) . " != " . | |
| $stat[7] . ")"); | |
| } | |
| if ($entry[3] != sprintf("%u", crc32((binary)$data) & 0xffffffff)) { | |
| die("Invalid internal .phar file (checksum error)"); | |
| } | |
| return $data; | |
| } | |
| static function _removeTmpFiles($temp, $origdir) | |
| { | |
| chdir($temp); | |
| foreach (glob('*') as $f) { | |
| if (file_exists($f)) { | |
| is_dir($f) ? @rmdir($f) : @unlink($f); | |
| if (file_exists($f) && is_dir($f)) { | |
| self::_removeTmpFiles($f, getcwd()); | |
| } | |
| } | |
| } | |
| @rmdir($temp); | |
| clearstatcache(); | |
| chdir($origdir); | |
| } | |
| } | |
| Extract_Phar::go(); | |
| __HALT_COMPILER(); ?> | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| __halt_compiler(); | |
| class EntityOLD extends Position{ | |
| public $age; | |
| public $air; | |
| public $spawntime; | |
| public $dmgcounter; | |
| public $eid; | |
| public $type; | |
| public $name; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $speedX; | |
| public $speedY; | |
| public $speedZ; | |
| public $speed; | |
| public $last = array(0, 0, 0, 0, 0, 0); | |
| public $yaw; | |
| public $pitch; | |
| public $dead; | |
| public $data; | |
| public $class; | |
| public $attach; | |
| public $closed; | |
| public $player; | |
| public $status; | |
| public $fallY; | |
| public $health; | |
| public $fire; | |
| public $crouched; | |
| public $invincible; | |
| public $fallStart; | |
| public $stack; | |
| public $meta; | |
| private $position; | |
| private $tickCounter; | |
| private $speedMeasure = array(0, 0, 0, 0, 0, 0, 0); | |
| private $server; | |
| private $isStatic; | |
| public $level; | |
| public $lastUpdate; | |
| public $check = true; | |
| public $size = 1; | |
| public $inAction = false; | |
| function __construct(Level $level, $eid, $class, $type = 0, $data = array()){ | |
| $this->level = $level; | |
| $this->fallY = false; | |
| $this->fallStart = false; | |
| $this->server = Server::getInstance(); | |
| $this->eid = (int) $eid; | |
| $this->type = (int) $type; | |
| $this->class = (int) $class; | |
| $this->player = false; | |
| $this->attach = false; | |
| $this->data = $data; | |
| $this->status = 0; | |
| $this->health = 20; | |
| $this->dmgcounter = array(0, 0, 0); | |
| $this->air = 300; | |
| $this->fire = 0; | |
| $this->crouched = false; | |
| $this->invincible = false; | |
| $this->lastUpdate = $this->spawntime = microtime(true); | |
| $this->dead = false; | |
| $this->closed = false; | |
| $this->isStatic = false; | |
| $this->name = ""; | |
| $this->tickCounter = 0; | |
| $this->server->query("INSERT OR REPLACE INTO entities (EID, level, type, class, health, hasUpdate) VALUES (".$this->eid.", '".$this->level->getName()."', ".$this->type.", ".$this->class.", ".$this->health.", 0);"); | |
| $this->x = isset($this->data["x"]) ? (float) $this->data["x"]:0; | |
| $this->y = isset($this->data["y"]) ? (float) $this->data["y"]:0; | |
| $this->z = isset($this->data["z"]) ? (float) $this->data["z"]:0; | |
| $this->speedX = isset($this->data["speedX"]) ? (float) $this->data["speedX"]:0; | |
| $this->speedY = isset($this->data["speedY"]) ? (float) $this->data["speedY"]:0; | |
| $this->speedZ = isset($this->data["speedZ"]) ? (float) $this->data["speedZ"]:0; | |
| $this->speed = 0; | |
| $this->yaw = isset($this->data["yaw"]) ? (float) $this->data["yaw"]:0; | |
| $this->pitch = isset($this->data["pitch"]) ? (float) $this->data["pitch"]:0; | |
| $this->position = array("level" => $this->level, "x" => &$this->x, "y" => &$this->y, "z" => &$this->z, "yaw" => &$this->yaw, "pitch" => &$this->pitch); | |
| switch($this->class){ | |
| case ENTITY_PLAYER: | |
| $this->player = $this->data["player"]; | |
| $this->setHealth($this->health, "generic"); | |
| $this->size = 1.2; | |
| break; | |
| case ENTITY_ITEM: | |
| if(isset($data["item"]) and ($data["item"] instanceof Item)){ | |
| $this->meta = $this->data["item"]->getMetadata(); | |
| $this->stack = $this->data["item"]->getCount(); | |
| }else{ | |
| $this->meta = (int) $this->data["meta"]; | |
| $this->stack = (int) $this->data["stack"]; | |
| } | |
| $this->setHealth(5, "generic"); | |
| $this->server->schedule(6010, array($this, "update")); //Despawn | |
| $this->update(); | |
| $this->size = 0.75; | |
| break; | |
| case ENTITY_MOB: | |
| $this->setHealth(isset($this->data["Health"]) ? $this->data["Health"]:10, "generic"); | |
| $this->update(); | |
| //$this->setName((isset($mobs[$this->type]) ? $mobs[$this->type]:$this->type)); | |
| $this->size = 1; | |
| break; | |
| case ENTITY_FALLING: | |
| $this->setHealth(PHP_INT_MAX, "generic"); | |
| $this->update(); | |
| $this->size = 0.98; | |
| break; | |
| case ENTITY_OBJECT: | |
| $this->x = isset($this->data["TileX"]) ? $this->data["TileX"]:$this->x; | |
| $this->y = isset($this->data["TileY"]) ? $this->data["TileY"]:$this->y; | |
| $this->z = isset($this->data["TileZ"]) ? $this->data["TileZ"]:$this->z; | |
| $this->setHealth(1, "generic"); | |
| //$this->setName((isset($objects[$this->type]) ? $objects[$this->type]:$this->type)); | |
| $this->size = 1; | |
| if($this->type === OBJECT_PAINTING){ | |
| $this->isStatic = true; | |
| }elseif($this->type === OBJECT_PRIMEDTNT){ | |
| if(!isset($this->data["fuse"])){ | |
| $this->data["fuse"] = 0; | |
| } | |
| $this->setHealth(10000000, "generic"); | |
| $this->server->schedule(5, array($this, "updateFuse"), array(), true); | |
| $this->update(); | |
| }elseif($this->type === OBJECT_ARROW){ | |
| $this->server->schedule(1210, array($this, "update")); //Despawn | |
| $this->update(); | |
| } | |
| break; | |
| } | |
| $this->updateLast(); | |
| $this->updatePosition(); | |
| if($this->y < 0 and $this->class !== ENTITY_PLAYER){ | |
| $this->close(); | |
| } | |
| } | |
| public function updateFuse(){ | |
| if($this->closed === true){ | |
| return false; | |
| } | |
| if($this->type === OBJECT_PRIMEDTNT){ | |
| $this->updateMetadata(); | |
| if(((microtime(true) - $this->spawntime) * 20) >= $this->data["fuse"]){ | |
| $this->close(); | |
| $explosion = new Explosion($this, $this->data["power"]); | |
| $explosion->explode(); | |
| } | |
| } | |
| } | |
| public function getDrops(){ | |
| if($this->class === ENTITY_PLAYER and $this->player instanceof Player and ($this->player->gamemode & 0x01) === 0){ | |
| $inv = array(); | |
| for($i = 0; $i < Player::SURVIVAL_SLOTS; ++$i){ | |
| $slot = $this->player->getSlot($i); | |
| $this->player->setSlot($i, Item\Item::get(AIR, 0, 0)); | |
| if($slot->getID() !== AIR and $slot->getCount() > 0){ | |
| $inv[] = array($slot->getID(), $slot->getMetadata(), $slot->getCount()); | |
| } | |
| } | |
| for($re = 0; $re < 4; $re++){ | |
| $slot = $this->player->getArmor($re); | |
| $this->player->setArmor($re, Item\Item::get(AIR, 0, 0)); | |
| if($slot->getID() !== AIR and $slot->getCount() > 0){ | |
| $inv[] = array($slot->getID(), $slot->getMetadata(), $slot->getCount()); | |
| } | |
| } | |
| return $inv; | |
| }elseif($this->class === ENTITY_OBJECT){ | |
| switch($this->type){ | |
| case OBJECT_PAINTING: | |
| return array( | |
| array(PAINTING, 0, 1), | |
| ); | |
| } | |
| }elseif($this->class === ENTITY_MOB){ | |
| switch($this->type){ | |
| case MOB_ZOMBIE: | |
| return array( | |
| array(FEATHER, 0, mt_rand(0,2)), | |
| ); | |
| case MOB_SPIDER: | |
| return array( | |
| array(STRING, 0, mt_rand(0,2)), | |
| ); | |
| case MOB_PIGMAN: | |
| return array( | |
| array(COOKED_PORKCHOP, 0, mt_rand(0,2)), | |
| ); | |
| case MOB_CREEPER: | |
| return array( | |
| array(GUNPOWDER, 0, mt_rand(0,2)), | |
| ); | |
| case MOB_SKELETON: | |
| return array( | |
| array(ARROW, 0, mt_rand(0,2)), | |
| array(BONE, 0, mt_rand(0,2)), | |
| ); | |
| case MOB_CHICKEN: | |
| return array( | |
| array(FEATHER, 0, mt_rand(0,2)), | |
| array(($this->fire > 0 ? COOKED_CHICKEN:RAW_CHICKEN), 0, 1), | |
| ); | |
| case MOB_COW: | |
| return array( | |
| array(LEATHER, 0, mt_rand(0,2)), | |
| array(($this->fire > 0 ? STEAK:RAW_BEEF), 0, 1), | |
| ); | |
| case MOB_PIG: | |
| return array( | |
| array(($this->fire > 0 ? COOKED_PORKCHOP:RAW_PORKCHOP), 0, 1), | |
| ); | |
| case MOB_SHEEP: | |
| return array( | |
| array(WOOL, $this->data["Color"] & 0x0F, 1), | |
| ); | |
| } | |
| } | |
| return array(); | |
| } | |
| private function spawnDrops(){ | |
| foreach($this->getDrops() as $drop){ | |
| $this->server->api->entity->drop($this, Item\Item::get($drop[0] & 0xFFFF, $drop[1] & 0xFFFF, $drop[2] & 0xFF), true); | |
| } | |
| } | |
| public function environmentUpdate(){ | |
| $hasUpdate = false; | |
| $time = microtime(true); | |
| if($this->class === ENTITY_PLAYER and ($this->player instanceof Player) and $this->player->spawned === true and $this->player->blocked !== true){ | |
| foreach($this->server->api->entity->getRadius($this, 1.5, ENTITY_ITEM) as $item){ | |
| if($item->closed === false and $item->spawntime > 0 and ($time - $item->spawntime) >= 0.6){ | |
| if((($this->player->gamemode & 0x01) === 1 or $this->player->canAddItem($item->type, $item->meta, $item->stack) === true) and $this->server->api->dhandle("player.pickup", array( | |
| "eid" => $this->player->eid, | |
| "player" => $this->player, | |
| "entity" => $item, | |
| "block" => $item->type, | |
| "meta" => $item->meta, | |
| "target" => $item->eid | |
| )) !== false){ | |
| $item->close(); | |
| //$item->spawntime = 0; | |
| //$this->server->schedule(15, array($item, "close")); | |
| } | |
| } | |
| } | |
| }elseif($this->class === ENTITY_ITEM){ | |
| if(($time - $this->spawntime) >= 300){ | |
| $this->close(); //Despawn timer | |
| return false; | |
| } | |
| }elseif($this->class === ENTITY_OBJECT and $this->type === OBJECT_ARROW){ | |
| if(($time - $this->spawntime) >= 60){ | |
| $this->close(); //Despawn timer | |
| return false; | |
| } | |
| } | |
| if($this->class === ENTITY_MOB){ | |
| switch($this->type){ | |
| case MOB_CHICKEN: | |
| case MOB_SHEEP: | |
| case MOB_COW: | |
| case MOB_PIG: | |
| if($this->server->api->getProperty("spawn-animals") !== true){ | |
| $this->close(); | |
| return false; | |
| } | |
| break; | |
| case MOB_ZOMBIE: | |
| case MOB_CREEPER: | |
| case MOB_PIGMAN: | |
| case MOB_SKELETON: | |
| case MOB_SPIDER: | |
| if($this->server->api->getProperty("spawn-mobs") !== true){ | |
| $this->close(); | |
| return false; | |
| } | |
| break; | |
| } | |
| } | |
| if($this->class !== ENTITY_PLAYER and ($this->y >= 128 or $this->y <= 0)){ | |
| $this->close(); | |
| return false; | |
| } | |
| if($this->dead === true){ | |
| $this->fire = 0; | |
| $this->air = 300; | |
| return false; | |
| } | |
| if($this->y < -16){ | |
| $this->harm(8, "void", true); | |
| $hasUpdate = true; | |
| } | |
| if($this->fire > 0){ | |
| if(($this->fire % 20) === 0){ | |
| $this->harm(1, "burning"); | |
| } | |
| $this->fire -= 10; | |
| if($this->fire <= 0){ | |
| $this->fire = 0; | |
| $this->updateMetadata(); | |
| }else{ | |
| $hasUpdate = true; | |
| } | |
| if(($this->player instanceof Player) and ($this->player->gamemode & 0x01) === 1){ //Remove fire effects in next tick | |
| $this->fire = 1; | |
| } | |
| } | |
| $startX = (int) (round($this->x - 0.5) - 1); | |
| $startY = (int) (round($this->y) - 1); | |
| $startZ = (int) (round($this->z - 0.5) - 1); | |
| $endX = $startX + 2; | |
| $endY = $startY + 2; | |
| $endZ = $startZ + 2; | |
| $waterDone = false; | |
| for($y = $startY; $y <= $endY; ++$y){ | |
| for($x = $startX; $x <= $endX; ++$x){ | |
| for($z = $startZ; $z <= $endZ; ++$z){ | |
| $b = $this->level->getBlock(new Math\Vector3($x, $y, $z)); | |
| switch($b->getID()){ | |
| case WATER: | |
| case STILL_WATER: //Drowing | |
| if($this->fire > 0 and $this->inBlock(new Math\Vector3($x, $y, $z))){ | |
| $this->fire = 0; | |
| $this->updateMetadata(); | |
| } | |
| if($this->air <= 0){ | |
| $this->harm(2, "water"); | |
| $hasUpdate = true; | |
| }elseif($x == ($endX - 1) and $y == $endY and $z == ($endZ - 1) and ($this->class === ENTITY_MOB or $this->class === ENTITY_PLAYER) and $waterDone === false){ | |
| $this->air -= 10; | |
| $waterDone = true; | |
| $this->updateMetadata(); | |
| $hasUpdate = true; | |
| } | |
| break; | |
| case LAVA: //Lava damage | |
| case STILL_LAVA: | |
| if($this->inBlock(new Math\Vector3($x, $y, $z))){ | |
| $this->harm(5, "lava"); | |
| $this->fire = 300; | |
| $this->updateMetadata(); | |
| $hasUpdate = true; | |
| } | |
| break; | |
| case FIRE: //Fire block damage | |
| if($this->inBlock(new Math\Vector3($x, $y, $z))){ | |
| $this->harm(1, "fire"); | |
| $this->fire = 300; | |
| $this->updateMetadata(); | |
| $hasUpdate = true; | |
| } | |
| break; | |
| case CACTUS: //Cactus damage | |
| if($this->touchingBlock(new Math\Vector3($x, $y, $z))){ | |
| $this->harm(1, "cactus"); | |
| $hasUpdate = true; | |
| } | |
| break; | |
| default: | |
| if($this->inBlock(new Math\Vector3($x, $y, $z), 0.7) and $y == $endY and $b->isTransparent === false and ($this->class === ENTITY_MOB or $this->class === ENTITY_PLAYER)){ | |
| $this->harm(1, "suffocation"); //Suffocation | |
| $hasUpdate = true; | |
| }elseif($x == ($endX - 1) and $y == $endY and $z == ($endZ - 1)){ | |
| $this->air = 300; //Breathing | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| return $hasUpdate; | |
| } | |
| public function update(){ | |
| if($this->closed === true){ | |
| return false; | |
| } | |
| $now = microtime(true); | |
| if($this->check === false){ | |
| $this->lastUpdate = $now; | |
| return; | |
| } | |
| $tdiff = $now - $this->lastUpdate; | |
| if($this->tickCounter === 0){ | |
| $this->tickCounter = 1; | |
| $hasUpdate = $this->environmentUpdate(); | |
| }else{ | |
| $hasUpdate = true; | |
| $this->tickCounter = 0; | |
| } | |
| if($this->closed === true){ | |
| return false; | |
| } | |
| if($this->isStatic === false){ | |
| $startX = floor($this->x - 0.5 - $this->size - 1); | |
| //prefix for flying when player on fence | |
| $y = (int) floor($this->y - 1); | |
| $startZ = floor($this->z - 0.5 - $this->size - 1); | |
| $endX = ceil($this->x - 0.5 + $this->size + 1); | |
| $endZ = ceil($this->z - 0.5 + $this->size + 1); | |
| $support = false; | |
| $isFlying = true; | |
| for($z = $startZ; $z <= $endZ; ++$z){ | |
| for($x = $startX; $x <= $endX; ++$x){ | |
| $v = new Math\Vector3($x, $y, $z); | |
| if($this->isSupport($v, $this->size)){ | |
| $b = $this->level->getBlock($v); | |
| if($b->isSolid === true){ | |
| $support = true; | |
| $isFlying = false; | |
| break; | |
| }elseif(($b instanceof LiquidBlock) or $b->getID() === COBWEB or $b->getID() === LADDER or $b->getID() === FENCE or $b->getID() === STONE_WALL){ | |
| $isFlying = false; | |
| } | |
| } | |
| } | |
| if($support === true){ | |
| break; | |
| } | |
| } | |
| if($this->class !== ENTITY_PLAYER){ | |
| $update = false; | |
| if(($this->class !== ENTITY_OBJECT and $this->type !== OBJECT_PRIMEDTNT) or $support === false){ | |
| $drag = 0.4 * $tdiff; | |
| if($this->speedX != 0){ | |
| $this->speedX -= $this->speedX * $drag; | |
| $this->x += $this->speedX * $tdiff; | |
| $update = true; | |
| } | |
| if($this->speedZ != 0){ | |
| $this->speedZ -= $this->speedZ * $drag; | |
| $this->z += $this->speedZ * $tdiff; | |
| $update = true; | |
| } | |
| if($this->speedY != 0){ | |
| $this->speedY -= $this->speedY * $drag; | |
| $ny = $this->y + $this->speedY * $tdiff; | |
| if($ny <= $this->y){ | |
| $x = (int) ($this->x - 0.5); | |
| $z = (int) ($this->z - 0.5); | |
| $lim = (int) floor($ny); | |
| for($y = (int) ceil($this->y) - 1; $y >= $lim; --$y){ | |
| if($this->level->getBlock(new Math\Vector3($x, $y, $z))->isSolid === true){ | |
| $ny = $y + 1; | |
| $this->speedY = 0; | |
| $support = true; | |
| if($this->class === ENTITY_FALLING){ | |
| $this->y = $ny; | |
| $fall = $this->level->getBlock(new Math\Vector3(intval($this->x - 0.5), intval(ceil($this->y)), intval($this->z - 0.5))); | |
| $down = $this->level->getBlock(new Math\Vector3(intval($this->x - 0.5), intval(ceil($this->y) - 1), intval($this->z - 0.5))); | |
| if($fall->isFullBlock === false or $down->isFullBlock === false){ | |
| $this->server->api->entity->drop($this, Item\Item::get($this->data["Tile"] & 0xFFFF, 0, 1), true); | |
| }else{ | |
| $this->level->setBlock($fall, Block\Block::get($this->data["Tile"]), true, false, true); | |
| } | |
| $this->server->api->handle("entity.motion", $this); | |
| $this->close(); | |
| return false; | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| $this->y = $ny; | |
| $update = true; | |
| } | |
| } | |
| if($support === false){ | |
| $this->speedY -= ($this->class === ENTITY_FALLING ? 18:32) * $tdiff; | |
| $update = true; | |
| }else{ | |
| $this->speedX = 0; | |
| $this->speedY = 0; | |
| $this->speedZ = 0; | |
| $this->server->api->handle("entity.move", $this); | |
| if(($this->class === ENTITY_OBJECT and $this->type !== OBJECT_PRIMEDTNT) or $this->speedY <= 0.1){ | |
| $update = false; | |
| $this->server->api->handle("entity.motion", $this); | |
| } | |
| } | |
| if($update === true){ | |
| $hasUpdate = true; | |
| $this->server->api->handle("entity.motion", $this); | |
| } | |
| }elseif($this->player instanceof Player){ | |
| if($isFlying === true and ($this->player->gamemode & 0x01) === 0x00){ | |
| if($this->fallY === false or $this->fallStart === false){ | |
| $this->fallY = $y; | |
| $this->fallStart = microtime(true); | |
| }elseif($this->class === ENTITY_PLAYER and ($this->fallStart + 5) < microtime(true)){ | |
| if($this->server->api->getProperty("allow-flight") !== true and $this->server->handle("player.flying", $this->player) !== true){ | |
| $this->player->close("flying"); | |
| return; | |
| } | |
| }elseif($y > $this->fallY){ | |
| $this->fallY = $y; | |
| } | |
| }elseif($this->fallY !== false){ //Fall damage! | |
| if($y < $this->fallY){ | |
| $d = $this->level->getBlock(new Math\Vector3($this->x, $y + 1, $this->z)); | |
| $d2 = $this->level->getBlock(new Math\Vector3($this->x, $y + 2, $this->z)); | |
| $dmg = ($this->fallY - $y) - 3; | |
| if($dmg > 0 and !($d instanceof LiquidBlock) and $d->getID() !== LADDER and $d->getID() !== COBWEB and !($d2 instanceof LiquidBlock) and $d2->getID() !== LADDER and $d2->getID() !== COBWEB){ | |
| $this->harm($dmg, "fall"); | |
| } | |
| } | |
| $this->fallY = false; | |
| $this->fallStart = false; | |
| } | |
| $this->calculateVelocity(); | |
| if($this->speed <= 9 or ($this->speed <= 20 and ($this->player->gamemode & 0x01) === 0x01)){ | |
| $this->player->lastCorrect = new Math\Vector3($this->last[0], $this->last[1], $this->last[2]); | |
| } | |
| } | |
| } | |
| if($this->class !== ENTITY_PLAYER){ | |
| $this->updateMovement(); | |
| if($hasUpdate === true){ | |
| $this->server->schedule(5, array($this, "update")); | |
| } | |
| } | |
| $this->lastUpdate = $now; | |
| } | |
| public function updateMovement(){ | |
| if($this->closed === true){ | |
| return false; | |
| } | |
| $now = microtime(true); | |
| if($this->isStatic === false and ($this->last[0] != $this->x or $this->last[1] != $this->y or $this->last[2] != $this->z or $this->last[3] != $this->yaw or $this->last[4] != $this->pitch)){ | |
| if($this->class === ENTITY_PLAYER or ($this->last[5] + 8) < $now){ | |
| if($this->server->api->handle("entity.move", $this) === false){ | |
| if($this->class === ENTITY_PLAYER and $this->player instanceof Player){ | |
| $this->player->teleport(new Math\Vector3($this->last[0], $this->last[1], $this->last[2]), $this->last[3], $this->last[4]); | |
| }else{ | |
| $this->setPosition(new Math\Vector3($this->last[0], $this->last[1], $this->last[2]), $this->last[3], $this->last[4]); | |
| } | |
| }else{ | |
| $this->updateLast(); | |
| $players = $this->level->getPlayers(); | |
| if($this->player instanceof Player){ | |
| unset($players[$this->player->CID]); | |
| $pk = new MovePlayerPacket; | |
| $pk->eid = $this->eid; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = $this->yaw; | |
| $pk->pitch = $this->pitch; | |
| $pk->bodyYaw = $this->yaw; | |
| Player::broadcastPacket($players, $pk); | |
| }else{ | |
| $pk = new MoveEntityPacket_PosRot; | |
| $pk->eid = $this->eid; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = $this->yaw; | |
| $pk->pitch = $this->pitch; | |
| Player::broadcastPacket($players, $pk); | |
| } | |
| } | |
| }else{ | |
| $this->updatePosition(); | |
| } | |
| } | |
| $this->lastUpdate = $now; | |
| } | |
| public function getDirection(){ | |
| $rotation = ($this->yaw - 90) % 360; | |
| if($rotation < 0) { | |
| $rotation += 360.0; | |
| } | |
| if((0 <= $rotation and $rotation < 45) or (315 <= $rotation and $rotation < 360)){ | |
| return 2; //North | |
| }elseif(45 <= $rotation and $rotation < 135){ | |
| return 3; //East | |
| }elseif(135 <= $rotation and $rotation < 225){ | |
| return 0; //South | |
| }elseif(225 <= $rotation and $rotation < 315){ | |
| return 1; //West | |
| }else{ | |
| return null; | |
| } | |
| } | |
| public function getMetadata(){ | |
| $flags = 0; | |
| $flags |= $this->fire > 0 ? 1:0; | |
| $flags |= ($this->crouched === true ? 0b10:0) << 1; | |
| $flags |= ($this->inAction === true ? 0b10000:0); | |
| $d = array( | |
| 0 => array("type" => 0, "value" => $flags), | |
| 1 => array("type" => 1, "value" => $this->air), | |
| 16 => array("type" => 0, "value" => 0), | |
| 17 => array("type" => 6, "value" => array(0, 0, 0)), | |
| ); | |
| if($this->class === ENTITY_MOB and $this->type === MOB_SHEEP){ | |
| if(!isset($this->data["Sheared"])){ | |
| $this->data["Sheared"] = 0; | |
| $this->data["Color"] = mt_rand(0,15); | |
| } | |
| $d[16]["value"] = (($this->data["Sheared"] == 1 ? 1:0) << 4) | ($this->data["Color"] & 0x0F); | |
| }elseif($this->type === OBJECT_PRIMEDTNT){ | |
| $d[16]["value"] = (int) max(0, $this->data["fuse"] - (microtime(true) - $this->spawntime) * 20); | |
| }elseif($this->class === ENTITY_PLAYER){ | |
| if($this->player->isSleeping !== false){ | |
| $d[16]["value"] = 2; | |
| $d[17]["value"] = array($this->player->isSleeping->x, $this->player->isSleeping->y, $this->player->isSleeping->z); | |
| } | |
| } | |
| return $d; | |
| } | |
| public function updateMetadata(){ | |
| $this->server->api->dhandle("entity.metadata", $this); | |
| } | |
| public function spawn($player){ | |
| if(!($player instanceof Player)){ | |
| $player = Player::get($player); | |
| } | |
| if($player->eid === $this->eid or $this->closed !== false or ($player->level !== $this->level and $this->class !== ENTITY_PLAYER)){ | |
| return false; | |
| } | |
| switch($this->class){ | |
| case ENTITY_PLAYER: | |
| if(!($this->player instanceof Player) or $this->player->connected !== true or $this->player->spawned === false){ | |
| return false; | |
| } | |
| $pk = new AddPlayerPacket; | |
| $pk->clientID = 0; //$this->player->clientID; | |
| $pk->username = $this->player->username; | |
| $pk->eid = $this->eid; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = 0; | |
| $pk->pitch = 0; | |
| $pk->unknown1 = 0; | |
| $pk->unknown2 = 0; | |
| $pk->metadata = $this->getMetadata(); | |
| $player->dataPacket($pk); | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->eid; | |
| $pk->speedX = $this->speedX; | |
| $pk->speedY = $this->speedY; | |
| $pk->speedZ = $this->speedZ; | |
| $player->dataPacket($pk); | |
| $pk = new PlayerEquipmentPacket; | |
| $pk->eid = $this->eid; | |
| $pk->item = $this->player->getSlot($this->player->slot)->getID(); | |
| $pk->meta = $this->player->getSlot($this->player->slot)->getMetadata(); | |
| $pk->slot = 0; | |
| $player->dataPacket($pk); | |
| $this->player->sendArmor($player); | |
| break; | |
| case ENTITY_ITEM: | |
| $pk = new AddItemEntityPacket; | |
| $pk->eid = $this->eid; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = $this->yaw; | |
| $pk->pitch = $this->pitch; | |
| $pk->roll = 0; | |
| $pk->item = Item\Item::get($this->type, $this->meta, $this->stack); | |
| $pk->metadata = $this->getMetadata(); | |
| $player->dataPacket($pk); | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->eid; | |
| $pk->speedX = $this->speedX; | |
| $pk->speedY = $this->speedY; | |
| $pk->speedZ = $this->speedZ; | |
| $player->dataPacket($pk); | |
| break; | |
| case ENTITY_MOB: | |
| $pk = new AddMobPacket; | |
| $pk->eid = $this->eid; | |
| $pk->type = $this->type; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = $this->yaw; | |
| $pk->pitch = $this->pitch; | |
| $pk->metadata = $this->getMetadata(); | |
| $player->dataPacket($pk); | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->eid; | |
| $pk->speedX = $this->speedX; | |
| $pk->speedY = $this->speedY; | |
| $pk->speedZ = $this->speedZ; | |
| $player->dataPacket($pk); | |
| break; | |
| case ENTITY_OBJECT: | |
| if($this->type === OBJECT_PAINTING){ | |
| $pk = new AddPaintingPacket; | |
| $pk->eid = $this->eid; | |
| $pk->x = (int) $this->x; | |
| $pk->y = (int) $this->y; | |
| $pk->z = (int) $this->z; | |
| $pk->direction = $this->getDirection(); | |
| $pk->title = $this->data["Motive"]; | |
| $player->dataPacket($pk); | |
| }elseif($this->type === OBJECT_PRIMEDTNT){ | |
| $pk = new AddEntityPacket; | |
| $pk->eid = $this->eid; | |
| $pk->type = $this->type; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->did = 0; | |
| $player->dataPacket($pk); | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->eid; | |
| $pk->speedX = $this->speedX; | |
| $pk->speedY = $this->speedY; | |
| $pk->speedZ = $this->speedZ; | |
| $player->dataPacket($pk); | |
| }elseif($this->type === OBJECT_ARROW){ | |
| $pk = new AddEntityPacket; | |
| $pk->eid = $this->eid; | |
| $pk->type = $this->type; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->did = 0; | |
| $player->dataPacket($pk); | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->eid; | |
| $pk->speedX = $this->speedX; | |
| $pk->speedY = $this->speedY; | |
| $pk->speedZ = $this->speedZ; | |
| $player->dataPacket($pk); | |
| } | |
| break; | |
| case ENTITY_FALLING: | |
| $pk = new AddEntityPacket; | |
| $pk->eid = $this->eid; | |
| $pk->type = $this->type; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->did = -$this->data["Tile"]; | |
| $player->dataPacket($pk); | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->eid; | |
| $pk->speedX = $this->speedX; | |
| $pk->speedY = $this->speedY; | |
| $pk->speedZ = $this->speedZ; | |
| $player->dataPacket($pk); | |
| break; | |
| } | |
| } | |
| public function close(){ | |
| if($this->closed === false){ | |
| $this->closed = true; | |
| $this->server->api->entity->remove($this->eid); | |
| } | |
| } | |
| public function __destruct(){ | |
| $this->close(); | |
| } | |
| public function getEID(){ | |
| return $this->eid; | |
| } | |
| public function getName(){ | |
| return $this->name; | |
| } | |
| public function setName($name){ | |
| $this->name = $name; | |
| $this->server->query("UPDATE entities SET name = '".str_replace("'", "", $this->name)."' WHERE EID = ".$this->eid.";"); | |
| } | |
| public function look($pos2){ | |
| $pos = $this->getPosition(); | |
| $angle = Utils::angle3D($pos2, $pos); | |
| $this->yaw = $angle["yaw"]; | |
| $this->pitch = $angle["pitch"]; | |
| $this->server->query("UPDATE entities SET pitch = ".$this->pitch.", yaw = ".$this->yaw." WHERE EID = ".$this->eid.";"); | |
| } | |
| public function move(Math\Vector3 $pos, $yaw = 0, $pitch = 0){ | |
| $this->x += $pos->x; | |
| $this->y += $pos->y; | |
| $this->z += $pos->z; | |
| $this->yaw += $yaw; | |
| $this->yaw %= 360; | |
| $this->pitch += $pitch; | |
| $this->pitch %= 90; | |
| $this->server->query("UPDATE entities SET x = ".$this->x.", y = ".$this->y.", z = ".$this->z.", pitch = ".$this->pitch.", yaw = ".$this->yaw." WHERE EID = ".$this->eid.";"); | |
| } | |
| public function updatePosition(){ | |
| $this->server->query("UPDATE entities SET level = '".$this->level->getName()."', x = ".$this->x.", y = ".$this->y.", z = ".$this->z.", pitch = ".$this->pitch.", yaw = ".$this->yaw." WHERE EID = ".$this->eid.";"); | |
| } | |
| public function setPosition(Math\Vector3 $pos, $yaw = false, $pitch = false){ | |
| if($pos instanceof Position and $pos->level instanceof Level and $this->level !== $pos->level){ | |
| $this->level = $pos->level; | |
| $this->server->preparedSQL->entity->setLevel->reset(); | |
| $this->server->preparedSQL->entity->setLevel->clear(); | |
| $this->server->preparedSQL->entity->setLevel->bindValue(":level", $this->level->getName(), SQLITE3_TEXT); | |
| $this->server->preparedSQL->entity->setLevel->bindValue(":eid", $this->eid, SQLITE3_INTEGER); | |
| $this->server->preparedSQL->entity->setLevel->execute(); | |
| } | |
| $this->x = $pos->x; | |
| $this->y = $pos->y; | |
| $this->z = $pos->z; | |
| if($yaw !== false){ | |
| $this->yaw = $yaw; | |
| } | |
| if($pitch !== false){ | |
| $this->pitch = $pitch; | |
| } | |
| $this->server->preparedSQL->entity->setPosition->reset(); | |
| $this->server->preparedSQL->entity->setPosition->clear(); | |
| $this->server->preparedSQL->entity->setPosition->bindValue(":x", $this->x, SQLITE3_TEXT); | |
| $this->server->preparedSQL->entity->setPosition->bindValue(":y", $this->y, SQLITE3_TEXT); | |
| $this->server->preparedSQL->entity->setPosition->bindValue(":z", $this->z, SQLITE3_TEXT); | |
| $this->server->preparedSQL->entity->setPosition->bindValue(":pitch", $this->pitch, SQLITE3_TEXT); | |
| $this->server->preparedSQL->entity->setPosition->bindValue(":yaw", $this->yaw, SQLITE3_TEXT); | |
| $this->server->preparedSQL->entity->setPosition->bindValue(":eid", $this->eid, SQLITE3_INTEGER); | |
| $this->server->preparedSQL->entity->setPosition->execute(); | |
| } | |
| public function inBlock(Math\Vector3 $block, $radius = 0.8){ | |
| $me = new Math\Vector3($this->x - 0.5, $this->y, $this->z - 0.5); | |
| if(($block->y == ((int) $this->y) or $block->y == (((int) $this->y) + 1)) and $block->maxPlainDistance($me) < $radius){ | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function touchingBlock(Math\Vector3 $block, $radius = 0.9){ | |
| $me = new Math\Vector3($this->x - 0.5, $this->y, $this->z - 0.5); | |
| if(($block->y == (((int) $this->y) - 1) or $block->y == ((int) $this->y) or $block->y == (((int) $this->y) + 1)) and $block->maxPlainDistance($me) < $radius){ | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function isSupport(Math\Vector3 $pos, $radius = 1){ | |
| $me = new Vector2($this->x - 0.5, $this->z - 0.5); | |
| $diff = $this->y - $pos->y; | |
| if($me->distance(new Vector2($pos->x, $pos->z)) < $radius and $diff > -0.7 and $diff < 1.6){ | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function resetSpeed(){ | |
| $this->speedMeasure = array(0, 0, 0, 0, 0, 0, 0); | |
| } | |
| public function getSpeed(){ | |
| return $this->speed; | |
| } | |
| public function getSpeedMeasure(){ | |
| return array_sum($this->speedMeasure) / count($this->speedMeasure); | |
| } | |
| public function calculateVelocity(){ | |
| $diffTime = max(0.05, abs(microtime(true) - $this->last[5])); | |
| $origin = new Vector2($this->last[0], $this->last[2]); | |
| $final = new Vector2($this->x, $this->z); | |
| $speedX = ($this->last[0] - $this->x) / $diffTime; | |
| $speedY = ($this->last[1] - $this->y) / $diffTime; | |
| $speedZ = ($this->last[2] - $this->z) / $diffTime; | |
| if($this->speedX != $speedX or $this->speedY != $speedY or $this->speedZ != $speedZ){ | |
| $this->speedX = $speedX; | |
| $this->speedY = $speedY; | |
| $this->speedZ = $speedZ; | |
| $this->server->api->handle("entity.motion", $this); | |
| } | |
| $this->speed = $origin->distance($final) / $diffTime; | |
| unset($this->speedMeasure[key($this->speedMeasure)]); | |
| $this->speedMeasure[] = $this->speed; | |
| } | |
| public function updateLast(){ | |
| $this->last[0] = $this->x; | |
| $this->last[1] = $this->y; | |
| $this->last[2] = $this->z; | |
| $this->last[3] = $this->yaw; | |
| $this->last[4] = $this->pitch; | |
| $this->last[5] = microtime(true); | |
| } | |
| public function getPosition($round = false){ | |
| return !isset($this->position) ? false:($round === true ? array_map("floor", $this->position):$this->position); | |
| } | |
| public function harm($dmg, $cause = "generic", $force = false){ | |
| return $this->setHealth(max(-128, $this->getHealth() - ((int) $dmg)), $cause, $force); | |
| } | |
| public function heal($health, $cause = "generic"){ | |
| return $this->setHealth(min(20, $this->getHealth() + ((int) $health)), $cause); | |
| } | |
| public function setHealth($health, $cause = "generic", $force = false){ | |
| $health = (int) $health; | |
| $harm = false; | |
| if($health < $this->health){ | |
| $harm = true; | |
| $dmg = $this->health - $health; | |
| if($this->class === ENTITY_PLAYER and ($this->player instanceof Player)){ | |
| $points = 0; | |
| $values = array( | |
| LEATHER_CAP => 1, | |
| LEATHER_TUNIC => 3, | |
| LEATHER_PANTS => 2, | |
| LEATHER_BOOTS => 1, | |
| CHAIN_HELMET => 1, | |
| CHAIN_CHESTPLATE => 5, | |
| CHAIN_LEGGINGS => 4, | |
| CHAIN_BOOTS => 1, | |
| GOLD_HELMET => 1, | |
| GOLD_CHESTPLATE => 5, | |
| GOLD_LEGGINGS => 3, | |
| GOLD_BOOTS => 1, | |
| IRON_HELMET => 2, | |
| IRON_CHESTPLATE => 6, | |
| IRON_LEGGINGS => 5, | |
| IRON_BOOTS => 2, | |
| DIAMOND_HELMET => 3, | |
| DIAMOND_CHESTPLATE => 8, | |
| DIAMOND_LEGGINGS => 6, | |
| DIAMOND_BOOTS => 3, | |
| ); | |
| foreach($this->player->armor as $part){ | |
| if($part instanceof Item and isset($values[$part->getID()])){ | |
| $points += $values[$part->getID()]; | |
| } | |
| } | |
| $dmg = (int) ($dmg - ($dmg * $points * 0.04)); | |
| $health = $this->health - $dmg; | |
| } | |
| if(($this->class !== ENTITY_PLAYER or (($this->player instanceof Player) and (($this->player->gamemode & 0x01) === 0x00 or $force === true))) and ($this->dmgcounter[0] < microtime(true) or $this->dmgcounter[1] < $dmg) and !$this->dead){ | |
| $this->dmgcounter[0] = microtime(true) + 0.5; | |
| $this->dmgcounter[1] = $dmg; | |
| }else{ | |
| return false; //Entity inmunity | |
| } | |
| }elseif($health === $this->health and !$this->dead){ | |
| return false; | |
| } | |
| if($this->server->api->dhandle("entity.health.change", array("entity" => $this, "eid" => $this->eid, "health" => $health, "cause" => $cause)) !== false or $force === true){ | |
| $this->health = min(127, max(-127, $health)); | |
| $this->server->query("UPDATE entities SET health = ".$this->health." WHERE EID = ".$this->eid.";"); | |
| if($harm === true){ | |
| $this->server->api->dhandle("entity.event", array("entity" => $this, "event" => 2)); //Ouch! sound | |
| } | |
| if($this->player instanceof Player){ | |
| $pk = new SetHealthPacket; | |
| $pk->health = $this->health; | |
| $this->player->dataPacket($pk); | |
| } | |
| if($this->health <= 0 and $this->dead === false){ | |
| $this->spawnDrops(); | |
| $this->air = 300; | |
| $this->fire = 0; | |
| $this->crouched = false; | |
| $this->fallY = false; | |
| $this->fallStart = false; | |
| $this->updateMetadata(); | |
| $this->dead = true; | |
| if($this->player instanceof Player){ | |
| $pk = new MoveEntityPacket_PosRot; | |
| $pk->eid = $this->eid; | |
| $pk->x = -256; | |
| $pk->y = 128; | |
| $pk->z = -256; | |
| $pk->yaw = 0; | |
| $pk->pitch = 0; | |
| Player::broadcastPacket($this->level->players, $pk); | |
| }else{ | |
| $this->server->api->dhandle("entity.event", array("entity" => $this, "event" => 3)); //Entity dead | |
| } | |
| if($this->player instanceof Player){ | |
| $this->player->blocked = true; | |
| $this->server->api->dhandle("player.death", array("player" => $this->player, "cause" => $cause)); | |
| if($this->server->api->getProperty("hardcore") == 1){ | |
| $this->server->api->ban->ban($this->player->username); | |
| } | |
| }else{ | |
| $this->close(); | |
| } | |
| }elseif($this->health > 0){ | |
| $this->dead = false; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getHealth(){ | |
| return $this->health; | |
| } | |
| public function __toString(){ | |
| return "Entity(x={$this->x},y={$this->y},z={$this->z},level=".$this->level->getName().",class={$this->class},type={$this->type})"; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * | |
| * | |
| */ | |
| namespace pocketmine; | |
| use pocketmine\utils\TextFormat; | |
| /** | |
| * Handles the achievement list and a bit more | |
| */ | |
| abstract class Achievement{ | |
| /** | |
| * @var array[] | |
| */ | |
| public static $list = array( | |
| /*"openInventory" => array( | |
| "name" => "Taking Inventory", | |
| "requires" => array(), | |
| ),*/ | |
| "mineWood" => array( | |
| "name" => "Getting Wood", | |
| "requires" => array( //"openInventory", | |
| ), | |
| ), | |
| "buildWorkBench" => array( | |
| "name" => "Benchmarking", | |
| "requires" => array( | |
| "mineWood", | |
| ), | |
| ), | |
| "buildPickaxe" => array( | |
| "name" => "Time to Mine!", | |
| "requires" => array( | |
| "buildWorkBench", | |
| ), | |
| ), | |
| "buildFurnace" => array( | |
| "name" => "Hot Topic", | |
| "requires" => array( | |
| "buildPickaxe", | |
| ), | |
| ), | |
| "acquireIron" => array( | |
| "name" => "Acquire hardware", | |
| "requires" => array( | |
| "buildFurnace", | |
| ), | |
| ), | |
| "buildHoe" => array( | |
| "name" => "Time to Farm!", | |
| "requires" => array( | |
| "buildWorkBench", | |
| ), | |
| ), | |
| "makeBread" => array( | |
| "name" => "Bake Bread", | |
| "requires" => array( | |
| "buildHoe", | |
| ), | |
| ), | |
| "bakeCake" => array( | |
| "name" => "The Lie", | |
| "requires" => array( | |
| "buildHoe", | |
| ), | |
| ), | |
| "buildBetterPickaxe" => array( | |
| "name" => "Getting an Upgrade", | |
| "requires" => array( | |
| "buildPickaxe", | |
| ), | |
| ), | |
| "buildSword" => array( | |
| "name" => "Time to Strike!", | |
| "requires" => array( | |
| "buildWorkBench", | |
| ), | |
| ), | |
| "diamonds" => array( | |
| "name" => "DIAMONDS!", | |
| "requires" => array( | |
| "acquireIron", | |
| ), | |
| ), | |
| ); | |
| public static function broadcast(Player $player, $achievementId){ | |
| if(isset(Achievement::$list[$achievementId])){ | |
| if(Server::getInstance()->getConfigString("announce-player-achievements", true) === true){ | |
| Server::getInstance()->broadcastMessage($player->getDisplayName() . " has just earned the achievement " . TextFormat::GREEN . Achievement::$list[$achievementId]["name"]); | |
| }else{ | |
| $player->sendMessage("You have just earned the achievement " . TextFormat::GREEN . Achievement::$list[$achievementId]["name"]); | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public static function add($achievementId, $achievementName, array $requires = array()){ | |
| if(!isset(Achievement::$list[$achievementId])){ | |
| Achievement::$list[$achievementId] = array( | |
| "name" => $achievementName, | |
| "requires" => $requires, | |
| ); | |
| return true; | |
| } | |
| return false; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| /** | |
| * Air block | |
| */ | |
| class Air extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::AIR, 0, "Air"); | |
| $this->isActivable = false; | |
| $this->breakable = false; | |
| $this->isFlowable = true; | |
| $this->isTransparent = true; | |
| $this->isReplaceable = true; | |
| $this->isPlaceable = false; | |
| $this->hasPhysics = false; | |
| $this->isSolid = false; | |
| $this->isFullBlock = true; | |
| $this->hardness = 0; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\network\protocol\ChatPacket; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Bed extends Transparent{ | |
| public function __construct($type = 0){ | |
| parent::__construct(self::BED_BLOCK, $type, "Bed Block"); | |
| $this->isActivable = true; | |
| $this->isFullBlock = false; | |
| $this->hardness = 1; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($player instanceof Player and Server::getInstance()->api->time->getPhase($this->level) !== "night"){ | |
| $pk = new ChatPacket; | |
| $pk->message = "You can only sleep at night"; | |
| $player->dataPacket($pk); | |
| return true; | |
| } | |
| $blockNorth = $this->getSide(2); //Gets the blocks around them | |
| $blockSouth = $this->getSide(3); | |
| $blockEast = $this->getSide(5); | |
| $blockWest = $this->getSide(4); | |
| if(($this->meta & 0x08) === 0x08){ //This is the Top part of bed | |
| $b = $this; | |
| }else{ //Bottom Part of Bed | |
| if($blockNorth->getID() === $this->id and ($blockNorth->meta & 0x08) === 0x08){ | |
| $b = $blockNorth; | |
| }elseif($blockSouth->getID() === $this->id and ($blockSouth->meta & 0x08) === 0x08){ | |
| $b = $blockSouth; | |
| }elseif($blockEast->getID() === $this->id and ($blockEast->meta & 0x08) === 0x08){ | |
| $b = $blockEast; | |
| }elseif($blockWest->getID() === $this->id and ($blockWest->meta & 0x08) === 0x08){ | |
| $b = $blockWest; | |
| }elseif($player instanceof Player){ | |
| $pk = new ChatPacket; | |
| $pk->message = "This bed is incomplete"; | |
| $player->dataPacket($pk); | |
| return true; | |
| } | |
| } | |
| if($player instanceof Player and $player->sleepOn($b) === false){ | |
| $pk = new ChatPacket; | |
| $pk->message = "This bed is occupied"; | |
| $player->dataPacket($pk); | |
| } | |
| return true; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->isTransparent === false){ | |
| $faces = array( | |
| 0 => 3, | |
| 1 => 4, | |
| 2 => 2, | |
| 3 => 5, | |
| ); | |
| $d = $player instanceof Player ? $player->getDirection() : 0; | |
| $next = $this->getSide($faces[(($d + 3) % 4)]); | |
| $downNext = $this->getSide(0); | |
| if($next->isReplaceable === true and $downNext->isTransparent === false){ | |
| $meta = (($d + 3) % 4) & 0x03; | |
| $this->level->setBlock($block, Block::get($this->id, $meta), true, false, true); | |
| $this->level->setBlock($next, Block::get($this->id, $meta | 0x08), true, false, true); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| public function onBreak(Item $item){ | |
| $blockNorth = $this->getSide(2); //Gets the blocks around them | |
| $blockSouth = $this->getSide(3); | |
| $blockEast = $this->getSide(5); | |
| $blockWest = $this->getSide(4); | |
| if(($this->meta & 0x08) === 0x08){ //This is the Top part of bed | |
| if($blockNorth->getID() === $this->id and $blockNorth->meta !== 0x08){ //Checks if the block ID and meta are right | |
| $this->level->setBlock($blockNorth, new Air(), true, false, true); | |
| }elseif($blockSouth->getID() === $this->id and $blockSouth->meta !== 0x08){ | |
| $this->level->setBlock($blockSouth, new Air(), true, false, true); | |
| }elseif($blockEast->getID() === $this->id and $blockEast->meta !== 0x08){ | |
| $this->level->setBlock($blockEast, new Air(), true, false, true); | |
| }elseif($blockWest->getID() === $this->id and $blockWest->meta !== 0x08){ | |
| $this->level->setBlock($blockWest, new Air(), true, false, true); | |
| } | |
| }else{ //Bottom Part of Bed | |
| if($blockNorth->getID() === $this->id and ($blockNorth->meta & 0x08) === 0x08){ | |
| $this->level->setBlock($blockNorth, new Air(), true, false, true); | |
| }elseif($blockSouth->getID() === $this->id and ($blockSouth->meta & 0x08) === 0x08){ | |
| $this->level->setBlock($blockSouth, new Air(), true, false, true); | |
| }elseif($blockEast->getID() === $this->id and ($blockEast->meta & 0x08) === 0x08){ | |
| $this->level->setBlock($blockEast, new Air(), true, false, true); | |
| }elseif($blockWest->getID() === $this->id and ($blockWest->meta & 0x08) === 0x08){ | |
| $this->level->setBlock($blockWest, new Air(), true, false, true); | |
| } | |
| } | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::BED, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Bedrock extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::BEDROCK, 0, "Bedrock"); | |
| $this->breakable = false; | |
| $this->hardness = 18000000; | |
| } | |
| public function isBreakable(Item $item){ | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Beetroot extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::BEETROOT_BLOCK, $meta, "Beetroot Block"); | |
| $this->isActivable = true; | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::FARMLAND){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| $this->meta = 0x07; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| $item->count--; | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(BEETROOT_SEEDS, 0, 1)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if(mt_rand(0, 2) == 1){ | |
| if($this->meta < 0x07){ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| }else{ | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array(); | |
| if($this->meta >= 0x07){ | |
| $drops[] = array(Item::BEETROOT, 0, 1); | |
| $drops[] = array(Item::BEETROOT_SEEDS, 0, mt_rand(0, 3)); | |
| }else{ | |
| $drops[] = array(Item::BEETROOT_SEEDS, 0, 1); | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class BirchWoodStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::BIRCH_WOOD_STAIRS, $meta, "Birch Wood Stairs"); | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * All Block classes are in here | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\level\Position; | |
| use pocketmine\Player; | |
| abstract class Block extends Position{ | |
| const AIR = 0; | |
| const STONE = 1; | |
| const GRASS = 2; | |
| const DIRT = 3; | |
| const COBBLESTONE = 4; | |
| const COBBLE = 4; | |
| const PLANK = 5; | |
| const PLANKS = 5; | |
| const WOODEN_PLANK = 5; | |
| const WOODEN_PLANKS = 5; | |
| const SAPLING = 6; | |
| const SAPLINGS = 6; | |
| const BEDROCK = 7; | |
| const WATER = 8; | |
| const STILL_WATER = 9; | |
| const LAVA = 10; | |
| const STILL_LAVA = 11; | |
| const SAND = 12; | |
| const GRAVEL = 13; | |
| const GOLD_ORE = 14; | |
| const IRON_ORE = 15; | |
| const COAL_ORE = 16; | |
| const WOOD = 17; | |
| const TRUNK = 17; | |
| const LOG = 17; | |
| const LEAVES = 18; | |
| const LEAVE = 18; | |
| const SPONGE = 19; | |
| const GLASS = 20; | |
| const LAPIS_ORE = 21; | |
| const LAPIS_BLOCK = 22; | |
| const SANDSTONE = 24; | |
| const BED_BLOCK = 26; | |
| const COBWEB = 30; | |
| const TALL_GRASS = 31; | |
| const BUSH = 32; | |
| const DEAD_BUSH = 32; | |
| const WOOL = 35; | |
| const DANDELION = 37; | |
| const ROSE = 38; | |
| const CYAN_FLOWER = 38; | |
| const BROWN_MUSHROOM = 39; | |
| const RED_MUSHROOM = 40; | |
| const GOLD_BLOCK = 41; | |
| const IRON_BLOCK = 42; | |
| const DOUBLE_SLAB = 43; | |
| const DOUBLE_SLABS = 43; | |
| const SLAB = 44; | |
| const SLABS = 44; | |
| const BRICKS = 45; | |
| const BRICKS_BLOCK = 45; | |
| const TNT = 46; | |
| const BOOKSHELF = 47; | |
| const MOSS_STONE = 48; | |
| const MOSSY_STONE = 48; | |
| const OBSIDIAN = 49; | |
| const TORCH = 50; | |
| const FIRE = 51; | |
| const WOOD_STAIRS = 53; | |
| const WOODEN_STAIRS = 53; | |
| const OAK_WOOD_STAIRS = 53; | |
| const OAK_WOODEN_STAIRS = 53; | |
| const CHEST = 54; | |
| const DIAMOND_ORE = 56; | |
| const DIAMOND_BLOCK = 57; | |
| const CRAFTING_TABLE = 58; | |
| const WORKBENCH = 58; | |
| const WHEAT_BLOCK = 59; | |
| const FARMLAND = 60; | |
| const FURNACE = 61; | |
| const BURNING_FURNACE = 62; | |
| const LIT_FURNACE = 62; | |
| const SIGN_POST = 63; | |
| const DOOR_BLOCK = 64; | |
| const WOODEN_DOOR_BLOCK = 64; | |
| const WOOD_DOOR_BLOCK = 64; | |
| const LADDER = 65; | |
| const COBBLE_STAIRS = 67; | |
| const COBBLESTONE_STAIRS = 67; | |
| const WALL_SIGN = 68; | |
| const IRON_DOOR_BLOCK = 71; | |
| const REDSTONE_ORE = 73; | |
| const GLOWING_REDSTONE_ORE = 74; | |
| const LIT_REDSTONE_ORE = 74; | |
| const SNOW = 78; | |
| const SNOW_LAYER = 78; | |
| const ICE = 79; | |
| const SNOW_BLOCK = 80; | |
| const CACTUS = 81; | |
| const CLAY_BLOCK = 82; | |
| const REEDS = 83; | |
| const SUGARCANE_BLOCK = 83; | |
| const FENCE = 85; | |
| const PUMPKIN = 86; | |
| const NETHERRACK = 87; | |
| const SOUL_SAND = 88; | |
| const GLOWSTONE = 89; | |
| const GLOWSTONE_BLOCK = 89; | |
| const LIT_PUMPKIN = 91; | |
| const JACK_O_LANTERN = 91; | |
| const CAKE_BLOCK = 92; | |
| const TRAPDOOR = 96; | |
| const STONE_BRICKS = 98; | |
| const STONE_BRICK = 98; | |
| const IRON_BAR = 101; | |
| const IRON_BARS = 101; | |
| const GLASS_PANE = 102; | |
| const GLASS_PANEL = 102; | |
| const MELON_BLOCK = 103; | |
| const PUMPKIN_STEM = 104; | |
| const MELON_STEM = 105; | |
| const FENCE_GATE = 107; | |
| const BRICK_STAIRS = 108; | |
| const STONE_BRICK_STAIRS = 109; | |
| const NETHER_BRICKS = 112; | |
| const NETHER_BRICK_BLOCK = 112; | |
| const NETHER_BRICKS_STAIRS = 114; | |
| const SANDSTONE_STAIRS = 128; | |
| const SPRUCE_WOOD_STAIRS = 134; | |
| const SPRUCE_WOODEN_STAIRS = 134; | |
| const BIRCH_WOOD_STAIRS = 135; | |
| const BIRCH_WOODEN_STAIRS = 135; | |
| const JUNGLE_WOOD_STAIRS = 136; | |
| const JUNGLE_WOODEN_STAIRS = 136; | |
| const COBBLE_WALL = 139; | |
| const STONE_WALL = 139; | |
| const COBBLESTONE_WALL = 139; | |
| const CARROT_BLOCK = 141; | |
| const POTATO_BLOCK = 142; | |
| const QUARTZ_BLOCK = 155; | |
| const QUARTZ_STAIRS = 156; | |
| const DOUBLE_WOOD_SLAB = 157; | |
| const DOUBLE_WOODEN_SLAB = 157; | |
| const DOUBLE_WOOD_SLABS = 157; | |
| const DOUBLE_WOODEN_SLABS = 157; | |
| const WOOD_SLAB = 158; | |
| const WOODEN_SLAB = 158; | |
| const WOOD_SLABS = 158; | |
| const WOODEN_SLABS = 158; | |
| const HAY_BALE = 170; | |
| const CARPET = 171; | |
| const COAL_BLOCK = 173; | |
| const BEETROOT_BLOCK = 244; | |
| const STONECUTTER = 245; | |
| const GLOWING_OBSIDIAN = 246; | |
| const NETHER_REACTOR = 247; | |
| public static $creative = array( | |
| //Building | |
| [Item::STONE, 0], | |
| [Item::COBBLESTONE, 0], | |
| [Item::STONE_BRICKS, 0], | |
| [Item::STONE_BRICKS, 1], | |
| [Item::STONE_BRICKS, 2], | |
| [Item::MOSS_STONE, 0], | |
| [Item::WOODEN_PLANKS, 0], | |
| [Item::WOODEN_PLANKS, 1], | |
| [Item::WOODEN_PLANKS, 2], | |
| [Item::WOODEN_PLANKS, 3], | |
| [Item::BRICKS, 0], | |
| [Item::DIRT, 0], | |
| [Item::GRASS, 0], | |
| [Item::CLAY_BLOCK, 0], | |
| [Item::SANDSTONE, 0], | |
| [Item::SANDSTONE, 1], | |
| [Item::SANDSTONE, 2], | |
| [Item::SAND, 0], | |
| [Item::GRAVEL, 0], | |
| [Item::TRUNK, 0], | |
| [Item::TRUNK, 1], | |
| [Item::TRUNK, 2], | |
| [Item::TRUNK, 3], | |
| [Item::NETHER_BRICKS, 0], | |
| [Item::NETHERRACK, 0], | |
| [Item::BEDROCK, 0], | |
| [Item::COBBLESTONE_STAIRS, 0], | |
| [Item::OAK_WOODEN_STAIRS, 0], | |
| [Item::SPRUCE_WOODEN_STAIRS, 0], | |
| [Item::BIRCH_WOODEN_STAIRS, 0], | |
| [Item::JUNGLE_WOODEN_STAIRS, 0], | |
| [Item::BRICK_STAIRS, 0], | |
| [Item::SANDSTONE_STAIRS, 0], | |
| [Item::STONE_BRICK_STAIRS, 0], | |
| [Item::NETHER_BRICKS_STAIRS, 0], | |
| [Item::QUARTZ_STAIRS, 0], | |
| [Item::SLAB, 0], | |
| [Item::SLAB, 1], | |
| [Item::WOODEN_SLAB, 0], | |
| [Item::WOODEN_SLAB, 1], | |
| [Item::WOODEN_SLAB, 2], | |
| [Item::WOODEN_SLAB, 3], | |
| [Item::SLAB, 3], | |
| [Item::SLAB, 4], | |
| [Item::SLAB, 5], | |
| [Item::SLAB, 6], | |
| [Item::QUARTZ_BLOCK, 0], | |
| [Item::QUARTZ_BLOCK, 1], | |
| [Item::QUARTZ_BLOCK, 2], | |
| [Item::COAL_ORE, 0], | |
| [Item::IRON_ORE, 0], | |
| [Item::GOLD_ORE, 0], | |
| [Item::DIAMOND_ORE, 0], | |
| [Item::LAPIS_ORE, 0], | |
| [Item::REDSTONE_ORE, 0], | |
| [Item::OBSIDIAN, 0], | |
| [Item::ICE, 0], | |
| [Item::SNOW_BLOCK, 0], | |
| //Decoration | |
| [Item::COBBLESTONE_WALL, 0], | |
| [Item::COBBLESTONE_WALL, 1], | |
| [Item::GOLD_BLOCK, 0], | |
| [Item::IRON_BLOCK, 0], | |
| [Item::DIAMOND_BLOCK, 0], | |
| [Item::LAPIS_BLOCK, 0], | |
| [Item::COAL_BLOCK, 0], | |
| [Item::SNOW_LAYER, 0], | |
| [Item::GLASS, 0], | |
| [Item::GLOWSTONE_BLOCK, 0], | |
| [Item::NETHER_REACTOR, 0], | |
| [Item::WOOL, 0], | |
| [Item::WOOL, 7], | |
| [Item::WOOL, 6], | |
| [Item::WOOL, 5], | |
| [Item::WOOL, 4], | |
| [Item::WOOL, 3], | |
| [Item::WOOL, 2], | |
| [Item::WOOL, 1], | |
| [Item::WOOL, 15], | |
| [Item::WOOL, 14], | |
| [Item::WOOL, 13], | |
| [Item::WOOL, 12], | |
| [Item::WOOL, 11], | |
| [Item::WOOL, 10], | |
| [Item::WOOL, 9], | |
| [Item::WOOL, 8], | |
| [Item::LADDER, 0], | |
| [Item::SPONGE, 0], | |
| [Item::GLASS_PANE, 0], | |
| [Item::WOODEN_DOOR, 0], | |
| [Item::TRAPDOOR, 0], | |
| [Item::FENCE, 0], | |
| [Item::FENCE_GATE, 0], | |
| [Item::IRON_BARS, 0], | |
| [Item::BED, 0], | |
| [Item::BOOKSHELF, 0], | |
| [Item::PAINTING, 0], | |
| [Item::WORKBENCH, 0], | |
| [Item::STONECUTTER, 0], | |
| [Item::CHEST, 0], | |
| [Item::FURNACE, 0], | |
| [Item::DANDELION, 0], | |
| [Item::CYAN_FLOWER, 0], | |
| [Item::BROWN_MUSHROOM, 0], | |
| [Item::RED_MUSHROOM, 0], | |
| [Item::CACTUS, 0], | |
| [Item::MELON_BLOCK, 0], | |
| [Item::PUMPKIN, 0], | |
| [Item::LIT_PUMPKIN, 0], | |
| [Item::COBWEB, 0], | |
| [Item::HAY_BALE, 0], | |
| [Item::TALL_GRASS, 1], | |
| [Item::TALL_GRASS, 2], | |
| [Item::DEAD_BUSH, 0], | |
| [Item::SAPLING, 0], | |
| [Item::SAPLING, 1], | |
| [Item::SAPLING, 2], | |
| [Item::SAPLING, 3], | |
| [Item::LEAVES, 0], | |
| [Item::LEAVES, 1], | |
| [Item::LEAVES, 2], | |
| [Item::LEAVES, 3], | |
| [Item::CAKE, 0], | |
| [Item::SIGN, 0], | |
| [Item::CARPET, 0], | |
| [Item::CARPET, 7], | |
| [Item::CARPET, 6], | |
| [Item::CARPET, 5], | |
| [Item::CARPET, 4], | |
| [Item::CARPET, 3], | |
| [Item::CARPET, 2], | |
| [Item::CARPET, 1], | |
| [Item::CARPET, 15], | |
| [Item::CARPET, 14], | |
| [Item::CARPET, 13], | |
| [Item::CARPET, 12], | |
| [Item::CARPET, 11], | |
| [Item::CARPET, 10], | |
| [Item::CARPET, 9], | |
| [Item::CARPET, 8], | |
| //Tools | |
| //[Item::RAILS, 0], | |
| //[Item::POWERED_RAILS, 0], | |
| [Item::TORCH, 0], | |
| [Item::BUCKET, 0], | |
| [Item::BUCKET, 8], | |
| [Item::BUCKET, 10], | |
| [Item::TNT, 0], | |
| [Item::IRON_HOE, 0], | |
| [Item::IRON_SWORD, 0], | |
| [Item::BOW, 0], | |
| [Item::SHEARS, 0], | |
| [Item::FLINT_AND_STEEL, 0], | |
| [Item::CLOCK, 0], | |
| [Item::COMPASS, 0], | |
| [Item::MINECART, 0], | |
| [Item::SPAWN_EGG, 10], //Chicken | |
| [Item::SPAWN_EGG, 11], //Cow | |
| [Item::SPAWN_EGG, 12], //Pig | |
| [Item::SPAWN_EGG, 13], //Sheep | |
| //TODO: Replace with Entity constants | |
| //Seeds | |
| [Item::SUGARCANE, 0], | |
| [Item::WHEAT, 0], | |
| [Item::SEEDS, 0], | |
| [Item::MELON_SEEDS, 0], | |
| [Item::PUMPKIN_SEEDS, 0], | |
| [Item::CARROT, 0], | |
| [Item::POTATO, 0], | |
| [Item::BEETROOT_SEEDS, 0], | |
| [Item::EGG, 0], | |
| [Item::DYE, 0], | |
| [Item::DYE, 7], | |
| [Item::DYE, 6], | |
| [Item::DYE, 5], | |
| [Item::DYE, 4], | |
| [Item::DYE, 3], | |
| [Item::DYE, 2], | |
| [Item::DYE, 1], | |
| [Item::DYE, 15], | |
| [Item::DYE, 14], | |
| [Item::DYE, 13], | |
| [Item::DYE, 12], | |
| [Item::DYE, 11], | |
| [Item::DYE, 10], | |
| [Item::DYE, 9], | |
| [Item::DYE, 8], | |
| ); | |
| /** @var Block[] */ | |
| public static $list = array(); | |
| protected $id; | |
| protected $meta; | |
| protected $name; | |
| protected $breakTime; | |
| protected $hardness; | |
| public $isActivable = false; | |
| public $breakable = true; | |
| public $isFlowable = false; | |
| public $isSolid = true; | |
| public $isTransparent = false; | |
| public $isReplaceable = false; | |
| public $isPlaceable = true; | |
| public $hasPhysics = false; | |
| public $isLiquid = false; | |
| public $isFullBlock = true; | |
| public $x = 0; | |
| public $y = 0; | |
| public $z = 0; | |
| public static function init(){ | |
| if(count(self::$list) === 0){ | |
| self::$list = array( | |
| self::AIR => new Air(), | |
| self::STONE => new Stone(), | |
| self::GRASS => new Grass(), | |
| self::DIRT => new Dirt(), | |
| self::COBBLESTONE => new Cobblestone(), | |
| self::PLANKS => new Planks(), | |
| self::SAPLING => new Sapling(), | |
| self::BEDROCK => new Bedrock(), | |
| self::WATER => new Water(), | |
| self::STILL_WATER => new StillWater(), | |
| self::LAVA => new Lava(), | |
| self::STILL_LAVA => new StillLava(), | |
| self::SAND => new Sand(), | |
| self::GRAVEL => new Gravel(), | |
| self::GOLD_ORE => new GoldOre(), | |
| self::IRON_ORE => new IronOre(), | |
| self::COAL_ORE => new CoalOre(), | |
| self::WOOD => new Wood(), | |
| self::LEAVES => new Leaves(), | |
| self::SPONGE => new Sponge(), | |
| self::GLASS => new Glass(), | |
| self::LAPIS_ORE => new LapisOre(), | |
| self::LAPIS_BLOCK => new Lapis(), | |
| self::SANDSTONE => new Sandstone(), | |
| self::BED_BLOCK => new Bed(), | |
| self::COBWEB => new Cobweb(), | |
| self::TALL_GRASS => new TallGrass(), | |
| self::DEAD_BUSH => new DeadBush(), | |
| self::WOOL => new Wool(), | |
| self::DANDELION => new Dandelion(), | |
| self::CYAN_FLOWER => new CyanFlower(), | |
| self::BROWN_MUSHROOM => new BrownMushroom(), | |
| self::RED_MUSHROOM => new RedMushroom(), | |
| self::GOLD_BLOCK => new Gold(), | |
| self::IRON_BLOCK => new Iron(), | |
| self::DOUBLE_SLAB => new DoubleSlab(), | |
| self::SLAB => new Slab(), | |
| self::BRICKS_BLOCK => new Bricks(), | |
| self::TNT => new TNT(), | |
| self::BOOKSHELF => new Bookshelf(), | |
| self::MOSS_STONE => new MossStone(), | |
| self::OBSIDIAN => new Obsidian(), | |
| self::TORCH => new Torch(), | |
| self::FIRE => new Fire(), | |
| self::WOOD_STAIRS => new WoodStairs(), | |
| self::CHEST => new Chest(), | |
| self::DIAMOND_ORE => new DiamondOre(), | |
| self::DIAMOND_BLOCK => new Diamond(), | |
| self::WORKBENCH => new Workbench(), | |
| self::WHEAT_BLOCK => new Wheat(), | |
| self::FARMLAND => new Farmland(), | |
| self::FURNACE => new Furnace(), | |
| self::BURNING_FURNACE => new BurningFurnace(), | |
| self::SIGN_POST => new SignPost(), | |
| self::WOOD_DOOR_BLOCK => new WoodDoor(), | |
| self::LADDER => new Ladder(), | |
| self::COBBLESTONE_STAIRS => new CobblestoneStairs(), | |
| self::WALL_SIGN => new WallSign(), | |
| self::IRON_DOOR_BLOCK => new IronDoor(), | |
| self::REDSTONE_ORE => new RedstoneOre(), | |
| self::GLOWING_REDSTONE_ORE => new GlowingRedstoneOre(), | |
| self::SNOW_LAYER => new SnowLayer(), | |
| self::ICE => new Ice(), | |
| self::SNOW_BLOCK => new Snow(), | |
| self::CACTUS => new Cactus(), | |
| self::CLAY_BLOCK => new Clay(), | |
| self::SUGARCANE_BLOCK => new Sugarcane(), | |
| self::FENCE => new Fence(), | |
| self::PUMPKIN => new Pumpkin(), | |
| self::NETHERRACK => new Netherrack(), | |
| self::SOUL_SAND => new SoulSand(), | |
| self::GLOWSTONE_BLOCK => new Glowstone(), | |
| self::LIT_PUMPKIN => new LitPumpkin(), | |
| self::CAKE_BLOCK => new Cake(), | |
| self::TRAPDOOR => new Trapdoor(), | |
| self::STONE_BRICKS => new StoneBricks(), | |
| self::IRON_BARS => new IronBars(), | |
| self::GLASS_PANE => new GlassPane(), | |
| self::MELON_BLOCK => new Melon(), | |
| self::PUMPKIN_STEM => new PumpkinStem(), | |
| self::MELON_STEM => new MelonStem(), | |
| self::FENCE_GATE => new FenceGate(), | |
| self::BRICK_STAIRS => new BrickStairs(), | |
| self::STONE_BRICK_STAIRS => new StoneBrickStairs(), | |
| self::NETHER_BRICKS => new NetherBrick(), | |
| self::NETHER_BRICKS_STAIRS => new NetherBrickStairs(), | |
| self::SANDSTONE_STAIRS => new SandstoneStairs(), | |
| self::SPRUCE_WOOD_STAIRS => new SpruceWoodStairs(), | |
| self::BIRCH_WOOD_STAIRS => new BirchWoodStairs(), | |
| self::JUNGLE_WOOD_STAIRS => new JungleWoodStairs(), | |
| self::STONE_WALL => new StoneWall(), | |
| self::CARROT_BLOCK => new Carrot(), | |
| self::POTATO_BLOCK => new Potato(), | |
| self::QUARTZ_BLOCK => new Quartz(), | |
| self::QUARTZ_STAIRS => new QuartzStairs(), | |
| self::DOUBLE_WOOD_SLAB => new DoubleWoodSlab(), | |
| self::WOOD_SLAB => new WoodSlab(), | |
| self::HAY_BALE => new HayBale(), | |
| self::CARPET => new Carpet(), | |
| self::COAL_BLOCK => new Coal(), | |
| self::BEETROOT_BLOCK => new Beetroot(), | |
| self::STONECUTTER => new Stonecutter(), | |
| self::GLOWING_OBSIDIAN => new GlowingObsidian(), | |
| ); | |
| } | |
| } | |
| /** | |
| * @param int $id | |
| * @param int $meta | |
| * @param Position $pos | |
| * | |
| * @return Block | |
| */ | |
| public static function get($id, $meta = 0, Position $pos = null){ | |
| if(isset(self::$list[$id])){ | |
| $block = clone self::$list[$id]; | |
| $block->setMetadata($meta); | |
| }else{ | |
| $block = new Generic($id, $meta); | |
| } | |
| if($pos instanceof Position){ | |
| $block->position($pos); | |
| } | |
| return $block; | |
| } | |
| /** | |
| * @param int $id | |
| * @param int $meta | |
| * @param string $name | |
| */ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| $this->id = (int) $id; | |
| $this->meta = (int) $meta; | |
| $this->name = $name; | |
| $this->breakTime = 0.20; | |
| $this->hardness = 10; | |
| } | |
| /** | |
| * @return int | |
| */ | |
| final public function getHardness(){ | |
| return $this->hardness; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| final public function getName(){ | |
| return $this->name; | |
| } | |
| /** | |
| * @return int | |
| */ | |
| final public function getID(){ | |
| return $this->id; | |
| } | |
| /** | |
| * @return int | |
| */ | |
| final public function getMetadata(){ | |
| return $this->meta; | |
| } | |
| /** | |
| * @param int $meta | |
| */ | |
| final public function setMetadata($meta){ | |
| $this->meta = $meta & 0x0F; | |
| } | |
| /** | |
| * Sets the block position to a new Position object | |
| * | |
| * @param Position $v | |
| */ | |
| final public function position(Position $v){ | |
| $this->level = $v->level; | |
| $this->x = (int) $v->x; | |
| $this->y = (int) $v->y; | |
| $this->z = (int) $v->z; | |
| } | |
| /** | |
| * Returns an array of Item objects to be dropped | |
| * | |
| * @param Item $item | |
| * | |
| * @return array | |
| */ | |
| public function getDrops(Item $item){ | |
| if(!isset(self::$list[$this->id])){ //Unknown blocks | |
| return array(); | |
| }else{ | |
| return array( | |
| array($this->id, $this->meta, 1), | |
| ); | |
| } | |
| } | |
| /** | |
| * Returns the seconds that this block takes to be broken using an specific Item | |
| * | |
| * @param Item $item | |
| * | |
| * @return float | |
| */ | |
| public function getBreakTime(Item $item){ | |
| return $this->breakTime; | |
| } | |
| /** | |
| * Returns the Block on the side $side, works like Vector3::side() | |
| * | |
| * @param int $side | |
| * @param int $step | |
| * | |
| * @return Block | |
| */ | |
| public function getSide($side, $step = 1){ | |
| $v = parent::getSide($side, $step); | |
| if($this->level instanceof Level){ | |
| return $this->level->getBlock($v); | |
| } | |
| return $v; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| final public function __toString(){ | |
| return "Block " . $this->name . " (" . $this->id . ":" . $this->meta . ")"; | |
| } | |
| /** | |
| * Returns if the item can be broken with an specific Item | |
| * | |
| * @param Item $item | |
| * | |
| * @return bool | |
| */ | |
| abstract function isBreakable(Item $item); | |
| /** | |
| * Do the actions needed so the block is broken with the Item | |
| * | |
| * @param Item $item | |
| * | |
| * @return mixed | |
| */ | |
| abstract function onBreak(Item $item); | |
| /** | |
| * Places the Block, using block space and block target, and side. Returns if the block has been placed. | |
| * | |
| * @param Item $item | |
| * @param Block $block | |
| * @param Block $target | |
| * @param int $face | |
| * @param float $fx | |
| * @param float $fy | |
| * @param float $fz | |
| * @param Player $player = null | |
| * | |
| * @return bool | |
| */ | |
| abstract function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null); | |
| /** | |
| * Do actions when activated by Item. Returns if it has done anything | |
| * | |
| * @param Item $item | |
| * @param Player $player | |
| * | |
| * @return bool | |
| */ | |
| abstract function onActivate(Item $item, Player $player = null); | |
| /** | |
| * Fires a block update on the Block | |
| * | |
| * @param int $type | |
| * | |
| * @return void | |
| */ | |
| abstract function onUpdate($type); | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Bookshelf extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::BOOKSHELF, 0, "Bookshelf"); | |
| $this->hardness = 7.5; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Bricks extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::BRICKS_BLOCK, 0, "Bricks"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 10; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::BRICKS_BLOCK, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class BrickStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::BRICK_STAIRS, $meta, "Brick Stairs"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class BrownMushroom extends Flowable{ | |
| public function __construct(){ | |
| parent::__construct(self::BROWN_MUSHROOM, 0, "Brown Mushroom"); | |
| $this->hardness = 0; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get($this->id)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->isTransparent === false){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\nbt\tag\Enum; | |
| use pocketmine\nbt\tag\Int; | |
| use pocketmine\nbt\tag\String; | |
| use pocketmine\Player; | |
| use pocketmine\tile\Furnace; | |
| use pocketmine\tile\Tile; | |
| class BurningFurnace extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::BURNING_FURNACE, $meta, "Burning Furnace"); | |
| $this->isActivable = true; | |
| $this->hardness = 17.5; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $faces = array( | |
| 0 => 4, | |
| 1 => 2, | |
| 2 => 5, | |
| 3 => 3, | |
| ); | |
| $this->meta = $faces[$player instanceof Player ? $player->getDirection() : 0]; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| $nbt = new Compound(false, array( | |
| new Enum("Items", array()), | |
| new String("id", Tile::FURNACE), | |
| new Int("x", $this->x), | |
| new Int("y", $this->y), | |
| new Int("z", $this->z) | |
| )); | |
| $nbt->Items->setTagType(NBT::TAG_Compound); | |
| new Furnace($this->level, $nbt); | |
| return true; | |
| } | |
| public function onBreak(Item $item){ | |
| $this->level->setBlock($this, new Air(), true, true, true); | |
| return true; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($player instanceof Player){ | |
| $t = $this->level->getTile($this); | |
| $furnace = false; | |
| if($t instanceof Furnace){ | |
| $furnace = $t; | |
| }else{ | |
| $nbt = new Compound(false, array( | |
| new Enum("Items", array()), | |
| new String("id", Tile::FURNACE), | |
| new Int("x", $this->x), | |
| new Int("y", $this->y), | |
| new Int("z", $this->z) | |
| )); | |
| $nbt->Items->setTagType(NBT::TAG_Compound); | |
| $furnace = new Furnace($this->level, $nbt); | |
| } | |
| if(($player->getGamemode() & 0x01) === 0x01){ | |
| return true; | |
| } | |
| $furnace->openInventory($player); | |
| } | |
| return true; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.7; | |
| case 4: | |
| return 0.9; | |
| case 3: | |
| return 1.35; | |
| case 2: | |
| return 0.45; | |
| case 1: | |
| return 2.65; | |
| default: | |
| return 17.5; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array(); | |
| if($item->isPickaxe() >= 1){ | |
| $drops[] = array(Item::FURNACE, 0, 1); | |
| } | |
| $t = $this->level->getTile($this); | |
| if($t instanceof Furnace){ | |
| for($s = 0; $s < Furnace::SLOTS; ++$s){ | |
| $slot = $t->getSlot($s); | |
| if($slot->getID() > Item::AIR and $slot->getCount() > 0){ | |
| $drops[] = array($slot->getID(), $slot->getMetadata(), $slot->getCount()); | |
| } | |
| } | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Cactus extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::CACTUS, $meta, "Cactus"); | |
| $this->isFullBlock = false; | |
| $this->hardness = 2; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| $down = $this->getSide(0); | |
| if($down->getID() !== self::SAND and $down->getID() !== self::CACTUS){ //Replace with common break method | |
| $this->level->setBlock($this, new Air(), false); | |
| Server::getInstance()->api->entity->drop($this, Item::get($this->id)); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if($this->getSide(0)->getID() !== self::CACTUS){ | |
| if($this->meta == 0x0F){ | |
| for($y = 1; $y < 3; ++$y){ | |
| $b = $this->level->getBlock(new Vector3($this->x, $this->y + $y, $this->z)); | |
| if($b->getID() === self::AIR){ | |
| $this->level->setBlock($b, new Cactus(), true, false, true); | |
| break; | |
| } | |
| } | |
| $this->meta = 0; | |
| $this->level->setBlock($this, $this, false); | |
| }else{ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, false); | |
| } | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| return false; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::SAND or $down->getID() === self::CACTUS){ | |
| $block0 = $this->getSide(2); | |
| $block1 = $this->getSide(3); | |
| $block2 = $this->getSide(4); | |
| $block3 = $this->getSide(5); | |
| if($block0->isTransparent === true and $block1->isTransparent === true and $block2->isTransparent === true and $block3->isTransparent === true){ | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Cake extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::CAKE_BLOCK, 0, "Cake Block"); | |
| $this->isFullBlock = false; | |
| $this->isActivable = true; | |
| $this->meta = $meta & 0x07; | |
| $this->hardness = 2.5; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() !== self::AIR){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->getID() === self::AIR){ //Replace with common break method | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array(); | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($player instanceof Player and $player->getHealth() < 20){ | |
| ++$this->meta; | |
| $player->heal(3, "cake"); | |
| if($this->meta >= 0x06){ | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| }else{ | |
| $this->level->setBlock($this, $this, true, false, true); | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Carpet extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::CARPET, $meta, "Carpet"); | |
| $names = array( | |
| 0 => "White Carpet", | |
| 1 => "Orange Carpet", | |
| 2 => "Magenta Carpet", | |
| 3 => "Light Blue Carpet", | |
| 4 => "Yellow Carpet", | |
| 5 => "Lime Carpet", | |
| 6 => "Pink Carpet", | |
| 7 => "Gray Carpet", | |
| 8 => "Light Gray Carpet", | |
| 9 => "Cyan Carpet", | |
| 10 => "Purple Carpet", | |
| 11 => "Blue Carpet", | |
| 12 => "Brown Carpet", | |
| 13 => "Green Carpet", | |
| 14 => "Red Carpet", | |
| 15 => "Black Carpet", | |
| ); | |
| $this->name = $names[$this->meta]; | |
| $this->hardness = 0; | |
| $this->isFullBlock = false; | |
| $this->isSolid = true; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() !== self::AIR){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->getID() === self::AIR){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get($this->id, $this->meta, 1)); | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Carrot extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::CARROT_BLOCK, $meta, "Carrot Block"); | |
| $this->isActivable = true; | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::FARMLAND){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| $this->meta = 0x07; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| $item->count--; | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(CARROT, 0, 1)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if(mt_rand(0, 2) == 1){ | |
| if($this->meta < 0x07){ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| }else{ | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array(); | |
| if($this->meta >= 0x07){ | |
| $drops[] = array(Item::CARROT, 0, mt_rand(1, 4)); | |
| }else{ | |
| $drops[] = array(Item::CARROT, 0, 1); | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\nbt\tag\Enum; | |
| use pocketmine\nbt\tag\Int; | |
| use pocketmine\nbt\tag\String; | |
| use pocketmine\Player; | |
| use pocketmine\tile\Chest as TileChest; | |
| use pocketmine\tile\Tile; | |
| class Chest extends Transparent{ | |
| const SLOTS = 27; | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::CHEST, $meta, "Chest"); | |
| $this->isActivable = true; | |
| $this->hardness = 15; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $faces = array( | |
| 0 => 4, | |
| 1 => 2, | |
| 2 => 5, | |
| 3 => 3, | |
| ); | |
| $chest = false; | |
| $this->meta = $faces[$player instanceof Player ? $player->getDirection() : 0]; | |
| for($side = 2; $side <= 5; ++$side){ | |
| if(($this->meta === 4 or $this->meta === 5) and ($side === 4 or $side === 5)){ | |
| continue; | |
| }elseif(($this->meta === 3 or $this->meta === 2) and ($side === 2 or $side === 3)){ | |
| continue; | |
| } | |
| $c = $this->getSide($side); | |
| if(($c instanceof TileChest) and $c->getMetadata() === $this->meta){ | |
| if((($tile = $this->level->getTile($c)) instanceof TileChest) and !$tile->isPaired()){ | |
| $chest = $tile; | |
| break; | |
| } | |
| } | |
| } | |
| $this->level->setBlock($block, $this, true, false, true); | |
| $nbt = new Compound(false, array( | |
| new Enum("Items", array()), | |
| new String("id", Tile::CHEST), | |
| new Int("x", $this->x), | |
| new Int("y", $this->y), | |
| new Int("z", $this->z) | |
| )); | |
| $nbt->Items->setTagType(NBT::TAG_Compound); | |
| $tile = new TileChest($this->level, $nbt); | |
| if($chest instanceof TileChest){ | |
| $chest->pairWith($tile); | |
| $tile->pairWith($chest); | |
| } | |
| return true; | |
| } | |
| public function onBreak(Item $item){ | |
| $t = $this->level->getTile($this); | |
| if($t instanceof TileChest){ | |
| $t->unpair(); | |
| } | |
| $this->level->setBlock($this, new Air(), true, true, true); | |
| return true; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($player instanceof Player){ | |
| $top = $this->getSide(1); | |
| if($top->isTransparent !== true){ | |
| return true; | |
| } | |
| $t = $this->level->getTile($this); | |
| $chest = false; | |
| if($t instanceof TileChest){ | |
| $chest = $t; | |
| }else{ | |
| $nbt = new Compound(false, array( | |
| new Enum("Items", array()), | |
| new String("id", Tile::CHEST), | |
| new Int("x", $this->x), | |
| new Int("y", $this->y), | |
| new Int("z", $this->z) | |
| )); | |
| $nbt->Items->setTagType(NBT::TAG_Compound); | |
| $chest = new TileChest($this->level, $nbt); | |
| } | |
| if(($player->gamemode & 0x01) === 0x01){ | |
| return true; | |
| } | |
| $chest->openInventory($player); | |
| } | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array( | |
| array($this->id, 0, 1), | |
| ); | |
| $t = $this->level->getTile($this); | |
| if($t instanceof Chest){ | |
| for($s = 0; $s < Chest::SLOTS; ++$s){ | |
| $slot = $t->getSlot($s); | |
| if($slot->getID() > Item::AIR and $slot->getCount() > 0){ | |
| $drops[] = array($slot->getID(), $slot->getMetadata(), $slot->getCount()); | |
| } | |
| } | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Clay extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::CLAY_BLOCK, 0, "Clay Block"); | |
| $this->hardness = 3; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::CLAY, 0, 4), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Coal extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::COAL_BLOCK, 0, "Coal Block"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.95; | |
| case 4: | |
| return 1.25; | |
| case 3: | |
| return 1.9; | |
| case 2: | |
| return 0.65; | |
| case 1: | |
| return 3.75; | |
| default: | |
| return 25; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::COAL_BLOCK, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class CoalOre extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::COAL_ORE, 0, "Coal Ore"); | |
| $this->hardness = 15; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| case 3: | |
| return 1.15; | |
| case 2: | |
| return 0.4; | |
| case 1: | |
| return 2.25; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::COAL, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Cobblestone extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::COBBLESTONE, 0, "Cobblestone"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 10; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::COBBLESTONE, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class CobblestoneStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::COBBLESTONE_STAIRS, $meta, "Cobblestone Stairs"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Cobweb extends Flowable{ | |
| public function __construct(){ | |
| parent::__construct(self::COBWEB, 0, "Cobweb"); | |
| $this->isSolid = true; | |
| $this->isFullBlock = false; | |
| $this->hardness = 25; | |
| } | |
| public function getDrops(Item $item){ | |
| return array(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class CyanFlower extends Flowable{ | |
| public function __construct(){ | |
| parent::__construct(self::CYAN_FLOWER, 0, "Cyan Flower"); | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === 2 or $down->getID() === 3 or $down->getID() === 60){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get($this->id)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Dandelion extends Flowable{ | |
| public function __construct(){ | |
| parent::__construct(self::DANDELION, 0, "Dandelion"); | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === 2 or $down->getID() === 3 or $down->getID() === 60){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get($this->id)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\level\Level; | |
| class DeadBush extends Flowable{ | |
| public function __construct(){ | |
| parent::__construct(self::DEAD_BUSH, 0, "Dead Bush"); | |
| //$this->isReplaceable = true; | |
| $this->hardness = 0; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Diamond extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::DIAMOND_BLOCK, 0, "Diamond Block"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.95; | |
| case 4: | |
| return 1.25; | |
| default: | |
| return 25; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 4){ | |
| return array( | |
| array(Item::DIAMOND_BLOCK, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class DiamondOre extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::DIAMOND_ORE, 0, "Diamond Ore"); | |
| $this->hardness = 15; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 4){ | |
| return array( | |
| array(Item::DIAMOND, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Dirt extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::DIRT, 0, "Dirt"); | |
| $this->isActivable = true; | |
| $this->hardness = 2.5; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->isHoe()){ | |
| $item->useOn($this); | |
| $this->level->setBlock($this, Block::get(Item::FARMLAND, 0), true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\network\protocol\LevelEventPacket; | |
| use pocketmine\Player; | |
| abstract class Door extends Transparent{ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| $this->isSolid = false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->getID() === self::AIR){ //Replace with common break method | |
| $this->level->setBlock($this, new Air(), false); | |
| if($this->getSide(1) instanceof Door){ | |
| $this->level->setBlock($this->getSide(1), new Air(), false); | |
| } | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| if($face === 1){ | |
| $blockUp = $this->getSide(1); | |
| $blockDown = $this->getSide(0); | |
| if($blockUp->isReplaceable === false or $blockDown->isTransparent === true){ | |
| return false; | |
| } | |
| $direction = $player instanceof Player ? $player->getDirection() : 0; | |
| $face = array( | |
| 0 => 3, | |
| 1 => 4, | |
| 2 => 2, | |
| 3 => 5, | |
| ); | |
| $next = $this->getSide($face[(($direction + 2) % 4)]); | |
| $next2 = $this->getSide($face[$direction]); | |
| $metaUp = 0x08; | |
| if($next->getID() === $this->id or ($next2->isTransparent === false and $next->isTransparent === true)){ //Door hinge | |
| $metaUp |= 0x01; | |
| } | |
| $this->level->setBlock($blockUp, Block::get($this->id, $metaUp), true, false, true); //Top | |
| $this->meta = $player->getDirection() & 0x03; | |
| $this->level->setBlock($block, $this, true, false, true); //Bottom | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onBreak(Item $item){ | |
| if(($this->meta & 0x08) === 0x08){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === $this->id){ | |
| $this->level->setBlock($down, new Air(), true, false, true); | |
| } | |
| }else{ | |
| $up = $this->getSide(1); | |
| if($up->getID() === $this->id){ | |
| $this->level->setBlock($up, new Air(), true, false, true); | |
| } | |
| } | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return true; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if(($this->meta & 0x08) === 0x08){ //Top | |
| $down = $this->getSide(0); | |
| if($down->getID() === $this->id){ | |
| $meta = $down->getMetadata() ^ 0x04; | |
| $this->level->setBlock($down, Block::get($this->id, $meta), true, false, true); | |
| $players = $this->level->getUsingChunk($this->x >> 4, $this->z >> 4); | |
| if($player instanceof Player){ | |
| unset($players[$player->CID]); | |
| } | |
| $pk = new LevelEventPacket; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->evid = 1003; | |
| $pk->data = 0; | |
| Player::broadcastPacket($players, $pk); | |
| return true; | |
| } | |
| return false; | |
| }else{ | |
| $this->meta ^= 0x04; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| $players = $this->level->getUsingChunk($this->x >> 4, $this->z >> 4); | |
| if($player instanceof Player){ | |
| unset($players[$player->CID]); | |
| } | |
| $pk = new LevelEventPacket; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->evid = 1003; | |
| $pk->data = 0; | |
| Player::broadcastPacket($players, $pk); | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class DoubleSlab extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::DOUBLE_SLAB, $meta, "Double Slab"); | |
| $names = array( | |
| 0 => "Stone", | |
| 1 => "Sandstone", | |
| 2 => "Wooden", | |
| 3 => "Cobblestone", | |
| 4 => "Brick", | |
| 5 => "Stone Brick", | |
| 6 => "Quartz", | |
| ); | |
| $this->name = "Double " . $names[$this->meta & 0x07] . " Slab"; | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 10; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::SLAB, $this->meta & 0x07, 2), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class DoubleWoodSlab extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::DOUBLE_WOOD_SLAB, $meta, "Double Wooden Slab"); | |
| $names = array( | |
| 0 => "Oak", | |
| 1 => "Spruce", | |
| 2 => "Birch", | |
| 3 => "Jungle", | |
| ); | |
| $this->name = "Double " . $names[$this->meta & 0x07] . " Wooden Slab"; | |
| $this->hardness = 15; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isAxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 3; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::WOOD_SLAB, $this->meta & 0x07, 2), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Fallable extends Solid{ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| $this->hasPhysics = true; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $ret = $this->level->setBlock($this, $this, true, false, true); | |
| return $ret; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Farmland extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::FARMLAND, $meta, "Farmland"); | |
| $this->hardness = 3; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::DIRT, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Fence extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::FENCE, 0, "Fence"); | |
| $this->isFullBlock = false; | |
| $this->hardness = 15; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class FenceGate extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::FENCE_GATE, $meta, "Fence Gate"); | |
| $this->isActivable = true; | |
| if(($this->meta & 0x04) === 0x04){ | |
| $this->isFullBlock = true; | |
| }else{ | |
| $this->isFullBlock = false; | |
| } | |
| $this->hardness = 15; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $faces = array( | |
| 0 => 3, | |
| 1 => 0, | |
| 2 => 1, | |
| 3 => 2, | |
| ); | |
| $this->meta = $faces[$player instanceof Player ? $player->getDirection() : 0] & 0x03; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| $faces = array( | |
| 0 => 3, | |
| 1 => 0, | |
| 2 => 1, | |
| 3 => 2, | |
| ); | |
| $this->meta = ($faces[$player instanceof Player ? $player->getDirection() : 0] & 0x03) | ((~$this->meta) & 0x04); | |
| if(($this->meta & 0x04) === 0x04){ | |
| $this->isFullBlock = true; | |
| }else{ | |
| $this->isFullBlock = false; | |
| } | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| class Fire extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::FIRE, $meta, "Fire"); | |
| $this->isReplaceable = true; | |
| $this->breakable = false; | |
| $this->isFullBlock = true; | |
| $this->hardness = 0; | |
| } | |
| public function getDrops(Item $item){ | |
| return array(); | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| for($s = 0; $s <= 5; ++$s){ | |
| $side = $this->getSide($s); | |
| if($side->getID() !== self::AIR and !($side instanceof Liquid)){ | |
| return false; | |
| } | |
| } | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if($this->getSide(0)->getID() !== self::NETHERRACK){ | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Flowable extends Transparent{ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| $this->isFlowable = true; | |
| $this->isFullBlock = false; | |
| $this->isSolid = false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Furnace extends BurningFurnace{ | |
| public function __construct($meta = 0){ | |
| parent::__construct($meta); | |
| $this->id = self::FURNACE; | |
| $this->name = "Furnace"; | |
| $this->isActivable = true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Generic extends Block{ | |
| /** | |
| * @param int $id | |
| * @param int $meta | |
| * @param string $name | |
| */ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| return $this->level->setBlock($this, $this, true, false, true); | |
| } | |
| public function isBreakable(Item $item){ | |
| return $this->breakable; | |
| } | |
| public function onBreak(Item $item){ | |
| return $this->level->setBlock($this, new Air(), true, false, true); | |
| } | |
| public function onUpdate($type){ | |
| if($this->hasPhysics === true and $type === Level::BLOCK_UPDATE_NORMAL){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::AIR or ($down instanceof Liquid)){ | |
| $data = array( | |
| "x" => $this->x + 0.5, | |
| "y" => $this->y + 0.5, | |
| "z" => $this->z + 0.5, | |
| "Tile" => $this->id, | |
| ); | |
| $server = Server::getInstance(); | |
| /*$this->level->setBlock($this, new Air(), false, false, true); | |
| //TODO | |
| //$e = $server->api->entity->add($this->level, ENTITY_FALLING, FALLING_SAND, $data); | |
| //$e->spawnToAll(); | |
| $server->api->block->blockUpdateAround(clone $this, Level::BLOCK_UPDATE_NORMAL, 1);*/ | |
| } | |
| return false; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| return $this->isActivable; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Glass extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::GLASS, 0, "Glass"); | |
| $this->hardness = 1.5; | |
| } | |
| public function getDrops(Item $item){ | |
| return array(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class GlassPane extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::GLASS_PANE, 0, "Glass Pane"); | |
| $this->isFullBlock = false; | |
| $this->isSolid = false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class GlowingObsidian extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::GLOWING_OBSIDIAN, $meta, "Glowing Obsidian"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| class GlowingRedstoneOre extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::GLOWING_REDSTONE_ORE, 0, "Glowing Redstone Ore"); | |
| $this->hardness = 15; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_SCHEDULED or $type === Level::BLOCK_UPDATE_RANDOM){ | |
| $this->level->setBlock($this, Block::get(Item::REDSTONE_ORE, $this->meta), false, false, true); | |
| return Level::BLOCK_UPDATE_WEAK; | |
| } | |
| return false; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 4){ | |
| return array( | |
| array(Item::REDSTONE_DUST, 0, mt_rand(4, 5)), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Glowstone extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::GLOWSTONE_BLOCK, 0, "Glowstone"); | |
| $this->hardness = 1.5; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::GLOWSTONE_DUST, 0, mt_rand(2, 4)), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Gold extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::GOLD_BLOCK, 0, "Gold Block"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 4){ | |
| return array( | |
| array(Item::GOLD_BLOCK, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class GoldOre extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::GOLD_ORE, 0, "Gold Ore"); | |
| $this->hardness = 15; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 4){ | |
| return array( | |
| array(Item::GOLD_ORE, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\generator\object\TallGrass; | |
| use pocketmine\Player; | |
| use pocketmine\utils\Random; | |
| class Grass extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::GRASS, 0, "Grass"); | |
| $this->isActivable = true; | |
| $this->hardness = 3; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::DIRT, 0, 1), | |
| ); | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ | |
| $item->count--; | |
| TallGrass::growGrass($this->level, $this, new Random(mt_rand()), 8, 2); | |
| return true; | |
| }elseif($item->isHoe()){ | |
| $item->useOn($this); | |
| $this->level->setBlock($this, new Farmland()); | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Gravel extends Fallable{ | |
| public function __construct(){ | |
| parent::__construct(self::GRAVEL, 0, "Gravel"); | |
| $this->hardness = 3; | |
| } | |
| public function getDrops(Item $item){ | |
| if(mt_rand(1, 10) === 1){ | |
| return array( | |
| array(Item::FLINT, 0, 1), | |
| ); | |
| } | |
| return array( | |
| array(Item::GRAVEL, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class HayBale extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::HAY_BALE, $meta, "Hay Bale"); | |
| $this->hardness = 10; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $faces = array( | |
| 0 => 0, | |
| 1 => 0, | |
| 2 => 0b1000, | |
| 3 => 0b1000, | |
| 4 => 0b0100, | |
| 5 => 0b0100, | |
| ); | |
| $this->meta = ($this->meta & 0x03) | $faces[$face]; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Ice extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::ICE, 0, "Ice"); | |
| $this->hardness = 2.5; | |
| } | |
| public function onBreak(Item $item){ | |
| $this->level->setBlock($this, new Water(), true, false, true); | |
| return true; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.1; | |
| case 4: | |
| return 0.15; | |
| case 3: | |
| return 0.2; | |
| case 2: | |
| return 0.1; | |
| case 1: | |
| return 0.4; | |
| default: | |
| return 0.75; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| return array(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Iron extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::IRON_BLOCK, 0, "Iron Block"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.95; | |
| case 4: | |
| return 1.25; | |
| case 3: | |
| return 1.9; | |
| default: | |
| return 25; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 3){ | |
| return array( | |
| array(Item::IRON_BLOCK, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class IronBars extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::IRON_BARS, 0, "Iron Bars"); | |
| $this->isFullBlock = false; | |
| $this->isSolid = false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class IronDoor extends Door{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::IRON_DOOR_BLOCK, $meta, "Iron Door Block"); | |
| //$this->isActivable = true; | |
| $this->hardness = 25; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.95; | |
| case 4: | |
| return 1.25; | |
| case 3: | |
| return 1.9; | |
| case 2: | |
| return 0.65; | |
| case 1: | |
| return 3.75; | |
| default: | |
| return 25; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::IRON_DOOR, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class IronOre extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::IRON_ORE, 0, "Iron Ore"); | |
| $this->hardness = 15; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| case 3: | |
| return 1.15; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 3){ | |
| return array( | |
| array(Item::IRON_ORE, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class JungleWoodStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::JUNGLE_WOOD_STAIRS, $meta, "Jungle Wood Stairs"); | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Ladder extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::LADDER, $meta, "Ladder"); | |
| $this->isSolid = false; | |
| $this->isFullBlock = false; | |
| $this->hardness = 2; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| if($target->isTransparent === false){ | |
| $faces = array( | |
| 2 => 2, | |
| 3 => 3, | |
| 4 => 4, | |
| 5 => 5, | |
| ); | |
| if(isset($faces[$face])){ | |
| $this->meta = $faces[$face]; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| /*if($this->getSide(0)->getID() === self::AIR){ //Replace with common break method | |
| Server::getInstance()->api->entity->drop($this, Item::get(LADDER, 0, 1)); | |
| $this->level->setBlock($this, new Air(), true, true, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| }*/ | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Lapis extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::LAPIS_BLOCK, 0, "Lapis Block"); | |
| $this->hardness = 15; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| case 3: | |
| return 1.15; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 3){ | |
| return array( | |
| array(Item::LAPIS_BLOCK, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class LapisOre extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::LAPIS_ORE, 0, "Lapis Ore"); | |
| $this->hardness = 15; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.6; | |
| case 4: | |
| return 0.75; | |
| case 3: | |
| return 1.15; | |
| default: | |
| return 15; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 3){ | |
| return array( | |
| array(Item::DYE, 4, mt_rand(4, 8)), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\level\Position; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Lava extends Liquid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::LAVA, $meta, "Lava"); | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $ret = $this->level->setBlock($this, $this, true, false, true); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(clone $this, 40, Level::BLOCK_UPDATE_NORMAL); | |
| return $ret; | |
| } | |
| public function getSourceCount(){ | |
| $count = 0; | |
| for($side = 2; $side <= 5; ++$side){ | |
| if($this->getSide($side) instanceof Lava){ | |
| $b = $this->getSide($side); | |
| $level = $b->meta & 0x07; | |
| if($level == 0x00){ | |
| $count++; | |
| } | |
| } | |
| } | |
| return $count; | |
| } | |
| public function checkWater(){ | |
| for($side = 1; $side <= 5; ++$side){ | |
| $b = $this->getSide($side); | |
| if($b instanceof Water){ | |
| $level = $this->meta & 0x07; | |
| if($level == 0x00){ | |
| $this->level->setBlock($this, new Obsidian(), false, false, true); | |
| }else{ | |
| $this->level->setBlock($this, new Cobblestone(), false, false, true); | |
| } | |
| } | |
| } | |
| } | |
| public function getFrom(){ | |
| for($side = 0; $side <= 5; ++$side){ | |
| $b = $this->getSide($side); | |
| if($b instanceof Lava){ | |
| $tlevel = $b->meta & 0x07; | |
| $level = $this->meta & 0x07; | |
| if(($tlevel + 2) == $level || ($side == 0x01 && $level == 0x01) || ($tlevel == 6 && $level == 7)){ | |
| return $b; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| public function onUpdate($type){ | |
| //return false; | |
| $newId = $this->id; | |
| $level = $this->meta & 0x07; | |
| if($type !== Level::BLOCK_UPDATE_NORMAL){ | |
| return false; | |
| } | |
| if($this->checkWater()){ | |
| return; | |
| } | |
| $falling = $this->meta >> 3; | |
| $down = $this->getSide(0); | |
| $from = $this->getFrom(); | |
| if($from !== null || $level == 0x00){ | |
| if($level !== 0x07){ | |
| if($down instanceof Air || $down instanceof Lava){ | |
| $this->level->setBlock($down, new Lava(0x01), false, false, true); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(new Position($down, 0, 0, $this->level), 40, Level::BLOCK_UPDATE_NORMAL); | |
| }else{ | |
| for($side = 2; $side <= 5; ++$side){ | |
| $b = $this->getSide($side); | |
| if($b instanceof Lava){ | |
| }elseif($b->isFlowable === true){ | |
| $this->level->setBlock($b, new Lava(min($level + 2, 7)), false, false, true); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($b, $this->level), 40, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| } | |
| } | |
| } | |
| }else{ | |
| //Extend Remove for Left Lavas | |
| for($side = 2; $side <= 5; ++$side){ | |
| $sb = $this->getSide($side); | |
| if($sb instanceof Lava){ | |
| $tlevel = $sb->meta & 0x07; | |
| if($tlevel != 0x00){ | |
| for($s = 0; $s <= 5; $s++){ | |
| $ssb = $sb->getSide($s); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($ssb, $this->level), 40, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| $this->level->setBlock($sb, new Air(), false, false, true); | |
| } | |
| } | |
| $b = $this->getSide(0)->getSide($side); | |
| if($b instanceof Lava){ | |
| $tlevel = $b->meta & 0x07; | |
| if($tlevel != 0x00){ | |
| for($s = 0; $s <= 5; $s++){ | |
| $ssb = $sb->getSide($s); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($ssb, $this->level), 40, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| $this->level->setBlock($b, new Air(), false, false, true); | |
| } | |
| } | |
| //Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($b, $this->level), 10, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| } | |
| return false; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Leaves extends Transparent{ | |
| const OAK = 0; | |
| const SPRUCE = 1; | |
| const BIRCH = 2; | |
| const JUNGLE = 3; | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::LEAVES, $meta, "Leaves"); | |
| $names = array( | |
| self::OAK => "Oak Leaves", | |
| self::SPRUCE => "Spruce Leaves", | |
| self::BIRCH => "Birch Leaves", | |
| self::JUNGLE => "Jungle Leaves", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| $this->hardness = 1; | |
| } | |
| private function findLog(Block $pos, array $visited, $distance, &$check, $fromSide = null){ | |
| ++$check; | |
| $index = $pos->x . "." . $pos->y . "." . $pos->z; | |
| if(isset($visited[$index])){ | |
| return false; | |
| } | |
| if($pos->getID() === self::WOOD){ | |
| return true; | |
| }elseif($pos->getID() === self::LEAVES and $distance < 3){ | |
| $visited[$index] = true; | |
| $down = $pos->getSide(0)->getID(); | |
| if($down === Item::WOOD){ | |
| return true; | |
| } | |
| if($fromSide === null){ | |
| for($side = 2; $side <= 5; ++$side){ | |
| if($this->findLog($pos->getSide($side), $visited, $distance + 1, $check, $side) === true){ | |
| return true; | |
| } | |
| } | |
| }else{ //No more loops | |
| switch($fromSide){ | |
| case 2: | |
| if($this->findLog($pos->getSide(2), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(4), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(5), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| } | |
| break; | |
| case 3: | |
| if($this->findLog($pos->getSide(3), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(4), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(5), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| } | |
| break; | |
| case 4: | |
| if($this->findLog($pos->getSide(2), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(3), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(4), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| } | |
| break; | |
| case 5: | |
| if($this->findLog($pos->getSide(2), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(3), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| }elseif($this->findLog($pos->getSide(5), $visited, $distance + 1, $check, $fromSide) === true){ | |
| return true; | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if(($this->meta & 0b00001100) === 0){ | |
| $this->meta |= 0x08; | |
| $this->level->setBlock($this, $this, false, false, true); | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if(($this->meta & 0b00001100) === 0x08){ | |
| $this->meta &= 0x03; | |
| $visited = array(); | |
| $check = 0; | |
| if($this->findLog($this, $visited, 0, $check) === true){ | |
| $this->level->setBlock($this, $this, false, false, true); | |
| }else{ | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| if(mt_rand(1, 20) === 1){ //Saplings | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(Item::SAPLING, $this->meta & 0x03, 1)); | |
| } | |
| if(($this->meta & 0x03) === self::OAK and mt_rand(1, 200) === 1){ //Apples | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(Item::APPLE, 0, 1)); | |
| } | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $this->meta |= 0x04; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array(); | |
| if($item->isShears()){ | |
| $drops[] = array(Item::LEAVES, $this->meta & 0x03, 1); | |
| }else{ | |
| if(mt_rand(1, 20) === 1){ //Saplings | |
| $drops[] = array(Item::SAPLING, $this->meta & 0x03, 1); | |
| } | |
| if(($this->meta & 0x03) === self::OAK and mt_rand(1, 200) === 1){ //Apples | |
| $drops[] = array(Item::APPLE, 0, 1); | |
| } | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Liquid extends Transparent{ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| $this->isLiquid = true; | |
| $this->breakable = false; | |
| $this->isReplaceable = true; | |
| $this->isSolid = false; | |
| $this->isFullBlock = true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class LitPumpkin extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::LIT_PUMPKIN, "Jack o'Lantern"); | |
| $this->hardness = 5; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $faces = array( | |
| 0 => 4, | |
| 1 => 2, | |
| 2 => 5, | |
| 3 => 3, | |
| ); | |
| $this->meta = $faces[$player->getDirection()]; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Melon extends Transparent{ | |
| public function __construct(){ | |
| parent::__construct(self::MELON_BLOCK, 0, "Melon Block"); | |
| $this->hardness = 5; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::MELON_SLICE, 0, mt_rand(3, 7)), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class MelonStem extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::MELON_STEM, $meta, "Melon Stem"); | |
| $this->isActivable = true; | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::FARMLAND){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(MELON_SEEDS, 0, mt_rand(0, 2))); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if(mt_rand(0, 2) == 1){ | |
| if($this->meta < 0x07){ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| }else{ | |
| for($side = 2; $side <= 5; ++$side){ | |
| $b = $this->getSide($side); | |
| if($b->getID() === self::MELON_BLOCK){ | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| $side = $this->getSide(mt_rand(2, 5)); | |
| $d = $side->getSide(0); | |
| if($side->getID() === self::AIR and ($d->getID() === self::FARMLAND or $d->getID() === self::GRASS or $d->getID() === self::DIRT)){ | |
| $this->level->setBlock($side, new Melon(), true, false, true); | |
| } | |
| } | |
| } | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| $this->meta = 0x07; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $item->count--; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::MELON_SEEDS, 0, mt_rand(0, 2)), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class MossStone extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::MOSS_STONE, $meta, "Moss Stone"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 10; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::MOSS_STONE, $this->meta, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class NetherBrick extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::NETHER_BRICKS, 0, "Nether Bricks"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 10; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::NETHER_BRICKS, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class NetherBrickStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::NETHER_BRICKS_STAIRS, $meta, "Nether Bricks Stairs"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Netherrack extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::NETHERRACK, 0, "Netherrack"); | |
| $this->hardness = 2; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.1; | |
| case 4: | |
| return 0.1; | |
| case 3: | |
| return 0.15; | |
| case 2: | |
| return 0.05; | |
| case 1: | |
| return 0.3; | |
| default: | |
| return 2; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::NETHERRACK, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class NetherReactor extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::NETHER_REACTOR, $meta, "Nether Reactor"); | |
| $this->isActivable = true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Obsidian extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::OBSIDIAN, 0, "Obsidian"); | |
| $this->hardness = 6000; | |
| } | |
| public function getBreakTime(Item $item){ | |
| if($item->isPickaxe() >= 5){ | |
| return 9.4; | |
| }else{ | |
| return 250; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 5){ | |
| return array( | |
| array(Item::OBSIDIAN, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Planks extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::PLANKS, $meta, "Wooden Planks"); | |
| $names = array( | |
| Wood::OAK => "Oak Wooden Planks", | |
| Wood::SPRUCE => "Spruce Wooden Planks", | |
| Wood::BIRCH => "Birch Wooden Planks", | |
| Wood::JUNGLE => "Jungle Wooden Planks", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| $this->hardness = 15; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Potato extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::POTATO_BLOCK, $meta, "Potato Block"); | |
| $this->isActivable = true; | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::FARMLAND){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| $this->meta = 0x07; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $item->count--; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(POTATO, 0, 1)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if(mt_rand(0, 2) == 1){ | |
| if($this->meta < 0x07){ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| }else{ | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array(); | |
| if($this->meta >= 0x07){ | |
| $drops[] = array(Item::POTATO, 0, mt_rand(1, 4)); | |
| }else{ | |
| $drops[] = array(Item::POTATO, 0, 1); | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Pumpkin extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::PUMPKIN, "Pumpkin"); | |
| $this->hardness = 5; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class PumpkinStem extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::PUMPKIN_STEM, $meta, "Pumpkin Stem"); | |
| $this->isActivable = true; | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::FARMLAND){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(PUMPKIN_SEEDS, 0, mt_rand(0, 2))); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if(mt_rand(0, 2) == 1){ | |
| if($this->meta < 0x07){ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| }else{ | |
| for($side = 2; $side <= 5; ++$side){ | |
| $b = $this->getSide($side); | |
| if($b->getID() === self::PUMPKIN){ | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| $side = $this->getSide(mt_rand(2, 5)); | |
| $d = $side->getSide(0); | |
| if($side->getID() === self::AIR and ($d->getID() === self::FARMLAND or $d->getID() === self::GRASS or $d->getID() === self::DIRT)){ | |
| $this->level->setBlock($side, new Pumpkin(), true, false, true); | |
| } | |
| } | |
| } | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| $this->meta = 0x07; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $item->count--; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::PUMPKIN_SEEDS, 0, mt_rand(0, 2)), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Quartz extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::QUARTZ_BLOCK, $meta, "Quartz Block"); | |
| $names = array( | |
| 0 => "Quartz Block", | |
| 1 => "Chiseled Quartz Block", | |
| 2 => "Quartz Pillar", | |
| 3 => "Quartz Pillar", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.15; | |
| case 4: | |
| return 0.2; | |
| case 3: | |
| return 0.3; | |
| case 2: | |
| return 0.1; | |
| case 1: | |
| return 0.6; | |
| default: | |
| return 4; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::QUARTZ_BLOCK, $this->meta & 0x03, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class QuartzStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::QUARTZ_STAIRS, $meta, "Quartz Stairs"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class RedMushroom extends Flowable{ | |
| public function __construct(){ | |
| parent::__construct(self::RED_MUSHROOM, 0, "Red Mushroom"); | |
| $this->hardness = 0; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get($this->id)); | |
| $this->level->setBlock($this, new Air(), false); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->isTransparent === false){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| class RedstoneOre extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::REDSTONE_ORE, 0, "Redstone Ore"); | |
| $this->hardness = 15; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL or $type === Level::BLOCK_UPDATE_TOUCH){ | |
| $this->level->setBlock($this, Block::get(Item::GLOWING_REDSTONE_ORE, $this->meta), false, false, true); | |
| return Level::BLOCK_UPDATE_WEAK; | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 2){ | |
| return array( | |
| array(Item::REDSTONE_DUST, 0, mt_rand(4, 5)), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Sand extends Fallable{ | |
| public function __construct(){ | |
| parent::__construct(self::SAND, 0, "Sand"); | |
| $this->hardness = 2.5; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Sandstone extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::SANDSTONE, $meta, "Sandstone"); | |
| $names = array( | |
| 0 => "Sandstone", | |
| 1 => "Chiseled Sandstone", | |
| 2 => "Smooth Sandstone", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| $this->hardness = 4; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.15; | |
| case 4: | |
| return 0.2; | |
| case 3: | |
| return 0.3; | |
| case 2: | |
| return 0.1; | |
| case 1: | |
| return 0.6; | |
| default: | |
| return 4; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::SANDSTONE, $this->meta & 0x03, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class SandstoneStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::SANDSTONE_STAIRS, $meta, "Sandstone Stairs"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\generator\object\Tree; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| use pocketmine\utils\Random; | |
| class Sapling extends Flowable{ | |
| const OAK = 0; | |
| const SPRUCE = 1; | |
| const BIRCH = 2; | |
| const JUNGLE = 3; | |
| const BURN_TIME = 5; | |
| public function __construct($meta = Sapling::OAK){ | |
| parent::__construct(self::SAPLING, $meta, "Sapling"); | |
| $this->isActivable = true; | |
| $names = array( | |
| 0 => "Oak Sapling", | |
| 1 => "Spruce Sapling", | |
| 2 => "Birch Sapling", | |
| 3 => "Jungle Sapling", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::GRASS or $down->getID() === self::DIRT or $down->getID() === self::FARMLAND){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| Tree::growTree($this->level, $this, new Random(mt_rand()), $this->meta & 0x03); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $item->count--; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get($this->id)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ //Growth | |
| if(mt_rand(1, 7) === 1){ | |
| if(($this->meta & 0x08) === 0x08){ | |
| Tree::growTree($this->level, $this, new Random(mt_rand()), $this->meta & 0x03); | |
| }else{ | |
| $this->meta |= 0x08; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| }else{ | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, $this->meta & 0x03, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class SignPost extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::SIGN_POST, $meta, "Sign Post"); | |
| $this->isSolid = false; | |
| $this->isFullBlock = false; | |
| $this->hardness = 5; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| if($face !== 0){ | |
| $faces = array( | |
| 2 => 2, | |
| 3 => 3, | |
| 4 => 4, | |
| 5 => 5, | |
| ); | |
| if(!isset($faces[$face])){ | |
| $this->meta = floor((($player->yaw + 180) * 16 / 360) + 0.5) & 0x0F; | |
| $this->level->setBlock($block, Block::get(Item::SIGN_POST, $this->meta), true, false, true); | |
| return true; | |
| }else{ | |
| $this->meta = $faces[$face]; | |
| $this->level->setBlock($block, Block::get(Item::WALL_SIGN, $this->meta), true, false, true); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->getID() === self::AIR){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(SIGN, 0, 1)); | |
| $this->level->setBlock($this, new Air(), true, true, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function onBreak(Item $item){ | |
| $this->level->setBlock($this, new Air(), true, true, true); | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::SIGN, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Slab extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::SLAB, $meta, "Slab"); | |
| $names = array( | |
| 0 => "Stone", | |
| 1 => "Sandstone", | |
| 2 => "Wooden", | |
| 3 => "Cobblestone", | |
| 4 => "Brick", | |
| 5 => "Stone Brick", | |
| 6 => "Quartz", | |
| 7 => "", | |
| ); | |
| $this->name = (($this->meta & 0x08) === 0x08 ? "Upper " : "") . $names[$this->meta & 0x07] . " Slab"; | |
| if(($this->meta & 0x08) === 0x08){ | |
| $this->isFullBlock = true; | |
| }else{ | |
| $this->isFullBlock = false; | |
| } | |
| $this->hardness = 30; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $this->meta &= 0x07; | |
| if($face === 0){ | |
| if($target->getID() === self::SLAB and ($target->getMetadata() & 0x08) === 0x08 and ($target->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($target, Block::get(Item::DOUBLE_SLAB, $this->meta), true, false, true); | |
| return true; | |
| }elseif($block->getID() === self::SLAB and ($block->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($block, Block::get(Item::DOUBLE_SLAB, $this->meta), true, false, true); | |
| return true; | |
| }else{ | |
| $this->meta |= 0x08; | |
| } | |
| }elseif($face === 1){ | |
| if($target->getID() === self::SLAB and ($target->getMetadata() & 0x08) === 0 and ($target->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($target, Block::get(Item::DOUBLE_SLAB, $this->meta), true, false, true); | |
| return true; | |
| }elseif($block->getID() === self::SLAB and ($block->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($block, Block::get(Item::DOUBLE_SLAB, $this->meta), true, false, true); | |
| return true; | |
| } | |
| }elseif(!($player instanceof Player) or !$player->inBlock($block)){ | |
| if($block->getID() === self::SLAB){ | |
| if(($block->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($block, Block::get(Item::DOUBLE_SLAB, $this->meta), true, false, true); | |
| return true; | |
| } | |
| return false; | |
| }else{ | |
| if($fy > 0.5){ | |
| $this->meta |= 0x08; | |
| } | |
| } | |
| }else{ | |
| return false; | |
| } | |
| if($block->getID() === self::SLAB and ($target->getMetadata() & 0x07) !== ($this->meta & 0x07)){ | |
| return false; | |
| } | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 10; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array($this->id, $this->meta & 0x07, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Snow extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::SNOW_BLOCK, 0, "Snow Block"); | |
| $this->hardness = 1; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class SnowLayer extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::SNOW_LAYER, $meta, "Snow Layer"); | |
| $this->isReplaceable = true; | |
| $this->isSolid = false; | |
| $this->isFullBlock = false; | |
| $this->hardness = 0.5; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down instanceof Solid){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->getID() === self::AIR){ //Replace with common break method | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isShovel() !== false){ | |
| return array( | |
| array(Item::SNOWBALL, 0, 1), | |
| ); | |
| } | |
| return array(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Solid extends Generic{ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| $this->isSolid = true; | |
| $this->isFullBlock = true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class SoulSand extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::SOUL_SAND, 0, "Soul Sand"); | |
| $this->hardness = 2.5; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Sponge extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::SPONGE, "Sponge"); | |
| $this->hardness = 3; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class SpruceWoodStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::SPRUCE_WOOD_STAIRS, $meta, "Spruce Wood Stairs"); | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Stair extends Transparent{ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| if(($this->meta & 0x04) === 0x04){ | |
| $this->isFullBlock = true; | |
| }else{ | |
| $this->isFullBlock = false; | |
| } | |
| $this->hardness = 30; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $faces = array( | |
| 0 => 0, | |
| 1 => 2, | |
| 2 => 1, | |
| 3 => 3, | |
| ); | |
| $this->meta = $faces[$player->getDirection()] & 0x03; | |
| if(($fy > 0.5 and $face !== 1) or $face === 0){ | |
| $this->meta |= 0x04; //Upside-down stairs | |
| } | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class StillLava extends Liquid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::STILL_LAVA, $meta, "Still Lava"); | |
| $this->hardness = 500; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class StillWater extends Water{ | |
| public function __construct($meta = 0){ | |
| Liquid::__construct(self::STILL_WATER, $meta, "Still Water"); | |
| $this->hardness = 500; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class Stone extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::STONE, 0, "Stone"); | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 7.5; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::COBBLESTONE, 0, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class StoneBricks extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::STONE_BRICKS, $meta, "Stone Bricks"); | |
| $names = array( | |
| 0 => "Stone Bricks", | |
| 1 => "Mossy Stone Bricks", | |
| 2 => "Cracked Stone Bricks", | |
| 3 => "Chiseled Stone Bricks", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| $this->hardness = 30; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isPickaxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 7.5; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| if($item->isPickaxe() >= 1){ | |
| return array( | |
| array(Item::STONE_BRICKS, $this->meta & 0x03, 1), | |
| ); | |
| }else{ | |
| return array(); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class StoneBrickStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::STONE_BRICK_STAIRS, $meta, "Stone Brick Stairs"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Stonecutter extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::STONECUTTER, $meta, "Stonecutter"); | |
| $this->isActivable = true; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| $player->toCraft[-1] = 2; | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class StoneWall extends Transparent{ | |
| public function __construct($meta = 0){ | |
| $meta &= 0x01; | |
| parent::__construct(self::STONE_WALL, $meta, "Cobblestone Wall"); | |
| if($meta === 1){ | |
| $this->name = "Mossy Cobblestone Wall"; | |
| } | |
| $this->isFullBlock = false; | |
| $this->isSolid = false; | |
| $this->hardness = 30; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\Player; | |
| class Sugarcane extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::SUGARCANE_BLOCK, $meta, "Sugarcane"); | |
| $this->hardness = 0; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::SUGARCANE, 0, 1), | |
| ); | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| if($this->getSide(0)->getID() !== self::SUGARCANE_BLOCK){ | |
| for($y = 1; $y < 3; ++$y){ | |
| $b = $this->level->getBlock(new Vector3($this->x, $this->y + $y, $this->z)); | |
| if($b->getID() === self::AIR){ | |
| $this->level->setBlock($b, new Sugarcane(), true, false, true); | |
| break; | |
| } | |
| } | |
| $this->meta = 0; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| } | |
| if(($player->gamemode & 0x01) === 0){ | |
| $item->count--; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| $down = $this->getSide(0); | |
| if($down->isTransparent === true and $down->getID() !== self::SUGARCANE_BLOCK){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(SUGARCANE)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if($this->getSide(0)->getID() !== self::SUGARCANE_BLOCK){ | |
| if($this->meta === 0x0F){ | |
| for($y = 1; $y < 3; ++$y){ | |
| $b = $this->level->getBlock(new Vector3($this->x, $this->y + $y, $this->z)); | |
| if($b->getID() === self::AIR){ | |
| $this->level->setBlock($b, new Sugarcane(), true, false, true); | |
| break; | |
| } | |
| } | |
| $this->meta = 0; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| }else{ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| } | |
| return Level::BLOCK_UPDATE_RANDOM; | |
| } | |
| } | |
| return false; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::SUGARCANE_BLOCK){ | |
| $this->level->setBlock($block, new Sugarcane(), true, false, true); | |
| return true; | |
| }elseif($down->getID() === self::GRASS or $down->getID() === self::DIRT or $down->getID() === self::SAND){ | |
| $block0 = $down->getSide(2); | |
| $block1 = $down->getSide(3); | |
| $block2 = $down->getSide(4); | |
| $block3 = $down->getSide(5); | |
| if(($block0 instanceof Water) or ($block1 instanceof Water) or ($block2 instanceof Water) or ($block3 instanceof Water)){ | |
| $this->level->setBlock($block, new Sugarcane(), true, false, true); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| class TallGrass extends Flowable{ | |
| public function __construct($meta = 1){ | |
| parent::__construct(self::TALL_GRASS, $meta, "Tall Grass"); | |
| $this->isReplaceable = true; | |
| $names = array( | |
| 0 => "Dead Shrub", | |
| 1 => "Tall Grass", | |
| 2 => "Fern", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| $this->hardness = 0; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array(); | |
| $possibleDrops = array( | |
| array(Item::WHEAT_SEEDS, 0, 1), | |
| array(Item::CARROT, 0, 1), | |
| array(Item::POTATO, 0, 1), | |
| array(Item::BEETROOT_SEEDS, 0, 1), | |
| array(Item::MELON_SEEDS, 0, 1), | |
| array(Item::PUMPKIN_SEEDS, 0, 1), | |
| 0, | |
| 0, | |
| 0, | |
| 0, | |
| 0, | |
| 0, | |
| 0, | |
| 0, | |
| ); | |
| if(($item = $possibleDrops[mt_rand(0, count($possibleDrops) - 1)]) !== 0){ | |
| $drops[] = $item; | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class TNT extends Solid{ | |
| public function __construct(){ | |
| parent::__construct(self::TNT, 0, "TNT"); | |
| $this->hardness = 0; | |
| $this->isActivable = true; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::FLINT_STEEL){ | |
| if(($player->gamemode & 0x01) === 0){ | |
| $item->useOn($this); | |
| } | |
| $data = array( | |
| "x" => $this->x + 0.5, | |
| "y" => $this->y + 0.5, | |
| "z" => $this->z + 0.5, | |
| "power" => 4, | |
| "fuse" => 20 * 4, //4 seconds | |
| ); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| //TODO | |
| //$e = Server::getInstance()->api->entity->add($this->level, ENTITY_OBJECT, OBJECT_PRIMEDTNT, $data); | |
| //$e->spawnToAll(); | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Torch extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::TORCH, $meta, "Torch"); | |
| $this->hardness = 0; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| $side = $this->getMetadata(); | |
| $faces = array( | |
| 1 => 4, | |
| 2 => 5, | |
| 3 => 2, | |
| 4 => 3, | |
| 5 => 0, | |
| 6 => 0, | |
| 0 => 0, | |
| ); | |
| if($this->getSide($faces[$side])->isTransparent === true and !($side === 0 and $this->getSide(0)->getID() === self::FENCE)){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get($this->id, 0, 1)); | |
| $this->level->setBlock($this, new Air(), true, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| } | |
| return false; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| if($target->isTransparent === false and $face !== 0){ | |
| $faces = array( | |
| 1 => 5, | |
| 2 => 4, | |
| 3 => 3, | |
| 4 => 2, | |
| 5 => 1, | |
| ); | |
| $this->meta = $faces[$face]; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| }elseif($this->getSide(0)->isTransparent === false or $this->getSide(0)->getID() === self::FENCE){ | |
| $this->meta = 0; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Transparent extends Generic{ | |
| public function __construct($id, $meta = 0, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $name); | |
| $this->isActivable = false; | |
| $this->breakable = true; | |
| $this->isFlowable = false; | |
| $this->isTransparent = true; | |
| $this->isReplaceable = false; | |
| $this->isPlaceable = true; | |
| $this->isSolid = true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Trapdoor extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::TRAPDOOR, $meta, "Trapdoor"); | |
| $this->isActivable = true; | |
| if(($this->meta & 0x04) === 0x04){ | |
| $this->isFullBlock = false; | |
| }else{ | |
| $this->isFullBlock = true; | |
| } | |
| $this->hardness = 15; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| if(($target->isTransparent === false or $target->getID() === self::SLAB) and $face !== 0 and $face !== 1){ | |
| $faces = array( | |
| 2 => 0, | |
| 3 => 1, | |
| 4 => 2, | |
| 5 => 3, | |
| ); | |
| $this->meta = $faces[$face] & 0x03; | |
| if($fy > 0.5){ | |
| $this->meta |= 0x08; | |
| } | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| $this->meta ^= 0x04; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class WallSign extends SignPost{ | |
| public function __construct($meta = 0){ | |
| Transparent::__construct(self::WALL_SIGN, $meta, "Wall Sign"); | |
| } | |
| public function onUpdate($type){ | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\level\Position; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Water extends Liquid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WATER, $meta, "Water"); | |
| $this->hardness = 500; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $ret = $this->level->setBlock($this, $this, true, false, true); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(clone $this, 10, Level::BLOCK_UPDATE_NORMAL); | |
| return $ret; | |
| } | |
| public function getSourceCount(){ | |
| $count = 0; | |
| for($side = 2; $side <= 5; ++$side){ | |
| if($this->getSide($side) instanceof Water){ | |
| $b = $this->getSide($side); | |
| $level = $b->meta & 0x07; | |
| if($level == 0x00){ | |
| $count++; | |
| } | |
| } | |
| } | |
| return $count; | |
| } | |
| public function checkLava(){ | |
| for($side = 0; $side <= 5; ++$side){ | |
| if($side == 1){ | |
| continue; | |
| } | |
| $b = $this->getSide($side); | |
| if($b instanceof Lava){ | |
| $level = $b->meta & 0x07; | |
| if($level == 0x00){ | |
| $this->level->setBlock($b, new Obsidian(), false, false, true); | |
| }else{ | |
| $this->level->setBlock($b, new Cobblestone(), false, false, true); | |
| } | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| public function getFrom(){ | |
| for($side = 0; $side <= 5; ++$side){ | |
| $b = $this->getSide($side); | |
| if($b instanceof Water){ | |
| $tlevel = $b->meta & 0x07; | |
| $level = $this->meta & 0x07; | |
| if(($tlevel + 1) == $level || ($side == 0x01 && $level == 0x01)){ | |
| return $b; | |
| } | |
| } | |
| } | |
| return null; | |
| } | |
| public function onUpdate($type){ | |
| //return false; | |
| $newId = $this->id; | |
| $level = $this->meta & 0x07; | |
| if($type !== Level::BLOCK_UPDATE_NORMAL){ | |
| return false; | |
| } | |
| $this->checkLava(); | |
| $falling = $this->meta >> 3; | |
| $down = $this->getSide(0); | |
| $from = $this->getFrom(); | |
| //Has Source or Its Source | |
| if($from !== null || $level == 0x00){ | |
| if($level !== 0x07){ | |
| if($down instanceof Air || $down instanceof Water){ | |
| $this->level->setBlock($down, new Water(0x01), false, false, true); | |
| //Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($down, $this->level), 10, Level::BLOCK_UPDATE_NORMAL); | |
| }else{ | |
| for($side = 2; $side <= 5; ++$side){ | |
| $b = $this->getSide($side); | |
| if($b instanceof Water){ | |
| if($this->getSourceCount() >= 2 && $level != 0x00){ | |
| $this->level->setBlock($this, new Water(0), false, false, true); | |
| } | |
| }elseif($b->isFlowable === true){ | |
| $this->level->setBlock($b, new Water($level + 1), false, false, true); | |
| //Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($b, $this->level), 10, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| } | |
| } | |
| } | |
| }else{ | |
| //Extend Remove for Left Waters | |
| for($side = 2; $side <= 5; ++$side){ | |
| $sb = $this->getSide($side); | |
| if($sb instanceof Water){ | |
| $tlevel = $sb->meta & 0x07; | |
| if($tlevel != 0x00){ | |
| for($s = 0; $s <= 5; $s++){ | |
| $ssb = $sb->getSide($s); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($ssb, $this->level), 10, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| $this->level->setBlock($sb, new Air(), false, false, true); | |
| } | |
| } | |
| $b = $this->getSide(0)->getSide($side); | |
| if($b instanceof Water){ | |
| $tlevel = $b->meta & 0x07; | |
| if($tlevel != 0x00){ | |
| for($s = 0; $s <= 5; $s++){ | |
| $ssb = $sb->getSide($s); | |
| Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($ssb, $this->level), 10, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| $this->level->setBlock($b, new Air(), false, false, true); | |
| } | |
| } | |
| //Server::getInstance()->api->block->scheduleBlockUpdate(Position::fromObject($b, $this->level), 10, Level::BLOCK_UPDATE_NORMAL); | |
| } | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| } | |
| return false; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Wheat extends Flowable{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WHEAT_BLOCK, $meta, "Wheat Block"); | |
| $this->isActivable = true; | |
| $this->hardness = 0; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $down = $this->getSide(0); | |
| if($down->getID() === self::FARMLAND){ | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| if($item->getID() === Item::DYE and $item->getMetadata() === 0x0F){ //Bonemeal | |
| $this->meta = 0x07; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $item->count--; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function onUpdate($type){ | |
| if($type === Level::BLOCK_UPDATE_NORMAL){ | |
| if($this->getSide(0)->isTransparent === true){ //Replace with common break method | |
| //TODO | |
| //Server::getInstance()->api->entity->drop($this, Item::get(WHEAT_SEEDS, 0, 1)); | |
| $this->level->setBlock($this, new Air(), false, false, true); | |
| return Level::BLOCK_UPDATE_NORMAL; | |
| } | |
| }elseif($type === Level::BLOCK_UPDATE_RANDOM){ | |
| if(mt_rand(0, 2) == 1){ | |
| if($this->meta < 0x07){ | |
| ++$this->meta; | |
| $this->level->setBlock($this, $this, true, false, true); | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| public function getDrops(Item $item){ | |
| $drops = array(); | |
| if($this->meta >= 0x07){ | |
| $drops[] = array(Item::WHEAT, 0, 1); | |
| $drops[] = array(Item::WHEAT_SEEDS, 0, mt_rand(0, 3)); | |
| }else{ | |
| $drops[] = array(Item::WHEAT_SEEDS, 0, 1); | |
| } | |
| return $drops; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Wood extends Solid{ | |
| const OAK = 0; | |
| const SPRUCE = 1; | |
| const BIRCH = 2; | |
| const JUNGLE = 3; | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WOOD, $meta, "Wood"); | |
| $names = array( | |
| self::OAK => "Oak Wood", | |
| self::SPRUCE => "Spruce Wood", | |
| self::BIRCH => "Birch Wood", | |
| self::JUNGLE => "Jungle Wood", | |
| ); | |
| $this->name = $names[$this->meta & 0x03]; | |
| $this->hardness = 10; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $faces = array( | |
| 0 => 0, | |
| 1 => 0, | |
| 2 => 0b1000, | |
| 3 => 0b1000, | |
| 4 => 0b0100, | |
| 5 => 0b0100, | |
| ); | |
| $this->meta = ($this->meta & 0x03) | $faces[$face]; | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, $this->meta & 0x03, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class WoodDoor extends Door{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WOOD_DOOR_BLOCK, $meta, "Wood Door Block"); | |
| $this->isActivable = true; | |
| $this->hardness = 15; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array(Item::WOODEN_DOOR, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class WoodSlab extends Transparent{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WOOD_SLAB, $meta, "Wooden Slab"); | |
| $names = array( | |
| 0 => "Oak", | |
| 1 => "Spruce", | |
| 2 => "Birch", | |
| 3 => "Jungle", | |
| ); | |
| $this->name = (($this->meta & 0x08) === 0x08 ? "Upper " : "") . $names[$this->meta & 0x07] . " Wooden Slab"; | |
| if(($this->meta & 0x08) === 0x08){ | |
| $this->isFullBlock = true; | |
| }else{ | |
| $this->isFullBlock = false; | |
| } | |
| $this->hardness = 15; | |
| } | |
| public function place(Item $item, Block $block, Block $target, $face, $fx, $fy, $fz, Player $player = null){ | |
| $this->meta &= 0x07; | |
| if($face === 0){ | |
| if($target->getID() === self::WOOD_SLAB and ($target->getMetadata() & 0x08) === 0x08 and ($target->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($target, Block::get(Item::DOUBLE_WOOD_SLAB, $this->meta), true, false, true); | |
| return true; | |
| }elseif($block->getID() === self::WOOD_SLAB and ($block->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($block, Block::get(Item::DOUBLE_WOOD_SLAB, $this->meta), true, false, true); | |
| return true; | |
| }else{ | |
| $this->meta |= 0x08; | |
| } | |
| }elseif($face === 1){ | |
| if($target->getID() === self::WOOD_SLAB and ($target->getMetadata() & 0x08) === 0 and ($target->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($target, Block::get(Item::DOUBLE_WOOD_SLAB, $this->meta), true, false, true); | |
| return true; | |
| }elseif($block->getID() === self::WOOD_SLAB and ($block->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($block, Block::get(Item::DOUBLE_WOOD_SLAB, $this->meta), true, false, true); | |
| return true; | |
| } | |
| }elseif(!($player instanceof Player) or !$player->inBlock($block)){ | |
| if($block->getID() === self::WOOD_SLAB){ | |
| if(($block->getMetadata() & 0x07) === ($this->meta & 0x07)){ | |
| $this->level->setBlock($block, Block::get(Item::DOUBLE_WOOD_SLAB, $this->meta), true, false, true); | |
| return true; | |
| } | |
| return false; | |
| }else{ | |
| if($fy > 0.5){ | |
| $this->meta |= 0x08; | |
| } | |
| } | |
| }else{ | |
| return false; | |
| } | |
| if($block->getID() === self::WOOD_SLAB and ($target->getMetadata() & 0x07) !== ($this->meta & 0x07)){ | |
| return false; | |
| } | |
| $this->level->setBlock($block, $this, true, false, true); | |
| return true; | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isAxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 3; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, $this->meta & 0x07, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| class WoodStairs extends Stair{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WOOD_STAIRS, $meta, "Wood Stairs"); | |
| } | |
| public function getBreakTime(Item $item){ | |
| switch($item->isAxe()){ | |
| case 5: | |
| return 0.4; | |
| case 4: | |
| return 0.5; | |
| case 3: | |
| return 0.75; | |
| case 2: | |
| return 0.25; | |
| case 1: | |
| return 1.5; | |
| default: | |
| return 3; | |
| } | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| class Wool extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WOOL, $meta, "Wool"); | |
| $names = array( | |
| 0 => "White Wool", | |
| 1 => "Orange Wool", | |
| 2 => "Magenta Wool", | |
| 3 => "Light Blue Wool", | |
| 4 => "Yellow Wool", | |
| 5 => "Lime Wool", | |
| 6 => "Pink Wool", | |
| 7 => "Gray Wool", | |
| 8 => "Light Gray Wool", | |
| 9 => "Cyan Wool", | |
| 10 => "Purple Wool", | |
| 11 => "Blue Wool", | |
| 12 => "Brown Wool", | |
| 13 => "Green Wool", | |
| 14 => "Red Wool", | |
| 15 => "Black Wool", | |
| ); | |
| $this->name = $names[$this->meta]; | |
| $this->hardness = 4; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\block; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class Workbench extends Solid{ | |
| public function __construct($meta = 0){ | |
| parent::__construct(self::WORKBENCH, $meta, "Crafting Table"); | |
| $this->isActivable = true; | |
| $this->hardness = 15; | |
| } | |
| public function onActivate(Item $item, Player $player = null){ | |
| $player->toCraft[-1] = 1; | |
| return true; | |
| } | |
| public function getDrops(Item $item){ | |
| return array( | |
| array($this->id, 0, 1), | |
| ); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Command handling related classes | |
| */ | |
| namespace pocketmine\command; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| abstract class Command{ | |
| /** @var string */ | |
| private $name; | |
| /** @var string */ | |
| private $nextLabel; | |
| /** @var string */ | |
| private $label; | |
| /** | |
| * @var string[] | |
| */ | |
| private $aliases = array(); | |
| /** | |
| * @var string[] | |
| */ | |
| private $activeAliases = array(); | |
| /** @var CommandMap */ | |
| private $commandMap = null; | |
| /** @var string */ | |
| protected $description = ""; | |
| /** @var string */ | |
| protected $usageMessage; | |
| /** @var string */ | |
| private $permission = null; | |
| /** @var string */ | |
| private $permissionMessage = null; | |
| /** | |
| * @param string $name | |
| * @param string $description | |
| * @param string $usageMessage | |
| * @param string[] $aliases | |
| */ | |
| public function __construct($name, $description = "", $usageMessage = null, array $aliases = array()){ | |
| $this->name = $name; | |
| $this->nextLabel = $name; | |
| $this->label = $name; | |
| $this->description = $description; | |
| $this->usageMessage = $usageMessage === null ? "/" . $name : $usageMessage; | |
| $this->aliases = $aliases; | |
| $this->activeAliases = (array) $aliases; | |
| } | |
| /** | |
| * @param CommandSender $sender | |
| * @param string $commandLabel | |
| * @param string[] $args | |
| * | |
| * @return mixed | |
| */ | |
| public abstract function execute(CommandSender $sender, $commandLabel, array $args); | |
| /** | |
| * @return string | |
| */ | |
| public function getName(){ | |
| return $this->name; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getPermission(){ | |
| return $this->permission; | |
| } | |
| /** | |
| * @param string|null $permission | |
| */ | |
| public function setPermission($permission){ | |
| $this->permission = $permission; | |
| } | |
| /** | |
| * @param CommandSender $target | |
| * | |
| * @return bool | |
| */ | |
| public function testPermission(CommandSender $target){ | |
| if($this->testPermissionSilent($target)){ | |
| return true; | |
| } | |
| if($this->permissionMessage === null){ | |
| $target->sendMessage(TextFormat::RED . "You don't have permissions to use this command."); | |
| }elseif($this->permissionMessage !== ""){ | |
| $target->sendMessage(str_replace("<permission>", $this->permission, $this->permissionMessage)); | |
| } | |
| return false; | |
| } | |
| /** | |
| * @param CommandSender $target | |
| * | |
| * @return bool | |
| */ | |
| public function testPermissionSilent(CommandSender $target){ | |
| if($this->permission === null or $this->permission === ""){ | |
| return true; | |
| } | |
| foreach(explode(";", $this->permission) as $permission){ | |
| if($target->hasPermission($permission)){ | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getLabel(){ | |
| return $this->label; | |
| } | |
| public function setLabel($name){ | |
| $this->nextLabel = $name; | |
| if(!$this->isRegistered()){ | |
| $this->label = $name; | |
| return true; | |
| } | |
| return false; | |
| } | |
| /** | |
| * Registers the command into a Command map | |
| * | |
| * @param CommandMap $commandMap | |
| * | |
| * @return bool | |
| */ | |
| public function register(CommandMap $commandMap){ | |
| if($this->allowChangesFrom($commandMap)){ | |
| $this->commandMap = $commandMap; | |
| return true; | |
| } | |
| return false; | |
| } | |
| /** | |
| * @param CommandMap $commandMap | |
| * | |
| * @return bool | |
| */ | |
| public function unregister(CommandMap $commandMap){ | |
| if($this->allowChangesFrom($commandMap)){ | |
| $this->commandMap = null; | |
| $this->activeAliases = $this->aliases; | |
| $this->label = $this->nextLabel; | |
| return true; | |
| } | |
| return false; | |
| } | |
| /** | |
| * @param CommandMap $commandMap | |
| * | |
| * @return bool | |
| */ | |
| private function allowChangesFrom(CommandMap $commandMap){ | |
| return $this->commandMap === null or $this->commandMap === $commandMap; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isRegistered(){ | |
| return $this->commandMap !== null; | |
| } | |
| /** | |
| * @return string[] | |
| */ | |
| public function getAliases(){ | |
| return $this->activeAliases; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getPermissionMessage(){ | |
| return $this->permissionMessage; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getDescription(){ | |
| return $this->description; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getUsage(){ | |
| return $this->usageMessage; | |
| } | |
| /** | |
| * @param string[] $aliases | |
| */ | |
| public function setAliases(array $aliases){ | |
| $this->aliases = $aliases; | |
| if(!$this->isRegistered()){ | |
| $this->activeAliases = (array) $aliases; | |
| } | |
| } | |
| /** | |
| * @param string $description | |
| */ | |
| public function setDescription($description){ | |
| $this->description = $description; | |
| } | |
| /** | |
| * @param string $permissionMessage | |
| */ | |
| public function setPermissionMessage($permissionMessage){ | |
| $this->permissionMessage = $permissionMessage; | |
| } | |
| /** | |
| * @param string $usage | |
| */ | |
| public function setUsage($usage){ | |
| $this->usageMessage = $usage; | |
| } | |
| /** | |
| * TODO: static::broadcastCommandMessage() | |
| * | |
| * @param CommandSender $source | |
| * @param string $message | |
| * @param bool $sendToSource | |
| */ | |
| public static function broadcastCommandMessage(CommandSender $source, $message, $sendToSource = true){ | |
| $result = $source->getName() . ": " . $message; | |
| //Command minecarts or command blocks are not implemented | |
| $users = Server::getInstance()->getPluginManager()->getPermissionSubscriptions(Server::BROADCAST_CHANNEL_ADMINISTRATIVE); | |
| $colored = TextFormat::GRAY . TextFormat::ITALIC . "[$result" . TextFormat::GRAY . TextFormat::ITALIC . "]"; | |
| if($sendToSource === true and !($source instanceof ConsoleCommandSender)){ | |
| $source->sendMessage($message); | |
| } | |
| foreach($users as $user){ | |
| if($user instanceof CommandSender){ | |
| if($user instanceof ConsoleCommandSender){ | |
| $user->sendMessage($result); | |
| }elseif($user !== $source){ | |
| $user->sendMessage($colored); | |
| } | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| interface CommandExecutor{ | |
| /** | |
| * @param CommandSender $sender | |
| * @param Command $command | |
| * @param string $label | |
| * @param string[] $args | |
| * | |
| * @return boolean | |
| */ | |
| public function onCommand(CommandSender $sender, Command $command, $label, array $args); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| interface CommandMap{ | |
| /** | |
| * @param string $fallbackPrefix | |
| * @param Command[] $commands | |
| */ | |
| public function registerAll($fallbackPrefix, array $commands); | |
| /** | |
| * @param string $fallbackPrefix | |
| * @param Command $command | |
| * @param string $label | |
| */ | |
| public function register($fallbackPrefix, Command $command, $label = null); | |
| /** | |
| * @param CommandSender $sender | |
| * @param string $cmdLine | |
| * | |
| * @return boolean | |
| */ | |
| public function dispatch(CommandSender $sender, $cmdLine); | |
| /** | |
| * @return void | |
| */ | |
| public function clearCommands(); | |
| /** | |
| * @param string $name | |
| * | |
| * @return Command | |
| */ | |
| public function getCommand($name); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| class CommandReader extends \Thread{ | |
| private $stream; | |
| /** @var resource */ | |
| private $fp; | |
| private $readline; | |
| /** @var \Threaded */ | |
| private $buffer; | |
| /** | |
| * @param string $stream | |
| */ | |
| public function __construct($stream = "php://stdin"){ | |
| $this->stream = $stream; | |
| $this->start(PTHREADS_INHERIT_ALL & ~PTHREADS_INHERIT_CLASSES); | |
| } | |
| private function readLine(){ | |
| if(!$this->readline){ | |
| $line = trim(fgets($this->fp)); | |
| }else{ | |
| $line = trim(readline("> ")); | |
| if($line != ""){ | |
| readline_add_history($line); | |
| } | |
| } | |
| return $line; | |
| } | |
| /** | |
| * Reads a line from console, if available. Returns null if not available | |
| * | |
| * @return string|null | |
| */ | |
| public function getLine(){ | |
| if($this->buffer->count() !== 0){ | |
| return $this->buffer->synchronized(function (){ | |
| return $this->buffer->shift(); | |
| }); | |
| } | |
| return null; | |
| } | |
| public function run(){ | |
| $this->buffer = new \Threaded; | |
| if(extension_loaded("readline") and $this->stream === "php://stdin"){ | |
| $this->readline = true; | |
| }else{ | |
| $this->readline = false; | |
| $this->fp = fopen($this->stream, "r"); | |
| stream_set_blocking($this->fp, 1); //Non-blocking STDIN won't work on Windows | |
| } | |
| $lastLine = microtime(true); | |
| while(true){ | |
| if(($line = $this->readLine()) !== ""){ | |
| $this->buffer->synchronized(function (\Threaded $buffer, $line){ | |
| $buffer[] = preg_replace("#\\x1b\\x5b([^\\x1b]*\\x7e|[\\x40-\\x50])#", "", $line); | |
| }, $this->buffer, $line); | |
| $lastLine = microtime(true); | |
| }elseif((microtime(true) - $lastLine) <= 0.1){ //Non blocking! Sleep to save CPU | |
| usleep(40000); | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| use pocketmine\permission\Permissible; | |
| interface CommandSender extends Permissible{ | |
| /** | |
| * @param string $message | |
| */ | |
| public function sendMessage($message); | |
| /** | |
| * @return \pocketmine\Server | |
| */ | |
| public function getServer(); | |
| /** | |
| * @return string | |
| */ | |
| public function getName(); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| use pocketmine\permission\PermissibleBase; | |
| use pocketmine\permission\PermissionAttachment; | |
| use pocketmine\plugin\Plugin; | |
| use pocketmine\Server; | |
| class ConsoleCommandSender implements CommandSender{ | |
| private $perm; | |
| public function __construct(){ | |
| $this->perm = new PermissibleBase($this); | |
| } | |
| /** | |
| * @param \pocketmine\permission\Permission|string $name | |
| * | |
| * @return bool | |
| */ | |
| public function isPermissionSet($name){ | |
| return $this->perm->isPermissionSet($name); | |
| } | |
| /** | |
| * @param \pocketmine\permission\Permission|string $name | |
| * | |
| * @return bool | |
| */ | |
| public function hasPermission($name){ | |
| return $this->perm->hasPermission($name); | |
| } | |
| /** | |
| * @param Plugin $plugin | |
| * @param string $name | |
| * @param bool $value | |
| * | |
| * @return \pocketmine\permission\PermissionAttachment | |
| */ | |
| public function addAttachment(Plugin $plugin, $name = null, $value = null){ | |
| return $this->perm->addAttachment($plugin, $name, $value); | |
| } | |
| /** | |
| * @param PermissionAttachment $attachment | |
| * | |
| * @return void | |
| */ | |
| public function removeAttachment(PermissionAttachment $attachment){ | |
| $this->perm->removeAttachment($attachment); | |
| } | |
| public function recalculatePermissions(){ | |
| $this->perm->recalculatePermissions(); | |
| } | |
| /** | |
| * @return \pocketmine\permission\PermissionAttachmentInfo[] | |
| */ | |
| public function getEffectivePermissions(){ | |
| return $this->perm->getEffectivePermissions(); | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isPlayer(){ | |
| return false; | |
| } | |
| /** | |
| * @return \pocketmine\Server | |
| */ | |
| public function getServer(){ | |
| return Server::getInstance(); | |
| } | |
| /** | |
| * @param string $message | |
| */ | |
| public function sendMessage($message){ | |
| foreach(explode("\n", trim($message)) as $line){ | |
| $line = trim($line); | |
| console($line); | |
| } | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getName(){ | |
| return "CONSOLE"; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isOp(){ | |
| return true; | |
| } | |
| /** | |
| * @param bool $value | |
| */ | |
| public function setOp($value){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class BanCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Prevents the specified player from using this server", | |
| "/ban <player> [reason...]" | |
| ); | |
| $this->setPermission("pocketmine.command.ban.player"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $name = array_shift($args); | |
| $reason = implode(" ", $args); | |
| Server::getInstance()->getNameBans()->addBan($name, $reason, null, $sender->getName()); | |
| if(($player = Server::getInstance()->getPlayerExact($name)) instanceof Player){ | |
| $player->kick("Banned by admin."); | |
| } | |
| Command::broadcastCommandMessage($sender, "Banned player " . $name); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class BanIpCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Prevents the specified IP address from using this server", | |
| "/ban <address|player> [reason...]" | |
| ); | |
| $this->setPermission("pocketmine.command.ban.ip"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $value = array_shift($args); | |
| $reason = implode(" ", $args); | |
| if(preg_match("/^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$/", $value)){ | |
| $this->processIPBan($value, $sender, $reason); | |
| }else{ | |
| if(($player = Server::getInstance()->getPlayer($value)) instanceof Player){ | |
| $this->processIPBan($player->getAddress(), $sender, $reason); | |
| }else{ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| private function processIPBan($ip, CommandSender $sender, $reason){ | |
| Server::getInstance()->getIPBans()->addBan($ip, $reason, null, $sender->getName()); | |
| foreach(Server::getInstance()->getOnlinePlayers() as $player){ | |
| if($player->getAddress() === $ip){ | |
| $player->kick("You have been IP banned."); | |
| } | |
| } | |
| Command::broadcastCommandMessage($sender, "Banned IP Address " . $ip); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| class BanListCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "View all players banned from this server", | |
| "/banlist [ips|players]" | |
| ); | |
| $this->setPermission("pocketmine.command.ban.list"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| $list = Server::getInstance()->getNameBans(); | |
| if(isset($args[0])){ | |
| $args[0] = strtolower($args[0]); | |
| if($args[0] === "ips"){ | |
| $list = Server::getInstance()->getIPBans(); | |
| }elseif($args[0] === "players"){ | |
| $list = Server::getInstance()->getNameBans(); | |
| } | |
| } | |
| $message = ""; | |
| $list = $list->getEntries(); | |
| foreach($list as $entry){ | |
| $message .= $entry->getName() . ", "; | |
| } | |
| $sender->sendMessage("There are " . count($list) . " total banned players:"); | |
| $sender->sendMessage(substr($message, 0, -2)); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class DefaultGamemodeCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Set the default gamemode", | |
| "/defaultgamemode <mode>" | |
| ); | |
| $this->setPermission("pocketmine.command.defaultgamemode"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $gameMode = Server::getGamemodeFromString($args[0]); | |
| if($gameMode !== -1){ | |
| Server::getInstance()->setConfigInt("gamemode", $gameMode); | |
| $sender->sendMessage("Default game mode set to " . strtolower(Server::getGamemodeString($gameMode))); | |
| }else{ | |
| $sender->sendMessage("Unknown game mode"); | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class DeopCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Takes the specified player's operator status", | |
| "/deop <player>" | |
| ); | |
| $this->setPermission("pocketmine.command.op.take"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $name = array_shift($args); | |
| $player = Server::getInstance()->getOfflinePlayer($name); | |
| $player->setOp(false); | |
| if($player instanceof Player){ | |
| $player->sendMessage(TextFormat::YELLOW . "You are no longer op!"); | |
| } | |
| Command::broadcastCommandMessage($sender, "De-opped " . $player->getName()); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class DifficultyCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Sets the game difficulty", | |
| "/difficulty <new difficulty>" | |
| ); | |
| $this->setPermission("pocketmine.command.difficulty"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) !== 1){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $difficulty = Server::getDifficultyFromString($args[0]); | |
| if(Server::getInstance()->isHardcore()){ | |
| $difficulty = 3; | |
| } | |
| if($difficulty !== -1){ | |
| Server::getInstance()->setConfigInt("difficulty", $difficulty); | |
| $sender->sendMessage("Set difficulty to " . $difficulty); | |
| }else{ | |
| $sender->sendMessage("Unknown difficulty"); | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class GamemodeCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Changes the player to a specific game mode", | |
| "/gamemode <mode> [player]" | |
| ); | |
| $this->setPermission("pocketmine.command.gamemode"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $gameMode = Server::getGamemodeFromString($args[0]); | |
| if($gameMode === -1){ | |
| $sender->sendMessage("Unknown game mode"); | |
| return true; | |
| Server::getInstance()->setConfigInt("gamemode", $gameMode); | |
| $sender->sendMessage("Default game mode set to " . strtolower(Server::getGamemodeString($gameMode))); | |
| } | |
| $target = $sender; | |
| if(isset($args[1])){ | |
| $target = Server::getInstance()->getPlayer($args[1]); | |
| if($target === null){ | |
| $sender->sendMessage("Can't find player " . $args[1]); | |
| return true; | |
| } | |
| }elseif(!($sender instanceof Player)){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return true; | |
| } | |
| if($gameMode !== $target->getGamemode()){ | |
| $target->setGamemode($gameMode); | |
| if($gameMode !== $target->getGamemode()){ | |
| $sender->sendMessage("Game mode change for " . $target->getName() . " failed!"); | |
| }else{ | |
| if($target === $sender){ | |
| Command::broadcastCommandMessage($sender, "Set own gamemode to " . strtolower(Server::getGamemodeString($gameMode)) . " mode"); | |
| }else{ | |
| Command::broadcastCommandMessage($sender, "Set " . $target->getName() . "'s gamemode to " . strtolower(Server::getGamemodeString($gameMode)) . " mode"); | |
| } | |
| } | |
| }else{ | |
| $sender->sendMessage($target->getName() . " already has game mode " . strtolower(Server::getGamemodeString($gameMode))); | |
| return true; | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class GiveCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Gives the specified player a certain amount of items", | |
| "/give <player> <item[:damage]> [amount]" | |
| ); | |
| $this->setPermission("pocketmine.command.give"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) < 2){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $player = Server::getInstance()->getPlayer($args[0]); | |
| $item = Item::fromString($args[1]); | |
| if(!isset($args[2])){ | |
| $item->setCount($item->getMaxStackSize()); | |
| }else{ | |
| $item->setCount((int) $args[2]); | |
| } | |
| if($player instanceof Player){ | |
| if(($player->getGamemode() & 0x01) === 0x01){ | |
| $sender->sendMessage(TextFormat::RED . "Player is in creative mode"); | |
| return true; | |
| } | |
| if($item->getID() == 0){ | |
| $sender->sendMessage(TextFormat::RED . "There is no item called " . $args[1] . "."); | |
| return true; | |
| } | |
| $player->addItem(clone $item); | |
| }else{ | |
| $sender->sendMessage(TextFormat::RED . "Can't find player " . $args[0]); | |
| return true; | |
| } | |
| Command::broadcastCommandMessage($sender, "Gave " . $player->getName() . " " . $item->getCount() . " of " . $item->getName() . " (" . $item->getID() . ":" . $item->getMetadata() . ")"); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\command\ConsoleCommandSender; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class HelpCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Shows the help menu", | |
| "/help [pageNumber]\n/help <topic> [pageNumber]", | |
| ["?"] | |
| ); | |
| $this->setPermission("pocketmine.command.help"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $command = ""; | |
| $pageNumber = 1; | |
| }elseif(is_numeric($args[count($args) - 1])){ | |
| $pageNumber = (int) array_pop($args); | |
| if($pageNumber <= 0){ | |
| $pageNumber = 1; | |
| } | |
| $command = implode(" ", $args); | |
| }else{ | |
| $command = implode(" ", $args); | |
| $pageNumber = 1; | |
| } | |
| if($sender instanceof ConsoleCommandSender){ | |
| $pageHeight = PHP_INT_MAX; | |
| }else{ | |
| $pageHeight = 5; | |
| } | |
| if($command === ""){ | |
| $commands = array(); | |
| foreach(Server::getInstance()->getCommandMap()->getCommands() as $command){ | |
| if($command->testPermissionSilent($sender)){ | |
| $commands[$command->getName()] = $command; | |
| } | |
| } | |
| ksort($commands, SORT_NATURAL | SORT_FLAG_CASE); | |
| $commands = array_chunk($commands, $pageHeight); | |
| $pageNumber = (int) min(count($commands), $pageNumber); | |
| if($pageNumber < 1){ | |
| $pageNumber = 1; | |
| } | |
| $message = TextFormat::RED . "-" . TextFormat::RESET . " Showing help page " . $pageNumber . " of " . count($commands) . " (/help <pageNumber>) " . TextFormat::RED . "-" . TextFormat::RESET . "\n"; | |
| if(isset($commands[$pageNumber - 1])){ | |
| foreach($commands[$pageNumber - 1] as $command){ | |
| $message .= TextFormat::DARK_GREEN . "/" . $command->getName() . ": " . TextFormat::WHITE . $command->getDescription() . "\n"; | |
| } | |
| } | |
| $sender->sendMessage($message); | |
| return true; | |
| }else{ | |
| if(($command = Server::getInstance()->getCommandMap()->getCommand(strtolower($command))) instanceof Command){ | |
| if($command->testPermissionSilent($sender)){ | |
| $message = TextFormat::YELLOW . "--------- " . TextFormat::WHITE . " Help: /" . $command->getName() . TextFormat::YELLOW . " ---------\n"; | |
| $message .= TextFormat::GOLD . "Description: " . TextFormat::WHITE . $command->getDescription() . "\n"; | |
| $message .= TextFormat::GOLD . "Usage: " . TextFormat::WHITE . implode("\n" . TextFormat::WHITE, explode("\n", $command->getUsage())) . "\n"; | |
| $sender->sendMessage($message); | |
| return true; | |
| } | |
| } | |
| $sender->sendMessage(TextFormat::RED . "No help for " . strtolower($command)); | |
| return true; | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class KickCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Removes the specified player from the server", | |
| "/kick <player> [reason...]" | |
| ); | |
| $this->setPermission("pocketmine.command.kick"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $name = array_shift($args); | |
| $reason = trim(implode(" ", $args)); | |
| if($reason === ""){ | |
| $reason = "Kicked by an operator."; | |
| } | |
| if(($player = Server::getInstance()->getPlayer($name)) instanceof Player){ | |
| $player->kick("Banned by admin."); | |
| }else{ | |
| $sender->sendMessage($name . " not found."); | |
| } | |
| Command::broadcastCommandMessage($sender, "Kicked player " . $name . ". With reason:\n" . $reason); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class KillCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Commits suicide, only usable as a player", | |
| "/kill", | |
| ["suicide"] | |
| ); | |
| $this->setPermission("pocketmine.command.kill"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if($sender instanceof Player){ | |
| //TODO: EntityDamageEvent | |
| //$ev->setLastDamageCause() | |
| $sender->setHealth(0); | |
| //TODO: set update | |
| $sender->sendMessage("Ouch. That look like it hurt."); | |
| }else{ | |
| $sender->sendMessage(TextFormat::RED . "You can only perform this command as a player"); | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class ListCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Lists all online players", | |
| "/list" | |
| ); | |
| $this->setPermission("pocketmine.command.list"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| $online = ""; | |
| foreach(Server::getInstance()->getOnlinePlayers() as $player){ | |
| if($player->isOnline() and (!($sender instanceof Player) or $sender->canSee($player))){ | |
| $online .= $player->getDisplayName() . ", "; | |
| } | |
| } | |
| $sender->sendMessage("There are " . count(Server::getInstance()->getOnlinePlayers()) . "/" . Server::getInstance()->getMaxPlayers() . " players online:\n" . substr($online, 0, -2)); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class MeCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Performs the specified action in chat", | |
| "/me <action...>" | |
| ); | |
| $this->setPermission("pocketmine.command.me"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $message = "* "; | |
| if($sender instanceof Player){ | |
| $message .= $sender->getDisplayName(); | |
| }else{ | |
| $message .= $sender->getName(); | |
| } | |
| Server::getInstance()->broadcastMessage($message . " " . implode(" ", $args)); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class OpCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Gives the specified player operator status", | |
| "/op <player>" | |
| ); | |
| $this->setPermission("pocketmine.command.op.give"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $name = array_shift($args); | |
| $player = Server::getInstance()->getOfflinePlayer($name); | |
| Command::broadcastCommandMessage($sender, "Opped " . $player->getName()); | |
| if($player instanceof Player){ | |
| $player->sendMessage("You are now op!"); | |
| } | |
| $player->setOp(true); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class PardonCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Allows the specified player to use this server", | |
| "/pardon <player>" | |
| ); | |
| $this->setPermission("pocketmine.command.unban.player"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) !== 1){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| Server::getInstance()->getNameBans()->remove($args[0]); | |
| Command::broadcastCommandMessage($sender, "Pardoned " . $name); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class PardonIpCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Allows the specified IP address to use this server", | |
| "/pardon-ip <address>" | |
| ); | |
| $this->setPermission("pocketmine.command.unban.ip"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) !== 1){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| if(preg_match("/^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$/", $args[0])){ | |
| Server::getInstance()->getIPBans()->remove($args[0]); | |
| Command::broadcastCommandMessage($sender, "Pardoned IP " . $args[0]); | |
| }else{ | |
| $sender->sendMessage("Invalid IP"); | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class PluginsCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Gets a list of plugins running on the server", | |
| "/plugins", | |
| ["pl"] | |
| ); | |
| $this->setPermission("pocketmine.command.plugins"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| $sender->sendMessage("Plugins " . $this->getPluginList()); | |
| return true; | |
| } | |
| private function getPluginList(){ | |
| $list = ""; | |
| foreach(($plugins = Server::getInstance()->getPluginManager()->getPlugins()) as $plugin){ | |
| if(strlen($list) > 0){ | |
| $list .= TextFormat::WHITE . ", "; | |
| } | |
| $list .= $plugin->isEnabled() ? TextFormat::GREEN : TextFormat::RED; | |
| $list .= $plugin->getDescription()->getFullName(); | |
| } | |
| return "(" . count($plugins) . "): $list"; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\event\HandlerList; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class ReloadCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Reloads the server configuration and plugins", | |
| "/reload" | |
| ); | |
| $this->setPermission("pocketmine.command.reload"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| Command::broadcastCommandMessage($sender, TextFormat::YELLOW . "Reloading server..."); | |
| Server::getInstance()->reload(); | |
| Command::broadcastCommandMessage($sender, TextFormat::GOLD . "Reload complete."); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| class SaveCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Saves the server to disk", | |
| "/save-all" | |
| ); | |
| $this->setPermission("pocketmine.command.save.perform"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| Command::broadcastCommandMessage($sender, "Forcing save..."); | |
| foreach(Server::getInstance()->getOnlinePlayers() as $player){ | |
| $player->save(); | |
| } | |
| foreach(Server::getInstance()->getLevels() as $level){ | |
| $level->save(true); | |
| } | |
| Command::broadcastCommandMessage($sender, "Save complete."); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| class SaveOffCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Disables server autosaving", | |
| "/save-off" | |
| ); | |
| $this->setPermission("pocketmine.command.save.disable"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| foreach(Server::getInstance()->getLevels() as $level){ | |
| $level->setAutoSave(false); | |
| } | |
| Command::broadcastCommandMessage($sender, "Disabled level saving"); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| class SaveOnCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Enables server autosaving", | |
| "/save-on" | |
| ); | |
| $this->setPermission("pocketmine.command.save.enable"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| foreach(Server::getInstance()->getLevels() as $level){ | |
| $level->setAutoSave(true); | |
| } | |
| Command::broadcastCommandMessage($sender, "Enabled level saving"); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\command\ConsoleCommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class SayCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Broadcasts the given message as the sender", | |
| "/say <message...>" | |
| ); | |
| $this->setPermission("pocketmine.command.say"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $message = TextFormat::LIGHT_PURPLE . "["; | |
| if($sender instanceof ConsoleCommandSender){ | |
| $message .= "Server"; | |
| }elseif($sender instanceof Player){ | |
| $message .= $sender->getDisplayName(); | |
| }else{ | |
| $message .= $sender->getName(); | |
| } | |
| $message .= TextFormat::LIGHT_PURPLE . "] " . implode(" ", $args); | |
| Server::getInstance()->broadcastMessage($message); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class SeedCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Shows the world seed", | |
| "/seed" | |
| ); | |
| $this->setPermission("pocketmine.command.seed"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if($sender instanceof Player){ | |
| $seed = $sender->getLevel()->getSeed(); | |
| }else{ | |
| $seed = Server::getInstance()->getDefaultLevel()->getSeed(); | |
| } | |
| $sender->sendMessage("Seed: " . $seed); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\level\Position; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class SpawnpointCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Sets a player's spawn point", | |
| "/spawnpoint OR /spawnpoint <player> OR /spawnpoint <player> <x> <y> <z>" | |
| ); | |
| $this->setPermission("pocketmine.command.spawnpoint"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| $target = null; | |
| if(count($args) === 0){ | |
| if($sender instanceof Player){ | |
| $target = $sender; | |
| }else{ | |
| $sender->sendMessage(TextFormat::RED . "Please provide a player!"); | |
| return true; | |
| } | |
| }else{ | |
| $target = Server::getInstance()->getPlayer($args[0]); | |
| if($target === null){ | |
| $sender->sendMessage(TextFormat::RED . "Can't find player ".$args[0]); | |
| return true; | |
| } | |
| } | |
| $level = $target->getLevel(); | |
| if(count($args) === 4){ | |
| if($level !== null){ | |
| $x = (int) $this->getRelativeDouble($sender->x, $sender, $args[1]); | |
| $y = (int) $this->getRelativeDouble($sender->y, $sender, $args[2], 0, 128); | |
| $z = (int) $this->getRelativeDouble($sender->z, $sender, $args[3]); | |
| $target->setSpawn(new Position($x, $y, $z, $level)); | |
| Command::broadcastCommandMessage($sender, "Set ".$target->getName()."'s spawnpoint to ".$x.", ".$y.", ".$z); | |
| return true; | |
| } | |
| }elseif(count($args) <= 1){ | |
| if($sender instanceof Player) { | |
| $pos = new Position((int) $sender->x, (int) $sender->y, (int) $sender->z, $sender->getLevel()); | |
| $target->setSpawn($pos); | |
| Command::broadcastCommandMessage($sender, "Set ".$target->getName()."'s spawnpoint to ".$pos->x.", ".$pos->y.", ".$pos->z); | |
| return true; | |
| }else{ | |
| $sender->sendMessage(TextFormat::RED . "Please provide a player!"); | |
| return true; | |
| } | |
| } | |
| $sender->sendMessage(TextFormat::RED . "Usage: ".$this->usageMessage); | |
| return true; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class StatusCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Reads back the server's performance.", | |
| "/list" | |
| ); | |
| $this->setPermission("pocketmine.command.list"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| $server = Server::getInstance(); | |
| $sender->sendMessage(TextFormat::GREEN . "---- ".TextFormat::WHITE . "Server status".TextFormat::GREEN. " ----"); | |
| $sender->sendMessage(TextFormat::GOLD . "TPS: ".TextFormat::WHITE.$server->getTicksPerSecond()); | |
| $sender->sendMessage(TextFormat::GOLD . "Upload: ".TextFormat::WHITE . round($server->getNetwork()->getUploadSpeed() / 1024, 2) . " kB/s"); | |
| $sender->sendMessage(TextFormat::GOLD . "Download: ".TextFormat::WHITE . round($server->getNetwork()->getDownloadSpeed() / 1024, 2) . " kB/s"); | |
| $sender->sendMessage(TextFormat::GOLD . "Memory: ".TextFormat::WHITE . round((memory_get_usage() / 1024) / 1024, 2) . TextFormat::YELLOW . "/" . TextFormat::WHITE . round((memory_get_usage(true) / 1024) / 1024, 2) . " MB"); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| class StopCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Stops the server, with optional reason", | |
| "/stop [reason]" | |
| ); | |
| $this->setPermission("pocketmine.command.stop"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| Command::broadcastCommandMessage($sender, "Stopping the server..."); | |
| $reason = implode(" ", $args); | |
| if($reason !== ""){ | |
| foreach(Server::getInstance()->getOnlinePlayers() as $player){ | |
| $player->kick($reason); | |
| } | |
| } | |
| Server::getInstance()->shutdown(); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\level\Position; | |
| use pocketmine\math\Vector3; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class TeleportCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Teleports the given player (or yourself) to another player or coordinates", | |
| "/tp [player] <target> and/or <x> <y> <z>" | |
| ); | |
| $this->setPermission("pocketmine.command.teleport"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) < 1 or count($args) > 4){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: ".$this->usageMessage); | |
| return true; | |
| } | |
| $target = null; | |
| $origin = $sender; | |
| if(count($args) === 1 or count($args) === 3){ | |
| if($sender instanceof Player){ | |
| $target = $sender; | |
| }else{ | |
| $sender->sendMessage(TextFormat::RED . "Please provide a player!"); | |
| return true; | |
| } | |
| }else{ | |
| $target = Server::getInstance()->getPlayer($args[0]); | |
| if($target === null){ | |
| $sender->sendMessage(TextFormat::RED . "Can't find player ".$args[0]); | |
| return true; | |
| } | |
| if(count($args) === 2){ | |
| $origin = $target; | |
| $target = Server::getInstance()->getPlayer($args[1]); | |
| if($target === null){ | |
| $sender->sendMessage(TextFormat::RED . "Can't find player ".$args[1]); | |
| return true; | |
| } | |
| } | |
| } | |
| if(count($args) < 3){ | |
| $pos = new Position($target->x, $target->y, $target->z, $target->getLevel()); | |
| $origin->teleport($pos); | |
| Command::broadcastCommandMessage($sender, "Teleported ".$origin->getName()." to ".$target->getName()); | |
| return true; | |
| }elseif($target->getLevel() !== null){ | |
| $pos = count($args) === 4 ? 1:0; | |
| $x = $this->getRelativeDouble($target->x, $sender, $args[$pos++]); | |
| $y = $this->getRelativeDouble($target->y, $sender, $args[$pos++], 0, 128); | |
| $z = $this->getRelativeDouble($target->z, $sender, $args[$pos]); | |
| $target->teleport(new Vector3($x, $y, $z)); | |
| Command::broadcastCommandMessage($sender, "Teleported ".$target->getName()." to ".round($x, 2).", ".round($y, 2).", ".round($z, 2)); | |
| return true; | |
| } | |
| $sender->sendMessage(TextFormat::RED . "Usage: ".$this->usageMessage); | |
| return true; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class TellCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Sends a private message to the given player", | |
| "/tell <player> <message>", | |
| ["w", "msg"] | |
| ); | |
| $this->setPermission("pocketmine.command.tell"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) < 2){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| return false; | |
| } | |
| $name = strtolower(array_shift($args)); | |
| $player = Server::getInstance()->getPlayer($name); | |
| if($player instanceof Player){ | |
| $sender->sendMessage("[me -> " . $player->getName() . "] " . implode($args)); | |
| $player->sendMessage("[" . $sender->getName() . " -> me] " . implode($args)); | |
| }else{ | |
| $sender->sendMessage("There's no player by that name online."); | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| abstract class VanillaCommand extends Command{ | |
| //TODO: increment chunk indexes | |
| const MAX_COORD = 524288; | |
| const MIN_COORD = -524288; | |
| public function __construct($name, $description = "", $usageMessage = null, array $aliases = array()){ | |
| parent::__construct($name, $description, $usageMessage, $aliases); | |
| } | |
| protected function getInteger(CommandSender $sender, $value, $min = self::MIN_COORD, $max = self::MAX_COORD){ | |
| $i = (int) $value; | |
| if($i < $min){ | |
| $i = $min; | |
| }elseif($i > $max){ | |
| $i = $max; | |
| } | |
| return $i; | |
| } | |
| protected function getRelativeDouble($original, CommandSender $sender, $input, $min = self::MIN_COORD, $max = self::MAX_COORD){ | |
| if($input{0} === "~"){ | |
| $value = $this->getDouble($sender, substr($input, 1)); | |
| return $original + $value; | |
| } | |
| return $this->getDouble($sender, $input, $min, $max); | |
| } | |
| protected function getDouble(CommandSender $sender, $value, $min = self::MIN_COORD, $max = self::MAX_COORD){ | |
| $i = (double) $value; | |
| if($i < $min){ | |
| $i = $min; | |
| }elseif($i > $max){ | |
| $i = $max; | |
| } | |
| return $i; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\network\protocol\Info; | |
| use pocketmine\plugin\Plugin; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class VersionCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Gets the version of this server including any plugins in use", | |
| "/version [plugin name]", | |
| ["ver", "about"] | |
| ); | |
| $this->setPermission("pocketmine.command.version"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 0){ | |
| $output = "This server is running PocketMine-MP version " . Server::getInstance()->getPocketMineVersion() . " 「" . Server::getInstance()->getCodename() . "」 (Implementing API version " . Server::getInstance()->getApiVersion() . " for Minecraft: PE " . Server::getInstance()->getVersion() . " protocol version " . Info::CURRENT_PROTOCOL . ")"; | |
| if(\pocketmine\GIT_COMMIT !== str_repeat("00", 20)){ | |
| $output .= " [git " . \pocketmine\GIT_COMMIT . "]"; | |
| } | |
| $sender->sendMessage($output); | |
| }else{ | |
| $pluginName = implode(" ", $args); | |
| $exactPlugin = Server::getInstance()->getPluginManager()->getPlugin($pluginName); | |
| if($exactPlugin instanceof Plugin){ | |
| $this->describeToSender($exactPlugin, $sender); | |
| return true; | |
| } | |
| $found = false; | |
| $pluginName = strtolower($pluginName); | |
| foreach(Server::getInstance()->getPluginManager()->getPlugins() as $plugin){ | |
| if(stripos($plugin->getName(), $pluginName) !== false){ | |
| $this->describeToSender($plugin, $sender); | |
| $found = true; | |
| } | |
| } | |
| if(!$found){ | |
| $sender->sendMessage("This server is not running any plugin by that name.\nUse /plugins to get a list of plugins."); | |
| } | |
| } | |
| return true; | |
| } | |
| private function describeToSender(Plugin $plugin, CommandSender $sender){ | |
| $desc = $plugin->getDescription(); | |
| $sender->sendMessage(TextFormat::DARK_GREEN . $desc->getName() . TextFormat::WHITE . " version " . TextFormat::DARK_GREEN . $desc->getVersion()); | |
| if($desc->getDescription() != null){ | |
| $sender->sendMessage($desc->getDescription()); | |
| } | |
| if($desc->getWebsite() != null){ | |
| $sender->sendMessage("Website: " . $desc->getWebsite()); | |
| } | |
| if(count($authors = $desc->getAuthors()) > 0){ | |
| if(count($authors) === 1){ | |
| $sender->sendMessage("Author: " . implode(", ", $authors)); | |
| }else{ | |
| $sender->sendMessage("Authors: " . implode(", ", $authors)); | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command\defaults; | |
| use pocketmine\command\Command; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class WhitelistCommand extends VanillaCommand{ | |
| public function __construct($name){ | |
| parent::__construct( | |
| $name, | |
| "Manages the list of players allowed to use this server", | |
| "/whitelist (add|remove) <player>\n/whitelist (on|off|list|reload)" | |
| ); | |
| $this->setPermission("pocketmine.command.whitelist.reload;pocketmine.command.whitelist.enable;pocketmine.command.whitelist.disable;pocketmine.command.whitelist.list;pocketmine.command.whitelist.add;pocketmine.command.whitelist.remove"); | |
| } | |
| public function execute(CommandSender $sender, $currentAlias, array $args){ | |
| if(!$this->testPermission($sender)){ | |
| return true; | |
| } | |
| if(count($args) === 1){ | |
| if($this->badPerm($sender, strtolower($args[0]))){ | |
| return true; | |
| } | |
| switch(strtolower($args[0])){ | |
| case "reload": | |
| Server::getInstance()->reloadWhitelist(); | |
| Command::broadcastCommandMessage($sender, "Reloaded white-list from file"); | |
| return true; | |
| case "on": | |
| Server::getInstance()->setConfigBool("white-list", true); | |
| Command::broadcastCommandMessage($sender, "Turned on white-listing"); | |
| return true; | |
| case "off": | |
| Server::getInstance()->setConfigBool("white-list", false); | |
| Command::broadcastCommandMessage($sender, "Turned off white-listing"); | |
| return true; | |
| case "list": | |
| $result = ""; | |
| foreach(Server::getInstance()->getWhitelisted() as $player){ | |
| $result .= $player . ", "; | |
| } | |
| $sender->sendMessage("White-listed players: " . substr($result, 0, -2)); | |
| return true; | |
| } | |
| }elseif(count($args) === 2){ | |
| if($this->badPerm($sender, strtolower($args[0]))){ | |
| return true; | |
| } | |
| switch(strtolower($args[0])){ | |
| case "add": | |
| Server::getInstance()->getOfflinePlayer($args[1])->setWhitelisted(true); | |
| Command::broadcastCommandMessage($sender, "Added " . $args[1] . " to white-list"); | |
| return true; | |
| case "remove": | |
| Server::getInstance()->getOfflinePlayer($args[1])->setWhitelisted(false); | |
| Command::broadcastCommandMessage($sender, "Removed " . $args[1] . " from white-list"); | |
| return true; | |
| } | |
| } | |
| $sender->sendMessage(TextFormat::RED . "Usage:\n" . $this->usageMessage); | |
| return true; | |
| } | |
| private function badPerm(CommandSender $sender, $perm){ | |
| if(!$sender->hasPermission("pocketmine.command.whitelist.$perm")){ | |
| $sender->sendMessage(TextFormat::RED . "You do not have permission to perform this action."); | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| use pocketmine\plugin\Plugin; | |
| use pocketmine\utils\TextFormat; | |
| class PluginCommand extends Command implements PluginIdentifiableCommand{ | |
| /** @var Plugin */ | |
| private $owningPlugin; | |
| /** @var CommandExecutor */ | |
| private $executor; | |
| /** | |
| * @param string $name | |
| * @param Plugin $owner | |
| */ | |
| public function __construct($name, Plugin $owner){ | |
| parent::__construct($name); | |
| $this->owningPlugin = $owner; | |
| $this->executor = $owner; | |
| $this->usageMessage = ""; | |
| } | |
| public function execute(CommandSender $sender, $commandLabel, array $args){ | |
| if(!$this->owningPlugin->isEnabled()){ | |
| return false; | |
| } | |
| if(!$this->testPermission($sender)){ | |
| return false; | |
| } | |
| $success = $this->executor->onCommand($sender, $this, $commandLabel, $args); | |
| if(!$success and $this->usageMessage !== ""){ | |
| $sender->sendMessage(TextFormat::RED . "Usage: " . $this->usageMessage); | |
| } | |
| return $success; | |
| } | |
| /** | |
| * @return Plugin | |
| */ | |
| public function getPlugin(){ | |
| return $this->owningPlugin; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| interface PluginIdentifiableCommand{ | |
| /** | |
| * @return \pocketmine\plugin\plugin | |
| */ | |
| public function getPlugin(); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| class RemoteConsoleCommandSender extends ConsoleCommandSender{ | |
| /** @var string */ | |
| private $messages = ""; | |
| public function sendMessage($message){ | |
| $this->messages .= trim($message, "\r\n")."\n"; | |
| } | |
| public function getMessage(){ | |
| return $this->messages; | |
| } | |
| public function getName(){ | |
| return "Rcon"; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\command; | |
| use pocketmine\command\defaults\BanCommand; | |
| use pocketmine\command\defaults\BanIpCommand; | |
| use pocketmine\command\defaults\BanListCommand; | |
| use pocketmine\command\defaults\DefaultGamemodeCommand; | |
| use pocketmine\command\defaults\DeopCommand; | |
| use pocketmine\command\defaults\DifficultyCommand; | |
| use pocketmine\command\defaults\GamemodeCommand; | |
| use pocketmine\command\defaults\GiveCommand; | |
| use pocketmine\command\defaults\HelpCommand; | |
| use pocketmine\command\defaults\KickCommand; | |
| use pocketmine\command\defaults\KillCommand; | |
| use pocketmine\command\defaults\ListCommand; | |
| use pocketmine\command\defaults\MeCommand; | |
| use pocketmine\command\defaults\OpCommand; | |
| use pocketmine\command\defaults\PardonCommand; | |
| use pocketmine\command\defaults\PardonIpCommand; | |
| use pocketmine\command\defaults\PluginsCommand; | |
| use pocketmine\command\defaults\ReloadCommand; | |
| use pocketmine\command\defaults\SaveCommand; | |
| use pocketmine\command\defaults\SaveOffCommand; | |
| use pocketmine\command\defaults\SaveOnCommand; | |
| use pocketmine\command\defaults\SayCommand; | |
| use pocketmine\command\defaults\SeedCommand; | |
| use pocketmine\command\defaults\SpawnpointCommand; | |
| use pocketmine\command\defaults\StatusCommand; | |
| use pocketmine\command\defaults\StopCommand; | |
| use pocketmine\command\defaults\TeleportCommand; | |
| use pocketmine\command\defaults\TellCommand; | |
| use pocketmine\command\defaults\VanillaCommand; | |
| use pocketmine\command\defaults\VersionCommand; | |
| use pocketmine\command\defaults\WhitelistCommand; | |
| use pocketmine\Server; | |
| class SimpleCommandMap implements CommandMap{ | |
| /** | |
| * @var Command[] | |
| */ | |
| protected $knownCommands = array(); | |
| /** @var Server */ | |
| private $server; | |
| public function __construct(Server $server){ | |
| $this->server = $server; | |
| $this->setDefaultCommands(); | |
| } | |
| private function setDefaultCommands(){ | |
| $this->register("pocketmine", new VersionCommand("version")); | |
| $this->register("pocketmine", new PluginsCommand("plugins")); | |
| $this->register("pocketmine", new SeedCommand("seed")); | |
| $this->register("pocketmine", new HelpCommand("help")); | |
| $this->register("pocketmine", new StopCommand("stop")); | |
| $this->register("pocketmine", new TellCommand("tell")); | |
| $this->register("pocketmine", new DefaultGamemodeCommand("defaultgamemode")); | |
| $this->register("pocketmine", new BanCommand("ban")); | |
| $this->register("pocketmine", new BanIpCommand("ban-ip")); | |
| $this->register("pocketmine", new BanListCommand("banlist")); | |
| $this->register("pocketmine", new PardonCommand("pardon")); | |
| $this->register("pocketmine", new PardonIpCommand("pardon-ip")); | |
| $this->register("pocketmine", new SayCommand("say")); | |
| $this->register("pocketmine", new MeCommand("me")); | |
| $this->register("pocketmine", new ListCommand("list")); | |
| $this->register("pocketmine", new DifficultyCommand("difficulty")); | |
| $this->register("pocketmine", new KickCommand("kick")); | |
| $this->register("pocketmine", new OpCommand("op")); | |
| $this->register("pocketmine", new DeopCommand("deop")); | |
| $this->register("pocketmine", new WhitelistCommand("whitelist")); | |
| $this->register("pocketmine", new SaveOnCommand("save-on")); | |
| $this->register("pocketmine", new SaveOffCommand("save-off")); | |
| $this->register("pocketmine", new SaveCommand("save-all")); | |
| $this->register("pocketmine", new GiveCommand("give")); | |
| $this->register("pocketmine", new GamemodeCommand("gamemode")); | |
| $this->register("pocketmine", new KillCommand("kill")); | |
| $this->register("pocketmine", new SpawnpointCommand("spawnpoint")); | |
| $this->register("pocketmine", new TeleportCommand("tp")); | |
| $this->register("pocketmine", new ReloadCommand("reload")); | |
| if($this->server->getConfigBoolean("debug.commands", false) === true){ | |
| $this->register("pocketmine", new StatusCommand("status")); | |
| } | |
| } | |
| public function registerAll($fallbackPrefix, array $commands){ | |
| foreach($commands as $command){ | |
| $this->register($fallbackPrefix, $command); | |
| } | |
| } | |
| public function register($fallbackPrefix, Command $command, $label = null){ | |
| if($label === null){ | |
| $label = $command->getName(); | |
| } | |
| $label = strtolower(trim($label)); | |
| $fallbackPrefix = strtolower(trim($fallbackPrefix)); | |
| $registered = $this->registerAlias($command, false, $fallbackPrefix, $label); | |
| $aliases = $command->getAliases(); | |
| foreach($aliases as $index => $alias){ | |
| if(!$this->registerAlias($command, true, $fallbackPrefix, $alias)){ | |
| unset($aliases[$index]); | |
| } | |
| } | |
| $command->setAliases($aliases); | |
| if(!$registered){ | |
| $command->setLabel($fallbackPrefix . ":" . $label); | |
| } | |
| $command->register($this); | |
| return $registered; | |
| } | |
| private function registerAlias(Command $command, $isAlias, $fallbackPrefix, $label){ | |
| $this->knownCommands[$fallbackPrefix . ":" . $label] = $command; | |
| if(($command instanceof VanillaCommand or $isAlias) and isset($this->knownCommands[$label])){ | |
| return false; | |
| } | |
| if(isset($this->knownCommands[$label]) and $this->knownCommands[$label]->getLabel() === $label){ | |
| return false; | |
| } | |
| if(!$isAlias){ | |
| $command->setLabel($label); | |
| } | |
| $this->knownCommands[$label] = $command; | |
| return true; | |
| } | |
| public function dispatch(CommandSender $sender, $commandLine){ | |
| $args = explode(" ", $commandLine); | |
| if(count($args) === 0){ | |
| return false; | |
| } | |
| $sentCommandLabel = strtolower(array_shift($args)); | |
| $target = $this->getCommand($sentCommandLabel); | |
| if($target === null){ | |
| return false; | |
| } | |
| $target->execute($sender, $sentCommandLabel, $args); | |
| return true; | |
| } | |
| public function clearCommands(){ | |
| foreach($this->knownCommands as $command){ | |
| $command->unregister($this); | |
| } | |
| $this->knownCommands = array(); | |
| $this->setDefaultCommands(); | |
| } | |
| public function getCommand($name){ | |
| if(isset($this->knownCommands[$name])){ | |
| return $this->knownCommands[$name]; | |
| } | |
| return null; | |
| } | |
| /** | |
| * @return Command[] | |
| */ | |
| public function getCommands(){ | |
| return $this->knownCommands; | |
| } | |
| /** | |
| * @return void | |
| */ | |
| public function registerServerAliases(){ | |
| //TODO | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine; | |
| //Entities | |
| const ENTITY_PLAYER = 1; | |
| const ENTITY_MOB = 2; | |
| const MOB_CHICKEN = 10; | |
| const MOB_COW = 11; | |
| const MOB_PIG = 12; | |
| const MOB_SHEEP = 13; | |
| const MOB_ZOMBIE = 32; | |
| const MOB_CREEPER = 33; | |
| const MOB_SKELETON = 34; | |
| const MOB_SPIDER = 35; | |
| const MOB_PIGMAN = 36; | |
| const ENTITY_OBJECT = 3; | |
| const OBJECT_PRIMEDTNT = 65; | |
| const OBJECT_ARROW = 80; | |
| const OBJECT_PAINTING = 83; | |
| const ENTITY_ITEM = 4; | |
| const ENTITY_FALLING = 5; | |
| const FALLING_SAND = 66; | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface Ageable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| abstract class Animal extends Creature implements Ageable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Arrow extends Projectile{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface Attachable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Chicken extends Animal{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface Colorable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Cow extends Animal{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| abstract class Creature extends Living{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Creeper extends Monster implements Explosive{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface Damageable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class DroppedItem extends Entity{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Egg extends Projectile{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Enderman extends Monster implements InventorySource{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class EnderPearl extends Projectile{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * All the entity classes | |
| */ | |
| namespace pocketmine\entity; | |
| use pocketmine\event\entity\EntityDespawnEvent; | |
| use pocketmine\event\entity\EntityLevelChangeEvent; | |
| use pocketmine\event\entity\EntityMotionEvent; | |
| use pocketmine\event\entity\EntityMoveEvent; | |
| use pocketmine\event\entity\EntitySpawnEvent; | |
| use pocketmine\level\Level; | |
| use pocketmine\level\Position; | |
| use pocketmine\math\AxisAlignedBB; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\network\protocol\MoveEntityPacket_PosRot; | |
| use pocketmine\network\protocol\MovePlayerPacket; | |
| use pocketmine\network\protocol\RemoveEntityPacket; | |
| use pocketmine\network\protocol\SetEntityMotionPacket; | |
| use pocketmine\network\protocol\SetTimePacket; | |
| use pocketmine\Network; | |
| use pocketmine\Player; | |
| use pocketmine\level\format\pmf\LevelFormat; | |
| use pocketmine\Server; | |
| abstract class Entity extends Position{ | |
| public static $entityCount = 1; | |
| /** | |
| * @var Entity[] | |
| */ | |
| public static $list = array(); | |
| /** | |
| * @var Entity[] | |
| */ | |
| public static $needUpdate = array(); | |
| /** | |
| * @var Player[] | |
| */ | |
| protected $hasSpawned = array(); | |
| protected $id; | |
| public $passenger = null; | |
| public $vehicle = null; | |
| public $chunkIndex; | |
| public $lastX; | |
| public $lastY; | |
| public $lastZ; | |
| public $motionX; | |
| public $motionY; | |
| public $motionZ; | |
| public $yaw; | |
| public $pitch; | |
| public $lastYaw; | |
| public $lastPitch; | |
| public $boundingBox; | |
| public $onGround; | |
| public $positionChanged; | |
| public $motionChanged; | |
| public $dead; | |
| public $height; | |
| public $width; | |
| public $length; | |
| /** @var int */ | |
| private $health = 20; | |
| private $maxHealth = 20; | |
| public $fallDistance; | |
| public $ticksLived; | |
| public $lastUpdate; | |
| public $maxFireTicks; | |
| public $fireTicks; | |
| public $airTicks; | |
| public $namedtag; | |
| protected $inWater; | |
| public $noDamageTicks; | |
| private $justCreated; | |
| protected $fireProof; | |
| private $invulnerable; | |
| public $closed; | |
| public static function get($entityID){ | |
| return isset(Entity::$list[$entityID]) ? Entity::$list[$entityID] : false; | |
| } | |
| public static function getAll(){ | |
| return Entity::$list; | |
| } | |
| public function __construct(Level $level, Compound $nbt){ | |
| $this->id = Entity::$entityCount++; | |
| $this->justCreated = true; | |
| $this->closed = false; | |
| $this->namedtag = $nbt; | |
| $this->level = $level; | |
| $this->boundingBox = new AxisAlignedBB(0, 0, 0, 0, 0, 0); | |
| $this->setPositionAndRotation(new Vector3($this->namedtag["Pos"][0], $this->namedtag["Pos"][1], $this->namedtag["Pos"][2]), $this->namedtag->Rotation[0], $this->namedtag->Rotation[1]); | |
| $this->setMotion(new Vector3($this->namedtag["Motion"][0], $this->namedtag["Motion"][1], $this->namedtag["Motion"][2])); | |
| $this->fallDistance = $this->namedtag["FallDistance"]; | |
| $this->fireTicks = $this->namedtag["Fire"]; | |
| $this->airTicks = $this->namedtag["Air"]; | |
| $this->onGround = $this->namedtag["OnGround"] > 0 ? true : false; | |
| $this->invulnerable = $this->namedtag["Invulnerable"] > 0 ? true : false; | |
| $index = LevelFormat::getIndex($this->x >> 4, $this->z >> 4); | |
| $this->chunkIndex = $index; | |
| Entity::$list[$this->id] = $this; | |
| $this->level->entities[$this->id] = $this; | |
| $this->level->chunkEntities[$this->chunkIndex][$this->id] = $this; | |
| $this->lastUpdate = microtime(true); | |
| $this->initEntity(); | |
| Server::getInstance()->getPluginManager()->callEvent(new EntitySpawnEvent($this)); | |
| } | |
| public function saveNBT(){ | |
| $this->namedtag["Pos"][0] = $this->x; | |
| $this->namedtag["Pos"][1] = $this->y; | |
| $this->namedtag["Pos"][2] = $this->z; | |
| $this->namedtag["Motion"][0] = $this->motionX; | |
| $this->namedtag["Motion"][1] = $this->motionY; | |
| $this->namedtag["Motion"][2] = $this->motionZ; | |
| $this->namedtag["Rotation"][0] = $this->yaw; | |
| $this->namedtag["Rotation"][1] = $this->pitch; | |
| $this->namedtag["FallDistance"] = $this->fallDistance; | |
| $this->namedtag["Fire"] = $this->fireTicks; | |
| $this->namedtag["Air"] = $this->airTicks; | |
| $this->namedtag["OnGround"] = $this->onGround == true ? 1 : 0; | |
| $this->namedtag["Invulnerable"] = $this->invulnerable == true ? 1 : 0; | |
| } | |
| protected abstract function initEntity(); | |
| public function spawnTo(Player $player){ | |
| if(!isset($this->hasSpawned[$player->getID()]) and $player->chunksLoaded[$this->chunkIndex] !== 0xff){ | |
| $this->hasSpawned[$player->getID()] = $player; | |
| } | |
| } | |
| public function despawnFrom(Player $player){ | |
| if(isset($this->hasSpawned[$player->getID()])){ | |
| $pk = new RemoveEntityPacket; | |
| $pk->eid = $this->id; | |
| $player->dataPacket($pk); | |
| unset($this->hasSpawned[$player->getID()]); | |
| } | |
| } | |
| abstract function attack($damage, $source = "generic"); | |
| abstract function heal($amount, $source = "generic"); | |
| /** | |
| * @return int | |
| */ | |
| public function getHealth(){ | |
| return $this->health; | |
| } | |
| /** | |
| * Sets the health of the Entity. This won't send any update to the players | |
| * | |
| * @param int $amount | |
| */ | |
| public function setHealth($amount){ | |
| if($amount < 0){ | |
| $this->health = 0; | |
| $this->dead = true; | |
| }elseif($amount > $this->getMaxHealth()){ | |
| $this->health = $this->getMaxHealth(); | |
| }else{ | |
| $this->health = (int) $amount; | |
| } | |
| } | |
| /** | |
| * @return int | |
| */ | |
| public function getMaxHealth(){ | |
| return $this->maxHealth; | |
| } | |
| /** | |
| * @param int $amount | |
| */ | |
| public function setMaxHealth($amount){ | |
| $this->maxHealth = (int) $amount; | |
| $this->health = (int) min($this->health, $this->maxHealth); | |
| } | |
| public function onUpdate(){ | |
| if($this->closed !== false){ | |
| return false; | |
| } | |
| $timeNow = microtime(true); | |
| $this->ticksLived += ($timeNow - $this->lastUpdate) * 20; | |
| if($this->handleWaterMovement()){ | |
| $this->fallDistance = 0; | |
| $this->inWater = true; | |
| $this->extinguish(); | |
| }else{ | |
| $this->inWater = false; | |
| } | |
| if($this->fireTicks > 0){ | |
| if($this->fireProof === true){ | |
| $this->fireTicks -= 4; | |
| if($this->fireTicks < 0){ | |
| $this->fireTicks = 0; | |
| } | |
| }else{ | |
| if(($this->fireTicks % 20) === 0){ | |
| $this->attackEntity(1, "onFire"); | |
| } | |
| --$this->fireTicks; | |
| } | |
| } | |
| if($this->handleLavaMovement()){ | |
| $this->attackEntity(4, "lava"); | |
| $this->setOnFire(15); | |
| $this->fallDistance *= 0.5; | |
| } | |
| if($this->y < -64){ | |
| $this->kill(); | |
| } | |
| if($this->x !== $this->lastX or $this->y !== $this->lastY or $this->z !== $this->lastZ or $this->yaw !== $this->lastYaw or $this->pitch !== $this->lastPitch){ | |
| $this->lastX = $this->x; | |
| $this->lastY = $this->y; | |
| $this->lastZ = $this->z; | |
| $this->lastYaw = $this->yaw; | |
| $this->lastPitch = $this->pitch; | |
| if($this instanceof Human){ | |
| $pk = new MovePlayerPacket; | |
| $pk->eid = $this->id; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = $this->yaw; | |
| $pk->pitch = $this->pitch; | |
| $pk->bodyYaw = $this->yaw; | |
| }else{ | |
| $pk = new MoveEntityPacket_PosRot; | |
| $pk->eid = $this->id; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = $this->yaw; | |
| $pk->pitch = $this->pitch; | |
| } | |
| Player::broadcastPacket($this->hasSpawned, $pk); | |
| } | |
| if($this->motionChanged === true){ | |
| $this->motionChanged = false; | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->id; | |
| $pk->speedX = $this->motionX; | |
| $pk->speedY = $this->motionY; | |
| $pk->speedZ = $this->motionZ; | |
| Player::broadcastPacket($this->hasSpawned, $pk); | |
| } | |
| $this->lastUpdate = $timeNow; | |
| return false; | |
| } | |
| public final function scheduleUpdate(){ | |
| Entity::$needUpdate[$this->id] = $this; | |
| } | |
| public abstract function getMetadata(); | |
| public function setOnFire($seconds){ | |
| $ticks = $seconds * 20; | |
| if($ticks > $this->fireTicks){ | |
| $this->fireTicks = $ticks; | |
| } | |
| } | |
| public function getDirection(){ | |
| $rotation = ($this->yaw - 90) % 360; | |
| if($rotation < 0){ | |
| $rotation += 360.0; | |
| } | |
| if((0 <= $rotation and $rotation < 45) or (315 <= $rotation and $rotation < 360)){ | |
| return 2; //North | |
| }elseif(45 <= $rotation and $rotation < 135){ | |
| return 3; //East | |
| }elseif(135 <= $rotation and $rotation < 225){ | |
| return 0; //South | |
| }elseif(225 <= $rotation and $rotation < 315){ | |
| return 1; //West | |
| }else{ | |
| return null; | |
| } | |
| } | |
| public function extinguish(){ | |
| $this->fireTicks = 0; | |
| } | |
| public function canTriggerWalking(){ | |
| return true; | |
| } | |
| protected function updateFallState($distanceThisTick, $onGround){ | |
| if($onGround === true){ | |
| if($this->fallDistance > 0){ | |
| if($this instanceof Living){ | |
| //TODO | |
| } | |
| $this->fall($this->fallDistance); | |
| $this->fallDistance = 0; | |
| } | |
| }elseif($distanceThisTick < 0){ | |
| $this->fallDistance -= $distanceThisTick; | |
| } | |
| } | |
| public function getBoundingBox(){ | |
| return $this->boundingBox; | |
| } | |
| public function fall($fallDistance){ //TODO | |
| } | |
| public function handleWaterMovement(){ //TODO | |
| } | |
| public function handleLavaMovement(){ //TODO | |
| } | |
| public function getEyeHeight(){ | |
| return 0; | |
| } | |
| public function moveFlying(){ //TODO | |
| } | |
| public function onCollideWithPlayer(Human $entityPlayer){ | |
| } | |
| protected function switchLevel(Level $targetLevel){ | |
| if($this->level instanceof Level){ | |
| Server::getInstance()->getPluginManager()->callEvent($ev = new EntityLevelChangeEvent($this, $this->level, $targetLevel)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| unset($this->level->entities[$this->id]); | |
| unset($this->level->chunkEntities[$this->chunkIndex][$this->id]); | |
| $this->despawnFromAll(); | |
| if($this instanceof Player){ | |
| foreach($this->chunksLoaded as $index => $Yndex){ | |
| if($Yndex !== 0xff){ | |
| $X = null; | |
| $Z = null; | |
| LevelFormat::getXZ($index, $X, $Z); | |
| foreach($this->level->getChunkEntities($X, $Z) as $entity){ | |
| $entity->despawnFrom($this); | |
| } | |
| } | |
| } | |
| $this->level->freeAllChunks($this); | |
| } | |
| } | |
| $this->level = $targetLevel; | |
| $this->level->entities[$this->id] = $this; | |
| if($this instanceof Player){ | |
| $this->chunksLoaded = array(); | |
| $pk = new SetTimePacket(); | |
| $pk->time = $this->level->getTime(); | |
| $pk->started = $this->level->stopTime == false; | |
| $this->dataPacket($pk); | |
| } | |
| $this->spawnToAll(); | |
| $this->chunkIndex = false; | |
| } | |
| public function getPosition(){ | |
| return new Position($this->x, $this->y, $this->z, $this->level); | |
| } | |
| public function move(Vector3 $displacement){ | |
| if($displacement->x == 0 and $displacement->y == 0 and $displacement->z == 0){ | |
| return; | |
| } | |
| $x = $this->x; | |
| $y = $this->y; | |
| $z = $this->z; | |
| $this->scheduleUpdate(); | |
| } | |
| public function setPositionAndRotation(Vector3 $pos, $yaw, $pitch){ | |
| if($this->setPosition($pos) === true){ | |
| $this->setRotation($yaw, $pitch); | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function setRotation($yaw, $pitch){ | |
| $this->yaw = $yaw; | |
| $this->pitch = $pitch; | |
| $this->scheduleUpdate(); | |
| } | |
| public function setPosition(Vector3 $pos){ | |
| if($pos instanceof Position and $pos->level instanceof Level and $pos->level !== $this->level){ | |
| if($this->switchLevel($pos->level) === false){ | |
| return false; | |
| } | |
| } | |
| Server::getInstance()->getPluginManager()->callEvent($ev = new EntityMoveEvent($this, $pos)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| $this->x = $pos->x; | |
| $this->y = $pos->y; | |
| $this->z = $pos->z; | |
| $radius = $this->width / 2; | |
| if(($index = LevelFormat::getIndex($this->x >> 4, $this->z >> 4)) !== $this->chunkIndex){ | |
| if($this->chunkIndex !== false){ | |
| unset($this->level->chunkEntities[$this->chunkIndex][$this->id]); | |
| } | |
| $this->chunkIndex = $index; | |
| $this->level->loadChunk($this->x >> 4, $this->z >> 4); | |
| $newChunk = $this->level->getUsingChunk($this->x >> 4, $this->z >> 4); | |
| foreach($this->hasSpawned as $player){ | |
| if(!isset($newChunk[$player->CID])){ | |
| $this->despawnFrom($player); | |
| }else{ | |
| unset($newChunk[$player->CID]); | |
| } | |
| } | |
| foreach($newChunk as $player){ | |
| $this->spawnTo($player); | |
| } | |
| $this->level->chunkEntities[$this->chunkIndex][$this->id] = $this; | |
| } | |
| $this->boundingBox->setBounds($pos->x - $radius, $pos->y, $pos->z - $radius, $pos->x + $radius, $pos->y + $this->height, $pos->z + $radius); | |
| $this->scheduleUpdate(); | |
| return true; | |
| } | |
| public function getMotion(){ | |
| return new Vector3($this->motionX, $this->motionY, $this->motionZ); | |
| } | |
| public function setMotion(Vector3 $motion){ | |
| Server::getInstance()->getPluginManager()->callEvent($ev = new EntityMotionEvent($this, $motion)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| $this->motionX = $motion->x; | |
| $this->motionY = $motion->y; | |
| $this->motionZ = $motion->z; | |
| $this->scheduleUpdate(); | |
| } | |
| public function isOnGround(){ | |
| return $this->onGround === true; | |
| } | |
| public function kill(){ | |
| $this->dead = true; | |
| } | |
| public function getLevel(){ | |
| return $this->level; | |
| } | |
| public function teleport(Vector3 $pos, $yaw = false, $pitch = false){ | |
| $this->setMotion(new Vector3(0, 0, 0)); | |
| if($this->setPositionAndRotation($pos, $yaw === false ? $this->yaw : $yaw, $pitch === false ? $this->pitch : $pitch) !== false){ | |
| if($this instanceof Player){ | |
| $this->airTicks = 300; | |
| $this->fallDistance = 0; | |
| $this->orderChunks(); | |
| $this->getNextChunk(true); | |
| $this->forceMovement = $pos; | |
| $pk = new MovePlayerPacket; | |
| $pk->eid = 0; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->bodyYaw = $this->yaw; | |
| $pk->pitch = $this->pitch; | |
| $pk->yaw = $this->yaw; | |
| $this->dataPacket($pk); | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getID(){ | |
| return $this->id; | |
| } | |
| public function spawnToAll(){ | |
| foreach($this->level->getPlayers() as $player){ | |
| if(isset($player->id) and $player->spawned === true){ | |
| $this->spawnTo($player); | |
| } | |
| } | |
| } | |
| public function despawnFromAll(){ | |
| foreach($this->hasSpawned as $player){ | |
| $this->despawnFrom($player); | |
| } | |
| } | |
| public function close(){ | |
| if($this->closed === false){ | |
| $this->closed = true; | |
| unset(Entity::$needUpdate[$this->id]); | |
| unset($this->level->entities[$this->id]); | |
| unset($this->level->chunkEntities[$this->chunkIndex][$this->id]); | |
| unset(Entity::$list[$this->id]); | |
| $this->despawnFromAll(); | |
| Server::getInstance()->getPluginManager()->callEvent(new EntityDespawnEvent($this)); | |
| } | |
| } | |
| public function __destruct(){ | |
| $this->close(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface Explosive{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class FallingBlock extends Entity{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| abstract class Hanging extends Entity implements Attachable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| use pocketmine\event\entity\EntityArmorChangeEvent; | |
| use pocketmine\event\entity\EntityInventoryChangeEvent; | |
| use pocketmine\item\Item; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\nbt\tag\Byte; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\nbt\tag\Enum; | |
| use pocketmine\nbt\tag\Short; | |
| use pocketmine\network\protocol\AddPlayerPacket; | |
| use pocketmine\network\protocol\ContainerSetContentPacket; | |
| use pocketmine\network\protocol\PlayerArmorEquipmentPacket; | |
| use pocketmine\network\protocol\PlayerEquipmentPacket; | |
| use pocketmine\network\protocol\RemovePlayerPacket; | |
| use pocketmine\network\protocol\SetEntityMotionPacket; | |
| use pocketmine\Network; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Human extends Creature implements ProjectileSource, InventorySource{ | |
| protected $nameTag = "TESTIFICATE"; | |
| protected $inventory = array(); | |
| public $slot; | |
| protected $hotbar = array(); | |
| protected $armor = array(); | |
| protected function initEntity(){ | |
| if(isset($this->namedtag->NameTag)){ | |
| $this->nameTag = $this->namedtag["NameTag"]; | |
| } | |
| $this->hotbar = array(-1, -1, -1, -1, -1, -1, -1, -1, -1); | |
| $this->armor = array( | |
| 0 => Item::get(Item::AIR, 0, 0), | |
| 1 => Item::get(Item::AIR, 0, 0), | |
| 2 => Item::get(Item::AIR, 0, 0), | |
| 3 => Item::get(Item::AIR, 0, 0) | |
| ); | |
| foreach($this->namedtag->Inventory as $item){ | |
| if($item["Slot"] >= 0 and $item["Slot"] < 9){ //Hotbar | |
| $this->hotbar[$item["Slot"]] = isset($item["TrueSlot"]) ? $item["TrueSlot"] : -1; | |
| }elseif($item["Slot"] >= 100 and $item["Slot"] < 104){ //Armor | |
| $this->armor[$item["Slot"] - 100] = Item::get($item["id"], $item["Damage"], $item["Count"]); | |
| }else{ | |
| $this->inventory[$item["Slot"] - 9] = Item::get($item["id"], $item["Damage"], $item["Count"]); | |
| } | |
| } | |
| $this->slot = $this->hotbar[0]; | |
| $this->height = 1.8; //Or 1.62? | |
| $this->width = 0.6; | |
| } | |
| public function saveNBT(){ | |
| parent::saveNBT(); | |
| $this->namedtag->Inventory = new Enum("Inventory", array()); | |
| $this->namedtag->Inventory->setTagType(NBT::TAG_Compound); | |
| for($slot = 0; $slot < 9; ++$slot){ | |
| if(isset($this->hotbar[$slot]) and $this->hotbar[$slot] !== -1){ | |
| $item = $this->getSlot($this->hotbar[$slot]); | |
| if($item->getID() !== 0 and $item->getCount() > 0){ | |
| $this->namedtag->Inventory[$slot] = new Compound(false, array( | |
| new Byte("Count", $item->getCount()), | |
| new Short("Damage", $item->getMetadata()), | |
| new Byte("Slot", $slot), | |
| new Byte("TrueSlot", $this->hotbar[$slot]), | |
| new Short("id", $item->getID()), | |
| )); | |
| continue; | |
| } | |
| } | |
| $this->namedtag->Inventory[$slot] = new Compound(false, array( | |
| new Byte("Count", 0), | |
| new Short("Damage", 0), | |
| new Byte("Slot", $slot), | |
| new Byte("TrueSlot", -1), | |
| new Short("id", 0), | |
| )); | |
| } | |
| //Normal inventory | |
| $slotCount = Player::SURVIVAL_SLOTS + 9; | |
| //$slotCount = (($this instanceof Player and ($this->gamemode & 0x01) === 1) ? Player::CREATIVE_SLOTS : Player::SURVIVAL_SLOTS) + 9; | |
| for($slot = 9; $slot < $slotCount; ++$slot){ | |
| $item = $this->getSlot($slot - 9); | |
| $this->namedtag->Inventory[$slot] = new Compound(false, array( | |
| new Byte("Count", $item->getCount()), | |
| new Short("Damage", $item->getMetadata()), | |
| new Byte("Slot", $slot), | |
| new Short("id", $item->getID()), | |
| )); | |
| } | |
| //Armor | |
| for($slot = 100; $slot < 104; ++$slot){ | |
| $item = $this->armor[$slot - 100]; | |
| if($item instanceof Item){ | |
| $this->namedtag->Inventory[$slot] = new Compound(false, array( | |
| new Byte("Count", $item->getCount()), | |
| new Short("Damage", $item->getMetadata()), | |
| new Byte("Slot", $slot), | |
| new Short("id", $item->getID()), | |
| )); | |
| } | |
| } | |
| } | |
| public function spawnTo(Player $player){ | |
| if($player !== $this and !isset($this->hasSpawned[$player->getID()])){ | |
| $this->hasSpawned[$player->getID()] = $player; | |
| $pk = new AddPlayerPacket; | |
| $pk->clientID = 0; | |
| $pk->username = $this->nameTag; | |
| $pk->eid = $this->id; | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->yaw = 0; | |
| $pk->pitch = 0; | |
| $pk->unknown1 = 0; | |
| $pk->unknown2 = 0; | |
| $pk->metadata = $this->getMetadata(); | |
| $player->dataPacket($pk); | |
| $pk = new SetEntityMotionPacket; | |
| $pk->eid = $this->id; | |
| $pk->speedX = $this->motionX; | |
| $pk->speedY = $this->motionY; | |
| $pk->speedZ = $this->motionZ; | |
| $player->dataPacket($pk); | |
| $this->sendCurrentEquipmentSlot($player); | |
| $this->sendArmor($player); | |
| } | |
| } | |
| public function despawnFrom(Player $player){ | |
| if(isset($this->hasSpawned[$player->getID()])){ | |
| $pk = new RemovePlayerPacket; | |
| $pk->eid = $this->id; | |
| $pk->clientID = 0; | |
| $player->dataPacket($pk); | |
| unset($this->hasSpawned[$player->getID()]); | |
| } | |
| } | |
| public function setEquipmentSlot($equipmentSlot, $inventorySlot){ | |
| $this->hotbar[$equipmentSlot] = $inventorySlot; | |
| if($equipmentSlot === $this->slot){ | |
| foreach($this->hasSpawned as $p){ | |
| $this->sendCurrentEquipmentSlot($p); | |
| } | |
| } | |
| } | |
| public function getEquipmentSlot($equipmentSlot){ | |
| if(isset($this->hotbar[$equipmentSlot])){ | |
| return $this->hotbar[$equipmentSlot]; | |
| } | |
| return -1; | |
| } | |
| public function setCurrentEquipmentSlot($slot){ | |
| if(isset($this->hotbar[$slot])){ | |
| $this->slot = (int) $slot; | |
| foreach($this->hasSpawned as $p){ | |
| $this->sendCurrentEquipmentSlot($p); | |
| } | |
| } | |
| } | |
| public function getCurrentEquipmentSlot(){ | |
| return $this->slot; | |
| } | |
| public function getCurrentEquipment(){ | |
| if($this->slot > -1) { | |
| return $this->hotbar[$this->slot]; | |
| } | |
| } | |
| public function sendCurrentEquipmentSlot(Player $player){ | |
| $pk = new PlayerEquipmentPacket; | |
| $pk->eid = $this->id; | |
| $pk->item = $this->getSlot($this->slot)->getID(); | |
| $pk->meta = $this->getSlot($this->slot)->getMetadata(); | |
| $pk->slot = 0; | |
| $player->dataPacket($pk); | |
| } | |
| public function setArmorSlot($slot, Item $item){ | |
| Server::getInstance()->getPluginManager()->callEvent($ev = new EntityArmorChangeEvent($this, $this->getArmorSlot($slot), $item, $slot)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| $this->armor[(int) $slot] = $ev->getNewItem(); | |
| foreach($this->hasSpawned as $p){ | |
| $this->sendArmor($p); | |
| } | |
| if($this instanceof Player){ | |
| $this->sendArmor(); | |
| } | |
| return true; | |
| } | |
| public function getArmorSlot($slot){ | |
| $slot = (int) $slot; | |
| if(!isset($this->armor[$slot])){ | |
| $this->armor[$slot] = Item::get(Item::AIR, 0, 0); | |
| } | |
| return $this->armor[$slot]; | |
| } | |
| public function sendArmor($player = null){ | |
| $slots = array(); | |
| for($i = 0; $i < 4; ++$i){ | |
| if(isset($this->armor[$i]) and ($this->armor[$i] instanceof Item) and $this->armor[$i]->getID() > Item::AIR){ | |
| $slots[$i] = $this->armor[$i]->getID() !== Item::AIR ? $this->armor[$i]->getID() - 256 : 0; | |
| }else{ | |
| $this->armor[$i] = Item::get(Item::AIR, 0, 0); | |
| $slots[$i] = 255; | |
| } | |
| } | |
| if($player instanceof Player){ | |
| $pk = new PlayerArmorEquipmentPacket(); | |
| $pk->eid = $this->id; | |
| $pk->slots = $slots; | |
| $player->dataPacket($pk); | |
| }elseif($this instanceof Player){ | |
| $pk = new ContainerSetContentPacket; | |
| $pk->windowid = 0x78; //Armor window id | |
| $pk->slots = $this->armor; | |
| $this->dataPacket($pk); | |
| } | |
| } | |
| public function getMetadata(){ //TODO | |
| $flags = 0; | |
| $flags |= $this->fireTicks > 0 ? 1 : 0; | |
| //$flags |= ($this->crouched === true ? 0b10:0) << 1; | |
| //$flags |= ($this->inAction === true ? 0b10000:0); | |
| $d = array( | |
| 0 => array("type" => 0, "value" => $flags), | |
| 1 => array("type" => 1, "value" => $this->airTicks), | |
| 16 => array("type" => 0, "value" => 0), | |
| 17 => array("type" => 6, "value" => array(0, 0, 0)), | |
| ); | |
| /*if($this->class === ENTITY_MOB and $this->type === MOB_SHEEP){ | |
| if(!isset($this->data["Sheared"])){ | |
| $this->data["Sheared"] = 0; | |
| $this->data["Color"] = mt_rand(0,15); | |
| } | |
| $d[16]["value"] = (($this->data["Sheared"] == 1 ? 1:0) << 4) | ($this->data["Color"] & 0x0F); | |
| }elseif($this->type === OBJECT_PRIMEDTNT){ | |
| $d[16]["value"] = (int) max(0, $this->data["fuse"] - (microtime(true) - $this->spawntime) * 20); | |
| }elseif($this->class === ENTITY_PLAYER){ | |
| if($this->player->sleeping !== false){ | |
| $d[16]["value"] = 2; | |
| $d[17]["value"] = array($this->player->sleeping->x, $this->player->sleeping->y, $this->player->sleeping->z); | |
| } | |
| }*/ | |
| return $d; | |
| } | |
| public function attack($damage, $source = "generic"){ | |
| } | |
| public function heal($amount, $source = "generic"){ | |
| } | |
| public function hasItem(Item $item, $checkDamage = true){ | |
| foreach($this->inventory as $s => $i){ | |
| if($i->equals($item, $checkDamage)){ | |
| return $i; | |
| } | |
| } | |
| return false; | |
| } | |
| public function canAddItem(Item $item){ | |
| $inv = $this->inventory; | |
| while($item->getCount() > 0){ | |
| $add = 0; | |
| foreach($inv as $s => $i){ | |
| if($i->getID() === Item::AIR){ | |
| $add = min($i->getMaxStackSize(), $item->getCount()); | |
| $inv[$s] = clone $item; | |
| $inv[$s]->setCount($add); | |
| break; | |
| }elseif($i->equals($item)){ | |
| $add = min($i->getMaxStackSize() - $i->getCount(), $item->getCount()); | |
| if($add <= 0){ | |
| continue; | |
| } | |
| $inv[$s] = clone $item; | |
| $inv[$s]->setCount($i->getCount() + $add); | |
| break; | |
| } | |
| } | |
| if($add <= 0){ | |
| return false; | |
| } | |
| $item->setCount($item->getCount() - $add); | |
| } | |
| return true; | |
| } | |
| public function addItem(Item $item){ | |
| while($item->getCount() > 0){ | |
| $add = 0; | |
| foreach($this->inventory as $s => $i){ | |
| if($i->getID() === Item::AIR){ | |
| $add = min($i->getMaxStackSize(), $item->getCount()); | |
| $i2 = clone $item; | |
| $i2->setCount($add); | |
| $this->setSlot($s, $i2); | |
| break; | |
| }elseif($i->equals($item)){ | |
| $add = min($i->getMaxStackSize() - $i->getCount(), $item->getCount()); | |
| if($add <= 0){ | |
| continue; | |
| } | |
| $i2 = clone $item; | |
| $i2->setCount($i->getCount() + $add); | |
| $this->setSlot($s, $i2); | |
| break; | |
| } | |
| } | |
| if($add <= 0){ | |
| return false; | |
| } | |
| $item->setCount($item->getCount() - $add); | |
| } | |
| return true; | |
| } | |
| public function canRemoveItem(Item $item, $checkDamage = true){ | |
| return $this->hasItem($item, $checkDamage); | |
| } | |
| public function removeItem(Item $item, $checkDamage = true){ | |
| while($item->getCount() > 0){ | |
| $remove = 0; | |
| foreach($this->inventory as $s => $i){ | |
| if($i->equals($item, $checkDamage)){ | |
| $remove = min($item->getCount(), $i->getCount()); | |
| if($item->getCount() < $i->getCount()){ | |
| $i->setCount($i->getCount() - $item->getCount()); | |
| $this->setSlot($s, $i); | |
| }else{ | |
| $this->setSlot($s, Item::get(Item::AIR, 0, 0)); | |
| } | |
| break; | |
| } | |
| } | |
| if($remove <= 0){ | |
| return false; | |
| } | |
| $item->setCount($item->getCount() - $remove); | |
| } | |
| return true; | |
| } | |
| public function setSlot($slot, Item $item){ | |
| Server::getInstance()->getPluginManager()->callEvent($ev = new EntityInventoryChangeEvent($this, $this->getSlot($slot), $item, $slot)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| $this->inventory[(int) $slot] = $ev->getNewItem(); | |
| return true; | |
| } | |
| /** | |
| * @param int $slot | |
| * | |
| * @return Item | |
| */ | |
| public function getSlot($slot){ | |
| $slot = (int) $slot; | |
| if(!isset($this->inventory[$slot])){ | |
| $this->inventory[$slot] = Item::get(Item::AIR, 0, 0); | |
| } | |
| return $this->inventory[$slot]; | |
| } | |
| public function getAllSlots(){ | |
| return $this->inventory; | |
| } | |
| public function getSlotCount(){ | |
| return count($this->inventory); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| use pocketmine\item\Item; | |
| interface InventorySource{ | |
| public function hasItem(Item $item, $checkDamage = true); | |
| public function canAddItem(Item $item); | |
| /** | |
| * @param Item $item | |
| * | |
| * @return boolean hasBeenAdded | |
| */ | |
| public function addItem(Item $item); | |
| public function canRemoveItem(Item $item, $checkDamage = true); | |
| /** | |
| * @param Item $item | |
| * @param boolean $checkDamage | |
| * | |
| * @return boolean hasBeenRemoved | |
| */ | |
| public function removeItem(Item $item, $checkDamage = true); | |
| public function getSlotCount(); | |
| public function getAllSlots(); | |
| public function getSlot($slot); | |
| public function setSlot($slot, Item $item); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| abstract class Living extends Entity implements Damageable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Minecart extends Vehicle{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| abstract class Monster extends Creature{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface NPC{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Ocelot extends Animal implements Tameable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Painting extends Hanging{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Pig extends Animal implements Rideable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class PigZombie extends Zombie{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| abstract class Projectile extends Entity{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface ProjectileSource{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface Rideable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Sheep extends Animal implements Colorable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Silverfish extends Monster{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Skeleton extends Monster implements ProjectileSource{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Slime extends Living{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Snowball extends Projectile{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Spider extends Monster{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| interface Tameable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class TNTPrimed extends Entity implements Explosive{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| abstract class Vehicle extends Entity implements Rideable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Villager extends Creature implements NPC, Ageable{ | |
| const FARMER = 0; | |
| const LIBRARIAN = 1; | |
| const PRIEST = 2; | |
| const BLACKSMITH = 3; | |
| const BUTCHER = 4; | |
| /** | |
| * Sets the villager profession | |
| * | |
| * @param $profession | |
| */ | |
| public function setProfession($profession){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Wolf extends Animal implements Tameable{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\entity; | |
| class Zombie extends Monster{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\block; | |
| use pocketmine\block\Block; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class BlockBreakEvent extends BlockEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var \pocketmine\Player */ | |
| protected $player; | |
| /** @var \pocketmine\item\Item */ | |
| protected $item; | |
| /** @var bool */ | |
| protected $instaBreak = false; | |
| public function __construct(Player $player, Block $block, Item $item, $instaBreak = false){ | |
| $this->block = $block; | |
| $this->item = $item; | |
| $this->player = $player; | |
| $this->instaBreak = (bool) $instaBreak; | |
| } | |
| public function getPlayer(){ | |
| return $this->player; | |
| } | |
| public function getItem(){ | |
| return $this->item; | |
| } | |
| public function getInstaBreak(){ | |
| return $this->instaBreak; | |
| } | |
| /** | |
| * @param boolean $instaBreak | |
| */ | |
| public function setInstaBreak($instaBreak){ | |
| $this->instaBreak = (bool) $instaBreak; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Block related events | |
| */ | |
| namespace pocketmine\event\block; | |
| use pocketmine\event\Event; | |
| abstract class BlockEvent extends Event{ | |
| /** @var \pocketmine\block\Block */ | |
| protected $block; | |
| public function getBlock(){ | |
| return $this->block; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\block; | |
| use pocketmine\block\Block; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player places a block | |
| */ | |
| class BlockPlaceEvent extends BlockEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var \pocketmine\Player */ | |
| protected $player; | |
| /** @var \pocketmine\item\Item */ | |
| protected $item; | |
| protected $blockReplace; | |
| protected $blockAgainst; | |
| public function __construct(Player $player, Block $blockPlace, Block $blockReplace, Block $blockAgainst, Item $item){ | |
| $this->block = $blockPlace; | |
| $this->blockReplace = $blockReplace; | |
| $this->blockAgainst = $blockAgainst; | |
| $this->item = $item; | |
| $this->player = $player; | |
| } | |
| public function getPlayer(){ | |
| return $this->player; | |
| } | |
| /** | |
| * Gets the item in hand | |
| * | |
| * @return mixed | |
| */ | |
| public function getItem(){ | |
| return $this->item; | |
| } | |
| public function getBlockReplaced(){ | |
| return $this->blockReplace; | |
| } | |
| public function getBlockAgainst(){ | |
| return $this->blockAgainst; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event; | |
| /** | |
| * Events that can be cancelled must use the interface Cancellable | |
| */ | |
| interface Cancellable{ | |
| public function isCancelled(); | |
| public function setCancelled($forceCancel = false); | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\item\Item; | |
| class EntityArmorChangeEvent extends EntityEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $oldItem; | |
| private $newItem; | |
| private $slot; | |
| public function __construct(Entity $entity, Item $oldItem, Item $newItem, $slot){ | |
| $this->entity = $entity; | |
| $this->oldItem = $oldItem; | |
| $this->newItem = $newItem; | |
| $this->slot = (int) $slot; | |
| } | |
| public function getSlot(){ | |
| return $this->slot; | |
| } | |
| public function getNewItem(){ | |
| return $this->newItem; | |
| } | |
| public function setNewItem(Item $item){ | |
| $this->newItem = $item; | |
| } | |
| public function getOldItem(){ | |
| return $this->oldItem; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\entity\Creature; | |
| use pocketmine\entity\DroppedItem; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\entity\Human; | |
| use pocketmine\entity\Projectile; | |
| use pocketmine\entity\Vehicle; | |
| /** | |
| * Called when a entity is despawned | |
| */ | |
| class EntityDespawnEvent extends EntityEvent{ | |
| public static $handlerList = null; | |
| /** | |
| * @param Entity $entity | |
| */ | |
| public function __construct(Entity $entity){ | |
| $this->entity = $entity; | |
| } | |
| /** | |
| * @return int | |
| */ | |
| public function getType(){ | |
| //TODO: implement Entity types | |
| return -1; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isCreature(){ | |
| return $this->entity instanceof Creature; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isHuman(){ | |
| return $this->entity instanceof Human; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isProjectile(){ | |
| return $this->entity instanceof Projectile; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isVehicle(){ | |
| return $this->entity instanceof Vehicle; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isItem(){ | |
| return $this->entity instanceof DroppedItem; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Entity related Events, like spawn, inventory, attack... | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\event\Event; | |
| abstract class EntityEvent extends Event{ | |
| /** @var \pocketmine\entity\Entity */ | |
| protected $entity; | |
| public function getEntity(){ | |
| return $this->entity; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\block\Block; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\level\Position; | |
| /** | |
| * Called when a entity explodes | |
| */ | |
| class EntityExplodeEvent extends EntityEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var Position */ | |
| protected $position; | |
| /** | |
| * @var Block[] | |
| */ | |
| protected $blocks; | |
| /** @var float */ | |
| protected $yield; | |
| /** | |
| * @param Entity $entity | |
| * @param Position $position | |
| * @param Block[] $blocks | |
| * @param float $yield | |
| */ | |
| public function __construct(Entity $entity, Position $position, array $blocks, $yield){ | |
| $this->entity = $entity; | |
| $this->position = $position; | |
| $this->blocks = $blocks; | |
| $this->yield = $yield; | |
| } | |
| /** | |
| * @return Position | |
| */ | |
| public function getPosition(){ | |
| return $this->position; | |
| } | |
| /** | |
| * @return Block[] | |
| */ | |
| public function getBlockList(){ | |
| return $this->blocks; | |
| } | |
| /** | |
| * @param Block[] $blocks | |
| */ | |
| public function setBlockList(array $blocks){ | |
| $this->blocks = $blocks; | |
| } | |
| /** | |
| * @return float | |
| */ | |
| public function getYield(){ | |
| return $this->yield; | |
| } | |
| /** | |
| * @param float $yield | |
| */ | |
| public function setYield($yield){ | |
| $this->yield = $yield; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\item\Item; | |
| class EntityInventoryChangeEvent extends EntityEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $oldItem; | |
| private $newItem; | |
| private $slot; | |
| public function __construct(Entity $entity, Item $oldItem, Item $newItem, $slot){ | |
| $this->entity = $entity; | |
| $this->oldItem = $oldItem; | |
| $this->newItem = $newItem; | |
| $this->slot = (int) $slot; | |
| } | |
| public function getSlot(){ | |
| return $this->slot; | |
| } | |
| public function getNewItem(){ | |
| return $this->newItem; | |
| } | |
| public function setNewItem(Item $item){ | |
| $this->newItem = $item; | |
| } | |
| public function getOldItem(){ | |
| return $this->oldItem; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\level\Level; | |
| class EntityLevelChangeEvent extends EntityEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $originLevel; | |
| private $targetLevel; | |
| public function __construct(Entity $entity, Level $originLevel, Level $targetLevel){ | |
| $this->entity = $entity; | |
| $this->originLevel = $originLevel; | |
| $this->targetLevel = $targetLevel; | |
| } | |
| public function getOrigin(){ | |
| return $this->originLevel; | |
| } | |
| public function getTarget(){ | |
| return $this->targetLevel; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\math\Vector3 as Vector3; | |
| class EntityMotionEvent extends EntityEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $mot; | |
| public function __construct(Entity $entity, Vector3 $mot){ | |
| $this->entity = $entity; | |
| $this->mot = $mot; | |
| } | |
| public function getVector(){ | |
| return $this->mot; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\math\Vector3 as Vector3; | |
| class EntityMoveEvent extends EntityEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var \pocketmine\math\Vector3 */ | |
| private $pos; | |
| public function __construct(Entity $entity, Vector3 $pos){ | |
| $this->entity = $entity; | |
| $this->pos = $pos; | |
| } | |
| public function getVector(){ | |
| return $this->pos; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\entity; | |
| use pocketmine\entity\Creature; | |
| use pocketmine\entity\DroppedItem; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\entity\Human; | |
| use pocketmine\entity\Projectile; | |
| use pocketmine\entity\Vehicle; | |
| /** | |
| * Called when a entity is spawned | |
| */ | |
| class EntitySpawnEvent extends EntityEvent{ | |
| public static $handlerList = null; | |
| /** | |
| * @param Entity $entity | |
| */ | |
| public function __construct(Entity $entity){ | |
| $this->entity = $entity; | |
| } | |
| /** | |
| * @return \pocketmine\level\Position | |
| */ | |
| public function getPosition(){ | |
| return $this->entity->getPosition(); | |
| } | |
| /** | |
| * @return int | |
| */ | |
| public function getType(){ | |
| //TODO: implement Entity types | |
| return -1; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isCreature(){ | |
| return $this->entity instanceof Creature; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isHuman(){ | |
| return $this->entity instanceof Human; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isProjectile(){ | |
| return $this->entity instanceof Projectile; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isVehicle(){ | |
| return $this->entity instanceof Vehicle; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isItem(){ | |
| return $this->entity instanceof DroppedItem; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Event related classes | |
| */ | |
| namespace pocketmine\event; | |
| abstract class Event{ | |
| /** | |
| * Any callable event must declare the static variable | |
| * | |
| * public static $handlerList = null; | |
| * | |
| * Not doing so will deny the proper event initialization | |
| */ | |
| protected $eventName = null; | |
| private $isCancelled = false; | |
| /** | |
| * @return string | |
| */ | |
| final public function getEventName(){ | |
| return $this->eventName !== null ? get_class($this) : $this->eventName; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isCancelled(){ | |
| return $this->isCancelled === true; | |
| } | |
| /** | |
| * @param bool $value | |
| * | |
| * @return bool | |
| */ | |
| public function setCancelled($value = true){ | |
| $this->isCancelled = (bool) $value; | |
| } | |
| /** | |
| * @return HandlerList | |
| */ | |
| public function getHandlers(){ | |
| if(static::$handlerList === null){ | |
| static::$handlerList = new HandlerList(); | |
| } | |
| return static::$handlerList; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event; | |
| /** | |
| * List of event prioritoes | |
| */ | |
| abstract class EventPriority{ | |
| /** | |
| * Event call is of very low importance and should be ran first, to allow | |
| * other plugins to further customise the outcome | |
| */ | |
| const LOWEST = 5; | |
| /** | |
| * Event call is of low importance | |
| */ | |
| const LOW = 4; | |
| /** | |
| * Event call is neither important or unimportant, and may be ran normally | |
| */ | |
| const NORMAL = 3; | |
| /** | |
| * Event call is of high importance | |
| */ | |
| const HIGH = 2; | |
| /** | |
| * Event call is critical and must have the final say in what happens | |
| * to the event | |
| */ | |
| const HIGHEST = 1; | |
| /** | |
| * Event is listened to purely for monitoring the outcome of an event. | |
| * | |
| * No modifications to the event should be made under this priority | |
| */ | |
| const MONITOR = 0; | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event; | |
| use pocketmine\plugin\Plugin; | |
| use pocketmine\plugin\RegisteredListener; | |
| class HandlerList{ | |
| /** | |
| * @var RegisteredListener[] | |
| */ | |
| private $handlers = null; | |
| /** | |
| * @var RegisteredListener[][] | |
| */ | |
| private $handlerSlots = array(); | |
| /** | |
| * @var HandlerList[] | |
| */ | |
| private static $allLists = array(); | |
| public static function bakeAll(){ | |
| foreach(self::$allLists as $h){ | |
| $h->bake(); | |
| } | |
| } | |
| /** | |
| * Unregisters all the listeners | |
| * If a Plugin or Listener is passed, all the listeners with that object will be removed | |
| * | |
| * @param Plugin|Listener|null $object | |
| */ | |
| public static function unregisterAll($object = null){ | |
| if($object instanceof Listener or $object instanceof Plugin){ | |
| foreach(self::$allLists as $h){ | |
| $h->unregister($object); | |
| } | |
| }else{ | |
| foreach(self::$allLists as $h){ | |
| foreach($h->handlerSlots as $key => $list){ | |
| $h->handlerSlots[$key] = array(); | |
| } | |
| $h->handlers = null; | |
| } | |
| } | |
| } | |
| public function __construct(){ | |
| $this->handlerSlots = array( | |
| EventPriority::MONITOR => array(), | |
| EventPriority::HIGHEST => array(), | |
| EventPriority::HIGH => array(), | |
| EventPriority::NORMAL => array(), | |
| EventPriority::LOW => array(), | |
| EventPriority::LOWEST => array() | |
| ); | |
| self::$allLists[] = $this; | |
| } | |
| public function register(RegisteredListener $listener){ | |
| if($listener->getPriority() < EventPriority::MONITOR or $listener->getPriority() > EventPriority::LOWEST){ | |
| return; | |
| } | |
| if(isset($this->handlerSlots[$listener->getPriority()][spl_object_hash($listener)])){ | |
| trigger_error("This listener is already registered to priority " . $listener->getPriority(), E_USER_WARNING); | |
| return; | |
| } | |
| $this->handlers = null; | |
| $this->handlerSlots[$listener->getPriority()][spl_object_hash($listener)] = $listener; | |
| } | |
| /** | |
| * @param RegisteredListener[] $listeners | |
| */ | |
| public function registerAll(array $listeners){ | |
| foreach($listeners as $listener){ | |
| $this->register($listener); | |
| } | |
| } | |
| /** | |
| * @param RegisteredListener|Listener|Plugin $object | |
| */ | |
| public function unregister($object){ | |
| if($object instanceof Plugin or $object instanceof Listener){ | |
| $changed = false; | |
| foreach($this->handlerSlots as $priority => $list){ | |
| foreach($list as $hash => $listener){ | |
| if(($object instanceof Plugin and $listener->getPlugin() === $object) | |
| or ($object instanceof Listener and $listener->getListener() === $object) | |
| ){ | |
| unset($this->handlerSlots[$priority][$hash]); | |
| $changed = true; | |
| } | |
| } | |
| } | |
| if($changed === true){ | |
| $this->handlers = null; | |
| } | |
| }elseif($object instanceof RegisteredListener){ | |
| if(isset($this->handlerSlots[$object->getPriority()][spl_object_hash($listener)])){ | |
| unset($this->handlerSlots[$object->getPriority()][spl_object_hash($listener)]); | |
| $this->handlers = null; | |
| } | |
| } | |
| } | |
| public function bake(){ | |
| if($this->handlers !== null){ | |
| return; | |
| } | |
| $entries = array(); | |
| foreach($this->handlerSlots as $list){ | |
| foreach($list as $hash => $listener){ | |
| $entries[$hash] = $listener; | |
| } | |
| } | |
| $this->handlers = $entries; | |
| } | |
| /** | |
| * @param null|Plugin $plugin | |
| * | |
| * @return RegisteredListener[] | |
| */ | |
| public function getRegisteredListeners($plugin = null){ | |
| if($plugin instanceof Plugin){ | |
| $listeners = array(); | |
| foreach($this->getRegisteredListeners(null) as $hash => $listener){ | |
| if($listener->getPlugin() === $plugin){ | |
| $listeners[$hash] = $plugin; | |
| } | |
| } | |
| return $listeners; | |
| }else{ | |
| while(($handlers = $this->handlers) === null){ | |
| $this->bake(); | |
| } | |
| return $handlers; | |
| } | |
| } | |
| /** | |
| * @return HandlerList[] | |
| */ | |
| public static function getHandlerLists(){ | |
| return self::$allLists; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Inventory related events | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Event; | |
| abstract class InventoryEvent extends Event{ | |
| /** @var Inventory */ | |
| protected $inventory; | |
| /** | |
| * @return Inventory | |
| */ | |
| public function getInventory(){ | |
| return $this->inventory; | |
| } | |
| /** | |
| * @return \pocketmine\entity\Human[] | |
| */ | |
| public function getViewers(){ | |
| return $this->inventory->getViewers(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event; | |
| interface Listener{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player is awarded an achievement | |
| */ | |
| class PlayerAchievementAwardedEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $achievement; | |
| /** | |
| * @param Player $player | |
| * @param string $achievementId | |
| */ | |
| public function __construct(Player $player, $achievementId){ | |
| $this->player = $player; | |
| $this->achievement = $achievementId; | |
| } | |
| public function getAchievement(){ | |
| return $this->achievement; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| /** | |
| * Called when a player chats something | |
| */ | |
| class PlayerChatEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $message; | |
| /** @var string */ | |
| protected $format; | |
| /** | |
| * @var Player[] | |
| */ | |
| protected $recipients = array(); | |
| public function __construct(Player $player, $message, $format = "<%s> %s", array $recipients = null){ | |
| $this->player = $player; | |
| $this->message = $message; | |
| $this->format = $format; | |
| if($recipients === null){ | |
| $this->recipients = Server::getInstance()->getPluginManager()->getPermissionSubscriptions(Server::BROADCAST_CHANNEL_USERS); | |
| }else{ | |
| $this->recipients = $recipients; | |
| } | |
| } | |
| public function getMessage(){ | |
| return $this->message; | |
| } | |
| public function setMessage($message){ | |
| $this->message = $message; | |
| } | |
| /** | |
| * Changes the player that is sending the message | |
| * | |
| * @param Player $player | |
| */ | |
| public function setPlayer(Player $player){ | |
| if($player instanceof Player){ | |
| $this->player = $player; | |
| } | |
| } | |
| public function getFormat(){ | |
| return $this->format; | |
| } | |
| public function setFormat($format){ | |
| $this->format = $format; | |
| } | |
| public function getRecipients(){ | |
| return $this->recipients; | |
| } | |
| public function setRecipients(array $recipients){ | |
| $this->recipients = $recipients; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player runs a command or chats, early in the process | |
| * | |
| * You don't want to use this except for a few cases like logging commands, | |
| * blocking commands on certain places, or applying modifiers. | |
| * | |
| * The message contains a slash at the start | |
| */ | |
| class PlayerCommandPreprocessEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $message; | |
| /** | |
| * @param Player $player | |
| * @param string $message | |
| */ | |
| public function __construct(Player $player, $message){ | |
| $this->player = $player; | |
| $this->message = $message; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getMessage(){ | |
| return $this->message; | |
| } | |
| /** | |
| * @param string $message | |
| */ | |
| public function setMessage($message){ | |
| $this->message = $message; | |
| } | |
| /** | |
| * @param Player $player | |
| */ | |
| public function setPlayer(Player $player){ | |
| $this->player = $player; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Player-only related events | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Event; | |
| abstract class PlayerEvent extends Event{ | |
| /** @var \pocketmine\Player */ | |
| protected $player; | |
| public function getPlayer(){ | |
| return $this->player; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player has its gamemode changed | |
| */ | |
| class PlayerGameModeChangeEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var int */ | |
| protected $gamemode; | |
| public function __construct(Player $player, $newGamemode){ | |
| $this->player = $player; | |
| $this->gamemode = (int) $newGamemode; | |
| } | |
| public function getNewGamemode(){ | |
| return $this->gamemode; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\block\Block; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player interacts or touches a block (including air?) | |
| */ | |
| class PlayerInteractEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** | |
| * @var \pocketmine\block\Block; | |
| */ | |
| protected $blockTouched; | |
| /** @var int */ | |
| protected $blockFace; | |
| /** @var \pocketmine\item\Item */ | |
| protected $item; | |
| public function __construct(Player $player, Item $item, Block $block, $face){ | |
| $this->blockTouched = $block; | |
| $this->player = $player; | |
| $this->item = $item; | |
| $this->blockFace = (int) $face; | |
| } | |
| public function getItem(){ | |
| return $this->item; | |
| } | |
| public function getBlock(){ | |
| return $this->blockTouched; | |
| } | |
| public function getFace(){ | |
| return $this->blockFace; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\item\Item; | |
| use pocketmine\Player; | |
| class PlayerItemHeldEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $item; | |
| private $slot; | |
| private $inventorySlot; | |
| public function __construct(Player $player, Item $item, $inventorySlot, $slot){ | |
| $this->player = $player; | |
| $this->item = $item; | |
| $this->inventorySlot = (int) $inventorySlot; | |
| $this->slot = (int) $slot; | |
| } | |
| public function getSlot(){ | |
| return $this->slot; | |
| } | |
| public function getInventorySlot(){ | |
| return $this->inventorySlot; | |
| } | |
| public function getItem(){ | |
| return $this->item; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player joins the server, after sending all the spawn packets | |
| */ | |
| class PlayerJoinEvent extends PlayerEvent{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $joinMessage; | |
| public function __construct(Player $player, $joinMessage){ | |
| $this->player = $player; | |
| $this->joinMessage = $joinMessage; | |
| } | |
| /** | |
| * Sets the join message. This won't work on Minecraft: PE <= 0.8.1, since the join message is client-side | |
| * We'll see if Mojang adds this in Minecraft: PE 0.9.0 ^.^ | |
| * | |
| * @param string $joinMessage | |
| */ | |
| public function setJoinMessage($joinMessage){ | |
| $this->joinMessage = $joinMessage; | |
| } | |
| public function getJoinMessage(){ | |
| return $this->joinMessage; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player leaves the server | |
| */ | |
| class PlayerKickEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $quitMessage; | |
| /** @var string */ | |
| protected $reason; | |
| public function __construct(Player $player, $reason, $quitMessage){ | |
| $this->player = $player; | |
| $this->quitMessage = $quitMessage; | |
| $this->reason = $reason; | |
| } | |
| public function getReason(){ | |
| return $this->reason; | |
| } | |
| public function setQuitMessage($quitMessage){ | |
| $this->quitMessage = $quitMessage; | |
| } | |
| public function getQuitMessage(){ | |
| return $this->quitMessage; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player joins, after things have been correctly set up (you can change anything now) | |
| */ | |
| class PlayerLoginEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $kickMessage; | |
| public function __construct(Player $player, $kickMessage){ | |
| $this->player = $player; | |
| $this->kickMessage = $kickMessage; | |
| } | |
| public function setKickMessage($kickMessage){ | |
| $this->kickMessage = $kickMessage; | |
| } | |
| public function getKickMessage(){ | |
| return $this->kickMessage; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Player; | |
| /** | |
| * Called when the player logs in, before things have been set up | |
| */ | |
| class PlayerPreLoginEvent extends PlayerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $kickMessage; | |
| public function __construct(Player $player, $kickMessage){ | |
| $this->player = $player; | |
| $this->kickMessage = $kickMessage; | |
| } | |
| public function setKickMessage($kickMessage){ | |
| $this->kickMessage = $kickMessage; | |
| } | |
| public function getKickMessage(){ | |
| return $this->kickMessage; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player leaves the server | |
| */ | |
| class PlayerQuitEvent extends PlayerEvent{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $quitMessage; | |
| public function __construct(Player $player, $quitMessage){ | |
| $this->player = $player; | |
| $this->quitMessage = $quitMessage; | |
| } | |
| public function setQuitMessage($quitMessage){ | |
| $this->quitMessage = $quitMessage; | |
| } | |
| public function getQuitMessage(){ | |
| return $this->quitMessage; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\player; | |
| use pocketmine\level\Position; | |
| use pocketmine\Player; | |
| /** | |
| * Called when a player is respawned (or first time spawned) | |
| */ | |
| class PlayerRespawnEvent extends PlayerEvent{ | |
| public static $handlerList = null; | |
| /** @var Position */ | |
| protected $position; | |
| /** | |
| * @param Player $player | |
| * @param Position $position | |
| */ | |
| public function __construct(Player $player, Position $position){ | |
| $this->player = $player; | |
| $this->position = $position; | |
| } | |
| /** | |
| * @return Position | |
| */ | |
| public function getRespawnPosition(){ | |
| return $this->position; | |
| } | |
| /** | |
| * @param Position $position | |
| */ | |
| public function setRespawnPosition(Position $position){ | |
| $this->position = $position; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\plugin; | |
| use pocketmine\event\Event; | |
| use pocketmine\plugin\Plugin; | |
| class PluginDisableEvent extends Event{ | |
| public static $handlerList = null; | |
| /** | |
| * @param Plugin $plugin | |
| */ | |
| public function __construct(Plugin $plugin){ | |
| $this->plugin = $plugin; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\plugin; | |
| use pocketmine\event\Event; | |
| use pocketmine\plugin\Plugin; | |
| class PluginEnableEvent extends Event{ | |
| public static $handlerList = null; | |
| /** | |
| * @param Plugin $plugin | |
| */ | |
| public function __construct(Plugin $plugin){ | |
| $this->plugin = $plugin; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Events related Plugin enable / disable events | |
| */ | |
| namespace pocketmine\event\plugin; | |
| use pocketmine\event\Event; | |
| use pocketmine\plugin\Plugin; | |
| abstract class PluginEvent extends Event{ | |
| /** @var Plugin */ | |
| private $plugin; | |
| /** | |
| * @return Plugin | |
| */ | |
| public function getPlugin(){ | |
| return $this->plugin; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\server; | |
| use pocketmine\event; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\network\protocol\DataPacket; | |
| use pocketmine\Player; | |
| class DataPacketReceiveEvent extends ServerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $packet; | |
| private $player; | |
| public function __construct(Player $player, DataPacket $packet){ | |
| $this->packet = $packet; | |
| $this->player = $player; | |
| } | |
| public function getPacket(){ | |
| return $this->packet; | |
| } | |
| public function getPlayer(){ | |
| return $this->player; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\server; | |
| use pocketmine\event; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\network\protocol\DataPacket; | |
| use pocketmine\Player; | |
| class DataPacketSendEvent extends ServerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $packet; | |
| private $player; | |
| public function __construct(Player $player, DataPacket $packet){ | |
| $this->packet = $packet; | |
| $this->player = $player; | |
| } | |
| public function getPacket(){ | |
| return $this->packet; | |
| } | |
| public function getPlayer(){ | |
| return $this->player; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\server; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\network\Packet; | |
| class PacketReceiveEvent extends ServerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $packet; | |
| public function __construct(Packet $packet){ | |
| $this->packet = $packet; | |
| } | |
| public function getPacket(){ | |
| return $this->packet; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\server; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\Event; | |
| use pocketmine\network\Packet; | |
| class PacketSendEvent extends ServerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $packet; | |
| public function __construct(Packet $packet){ | |
| $this->packet = $packet; | |
| } | |
| public function getPacket(){ | |
| return $this->packet; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\server; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\event\Cancellable; | |
| /** | |
| * Called when the console runs a command, early in the process | |
| * | |
| * You don't want to use this except for a few cases like logging commands, | |
| * blocking commands on certain places, or applying modifiers. | |
| * | |
| * The message contains a slash at the start | |
| */ | |
| class ServerCommandEvent extends ServerEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| /** @var string */ | |
| protected $command; | |
| /** @var CommandSender */ | |
| protected $sender; | |
| /** | |
| * @param CommandSender $sender | |
| * @param string $command | |
| */ | |
| public function __construct(CommandSender $sender, $command){ | |
| $this->sender = $sender; | |
| $this->command = $command; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getCommand(){ | |
| return $this->command; | |
| } | |
| /** | |
| * @param string $command | |
| */ | |
| public function setCommand($command){ | |
| $this->command = $command; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Events related to the server core, like networking, stop, level loading | |
| */ | |
| namespace pocketmine\event\server; | |
| use pocketmine\event\Event; | |
| abstract class ServerEvent extends Event{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Events used by Tiles | |
| */ | |
| namespace pocketmine\event\tile; | |
| use pocketmine\event\Event; | |
| abstract class TileEvent extends Event{ | |
| protected $tile; | |
| public function getTile(){ | |
| return $this->tile; | |
| } | |
| }<?php | |
| /** | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\event\tile; | |
| use pocketmine\Event; | |
| use pocketmine\event\Cancellable; | |
| use pocketmine\item\Item; | |
| use pocketmine\tile\Tile; | |
| class TileInventoryChangeEvent extends TileEvent implements Cancellable{ | |
| public static $handlerList = null; | |
| private $oldItem; | |
| private $newItem; | |
| private $slot; | |
| public function __construct(Tile $tile, Item $oldItem, Item $newItem, $slot){ | |
| $this->tile = $tile; | |
| $this->oldItem = $oldItem; | |
| $this->newItem = $newItem; | |
| $this->slot = (int) $slot; | |
| } | |
| public function getSlot(){ | |
| return $this->slot; | |
| } | |
| public function getNewItem(){ | |
| return $this->newItem; | |
| } | |
| public function setNewItem(Item $item){ | |
| $this->newItem = $item; | |
| } | |
| public function getOldItem(){ | |
| return $this->oldItem; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine; | |
| use pocketmine\permission\ServerOperator; | |
| interface IPlayer extends ServerOperator{ | |
| /** | |
| * @return bool | |
| */ | |
| public function isOnline(); | |
| /** | |
| * @return string | |
| */ | |
| public function getName(); | |
| /** | |
| * @return bool | |
| */ | |
| public function isBanned(); | |
| /** | |
| * @param bool $banned | |
| */ | |
| public function setBanned($banned); | |
| /** | |
| * @return bool | |
| */ | |
| public function isWhitelisted(); | |
| /** | |
| * @param bool $value | |
| */ | |
| public function setWhitelisted($value); | |
| /** | |
| * @return Player|null | |
| */ | |
| public function getPlayer(); | |
| /** | |
| * @return int|double | |
| */ | |
| public function getFirstPlayed(); | |
| /** | |
| * @return int|double | |
| */ | |
| public function getLastPlayed(); | |
| /** | |
| * @return mixed | |
| */ | |
| public function hasPlayedBefore(); | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Apple extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::APPLE, 0, $count, "Apple"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class Bed extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::BED_BLOCK); | |
| parent::__construct(self::BED, 0, $count, "Bed"); | |
| $this->maxStackSize = 1; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class BeetrootSeeds extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::BEETROOT_BLOCK); | |
| parent::__construct(self::BEETROOT_SEEDS, 0, $count, "Beetroot Seeds"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class BeetrootSoup extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::BEETROOT_SOUP, 0, $count, "Beetroot Soup"); | |
| $this->maxStackSize = 1; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block as BlockBlock; | |
| /** | |
| * Class used for Items that can be Blocks | |
| */ | |
| class Block extends Item{ | |
| public function __construct(BlockBlock $block, $meta = 0, $count = 1){ | |
| $this->block = clone $block; | |
| parent::__construct($block->getID(), $block->getMetadata(), $count, $block->getName()); | |
| } | |
| public function setMetadata($meta){ | |
| $this->meta = $meta & 0x0F; | |
| $this->block->setMetadata($this->meta); | |
| } | |
| public function getBlock(){ | |
| return $this->block; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Bow extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::BOW, 0, $count, "Bow"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Bowl extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::BOWL, 0, $count, "Bowl"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Brick extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::BRICK, 0, $count, "Brick"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Air; | |
| use pocketmine\block\Block; | |
| use pocketmine\block\Lava; | |
| use pocketmine\block\Liquid; | |
| use pocketmine\block\Water; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class Bucket extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::BUCKET, $meta, $count, "Bucket"); | |
| $this->isActivable = true; | |
| $this->maxStackSize = 1; | |
| } | |
| public function onActivate(Level $level, Player $player, Block $block, Block $target, $face, $fx, $fy, $fz){ | |
| if($this->meta === Item::AIR){ | |
| if($target instanceof Liquid){ | |
| $level->setBlock($target, new Air(), true, false, true); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $this->meta = ($target instanceof Water) ? Item::WATER : Item::LAVA; | |
| } | |
| return true; | |
| } | |
| }elseif($this->meta === Item::WATER){ | |
| //Support Make Non-Support Water to Support Water | |
| if($block->getID() === self::AIR || ($block instanceof Water && ($block->getMetadata() & 0x07) != 0x00)){ | |
| $water = new Water(); | |
| $level->setBlock($block, $water, true, false, true); | |
| $water->place(clone $this, $block, $target, $face, $fx, $fy, $fz, $player); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $this->meta = 0; | |
| } | |
| return true; | |
| } | |
| }elseif($this->meta === Item::LAVA){ | |
| if($block->getID() === self::AIR){ | |
| $level->setBlock($block, new Lava(), true, false, true); | |
| if(($player->gamemode & 0x01) === 0){ | |
| $this->meta = 0; | |
| } | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class Cake extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::CAKE_BLOCK); | |
| $this->maxStackSize = 1; | |
| parent::__construct(self::CAKE, 0, $count, "Cake"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class Carrot extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::CARROT_BLOCK); | |
| parent::__construct(self::CARROT, 0, $count, "Carrot"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Coal extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::COAL, $meta & 0x01, $count, "Coal"); | |
| if($this->meta === 1){ | |
| $this->name = "Charcoal"; | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Diamond extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::DIAMOND, 0, $count, "Diamond"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class DiamondAxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::DIAMOND_AXE, 0, $count, "Diamond Axe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class DiamondHoe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::DIAMOND_HOE, 0, $count, "Diamond Hoe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class DiamondPickaxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::DIAMOND_PICKAXE, 0, $count, "Diamond Pickaxe"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class DiamondShovel extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::DIAMOND_SHOVEL, 0, $count, "Diamond Shovel"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class DiamondSword extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::DIAMOND_SWORD, 0, $count, "Diamond Sword"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Feather extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::FEATHER, 0, $count, "Feather"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| use pocketmine\block\Fire; | |
| use pocketmine\block\Solid; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class FlintSteel extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::FLINT_STEEL, $meta, $count, "Flint and Steel"); | |
| $this->isActivable = true; | |
| } | |
| public function onActivate(Level $level, Player $player, Block $block, Block $target, $face, $fx, $fy, $fz){ | |
| if(($player->gamemode & 0x01) === 0 and $this->useOn($block) and $this->getMetadata() >= $this->getMaxDurability()){ | |
| $player->setSlot($player->getCurrentEquipment(), new Item(Item::AIR, 0, 0)); | |
| } | |
| if($block->getID() === self::AIR and ($target instanceof Solid)){ | |
| $level->setBlock($block, new Fire(), true, false, true); | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class GoldAxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::GOLD_AXE, 0, $count, "Gold Axe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class GoldHoe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::GOLD_HOE, 0, $count, "Gold Hoe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class GoldIngot extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::GOLD_INGOT, 0, $count, "Gold Ingot"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class GoldPickaxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::GOLD_PICKAXE, 0, $count, "Gold Pickaxe"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class GoldShovel extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::GOLD_SHOVEL, 0, $count, "Gold Shovel"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class GoldSword extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::GOLD_SWORD, 0, $count, "Gold Sword"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class IronAxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::IRON_AXE, 0, $count, "Iron Axe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class IronDoor extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::IRON_DOOR_BLOCK); | |
| parent::__construct(self::IRON_DOOR, 0, $count, "Iron Door"); | |
| $this->maxStackSize = 1; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class IronHoe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::IRON_HOE, 0, $count, "Iron Hoe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class IronIngot extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::IRON_INGOT, 0, $count, "Iron Ingot"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class IronPickaxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::IRON_PICKAXE, 0, $count, "Iron Pickaxe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class IronShovel extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::IRON_SHOVEL, 0, $count, "Iron Shovel"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * All the Item classes | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\item\Block as ItemBlock; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| use pocketmine\recipes\Fuel; | |
| use pocketmine\recipes\Smelt; | |
| class Item{ | |
| //All Block IDs are here too | |
| const AIR = 0; | |
| const STONE = 1; | |
| const GRASS = 2; | |
| const DIRT = 3; | |
| const COBBLESTONE = 4; | |
| const COBBLE = 4; | |
| const PLANK = 5; | |
| const PLANKS = 5; | |
| const WOODEN_PLANK = 5; | |
| const WOODEN_PLANKS = 5; | |
| const SAPLING = 6; | |
| const SAPLINGS = 6; | |
| const BEDROCK = 7; | |
| const WATER = 8; | |
| const STILL_WATER = 9; | |
| const LAVA = 10; | |
| const STILL_LAVA = 11; | |
| const SAND = 12; | |
| const GRAVEL = 13; | |
| const GOLD_ORE = 14; | |
| const IRON_ORE = 15; | |
| const COAL_ORE = 16; | |
| const WOOD = 17; | |
| const TRUNK = 17; | |
| const LEAVES = 18; | |
| const LEAVE = 18; | |
| const SPONGE = 19; | |
| const GLASS = 20; | |
| const LAPIS_ORE = 21; | |
| const LAPIS_BLOCK = 22; | |
| const SANDSTONE = 24; | |
| const BED_BLOCK = 26; | |
| const COBWEB = 30; | |
| const TALL_GRASS = 31; | |
| const BUSH = 32; | |
| const DEAD_BUSH = 32; | |
| const WOOL = 35; | |
| const DANDELION = 37; | |
| const ROSE = 38; | |
| const CYAN_FLOWER = 38; | |
| const BROWN_MUSHROOM = 39; | |
| const RED_MUSHROOM = 40; | |
| const GOLD_BLOCK = 41; | |
| const IRON_BLOCK = 42; | |
| const DOUBLE_SLAB = 43; | |
| const DOUBLE_SLABS = 43; | |
| const SLAB = 44; | |
| const SLABS = 44; | |
| const BRICKS = 45; | |
| const BRICKS_BLOCK = 45; | |
| const TNT = 46; | |
| const BOOKSHELF = 47; | |
| const MOSS_STONE = 48; | |
| const MOSSY_STONE = 48; | |
| const OBSIDIAN = 49; | |
| const TORCH = 50; | |
| const FIRE = 51; | |
| const WOOD_STAIRS = 53; | |
| const WOODEN_STAIRS = 53; | |
| const OAK_WOOD_STAIRS = 53; | |
| const OAK_WOODEN_STAIRS = 53; | |
| const CHEST = 54; | |
| const DIAMOND_ORE = 56; | |
| const DIAMOND_BLOCK = 57; | |
| const CRAFTING_TABLE = 58; | |
| const WORKBENCH = 58; | |
| const WHEAT_BLOCK = 59; | |
| const FARMLAND = 60; | |
| const FURNACE = 61; | |
| const BURNING_FURNACE = 62; | |
| const LIT_FURNACE = 62; | |
| const SIGN_POST = 63; | |
| const DOOR_BLOCK = 64; | |
| const WOODEN_DOOR_BLOCK = 64; | |
| const WOOD_DOOR_BLOCK = 64; | |
| const LADDER = 65; | |
| const COBBLE_STAIRS = 67; | |
| const COBBLESTONE_STAIRS = 67; | |
| const WALL_SIGN = 68; | |
| const IRON_DOOR_BLOCK = 71; | |
| const REDSTONE_ORE = 73; | |
| const GLOWING_REDSTONE_ORE = 74; | |
| const LIT_REDSTONE_ORE = 74; | |
| const SNOW = 78; | |
| const SNOW_LAYER = 78; | |
| const ICE = 79; | |
| const SNOW_BLOCK = 80; | |
| const CACTUS = 81; | |
| const CLAY_BLOCK = 82; | |
| const REEDS = 83; | |
| const SUGARCANE_BLOCK = 83; | |
| const FENCE = 85; | |
| const PUMPKIN = 86; | |
| const NETHERRACK = 87; | |
| const SOUL_SAND = 88; | |
| const GLOWSTONE = 89; | |
| const GLOWSTONE_BLOCK = 89; | |
| const LIT_PUMPKIN = 91; | |
| const JACK_O_LANTERN = 91; | |
| const CAKE_BLOCK = 92; | |
| const TRAPDOOR = 96; | |
| const STONE_BRICKS = 98; | |
| const STONE_BRICK = 98; | |
| const IRON_BAR = 101; | |
| const IRON_BARS = 101; | |
| const GLASS_PANE = 102; | |
| const GLASS_PANEL = 102; | |
| const MELON_BLOCK = 103; | |
| const PUMPKIN_STEM = 104; | |
| const MELON_STEM = 105; | |
| const FENCE_GATE = 107; | |
| const BRICK_STAIRS = 108; | |
| const STONE_BRICK_STAIRS = 109; | |
| const NETHER_BRICKS = 112; | |
| const NETHER_BRICK_BLOCK = 112; | |
| const NETHER_BRICKS_STAIRS = 114; | |
| const SANDSTONE_STAIRS = 128; | |
| const SPRUCE_WOOD_STAIRS = 134; | |
| const SPRUCE_WOODEN_STAIRS = 134; | |
| const BIRCH_WOOD_STAIRS = 135; | |
| const BIRCH_WOODEN_STAIRS = 135; | |
| const JUNGLE_WOOD_STAIRS = 136; | |
| const JUNGLE_WOODEN_STAIRS = 136; | |
| const COBBLE_WALL = 139; | |
| const STONE_WALL = 139; | |
| const COBBLESTONE_WALL = 139; | |
| const CARROT_BLOCK = 141; | |
| const POTATO_BLOCK = 142; | |
| const QUARTZ_BLOCK = 155; | |
| const QUARTZ_STAIRS = 156; | |
| const DOUBLE_WOOD_SLAB = 157; | |
| const DOUBLE_WOODEN_SLAB = 157; | |
| const DOUBLE_WOOD_SLABS = 157; | |
| const DOUBLE_WOODEN_SLABS = 157; | |
| const WOOD_SLAB = 158; | |
| const WOODEN_SLAB = 158; | |
| const WOOD_SLABS = 158; | |
| const WOODEN_SLABS = 158; | |
| const HAY_BALE = 170; | |
| const CARPET = 171; | |
| const COAL_BLOCK = 173; | |
| const BEETROOT_BLOCK = 244; | |
| const STONECUTTER = 245; | |
| const GLOWING_OBSIDIAN = 246; | |
| const NETHER_REACTOR = 247; | |
| //Normal Item IDs | |
| const IRON_SHOVEL = 256; // | |
| const IRON_PICKAXE = 257; // | |
| const IRON_AXE = 258; // | |
| const FLINT_STEEL = 259; // | |
| const FLINT_AND_STEEL = 259; // | |
| const APPLE = 260; // | |
| const BOW = 261; | |
| const ARROW = 262; | |
| const COAL = 263; // | |
| const DIAMOND = 264; // | |
| const IRON_INGOT = 265; // | |
| const GOLD_INGOT = 266; // | |
| const IRON_SWORD = 267; | |
| const WOODEN_SWORD = 268; // | |
| const WOODEN_SHOVEL = 269; // | |
| const WOODEN_PICKAXE = 270; // | |
| const WOODEN_AXE = 271; // | |
| const STONE_SWORD = 272; | |
| const STONE_SHOVEL = 273; | |
| const STONE_PICKAXE = 274; | |
| const STONE_AXE = 275; | |
| const DIAMOND_SWORD = 276; | |
| const DIAMOND_SHOVEL = 277; | |
| const DIAMOND_PICKAXE = 278; | |
| const DIAMOND_AXE = 279; | |
| const STICK = 280; // | |
| const STICKS = 280; | |
| const BOWL = 281; // | |
| const MUSHROOM_STEW = 282; | |
| const GOLD_SWORD = 283; | |
| const GOLD_SHOVEL = 284; | |
| const GOLD_PICKAXE = 285; | |
| const GOLD_AXE = 286; | |
| const GOLDEN_SWORD = 283; | |
| const GOLDEN_SHOVEL = 284; | |
| const GOLDEN_PICKAXE = 285; | |
| const GOLDEN_AXE = 286; | |
| const STRING = 287; | |
| const FEATHER = 288; // | |
| const GUNPOWDER = 289; | |
| const WOODEN_HOE = 290; | |
| const STONE_HOE = 291; | |
| const IRON_HOE = 292; // | |
| const DIAMOND_HOE = 293; | |
| const GOLD_HOE = 294; | |
| const GOLDEN_HOE = 294; | |
| const SEEDS = 295; | |
| const WHEAT_SEEDS = 295; | |
| const WHEAT = 296; | |
| const BREAD = 297; | |
| const LEATHER_CAP = 298; | |
| const LEATHER_TUNIC = 299; | |
| const LEATHER_PANTS = 300; | |
| const LEATHER_BOOTS = 301; | |
| const CHAIN_HELMET = 302; | |
| const CHAIN_CHESTPLATE = 303; | |
| const CHAIN_LEGGINGS = 304; | |
| const CHAIN_BOOTS = 305; | |
| const IRON_HELMET = 306; | |
| const IRON_CHESTPLATE = 307; | |
| const IRON_LEGGINGS = 308; | |
| const IRON_BOOTS = 309; | |
| const DIAMOND_HELMET = 310; | |
| const DIAMOND_CHESTPLATE = 311; | |
| const DIAMOND_LEGGINGS = 312; | |
| const DIAMOND_BOOTS = 313; | |
| const GOLD_HELMET = 314; | |
| const GOLD_CHESTPLATE = 315; | |
| const GOLD_LEGGINGS = 316; | |
| const GOLD_BOOTS = 317; | |
| const FLINT = 318; | |
| const RAW_PORKCHOP = 319; | |
| const COOKED_PORKCHOP = 320; | |
| const PAINTING = 321; | |
| const GOLDEN_APPLE = 322; | |
| const SIGN = 323; | |
| const WOODEN_DOOR = 324; | |
| const BUCKET = 325; | |
| const MINECART = 329; | |
| const IRON_DOOR = 330; | |
| const REDSTONE = 331; | |
| const REDSTONE_DUST = 331; | |
| const SNOWBALL = 332; | |
| const LEATHER = 334; | |
| const BRICK = 336; | |
| const CLAY = 337; | |
| const SUGARCANE = 338; | |
| const SUGAR_CANE = 338; | |
| const SUGAR_CANES = 338; | |
| const PAPER = 339; | |
| const BOOK = 340; | |
| const SLIMEBALL = 341; | |
| const EGG = 344; | |
| const COMPASS = 345; | |
| const CLOCK = 347; | |
| const GLOWSTONE_DUST = 348; | |
| //const RAW_FISH = 349; | |
| //const COOKED_FISH = 350; | |
| const DYE = 351; | |
| const BONE = 352; | |
| const SUGAR = 353; | |
| const CAKE = 354; | |
| const BED = 355; | |
| //const COOKIE = 357; | |
| const SHEARS = 359; | |
| const MELON = 360; | |
| const MELON_SLICE = 360; | |
| const PUMPKIN_SEEDS = 361; | |
| const MELON_SEEDS = 362; | |
| const RAW_BEEF = 363; | |
| const STEAK = 364; | |
| const COOKED_BEEF = 364; | |
| const RAW_CHICKEN = 365; | |
| const COOKED_CHICKEN = 366; | |
| const SPAWN_EGG = 383; | |
| const CARROT = 391; | |
| const CARROTS = 391; | |
| const POTATO = 392; | |
| const POTATOES = 392; //@shoghicp Why the heck do we need plural redundant Item ID here???? | |
| const BAKED_POTATO = 393; | |
| const BAKED_POTATOES = 393; | |
| const PUMPKIN_PIE = 400; | |
| const NETHER_BRICK = 405; | |
| const QUARTZ = 406; | |
| const NETHER_QUARTZ = 406; | |
| const CAMERA = 456; | |
| const BEETROOT = 457; | |
| const BEETROOT_SEEDS = 458; | |
| const BEETROOT_SEED = 458; | |
| const BEETROOT_SOUP = 459; | |
| /** @var Item[] */ | |
| public static $list = array(); | |
| protected $block; | |
| protected $id; | |
| protected $meta; | |
| public $count; | |
| protected $maxStackSize = 64; | |
| protected $durability = 0; | |
| protected $name; | |
| public $isActivable = false; | |
| public static function init(){ | |
| if(count(self::$list) === 0){ | |
| self::$list = array( | |
| self::SUGARCANE => new Sugarcane(), | |
| self::WHEAT_SEEDS => new WheatSeeds(), | |
| self::PUMPKIN_SEEDS => new PumpkinSeeds(), | |
| self::MELON_SEEDS => new MelonSeeds(), | |
| self::MUSHROOM_STEW => new MushroomStew(), | |
| self::BEETROOT_SOUP => new BeetrootSoup(), | |
| self::CARROT => new Carrot(), | |
| self::POTATO => new Potato(), | |
| self::BEETROOT_SEEDS => new BeetrootSeeds(), | |
| self::SIGN => new Sign(), | |
| self::WOODEN_DOOR => new WoodenDoor(), | |
| self::BUCKET => new Bucket(), | |
| self::IRON_DOOR => new IronDoor(), | |
| self::CAKE => new Cake(), | |
| self::BED => new Bed(), | |
| self::PAINTING => new Painting(), | |
| self::COAL => new Coal(), | |
| self::APPLE => new Apple(), | |
| self::SPAWN_EGG => new SpawnEgg(), | |
| self::DIAMOND => new Diamond(), | |
| self::STICK => new Stick(), | |
| self::BOWL => new Bowl(), | |
| self::FEATHER => new Feather(), | |
| self::BRICK => new Brick(), | |
| self::IRON_INGOT => new IronIngot(), | |
| self::GOLD_INGOT => new GoldIngot(), | |
| self::IRON_SHOVEL => new IronShovel(), | |
| self::IRON_PICKAXE => new IronPickaxe(), | |
| self::IRON_AXE => new IronAxe(), | |
| self::IRON_HOE => new IronHoe(), | |
| self::DIAMOND_SWORD => new DiamondSword(), | |
| self::DIAMOND_SHOVEL => new DiamondShovel(), | |
| self::DIAMOND_PICKAXE => new DiamondPickaxe(), | |
| self::DIAMOND_AXE => new DiamondAxe(), | |
| self::DIAMOND_HOE => new DiamondHoe(), | |
| self::GOLD_SWORD => new GoldSword(), | |
| self::GOLD_SHOVEL => new GoldShovel(), | |
| self::GOLD_PICKAXE => new GoldPickaxe(), | |
| self::GOLD_AXE => new GoldAxe(), | |
| self::GOLD_HOE => new GoldHoe(), | |
| self::STONE_SWORD => new StoneSword(), | |
| self::STONE_SHOVEL => new StoneShovel(), | |
| self::STONE_PICKAXE => new StonePickaxe(), | |
| self::STONE_AXE => new StoneAxe(), | |
| self::STONE_HOE => new StoneHoe(), | |
| self::WOODEN_SWORD => new WoodenSword(), | |
| self::WOODEN_SHOVEL => new WoodenShovel(), | |
| self::WOODEN_PICKAXE => new WoodenPickaxe(), | |
| self::WOODEN_AXE => new WoodenAxe(), | |
| self::WOODEN_HOE => new WoodenHoe(), | |
| self::FLINT_STEEL => new FlintSteel(), | |
| self::SHEARS => new Shears(), | |
| self::BOW => new Bow(), | |
| ); | |
| foreach(Block::$list as $id => $class){ | |
| self::$list[$id] = new ItemBlock($class); | |
| } | |
| } | |
| } | |
| public static function get($id, $meta = 0, $count = 1){ | |
| if(isset(self::$list[$id])){ | |
| $item = clone self::$list[$id]; | |
| $item->setMetadata($meta); | |
| $item->setCount($count); | |
| }else{ | |
| $item = new Item($id, $meta, $count); | |
| } | |
| return $item; | |
| } | |
| public static function fromString($str, $multiple = false){ | |
| if($multiple === true){ | |
| $blocks = array(); | |
| foreach(explode(",", $str) as $b){ | |
| $blocks[] = self::fromString($b, false); | |
| } | |
| return $blocks; | |
| }else{ | |
| $b = explode(":", str_replace(" ", "_", trim($str))); | |
| if(!isset($b[1])){ | |
| $meta = 0; | |
| }else{ | |
| $meta = ((int) $b[1]) & 0xFFFF; | |
| } | |
| if(defined("pocketmine\\item\\Item::" . strtoupper($b[0]))){ | |
| $item = self::get(constant("pocketmine\\item\\Item::" . strtoupper($b[0])), $meta); | |
| if($item->getID() === self::AIR and strtoupper($b[0]) !== "AIR"){ | |
| $item = self::get(((int) $b[0]) & 0xFFFF, $meta); | |
| } | |
| }else{ | |
| $item = self::get(((int) $b[0]) & 0xFFFF, $meta); | |
| } | |
| return $item; | |
| } | |
| } | |
| public function __construct($id, $meta = 0, $count = 1, $name = "Unknown"){ | |
| $this->id = (int) $id; | |
| $this->meta = (int) $meta; | |
| $this->count = (int) $count; | |
| $this->name = $name; | |
| if(!isset($this->block) and $this->id <= 0xff and isset(Block::$list[$this->id])){ | |
| $this->block = Block::get($this->id, $this->meta); | |
| $this->name = $this->block->getName(); | |
| } | |
| if($this->isTool() !== false){ | |
| $this->maxStackSize = 1; | |
| } | |
| } | |
| public function getCount(){ | |
| return $this->count; | |
| } | |
| public function setCount($count){ | |
| $this->count = (int) $count; | |
| } | |
| final public function getName(){ | |
| return $this->name; | |
| } | |
| final public function isPlaceable(){ | |
| return (($this->block instanceof Block) and $this->block->isPlaceable === true); | |
| } | |
| public function getBlock(){ | |
| if($this->block instanceof Block){ | |
| return $this->block; | |
| }else{ | |
| return Block::get(self::AIR); | |
| } | |
| } | |
| final public function getID(){ | |
| return $this->id; | |
| } | |
| final public function getMetadata(){ | |
| return $this->meta; | |
| } | |
| public function setMetadata($meta){ | |
| $this->meta = $meta & 0xFFFF; | |
| } | |
| final public function getMaxStackSize(){ | |
| return $this->maxStackSize; | |
| } | |
| final public function getFuelTime(){ | |
| if(!isset(Fuel::$duration[$this->id])){ | |
| return false; | |
| } | |
| if($this->id !== self::BUCKET or $this->meta === 10){ | |
| return Fuel::$duration[$this->id]; | |
| } | |
| return false; | |
| } | |
| final public function getSmeltItem(){ | |
| if(!isset(Smelt::$product[$this->id])){ | |
| return false; | |
| } | |
| if(isset(Smelt::$product[$this->id][0]) and !is_array(Smelt::$product[$this->id][0])){ | |
| return self::get(Smelt::$product[$this->id][0], Smelt::$product[$this->id][1]); | |
| } | |
| if(!isset(Smelt::$product[$this->id][$this->meta])){ | |
| return false; | |
| } | |
| return self::get(Smelt::$product[$this->id][$this->meta][0], Smelt::$product[$this->id][$this->meta][1]); | |
| } | |
| /** | |
| * @param Entity|Block $object | |
| * | |
| * @return bool | |
| */ | |
| public function useOn($object){ | |
| return false; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isTool(){ | |
| return false; | |
| } | |
| /** | |
| * @return int|bool | |
| */ | |
| public function getMaxDurability(){ | |
| return false; | |
| } | |
| public function isPickaxe(){ | |
| return false; | |
| } | |
| public function isAxe(){ | |
| return false; | |
| } | |
| public function isSword(){ | |
| return false; | |
| } | |
| public function isShovel(){ | |
| return false; | |
| } | |
| public function isHoe(){ | |
| return false; | |
| } | |
| public function isShears(){ | |
| return false; | |
| } | |
| final public function __toString(){ | |
| return "Item " . $this->name . " (" . $this->id . ":" . $this->meta . ")"; | |
| } | |
| public function getDestroySpeed(Block $block, Player $player){ | |
| return 1; | |
| } | |
| public function onActivate(Level $level, Player $player, Block $block, Block $target, $face, $fx, $fy, $fz){ | |
| return false; | |
| } | |
| public final function equals(Item $item, $checkDamage = false){ | |
| return $this->id === $item->getID() and ($checkDamage === false or $this->getMetadata() === $item->getMetadata()); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class MelonSeeds extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::MELON_STEM); | |
| parent::__construct(self::MELON_SEEDS, 0, $count, "Melon Seeds"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class MushroomStew extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::MUSHROOM_STEW, 0, $count, "Mushroom Stew"); | |
| $this->maxStackSize = 1; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Painting extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::PAINTING, 0, $count, "Painting"); | |
| $this->isActivable = true; | |
| } | |
| public function onActivate(Level $level, Player $player, Block $block, Block $target, $face, $fx, $fy, $fz){ | |
| if($target->isTransparent === false and $face > 1 and $block->isSolid === false){ | |
| $server = Server::getInstance(); | |
| $faces = array( | |
| 2 => 1, | |
| 3 => 3, | |
| 4 => 0, | |
| 5 => 2, | |
| ); | |
| $motives = array( | |
| // Motive Width Height | |
| array("Kebab", 1, 1), | |
| array("Aztec", 1, 1), | |
| array("Alban", 1, 1), | |
| array("Aztec2", 1, 1), | |
| array("Bomb", 1, 1), | |
| array("Plant", 1, 1), | |
| array("Wasteland", 1, 1), | |
| array("Wanderer", 1, 2), | |
| array("Graham", 1, 2), | |
| array("Pool", 2, 1), | |
| array("Courbet", 2, 1), | |
| array("Sunset", 2, 1), | |
| array("Sea", 2, 1), | |
| array("Creebet", 2, 1), | |
| array("Match", 2, 2), | |
| array("Bust", 2, 2), | |
| array("Stage", 2, 2), | |
| array("Void", 2, 2), | |
| array("SkullAndRoses", 2, 2), | |
| //array("Wither", 2, 2), | |
| array("Fighters", 4, 2), | |
| array("Skeleton", 4, 3), | |
| array("DonkeyKong", 4, 3), | |
| array("Pointer", 4, 4), | |
| array("Pigscene", 4, 4), | |
| array("Flaming Skull", 4, 4), | |
| ); | |
| $motive = $motives[mt_rand(0, count($motives) - 1)]; | |
| $data = array( | |
| "x" => $target->x, | |
| "y" => $target->y, | |
| "z" => $target->z, | |
| "yaw" => $faces[$face] * 90, | |
| "Motive" => $motive[0], | |
| ); | |
| //TODO | |
| //$e = $server->api->entity->add($level, ENTITY_OBJECT, OBJECT_PAINTING, $data); | |
| //$e->spawnToAll(); | |
| if(($player->gamemode & 0x01) === 0x00){ | |
| $player->removeItem(Item::get($this->getID(), $this->getMetadata(), 1)); | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class Potato extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::POTATO_BLOCK); | |
| parent::__construct(self::POTATO, 0, $count, "Potato"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class PumpkinSeeds extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::PUMPKIN_STEM); | |
| parent::__construct(self::PUMPKIN_SEEDS, 0, $count, "Pumpkin Seeds"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Shears extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::SHEARS, $meta, $count, "Shears"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class Sign extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::SIGN_POST); | |
| $this->maxStackSize = 16; | |
| parent::__construct(self::SIGN, 0, $count, "Sign"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| use pocketmine\Entity; | |
| use pocketmine\level\Level; | |
| use pocketmine\Player; | |
| class SpawnEgg extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::SPAWN_EGG, 0, $count, "Spawn Egg"); | |
| $this->meta = $meta; | |
| $this->isActivable = true; | |
| } | |
| public function onActivate(Level $level, Player $player, Block $block, Block $target, $face, $fx, $fy, $fz){ | |
| switch($this->meta){ | |
| //TODO: use entity constants | |
| case 10: | |
| case 11: | |
| case 12: | |
| case 13: | |
| $data = array( | |
| "x" => $block->x + 0.5, | |
| "y" => $block->y, | |
| "z" => $block->z + 0.5, | |
| ); | |
| //$e = Server::getInstance()->api->entity->add($block->level, ENTITY_MOB, $this->meta, $data); | |
| //Server::getInstance()->api->entity->spawnToAll($e); | |
| if(($player->gamemode & 0x01) === 0){ | |
| --$this->count; | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class Stick extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::STICK, 0, $count, "Stick"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class StoneAxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::STONE_AXE, 0, $count, "Stone Axe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class StoneHoe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::STONE_HOE, 0, $count, "Stone Hoe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class StonePickaxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::STONE_PICKAXE, 0, $count, "Stone Pickaxe"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class StoneShovel extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::STONE_SHOVEL, 0, $count, "Stone Shovel"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class StoneSword extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::STONE_SWORD, 0, $count, "Stone Sword"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class Sugarcane extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::SUGARCANE_BLOCK); | |
| parent::__construct(self::SUGARCANE, 0, $count, "Sugar Cane"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\entity\Entity; | |
| abstract class Tool extends Item{ | |
| public function __construct($id, $meta = 0, $count = 1, $name = "Unknown"){ | |
| parent::__construct($id, $meta, $count, $name); | |
| $this->maxStackSize = 1; | |
| } | |
| /** | |
| * TODO: Move this to each item | |
| * | |
| * @param Entity|Block $object | |
| * | |
| * @return bool | |
| */ | |
| public function useOn($object){ | |
| if($this->isHoe()){ | |
| if(($object instanceof Block) and ($object->getID() === self::GRASS or $object->getID() === self::DIRT)){ | |
| $this->meta++; | |
| } | |
| }elseif(($object instanceof Entity) and !$this->isSword()){ | |
| $this->meta += 2; | |
| }else{ | |
| $this->meta++; | |
| } | |
| return true; | |
| } | |
| /** | |
| * TODO: Move this to each item | |
| * | |
| * @return int|bool | |
| */ | |
| public function getMaxDurability(){ | |
| $levels = array( | |
| 2 => 33, | |
| 1 => 60, | |
| 3 => 132, | |
| 4 => 251, | |
| 5 => 1562, | |
| self::FLINT_STEEL => 65, | |
| self::SHEARS => 239, | |
| self::BOW => 385, | |
| ); | |
| if(($type = $this->isPickaxe()) === false){ | |
| if(($type = $this->isAxe()) === false){ | |
| if(($type = $this->isSword()) === false){ | |
| if(($type = $this->isShovel()) === false){ | |
| if(($type = $this->isHoe()) === false){ | |
| $type = $this->id; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| return $levels[$type]; | |
| } | |
| public function isPickaxe(){ | |
| switch($this->id){ | |
| case self::IRON_PICKAXE: | |
| return 4; | |
| case self::WOODEN_PICKAXE: | |
| return 1; | |
| case self::STONE_PICKAXE: | |
| return 3; | |
| case self::DIAMOND_PICKAXE: | |
| return 5; | |
| case self::GOLD_PICKAXE: | |
| return 2; | |
| default: | |
| return false; | |
| } | |
| } | |
| final public function isAxe(){ | |
| switch($this->id){ | |
| case self::IRON_AXE: | |
| return 4; | |
| case self::WOODEN_AXE: | |
| return 1; | |
| case self::STONE_AXE: | |
| return 3; | |
| case self::DIAMOND_AXE: | |
| return 5; | |
| case self::GOLD_AXE: | |
| return 2; | |
| default: | |
| return false; | |
| } | |
| } | |
| final public function isSword(){ | |
| switch($this->id){ | |
| case self::IRON_SWORD: | |
| return 4; | |
| case self::WOODEN_SWORD: | |
| return 1; | |
| case self::STONE_SWORD: | |
| return 3; | |
| case self::DIAMOND_SWORD: | |
| return 5; | |
| case self::GOLD_SWORD: | |
| return 2; | |
| default: | |
| return false; | |
| } | |
| } | |
| final public function isShovel(){ | |
| switch($this->id){ | |
| case self::IRON_SHOVEL: | |
| return 4; | |
| case self::WOODEN_SHOVEL: | |
| return 1; | |
| case self::STONE_SHOVEL: | |
| return 3; | |
| case self::DIAMOND_SHOVEL: | |
| return 5; | |
| case self::GOLD_SHOVEL: | |
| return 2; | |
| default: | |
| return false; | |
| } | |
| } | |
| public function isHoe(){ | |
| switch($this->id){ | |
| case self::IRON_HOE: | |
| case self::WOODEN_HOE: | |
| case self::STONE_HOE: | |
| case self::DIAMOND_HOE: | |
| case self::GOLD_HOE: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| public function isShears(){ | |
| return ($this->id === self::SHEARS); | |
| } | |
| public function isTool(){ | |
| return false; | |
| return ($this->id === self::FLINT_STEEL or $this->id === self::SHEARS or $this->id === self::BOW or $this->isPickaxe() !== false or $this->isAxe() !== false or $this->isShovel() !== false or $this->isSword() !== false); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class WheatSeeds extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::WHEAT_BLOCK); | |
| parent::__construct(self::WHEAT_SEEDS, 0, $count, "Wheat Seeds"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class WoodenAxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::WOODEN_AXE, 0, $count, "Wooden Axe"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| use pocketmine\block\Block; | |
| class WoodenDoor extends Item{ | |
| public function __construct($meta = 0, $count = 1){ | |
| $this->block = Block::get(Item::WOODEN_DOOR_BLOCK); | |
| parent::__construct(self::WOODEN_DOOR, 0, $count, "Wooden Door"); | |
| $this->maxStackSize = 1; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class WoodenHoe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::WOODEN_HOE, 0, $count, "Wooden Hoe"); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class WoodenPickaxe extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::WOODEN_PICKAXE, 0, $count, "Wooden Pickaxe"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class WoodenShovel extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::WOODEN_SHOVEL, 0, $count, "Wooden Shovel"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\item; | |
| class WoodenSword extends Tool{ | |
| public function __construct($meta = 0, $count = 1){ | |
| parent::__construct(self::WOODEN_SWORD, 0, $count, "Wooden Sword"); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level; | |
| use pocketmine\block\Block; | |
| use pocketmine\block\TNT; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\entity\EntityExplodeEvent; | |
| use pocketmine\item\Item; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\network\protocol\ExplodePacket; | |
| use pocketmine\Player; | |
| use pocketmine\Server; | |
| class Explosion{ | |
| public static $specialDrops = array( | |
| Item::GRASS => Item::DIRT, | |
| Item::STONE => Item::COBBLESTONE, | |
| Item::COAL_ORE => Item::COAL, | |
| Item::DIAMOND_ORE => Item::DIAMOND, | |
| Item::REDSTONE_ORE => Item::REDSTONE, | |
| ); | |
| private $rays = 16; //Rays | |
| public $level; | |
| public $source; | |
| public $size; | |
| /** | |
| * @var Block[] | |
| */ | |
| public $affectedBlocks = array(); | |
| public $stepLen = 0.3; | |
| private $what; | |
| public function __construct(Position $center, $size, $what = null){ | |
| $this->level = $center->level; | |
| $this->source = $center; | |
| $this->size = max($size, 0); | |
| $this->what = $what; | |
| } | |
| public function explode(){ | |
| if($this->size < 0.1){ | |
| return false; | |
| } | |
| $mRays = $this->rays - 1; | |
| for($i = 0; $i < $this->rays; ++$i){ | |
| for($j = 0; $j < $this->rays; ++$j){ | |
| for($k = 0; $k < $this->rays; ++$k){ | |
| if($i == 0 or $i == $mRays or $j == 0 or $j == $mRays or $k == 0 or $k == $mRays){ | |
| $vector = new Vector3($i / $mRays * 2 - 1, $j / $mRays * 2 - 1, $k / $mRays * 2 - 1); //($i / $mRays) * 2 - 1 | |
| $vector = $vector->normalize()->multiply($this->stepLen); | |
| $pointer = clone $this->source; | |
| for($blastForce = $this->size * (mt_rand(700, 1300) / 1000); $blastForce > 0; $blastForce -= $this->stepLen * 0.75){ | |
| $vBlock = $pointer->floor(); | |
| $blockID = $this->level->level->getBlockID($vBlock->x, $vBlock->y, $vBlock->z); | |
| if($blockID > 0){ | |
| $block = Block::get($blockID, 0); | |
| $block->x = $vBlock->x; | |
| $block->y = $vBlock->y; | |
| $block->z = $vBlock->z; | |
| $blastForce -= ($block->getHardness() / 5 + 0.3) * $this->stepLen; | |
| if($blastForce > 0){ | |
| $index = ($block->x << 15) + ($block->z << 7) + $block->y; | |
| if(!isset($this->affectedBlocks[$index])){ | |
| $this->affectedBlocks[$index] = $block; | |
| } | |
| } | |
| } | |
| $pointer = $pointer->add($vector); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| $send = array(); | |
| $source = $this->source->floor(); | |
| $radius = 2 * $this->size; | |
| $yield = (1 / $this->size) * 100; | |
| if($this->what instanceof Entity){ | |
| Server::getInstance()->getPluginManager()->callEvent($ev = new EntityExplodeEvent($this->what, $this->source, $this->affectedBlocks, $yield)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| }else{ | |
| $yield = $ev->getYield(); | |
| $this->affectedBlocks = $ev->getBlockList(); | |
| } | |
| } | |
| //TODO | |
| /*foreach($server->api->entity->getRadius($this->source, $radius) as $entity){ | |
| $impact = (1 - $this->source->distance($entity) / $radius) * 0.5; //placeholder, 0.7 should be exposure | |
| $damage = (int) (($impact * $impact + $impact) * 8 * $this->size + 1); | |
| $entity->harm($damage, "explosion"); | |
| }*/ | |
| foreach($this->affectedBlocks as $block){ | |
| if($block instanceof TNT){ | |
| $data = array( | |
| "x" => $block->x + 0.5, | |
| "y" => $block->y + 0.5, | |
| "z" => $block->z + 0.5, | |
| "power" => 4, | |
| "fuse" => mt_rand(10, 30), //0.5 to 1.5 seconds | |
| ); | |
| //TODO | |
| //$e = $server->api->entity->add($this->level, ENTITY_OBJECT, OBJECT_PRIMEDTNT, $data); | |
| //$e->spawnToAll(); | |
| }elseif(mt_rand(0, 100) < $yield){ | |
| if(isset(self::$specialDrops[$block->getID()])){ | |
| //TODO | |
| //$server->api->entity->drop(new Position($block->x + 0.5, $block->y, $block->z + 0.5, $this->level), Item::get(self::$specialDrops[$block->getID()], 0)); | |
| }else{ | |
| //TODO | |
| //$server->api->entity->drop(new Position($block->x + 0.5, $block->y, $block->z + 0.5, $this->level), Item::get($block->getID(), $this->level->level->getBlockDamage($block->x, $block->y, $block->z))); | |
| } | |
| } | |
| $this->level->level->setBlockID($block->x, $block->y, $block->z, 0); | |
| $send[] = new Vector3($block->x - $source->x, $block->y - $source->y, $block->z - $source->z); | |
| } | |
| $pk = new ExplodePacket; | |
| $pk->x = $this->source->x; | |
| $pk->y = $this->source->y; | |
| $pk->z = $this->source->z; | |
| $pk->radius = $this->size; | |
| $pk->records = $send; | |
| Player::broadcastPacket($this->level->getPlayers(), $pk); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format\anvil; | |
| use pocketmine\level\format\LevelFormat; | |
| class Anvil implements LevelFormat{ | |
| protected $basePath; | |
| public function __construct($path, $levelName){ | |
| $this->basePath = realpath($path) . "/"; | |
| } | |
| public static function isValid($path){ | |
| return file_exists(realpath($path) . "region/"); | |
| } | |
| public static function getRegionIndex($chunkX, $chunkZ, &$x, &$z){ | |
| $x = $chunkX >> 5; | |
| $z = $chunkZ >> 5; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format\anvil; | |
| use pocketmine\utils\Binary; | |
| class RegionLoader{ | |
| const COMPRESSION_GZIP = 1; | |
| const COMPRESSION_ZLIB = 2; | |
| protected $x; | |
| protected $z; | |
| protected $filePath; | |
| protected $filePointer; | |
| protected $locationTable = array(); | |
| public function __construct($path, $regionX, $regionZ){ | |
| $this->filePath = $path . "r.$regionX.$regionZ.mca"; | |
| touch($this->filePath); | |
| $this->filePointer = fopen($this->filePath, "r+b"); | |
| flock($this->filePointer, LOCK_EX); | |
| stream_set_read_buffer($this->filePointer, 4096); | |
| stream_set_write_buffer($this->filePointer, 1024 * 16); //16KB | |
| if(!file_exists($this->filePath)){ | |
| $this->createBlank(); | |
| }else{ | |
| $this->loadLocationTable(); | |
| } | |
| } | |
| public function __destruct(){ | |
| if(is_resource($this->filePointer)){ | |
| $this->cleanGarbage(); | |
| $this->writeLocationTable(); | |
| flock($this->filePointer, LOCK_UN); | |
| fclose($this->filePointer); | |
| } | |
| } | |
| private function cleanGarbage(){ | |
| $sectors = array(); | |
| $maxSector = 1; | |
| foreach($this->locationTable as $index => $data){ //Calculate file usage | |
| if($data[0] === 0 or $data[1] === 0){ | |
| $this->locationTable[$index] = array(0, 0); | |
| continue; | |
| } | |
| for($i = 0; $i < $data[1]; ++$i){ | |
| $sectors[$data[0]] = $index; | |
| if($data[0] > $maxSector){ | |
| $maxSector = $data[0]; | |
| } | |
| } | |
| } | |
| if(count($sectors) === ($maxSector - 2)){ //No collection needed | |
| return 0; | |
| } | |
| ksort($sectors); | |
| $shift = 0; | |
| $lastSector = 1; //First chunk - 1 | |
| fseek($this->filePointer, 8192); | |
| $sector = 2; | |
| foreach($sectors as $sector => $index){ | |
| if(($sector - $lastSector) > 1){ | |
| $shift += $sector - $lastSector - 1; | |
| } | |
| if($shift > 0){ | |
| fseek($this->filePointer, $sector << 12); | |
| $old = fread($this->filePointer, 4096); | |
| fseek($this->filePointer, ($sector - $shift) << 12); | |
| fwrite($this->filePointer, $old, 4096); | |
| } | |
| $this->locationTable[$index][0] -= $shift; | |
| } | |
| ftruncate($this->filePointer, ($sector + 1) << 12); //Truncate to the end of file written | |
| return $shift; | |
| } | |
| private function loadLocationTable(){ | |
| fseek($this->filePointer, 0); | |
| for($i = 0; $i < 1024; ++$i){ | |
| $index = Binary::readInt(fread($this->filePointer, 4)); | |
| $this->locationTable[$i] = array(($index & ~0xff) >> 8, $index & 0xff); | |
| } | |
| } | |
| private function writeLocationTable(){ | |
| fseek($this->filePointer, 0); | |
| for($i = 0; $i < 1024; ++$i){ | |
| fwrite($this->filePointer, Binary::writeInt(($this->locationTable[$i][0] << 8) | $this->locationTable[$i][1])); | |
| } | |
| } | |
| private function writeLocationIndex($index){ | |
| fseek($this->filePointer, $index << 2); | |
| fwrite($this->filePointer, Binary::writeInt(($this->locationTable[$index][0] << 8) | $this->locationTable[$index][1])); | |
| } | |
| private function createBlank(){ | |
| fseek($this->filePointer, 0); | |
| ftruncate($this->filePointer, 0); | |
| for($i = 0; $i < 1024; ++$i){ | |
| $this->locationTable[$i] = array(0, 0); | |
| fwrite($this->filePointer, Binary::writeInt(0)); | |
| } | |
| for($i = 0; $i < 1024; ++$i){ | |
| fwrite($this->filePointer, Binary::writeInt(0)); | |
| } | |
| } | |
| public function getX(){ | |
| return $this->x; | |
| } | |
| public function getZ(){ | |
| return $this->z; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format; | |
| interface Chunk{ | |
| const SECTION_COUNT = 8; | |
| /** | |
| * @return int | |
| */ | |
| public function getX(); | |
| /** | |
| * @return int | |
| */ | |
| public function getZ(); | |
| /** | |
| * @return \pocketmine\level\Level | |
| */ | |
| public function getLevel(); | |
| /** | |
| * Modifies $blockId and $meta | |
| * | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * @param int &$blockId | |
| * @param int &$meta | |
| */ | |
| public function getBlock($x, $y, $z, &$blockId, &$meta = null); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * @param int $blockId, if null, do not change | |
| * @param int $meta 0-15, if null, do not change | |
| */ | |
| public function setBlock($x, $y, $z, $blockId = null, $meta = null); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockSkyLight($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * @param int $level 0-15 | |
| */ | |
| public function setBlockSkyLight($x, $y, $z, $level); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockLight($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * @param int $level 0-15 | |
| */ | |
| public function setBlockLight($x, $y, $z, $level); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-127 | |
| */ | |
| public function getHighestBlockAt($x, $z); | |
| /** | |
| * Thread-safe read-only chunk | |
| * | |
| * @return ChunkSnapshot | |
| */ | |
| public function getChunkSnapshot(); | |
| /** | |
| * @return \pocketmine\entity\Entity[] | |
| */ | |
| public function getEntities(); | |
| /** | |
| * @return \pocketmine\tile\Tile[] | |
| */ | |
| public function getTiles(); | |
| /** | |
| * @return bool | |
| */ | |
| public function isLoaded(); | |
| /** | |
| * Loads the chunk | |
| * | |
| * @param bool $generate If the chunk does not exist, generate it | |
| * | |
| * @return bool | |
| */ | |
| public function load($generate = true); | |
| /** | |
| * @param bool $save | |
| * @param bool $safe If false, unload the chunk even if players are nearby | |
| * | |
| * @return bool | |
| */ | |
| public function unload($save = true, $safe = true); | |
| /** | |
| * Tests whether a section (mini-chunk) is empty | |
| * | |
| * @param $fY 0-7, (Y / 16) | |
| * | |
| * @return bool | |
| */ | |
| public function isSectionEmpty($fY); | |
| /** | |
| * @param int $fY 0-7 | |
| * | |
| * @return ChunkSection | |
| */ | |
| public function getSection($fY); | |
| /** | |
| * @param int $fY 0-7 | |
| * @param ChunkSection $section | |
| * | |
| * @return boolean | |
| */ | |
| public function setSection($fY, ChunkSection $section); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format; | |
| interface ChunkSection{ | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-255 | |
| */ | |
| public function getBlockId($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * @param int $id 0-255 | |
| */ | |
| public function setBlockId($x, $y, $z, $id); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockData($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * @param int $data 0-15 | |
| */ | |
| public function setBlockData($x, $y, $z, $data); | |
| /** | |
| * Modifies $blockId and $meta | |
| * | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * @param int &$blockId | |
| * @param int &$meta | |
| */ | |
| public function getBlock($x, $y, $z, &$blockId, &$meta = null); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * @param int $blockId, if null, do not change | |
| * @param int $meta 0-15, if null, do not change | |
| */ | |
| public function setBlock($x, $y, $z, $blockId = null, $meta = null); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockSkyLight($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * @param int $level 0-15 | |
| */ | |
| public function setBlockSkyLight($x, $y, $z, $level); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockLight($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-15 | |
| * @param int $z 0-15 | |
| * @param int $level 0-15 | |
| */ | |
| public function setBlockLight($x, $y, $z, $level); | |
| /** | |
| * Returns a id column from high y to low y | |
| * | |
| * @param int $x 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return string[16] | |
| */ | |
| public function getBlockIdColumn($x, $z); | |
| /** | |
| * Returns a data column from high y to low y | |
| * | |
| * @param int $x 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return string[8] | |
| */ | |
| public function getBlockDataColumn($x, $z); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format; | |
| interface ChunkSnapshot{ | |
| /** | |
| * @return int | |
| */ | |
| public function getX(); | |
| /** | |
| * @return int | |
| */ | |
| public function getZ(); | |
| /** | |
| * @return string | |
| */ | |
| public function getLevelName(); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-255 | |
| */ | |
| public function getBlockId($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockData($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockSkyLight($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $y 0-127 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-15 | |
| */ | |
| public function getBlockLight($x, $y, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return int 0-127 | |
| */ | |
| public function getHighestBlockAt($x, $z); | |
| /** | |
| * @param int $x 0-15 | |
| * @param int $z 0-15 | |
| * | |
| * @return int | |
| */ | |
| public function getBiome($x, $z); | |
| /** | |
| * Tests whether a section (mini-chunk) is empty | |
| * | |
| * @param $fY 0-7, (Y / 16) | |
| * | |
| * @return bool | |
| */ | |
| public function isSectionEmpty($fY); | |
| /** | |
| * @param int $Y 0-7 | |
| * | |
| * @return ChunkSection | |
| */ | |
| public function getSection($Y); | |
| /** | |
| * @param int $Y 0-7 | |
| * @param ChunkSection $section | |
| * | |
| * @return boolean | |
| */ | |
| public function setSection($Y, ChunkSection $section); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format\generic; | |
| use pocketmine\level\format\Chunk; | |
| use pocketmine\level\format\ChunkSection; | |
| use pocketmine\level\Level; | |
| abstract class BaseChunk implements Chunk{ | |
| /** @var ChunkSection[] */ | |
| protected $sections = array(); | |
| protected $level; | |
| protected $x; | |
| protected $z; | |
| /** | |
| * @param Level $level | |
| * @param int $x | |
| * @param int $z | |
| * @param ChunkSection[] $sections | |
| */ | |
| public function __construct(Level $level, $x, $z, array $sections){ | |
| $this->level = $level; | |
| $this->x = (int) $x; | |
| $this->z = (int) $z; | |
| $Y = 0; | |
| foreach($sections as $section){ | |
| if($section instanceof ChunkSection){ | |
| $this->sections[$Y] = $section; | |
| }else{ | |
| trigger_error("Received invalid ChunkSection instance", E_USER_ERROR); | |
| return; | |
| } | |
| ++$Y; | |
| if($section >= self::SECTION_COUNT){ | |
| trigger_error("Invalid amount of chunks", E_USER_WARNING); | |
| return; | |
| } | |
| } | |
| } | |
| public function getX(){ | |
| return $this->x; | |
| } | |
| public function getZ(){ | |
| return $this->z; | |
| } | |
| public function getLevel(){ | |
| return $this->level; | |
| } | |
| public function getBlock($x, $y, $z, &$blockId, &$meta = null){ | |
| $this->sections[$y >> 4]->getBlock($x, $y - ($y >> 4), $z, $blockId, $meta); | |
| } | |
| public function setBlock($x, $y, $z, $blockId = null, $meta = null){ | |
| $this->sections[$y >> 4]->setBlock($x, $y - ($y >> 4), $z, $blockId, $meta); | |
| } | |
| public function getBlockSkyLight($x, $y, $z){ | |
| return $this->sections[$y >> 4]->getBlockSkyLight($x, $y - ($y >> 4), $z); | |
| } | |
| public function setBlockSkyLight($x, $y, $z, $data){ | |
| $this->sections[$y >> 4]->getBlockSkyLight($x, $y - ($y >> 4), $z, $data); | |
| } | |
| public function getBlockLight($x, $y, $z){ | |
| return $this->sections[$y >> 4]->getBlockSkyLight($x, $y - ($y >> 4), $z); | |
| } | |
| public function setBlockLight($x, $y, $z, $data){ | |
| $this->sections[$y >> 4]->getBlockSkyLight($x, $y - ($y >> 4), $z, $data); | |
| } | |
| public function getHighestBlockAt($x, $z){ | |
| for($Y = self::SECTION_COUNT; $Y >= 0; --$Y){ | |
| if(!$this->isSectionEmpty($Y)){ | |
| $column = $this->sections[$Y]->getBlockIdColumn($x, $z); | |
| for($y = 15; $y >= 0; --$y){ | |
| if($column{$y} !== "\x00"){ | |
| return $y + $Y << 4; | |
| } | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| public function isSectionEmpty($fY){ | |
| return $this->sections[(int) $fY] instanceof EmptyChunkSection; | |
| } | |
| public function getSection($fY){ | |
| return $this->sections[(int) $fY]; | |
| } | |
| public function setSection($fY, ChunkSection $section){ | |
| $this->sections[(int) $fY] = $section; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format\generic; | |
| use pocketmine\level\format\ChunkSection; | |
| /** | |
| * Stub used to detect empty chunks | |
| */ | |
| class EmptyChunkSection implements ChunkSection{ | |
| final public function getBlockId($x, $y, $z){ | |
| return 0; | |
| } | |
| final public function getBlockIdColumn($x, $z){ | |
| return "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; | |
| } | |
| final public function getBlockDataColumn($x, $z){ | |
| return "\x00\x00\x00\x00\x00\x00\x00\x00"; | |
| } | |
| final public function setBlockId($x, $y, $z, $id){ | |
| } | |
| final public function getBlockData($x, $y, $z){ | |
| return 0; | |
| } | |
| final public function setBlockData($x, $y, $z, $data){ | |
| } | |
| final public function getBlockLight($x, $y, $z){ | |
| return 0; | |
| } | |
| final public function setBlockLight($x, $y, $z, $level){ | |
| } | |
| final public function getBlockSkyLight($x, $y, $z){ | |
| return 0; | |
| } | |
| final public function setBlockSkyLight($x, $y, $z, $level){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format; | |
| /** | |
| * All Level formats must implement this interface | |
| */ | |
| interface LevelFormat{ | |
| /** | |
| * @param string $path | |
| * @param string $levelName | |
| */ | |
| public function __construct($path, $levelName); | |
| /** | |
| * Tells if the path is a valid level | |
| * | |
| * @param string $path | |
| * | |
| * @return true | |
| */ | |
| public static function isValid($path); | |
| /** | |
| * @param int $X absolute Chunk X value | |
| * @param int $Z absolute Chunk Z value | |
| * @param bool $create Whether to generate the chunk if it does not exist | |
| * | |
| * @return ChunkSnapshot | |
| */ | |
| public function getChunk($X, $Z, $create = false); | |
| /** | |
| * @return bool | |
| */ | |
| public function saveChunks(); | |
| public function unloadChunks(); | |
| public function loadChunk($X, $Z); | |
| public function unloadChunk($X, $Z); | |
| public function getName(); | |
| /** | |
| * @return ChunkSnapshot | |
| */ | |
| public function getLoadedChunks(); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format\pmf; | |
| class ChunkSection implements \pocketmine\level\format\ChunkSection{ | |
| const METADATA_OFFSET = 16; | |
| const LIGHT_OFFSET = 24; | |
| const SKYLIGHT_OFFSET = 32; | |
| private $section = ""; | |
| public function __construct($section = null){ | |
| if($section !== null){ | |
| if(strlen($section) !== 8192){ | |
| trigger_error("Invalid ChunkSection generated", E_USER_WARNING); | |
| return; | |
| } | |
| $this->section = $section; | |
| }else{ | |
| $this->section = str_repeat("\x00\x00\x00\x00\x00\x00\x00\x00", 1024); | |
| } | |
| } | |
| public function getBlockId($x, $y, $z){ | |
| return $b = ord($this->section{$y + ($x << 5) + ($z << 9)}); | |
| } | |
| public function getBlock($x, $y, $z, &$blockId, &$meta = null){ | |
| $i = ($x << 5) + ($z << 9); | |
| $blockId = ord($this->section{$i + $y}); | |
| $meta = ord($this->section{($y >> 1) + self::METADATA_OFFSET}); | |
| } | |
| public function setBlock($x, $y, $z, $blockId = null, $meta = null){ | |
| $i = ($x << 5) + ($z << 9); | |
| if($blockId !== null){ | |
| $this->section{$i + $y} = chr($blockId); | |
| } | |
| if($meta !== null){ | |
| $i += ($y >> 1) + self::METADATA_OFFSET; | |
| $m = ord($this->section{$i}); | |
| if(($y & 1) === 0){ | |
| $this->section{$i} = chr(($m & 0xf0) | ($meta & 0x0f)); | |
| }else{ | |
| $this->section{$i} = chr((($meta & 0x0f) << 4) | ($m & 0x0f)); | |
| } | |
| } | |
| } | |
| public function setBlockId($x, $y, $z, $id){ | |
| $this->section{$y + ($x << 5) + ($z << 9)} = chr($id & 0xff); | |
| } | |
| public function getBlockData($x, $y, $z){ | |
| $m = ord($this->section{($y >> 1) + self::METADATA_OFFSET + ($x << 5) + ($z << 9)}); | |
| if(($y & 1) === 0){ | |
| return $m & 0x0F; | |
| }else{ | |
| return $m >> 4; | |
| } | |
| } | |
| public function setBlockData($x, $y, $z, $data){ | |
| $i = ($y >> 1) + self::METADATA_OFFSET + ($x << 5) + ($z << 9); | |
| $m = ord($this->section{$i}); | |
| if(($y & 1) === 0){ | |
| $this->section{$i} = chr(($m & 0xf0) | ($data & 0x0f)); | |
| }else{ | |
| $this->section{$i} = chr((($data & 0x0f) << 4) | ($m & 0x0f)); | |
| } | |
| } | |
| public function getBlockIdColumn($x, $z){ | |
| $column = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; | |
| $i = ($x << 5) + ($z << 9); | |
| for($y = 15; $y >= 0; --$y){ | |
| $column{15 - $y} = $this->section{$i + $y}; | |
| } | |
| return $column; | |
| } | |
| public function getBlockDataColumn($x, $z){ | |
| $column = "\x00\x00\x00\x00\x00\x00\x00\x00"; | |
| $i = ($x << 5) + ($z << 9) + self::METADATA_OFFSET; | |
| for($y = 7; $y >= 0; --$y){ | |
| $column{7 - $y} = $this->section{$i + $y}; | |
| } | |
| return $column; | |
| } | |
| public function getBlockLight($x, $y, $z){ | |
| $l = ord($this->section{($y >> 1) + self::LIGHT_OFFSET + ($x << 5) + ($z << 9)}); | |
| if(($y & 1) === 0){ | |
| return $l & 0x0F; | |
| }else{ | |
| return $l >> 4; | |
| } | |
| } | |
| public function setBlockLight($x, $y, $z, $level){ | |
| $i = ($y >> 1) + self::LIGHT_OFFSET + ($x << 5) + ($z << 9); | |
| $l = ord($this->section{$i}); | |
| if(($y & 1) === 0){ | |
| $this->section{$i} = chr(($l & 0xf0) | ($level & 0x0f)); | |
| }else{ | |
| $this->section{$i} = chr((($level & 0x0f) << 4) | ($l & 0x0f)); | |
| } | |
| } | |
| public function getBlockSkyLight($x, $y, $z){ | |
| $sl = ord($this->section{($y >> 1) + self::SKYLIGHT_OFFSET + ($x << 5) + ($z << 9)}); | |
| if(($y & 1) === 0){ | |
| return $sl & 0x0F; | |
| }else{ | |
| return $sl >> 4; | |
| } | |
| } | |
| public function setBlockSkyLight($x, $y, $z, $level){ | |
| $i = ($y >> 1) + self::SKYLIGHT_OFFSET + ($x << 5) + ($z << 9); | |
| $sl = ord($this->section{$i}); | |
| if(($y & 1) === 0){ | |
| $this->section{$i} = chr(($sl & 0xf0) | ($level & 0x0f)); | |
| }else{ | |
| $this->section{$i} = chr((($level & 0x0f) << 4) | ($sl & 0x0f)); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format\pmf; | |
| use pocketmine\level\Level; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\nbt\tag\Enum; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class LevelFormat extends PMF{ | |
| const VERSION = 2; | |
| const ZLIB_LEVEL = 6; | |
| const ZLIB_ENCODING = 15; //15 = zlib, -15 = raw deflate, 31 = gzip | |
| public $level; | |
| public $levelData = array(); | |
| public $isLoaded = true; | |
| private $chunks = array(); | |
| private $chunkChange = array(); | |
| private $chunkInfo = array(); | |
| public $isGenerating = 0; | |
| public function getData($index){ | |
| if(!isset($this->levelData[$index])){ | |
| return false; | |
| } | |
| return ($this->levelData[$index]); | |
| } | |
| public function setData($index, $data){ | |
| if(!isset($this->levelData[$index])){ | |
| return false; | |
| } | |
| $this->levelData[$index] = $data; | |
| return true; | |
| } | |
| public function closeLevel(){ | |
| $this->chunks = null; | |
| unset($this->chunks, $this->chunkChange, $this->chunkInfo, $this->level); | |
| $this->close(); | |
| } | |
| /** | |
| * @param string $file | |
| * @param bool|array $blank default false | |
| */ | |
| public function __construct($file, $blank = false){ | |
| $this->chunks = array(); | |
| $this->chunkChange = array(); | |
| $this->chunkInfo = array(); | |
| if(is_array($blank)){ | |
| $this->create($file, 0); | |
| $this->levelData = $blank; | |
| $this->createBlank(); | |
| $this->isLoaded = true; | |
| }else{ | |
| if($this->load($file) !== false){ | |
| $this->parseInfo(); | |
| if($this->parseLevel() === false){ | |
| $this->isLoaded = false; | |
| }else{ | |
| $this->isLoaded = true; | |
| } | |
| }else{ | |
| $this->isLoaded = false; | |
| } | |
| } | |
| } | |
| public function saveData(){ | |
| $this->levelData["version"] = self::VERSION; | |
| @ftruncate($this->fp, 5); | |
| $this->seek(5); | |
| $this->write(chr($this->levelData["version"])); | |
| $this->write(Binary::writeShort(strlen($this->levelData["name"])) . $this->levelData["name"]); | |
| $this->write(Binary::writeInt($this->levelData["seed"])); | |
| $this->write(Binary::writeInt($this->levelData["time"])); | |
| $this->write(Binary::writeFloat($this->levelData["spawnX"])); | |
| $this->write(Binary::writeFloat($this->levelData["spawnY"])); | |
| $this->write(Binary::writeFloat($this->levelData["spawnZ"])); | |
| $this->write(chr($this->levelData["height"])); | |
| $this->write(Binary::writeShort(strlen($this->levelData["generator"])) . $this->levelData["generator"]); | |
| $settings = serialize($this->levelData["generatorSettings"]); | |
| $this->write(Binary::writeShort(strlen($settings)) . $settings); | |
| $extra = zlib_encode($this->levelData["extra"], self::ZLIB_ENCODING, self::ZLIB_LEVEL); | |
| $this->write(Binary::writeShort(strlen($extra)) . $extra); | |
| } | |
| private function createBlank(){ | |
| $this->saveData(); | |
| @mkdir(dirname($this->file) . "/chunks/", 0755); | |
| } | |
| protected function parseLevel(){ | |
| if($this->getType() !== 0x00){ | |
| return false; | |
| } | |
| $this->seek(5); | |
| $this->levelData["version"] = ord($this->read(1)); | |
| if($this->levelData["version"] > self::VERSION){ | |
| console("[ERROR] New unsupported PMF Level format version #" . $this->levelData["version"] . ", current version is #" . self::VERSION); | |
| return false; | |
| } | |
| $this->levelData["name"] = $this->read(Binary::readShort($this->read(2), false)); | |
| $this->levelData["seed"] = Binary::readInt($this->read(4)); | |
| $this->levelData["time"] = Binary::readInt($this->read(4)); | |
| $this->levelData["spawnX"] = Binary::readFloat($this->read(4)); | |
| $this->levelData["spawnY"] = Binary::readFloat($this->read(4)); | |
| $this->levelData["spawnZ"] = Binary::readFloat($this->read(4)); | |
| if($this->levelData["version"] === 0){ | |
| $this->read(1); | |
| $this->levelData["height"] = ord($this->read(1)); | |
| }else{ | |
| $this->levelData["height"] = ord($this->read(1)); | |
| if($this->levelData["height"] !== 8){ | |
| return false; | |
| } | |
| $this->levelData["generator"] = $this->read(Binary::readShort($this->read(2), false)); | |
| $this->levelData["generatorSettings"] = unserialize($this->read(Binary::readShort($this->read(2), false))); | |
| } | |
| $this->levelData["extra"] = @zlib_decode($this->read(Binary::readShort($this->read(2), false))); | |
| $upgrade = false; | |
| if($this->levelData["version"] === 0){ | |
| $this->upgrade_From0_To1(); | |
| $upgrade = true; | |
| } | |
| if($this->levelData["version"] === 1){ | |
| $this->upgrade_From1_To2(); | |
| $upgrade = true; | |
| } | |
| if($upgrade === true){ | |
| $this->saveData(); | |
| } | |
| } | |
| private function upgrade_From0_To1(){ | |
| console("[NOTICE] Old PMF Level format version #0 detected, upgrading to version #1"); | |
| for($index = 0; $index < 256; ++$index){ | |
| $X = $index & 0x0F; | |
| $Z = $index >> 4; | |
| $bitflags = Binary::readShort($this->read(2)); | |
| $oldPath = dirname($this->file) . "/chunks/" . $Z . "." . $X . ".pmc"; | |
| $chunkOld = gzopen($oldPath, "rb"); | |
| $newPath = dirname($this->file) . "/chunks/" . (($X ^ $Z) & 0xff) . "/" . $Z . "." . $X . ".pmc"; | |
| @mkdir(dirname($newPath)); | |
| $chunkNew = gzopen($newPath, "wb1"); | |
| gzwrite($chunkNew, chr($bitflags) . "\x00\x00\x00\x01"); | |
| while(gzeof($chunkOld) === false){ | |
| gzwrite($chunkNew, gzread($chunkOld, 65535)); | |
| } | |
| gzclose($chunkNew); | |
| gzclose($chunkOld); | |
| @unlink($oldPath); | |
| } | |
| $this->levelData["version"] = 1; | |
| $this->levelData["generator"] = "default"; | |
| $this->levelData["generatorSettings"] = ""; | |
| } | |
| private function upgrade_From1_To2(){ | |
| console("[NOTICE] Old PMF Level format version #1 detected, upgrading to version #2"); | |
| $nbt = new Compound("", array( | |
| new Enum("Entities", array()), | |
| new Enum("TileEntities", array()) | |
| )); | |
| $nbt->Entities->setTagType(NBT::TAG_Compound); | |
| $nbt->TileEntities->setTagType(NBT::TAG_Compound); | |
| $nbtCodec = new NBT(NBT::BIG_ENDIAN); | |
| $nbtCodec->setData($nbt); | |
| $namedtag = $nbtCodec->write(); | |
| $namedtag = Binary::writeInt(strlen($namedtag)) . $namedtag; | |
| foreach(glob(dirname($this->file) . "/chunks/*/*.*.pmc") as $chunkFile){ | |
| $oldChunk = zlib_decode(file_get_contents($chunkFile)); | |
| $newChunk = substr($oldChunk, 0, 5); | |
| $newChunk .= $namedtag; | |
| $newChunk .= str_repeat("\x01", 256); //Biome indexes (all Plains) | |
| $newChunk .= substr($oldChunk, 5); | |
| file_put_contents($chunkFile, zlib_encode($newChunk, self::ZLIB_ENCODING, self::ZLIB_LEVEL)); | |
| } | |
| $this->levelData["version"] = 2; | |
| } | |
| public static function getIndex($X, $Z){ | |
| return ($Z << 16) | ($X < 0 ? (~--$X & 0x7fff) | 0x8000 : $X & 0x7fff); | |
| } | |
| public static function getXZ($index, &$X = null, &$Z = null){ | |
| $Z = $index >> 16; | |
| $X = ($index & 0x8000) === 0x8000 ? -($index & 0x7fff) : $index & 0x7fff; | |
| return array($X, $Z); | |
| } | |
| private function getChunkPath($X, $Z){ | |
| return dirname($this->file) . "/chunks/" . (((int) $X ^ (int) $Z) & 0xff) . "/" . $Z . "." . $X . ".pmc"; | |
| } | |
| public function generateChunk($X, $Z){ | |
| $path = $this->getChunkPath($X, $Z); | |
| if(!file_exists(dirname($path))){ | |
| @mkdir(dirname($path), 0755); | |
| } | |
| $this->initCleanChunk($X, $Z); | |
| if($this->level instanceof Level){ | |
| $ret = $this->level->generateChunk($X, $Z); | |
| $this->saveChunk($X, $Z); | |
| $this->populateChunk($X - 1, $Z); | |
| $this->populateChunk($X + 1, $Z); | |
| $this->populateChunk($X, $Z - 1); | |
| $this->populateChunk($X, $Z + 1); | |
| $this->populateChunk($X + 1, $Z + 1); | |
| $this->populateChunk($X + 1, $Z - 1); | |
| $this->populateChunk($X - 1, $Z - 1); | |
| $this->populateChunk($X - 1, $Z + 1); | |
| return $ret; | |
| } | |
| } | |
| public function populateChunk($X, $Z){ | |
| if($this->level instanceof Level){ | |
| if($this->isGenerating === 0 and | |
| $this->isChunkLoaded($X, $Z) and | |
| !$this->isPopulated($X, $Z) and | |
| $this->isGenerated($X - 1, $Z) and | |
| $this->isGenerated($X, $Z - 1) and | |
| $this->isGenerated($X + 1, $Z) and | |
| $this->isGenerated($X, $Z + 1) and | |
| $this->isGenerated($X + 1, $Z + 1) and | |
| $this->isGenerated($X - 1, $Z - 1) and | |
| $this->isGenerated($X + 1, $Z - 1) and | |
| $this->isGenerated($X - 1, $Z + 1) | |
| ){ | |
| $this->level->populateChunk($X, $Z); | |
| $this->saveChunk($X, $Z); | |
| } | |
| } | |
| } | |
| public function loadChunk($X, $Z){ | |
| if($this->isChunkLoaded($X, $Z)){ | |
| return true; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| $path = $this->getChunkPath($X, $Z); | |
| if(!file_exists($path)){ | |
| if($this->generateChunk($X, $Z) === false){ | |
| return false; | |
| } | |
| if($this->isGenerating === 0){ | |
| $this->populateChunk($X, $Z); | |
| } | |
| return true; | |
| } | |
| $chunk = file_get_contents($path); | |
| if($chunk === false){ | |
| return false; | |
| } | |
| $chunk = zlib_decode($chunk); | |
| $offset = 0; | |
| $this->chunkInfo[$index] = array( | |
| 0 => ord($chunk{0}), | |
| 1 => Binary::readInt(substr($chunk, 1, 4)), | |
| ); | |
| $offset += 5; | |
| $len = Binary::readInt(substr($chunk, $offset, 4)); | |
| $offset += 4; | |
| $nbt = new NBT(NBT::BIG_ENDIAN); | |
| $nbt->read(substr($chunk, $offset, $len)); | |
| $this->chunkInfo[$index][2] = $nbt->getData(); | |
| $offset += $len; | |
| $this->chunks[$index] = array(); | |
| $this->chunkChange[$index] = array(-1 => false); | |
| $this->chunkInfo[$index][3] = substr($chunk, $offset, 256); //Biome data | |
| $offset += 256; | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| if(($this->chunkInfo[$index][0] & (1 << $Y)) !== 0){ | |
| // 4096 + 2048 + 2048, Block Data, Meta, Light | |
| if(strlen($this->chunks[$index][$Y] = substr($chunk, $offset, 8192)) < 8192){ | |
| console("[NOTICE] Empty corrupt chunk detected [$X,$Z,:$Y], recovering contents", true, true, 2); | |
| $this->fillMiniChunk($X, $Z, $Y); | |
| } | |
| $offset += 8192; | |
| }else{ | |
| $this->chunks[$index][$Y] = false; | |
| } | |
| } | |
| if($this->isGenerating === 0 and !$this->isPopulated($X, $Z)){ | |
| $this->populateChunk($X, $Z); | |
| } | |
| return true; | |
| } | |
| public function unloadChunk($X, $Z, $save = true){ | |
| $X = (int) $X; | |
| $Z = (int) $Z; | |
| if(!$this->isChunkLoaded($X, $Z)){ | |
| return false; | |
| }elseif($save !== false){ | |
| $this->saveChunk($X, $Z); | |
| } | |
| $index = self::getIndex($X, $Z); | |
| $this->chunks[$index] = null; | |
| $this->chunkChange[$index] = null; | |
| $this->chunkInfo[$index] = null; | |
| unset($this->chunks[$index], $this->chunkChange[$index], $this->chunkInfo[$index]); | |
| return true; | |
| } | |
| public function isChunkLoaded($X, $Z){ | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| return false; | |
| } | |
| return true; | |
| } | |
| protected function cleanChunk($X, $Z){ | |
| $index = self::getIndex($X, $Z); | |
| if(isset($this->chunks[$index])){ | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| if($this->chunks[$index][$Y] !== false and substr_count($this->chunks[$index][$Y], "\x00") === 8192){ | |
| $this->chunks[$index][$Y] = false; | |
| $this->chunkInfo[$index][0] &= ~(1 << $Y); | |
| } | |
| } | |
| } | |
| } | |
| public function isMiniChunkEmpty($X, $Z, $Y){ | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index]) or $this->chunks[$index][$Y] === false){ | |
| return true; | |
| } | |
| return false; | |
| } | |
| protected function fillMiniChunk($X, $Z, $Y){ | |
| if($this->isChunkLoaded($X, $Z) === false){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| $this->chunks[$index][$Y] = str_repeat("\x00", 8192); | |
| $this->chunkChange[$index][-1] = true; | |
| $this->chunkChange[$index][$Y] = 8192; | |
| $this->chunkInfo[$index][0] |= 1 << $Y; | |
| return true; | |
| } | |
| public function getMiniChunk($X, $Z, $Y){ | |
| if($this->isChunkLoaded($X, $Z) === false and $this->loadChunk($X, $Z) === false){ | |
| return str_repeat("\x00", 8192); | |
| } | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index][$Y]) or $this->chunks[$index][$Y] === false){ | |
| return str_repeat("\x00", 8192); | |
| } | |
| return $this->chunks[$index][$Y]; | |
| } | |
| public function initCleanChunk($X, $Z){ | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| $this->chunks[$index] = array( | |
| 0 => false, | |
| 1 => false, | |
| 2 => false, | |
| 3 => false, | |
| 4 => false, | |
| 5 => false, | |
| 6 => false, | |
| 7 => false, | |
| ); | |
| $this->chunkChange[$index] = array( | |
| -1 => true, | |
| 0 => 8192, | |
| 1 => 8192, | |
| 2 => 8192, | |
| 3 => 8192, | |
| 4 => 8192, | |
| 5 => 8192, | |
| 6 => 8192, | |
| 7 => 8192, | |
| ); | |
| $nbt = new Compound("", array( | |
| new Enum("Entities", array()), | |
| new Enum("TileEntities", array()) | |
| )); | |
| $nbt->Entities->setTagType(NBT::TAG_Compound); | |
| $nbt->TileEntities->setTagType(NBT::TAG_Compound); | |
| $this->chunkInfo[$index] = array( | |
| 0 => 0, | |
| 1 => 0, | |
| 2 => $nbt, | |
| 3 => str_repeat("\x00", 256), | |
| ); | |
| } | |
| } | |
| public function setMiniChunk($X, $Z, $Y, $data){ | |
| if($this->isGenerating > 0){ | |
| $this->initCleanChunk($X, $Z); | |
| }elseif($this->isChunkLoaded($X, $Z) === false){ | |
| $this->loadChunk($X, $Z); | |
| } | |
| if(strlen($data) !== 8192){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| $this->chunks[$index][$Y] = (string) $data; | |
| $this->chunkChange[$index][-1] = true; | |
| $this->chunkChange[$index][$Y] = 8192; | |
| $this->chunkInfo[$index][0] |= 1 << $Y; | |
| return true; | |
| } | |
| public function getBlockID($x, $y, $z){ | |
| if($y > 127 or $y < 0){ | |
| return 0; | |
| } | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $Y = $y >> 4; | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| return 0; | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $aY = $y - ($Y << 4); | |
| $b = ord($this->chunks[$index][$Y]{(int) ($aY + ($aX << 5) + ($aZ << 9))}); | |
| return $b; | |
| } | |
| public function getBiome($x, $z){ | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| return 0; | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| return ord($this->chunkInfo[$index][3]{$aX + ($aZ << 4)}); | |
| } | |
| public function setBiome($x, $z, $biome){ | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| return false; | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $this->chunkInfo[$index][3]{$aX + ($aZ << 4)} = chr((int) $biome); | |
| return true; | |
| } | |
| public function setBlockID($x, $y, $z, $block){ | |
| if($y > 127 or $y < 0){ | |
| return false; | |
| } | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $Y = $y >> 4; | |
| $block &= 0xFF; | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| return false; | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $aY = $y - ($Y << 4); | |
| $this->chunks[$index][$Y]{(int) ($aY + ($aX << 5) + ($aZ << 9))} = chr($block); | |
| if(!isset($this->chunkChange[$index][$Y])){ | |
| $this->chunkChange[$index][$Y] = 1; | |
| }else{ | |
| ++$this->chunkChange[$index][$Y]; | |
| } | |
| $this->chunkChange[$index][-1] = true; | |
| return true; | |
| } | |
| public function getBlockDamage($x, $y, $z){ | |
| if($y > 127 or $y < 0){ | |
| return 0; | |
| } | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $Y = $y >> 4; | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| return 0; | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $aY = $y - ($Y << 4); | |
| $m = ord($this->chunks[$index][$Y]{(int) (($aY >> 1) + 16 + ($aX << 5) + ($aZ << 9))}); | |
| if(($y & 1) === 0){ | |
| $m = $m & 0x0F; | |
| }else{ | |
| $m = $m >> 4; | |
| } | |
| return $m; | |
| } | |
| public function setBlockDamage($x, $y, $z, $damage){ | |
| if($y > 127 or $y < 0){ | |
| return false; | |
| } | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $Y = $y >> 4; | |
| $damage &= 0x0F; | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index])){ | |
| return false; | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $aY = $y - ($Y << 4); | |
| $mindex = (int) (($aY >> 1) + 16 + ($aX << 5) + ($aZ << 9)); | |
| $old_m = ord($this->chunks[$index][$Y]{$mindex}); | |
| if(($y & 1) === 0){ | |
| $m = ($old_m & 0xF0) | $damage; | |
| }else{ | |
| $m = ($damage << 4) | ($old_m & 0x0F); | |
| } | |
| if($old_m != $m){ | |
| $this->chunks[$index][$Y]{$mindex} = chr($m); | |
| if(!isset($this->chunkChange[$index][$Y])){ | |
| $this->chunkChange[$index][$Y] = 1; | |
| }else{ | |
| ++$this->chunkChange[$index][$Y]; | |
| } | |
| $this->chunkChange[$index][-1] = true; | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getBlock($x, $y, $z){ | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $Y = $y >> 4; | |
| if($y < 0 or $y > 127){ | |
| return array(0, 0); | |
| } | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index]) and $this->loadChunk($X, $Z) === false){ | |
| return array(0, 0); | |
| }elseif($this->chunks[$index][$Y] === false){ | |
| return array(0, 0); | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $aY = $y - ($Y << 4); | |
| $b = ord($this->chunks[$index][$Y]{(int) ($aY + ($aX << 5) + ($aZ << 9))}); | |
| $m = ord($this->chunks[$index][$Y]{(int) (($aY >> 1) + 16 + ($aX << 5) + ($aZ << 9))}); | |
| if(($y & 1) === 0){ | |
| $m = $m & 0x0F; | |
| }else{ | |
| $m = $m >> 4; | |
| } | |
| return array($b, $m); | |
| } | |
| public function setBlock($x, $y, $z, $block, $meta = 0){ | |
| if($y > 127 or $y < 0){ | |
| return false; | |
| } | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $Y = $y >> 4; | |
| $block &= 0xFF; | |
| $meta &= 0x0F; | |
| $index = self::getIndex($X, $Z); | |
| if(!isset($this->chunks[$index]) and $this->loadChunk($X, $Z) === false){ | |
| return false; | |
| }elseif($this->chunks[$index][$Y] === false){ | |
| $this->fillMiniChunk($X, $Z, $Y); | |
| } | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $aY = $y - ($Y << 4); | |
| $bindex = (int) ($aY + ($aX << 5) + ($aZ << 9)); | |
| $mindex = (int) (($aY >> 1) + 16 + ($aX << 5) + ($aZ << 9)); | |
| $old_b = ord($this->chunks[$index][$Y]{$bindex}); | |
| $old_m = ord($this->chunks[$index][$Y]{$mindex}); | |
| if(($y & 1) === 0){ | |
| $m = ($old_m & 0xF0) | $meta; | |
| }else{ | |
| $m = ($meta << 4) | ($old_m & 0x0F); | |
| } | |
| if($old_b !== $block or $old_m !== $m){ | |
| $this->chunks[$index][$Y]{$bindex} = chr($block); | |
| $this->chunks[$index][$Y]{$mindex} = chr($m); | |
| if(!isset($this->chunkChange[$index][$Y])){ | |
| $this->chunkChange[$index][$Y] = 1; | |
| }else{ | |
| ++$this->chunkChange[$index][$Y]; | |
| } | |
| $this->chunkChange[$index][-1] = true; | |
| return true; | |
| } | |
| return false; | |
| } | |
| public function getChunkNBT($X, $Z){ | |
| if(!$this->isChunkLoaded($X, $Z) and $this->loadChunk($X, $Z) === false){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| return $this->chunkInfo[$index][2]; | |
| } | |
| public function setChunkNBT($X, $Z, Compound $nbt){ | |
| if(!$this->isChunkLoaded($X, $Z) and $this->loadChunk($X, $Z) === false){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| $this->chunkChange[$index][-1] = true; | |
| $this->chunkInfo[$index][2] = $nbt; | |
| } | |
| public function saveChunk($X, $Z, $force = false){ | |
| $X = (int) $X; | |
| $Z = (int) $Z; | |
| if(!$this->isChunkLoaded($X, $Z)){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| if($force !== true and (!isset($this->chunkChange[$index]) or $this->chunkChange[$index][-1] === false)){ //No changes in chunk | |
| return true; | |
| } | |
| $path = $this->getChunkPath($X, $Z); | |
| if(!file_exists(dirname($path))){ | |
| @mkdir(dirname($path), 0755); | |
| } | |
| $bitmap = 0; | |
| $this->cleanChunk($X, $Z); | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| if($this->chunks[$index][$Y] !== false and ((isset($this->chunkChange[$index][$Y]) and $this->chunkChange[$index][$Y] === 0) or !$this->isMiniChunkEmpty($X, $Z, $Y))){ | |
| $bitmap |= 1 << $Y; | |
| }else{ | |
| $this->chunks[$index][$Y] = false; | |
| } | |
| $this->chunkChange[$index][$Y] = 0; | |
| } | |
| $this->chunkInfo[$index][0] = $bitmap; | |
| $this->chunkChange[$index][-1] = false; | |
| $chunk = ""; | |
| $chunk .= chr($bitmap); | |
| $chunk .= Binary::writeInt($this->chunkInfo[$index][1]); | |
| $namedtag = new NBT(NBT::BIG_ENDIAN); | |
| $namedtag->setData($this->chunkInfo[$index][2]); | |
| $namedtag = $namedtag->write(); | |
| $chunk .= Binary::writeInt(strlen($namedtag)) . $namedtag; | |
| $chunk .= $this->chunkInfo[$index][3]; //biomes | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| $t = 1 << $Y; | |
| if(($bitmap & $t) === $t){ | |
| $chunk .= $this->chunks[$index][$Y]; | |
| } | |
| } | |
| file_put_contents($path, zlib_encode($chunk, self::ZLIB_ENCODING, self::ZLIB_LEVEL)); | |
| return true; | |
| } | |
| public function setPopulated($X, $Z){ | |
| if(!$this->isChunkLoaded($X, $Z)){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| $this->chunkInfo[$index][1] |= 0b00000000000000000000000000000001; | |
| } | |
| public function unsetPopulated($X, $Z){ | |
| if(!$this->isChunkLoaded($X, $Z)){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| $this->chunkInfo[$index][1] &= ~0b00000000000000000000000000000001; | |
| } | |
| public function isPopulated($X, $Z){ | |
| if(!$this->isChunkLoaded($X, $Z)){ | |
| return false; | |
| } | |
| $index = self::getIndex($X, $Z); | |
| return ($this->chunkInfo[$index][1] & 0b00000000000000000000000000000001) > 0; | |
| } | |
| public function isGenerated($X, $Z){ | |
| return file_exists($this->getChunkPath($X, $Z)); | |
| } | |
| public function doSaveRound($force = false){ | |
| foreach($this->chunks as $index => $chunk){ | |
| self::getXZ($index, $X, $Z); | |
| $this->saveChunk($X, $Z, $force); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * PMF (PocketMine Format) handling | |
| */ | |
| namespace pocketmine\level\format\pmf; | |
| class PMF{ | |
| const VERSION = 0x01; | |
| protected $fp; | |
| protected $file; | |
| private $version; | |
| private $type; | |
| public function __construct($file, $new = false, $type = 0, $version = PMF::VERSION){ | |
| if($new === true){ | |
| $this->create($file, $type, $version); | |
| }else{ | |
| if($this->load($file) !== true){ | |
| $this->parseInfo(); | |
| } | |
| } | |
| } | |
| public function getVersion(){ | |
| return $this->version; | |
| } | |
| public function getType(){ | |
| return $this->type; | |
| } | |
| public function load($file){ | |
| $this->close(); | |
| $this->file = $file; | |
| if(($this->fp = @fopen($file, "c+b")) !== false){ | |
| fseek($this->fp, 0, SEEK_END); | |
| if(ftell($this->fp) >= 5){ //Header + 2 Bytes | |
| @flock($this->fp, LOCK_EX); | |
| return true; | |
| } | |
| $this->close(); | |
| } | |
| return false; | |
| } | |
| public function parseInfo(){ | |
| $this->seek(0); | |
| if(fread($this->fp, 3) !== "PMF"){ | |
| return false; | |
| } | |
| $this->version = ord($this->read(1)); | |
| switch($this->version){ | |
| case 0x01: | |
| $this->type = ord($this->read(1)); | |
| break; | |
| default: | |
| console("[ERROR] Tried loading non-supported PMF version " . $this->version . " on file " . $this->file); | |
| return false; | |
| } | |
| return true; | |
| } | |
| public function getFile(){ | |
| return $this->file; | |
| } | |
| public function close(){ | |
| unset($this->version, $this->type, $this->file); | |
| if(is_object($this->fp)){ | |
| @flock($this->fp, LOCK_UN); | |
| fclose($this->fp); | |
| } | |
| } | |
| public function create($file, $type, $version = PMF::VERSION){ | |
| $this->file = $file; | |
| @mkdir(dirname($this->file), 0755, true); | |
| if(!is_resource($this->fp)){ | |
| if(($this->fp = @fopen($file, "c+b")) === false){ | |
| return false; | |
| } | |
| } | |
| $this->seek(0); | |
| $this->write("PMF" . chr((int) $version) . chr((int) $type)); | |
| return true; | |
| } | |
| public function read($length){ | |
| if($length <= 0){ | |
| return ""; | |
| } | |
| if(is_resource($this->fp)){ | |
| return fread($this->fp, (int) $length); | |
| } | |
| return false; | |
| } | |
| public function write($string, $length = false){ | |
| if(is_resource($this->fp)){ | |
| return ($length === false ? fwrite($this->fp, $string) : fwrite($this->fp, $string, $length)); | |
| } | |
| return false; | |
| } | |
| public function seek($offset, $whence = SEEK_SET){ | |
| if(is_resource($this->fp)){ | |
| return fseek($this->fp, (int) $offset, (int) $whence); | |
| } | |
| return false; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\format; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| /** | |
| * WARNING: This code is old, and only supports the file format partially (reverse engineering) | |
| * It can break, lock, or hit you in the face in any moment. | |
| * | |
| */ | |
| class PocketChunkParser{ | |
| private $location; | |
| private $raw = ""; | |
| private $file; | |
| public $sectorLength = 4096; //16 * 16 * 16 | |
| public $chunkLength = 86016; //21 * $sectorLength | |
| public $map = array(); | |
| public function __construct(){ | |
| } | |
| private function loadLocationTable(){ | |
| $this->location = array(); | |
| console("[DEBUG] Loading Chunk Location table...", true, true, 2); | |
| for($offset = 0; $offset < 0x1000; $offset += 4){ | |
| $data = Binary::readLInt(substr($this->raw, $offset, 4)); | |
| $sectors = $data & 0xff; | |
| if($sectors === 0){ | |
| continue; | |
| } | |
| $sectorLocation = $data >> 8; | |
| $this->location[$offset >> 2] = $sectorLocation * $this->sectorLength; //$this->getOffset($X, $Z, $sectors); | |
| } | |
| } | |
| public function loadFile($file){ | |
| if(file_exists($file . ".gz")){ | |
| $this->raw = gzinflate(file_get_contents($file . ".gz")); | |
| $r = @gzinflate($this->raw); | |
| if($r !== false and $r != ""){ | |
| $this->raw = $r; | |
| } | |
| @unlink($file . ".gz"); | |
| file_put_contents($file, $this->raw); | |
| }elseif(!file_exists($file)){ | |
| return false; | |
| }else{ | |
| $this->raw = file_get_contents($file); | |
| } | |
| $this->file = $file; | |
| $this->chunkLength = $this->sectorLength * ord($this->raw{0}); | |
| return true; | |
| } | |
| public function loadRaw($raw, $file){ | |
| $this->file = $file; | |
| $this->raw = $raw; | |
| $this->chunkLength = $this->sectorLength * ord($this->raw{0}); | |
| return true; | |
| } | |
| private function getOffset($X, $Z){ | |
| return $this->location[$X + ($Z << 5)]; | |
| } | |
| public function getChunk($X, $Z){ | |
| $X = (int) $X; | |
| $Z = (int) $Z; | |
| return substr($this->raw, $this->getOffset($X, $Z), $this->chunkLength); | |
| } | |
| public function writeChunk($X, $Z){ | |
| $X = (int) $X; | |
| $Z = (int) $Z; | |
| if(!isset($this->map[$X][$Z])){ | |
| return false; | |
| } | |
| $chunk = ""; | |
| foreach($this->map[$X][$Z] as $section => $data){ | |
| for($i = 0; $i < 256; ++$i){ | |
| $chunk .= $data[$i]; | |
| } | |
| } | |
| return Binary::writeLInt(strlen($chunk)) . $chunk; | |
| } | |
| public function parseChunk($X, $Z){ | |
| $X = (int) $X; | |
| $Z = (int) $Z; | |
| $offset = $this->getOffset($X, $Z); | |
| $len = Binary::readLInt(substr($this->raw, $offset, 4)); | |
| $offset += 4; | |
| $chunk = array( | |
| 0 => array(), //Block | |
| 1 => array(), //Data | |
| 2 => array(), //SkyLight | |
| 3 => array(), //BlockLight | |
| ); | |
| foreach($chunk as $section => &$data){ | |
| $l = $section === 0 ? 128 : 64; | |
| for($i = 0; $i < 256; ++$i){ | |
| $data[$i] = substr($this->raw, $offset, $l); | |
| $offset += $l; | |
| } | |
| } | |
| return $chunk; | |
| } | |
| public function loadMap(){ | |
| if($this->raw == ""){ | |
| return false; | |
| } | |
| $this->loadLocationTable(); | |
| console("[DEBUG] Loading chunks...", true, true, 2); | |
| for($x = 0; $x < 16; ++$x){ | |
| $this->map[$x] = array(); | |
| for($z = 0; $z < 16; ++$z){ | |
| $this->map[$x][$z] = $this->parseChunk($x, $z); | |
| } | |
| } | |
| $this->raw = ""; | |
| console("[DEBUG] Chunks loaded!", true, true, 2); | |
| return true; | |
| } | |
| public function saveMap($final = false){ | |
| console("[DEBUG] Saving chunks...", true, true, 2); | |
| $fp = fopen($this->file, "r+b"); | |
| flock($fp, LOCK_EX); | |
| foreach($this->map as $x => $d){ | |
| foreach($d as $z => $chunk){ | |
| fseek($fp, $this->getOffset($x, $z)); | |
| fwrite($fp, $this->writeChunk($x, $z), $this->chunkLength); | |
| } | |
| } | |
| flock($fp, LOCK_UN); | |
| fclose($fp); | |
| $original = filesize($this->file); | |
| file_put_contents($this->file . ".gz", gzdeflate(gzdeflate(file_get_contents($this->file), 9), 9)); //Double compression for flat maps | |
| $compressed = filesize($this->file . ".gz"); | |
| console("[DEBUG] Saved chunks.dat.gz with " . round(($compressed / $original) * 100, 2) . "% (" . round($compressed / 1024, 2) . "KB) of the original size", true, true, 2); | |
| if($final === true){ | |
| @unlink($this->file); | |
| } | |
| } | |
| public function getFloor($x, $z){ | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $index = $aZ + ($aX << 4); | |
| for($y = 127; $y <= 0; --$y){ | |
| if($this->map[$X][$Z][0][$index]{$y} !== "\x00"){ | |
| break; | |
| } | |
| } | |
| return $y; | |
| } | |
| public function getBlock($x, $y, $z){ | |
| $x = (int) $x; | |
| $y = (int) $y; | |
| $z = (int) $z; | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $index = $aZ + ($aX << 4); | |
| $block = ord($this->map[$X][$Z][0][$index]{$y}); | |
| $meta = ord($this->map[$X][$Z][1][$index]{$y >> 1}); | |
| if(($y & 1) === 0){ | |
| $meta = $meta & 0x0F; | |
| }else{ | |
| $meta = $meta >> 4; | |
| } | |
| return array($block, $meta); | |
| } | |
| public function getChunkColumn($X, $Z, $x, $z, $type = 0){ | |
| $index = $z + ($x << 4); | |
| return $this->map[$X][$Z][$type][$index]; | |
| } | |
| public function setBlock($x, $y, $z, $block, $meta = 0){ | |
| $x = (int) $x; | |
| $y = (int) $y; | |
| $z = (int) $z; | |
| $X = $x >> 4; | |
| $Z = $z >> 4; | |
| $aX = $x - ($X << 4); | |
| $aZ = $z - ($Z << 4); | |
| $index = $aZ + ($aX << 4); | |
| $this->map[$X][$Z][0][$index]{$y} = chr($block); | |
| $old_meta = ord($this->map[$X][$Z][1][$index]{$y >> 1}); | |
| if(($y & 1) === 0){ | |
| $meta = ($old_meta & 0xF0) | ($meta & 0x0F); | |
| }else{ | |
| $meta = (($meta << 4) & 0xF0) | ($old_meta & 0x0F); | |
| } | |
| $this->map[$X][$Z][1][$index]{$y >> 1} = chr($meta); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator; | |
| use pocketmine\block\Air; | |
| use pocketmine\block\CoalOre; | |
| use pocketmine\block\DiamondOre; | |
| use pocketmine\block\Dirt; | |
| use pocketmine\block\GoldOre; | |
| use pocketmine\block\Gravel; | |
| use pocketmine\block\IronOre; | |
| use pocketmine\block\LapisOre; | |
| use pocketmine\block\RedstoneOre; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\generator\populator\Ore; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class Flat extends Generator{ | |
| private $level, $random, $structure, $chunks, $options, $floorLevel, $preset, $populators = array(); | |
| public function getSettings(){ | |
| return $this->options; | |
| } | |
| public function getName(){ | |
| return "flat"; | |
| } | |
| public function __construct(array $options = array()){ | |
| $this->preset = "2;7,59x1,3x3,2;1;spawn(radius=10 block=89),decoration(treecount=80 grasscount=45)"; | |
| $this->options = $options; | |
| if(isset($options["preset"])){ | |
| $this->parsePreset($options["preset"]); | |
| }else{ | |
| $this->parsePreset($this->preset); | |
| } | |
| if(isset($this->options["decoration"])){ | |
| $ores = new Ore(); | |
| $ores->setOreTypes(array( | |
| new object\OreType(new CoalOre(), 20, 16, 0, 128), | |
| new object\OreType(New IronOre(), 20, 8, 0, 64), | |
| new object\OreType(new RedstoneOre(), 8, 7, 0, 16), | |
| new object\OreType(new LapisOre(), 1, 6, 0, 32), | |
| new object\OreType(new GoldOre(), 2, 8, 0, 32), | |
| new object\OreType(new DiamondOre(), 1, 7, 0, 16), | |
| new object\OreType(new Dirt(), 20, 32, 0, 128), | |
| new object\OreType(new Gravel(), 10, 16, 0, 128), | |
| )); | |
| $this->populators[] = $ores; | |
| } | |
| /*if(isset($this->options["mineshaft"])){ | |
| $this->populators[] = new MineshaftPopulator(isset($this->options["mineshaft"]["chance"]) ? floatval($this->options["mineshaft"]["chance"]) : 0.01); | |
| }*/ | |
| } | |
| public function parsePreset($preset){ | |
| $this->preset = $preset; | |
| $preset = explode(";", $preset); | |
| $version = (int) $preset[0]; | |
| $blocks = @$preset[1]; | |
| $biome = isset($preset[2]) ? $preset[2] : 1; | |
| $options = isset($preset[3]) ? $preset[3] : ""; | |
| preg_match_all('#(([0-9]{0,})x?([0-9]{1,3}:?[0-9]{0,2})),?#', $blocks, $matches); | |
| $y = 0; | |
| $this->structure = array(); | |
| $this->chunks = array(); | |
| foreach($matches[3] as $i => $b){ | |
| $b = Item::fromString($b); | |
| $cnt = $matches[2][$i] === "" ? 1 : intval($matches[2][$i]); | |
| for($cY = $y, $y += $cnt; $cY < $y; ++$cY){ | |
| $this->structure[$cY] = $b; | |
| } | |
| } | |
| $this->floorLevel = $y; | |
| for(; $y < 0xFF; ++$y){ | |
| $this->structure[$y] = new Air(); | |
| } | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| $this->chunks[$Y] = ""; | |
| $startY = $Y << 4; | |
| $endY = $startY + 16; | |
| for($Z = 0; $Z < 16; ++$Z){ | |
| for($X = 0; $X < 16; ++$X){ | |
| $blocks = ""; | |
| $metas = ""; | |
| for($y = $startY; $y < $endY; ++$y){ | |
| $blocks .= chr($this->structure[$y]->getID()); | |
| $metas .= substr(dechex($this->structure[$y]->getMetadata()), -1); | |
| } | |
| $this->chunks[$Y] .= $blocks . hex2bin($metas) . "\x00\x00\x00\x00\x00\x00\x00\x00"; | |
| } | |
| } | |
| } | |
| preg_match_all('#(([0-9a-z_]{1,})\(?([0-9a-z_ =:]{0,})\)?),?#', $options, $matches); | |
| foreach($matches[2] as $i => $option){ | |
| $params = true; | |
| if($matches[3][$i] !== ""){ | |
| $params = array(); | |
| $p = explode(" ", $matches[3][$i]); | |
| foreach($p as $k){ | |
| $k = explode("=", $k); | |
| if(isset($k[1])){ | |
| $params[$k[0]] = $k[1]; | |
| } | |
| } | |
| } | |
| $this->options[$option] = $params; | |
| } | |
| } | |
| public function init(Level $level, Random $random){ | |
| $this->level = $level; | |
| $this->random = $random; | |
| } | |
| public function generateChunk($chunkX, $chunkZ){ | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| $this->level->setMiniChunk($chunkX, $chunkZ, $Y, $this->chunks[$Y]); | |
| } | |
| } | |
| public function populateChunk($chunkX, $chunkZ){ | |
| $this->random->setSeed(0xdeadbeef ^ ($chunkX << 8) ^ $chunkZ ^ $this->level->getSeed()); | |
| foreach($this->populators as $populator){ | |
| $populator->populate($this->level, $chunkX, $chunkZ, $this->random); | |
| } | |
| } | |
| public function getSpawn(){ | |
| return new Vector3(128, $this->floorLevel, 128); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Generator classes used in Levels | |
| */ | |
| namespace pocketmine\level\generator; | |
| use pocketmine\level\Level; | |
| use pocketmine\utils\Random; | |
| abstract class Generator{ | |
| private static $list = array(); | |
| public static function addGenerator($object, $name){ | |
| if(is_subclass_of($object, "pocketmine\\level\\generator\\Generator") and !isset(Generator::$list[$name])){ | |
| Generator::$list[$name] = $object; | |
| return true; | |
| } | |
| return false; | |
| } | |
| public static function getGenerator($name){ | |
| if(isset(Generator::$list[$name])){ | |
| return Generator::$list[$name]; | |
| } | |
| return "pocketmine\\level\\generator\\Normal"; | |
| } | |
| public abstract function __construct(array $settings = array()); | |
| public abstract function init(Level $level, Random $random); | |
| public abstract function generateChunk($chunkX, $chunkZ); | |
| public abstract function populateChunk($chunkX, $chunkZ); | |
| public abstract function getSettings(); | |
| public abstract function getName(); | |
| public abstract function getSpawn(); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Different noise generators for level generation | |
| * | |
| * WARNING: This class is available on the PocketMine-MP Zephir project. | |
| * If this class is modified, remember to modify the PHP C extension. | |
| */ | |
| namespace pocketmine\level\generator\noise; | |
| abstract class Generator{ | |
| protected $perm = array(); | |
| protected $offsetX = 0; | |
| protected $offsetY = 0; | |
| protected $offsetZ = 0; | |
| protected $octaves = 8; | |
| protected $frequency; | |
| protected $amplitude; | |
| public static function floor($x){ | |
| return $x >= 0 ? (int) $x : (int) ($x - 1); | |
| } | |
| public static function fade($x){ | |
| return $x * $x * $x * ($x * ($x * 6 - 15) + 10); | |
| } | |
| public static function lerp($x, $y, $z){ | |
| return $y + $x * ($z - $y); | |
| } | |
| public static function grad($hash, $x, $y, $z){ | |
| $hash &= 15; | |
| $u = $hash < 8 ? $x : $y; | |
| $v = $hash < 4 ? $y : (($hash === 12 or $hash === 14) ? $x : $z); | |
| return (($hash & 1) === 0 ? $u : -$u) + (($hash & 2) === 0 ? $v : -$v); | |
| } | |
| abstract public function getNoise2D($x, $z); | |
| abstract public function getNoise3D($x, $y, $z); | |
| public function noise2D($x, $z, $normalized = false){ | |
| $result = 0; | |
| $amp = 1; | |
| $freq = 1; | |
| $max = 0; | |
| for($i = 0; $i < $this->octaves; ++$i){ | |
| $result += $this->getNoise2D($x * $freq, $z * $freq) * $amp; | |
| $max += $amp; | |
| $freq *= $this->frequency; | |
| $amp *= $this->amplitude; | |
| } | |
| if($normalized === true){ | |
| $result /= $max; | |
| } | |
| return $result; | |
| } | |
| public function noise3D($x, $y, $z, $normalized = false){ | |
| $result = 0; | |
| $amp = 1; | |
| $freq = 1; | |
| $max = 0; | |
| for($i = 0; $i < $this->octaves; ++$i){ | |
| $result += $this->getNoise3D($x * $freq, $y * $freq, $z * $freq) * $amp; | |
| $max += $amp; | |
| $freq *= $this->frequency; | |
| $amp *= $this->amplitude; | |
| } | |
| if($normalized === true){ | |
| $result /= $max; | |
| } | |
| return $result; | |
| } | |
| public function setOffset($x, $y, $z){ | |
| $this->offsetX = $x; | |
| $this->offsetY = $y; | |
| $this->offsetZ = $z; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\noise; | |
| use pocketmine\utils\Random; | |
| class Perlin extends Generator{ | |
| public static $grad3 = [ | |
| [1, 1, 0], [-1, 1, 0], [1, -1, 0], [-1, -1, 0], | |
| [1, 0, 1], [-1, 0, 1], [1, 0, -1], [-1, 0, -1], | |
| [0, 1, 1], [0, -1, 1], [0, 1, -1], [0, -1, -1] | |
| ]; | |
| public function __construct(Random $random, $octaves, $frequency, $amplitude){ | |
| $this->octaves = $octaves; | |
| $this->frequency = $frequency; | |
| $this->amplitude = $amplitude; | |
| $this->offsetX = $random->nextFloat() * 256; | |
| $this->offsetY = $random->nextFloat() * 256; | |
| $this->offsetZ = $random->nextFloat() * 256; | |
| for($i = 0; $i < 512; ++$i){ | |
| $this->perm[$i] = 0; | |
| } | |
| for($i = 0; $i < 256; ++$i){ | |
| $this->perm[$i] = $random->nextRange(0, 255); | |
| } | |
| for($i = 0; $i < 256; ++$i){ | |
| $pos = $random->nextRange(0, 255 - $i) + $i; | |
| $old = $this->perm[$i]; | |
| $this->perm[$i] = $this->perm[$pos]; | |
| $this->perm[$pos] = $old; | |
| $this->perm[$i + 256] = $this->perm[$i]; | |
| } | |
| } | |
| public function getNoise3D($x, $y, $z){ | |
| $x += $this->offsetX; | |
| $y += $this->offsetY; | |
| $z += $this->offsetZ; | |
| $floorX = (int) floor($x); | |
| $floorY = (int) floor($y); | |
| $floorZ = (int) floor($z); | |
| $X = $floorX & 0xFF; | |
| $Y = $floorY & 0xFF; | |
| $Z = $floorZ & 0xFF; | |
| $x -= $floorX; | |
| $y -= $floorY; | |
| $z -= $floorZ; | |
| //Fade curves | |
| $fX = self::fade($x); | |
| $fY = self::fade($y); | |
| $fZ = self::fade($z); | |
| //Cube corners | |
| $A = $this->perm[$X] + $Y; | |
| $AA = $this->perm[$A] + $Z; | |
| $AB = $this->perm[$A + 1] + $Z; | |
| $B = $this->perm[$X + 1] + $Y; | |
| $BA = $this->perm[$B] + $Z; | |
| $BB = $this->perm[$B + 1] + $Z; | |
| return self::lerp($fZ, self::lerp($fY, self::lerp($fX, self::grad($this->perm[$AA], $x, $y, $z), | |
| self::grad($this->perm[$BA], $x - 1, $y, $z)), | |
| self::lerp($fX, self::grad($this->perm[$AB], $x, $y - 1, $z), | |
| self::grad($this->perm[$BB], $x - 1, $y - 1, $z))), | |
| self::lerp($fY, self::lerp($fX, self::grad($this->perm[$AA + 1], $x, $y, $z - 1), | |
| self::grad($this->perm[$BA + 1], $x - 1, $y, $z - 1)), | |
| self::lerp($fX, self::grad($this->perm[$AB + 1], $x, $y - 1, $z - 1), | |
| self::grad($this->perm[$BB + 1], $x - 1, $y - 1, $z - 1)))); | |
| } | |
| public function getNoise2D($x, $y){ | |
| return $this->getNoise3D($x, $y, 0); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\noise; | |
| use pocketmine\utils\Random; | |
| /** | |
| * Generates simplex-based noise. | |
| * <p> | |
| * This is a modified version of the freely published version in the paper by | |
| * Stefan Gustavson at | |
| * <a href="http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf"> | |
| * http://staffwww.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf</a> | |
| */ | |
| class Simplex extends Perlin{ | |
| protected static $SQRT_3; | |
| protected static $SQRT_5; | |
| protected static $F2; | |
| protected static $G2; | |
| protected static $G22; | |
| protected static $F3; | |
| protected static $G3; | |
| protected static $F4; | |
| protected static $G4; | |
| protected static $G42; | |
| protected static $G43; | |
| protected static $G44; | |
| protected static $grad4 = [[0, 1, 1, 1], [0, 1, 1, -1], [0, 1, -1, 1], [0, 1, -1, -1], | |
| [0, -1, 1, 1], [0, -1, 1, -1], [0, -1, -1, 1], [0, -1, -1, -1], | |
| [1, 0, 1, 1], [1, 0, 1, -1], [1, 0, -1, 1], [1, 0, -1, -1], | |
| [-1, 0, 1, 1], [-1, 0, 1, -1], [-1, 0, -1, 1], [-1, 0, -1, -1], | |
| [1, 1, 0, 1], [1, 1, 0, -1], [1, -1, 0, 1], [1, -1, 0, -1], | |
| [-1, 1, 0, 1], [-1, 1, 0, -1], [-1, -1, 0, 1], [-1, -1, 0, -1], | |
| [1, 1, 1, 0], [1, 1, -1, 0], [1, -1, 1, 0], [1, -1, -1, 0], | |
| [-1, 1, 1, 0], [-1, 1, -1, 0], [-1, -1, 1, 0], [-1, -1, -1, 0]]; | |
| protected static $simplex = [ | |
| [0, 1, 2, 3], [0, 1, 3, 2], [0, 0, 0, 0], [0, 2, 3, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 2, 3, 0], | |
| [0, 2, 1, 3], [0, 0, 0, 0], [0, 3, 1, 2], [0, 3, 2, 1], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 3, 2, 0], | |
| [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], | |
| [1, 2, 0, 3], [0, 0, 0, 0], [1, 3, 0, 2], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [2, 3, 0, 1], [2, 3, 1, 0], | |
| [1, 0, 2, 3], [1, 0, 3, 2], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [2, 0, 3, 1], [0, 0, 0, 0], [2, 1, 3, 0], | |
| [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], | |
| [2, 0, 1, 3], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [3, 0, 1, 2], [3, 0, 2, 1], [0, 0, 0, 0], [3, 1, 2, 0], | |
| [2, 1, 0, 3], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [3, 1, 0, 2], [0, 0, 0, 0], [3, 2, 0, 1], [3, 2, 1, 0]]; | |
| protected $offsetW; | |
| public function __construct(Random $random, $octaves, $frequency, $amplitude){ | |
| parent::__construct($random, $octaves, $frequency, $amplitude); | |
| $this->offsetW = $random->nextFloat() * 256; | |
| self::$SQRT_3 = sqrt(3); | |
| self::$SQRT_5 = sqrt(5); | |
| self::$F2 = 0.5 * (self::$SQRT_3 - 1); | |
| self::$G2 = (3 - self::$SQRT_3) / 6; | |
| self::$G22 = self::$G2 * 2.0 - 1; | |
| self::$F3 = 1.0 / 3.0; | |
| self::$G3 = 1.0 / 6.0; | |
| self::$F4 = (self::$SQRT_5 - 1.0) / 4.0; | |
| self::$G4 = (5.0 - self::$SQRT_5) / 20.0; | |
| self::$G42 = self::$G4 * 2.0; | |
| self::$G43 = self::$G4 * 3.0; | |
| self::$G44 = self::$G4 * 4.0 - 1.0; | |
| } | |
| protected static function dot2D($g, $x, $y){ | |
| return $g[0] * $x + $g[1] * $y; | |
| } | |
| protected static function dot3D($g, $x, $y, $z){ | |
| return $g[0] * $x + $g[1] * $y + $g[2] * $z; | |
| } | |
| protected static function dot4D($g, $x, $y, $z, $w){ | |
| return $g[0] * $x + $g[1] * $y + $g[2] * $z + $g[3] * $w; | |
| } | |
| public function getNoise3D($x, $y, $z){ | |
| $x += $this->offsetX; | |
| $y += $this->offsetY; | |
| $z += $this->offsetZ; | |
| // Skew the input space to determine which simplex cell we're in | |
| $s = ($x + $y + $z) * self::$F3; // Very nice and simple skew factor for 3D | |
| $i = (int) floor($x + $s); | |
| $j = (int) floor($y + $s); | |
| $k = (int) floor($z + $s); | |
| $t = ($i + $j + $k) * self::$G3; | |
| $X0 = $i - $t; // Unskew the cell origin back to (x,y,z) space | |
| $Y0 = $j - $t; | |
| $Z0 = $k - $t; | |
| $x0 = $x - $X0; // The x,y,z distances from the cell origin | |
| $y0 = $y - $Y0; | |
| $z0 = $z - $Z0; | |
| // For the 3D case, the simplex shape is a slightly irregular tetrahedron. | |
| // Determine which simplex we are in. | |
| if($x0 >= $y0){ | |
| if($y0 >= $z0){ | |
| $i1 = 1; | |
| $j1 = 0; | |
| $k1 = 0; | |
| $i2 = 1; | |
| $j2 = 1; | |
| $k2 = 0; | |
| } // X Y Z order | |
| elseif($x0 >= $z0){ | |
| $i1 = 1; | |
| $j1 = 0; | |
| $k1 = 0; | |
| $i2 = 1; | |
| $j2 = 0; | |
| $k2 = 1; | |
| } // X Z Y order | |
| else{ | |
| $i1 = 0; | |
| $j1 = 0; | |
| $k1 = 1; | |
| $i2 = 1; | |
| $j2 = 0; | |
| $k2 = 1; | |
| } | |
| // Z X Y order | |
| }else{ // x0<y0 | |
| if($y0 < $z0){ | |
| $i1 = 0; | |
| $j1 = 0; | |
| $k1 = 1; | |
| $i2 = 0; | |
| $j2 = 1; | |
| $k2 = 1; | |
| } // Z Y X order | |
| elseif($x0 < $z0){ | |
| $i1 = 0; | |
| $j1 = 1; | |
| $k1 = 0; | |
| $i2 = 0; | |
| $j2 = 1; | |
| $k2 = 1; | |
| } // Y Z X order | |
| else{ | |
| $i1 = 0; | |
| $j1 = 1; | |
| $k1 = 0; | |
| $i2 = 1; | |
| $j2 = 1; | |
| $k2 = 0; | |
| } | |
| // Y X Z order | |
| } | |
| // A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z), | |
| // a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and | |
| // a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where | |
| // c = 1/6. | |
| $x1 = $x0 - $i1 + self::$G3; // Offsets for second corner in (x,y,z) coords | |
| $y1 = $y0 - $j1 + self::$G3; | |
| $z1 = $z0 - $k1 + self::$G3; | |
| $x2 = $x0 - $i2 + 2.0 * self::$G3; // Offsets for third corner in (x,y,z) coords | |
| $y2 = $y0 - $j2 + 2.0 * self::$G3; | |
| $z2 = $z0 - $k2 + 2.0 * self::$G3; | |
| $x3 = $x0 - 1.0 + 3.0 * self::$G3; // Offsets for last corner in (x,y,z) coords | |
| $y3 = $y0 - 1.0 + 3.0 * self::$G3; | |
| $z3 = $z0 - 1.0 + 3.0 * self::$G3; | |
| // Work out the hashed gradient indices of the four simplex corners | |
| $ii = $i & 255; | |
| $jj = $j & 255; | |
| $kk = $k & 255; | |
| $gi0 = $this->perm[$ii + $this->perm[$jj + $this->perm[$kk]]] % 12; | |
| $gi1 = $this->perm[$ii + $i1 + $this->perm[$jj + $j1 + $this->perm[$kk + $k1]]] % 12; | |
| $gi2 = $this->perm[$ii + $i2 + $this->perm[$jj + $j2 + $this->perm[$kk + $k2]]] % 12; | |
| $gi3 = $this->perm[$ii + 1 + $this->perm[$jj + 1 + $this->perm[$kk + 1]]] % 12; | |
| // Calculate the contribution from the four corners | |
| $t0 = 0.6 - $x0 * $x0 - $y0 * $y0 - $z0 * $z0; | |
| if($t0 < 0){ | |
| $n0 = 0.0; | |
| }else{ | |
| $t0 *= $t0; | |
| $n0 = $t0 * $t0 * self::dot3D(self::$grad3[$gi0], $x0, $y0, $z0); | |
| } | |
| $t1 = 0.6 - $x1 * $x1 - $y1 * $y1 - $z1 * $z1; | |
| if($t1 < 0){ | |
| $n1 = 0.0; | |
| }else{ | |
| $t1 *= $t1; | |
| $n1 = $t1 * $t1 * self::dot3D(self::$grad3[$gi1], $x1, $y1, $z1); | |
| } | |
| $t2 = 0.6 - $x2 * $x2 - $y2 * $y2 - $z2 * $z2; | |
| if($t2 < 0){ | |
| $n2 = 0.0; | |
| }else{ | |
| $t2 *= $t2; | |
| $n2 = $t2 * $t2 * self::dot3D(self::$grad3[$gi2], $x2, $y2, $z2); | |
| } | |
| $t3 = 0.6 - $x3 * $x3 - $y3 * $y3 - $z3 * $z3; | |
| if($t3 < 0){ | |
| $n3 = 0.0; | |
| }else{ | |
| $t3 *= $t3; | |
| $n3 = $t3 * $t3 * self::dot3D(self::$grad3[$gi3], $x3, $y3, $z3); | |
| } | |
| // Add contributions from each corner to get the noise value. | |
| // The result is scaled to stay just inside [-1,1] | |
| return 32.0 * ($n0 + $n1 + $n2 + $n3); | |
| } | |
| public function getNoise2D($x, $y){ | |
| $x += $this->offsetX; | |
| $y += $this->offsetY; | |
| // Skew the input space to determine which simplex cell we're in | |
| $s = ($x + $y) * self::$F2; // Hairy factor for 2D | |
| $i = (int) floor($x + $s); | |
| $j = (int) floor($y + $s); | |
| $t = ($i + $j) * self::$G2; | |
| $X0 = $i - $t; // Unskew the cell origin back to (x,y) space | |
| $Y0 = $j - $t; | |
| $x0 = $x - $X0; // The x,y distances from the cell origin | |
| $y0 = $y - $Y0; | |
| // For the 2D case, the simplex shape is an equilateral triangle. | |
| // Determine which simplex we are in. | |
| if($x0 > $y0){ | |
| $i1 = 1; | |
| $j1 = 0; | |
| } // lower triangle, XY order: (0,0)->(1,0)->(1,1) | |
| else{ | |
| $i1 = 0; | |
| $j1 = 1; | |
| } | |
| // upper triangle, YX order: (0,0)->(0,1)->(1,1) | |
| // A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and | |
| // a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where | |
| // c = (3-sqrt(3))/6 | |
| $x1 = $x0 - $i1 + self::$G2; // Offsets for middle corner in (x,y) unskewed coords | |
| $y1 = $y0 - $j1 + self::$G2; | |
| $x2 = $x0 + self::$G22; // Offsets for last corner in (x,y) unskewed coords | |
| $y2 = $y0 + self::$G22; | |
| // Work out the hashed gradient indices of the three simplex corners | |
| $ii = $i & 255; | |
| $jj = $j & 255; | |
| $gi0 = $this->perm[$ii + $this->perm[$jj]] % 12; | |
| $gi1 = $this->perm[$ii + $i1 + $this->perm[$jj + $j1]] % 12; | |
| $gi2 = $this->perm[$ii + 1 + $this->perm[$jj + 1]] % 12; | |
| // Calculate the contribution from the three corners | |
| $t0 = 0.5 - $x0 * $x0 - $y0 * $y0; | |
| if($t0 < 0){ | |
| $n0 = 0.0; | |
| }else{ | |
| $t0 *= $t0; | |
| $n0 = $t0 * $t0 * self::dot2D(self::$grad3[$gi0], $x0, $y0); // (x,y) of grad3 used for 2D gradient | |
| } | |
| $t1 = 0.5 - $x1 * $x1 - $y1 * $y1; | |
| if($t1 < 0){ | |
| $n1 = 0.0; | |
| }else{ | |
| $t1 *= $t1; | |
| $n1 = $t1 * $t1 * self::dot2D(self::$grad3[$gi1], $x1, $y1); | |
| } | |
| $t2 = 0.5 - $x2 * $x2 - $y2 * $y2; | |
| if($t2 < 0){ | |
| $n2 = 0.0; | |
| }else{ | |
| $t2 *= $t2; | |
| $n2 = $t2 * $t2 * self::dot2D(self::$grad3[$gi2], $x2, $y2); | |
| } | |
| // Add contributions from each corner to get the noise value. | |
| // The result is scaled to return values in the interval [-1,1]. | |
| return 70.0 * ($n0 + $n1 + $n2); | |
| } | |
| /** | |
| * Computes and returns the 4D simplex noise for the given coordinates in | |
| * 4D space | |
| * | |
| * @param float $x X coordinate | |
| * @param float $y Y coordinate | |
| * @param float $z Z coordinate | |
| * @param float $w W coordinate | |
| * | |
| * @return float Noise at given location, from range -1 to 1 | |
| */ | |
| /*public function getNoise4D($x, $y, $z, $w){ | |
| x += offsetX; | |
| y += offsetY; | |
| z += offsetZ; | |
| w += offsetW; | |
| n0, n1, n2, n3, n4; // Noise contributions from the five corners | |
| // Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in | |
| s = (x + y + z + w) * self::$F4; // Factor for 4D skewing | |
| i = floor(x + s); | |
| j = floor(y + s); | |
| k = floor(z + s); | |
| l = floor(w + s); | |
| t = (i + j + k + l) * self::$G4; // Factor for 4D unskewing | |
| X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space | |
| Y0 = j - t; | |
| Z0 = k - t; | |
| W0 = l - t; | |
| x0 = x - X0; // The x,y,z,w distances from the cell origin | |
| y0 = y - Y0; | |
| z0 = z - Z0; | |
| w0 = w - W0; | |
| // For the 4D case, the simplex is a 4D shape I won't even try to describe. | |
| // To find out which of the 24 possible simplices we're in, we need to | |
| // determine the magnitude ordering of x0, y0, z0 and w0. | |
| // The method below is a good way of finding the ordering of x,y,z,w and | |
| // then find the correct traversal order for the simplex we’re in. | |
| // First, six pair-wise comparisons are performed between each possible pair | |
| // of the four coordinates, and the results are used to add up binary bits | |
| // for an integer index. | |
| c1 = (x0 > y0) ? 32 : 0; | |
| c2 = (x0 > z0) ? 16 : 0; | |
| c3 = (y0 > z0) ? 8 : 0; | |
| c4 = (x0 > w0) ? 4 : 0; | |
| c5 = (y0 > w0) ? 2 : 0; | |
| c6 = (z0 > w0) ? 1 : 0; | |
| c = c1 + c2 + c3 + c4 + c5 + c6; | |
| i1, j1, k1, l1; // The integer offsets for the second simplex corner | |
| i2, j2, k2, l2; // The integer offsets for the third simplex corner | |
| i3, j3, k3, l3; // The integer offsets for the fourth simplex corner | |
| // simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order. | |
| // Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w | |
| // impossible. Only the 24 indices which have non-zero entries make any sense. | |
| // We use a thresholding to set the coordinates in turn from the largest magnitude. | |
| // The number 3 in the "simplex" array is at the position of the largest coordinate. | |
| i1 = simplex[c][0] >= 3 ? 1 : 0; | |
| j1 = simplex[c][1] >= 3 ? 1 : 0; | |
| k1 = simplex[c][2] >= 3 ? 1 : 0; | |
| l1 = simplex[c][3] >= 3 ? 1 : 0; | |
| // The number 2 in the "simplex" array is at the second largest coordinate. | |
| i2 = simplex[c][0] >= 2 ? 1 : 0; | |
| j2 = simplex[c][1] >= 2 ? 1 : 0; | |
| k2 = simplex[c][2] >= 2 ? 1 : 0; | |
| l2 = simplex[c][3] >= 2 ? 1 : 0; | |
| // The number 1 in the "simplex" array is at the second smallest coordinate. | |
| i3 = simplex[c][0] >= 1 ? 1 : 0; | |
| j3 = simplex[c][1] >= 1 ? 1 : 0; | |
| k3 = simplex[c][2] >= 1 ? 1 : 0; | |
| l3 = simplex[c][3] >= 1 ? 1 : 0; | |
| // The fifth corner has all coordinate offsets = 1, so no need to look that up. | |
| x1 = x0 - i1 + self::$G4; // Offsets for second corner in (x,y,z,w) coords | |
| y1 = y0 - j1 + self::$G4; | |
| z1 = z0 - k1 + self::$G4; | |
| w1 = w0 - l1 + self::$G4; | |
| x2 = x0 - i2 + self::$G42; // Offsets for third corner in (x,y,z,w) coords | |
| y2 = y0 - j2 + self::$G42; | |
| z2 = z0 - k2 + self::$G42; | |
| w2 = w0 - l2 + self::$G42; | |
| x3 = x0 - i3 + self::$G43; // Offsets for fourth corner in (x,y,z,w) coords | |
| y3 = y0 - j3 + self::$G43; | |
| z3 = z0 - k3 + self::$G43; | |
| w3 = w0 - l3 + self::$G43; | |
| x4 = x0 + self::$G44; // Offsets for last corner in (x,y,z,w) coords | |
| y4 = y0 + self::$G44; | |
| z4 = z0 + self::$G44; | |
| w4 = w0 + self::$G44; | |
| // Work out the hashed gradient indices of the five simplex corners | |
| ii = i & 255; | |
| jj = j & 255; | |
| kk = k & 255; | |
| ll = l & 255; | |
| gi0 = $this->perm[ii + $this->perm[jj + $this->perm[kk + $this->perm[ll]]]] % 32; | |
| gi1 = $this->perm[ii + i1 + $this->perm[jj + j1 + $this->perm[kk + k1 + $this->perm[ll + l1]]]] % 32; | |
| gi2 = $this->perm[ii + i2 + $this->perm[jj + j2 + $this->perm[kk + k2 + $this->perm[ll + l2]]]] % 32; | |
| gi3 = $this->perm[ii + i3 + $this->perm[jj + j3 + $this->perm[kk + k3 + $this->perm[ll + l3]]]] % 32; | |
| gi4 = $this->perm[ii + 1 + $this->perm[jj + 1 + $this->perm[kk + 1 + $this->perm[ll + 1]]]] % 32; | |
| // Calculate the contribution from the five corners | |
| t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0 - w0 * w0; | |
| if(t0 < 0){ | |
| n0 = 0.0; | |
| }else{ | |
| t0 *= t0; | |
| n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0); | |
| } | |
| t1 = 0.6 - x1 * x1 - y1 * y1 - z1 * z1 - w1 * w1; | |
| if(t1 < 0){ | |
| n1 = 0.0; | |
| }else{ | |
| t1 *= t1; | |
| n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1); | |
| } | |
| t2 = 0.6 - x2 * x2 - y2 * y2 - z2 * z2 - w2 * w2; | |
| if(t2 < 0){ | |
| n2 = 0.0; | |
| }else{ | |
| t2 *= t2; | |
| n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2); | |
| } | |
| t3 = 0.6 - x3 * x3 - y3 * y3 - z3 * z3 - w3 * w3; | |
| if(t3 < 0){ | |
| n3 = 0.0; | |
| }else{ | |
| t3 *= t3; | |
| n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3); | |
| } | |
| t4 = 0.6 - x4 * x4 - y4 * y4 - z4 * z4 - w4 * w4; | |
| if(t4 < 0){ | |
| n4 = 0.0; | |
| }else{ | |
| t4 *= t4; | |
| n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4); | |
| } | |
| // Sum up and scale the result to cover the range [-1,1] | |
| return 27.0 * (n0 + n1 + n2 + n3 + n4); | |
| }*/ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator; | |
| use pocketmine\block\CoalOre; | |
| use pocketmine\block\DiamondOre; | |
| use pocketmine\block\Dirt; | |
| use pocketmine\block\GoldOre; | |
| use pocketmine\block\Gravel; | |
| use pocketmine\block\IronOre; | |
| use pocketmine\block\LapisOre; | |
| use pocketmine\block\RedstoneOre; | |
| use pocketmine\level\generator\noise\Simplex; | |
| use pocketmine\level\generator\object\OreType; | |
| use pocketmine\level\generator\populator\Ore; | |
| use pocketmine\level\generator\populator\TallGrass; | |
| use pocketmine\level\generator\populator\Tree; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class Normal extends Generator{ | |
| private $populators = array(); | |
| private $level; | |
| private $random; | |
| private $worldHeight = 65; | |
| private $waterHeight = 63; | |
| private $noiseHills; | |
| private $noisePatches; | |
| private $noisePatchesSmall; | |
| private $noiseBase; | |
| public function __construct(array $options = array()){ | |
| } | |
| public function getName(){ | |
| return "normal"; | |
| } | |
| public function getSettings(){ | |
| return array(); | |
| } | |
| public function init(Level $level, Random $random){ | |
| $this->level = $level; | |
| $this->random = $random; | |
| $this->random->setSeed($this->level->getSeed()); | |
| $this->noiseHills = new Simplex($this->random, 3, 0.11, 12); | |
| $this->noisePatches = new Simplex($this->random, 2, 0.03, 16); | |
| $this->noisePatchesSmall = new Simplex($this->random, 2, 0.5, 4); | |
| $this->noiseBase = new Simplex($this->random, 16, 0.7, 16); | |
| $ores = new Ore(); | |
| $ores->setOreTypes(array( | |
| new OreType(new CoalOre(), 20, 16, 0, 128), | |
| new OreType(New IronOre(), 20, 8, 0, 64), | |
| new OreType(new RedstoneOre(), 8, 7, 0, 16), | |
| new OreType(new LapisOre(), 1, 6, 0, 32), | |
| new OreType(new GoldOre(), 2, 8, 0, 32), | |
| new OreType(new DiamondOre(), 1, 7, 0, 16), | |
| new OreType(new Dirt(), 20, 32, 0, 128), | |
| new OreType(new Gravel(), 10, 16, 0, 128), | |
| )); | |
| $this->populators[] = $ores; | |
| $trees = new Tree(); | |
| $trees->setBaseAmount(3); | |
| $trees->setRandomAmount(0); | |
| $this->populators[] = $trees; | |
| $tallGrass = new TallGrass(); | |
| $tallGrass->setBaseAmount(5); | |
| $tallGrass->setRandomAmount(0); | |
| $this->populators[] = $tallGrass; | |
| } | |
| public function generateChunk($chunkX, $chunkZ){ | |
| $this->random->setSeed(0xdeadbeef ^ ($chunkX << 8) ^ $chunkZ ^ $this->level->getSeed()); | |
| $hills = array(); | |
| $patches = array(); | |
| $patchesSmall = array(); | |
| $base = array(); | |
| for($z = 0; $z < 16; ++$z){ | |
| for($x = 0; $x < 16; ++$x){ | |
| $i = ($z << 4) + $x; | |
| $hills[$i] = $this->noiseHills->noise2D($x + ($chunkX << 4), $z + ($chunkZ << 4), true); | |
| $patches[$i] = $this->noisePatches->noise2D($x + ($chunkX << 4), $z + ($chunkZ << 4), true); | |
| $patchesSmall[$i] = $this->noisePatchesSmall->noise2D($x + ($chunkX << 4), $z + ($chunkZ << 4), true); | |
| $base[$i] = $this->noiseBase->noise2D($x + ($chunkX << 4), $z + ($chunkZ << 4), true); | |
| if($base[$i] < 0){ | |
| $base[$i] *= 0.5; | |
| } | |
| } | |
| } | |
| for($chunkY = 0; $chunkY < 8; ++$chunkY){ | |
| $chunk = ""; | |
| $startY = $chunkY << 4; | |
| $endY = $startY + 16; | |
| for($z = 0; $z < 16; ++$z){ | |
| for($x = 0; $x < 16; ++$x){ | |
| $i = ($z << 4) + $x; | |
| $height = $this->worldHeight + $hills[$i] * 14 + $base[$i] * 7; | |
| $height = (int) $height; | |
| for($y = $startY; $y < $endY; ++$y){ | |
| $diff = $height - $y; | |
| if($y <= 4 and ($y === 0 or $this->random->nextFloat() < 0.75)){ | |
| $chunk .= "\x07"; //bedrock | |
| }elseif($diff > 2){ | |
| $chunk .= "\x01"; //stone | |
| }elseif($diff > 0){ | |
| if($patches[$i] > 0.7){ | |
| $chunk .= "\x01"; //stone | |
| }elseif($patches[$i] < -0.8){ | |
| $chunk .= "\x0d"; //gravel | |
| }else{ | |
| $chunk .= "\x03"; //dirt | |
| } | |
| }elseif($y <= $this->waterHeight){ | |
| if(($this->waterHeight - $y) <= 1 and $diff === 0){ | |
| $chunk .= "\x0c"; //sand | |
| }elseif($diff === 0){ | |
| if($patchesSmall[$i] > 0.3){ | |
| $chunk .= "\x0d"; //gravel | |
| }elseif($patchesSmall[$i] < -0.45){ | |
| $chunk .= "\x0c"; //sand | |
| }else{ | |
| $chunk .= "\x03"; //dirt | |
| } | |
| }else{ | |
| $chunk .= "\x09"; //still_water | |
| } | |
| }elseif($diff === 0){ | |
| if($patches[$i] > 0.7){ | |
| $chunk .= "\x01"; //stone | |
| }elseif($patches[$i] < -0.8){ | |
| $chunk .= "\x0d"; //gravel | |
| }else{ | |
| $chunk .= "\x02"; //grass | |
| } | |
| }else{ | |
| $chunk .= "\x00"; | |
| } | |
| } | |
| $chunk .= "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; | |
| } | |
| } | |
| $this->level->setMiniChunk($chunkX, $chunkZ, $chunkY, $chunk); | |
| } | |
| } | |
| public function populateChunk($chunkX, $chunkZ){ | |
| $this->random->setSeed(0xdeadbeef ^ ($chunkX << 8) ^ $chunkZ ^ $this->level->getSeed()); | |
| foreach($this->populators as $populator){ | |
| $this->random->setSeed(0xdeadbeef ^ ($chunkX << 8) ^ $chunkZ ^ $this->level->getSeed()); | |
| $populator->populate($this->level, $chunkX, $chunkZ, $this->random); | |
| } | |
| } | |
| public function getSpawn(){ | |
| return $this->level->getSafeSpawn(new Vector3(127.5, 128, 127.5)); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| class BigTree extends Tree{ | |
| private $trunkHeightMultiplier = 0.618; | |
| private $trunkHeight; | |
| private $leafAmount = 1; | |
| private $leafDistanceLimit = 5; | |
| private $widthScale = 1; | |
| private $branchSlope = 0.381; | |
| private $totalHeight = 6; | |
| private $leavesHeight = 3; | |
| protected $radiusIncrease = 0; | |
| private $addLeavesVines = false; | |
| private $addLogVines = false; | |
| private $addCocoaPlants = false; | |
| public function canPlaceObject(Level $level, Vector3 $pos){ | |
| return false; | |
| } | |
| public function placeObject(Level $level, Vector3 $pos, $type){ | |
| $this->trunkHeight = (int) ($this->totalHeight * $this->trunkHeightMultiplier); | |
| $leaves = $this->getLeafGroupPoints($level, $pos); | |
| foreach($leaves as $leafGroup){ | |
| $groupX = $leafGroup->getBlockX(); | |
| $groupY = $leafGroup->getBlockY(); | |
| $groupZ = $leafGroup->getBlockZ(); | |
| for($yy = $groupY; $yy < $groupY + $this->leafDistanceLimit; ++$yy){ | |
| $this->generateGroupLayer($level, $groupX, $yy, $groupZ, $this->getLeafGroupLayerSize($yy - $groupY)); | |
| } | |
| } | |
| /*final BlockIterator trunk = new BlockIterator(new Point(w, x, y - 1, z), new Point(w, x, y + trunkHeight, z)); | |
| while (trunk.hasNext()) { | |
| trunk.next().setMaterial(VanillaMaterials.LOG, logMetadata); | |
| } | |
| generateBranches(w, x, y, z, leaves); | |
| $level->setBlock($x, $pos->y - 1, $z, 3, 0); | |
| $this->totalHeight += $random->nextRange(0, 2); | |
| $this->leavesHeight += mt_rand(0, 1); | |
| for($yy = ($this->totalHeight - $this->leavesHeight); $yy < ($this->totalHeight + 1); ++$yy){ | |
| $yRadius = ($yy - $this->totalHeight); | |
| $xzRadius = (int) (($this->radiusIncrease + 1) - $yRadius / 2); | |
| for($xx = -$xzRadius; $xx < ($xzRadius + 1); ++$xx){ | |
| for($zz = -$xzRadius; $zz < ($xzRadius + 1); ++$zz){ | |
| if((abs($xx) != $xzRadius or abs($zz) != $xzRadius) and $yRadius != 0){ | |
| $level->setBlock($pos->x + $xx, $pos->y + $yy, $pos->z + $zz, 18, $type); | |
| } | |
| } | |
| } | |
| } | |
| for($yy = 0; $yy < ($this->totalHeight - 1); ++$yy){ | |
| $level->setBlock($x, $pos->y + $yy, $z, 17, $type); | |
| } | |
| */ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * All the different object classes used in populators | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| abstract class Object{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\math\VectorMath; | |
| use pocketmine\utils\Random; | |
| class Ore{ | |
| private $random; | |
| public $type; | |
| public function __construct(Random $random, OreType $type){ | |
| $this->type = $type; | |
| $this->random = $random; | |
| } | |
| public function getType(){ | |
| return $this->type; | |
| } | |
| public function canPlaceObject(Level $level, $x, $y, $z){ | |
| return ($level->level->getBlockID($x, $y, $z) !== 0); | |
| } | |
| public function placeObject(Level $level, Vector3 $pos){ | |
| $clusterSize = (int) $this->type->clusterSize; | |
| $angle = $this->random->nextFloat() * M_PI; | |
| $offset = VectorMath::getDirection2D($angle)->multiply($clusterSize)->divide(8); | |
| $x1 = $pos->x + 8 + $offset->x; | |
| $x2 = $pos->x + 8 - $offset->x; | |
| $z1 = $pos->z + 8 + $offset->y; | |
| $z2 = $pos->z + 8 - $offset->y; | |
| $y1 = $pos->y + $this->random->nextRange(0, 3) + 2; | |
| $y2 = $pos->y + $this->random->nextRange(0, 3) + 2; | |
| for($count = 0; $count <= $clusterSize; ++$count){ | |
| $seedX = $x1 + ($x2 - $x1) * $count / $clusterSize; | |
| $seedY = $y1 + ($y2 - $y1) * $count / $clusterSize; | |
| $seedZ = $z1 + ($z2 - $z1) * $count / $clusterSize; | |
| $size = ((sin($count * (M_PI / $clusterSize)) + 1) * $this->random->nextFloat() * $clusterSize / 16 + 1) / 2; | |
| $startX = (int) ($seedX - $size); | |
| $startY = (int) ($seedY - $size); | |
| $startZ = (int) ($seedZ - $size); | |
| $endX = (int) ($seedX + $size); | |
| $endY = (int) ($seedY + $size); | |
| $endZ = (int) ($seedZ + $size); | |
| for($x = $startX; $x <= $endX; ++$x){ | |
| $sizeX = ($x + 0.5 - $seedX) / $size; | |
| $sizeX *= $sizeX; | |
| if($sizeX < 1){ | |
| for($y = $startY; $y <= $endY; ++$y){ | |
| $sizeY = ($y + 0.5 - $seedY) / $size; | |
| $sizeY *= $sizeY; | |
| if($y > 0 and ($sizeX + $sizeY) < 1){ | |
| for($z = $startZ; $z <= $endZ; ++$z){ | |
| $sizeZ = ($z + 0.5 - $seedZ) / $size; | |
| $sizeZ *= $sizeZ; | |
| if(($sizeX + $sizeY + $sizeZ) < 1 and $level->level->getBlockID($x, $y, $z) === 1){ | |
| $level->setBlockRaw(new Vector3($x, $y, $z), $this->type->material); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\block\Block; | |
| class OreType{ | |
| public $material, $clusterCount, $clusterSize, $maxHeight, $minHeight; | |
| public function __construct(Block $material, $clusterCount, $clusterSize, $minHeight, $maxHeight){ | |
| $this->material = $material; | |
| $this->clusterCount = (int) $clusterCount; | |
| $this->clusterSize = (int) $clusterSize; | |
| $this->maxHeight = (int) $maxHeight; | |
| $this->minHeight = (int) $minHeight; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\block\Dirt; | |
| use pocketmine\block\Leaves; | |
| use pocketmine\block\Wood; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class PineTree extends Tree{ | |
| var $type = 1; | |
| private $totalHeight = 8; | |
| private $leavesSizeY = -1; | |
| private $leavesAbsoluteMaxRadius = -1; | |
| public function canPlaceObject(Level $level, Vector3 $pos, Random $random){ | |
| $this->findRandomLeavesSize($random); | |
| $checkRadius = 0; | |
| for($yy = 0; $yy < $this->totalHeight; ++$yy){ | |
| if($yy === $this->leavesSizeY){ | |
| $checkRadius = $this->leavesAbsoluteMaxRadius; | |
| } | |
| for($xx = -$checkRadius; $xx < ($checkRadius + 1); ++$xx){ | |
| for($zz = -$checkRadius; $zz < ($checkRadius + 1); ++$zz){ | |
| if(!isset($this->overridable[$level->level->getBlockID($pos->x + $xx, $pos->y + $yy, $pos->z + $zz)])){ | |
| return false; | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| private function findRandomLeavesSize(Random $random){ | |
| $this->totalHeight += $random->nextRange(-1, 2); | |
| $this->leavesSizeY = 1 + $random->nextRange(0, 2); | |
| $this->leavesAbsoluteMaxRadius = 2 + $random->nextRange(0, 1); | |
| } | |
| public function placeObject(Level $level, Vector3 $pos, Random $random){ | |
| if($this->leavesSizeY === -1 or $this->leavesAbsoluteMaxRadius === -1){ | |
| $this->findRandomLeavesSize($random); | |
| } | |
| $level->setBlockRaw(new Vector3($pos->x, $pos->y - 1, $pos->z), new Dirt()); | |
| $leavesRadius = 0; | |
| $leavesMaxRadius = 1; | |
| $leavesBottomY = $this->totalHeight - $this->leavesSizeY; | |
| $firstMaxedRadius = false; | |
| for($leavesY = 0; $leavesY <= $leavesBottomY; ++$leavesY){ | |
| $yy = $this->totalHeight - $leavesY; | |
| for($xx = -$leavesRadius; $xx <= $leavesRadius; ++$xx){ | |
| for($zz = -$leavesRadius; $zz <= $leavesRadius; ++$zz){ | |
| if(abs($xx) != $leavesRadius or abs($zz) != $leavesRadius or $leavesRadius <= 0){ | |
| $level->setBlockRaw(new Vector3($pos->x + $xx, $pos->y + $yy, $pos->z + $zz), new Leaves($this->type)); | |
| } | |
| } | |
| } | |
| if($leavesRadius >= $leavesMaxRadius){ | |
| $leavesRadius = $firstMaxedRadius ? 1 : 0; | |
| $firstMaxedRadius = true; | |
| if(++$leavesMaxRadius > $this->leavesAbsoluteMaxRadius){ | |
| $leavesMaxRadius = $this->leavesAbsoluteMaxRadius; | |
| } | |
| }else{ | |
| ++$leavesRadius; | |
| } | |
| } | |
| $trunkHeightReducer = $random->nextRange(0, 3); | |
| for($yy = 0; $yy < ($this->totalHeight - $trunkHeightReducer); ++$yy){ | |
| $level->setBlockRaw(new Vector3($pos->x, $pos->y + $yy, $pos->z), new Wood($this->type)); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\block\Block; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class Pond{ | |
| private $random; | |
| public $type; | |
| public function __construct(Random $random, Block $type){ | |
| $this->type = $type; | |
| $this->random = $random; | |
| } | |
| public function canPlaceObject(Level $level, Vector3 $pos){ | |
| } | |
| public function placeObject(Level $level, Vector3 $pos){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\block\Dirt; | |
| use pocketmine\block\Leaves; | |
| use pocketmine\block\Wood; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class SmallTree extends Tree{ | |
| public $type = 0; | |
| private $trunkHeight = 5; | |
| private static $leavesHeight = 4; // All trees appear to be 4 tall | |
| private static $leafRadii = array(1, 1.41, 2.83, 2.24); | |
| private $addLeavesVines = false; | |
| private $addLogVines = false; | |
| private $addCocoaPlants = false; | |
| public function canPlaceObject(Level $level, Vector3 $pos, Random $random){ | |
| $radiusToCheck = 0; | |
| for($yy = 0; $yy < $this->trunkHeight + 3; ++$yy){ | |
| if($yy == 1 or $yy === $this->trunkHeight){ | |
| ++$radiusToCheck; | |
| } | |
| for($xx = -$radiusToCheck; $xx < ($radiusToCheck + 1); ++$xx){ | |
| for($zz = -$radiusToCheck; $zz < ($radiusToCheck + 1); ++$zz){ | |
| if(!isset($this->overridable[$level->level->getBlockID($pos->x + $xx, $pos->y + $yy, $pos->z + $zz)])){ | |
| return false; | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| public function placeObject(Level $level, Vector3 $pos, Random $random){ | |
| // The base dirt block | |
| $dirtpos = new Vector3($pos->x, $pos->y - 1, $pos->z); | |
| $level->setBlockRaw($dirtpos, new Dirt()); | |
| // Adjust the tree trunk's height randomly | |
| // plot [-14:11] int( x / 8 ) + 5 | |
| // - min=4 (all leaves are 4 tall, some trunk must show) | |
| // - max=6 (top leaves are within ground-level whacking range | |
| // on all small trees) | |
| $heightPre = $random->nextRange(-14, 11); | |
| $this->trunkHeight = intval($heightPre / 8) + 5; | |
| // Adjust the starting leaf density using the trunk height as a | |
| // starting position (tall trees with skimpy leaves don't look | |
| // too good) | |
| $leafPre = $random->nextRange($this->trunkHeight, 10) / 20; // (TODO: seed may apply) | |
| // Now build the tree (from the top down) | |
| $leaflevel = 0; | |
| for($yy = ($this->trunkHeight + 1); $yy >= 0; --$yy){ | |
| if($leaflevel < self::$leavesHeight){ | |
| // The size is a slight variation on the trunkheight | |
| $radius = self::$leafRadii[$leaflevel] + $leafPre; | |
| $bRadius = 3; | |
| for($xx = -$bRadius; $xx <= $bRadius; ++$xx){ | |
| for($zz = -$bRadius; $zz <= $bRadius; ++$zz){ | |
| if(sqrt(($xx * $xx) + ($zz * $zz)) <= $radius){ | |
| $leafpos = new Vector3($pos->x + $xx, | |
| $pos->y + $yy, | |
| $pos->z + $zz); | |
| $level->setBlockRaw($leafpos, new Leaves($this->type)); | |
| } | |
| } | |
| } | |
| $leaflevel++; | |
| } | |
| // Place the trunk last | |
| if($leaflevel > 1){ | |
| $trunkpos = new Vector3($pos->x, $pos->y + $yy, $pos->z); | |
| $level->setBlockRaw($trunkpos, new Wood($this->type)); | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\block\Dirt; | |
| use pocketmine\block\Leaves; | |
| use pocketmine\block\Wood; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class SpruceTree extends Tree{ | |
| var $type = 1; | |
| private $totalHeight = 8; | |
| private $leavesBottomY = -1; | |
| private $leavesMaxRadius = -1; | |
| public function canPlaceObject(Level $level, Vector3 $pos, Random $random){ | |
| $this->findRandomLeavesSize($random); | |
| $checkRadius = 0; | |
| for($yy = 0; $yy < $this->totalHeight + 2; ++$yy){ | |
| if($yy === $this->leavesBottomY){ | |
| $checkRadius = $this->leavesMaxRadius; | |
| } | |
| for($xx = -$checkRadius; $xx < ($checkRadius + 1); ++$xx){ | |
| for($zz = -$checkRadius; $zz < ($checkRadius + 1); ++$zz){ | |
| if(!isset($this->overridable[$level->level->getBlockID($pos->x + $xx, $pos->y + $yy, $pos->z + $zz)])){ | |
| return false; | |
| } | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| private function findRandomLeavesSize(Random $random){ | |
| $this->totalHeight += $random->nextRange(-1, 2); | |
| $this->leavesBottomY = (int) ($this->totalHeight - $random->nextRange(1, 2) - 3); | |
| $this->leavesMaxRadius = 1 + $random->nextRange(0, 1); | |
| } | |
| public function placeObject(Level $level, Vector3 $pos, Random $random){ | |
| if($this->leavesBottomY === -1 or $this->leavesMaxRadius === -1){ | |
| $this->findRandomLeavesSize($random); | |
| } | |
| $level->setBlockRaw(new Vector3($pos->x, $pos->y - 1, $pos->z), new Dirt()); | |
| $leavesRadius = 0; | |
| for($yy = $this->totalHeight; $yy >= $this->leavesBottomY; --$yy){ | |
| for($xx = -$leavesRadius; $xx <= $leavesRadius; ++$xx){ | |
| for($zz = -$leavesRadius; $zz <= $leavesRadius; ++$zz){ | |
| if(abs($xx) != $leavesRadius or abs($zz) != $leavesRadius or $leavesRadius <= 0){ | |
| $level->setBlockRaw(new Vector3($pos->x + $xx, $pos->y + $yy, $pos->z + $zz), new Leaves($this->type)); | |
| } | |
| } | |
| } | |
| if($leavesRadius > 0 and $yy === ($pos->y + $this->leavesBottomY + 1)){ | |
| --$leavesRadius; | |
| }elseif($leavesRadius < $this->leavesMaxRadius){ | |
| ++$leavesRadius; | |
| } | |
| } | |
| for($yy = 0; $yy < ($this->totalHeight - 1); ++$yy){ | |
| $level->setBlockRaw(new Vector3($pos->x, $pos->y + $yy, $pos->z), new Wood($this->type)); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\block\Block; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class TallGrass{ | |
| public static function growGrass(Level $level, Vector3 $pos, Random $random, $count = 15, $radius = 10){ | |
| $arr = array( | |
| Block::get(Block::DANDELION, 0), | |
| Block::get(Block::CYAN_FLOWER, 0), | |
| Block::get(Block::TALL_GRASS, 1), | |
| Block::get(Block::TALL_GRASS, 1), | |
| Block::get(Block::TALL_GRASS, 1), | |
| Block::get(Block::TALL_GRASS, 1) | |
| ); | |
| $arrC = count($arr) - 1; | |
| for($c = 0; $c < $count; ++$c){ | |
| $x = $random->nextRange($pos->x - $radius, $pos->x + $radius); | |
| $z = $random->nextRange($pos->z - $radius, $pos->z + $radius); | |
| if($level->level->getBlockID($x, $pos->y + 1, $z) === Block::AIR and $level->level->getBlockID($x, $pos->y, $z) === Block::GRASS){ | |
| $t = $arr[$random->nextRange(0, $arrC)]; | |
| $level->setBlockRaw(new Vector3($x, $pos->y + 1, $z), $t); | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\object; | |
| use pocketmine\block\Sapling; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class Tree{ | |
| public $overridable = array( | |
| 0 => true, | |
| 2 => true, | |
| 3 => true, | |
| 6 => true, | |
| 17 => true, | |
| 18 => true, | |
| ); | |
| public static function growTree(Level $level, Vector3 $pos, Random $random, $type = 0){ | |
| switch($type & 0x03){ | |
| case Sapling::SPRUCE: | |
| if($random->nextRange(0, 1) === 1){ | |
| $tree = new SpruceTree(); | |
| }else{ | |
| $tree = new PineTree(); | |
| } | |
| break; | |
| case Sapling::BIRCH: | |
| $tree = new SmallTree(); | |
| $tree->type = Sapling::BIRCH; | |
| break; | |
| case Sapling::JUNGLE: | |
| $tree = new SmallTree(); | |
| $tree->type = Sapling::JUNGLE; | |
| break; | |
| case Sapling::OAK: | |
| default: | |
| /*if($random->nextRange(0, 9) === 0){ | |
| $tree = new BigTree(); | |
| }else{*/ | |
| $tree = new SmallTree(); | |
| //} | |
| break; | |
| } | |
| if($tree->canPlaceObject($level, $pos, $random)){ | |
| $tree->placeObject($level, $pos, $random); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\populator; | |
| use pocketmine\level\Level; | |
| use pocketmine\utils\Random; | |
| class Mineshaft extends Populator{ | |
| private static $DISTANCE = 256; | |
| private static $VARIATION = 16; | |
| private static $ODD = 3; | |
| private static $BASE_Y = 35; | |
| private static $RAND_Y = 11; | |
| public function populate(Level $level, $chunkX, $chunkZ, Random $random){ | |
| if($random->nextRange(0, self::$ODD) === 0){ | |
| //$mineshaft = new Mineshaft($random); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\populator; | |
| use pocketmine\level\generator\object\Ore as ObjectOre; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class Ore extends Populator{ | |
| private $oreTypes = array(); | |
| public function populate(Level $level, $chunkX, $chunkZ, Random $random){ | |
| foreach($this->oreTypes as $type){ | |
| $ore = new ObjectOre($random, $type); | |
| for($i = 0; $i < $ore->type->clusterCount; ++$i){ | |
| $x = $random->nextRange($chunkX << 4, ($chunkX << 4) + 15); | |
| $y = $random->nextRange($ore->type->minHeight, $ore->type->maxHeight); | |
| $z = $random->nextRange($chunkZ << 4, ($chunkZ << 4) + 15); | |
| if($ore->canPlaceObject($level, $x, $y, $z)){ | |
| $ore->placeObject($level, new Vector3($x, $y, $z)); | |
| } | |
| } | |
| } | |
| } | |
| public function setOreTypes(array $types){ | |
| $this->oreTypes = $types; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\populator; | |
| use pocketmine\block\Water; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class Pond extends Populator{ | |
| private $waterOdd = 4; | |
| private $lavaOdd = 4; | |
| private $lavaSurfaceOdd = 4; | |
| public function populate(Level $level, $chunkX, $chunkZ, Random $random){ | |
| if($random->nextRange(0, $this->waterOdd) === 0){ | |
| $v = new Vector3( | |
| $random->nextRange($chunkX << 4, ($chunkX << 4) + 16), | |
| $random->nextRange(0, 128), | |
| $random->nextRange($chunkZ << 4, ($chunkZ << 4) + 16) | |
| ); | |
| $pond = new \pocketmine\level\generator\object\Pond($random, new Water()); | |
| if($pond->canPlaceObject($level, $v)){ | |
| $pond->placeObject($level, $v); | |
| } | |
| } | |
| } | |
| public function setWaterOdd($waterOdd){ | |
| $this->waterOdd = $waterOdd; | |
| } | |
| public function setLavaOdd($lavaOdd){ | |
| $this->lavaOdd = $lavaOdd; | |
| } | |
| public function setLavaSurfaceOdd($lavaSurfaceOdd){ | |
| $this->lavaSurfaceOdd = $lavaSurfaceOdd; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * All the Object populator classes | |
| */ | |
| namespace pocketmine\level\generator\populator; | |
| use pocketmine\level\Level; | |
| use pocketmine\utils\Random; | |
| abstract class Populator{ | |
| public abstract function populate(Level $level, $chunkX, $chunkZ, Random $random); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\populator; | |
| use pocketmine\block\Block; | |
| use pocketmine\block\TallGrass as BlockTallGrass; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class TallGrass extends Populator{ | |
| /** @var Level */ | |
| private $level; | |
| private $randomAmount; | |
| private $baseAmount; | |
| public function setRandomAmount($amount){ | |
| $this->randomAmount = $amount; | |
| } | |
| public function setBaseAmount($amount){ | |
| $this->baseAmount = $amount; | |
| } | |
| public function populate(Level $level, $chunkX, $chunkZ, Random $random){ | |
| $this->level = $level; | |
| $amount = $random->nextRange(0, $this->randomAmount + 1) + $this->baseAmount; | |
| for($i = 0; $i < $amount; ++$i){ | |
| $x = $random->nextRange($chunkX << 4, ($chunkX << 4) + 15); | |
| $z = $random->nextRange($chunkZ << 4, ($chunkZ << 4) + 15); | |
| for($size = 30; $size > 0; --$size){ | |
| $xx = $x - 7 + $random->nextRange(0, 15); | |
| $zz = $z - 7 + $random->nextRange(0, 15); | |
| $yy = $this->getHighestWorkableBlock($xx, $zz); | |
| $vector = new Vector3($xx, $yy, $zz); | |
| if($yy !== -1 and $this->canTallGrassStay($this->level->getBlockRaw($vector))){ | |
| $this->level->setBlockRaw($vector, new BlockTallGrass(1)); | |
| } | |
| } | |
| } | |
| } | |
| private function canTallGrassStay(Block $block){ | |
| return $block->getID() === Block::AIR and $block->getSide(0)->getID() === Block::GRASS; | |
| } | |
| private function getHighestWorkableBlock($x, $z){ | |
| for($y = 128; $y > 0; --$y){ | |
| $b = $this->level->getBlockRaw(new Vector3($x, $y, $z)); | |
| if($b->getID() === Block::AIR or $b->getID() === Block::LEAVES){ | |
| if(--$y <= 0){ | |
| return -1; | |
| } | |
| }else{ | |
| break; | |
| } | |
| } | |
| return ++$y; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level\generator\populator; | |
| use pocketmine\block\Block; | |
| use pocketmine\block\Sapling; | |
| use pocketmine\level\generator\object\Tree as ObjectTree; | |
| use pocketmine\level\Level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\utils\Random; | |
| class Tree extends Populator{ | |
| private $level; | |
| private $randomAmount; | |
| private $baseAmount; | |
| public function setRandomAmount($amount){ | |
| $this->randomAmount = $amount; | |
| } | |
| public function setBaseAmount($amount){ | |
| $this->baseAmount = $amount; | |
| } | |
| public function populate(Level $level, $chunkX, $chunkZ, Random $random){ | |
| $this->level = $level; | |
| $amount = $random->nextRange(0, $this->randomAmount + 1) + $this->baseAmount; | |
| for($i = 0; $i < $amount; ++$i){ | |
| $x = $random->nextRange($chunkX << 4, ($chunkX << 4) + 15); | |
| $z = $random->nextRange($chunkZ << 4, ($chunkZ << 4) + 15); | |
| $y = $this->getHighestWorkableBlock($x, $z); | |
| if($y === -1){ | |
| continue; | |
| } | |
| if($random->nextFloat() > 0.75){ | |
| $meta = Sapling::BIRCH; | |
| }else{ | |
| $meta = Sapling::OAK; | |
| } | |
| ObjectTree::growTree($this->level, new Vector3($x, $y, $z), $random, $meta); | |
| } | |
| } | |
| private function getHighestWorkableBlock($x, $z){ | |
| for($y = 128; $y > 0; --$y){ | |
| $b = $this->level->getBlockRaw(new Vector3($x, $y, $z)); | |
| if($b->getID() !== Block::DIRT and $b->getID() !== Block::GRASS){ | |
| if(--$y <= 0){ | |
| return -1; | |
| } | |
| }else{ | |
| break; | |
| } | |
| } | |
| return ++$y; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * All Level related classes are here, like Generators, Populators, Noise, ... | |
| */ | |
| namespace pocketmine\level; | |
| use pocketmine\block\Air; | |
| use pocketmine\block\Block; | |
| use pocketmine\entity\Entity; | |
| use pocketmine\event\block\BlockBreakEvent; | |
| use pocketmine\event\block\BlockPlaceEvent; | |
| use pocketmine\event\player\PlayerInteractEvent; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\generator\Generator; | |
| use pocketmine\math\Vector2; | |
| use pocketmine\math\Vector3 as Vector3; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\nbt\tag\Enum; | |
| use pocketmine\nbt\tag\Int; | |
| use pocketmine\nbt\tag\String; | |
| use pocketmine\network\protocol\SetTimePacket; | |
| use pocketmine\network\protocol\UpdateBlockPacket; | |
| use pocketmine\Player; | |
| use pocketmine\level\format\pmf\LevelFormat; | |
| use pocketmine\Server; | |
| use pocketmine\tile\Chest; | |
| use pocketmine\tile\Furnace; | |
| use pocketmine\tile\Sign; | |
| use pocketmine\tile\Tile; | |
| use pocketmine\utils\Cache; | |
| use pocketmine\utils\Random; | |
| use pocketmine\utils\ReversePriorityQueue; | |
| /** | |
| * Main Level handling class, includes all the methods used on them. | |
| */ | |
| class Level{ | |
| const BLOCK_UPDATE_NORMAL = 1; | |
| const BLOCK_UPDATE_RANDOM = 2; | |
| const BLOCK_UPDATE_SCHEDULED = 3; | |
| const BLOCK_UPDATE_WEAK = 4; | |
| const BLOCK_UPDATE_TOUCH = 5; | |
| /** @var Player[] */ | |
| public $players = array(); | |
| /** @var Entity[] */ | |
| public $entities = array(); | |
| /** @var Entity[][] */ | |
| public $chunkEntities = array(); | |
| /** @var Tile[] */ | |
| public $tiles = array(); | |
| /** @var Tile[][] */ | |
| public $chunkTiles = array(); | |
| public $nextSave; | |
| /** @var LevelFormat */ | |
| public $level; | |
| public $stopTime; | |
| private $time; | |
| private $startCheck; | |
| private $startTime; | |
| /** @var Server */ | |
| private $server; | |
| private $name; | |
| private $usedChunks; | |
| private $changedBlocks; | |
| private $changedCount; | |
| /** @var Generator */ | |
| private $generator; | |
| /** @var ReversePriorityQueue */ | |
| private $updateQueue; | |
| private $autoSave = true; | |
| /** | |
| * @param Server $server | |
| * @param LevelFormat $level | |
| * @param string $name | |
| */ | |
| public function __construct(Server $server, LevelFormat $level, $name){ | |
| $this->server = $server; | |
| $this->updateQueue = new ReversePriorityQueue(); | |
| $this->updateQueue->setExtractFlags(\SplPriorityQueue::EXTR_BOTH); | |
| $this->level = $level; | |
| $this->level->level = $this; | |
| $this->startTime = $this->time = (int) $this->level->getData("time"); | |
| $this->nextSave = $this->startCheck = microtime(true); | |
| $this->nextSave += 90; | |
| $this->stopTime = false; | |
| $this->name = $name; | |
| $this->usedChunks = array(); | |
| $this->changedBlocks = array(); | |
| $this->changedCount = array(); | |
| $gen = Generator::getGenerator($this->level->levelData["generator"]); | |
| $this->generator = new $gen((array) $this->level->levelData["generatorSettings"]); | |
| $this->generator->init($this, new Random($this->level->levelData["seed"])); | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function getAutoSave(){ | |
| return $this->autoSave === true; | |
| } | |
| /** | |
| * @param bool $value | |
| */ | |
| public function setAutoSave($value){ | |
| $this->autoSave = $value; | |
| } | |
| public function close(){ | |
| $this->__destruct(); | |
| } | |
| /** | |
| * Unloads the current level from memory safely | |
| * | |
| * @param bool $force default false, force unload of default level | |
| * | |
| * @return bool | |
| */ | |
| public function unload($force = false){ | |
| if($this === $this->server->getDefaultLevel() and $force !== true){ | |
| return false; | |
| } | |
| console("[INFO] Unloading level \"" . $this->getName() . "\""); | |
| $this->nextSave = PHP_INT_MAX; | |
| $this->save(); | |
| $defaultLevel = $this->server->getDefaultLevel(); | |
| foreach($this->getPlayers() as $player){ | |
| if($this === $defaultLevel or $defaultLevel === null){ | |
| $player->close($player->getName() . " has left the game", "forced default level unload"); | |
| }elseif($defaultLevel instanceof Level){ | |
| $player->teleport($this->server->getDefaultLevel()->getSafeSpawn()); | |
| } | |
| } | |
| $this->close(); | |
| if($this === $defaultLevel){ | |
| $this->server->setDefaultLevel(null); | |
| } | |
| return true; | |
| } | |
| /** | |
| * Gets the chunks being used by players | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return Player[][] | |
| */ | |
| public function getUsingChunk($X, $Z){ | |
| $index = LevelFormat::getIndex($X, $Z); | |
| return isset($this->usedChunks[$index]) ? $this->usedChunks[$index] : array(); | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * @param Player $player | |
| */ | |
| public function useChunk($X, $Z, Player $player){ | |
| $index = LevelFormat::getIndex($X, $Z); | |
| $this->loadChunk($X, $Z); | |
| $this->usedChunks[$index][$player->CID] = $player; | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param Player $player | |
| */ | |
| public function freeAllChunks(Player $player){ | |
| foreach($this->usedChunks as $i => $c){ | |
| unset($this->usedChunks[$i][$player->CID]); | |
| } | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * @param Player $player | |
| */ | |
| public function freeChunk($X, $Z, Player $player){ | |
| unset($this->usedChunks[LevelFormat::getIndex($X, $Z)][$player->CID]); | |
| } | |
| /** | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return bool | |
| */ | |
| public function isChunkPopulated($X, $Z){ | |
| return $this->level->isPopulated($X, $Z); | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| */ | |
| public function checkTime(){ | |
| if(!isset($this->level)){ | |
| return; | |
| } | |
| $now = microtime(true); | |
| if($this->stopTime == true){ | |
| return; | |
| }else{ | |
| $time = $this->startTime + ($now - $this->startCheck) * 20; | |
| } | |
| $this->time = $time; | |
| $pk = new SetTimePacket; | |
| $pk->time = (int) $this->time; | |
| $pk->started = $this->stopTime == false; | |
| Player::broadcastPacket($this->players, $pk); | |
| return; | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param int $currentTick | |
| * | |
| * @return bool | |
| */ | |
| public function doTick($currentTick){ | |
| if(!isset($this->level)){ | |
| return false; | |
| } | |
| if(($currentTick % 200) === 0){ | |
| $this->checkTime(); | |
| } | |
| if($this->level->isGenerating === 0 and count($this->changedCount) > 0){ | |
| foreach($this->changedCount as $index => $mini){ | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| if(($mini & (1 << $Y)) === 0){ | |
| continue; | |
| } | |
| if(count($this->changedBlocks[$index][$Y]) < 582){ //Optimal value, calculated using the relation between minichunks and single packets | |
| continue; | |
| }else{ | |
| foreach($this->players as $p){ | |
| $p->setChunkIndex($index, $mini); | |
| } | |
| unset($this->changedBlocks[$index][$Y]); | |
| } | |
| } | |
| } | |
| $this->changedCount = array(); | |
| if(count($this->changedBlocks) > 0){ | |
| foreach($this->changedBlocks as $index => $mini){ | |
| foreach($mini as $blocks){ | |
| foreach($blocks as $b){ | |
| $pk = new UpdateBlockPacket; | |
| $pk->x = $b->x; | |
| $pk->y = $b->y; | |
| $pk->z = $b->z; | |
| $pk->block = $b->getID(); | |
| $pk->meta = $b->getMetadata(); | |
| Player::broadcastPacket($this->players, $pk); | |
| } | |
| } | |
| } | |
| $this->changedBlocks = array(); | |
| } | |
| $X = null; | |
| $Z = null; | |
| //Do chunk updates | |
| while($this->updateQueue->count() > 0 and $this->updateQueue->current()["priority"] <= $currentTick){ | |
| $block = $this->getBlockRaw($this->updateQueue->extract()["data"]); | |
| $block->onUpdate(self::BLOCK_UPDATE_SCHEDULED); | |
| } | |
| foreach($this->usedChunks as $index => $p){ | |
| LevelFormat::getXZ($index, $X, $Z); | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| if(!$this->level->isMiniChunkEmpty($X, $Z, $Y)){ | |
| for($i = 0; $i < 3; ++$i){ | |
| $block = $this->getBlockRaw(new Vector3(($X << 4) + mt_rand(0, 15), ($Y << 4) + mt_rand(0, 15), ($Z << 4) + mt_rand(0, 15))); | |
| if($block instanceof Block){ | |
| if($block->onUpdate(self::BLOCK_UPDATE_RANDOM) === self::BLOCK_UPDATE_NORMAL){ | |
| $this->updateAround($block, self::BLOCK_UPDATE_NORMAL); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| } | |
| if($this->nextSave < microtime(true)){ | |
| $X = null; | |
| $Z = null; | |
| foreach($this->usedChunks as $i => $c){ | |
| if(count($c) === 0){ | |
| unset($this->usedChunks[$i]); | |
| LevelFormat::getXZ($i, $X, $Z); | |
| if(!$this->isSpawnChunk($X, $Z)){ | |
| $this->level->unloadChunk($X, $Z, $this->getAutoSave()); | |
| } | |
| } | |
| } | |
| $this->save(false, false); | |
| } | |
| } | |
| /** | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return bool | |
| */ | |
| public function generateChunk($X, $Z){ | |
| ++$this->level->isGenerating; | |
| $this->generator->generateChunk($X, $Z); | |
| --$this->level->isGenerating; | |
| return true; | |
| } | |
| /** | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return bool | |
| */ | |
| public function populateChunk($X, $Z){ | |
| $this->level->setPopulated($X, $Z); | |
| $this->generator->populateChunk($X, $Z); | |
| return true; | |
| } | |
| public function __destruct(){ | |
| if(isset($this->level)){ | |
| $this->save(false, false); | |
| $this->level->closeLevel(); | |
| if($this->isLoaded()){ | |
| unset($this->level); | |
| $this->server->unloadLevel($this, true); | |
| } | |
| } | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isLoaded(){ | |
| return isset($this->level) and $this->level instanceof LevelFormat; | |
| } | |
| /** | |
| * @param bool $force | |
| * @param bool $extra | |
| * | |
| * @return bool | |
| */ | |
| public function save($force = false, $extra = true){ | |
| if(!isset($this->level)){ | |
| return false; | |
| } | |
| if($this->getAutoSave() === false and $force === false){ | |
| return; | |
| } | |
| if($extra !== false){ | |
| $this->doSaveRoundExtra(); | |
| } | |
| $this->level->setData("time", (int) $this->time); | |
| $this->level->doSaveRound($force); | |
| $this->level->saveData(); | |
| $this->nextSave = microtime(true) + 45; | |
| return true; | |
| } | |
| protected function doSaveRoundExtra(){ | |
| foreach($this->usedChunks as $index => $d){ | |
| LevelFormat::getXZ($index, $X, $Z); | |
| $nbt = new Compound("", array( | |
| new Enum("Entities", array()), | |
| new Enum("TileEntities", array()), | |
| )); | |
| $nbt->Entities->setTagType(NBT::TAG_Compound); | |
| $nbt->TileEntities->setTagType(NBT::TAG_Compound); | |
| $i = 0; | |
| foreach($this->chunkEntities[$index] as $entity){ | |
| if($entity->closed !== true){ | |
| $entity->saveNBT(); | |
| $nbt->Entities[$i] = $entity->namedtag; | |
| ++$i; | |
| } | |
| } | |
| $i = 0; | |
| foreach($this->chunkTiles[$index] as $tile){ | |
| if($tile->closed !== true){ | |
| $nbt->TileEntities[$i] = $tile->namedtag; | |
| ++$i; | |
| } | |
| } | |
| $this->level->setChunkNBT($X, $Z, $nbt); | |
| } | |
| } | |
| /** | |
| * @param Vector3 $pos | |
| * @param int $type | |
| */ | |
| public function updateAround(Vector3 $pos, $type = self::BLOCK_UPDATE_NORMAL){ | |
| $block = $this->getBlockRaw($pos); | |
| $block->getSide(0)->onUpdate($type); | |
| $block->getSide(1)->onUpdate($type); | |
| $block->getSide(2)->onUpdate($type); | |
| $block->getSide(3)->onUpdate($type); | |
| $block->getSide(4)->onUpdate($type); | |
| $block->getSide(5)->onUpdate($type); | |
| } | |
| /** | |
| * @param Vector3 $pos | |
| * @param int $delay | |
| */ | |
| public function scheduleUpdate(Vector3 $pos, $delay){ | |
| $this->updateQueue->insert($pos, (int) $delay); | |
| } | |
| /** | |
| * @param Vector3 $pos | |
| * | |
| * @return Block | |
| */ | |
| public function getBlockRaw(Vector3 $pos){ | |
| $b = $this->level->getBlock($pos->x, $pos->y, $pos->z); | |
| return Block::get($b[0], $b[1], new Position($pos->x, $pos->y, $pos->z, $this)); | |
| } | |
| /** | |
| * @param Vector3 $pos | |
| * | |
| * @return bool|Block | |
| */ | |
| public function getBlock(Vector3 $pos){ | |
| if($pos instanceof Position and $pos->level !== $this){ | |
| return false; | |
| } | |
| $b = $this->level->getBlock($pos->x, $pos->y, $pos->z); | |
| return Block::get($b[0], $b[1], new Position($pos->x, $pos->y, $pos->z, $this)); | |
| } | |
| /** | |
| * @param Vector3 $pos | |
| * @param Block $block | |
| * @param bool $direct | |
| * @param bool $send | |
| * | |
| * @return bool | |
| */ | |
| public function setBlockRaw(Vector3 $pos, Block $block, $direct = true, $send = true){ | |
| if(($ret = $this->level->setBlock($pos->x, $pos->y, $pos->z, $block->getID(), $block->getMetadata())) === true and $send !== false){ | |
| if($direct === true){ | |
| $pk = new UpdateBlockPacket; | |
| $pk->x = $pos->x; | |
| $pk->y = $pos->y; | |
| $pk->z = $pos->z; | |
| $pk->block = $block->getID(); | |
| $pk->meta = $block->getMetadata(); | |
| Player::broadcastPacket($this->players, $pk); | |
| }elseif($direct === false){ | |
| if(!($pos instanceof Position)){ | |
| $pos = new Position($pos->x, $pos->y, $pos->z, $this); | |
| } | |
| $block->position($pos); | |
| $index = LevelFormat::getIndex($pos->x >> 4, $pos->z >> 4); | |
| if(ADVANCED_CACHE == true){ | |
| Cache::remove("world:{$this->name}:{$index}"); | |
| } | |
| if(!isset($this->changedBlocks[$index])){ | |
| $this->changedBlocks[$index] = array(); | |
| $this->changedCount[$index] = 0; | |
| } | |
| $Y = $pos->y >> 4; | |
| if(!isset($this->changedBlocks[$index][$Y])){ | |
| $this->changedBlocks[$index][$Y] = array(); | |
| $this->changedCount[$index] |= 1 << $Y; | |
| } | |
| $this->changedBlocks[$index][$Y][] = clone $block; | |
| } | |
| } | |
| return $ret; | |
| } | |
| /** | |
| * @param Vector3 $pos | |
| * @param Block $block | |
| * @param bool $update | |
| * @param bool $tiles | |
| * @param bool $direct | |
| * | |
| * @return bool | |
| */ | |
| public function setBlock(Vector3 $pos, Block $block, $update = true, $tiles = false, $direct = false){ | |
| if((($pos instanceof Position) and $pos->level !== $this) or $pos->x < 0 or $pos->y < 0 or $pos->z < 0){ | |
| return false; | |
| } | |
| $ret = $this->level->setBlock($pos->x, $pos->y, $pos->z, $block->getID(), $block->getMetadata()); | |
| if($ret === true){ | |
| if(!($pos instanceof Position)){ | |
| $pos = new Position($pos->x, $pos->y, $pos->z, $this); | |
| } | |
| $block->position($pos); | |
| if($direct === true){ | |
| $pk = new UpdateBlockPacket; | |
| $pk->x = $pos->x; | |
| $pk->y = $pos->y; | |
| $pk->z = $pos->z; | |
| $pk->block = $block->getID(); | |
| $pk->meta = $block->getMetadata(); | |
| Player::broadcastPacket($this->players, $pk); | |
| }else{ | |
| $index = LevelFormat::getIndex($pos->x >> 4, $pos->z >> 4); | |
| if(ADVANCED_CACHE == true){ | |
| Cache::remove("world:{$this->name}:{$index}"); | |
| } | |
| if(!isset($this->changedBlocks[$index])){ | |
| $this->changedBlocks[$index] = array(); | |
| $this->changedCount[$index] = 0; | |
| } | |
| $Y = $pos->y >> 4; | |
| if(!isset($this->changedBlocks[$index][$Y])){ | |
| $this->changedBlocks[$index][$Y] = array(); | |
| $this->changedCount[$index] |= 1 << $Y; | |
| } | |
| $this->changedBlocks[$index][$Y][] = clone $block; | |
| } | |
| if($update === true){ | |
| $this->updateAround($pos, self::BLOCK_UPDATE_NORMAL); | |
| $block->onUpdate(self::BLOCK_UPDATE_NORMAL); | |
| } | |
| if($tiles === true){ | |
| if(($t = $this->getTile($pos)) instanceof Tile){ | |
| $t->close(); | |
| } | |
| } | |
| } | |
| return $ret; | |
| } | |
| /** | |
| * Tries to break a block using a item, including Player time checks if available | |
| * | |
| * @param Vector3 $vector | |
| * @param Item &$item (if null, can break anything) | |
| * @param Player $player | |
| * | |
| * @return boolean | |
| */ | |
| public function useBreakOn(Vector3 $vector, Item &$item = null, Player $player = null){ | |
| $target = $this->getBlock($vector); | |
| if($player instanceof Player){ | |
| $lastTime = $player->lastBreak - $player->getLag() / 1000; | |
| if(($player->getGamemode() & 0x01) === 1 and ($lastTime + 0.15) >= microtime(true)){ | |
| return false; | |
| }elseif(($lastTime + $target->getBreakTime($item)) >= microtime(true)){ | |
| return false; | |
| } | |
| $player->lastBreak = microtime(true); | |
| } | |
| //TODO: Adventure mode checks | |
| if($player instanceof Player){ | |
| $ev = new BlockBreakEvent($player, $target, $item, ($player->getGamemode() & 0x01) === 1 ? true : false); | |
| if($item instanceof Item and !$target->isBreakable($item) and $ev->getInstaBreak() === false){ | |
| $ev->setCancelled(); | |
| } | |
| if(!$player->isOp() and ($distance = $this->server->getConfigInt("spawn-protection", 16)) > -1){ | |
| $t = new Vector2($target->x, $target->z); | |
| $s = new Vector2($this->getSpawn()->x, $this->getSpawn()->z); | |
| if($t->distance($s) <= $distance){ //set it to cancelled so plugins can bypass this | |
| $ev->setCancelled(); | |
| } | |
| } | |
| $this->server->getPluginManager()->callEvent($ev); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| }elseif($item instanceof Item and !$target->isBreakable($item)){ | |
| return false; | |
| } | |
| $target->onBreak($item); | |
| if($item instanceof Item){ | |
| $item->useOn($target); | |
| if($item->isTool() and $item->getMetadata() >= $item->getMaxDurability()){ | |
| $item = Item::get(Item::AIR, 0, 0); | |
| } | |
| } | |
| return $target->getDrops($item); | |
| } | |
| /** | |
| * Uses a item on a position and face, placing it or activating the block | |
| * | |
| * @param Vector3 $vector | |
| * @param Item $item | |
| * @param int $face | |
| * @param float $fx default 0.0 | |
| * @param float $fy default 0.0 | |
| * @param float $fz default 0.0 | |
| * @param Player $player default null | |
| * | |
| * @return boolean | |
| */ | |
| public function useItemOn(Vector3 $vector, Item &$item, $face, $fx = 0.0, $fy = 0.0, $fz = 0.0, Player $player = null){ | |
| $target = $this->getBlock($vector); | |
| $block = $target->getSide($face); | |
| if($block->y > 127 or $block->y < 0){ | |
| return false; | |
| } | |
| if($target->getID() === Item::AIR){ | |
| return false; | |
| } | |
| if($player instanceof Player){ | |
| $ev = new PlayerInteractEvent($player, $item, $target, $face); | |
| if(!$player->isOp() and ($distance = $this->server->getConfigInt("spawn-protection", 16)) > -1){ | |
| $t = new Vector2($target->x, $target->z); | |
| $s = new Vector2($this->getSpawn()->x, $this->getSpawn()->z); | |
| if($t->distance($s) <= $distance){ //set it to cancelled so plugins can bypass this | |
| $ev->setCancelled(); | |
| } | |
| } | |
| $this->server->getPluginManager()->callEvent($ev); | |
| if(!$ev->isCancelled()){ | |
| $target->onUpdate(self::BLOCK_UPDATE_TOUCH); | |
| if($target->isActivable === true and $target->onActivate($item, $player) === true){ | |
| return true; | |
| } | |
| } | |
| }elseif($target->isActivable === true and $target->onActivate($item, $player) === true){ | |
| return true; | |
| } | |
| if($item->isPlaceable()){ | |
| $hand = $item->getBlock(); | |
| $hand->position($block); | |
| }elseif($block->getID() === Item::FIRE){ | |
| $this->setBlock($block, new Air(), true, false, true); | |
| return false; | |
| }else{ | |
| return false; | |
| } | |
| if(!($block->isReplaceable === true or ($hand->getID() === Item::SLAB and $block->getID() === Item::SLAB))){ | |
| return false; | |
| } | |
| if($target->isReplaceable === true){ | |
| $block = $target; | |
| $hand->position($block); | |
| //$face = -1; | |
| } | |
| //TODO: Implement using Bounding Boxes, all entities | |
| /*if($hand->isSolid === true and $player->inBlock($block)){ | |
| return false; //Entity in block | |
| }*/ | |
| if($player instanceof Player){ | |
| $ev = new BlockPlaceEvent($player, $hand, $block, $target, $item); | |
| if(!$player->isOp() and ($distance = $this->server->getConfigInt("spawn-protection", 16)) > -1){ | |
| $t = new Vector2($target->x, $target->z); | |
| $s = new Vector2($this->getSpawn()->x, $this->getSpawn()->z); | |
| if($t->distance($s) <= $distance){ //set it to cancelled so plugins can bypass this | |
| $ev->setCancelled(); | |
| } | |
| } | |
| $this->server->getPluginManager()->callEvent($ev); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| } | |
| if($hand->place($item, $block, $target, $face, $fx, $fy, $fz, $player) === false){ | |
| return false; | |
| } | |
| if($hand->getID() === Item::SIGN_POST or $hand->getID() === Item::WALL_SIGN){ | |
| $tile = new Sign($this, new Compound(false, array( | |
| new String("id", Tile::SIGN), | |
| new Int("x", $block->x), | |
| new Int("y", $block->y), | |
| new Int("z", $block->z), | |
| new String("Text1", ""), | |
| new String("Text2", ""), | |
| new String("Text3", ""), | |
| new String("Text4", "") | |
| ))); | |
| if($player instanceof Player){ | |
| $tile->namedtag->creator = new String("creator", $player->getName()); | |
| } | |
| } | |
| $item->setCount($item->getCount() - 1); | |
| if($item->getCount() <= 0){ | |
| $item = Item::get(Item::AIR, 0, 0); | |
| } | |
| return true; | |
| } | |
| /** | |
| * Gets the biome ID of a column | |
| * | |
| * @param int $x | |
| * @param int $z | |
| * | |
| * @return int | |
| */ | |
| public function getBiome($x, $z){ | |
| return $this->level->getBiome((int) $x, (int) $z); | |
| } | |
| /** | |
| * Sets the biome ID for a column | |
| * | |
| * @param int $x | |
| * @param int $z | |
| * @param int $biome | |
| * | |
| * @return int | |
| */ | |
| public function setBiome($x, $z, $biome){ | |
| return $this->level->getBiome((int) $x, (int) $z, $biome); | |
| } | |
| /** | |
| * Gets the list of all the entitites in this level | |
| * | |
| * @return Entity[] | |
| */ | |
| public function getEntities(){ | |
| return $this->entities; | |
| } | |
| /** | |
| * Returns a list of the Tile entities in this level | |
| * | |
| * @return Tile[] | |
| */ | |
| public function getTiles(){ | |
| return $this->tiles; | |
| } | |
| /** | |
| * Returns a list of the players in this level | |
| * | |
| * @return Player[] | |
| */ | |
| public function getPlayers(){ | |
| return $this->players; | |
| } | |
| /** | |
| * Returns the Tile in a position, or false if not found | |
| * | |
| * @param Vector3 $pos | |
| * | |
| * @return bool|Tile | |
| */ | |
| public function getTile(Vector3 $pos){ | |
| if($pos instanceof Position and $pos->level !== $this){ | |
| return false; | |
| } | |
| $tiles = $this->getChunkTiles($pos->x >> 4, $pos->z >> 4); | |
| if(count($tiles) > 0){ | |
| foreach($tiles as $tile){ | |
| if($tile->x === (int) $pos->x and $tile->y === (int) $pos->y and $tile->z === (int) $pos->z){ | |
| return $tile; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * Gets a raw minichunk | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * @param int $Y | |
| * | |
| * @return string | |
| */ | |
| public function getMiniChunk($X, $Z, $Y){ | |
| return $this->level->getMiniChunk($X, $Z, $Y); | |
| } | |
| /** | |
| * Sets a raw minichunk | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * @param int $Y | |
| * @param string $data (must be 4096 bytes) | |
| * | |
| * @return bool | |
| */ | |
| public function setMiniChunk($X, $Z, $Y, $data){ | |
| $this->changedCount[$X . ":" . $Y . ":" . $Z] = 4096; | |
| if(ADVANCED_CACHE == true){ | |
| Cache::remove("world:{$this->name}:$X:$Z"); | |
| } | |
| return $this->level->setMiniChunk($X, $Z, $Y, $data); | |
| } | |
| /** | |
| * Returns a list of the entities on a given chunk | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return Entity[] | |
| */ | |
| public function getChunkEntities($X, $Z){ | |
| $index = LevelFormat::getIndex($X, $Z); | |
| if(isset($this->usedChunks[$index]) or $this->loadChunk($X, $Z) === true){ | |
| return $this->chunkEntities[$index]; | |
| } | |
| return array(); | |
| } | |
| /** | |
| * Gives a list of the Tile entities on a given chunk | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return Tile[] | |
| */ | |
| public function getChunkTiles($X, $Z){ | |
| $index = LevelFormat::getIndex($X, $Z); | |
| if(isset($this->usedChunks[$index]) or $this->loadChunk($X, $Z) === true){ | |
| return $this->chunkTiles[$index]; | |
| } | |
| return array(); | |
| } | |
| /** | |
| * Loads a chunk | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return bool | |
| */ | |
| public function loadChunk($X, $Z){ | |
| $index = LevelFormat::getIndex($X, $Z); | |
| if(isset($this->usedChunks[$index])){ | |
| return true; | |
| }elseif($this->level->loadChunk($X, $Z) !== false){ | |
| $this->usedChunks[$index] = array(); | |
| $this->chunkTiles[$index] = array(); | |
| $this->chunkEntities[$index] = array(); | |
| $tags = $this->level->getChunkNBT($X, $Z); | |
| if(isset($tags->Entities)){ | |
| foreach($tags->Entities as $nbt){ | |
| if(!isset($nbt["id"])){ | |
| continue; | |
| } | |
| switch($nbt["id"]){ | |
| //TODO: spawn entities | |
| } | |
| } | |
| } | |
| if(isset($tags->TileEntities)){ | |
| foreach($tags->TileEntities as $nbt){ | |
| switch($nbt["id"]){ | |
| case Tile::CHEST: | |
| new Chest($this, $nbt); | |
| break; | |
| case Tile::FURNACE: | |
| new Furnace($this, $nbt); | |
| break; | |
| case Tile::SIGN: | |
| new Sign($this, $nbt); | |
| break; | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| return false; | |
| } | |
| /** | |
| * Unloads a chunk | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * @param bool $force | |
| * | |
| * @return bool | |
| */ | |
| public function unloadChunk($X, $Z, $force = false){ | |
| if(!isset($this->level)){ | |
| return false; | |
| } | |
| if($force !== true and $this->isSpawnChunk($X, $Z)){ | |
| return false; | |
| } | |
| $index = LevelFormat::getIndex($X, $Z); | |
| unset($this->usedChunks[$index]); | |
| unset($this->chunkEntities[$index]); | |
| unset($this->chunkTiles[$index]); | |
| Cache::remove("world:{$this->name}:$X:$Z"); | |
| return $this->level->unloadChunk($X, $Z, $this->getAutoSave()); | |
| } | |
| /** | |
| * Returns true if the spawn is part of the spawn | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * | |
| * @return bool | |
| */ | |
| public function isSpawnChunk($X, $Z){ | |
| $spawnX = $this->level->getData("spawnX") >> 4; | |
| $spawnZ = $this->level->getData("spawnZ") >> 4; | |
| return abs($X - $spawnX) <= 1 and abs($Z - $spawnZ) <= 1; | |
| } | |
| /** | |
| * Gets a full chunk or parts of it for networking usage, allows cache usage | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * @param int $Yndex bitmap of chunks to be returned | |
| * | |
| * @return bool|mixed|string | |
| */ | |
| public function getOrderedChunk($X, $Z, $Yndex){ | |
| if(!isset($this->level)){ | |
| return false; | |
| } | |
| if(ADVANCED_CACHE == true and $Yndex === 0xff){ | |
| $identifier = "world:{$this->name}:" . LevelFormat::getIndex($X, $Z); | |
| if(($cache = Cache::get($identifier)) !== false){ | |
| return $cache; | |
| } | |
| } | |
| $raw = array(); | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| if(($Yndex & (1 << $Y)) !== 0){ | |
| $raw[$Y] = $this->level->getMiniChunk($X, $Z, $Y); | |
| } | |
| } | |
| $ordered = ""; | |
| $flag = chr($Yndex); | |
| for($j = 0; $j < 256; ++$j){ | |
| $ordered .= $flag; | |
| foreach($raw as $mini){ | |
| $ordered .= substr($mini, $j << 5, 24); //16 + 8 | |
| } | |
| } | |
| if(ADVANCED_CACHE == true and $Yndex == 0xff){ | |
| Cache::add($identifier, $ordered, 60); | |
| } | |
| return $ordered; | |
| } | |
| /** | |
| * Returns the network minichunk for a given Y | |
| * | |
| * @param int $X | |
| * @param int $Z | |
| * @param int $Y | |
| * | |
| * @return bool|string | |
| */ | |
| public function getOrderedMiniChunk($X, $Z, $Y){ | |
| if(!isset($this->level)){ | |
| return false; | |
| } | |
| $raw = $this->level->getMiniChunk($X, $Z, $Y); | |
| $ordered = ""; | |
| $flag = chr(1 << $Y); | |
| for($j = 0; $j < 256; ++$j){ | |
| $ordered .= $flag . substr($raw, $j << 5, 24); //16 + 8 | |
| } | |
| return $ordered; | |
| } | |
| /** | |
| * Returns the raw spawnpoint | |
| * | |
| * @return Position | |
| */ | |
| public function getSpawn(){ | |
| return new Position($this->level->getData("spawnX"), $this->level->getData("spawnY"), $this->level->getData("spawnZ"), $this); | |
| } | |
| /** | |
| * @param Vector3 $spawn default null | |
| * | |
| * @return bool|Position | |
| */ | |
| public function getSafeSpawn($spawn = null){ | |
| if(!($spawn instanceof Vector3)){ | |
| $spawn = $this->getSpawn(); | |
| } | |
| if($spawn instanceof Vector3){ | |
| $x = (int) round($spawn->x); | |
| $y = (int) round($spawn->y); | |
| $z = (int) round($spawn->z); | |
| for(; $y > 0; --$y){ | |
| $v = new Vector3($x, $y, $z); | |
| $b = $this->getBlock($v->getSide(0)); | |
| if($b === false){ | |
| return $spawn; | |
| }elseif(!($b instanceof Air)){ | |
| break; | |
| } | |
| } | |
| for(; $y < 128; ++$y){ | |
| $v = new Vector3($x, $y, $z); | |
| if($this->getBlock($v->getSide(1)) instanceof Air){ | |
| if($this->getBlock($v) instanceof Air){ | |
| return new Position($x, $y, $z, $this); | |
| } | |
| }else{ | |
| ++$y; | |
| } | |
| } | |
| return new Position($x, $y, $z, $this); | |
| } | |
| return false; | |
| } | |
| /** | |
| * Sets the spawnpoint | |
| * | |
| * @param Vector3 $pos | |
| */ | |
| public function setSpawn(Vector3 $pos){ | |
| $this->level->setData("spawnX", $pos->x); | |
| $this->level->setData("spawnY", $pos->y); | |
| $this->level->setData("spawnZ", $pos->z); | |
| } | |
| /** | |
| * Gets the current time | |
| * | |
| * @return int | |
| */ | |
| public function getTime(){ | |
| return (int) $this->time; | |
| } | |
| /** | |
| * Returns the Level name | |
| * | |
| * @return string | |
| */ | |
| public function getName(){ | |
| return $this->name; //return $this->level->getData("name"); | |
| } | |
| /** | |
| * Sets the current time on the level | |
| * | |
| * @param int $time | |
| */ | |
| public function setTime($time){ | |
| $this->startTime = $this->time = (int) $time; | |
| $this->startCheck = microtime(true); | |
| $this->checkTime(); | |
| } | |
| /** | |
| * Stops the time for the level, will not save the lock state to disk | |
| */ | |
| public function stopTime(){ | |
| $this->stopTime = true; | |
| $this->startCheck = 0; | |
| $this->checkTime(); | |
| } | |
| /** | |
| * Start the time again, if it was stopped | |
| */ | |
| public function startTime(){ | |
| $this->stopTime = false; | |
| $this->startCheck = microtime(true); | |
| $this->checkTime(); | |
| } | |
| /** | |
| * Gets the level seed | |
| * | |
| * @return int | |
| */ | |
| public function getSeed(){ | |
| return (int) $this->level->getData("seed"); | |
| } | |
| /** | |
| * Sets the seed for the level | |
| * | |
| * @param int $seed | |
| */ | |
| public function setSeed($seed){ | |
| $this->level->setData("seed", (int) $seed); | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level; | |
| use pocketmine\level\format\PocketChunkParser; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\level\format\pmf\LevelFormat; | |
| use pocketmine\utils\Config; | |
| class LevelImport{ | |
| private $path; | |
| public function __construct($path){ | |
| $this->path = $path; | |
| } | |
| public function import(){ | |
| if(file_exists($this->path . "tileEntities.dat")){ //OldPM | |
| $level = unserialize(file_get_contents($this->path . "level.dat")); | |
| console("[INFO] Importing OldPM level \"" . $level["LevelName"] . "\" to PMF format"); | |
| $entities = new Config($this->path . "entities.yml", Config::YAML, unserialize(file_get_contents($this->path . "entities.dat"))); | |
| $entities->save(); | |
| $tiles = new Config($this->path . "tiles.yml", Config::YAML, unserialize(file_get_contents($this->path . "tileEntities.dat"))); | |
| $tiles->save(); | |
| }elseif(file_exists($this->path . "chunks.dat") and file_exists($this->path . "level.dat")){ //Pocket | |
| $nbt = new NBT(NBT::LITTLE_ENDIAN); | |
| $nbt->read(substr(file_get_contents($this->path . "level.dat"), 8)); | |
| $level = $nbt->getData(); | |
| if($level["LevelName"] == ""){ | |
| $level["LevelName"] = "world" . time(); | |
| } | |
| console("[INFO] Importing Pocket level \"" . $level->LevelName . "\" to PMF format"); | |
| unset($level->Player); | |
| $nbt->read(substr(file_get_contents($this->path . "entities.dat"), 12)); | |
| $entities = $nbt->getData(); | |
| if(!isset($entities->TileEntities)){ | |
| $entities->TileEntities = array(); | |
| } | |
| $tiles = $entities->TileEntities; | |
| $entities = $entities->Entities; | |
| $entities = new Config($this->path . "entities.yml", Config::YAML, $entities); | |
| $entities->save(); | |
| $tiles = new Config($this->path . "tiles.yml", Config::YAML, $tiles); | |
| $tiles->save(); | |
| }else{ | |
| return false; | |
| } | |
| $pmf = new LevelFormat($this->path . "level.pmf", array( | |
| "name" => $level->LevelName, | |
| "seed" => $level->RandomSeed, | |
| "time" => $level->Time, | |
| "spawnX" => $level->SpawnX, | |
| "spawnY" => $level->SpawnY, | |
| "spawnZ" => $level->SpawnZ, | |
| "height" => 8, | |
| "generator" => "default", | |
| "generatorSettings" => "", | |
| "extra" => "" | |
| )); | |
| $chunks = new PocketChunkParser(); | |
| $chunks->loadFile($this->path . "chunks.dat"); | |
| $chunks->loadMap(); | |
| for($Z = 0; $Z < 16; ++$Z){ | |
| for($X = 0; $X < 16; ++$X){ | |
| $chunk = array( | |
| 0 => "", | |
| 1 => "", | |
| 2 => "", | |
| 3 => "", | |
| 4 => "", | |
| 5 => "", | |
| 6 => "", | |
| 7 => "" | |
| ); | |
| $pmf->initCleanChunk($X, $Z); | |
| for($z = 0; $z < 16; ++$z){ | |
| for($x = 0; $x < 16; ++$x){ | |
| $block = $chunks->getChunkColumn($X, $Z, $x, $z, 0); | |
| $meta = $chunks->getChunkColumn($X, $Z, $x, $z, 1); | |
| for($Y = 0; $Y < 8; ++$Y){ | |
| $chunk[$Y] .= substr($block, $Y << 4, 16); | |
| $chunk[$Y] .= substr($meta, $Y << 3, 8); | |
| $chunk[$Y] .= "\x00\x00\x00\x00\x00\x00\x00\x00"; | |
| } | |
| } | |
| } | |
| foreach($chunk as $Y => $data){ | |
| $pmf->setMiniChunk($X, $Z, $Y, $data); | |
| } | |
| $pmf->setPopulated($X, $Z); | |
| $pmf->saveChunk($X, $Z); | |
| } | |
| console("[NOTICE] Importing level " . ceil(($Z + 1) / 0.16) . "%"); | |
| } | |
| $chunks->map = null; | |
| $chunks = null; | |
| @unlink($this->path . "level.dat"); | |
| @unlink($this->path . "level.dat_old"); | |
| @unlink($this->path . "player.dat"); | |
| @unlink($this->path . "entities.dat"); | |
| @unlink($this->path . "chunks.dat"); | |
| @unlink($this->path . "chunks.dat.gz"); | |
| @unlink($this->path . "tiles.dat"); | |
| unset($chunks, $level, $entities, $tiles, $nbt); | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level; | |
| use pocketmine\math\Vector3 as Vector3; | |
| class Position extends Vector3{ | |
| /** @var Level */ | |
| public $level = null; | |
| /** | |
| * @param int $x | |
| * @param int $y | |
| * @param int $z | |
| * @param Level $level | |
| */ | |
| public function __construct($x = 0, $y = 0, $z = 0, Level $level){ | |
| $this->x = $x; | |
| $this->y = $y; | |
| $this->z = $z; | |
| $this->level = $level; | |
| } | |
| public static function fromObject(Vector3 $pos, Level $level){ | |
| return new Position($pos->x, $pos->y, $pos->z, $level); | |
| } | |
| /** | |
| * Returns a side Vector | |
| * | |
| * @param int $side | |
| * @param int $step | |
| * | |
| * @return Position | |
| */ | |
| public function getSide($side, $step = 1){ | |
| return Position::fromObject(parent::getSide($side, $step), $this->level); | |
| } | |
| /** | |
| * Returns the distance between two points or objects | |
| * | |
| * @param Vector3 $pos | |
| * | |
| * @return float | |
| */ | |
| public function distance(Vector3 $pos){ | |
| if(($pos instanceof Position) and $pos->level !== $this->level){ | |
| return PHP_INT_MAX; | |
| } | |
| return parent::distance($pos); | |
| } | |
| public function __toString(){ | |
| return "Position(level=" . $this->level->getName() . ",x=" . $this->x . ",y=" . $this->y . ",z=" . $this->z . ")"; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\level; | |
| use pocketmine\level\generator\Generator; | |
| use pocketmine\level\format\pmf\LevelFormat; | |
| use pocketmine\Server; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Random; | |
| use pocketmine\utils\Utils; | |
| class WorldGenerator{ | |
| private $seed, $level, $path, $random, $generator, $server; | |
| /** | |
| * @param Server $server | |
| * @param Generator $generator | |
| * @param string $name | |
| * @param int $seed | |
| */ | |
| public function __construct(Server $server, Generator $generator, $name, $seed = null){ | |
| $this->seed = $seed !== null ? (int) $seed : Binary::readInt(Utils::getRandomBytes(4, false)); | |
| $this->random = new Random($this->seed); | |
| $this->server = $server; | |
| $this->path = $this->server->getDataPath() . "worlds/" . $name . "/"; | |
| $this->generator = $generator; | |
| $level = new LevelFormat($this->path . "level.pmf", array( | |
| "name" => $name, | |
| "seed" => $this->seed, | |
| "time" => 0, | |
| "spawnX" => 128, | |
| "spawnY" => 128, | |
| "spawnZ" => 128, | |
| "height" => 8, | |
| "generator" => $this->generator->getName(), | |
| "generatorSettings" => $this->generator->getSettings(), | |
| "extra" => "" | |
| )); | |
| $this->level = new Level($this->server, $level, $name); | |
| } | |
| public function generate(){ | |
| $this->generator->init($this->level, $this->random); | |
| for($Z = 7; $Z <= 9; ++$Z){ | |
| for($X = 7; $X <= 9; ++$X){ | |
| $this->level->level->loadChunk($X, $Z); | |
| } | |
| } | |
| $this->level->setSpawn($this->generator->getSpawn()); | |
| } | |
| public function close(){ | |
| $this->level->close(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\math; | |
| /** | |
| * WARNING: This class is available on the PocketMine-MP Zephir project. | |
| * If this class is modified, remember to modify the PHP C extension. | |
| */ | |
| class AxisAlignedBB{ | |
| public $minX; | |
| public $minY; | |
| public $minZ; | |
| public $maxX; | |
| public $maxY; | |
| public $maxZ; | |
| public function __construct($minX, $minY, $minZ, $maxX, $maxY, $maxZ){ | |
| $this->minX = $minX; | |
| $this->minY = $minY; | |
| $this->minZ = $minZ; | |
| $this->maxX = $maxX; | |
| $this->maxY = $maxY; | |
| $this->maxZ = $maxZ; | |
| } | |
| public function setBounds($minX, $minY, $minZ, $maxX, $maxY, $maxZ){ | |
| $this->minX = $minX; | |
| $this->minY = $minY; | |
| $this->minZ = $minZ; | |
| $this->maxX = $maxX; | |
| $this->maxY = $maxY; | |
| $this->maxZ = $maxZ; | |
| return $this; | |
| } | |
| public function addCoord($x, $y, $z){ | |
| $vec = clone $this; | |
| if($x < 0){ | |
| $vec->minX += $x; | |
| }elseif($x > 0){ | |
| $vec->maxX += $x; | |
| } | |
| if($y < 0){ | |
| $vec->minY += $y; | |
| }elseif($y > 0){ | |
| $vec->maxY += $y; | |
| } | |
| if($z < 0){ | |
| $vec->minZ += $z; | |
| }elseif($z > 0){ | |
| $vec->maxZ += $z; | |
| } | |
| return $vec; | |
| } | |
| public function expand($x, $y, $z){ | |
| $vec = clone $this; | |
| $vec->minX -= $x; | |
| $vec->minY -= $y; | |
| $vec->minZ -= $z; | |
| $vec->maxX += $x; | |
| $vec->maxY += $y; | |
| $vec->maxZ += $z; | |
| return $vec; | |
| } | |
| public function offset($x, $y, $z){ | |
| $vec = clone $this; | |
| $vec->minX += $x; | |
| $vec->minY += $y; | |
| $vec->minZ += $z; | |
| $vec->maxX += $x; | |
| $vec->maxY += $y; | |
| $vec->maxZ += $z; | |
| return $vec; | |
| } | |
| public function contract($x, $y, $z){ | |
| $vec = clone $this; | |
| $vec->minX += $x; | |
| $vec->minY += $y; | |
| $vec->minZ += $z; | |
| $vec->maxX -= $x; | |
| $vec->maxY -= $y; | |
| $vec->maxZ -= $z; | |
| return $vec; | |
| } | |
| public function setBB(AxisAlignedBB $bb){ | |
| return new AxisAlignedBB( | |
| min($this->minX, $bb->minX), | |
| min($this->minY, $bb->minY), | |
| min($this->minZ, $bb->minZ), | |
| max($this->maxX, $bb->maxX), | |
| max($this->maxY, $bb->maxY), | |
| max($this->maxZ, $bb->maxZ) | |
| ); | |
| } | |
| public function getOffsetBoundingBox($x, $y, $z){ | |
| return new AxisAlignedBB($this->minX + $x, $this->minY + $y, $this->minZ + $z, $this->maxX + $x, $this->maxY + $y, $this->maxZ + $z); | |
| } | |
| public function calculateXOffset(AxisAlignedBB $bb, $x){ | |
| if($bb->maxY <= $this->minY or $bb->minY >= $this->maxY){ | |
| return $x; | |
| } | |
| if($bb->maxZ <= $this->minZ or $bb->minZ >= $this->maxZ){ | |
| return $x; | |
| } | |
| if($x > 0 and $bb->maxX <= $this->minX){ | |
| $x1 = $this->minX - $bb->maxX; | |
| if($x1 < $x){ | |
| $x = $x1; | |
| } | |
| } | |
| if($x < 0 and $bb->minX >= $this->maxX){ | |
| $x2 = $this->maxX - $bb->minX; | |
| if($x2 > $x){ | |
| $x = $x2; | |
| } | |
| } | |
| return $x; | |
| } | |
| public function calculateYOffset(AxisAlignedBB $bb, $y){ | |
| if($bb->maxX <= $this->minX or $bb->minX >= $this->maxX){ | |
| return $y; | |
| } | |
| if($bb->maxZ <= $this->minZ or $bb->minZ >= $this->maxZ){ | |
| return $y; | |
| } | |
| if($y > 0 and $bb->maxY <= $this->minY){ | |
| $y1 = $this->minY - $bb->maxY; | |
| if($y1 < $y){ | |
| $y = $y1; | |
| } | |
| } | |
| if($y < 0 and $bb->minY >= $this->maxY){ | |
| $y2 = $this->maxY - $bb->minY; | |
| if($y2 > $y){ | |
| $y = $y2; | |
| } | |
| } | |
| return $y; | |
| } | |
| public function calculateZOffset(AxisAlignedBB $bb, $z){ | |
| if($bb->maxX <= $this->minX or $bb->minX >= $this->maxX){ | |
| return $z; | |
| } | |
| if($bb->maxY <= $this->minY or $bb->minY >= $this->maxY){ | |
| return $z; | |
| } | |
| if($z > 0 and $bb->maxZ <= $this->minZ){ | |
| $z1 = $this->minZ - $bb->maxZ; | |
| if($z1 < $z){ | |
| $z = $z1; | |
| } | |
| } | |
| if($z < 0 and $bb->minZ >= $this->maxZ){ | |
| $z2 = $this->maxZ - $bb->minZ; | |
| if($z2 > $z){ | |
| $z = $z2; | |
| } | |
| } | |
| return $z; | |
| } | |
| public function intersectsWith(AxisAlignedBB $bb){ | |
| if($bb->maxX <= $this->minX or $bb->minX >= $this->maxX){ | |
| return false; | |
| } | |
| if($bb->maxY <= $this->minY or $bb->minY >= $this->maxY){ | |
| return false; | |
| } | |
| return $bb->maxZ > $this->minZ and $bb->minZ < $this->maxZ; | |
| } | |
| public function isVectorInside(Vector3 $vector){ | |
| if($vector->x <= $this->minX or $vector->x >= $this->maxX){ | |
| return false; | |
| } | |
| if($vector->y <= $this->minY or $vector->y >= $this->maxY){ | |
| return false; | |
| } | |
| return $vector->z > $this->minZ and $vector->z < $this->maxZ; | |
| } | |
| public function getAverageEdgeLength(){ | |
| return ($this->maxX - $this->minX + $this->maxY - $this->minY + $this->maxZ - $this->minZ) / 3; | |
| } | |
| public function isVectorInYZ(Vector3 $vector){ | |
| return $vector->y >= $this->minY and $vector->y <= $this->maxY and $vector->z >= $this->minZ and $vector->z <= $this->maxZ; | |
| } | |
| public function isVectorInXZ(Vector3 $vector){ | |
| return $vector->x >= $this->minX and $vector->x <= $this->maxX and $vector->z >= $this->minZ and $vector->z <= $this->maxZ; | |
| } | |
| public function isVectorInXY(Vector3 $vector){ | |
| return $vector->x >= $this->minX and $vector->x <= $this->maxX and $vector->y >= $this->minY and $vector->y <= $this->maxY; | |
| } | |
| /* | |
| public function calculateIntercept(...){ | |
| } | |
| */ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Math related classes, like matrices, bounding boxes and vector | |
| */ | |
| namespace pocketmine\math; | |
| abstract class Math{ | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\math; | |
| class Matrix implements \ArrayAccess{ | |
| private $matrix = array(); | |
| private $rows = 0; | |
| private $columns = 0; | |
| public function offsetExists($offset){ | |
| return isset($this->matrix[(int) $offset]); | |
| } | |
| public function offsetGet($offset){ | |
| return $this->matrix[(int) $offset]; | |
| } | |
| public function offsetSet($offset, $value){ | |
| $this->matrix[(int) $offset] = $value; | |
| } | |
| public function offsetUnset($offset){ | |
| unset($this->matrix[(int) $offset]); | |
| } | |
| public function __construct($rows, $columns, array $set = array()){ | |
| $this->rows = max(1, (int) $rows); | |
| $this->columns = max(1, (int) $columns); | |
| $this->set($set); | |
| } | |
| public function set(array $m){ | |
| for($r = 0; $r < $this->rows; ++$r){ | |
| $this->matrix[$r] = array(); | |
| for($c = 0; $c < $this->columns; ++$c){ | |
| $this->matrix[$r][$c] = isset($m[$r][$c]) ? $m[$r][$c] : 0; | |
| } | |
| } | |
| } | |
| public function getRows(){ | |
| return ($this->rows); | |
| } | |
| public function getColumns(){ | |
| return ($this->columns); | |
| } | |
| public function setElement($row, $column, $value){ | |
| if($row > $this->rows or $row < 0 or $column > $this->columns or $column < 0){ | |
| return false; | |
| } | |
| $this->matrix[(int) $row][(int) $column] = $value; | |
| return true; | |
| } | |
| public function getElement($row, $column){ | |
| if($row > $this->rows or $row < 0 or $column > $this->columns or $column < 0){ | |
| return false; | |
| } | |
| return $this->matrix[(int) $row][(int) $column]; | |
| } | |
| public function isSquare(){ | |
| return $this->rows === $this->columns; | |
| } | |
| public function add(Matrix $matrix){ | |
| if($this->rows !== $matrix->getRows() or $this->columns !== $matrix->getColumns()){ | |
| return false; | |
| } | |
| $result = new Matrix($this->rows, $this->columns); | |
| for($r = 0; $r < $this->rows; ++$r){ | |
| for($c = 0; $c < $this->columns; ++$c){ | |
| $result->setElement($r, $c, $this->matrix[$r][$c] + $matrix->getElement($r, $c)); | |
| } | |
| } | |
| return $result; | |
| } | |
| public function substract(Matrix $matrix){ | |
| if($this->rows !== $matrix->getRows() or $this->columns !== $matrix->getColumns()){ | |
| return false; | |
| } | |
| $result = clone $this; | |
| for($r = 0; $r < $this->rows; ++$r){ | |
| for($c = 0; $c < $this->columns; ++$c){ | |
| $result->setElement($r, $c, $this->matrix[$r][$c] - $matrix->getElement($r, $c)); | |
| } | |
| } | |
| return $result; | |
| } | |
| public function multiplyScalar($number){ | |
| $result = clone $this; | |
| for($r = 0; $r < $this->rows; ++$r){ | |
| for($c = 0; $c < $this->columns; ++$c){ | |
| $result->setElement($r, $c, $this->matrix[$r][$c] * $number); | |
| } | |
| } | |
| return $result; | |
| } | |
| public function divideScalar($number){ | |
| $result = clone $this; | |
| for($r = 0; $r < $this->rows; ++$r){ | |
| for($c = 0; $c < $this->columns; ++$c){ | |
| $result->setElement($r, $c, $this->matrix[$r][$c] / $number); | |
| } | |
| } | |
| return $result; | |
| } | |
| public function transpose(){ | |
| $result = new Matrix($this->columns, $this->rows); | |
| for($r = 0; $r < $this->rows; ++$r){ | |
| for($c = 0; $c < $this->columns; ++$c){ | |
| $result->setElement($c, $r, $this->matrix[$r][$c]); | |
| } | |
| } | |
| return $result; | |
| } | |
| //Naive Matrix product, O(n^3) | |
| public function product(Matrix $matrix){ | |
| if($this->columns !== $matrix->getRows()){ | |
| return false; | |
| } | |
| $c = $matrix->getColumns(); | |
| $result = new Matrix($this->rows, $c); | |
| for($i = 0; $i < $this->rows; ++$i){ | |
| for($j = 0; $j < $c; ++$j){ | |
| $sum = 0; | |
| for($k = 0; $k < $this->columns; ++$k){ | |
| $sum += $this->matrix[$i][$k] * $matrix->getElement($k, $j); | |
| } | |
| $result->setElement($i, $j, $sum); | |
| } | |
| } | |
| return $result; | |
| } | |
| //Computation of the determinant of 2x2 and 3x3 matrices | |
| public function determinant(){ | |
| if($this->isSquare() !== true){ | |
| return false; | |
| } | |
| switch($this->rows){ | |
| case 1: | |
| return 0; | |
| case 2: | |
| return $this->matrix[0][0] * $this->matrix[1][1] - $this->matrix[0][1] * $this->matrix[1][0]; | |
| case 3: | |
| return $this->matrix[0][0] * $this->matrix[1][1] * $this->matrix[2][2] + $this->matrix[0][1] * $this->matrix[1][2] * $this->matrix[2][0] + $this->matrix[0][2] * $this->matrix[1][0] * $this->matrix[2][1] - $this->matrix[2][0] * $this->matrix[1][1] * $this->matrix[0][2] - $this->matrix[2][1] * $this->matrix[1][2] * $this->matrix[0][0] - $this->matrix[2][2] * $this->matrix[1][0] * $this->matrix[0][1]; | |
| } | |
| return false; | |
| } | |
| public function __toString(){ | |
| $s = ""; | |
| for($r = 0; $r < $this->rows; ++$r){ | |
| $s .= implode(",", $this->matrix[$r]) . ";"; | |
| } | |
| return "Matrix({$this->rows}x{$this->columns};" . substr($s, 0, -1) . ")"; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\math; | |
| /** | |
| * WARNING: This class is available on the PocketMine-MP Zephir project. | |
| * If this class is modified, remember to modify the PHP C extension. | |
| */ | |
| class Vector2{ | |
| public $x; | |
| public $y; | |
| public function __construct($x = 0, $y = 0){ | |
| $this->x = $x; | |
| $this->y = $y; | |
| } | |
| public function getX(){ | |
| return $this->x; | |
| } | |
| public function getY(){ | |
| return $this->y; | |
| } | |
| public function getFloorX(){ | |
| return (int) $this->x; | |
| } | |
| public function getFloorY(){ | |
| return (int) $this->y; | |
| } | |
| public function add($x, $y = 0){ | |
| if($x instanceof Vector2){ | |
| return $this->add($x->x, $x->y); | |
| }else{ | |
| return new Vector2($this->x + $x, $this->y + $y); | |
| } | |
| } | |
| public function subtract($x, $y = 0){ | |
| if($x instanceof Vector2){ | |
| return $this->add(-$x->x, -$x->y); | |
| }else{ | |
| return $this->add(-$x, -$y); | |
| } | |
| } | |
| public function ceil(){ | |
| return new Vector2((int) ($this->x + 1), (int) ($this->y + 1)); | |
| } | |
| public function floor(){ | |
| return new Vector2((int) $this->x, (int) $this->y); | |
| } | |
| public function round(){ | |
| return new Vector2(round($this->x), round($this->y)); | |
| } | |
| public function abs(){ | |
| return new Vector2(abs($this->x), abs($this->y)); | |
| } | |
| public function multiply($number){ | |
| return new Vector2($this->x * $number, $this->y * $number); | |
| } | |
| public function divide($number){ | |
| return new Vector2($this->x / $number, $this->y / $number); | |
| } | |
| public function distance($x, $y = 0){ | |
| if($x instanceof Vector2){ | |
| return sqrt($this->distanceSquared($x->x, $x->y)); | |
| }else{ | |
| return sqrt($this->distanceSquared($x, $y)); | |
| } | |
| } | |
| public function distanceSquared($x, $y = 0){ | |
| if($x instanceof Vector2){ | |
| return $this->distanceSquared($x->x, $x->y); | |
| }else{ | |
| return pow($this->x - $x, 2) + pow($this->y - $y, 2); | |
| } | |
| } | |
| public function length(){ | |
| return sqrt($this->lengthSquared()); | |
| } | |
| public function lengthSquared(){ | |
| return $this->x * $this->x + $this->y * $this->y; | |
| } | |
| public function normalize(){ | |
| $len = $this->length(); | |
| if($len != 0){ | |
| return $this->divide($len); | |
| } | |
| return new Vector2(0, 0); | |
| } | |
| public function dot(Vector2 $v){ | |
| return $this->x * $v->x + $this->y * $v->y; | |
| } | |
| public function __toString(){ | |
| return "Vector2(x=" . $this->x . ",y=" . $this->y . ")"; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\math; | |
| /** | |
| * WARNING: This class is available on the PocketMine-MP Zephir project. | |
| * If this class is modified, remember to modify the PHP C extension. | |
| */ | |
| class Vector3{ | |
| public $x; | |
| public $y; | |
| public $z; | |
| public function __construct($x = 0, $y = 0, $z = 0){ | |
| $this->x = $x; | |
| $this->y = $y; | |
| $this->z = $z; | |
| } | |
| public function getX(){ | |
| return $this->x; | |
| } | |
| public function getY(){ | |
| return $this->y; | |
| } | |
| public function getZ(){ | |
| return $this->z; | |
| } | |
| public function getFloorX(){ | |
| return (int) $this->x; | |
| } | |
| public function getFloorY(){ | |
| return (int) $this->y; | |
| } | |
| public function getFloorZ(){ | |
| return (int) $this->z; | |
| } | |
| public function getRight(){ | |
| return $this->x; | |
| } | |
| public function getUp(){ | |
| return $this->y; | |
| } | |
| public function getForward(){ | |
| return $this->z; | |
| } | |
| public function getSouth(){ | |
| return $this->x; | |
| } | |
| public function getWest(){ | |
| return $this->z; | |
| } | |
| public function add($x, $y = 0, $z = 0){ | |
| if($x instanceof Vector3){ | |
| return $this->add($x->x, $x->y, $x->z); | |
| }else{ | |
| return new Vector3($this->x + $x, $this->y + $y, $this->z + $z); | |
| } | |
| } | |
| public function subtract($x = 0, $y = 0, $z = 0){ | |
| if($x instanceof Vector3){ | |
| return $this->add(-$x->x, -$x->y, -$x->z); | |
| }else{ | |
| return $this->add(-$x, -$y, -$z); | |
| } | |
| } | |
| public function multiply($number){ | |
| return new Vector3($this->x * $number, $this->y * $number, $this->z * $number); | |
| } | |
| public function divide($number){ | |
| return new Vector3($this->x / $number, $this->y / $number, $this->z / $number); | |
| } | |
| public function ceil(){ | |
| return new Vector3((int) ($this->x + 1), (int) ($this->y + 1), (int) ($this->z + 1)); | |
| } | |
| public function floor(){ | |
| return new Vector3((int) $this->x, (int) $this->y, (int) $this->z); | |
| } | |
| public function round(){ | |
| return new Vector3(round($this->x), round($this->y), round($this->z)); | |
| } | |
| public function abs(){ | |
| return new Vector3(abs($this->x), abs($this->y), abs($this->z)); | |
| } | |
| public function getSide($side, $step = 1){ | |
| switch((int) $side){ | |
| case 0: | |
| return new Vector3($this->x, $this->y - (int) $step, $this->z); | |
| case 1: | |
| return new Vector3($this->x, $this->y + (int) $step, $this->z); | |
| case 2: | |
| return new Vector3($this->x, $this->y, $this->z - (int) $step); | |
| case 3: | |
| return new Vector3($this->x, $this->y, $this->z + (int) $step); | |
| case 4: | |
| return new Vector3($this->x - (int) $step, $this->y, $this->z); | |
| case 5: | |
| return new Vector3($this->x + (int) $step, $this->y, $this->z); | |
| default: | |
| return $this; | |
| } | |
| } | |
| public function distance(Vector3 $pos){ | |
| return sqrt($this->distanceSquared($pos)); | |
| } | |
| public function distanceSquared(Vector3 $pos){ | |
| return pow($this->x - $pos->x, 2) + pow($this->y - $pos->y, 2) + pow($this->z - $pos->z, 2); | |
| } | |
| public function maxPlainDistance($x = 0, $z = 0){ | |
| if($x instanceof Vector3){ | |
| return $this->maxPlainDistance($x->x, $x->z); | |
| }elseif($x instanceof Vector2){ | |
| return $this->maxPlainDistance($x->x, $x->y); | |
| }else{ | |
| return max(abs($this->x - $x), abs($this->z - $z)); | |
| } | |
| } | |
| public function length(){ | |
| return sqrt($this->lengthSquared()); | |
| } | |
| public function lengthSquared(){ | |
| return $this->x * $this->x + $this->y * $this->y + $this->z * $this->z; | |
| } | |
| public function normalize(){ | |
| $len = $this->length(); | |
| if($len != 0){ | |
| return $this->divide($len); | |
| } | |
| return new Vector3(0, 0, 0); | |
| } | |
| public function dot(Vector3 $v){ | |
| return $this->x * $v->x + $this->y * $v->y + $this->z * $v->z; | |
| } | |
| public function cross(Vector3 $v){ | |
| return new Vector3( | |
| $this->y * $v->z - $this->z * $v->y, | |
| $this->z * $v->x - $this->x * $v->z, | |
| $this->x * $v->y - $this->y * $v->x | |
| ); | |
| } | |
| public function __toString(){ | |
| return "Vector3(x=" . $this->x . ",y=" . $this->y . ",z=" . $this->z . ")"; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\math; | |
| abstract class VectorMath{ | |
| public static function getDirection2D($azimuth){ | |
| return new Vector2(cos($azimuth), sin($azimuth)); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Named Binary Tag handling classes | |
| */ | |
| namespace pocketmine\nbt; | |
| use pocketmine\nbt\tag\Byte; | |
| use pocketmine\nbt\tag\Byte_Array; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\nbt\tag\Double; | |
| use pocketmine\nbt\tag\End; | |
| use pocketmine\nbt\tag\Enum; | |
| use pocketmine\nbt\tag\Float; | |
| use pocketmine\nbt\tag\Int; | |
| use pocketmine\nbt\tag\Int_Array; | |
| use pocketmine\nbt\tag\Long; | |
| use pocketmine\nbt\tag\NamedTAG; | |
| use pocketmine\nbt\tag\Short; | |
| use pocketmine\nbt\tag\String; | |
| use pocketmine\nbt\tag\Tag; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| /** | |
| * Named Binary Tag encoder/decoder | |
| */ | |
| class NBT{ | |
| 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_Byte_Array = 7; | |
| const TAG_String = 8; | |
| const TAG_Enum = 9; | |
| const TAG_Compound = 10; | |
| const TAG_Int_Array = 11; | |
| private $buffer; | |
| private $offset; | |
| private $endianness; | |
| private $data; | |
| public function get($len){ | |
| if($len < 0){ | |
| $this->offset = strlen($this->buffer) - 1; | |
| return ""; | |
| }elseif($len === true){ | |
| return substr($this->buffer, $this->offset); | |
| } | |
| if($len > 1024){ | |
| return substr($this->buffer, ($this->offset += $len) - $len, $len); | |
| } | |
| $buffer = ""; | |
| for(; $len > 0; --$len, ++$this->offset){ | |
| $buffer .= @$this->buffer{$this->offset}; | |
| } | |
| return $buffer; | |
| } | |
| public function put($v){ | |
| $this->buffer .= $v; | |
| } | |
| public function feof(){ | |
| return !isset($this->buffer{$this->offset}); | |
| } | |
| public function __construct($endianness = self::LITTLE_ENDIAN){ | |
| $this->offset = 0; | |
| $this->endianness = $endianness & 0x01; | |
| } | |
| public function read($buffer){ | |
| $this->offset = 0; | |
| $this->buffer = $buffer; | |
| $this->data = $this->readTag(); | |
| $this->buffer = ""; | |
| } | |
| public function readCompressed($buffer){ | |
| $this->read(\gzdecode($buffer)); | |
| } | |
| public function write(){ | |
| $this->offset = 0; | |
| if($this->data instanceof Compound){ | |
| $this->writeTag($this->data); | |
| return $this->buffer; | |
| }else{ | |
| return false; | |
| } | |
| } | |
| public function writeCompressed(){ | |
| if(($write = $this->write()) !== false){ | |
| return \gzencode($write, 9); | |
| } | |
| return false; | |
| } | |
| public function readTag(){ | |
| switch($this->getByte()){ | |
| case NBT::TAG_Byte: | |
| $tag = new Byte($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Short: | |
| $tag = new Short($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Int: | |
| $tag = new Int($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Long: | |
| $tag = new Long($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Float: | |
| $tag = new Float($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Double: | |
| $tag = new Double($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Byte_Array: | |
| $tag = new Byte_Array($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_String: | |
| $tag = new String($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Enum: | |
| $tag = new Enum($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Compound: | |
| $tag = new Compound($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_Int_Array: | |
| $tag = new Int_Array($this->getString()); | |
| $tag->read($this); | |
| break; | |
| case NBT::TAG_End: //No named tag | |
| default: | |
| $tag = new End; | |
| break; | |
| } | |
| return $tag; | |
| } | |
| public function writeTag(Tag $tag){ | |
| $this->putByte($tag->getType()); | |
| if($tag instanceof NamedTAG){ | |
| $this->putString($tag->getName()); | |
| } | |
| $tag->write($this); | |
| } | |
| public function getByte($signed = false){ | |
| return Binary::readByte($this->get(1), $signed); | |
| } | |
| public function putByte($v){ | |
| $this->buffer .= Binary::writeByte($v); | |
| } | |
| public function getShort(){ | |
| return $this->endianness === self::BIG_ENDIAN ? Binary::readShort($this->get(2)) : Binary::readLShort($this->get(2)); | |
| } | |
| public function putShort($v){ | |
| $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeShort($v) : Binary::writeLShort($v); | |
| } | |
| public function getInt(){ | |
| return $this->endianness === self::BIG_ENDIAN ? Binary::readInt($this->get(4)) : Binary::readLInt($this->get(4)); | |
| } | |
| public function putInt($v){ | |
| $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeInt($v) : Binary::writeLInt($v); | |
| } | |
| public function getLong(){ | |
| return $this->endianness === self::BIG_ENDIAN ? Binary::readLong($this->get(8)) : Binary::readLLong($this->get(8)); | |
| } | |
| public function putLong($v){ | |
| $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeLong($v) : Binary::writeLLong($v); | |
| } | |
| public function getFloat(){ | |
| return $this->endianness === self::BIG_ENDIAN ? Binary::readFloat($this->get(4)) : Binary::readLFloat($this->get(4)); | |
| } | |
| public function putFloat($v){ | |
| $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeFloat($v) : Binary::writeLFloat($v); | |
| } | |
| public function getDouble(){ | |
| return $this->endianness === self::BIG_ENDIAN ? Binary::readDouble($this->get(8)) : Binary::readLDouble($this->get(8)); | |
| } | |
| public function putDouble($v){ | |
| $this->buffer .= $this->endianness === self::BIG_ENDIAN ? Binary::writeDouble($v) : Binary::writeLDouble($v); | |
| } | |
| public function getString(){ | |
| return $this->get($this->getShort()); | |
| } | |
| public function putString($v){ | |
| $this->putShort(strlen($v)); | |
| $this->buffer .= $v; | |
| } | |
| public function getData(){ | |
| return $this->data; | |
| } | |
| public function setData(Compound $data){ | |
| $this->data = $data; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Byte extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Byte; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->getByte(true); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putByte($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Byte_Array extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Byte_Array; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->get($nbt->getInt()); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putInt(strlen($this->value)); | |
| $nbt->put($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Compound extends NamedTag implements \ArrayAccess{ | |
| public function __construct($name = "", $value = array()){ | |
| $this->name = $name; | |
| foreach($value as $tag){ | |
| $this->{$tag->getName()} = $tag; | |
| } | |
| } | |
| public function offsetExists($offset){ | |
| return isset($this->{$offset}); | |
| } | |
| public function offsetGet($offset){ | |
| if($this->{$offset} instanceof Tag){ | |
| if($this->{$offset} instanceof \ArrayAccess){ | |
| return $this->{$offset}; | |
| }else{ | |
| return $this->{$offset}->getValue(); | |
| } | |
| } | |
| return null; | |
| } | |
| public function offsetSet($offset, $value){ | |
| if($value instanceof Tag){ | |
| $this->{$offset} = $value; | |
| }elseif(isset($this->{$offset}) and $this->{$offset} instanceof Tag){ | |
| $this->{$offset}->setValue($value); | |
| } | |
| } | |
| public function offsetUnset($offset){ | |
| unset($this->{$offset}); | |
| } | |
| public function getType(){ | |
| return NBT::TAG_Compound; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = array(); | |
| do{ | |
| $tag = $nbt->readTag(); | |
| if($tag instanceof NamedTag and $tag->getName() !== ""){ | |
| $this->{$tag->getName()} = $tag; | |
| } | |
| }while(!($tag instanceof End) and !$nbt->feof()); | |
| } | |
| public function write(NBT $nbt){ | |
| foreach($this as $tag){ | |
| if($tag instanceof Tag and !($tag instanceof End)){ | |
| $nbt->writeTag($tag); | |
| } | |
| } | |
| $nbt->writeTag(new End); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Double extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Double; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->getDouble(); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putDouble($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class End extends Tag{ | |
| public function getType(){ | |
| return NBT::TAG_End; | |
| } | |
| public function read(NBT $nbt){ | |
| } | |
| public function write(NBT $nbt){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\nbt\tag\Enum as TagEnum; | |
| class Enum extends NamedTag implements \ArrayAccess{ | |
| private $tagType; | |
| public function __construct($name = "", $value = array()){ | |
| $this->name = $name; | |
| foreach($value as $k => $v){ | |
| $this->{$k} = $v; | |
| } | |
| } | |
| public function offsetExists($offset){ | |
| return isset($this->{$offset}); | |
| } | |
| public function offsetGet($offset){ | |
| if($this->{$offset} instanceof Tag){ | |
| if($this->{$offset} instanceof \ArrayAccess){ | |
| return $this->{$offset}; | |
| }else{ | |
| return $this->{$offset}->getValue(); | |
| } | |
| } | |
| return null; | |
| } | |
| public function offsetSet($offset, $value){ | |
| if($value instanceof Tag){ | |
| $this->{$offset} = $value; | |
| }elseif($this->{$offset} instanceof Tag){ | |
| $this->{$offset}->setValue($value); | |
| } | |
| } | |
| public function offsetUnset($offset){ | |
| unset($this->{$offset}); | |
| } | |
| public function getType(){ | |
| return NBT::TAG_Enum; | |
| } | |
| public function setTagType($type){ | |
| $this->tagType = $type; | |
| } | |
| public function getTagType(){ | |
| return $this->tagType; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = array(); | |
| $this->tagType = $nbt->getByte(); | |
| $size = $nbt->getInt(); | |
| for($i = 0; $i < $size and !$nbt->feof(); ++$i){ | |
| switch($this->tagType){ | |
| case NBT::TAG_Byte: | |
| $tag = new Byte(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Short: | |
| $tag = new Short(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Int: | |
| $tag = new Int(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Long: | |
| $tag = new Long(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Float: | |
| $tag = new Float(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Double: | |
| $tag = new Double(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Byte_Array: | |
| $tag = new Byte_Array(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_String: | |
| $tag = new String(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Enum: | |
| $tag = new TagEnum(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Compound: | |
| $tag = new Compound(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| case NBT::TAG_Int_Array: | |
| $tag = new Int_Array(false); | |
| $tag->read($nbt); | |
| $this->{$i} = $tag; | |
| break; | |
| } | |
| } | |
| } | |
| public function write(NBT $nbt){ | |
| if(!isset($this->tagType)){ | |
| foreach($this as $tag){ | |
| if($tag instanceof Tag){ | |
| if(!isset($id)){ | |
| $id = $tag->getType(); | |
| }elseif($id !== $tag->getType()){ | |
| return false; | |
| } | |
| } | |
| } | |
| $this->tagType = @$id; | |
| } | |
| $nbt->putByte($this->tagType); | |
| $tags = array(); | |
| foreach($this as $tag){ | |
| if($tag instanceof Tag){ | |
| $tags[] = $tag; | |
| } | |
| } | |
| $nbt->putInt(count($tags)); | |
| foreach($tags as $tag){ | |
| $tag->write($nbt); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Float extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Float; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->getFloat(); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putFloat($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Int extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Int; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->getInt(); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putInt($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Int_Array extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Int_Array; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = array(); | |
| $size = $nbt->getInt(); | |
| for($i = 0; $i < $size and !$nbt->feof(); ++$i){ | |
| $this->value[] = $nbt->getInt(); | |
| } | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putInt(count($this->value)); | |
| foreach($this->value as $v){ | |
| $nbt->putInt($v); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Long extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Long; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->getLong(); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putLong($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| abstract class NamedTag extends Tag{ | |
| protected $name; | |
| /** | |
| * @param string $name | |
| * @param bool|float|double|int|byte|short|array|Compound|Enum|string $value | |
| */ | |
| public function __construct($name = "", $value = false){ | |
| $this->name = $name; | |
| if($value !== false){ | |
| $this->value = $value; | |
| } | |
| } | |
| public function getName(){ | |
| return $this->name === false ? "" : $this->name; | |
| } | |
| public function setName($name){ | |
| $this->name = $name; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class Short extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_Short; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->getShort(); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putShort($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| class String extends NamedTag{ | |
| public function getType(){ | |
| return NBT::TAG_String; | |
| } | |
| public function read(NBT $nbt){ | |
| $this->value = $nbt->get($nbt->getShort()); | |
| } | |
| public function write(NBT $nbt){ | |
| $nbt->putShort(strlen($this->value)); | |
| $nbt->put($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * All the NBT Tags | |
| */ | |
| namespace pocketmine\nbt\tag; | |
| use pocketmine\nbt\NBT; | |
| abstract class Tag extends \stdClass{ | |
| protected $value; | |
| public function &getValue(){ | |
| return $this->value; | |
| } | |
| public abstract function getType(); | |
| public function setValue($value){ | |
| $this->value = $value; | |
| } | |
| abstract public function write(NBT $nbt); | |
| abstract public function read(NBT $nbt); | |
| public final function __toString(){ | |
| return $this->value; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network; | |
| class Packet extends \stdClass{ | |
| public $ip; | |
| public $port; | |
| public $buffer; | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class AddEntityPacket extends DataPacket{ | |
| public $eid; | |
| public $type; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $did; | |
| public $speedX; | |
| public $speedY; | |
| public $speedZ; | |
| public function pid(){ | |
| return Info::ADD_ENTITY_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putByte($this->type); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| $this->putInt($this->did); | |
| if($this->did > 0){ | |
| $this->putShort($this->speedX); | |
| $this->putShort($this->speedY); | |
| $this->putShort($this->speedZ); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class AddItemEntityPacket extends DataPacket{ | |
| public $eid; | |
| public $item; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $yaw; | |
| public $pitch; | |
| public $roll; | |
| public function pid(){ | |
| return Info::ADD_ITEM_ENTITY_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putSlot($this->item); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| $this->putByte($this->yaw); | |
| $this->putByte($this->pitch); | |
| $this->putByte($this->roll); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class AddMobPacket extends DataPacket{ | |
| public $eid; | |
| public $type; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $pitch; | |
| public $yaw; | |
| public $metadata; | |
| public function pid(){ | |
| return Info::ADD_MOB_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putInt($this->type); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| $this->putByte($this->yaw); | |
| $this->putByte($this->pitch); | |
| $this->put(Binary::writeMetadata($this->metadata)); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class AddPaintingPacket extends DataPacket{ | |
| public $eid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $direction; | |
| public $title; | |
| public function pid(){ | |
| return Info::ADD_PAINTING_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putInt($this->x); | |
| $this->putInt($this->y); | |
| $this->putInt($this->z); | |
| $this->putInt($this->direction); | |
| $this->putString($this->title); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class AddPlayerPacket extends DataPacket{ | |
| public $clientID; | |
| public $username; | |
| public $eid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $pitch; | |
| public $yaw; | |
| public $unknown1; | |
| public $unknown2; | |
| public $metadata; | |
| public function pid(){ | |
| return Info::ADD_PLAYER_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putLong($this->clientID); | |
| $this->putString($this->username); | |
| $this->putInt($this->eid); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| $this->putByte($this->yaw); | |
| $this->putByte($this->pitch); | |
| $this->putShort($this->unknown1); | |
| $this->putShort($this->unknown2); | |
| $this->put(Binary::writeMetadata($this->metadata)); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class AdventureSettingsPacket extends DataPacket{ | |
| public $flags; | |
| public function pid(){ | |
| return Info::ADVENTURE_SETTINGS_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->flags); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class AnimatePacket extends DataPacket{ | |
| public $action; | |
| public $eid; | |
| public function pid(){ | |
| return Info::ANIMATE_PACKET; | |
| } | |
| public function decode(){ | |
| $this->action = $this->getByte(); | |
| $this->eid = $this->getInt(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->action); | |
| $this->putInt($this->eid); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ChatPacket extends DataPacket{ | |
| public $message; | |
| public function pid(){ | |
| return Info::CHAT_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putString($this->message); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ChunkDataPacket extends DataPacket{ | |
| public $chunkX; | |
| public $chunkZ; | |
| public $data; | |
| public function pid(){ | |
| return Info::CHUNK_DATA_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->chunkX); | |
| $this->putInt($this->chunkZ); | |
| $this->put($this->data); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ClientConnectPacket extends DataPacket{ | |
| public $clientID; | |
| public $session; | |
| public $unknown1; | |
| public function pid(){ | |
| return Info::CLIENT_CONNECT_PACKET; | |
| } | |
| public function decode(){ | |
| $this->clientID = $this->getLong(); | |
| $this->session = $this->getLong(); | |
| $this->unknown1 = $this->get(1); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ClientHandshakePacket extends DataPacket{ | |
| public $cookie; | |
| public $security; | |
| public $port; | |
| public $dataArray0; | |
| public $dataArray; | |
| public $timestamp; | |
| public $session2; | |
| public $session; | |
| public function pid(){ | |
| return Info::CLIENT_HANDSHAKE_PACKET; | |
| } | |
| public function decode(){ | |
| $this->cookie = $this->get(4); | |
| $this->security = $this->get(1); | |
| $this->port = $this->getShort(true); | |
| $this->dataArray0 = $this->get($this->getByte()); | |
| $this->dataArray = $this->getDataArray(9); | |
| $this->timestamp = $this->get(2); | |
| $this->session2 = $this->getLong(); | |
| $this->session = $this->getLong(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ContainerClosePacket extends DataPacket{ | |
| public $windowid; | |
| public function pid(){ | |
| return Info::CONTAINER_CLOSE_PACKET; | |
| } | |
| public function decode(){ | |
| $this->windowid = $this->getByte(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->windowid); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ContainerOpenPacket extends DataPacket{ | |
| public $windowid; | |
| public $type; | |
| public $slots; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public function pid(){ | |
| return Info::CONTAINER_OPEN_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->windowid); | |
| $this->putByte($this->type); | |
| $this->putByte($this->slots); | |
| $this->putInt($this->x); | |
| $this->putInt($this->y); | |
| $this->putInt($this->z); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ContainerSetContentPacket extends DataPacket{ | |
| public $windowid; | |
| public $slots = array(); | |
| public $hotbar = array(); | |
| public function pid(){ | |
| return Info::CONTAINER_SET_CONTENT_PACKET; | |
| } | |
| public function decode(){ | |
| $this->windowid = $this->getByte(); | |
| $count = $this->getShort(); | |
| for($s = 0; $s < $count and !$this->feof(); ++$s){ | |
| $this->slots[$s] = $this->getSlot(); | |
| } | |
| if($this->windowid === 0){ | |
| $count = $this->getShort(); | |
| for($s = 0; $s < $count and !$this->feof(); ++$s){ | |
| $this->hotbar[$s] = $this->getInt(); | |
| } | |
| } | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->windowid); | |
| $this->putShort(count($this->slots)); | |
| foreach($this->slots as $slot){ | |
| $this->putSlot($slot); | |
| } | |
| if($this->windowid === 0 and count($this->hotbar) > 0){ | |
| $this->putShort(count($this->hotbar)); | |
| foreach($this->hotbar as $slot){ | |
| $this->putInt($slot); | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ContainerSetDataPacket extends DataPacket{ | |
| public $windowid; | |
| public $property; | |
| public $value; | |
| public function pid(){ | |
| return Info::CONTAINER_SET_DATA_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->windowid); | |
| $this->putShort($this->property); | |
| $this->putShort($this->value); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ContainerSetSlotPacket extends DataPacket{ | |
| public $windowid; | |
| public $slot; | |
| public $item; | |
| public function pid(){ | |
| return Info::CONTAINER_SET_SLOT_PACKET; | |
| } | |
| public function decode(){ | |
| $this->windowid = $this->getByte(); | |
| $this->slot = $this->getShort(); | |
| $this->item = $this->getSlot(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->windowid); | |
| $this->putShort($this->slot); | |
| $this->putSlot($this->item); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| use pocketmine\item\Item; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| abstract class DataPacket extends \stdClass{ | |
| private $offset = 0; | |
| public $buffer = ""; | |
| public $reliability = 0; | |
| public $hasSplit = false; | |
| public $messageIndex; | |
| public $orderIndex; | |
| public $orderChannel; | |
| public $splitCount; | |
| public $splitID; | |
| public $splitIndex; | |
| abstract public function pid(); | |
| abstract public function encode(); | |
| abstract public function decode(); | |
| protected function reset(){ | |
| $this->setBuffer(chr($this->pid())); | |
| } | |
| public function setBuffer($buffer = ""){ | |
| $this->buffer = $buffer; | |
| $this->offset = 0; | |
| } | |
| public function getBuffer(){ | |
| return $this->buffer; | |
| } | |
| protected function get($len){ | |
| if($len <= 0){ | |
| $this->offset = strlen($this->buffer) - 1; | |
| return ""; | |
| }elseif($len === true){ | |
| return substr($this->buffer, $this->offset); | |
| } | |
| $buffer = ""; | |
| for(; $len > 0; --$len, ++$this->offset){ | |
| $buffer .= @$this->buffer{$this->offset}; | |
| } | |
| return $buffer; | |
| } | |
| protected function put($str){ | |
| $this->buffer .= $str; | |
| } | |
| protected function getLong($unsigned = false){ | |
| return Binary::readLong($this->get(8), $unsigned); | |
| } | |
| protected function putLong($v){ | |
| $this->buffer .= Binary::writeLong($v); | |
| } | |
| protected function getInt(){ | |
| return Binary::readInt($this->get(4)); | |
| } | |
| protected function putInt($v){ | |
| $this->buffer .= Binary::writeInt($v); | |
| } | |
| protected function getShort($unsigned = false){ | |
| return Binary::readShort($this->get(2), $unsigned); | |
| } | |
| protected function putShort($v){ | |
| $this->buffer .= Binary::writeShort($v); | |
| } | |
| protected function getFloat(){ | |
| return Binary::readFloat($this->get(4)); | |
| } | |
| protected function putFloat($v){ | |
| $this->buffer .= Binary::writeFloat($v); | |
| } | |
| protected function getTriad(){ | |
| return Binary::readTriad($this->get(3)); | |
| } | |
| protected function putTriad($v){ | |
| $this->buffer .= Binary::writeTriad($v); | |
| } | |
| protected function getLTriad(){ | |
| return Binary::readTriad(strrev($this->get(3))); | |
| } | |
| protected function putLTriad($v){ | |
| $this->buffer .= strrev(Binary::writeTriad($v)); | |
| } | |
| protected function getByte(){ | |
| return ord($this->buffer{$this->offset++}); | |
| } | |
| protected function putByte($v){ | |
| $this->buffer .= chr($v); | |
| } | |
| protected function getDataArray($len = 10){ | |
| $data = array(); | |
| for($i = 1; $i <= $len and !$this->feof(); ++$i){ | |
| $data[] = $this->get($this->getTriad()); | |
| } | |
| return $data; | |
| } | |
| protected function putDataArray(array $data = array()){ | |
| foreach($data as $v){ | |
| $this->putTriad(strlen($v)); | |
| $this->put($v); | |
| } | |
| } | |
| protected function getSlot(){ | |
| $id = $this->getShort(); | |
| $cnt = $this->getByte(); | |
| return Item::get( | |
| $id, | |
| $this->getShort(), | |
| $cnt | |
| ); | |
| } | |
| protected function putSlot(Item $item){ | |
| $this->putShort($item->getID()); | |
| $this->putByte($item->getCount()); | |
| $this->putShort($item->getMetadata()); | |
| } | |
| protected function getString(){ | |
| return $this->get($this->getShort(true)); | |
| } | |
| protected function putString($v){ | |
| $this->putShort(strlen($v)); | |
| $this->put($v); | |
| } | |
| protected function feof(){ | |
| return !isset($this->buffer{$this->offset}); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class DisconnectPacket extends DataPacket{ | |
| public function pid(){ | |
| return Info::DISCONNECT_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class DropItemPacket extends DataPacket{ | |
| public $eid; | |
| public $unknown; | |
| public $item; | |
| public function pid(){ | |
| return Info::DROP_ITEM_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->unknown = $this->getByte(); | |
| $this->item = $this->getSlot(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class EntityDataPacket extends DataPacket{ | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $namedtag; | |
| public function pid(){ | |
| return Info::ENTITY_DATA_PACKET; | |
| } | |
| public function decode(){ | |
| $this->x = $this->getShort(); | |
| $this->y = $this->getByte(); | |
| $this->z = $this->getShort(); | |
| $this->namedtag = $this->get(true); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putShort($this->x); | |
| $this->putByte($this->y); | |
| $this->putShort($this->z); | |
| $this->put($this->namedtag); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class EntityEventPacket extends DataPacket{ | |
| public $eid; | |
| public $event; | |
| public function pid(){ | |
| return Info::ENTITY_EVENT_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->event = $this->getByte(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putByte($this->event); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ExplodePacket extends DataPacket{ | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $radius; | |
| public $records; | |
| public function pid(){ | |
| return Info::EXPLODE_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| $this->putFloat($this->radius); | |
| $this->putInt(@count($this->records)); | |
| if(@count($this->records) > 0){ | |
| foreach($this->records as $record){ | |
| $this->putByte($record->x); | |
| $this->putByte($record->y); | |
| $this->putByte($record->z); | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class HurtArmorPacket extends DataPacket{ | |
| public $health; | |
| public function pid(){ | |
| return Info::HURT_ARMOR_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->health); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Minecraft: PE multiplayer protocol implementation | |
| */ | |
| namespace pocketmine\network\protocol; | |
| abstract class Info{ | |
| /** | |
| * Actual Minecraft: PE protocol version | |
| */ | |
| const CURRENT_PROTOCOL = 14; | |
| const PING_PACKET = 0x00; | |
| const PONG_PACKET = 0x03; | |
| const CLIENT_CONNECT_PACKET = 0x09; | |
| const SERVER_HANDSHAKE_PACKET = 0x10; | |
| const CLIENT_HANDSHAKE_PACKET = 0x13; | |
| //const SERVER_FULL_PACKET = 0x14; | |
| const DISCONNECT_PACKET = 0x15; | |
| //const BANNED_PACKET = 0x17; | |
| const LOGIN_PACKET = 0x82; | |
| const LOGIN_STATUS_PACKET = 0x83; | |
| const READY_PACKET = 0x84; | |
| const MESSAGE_PACKET = 0x85; | |
| const SET_TIME_PACKET = 0x86; | |
| const START_GAME_PACKET = 0x87; | |
| const ADD_MOB_PACKET = 0x88; | |
| const ADD_PLAYER_PACKET = 0x89; | |
| const REMOVE_PLAYER_PACKET = 0x8a; | |
| const ADD_ENTITY_PACKET = 0x8c; | |
| const REMOVE_ENTITY_PACKET = 0x8d; | |
| const ADD_ITEM_ENTITY_PACKET = 0x8e; | |
| const TAKE_ITEM_ENTITY_PACKET = 0x8f; | |
| const MOVE_ENTITY_PACKET = 0x90; | |
| const MOVE_ENTITY_PACKET_POSROT = 0x93; | |
| const ROTATE_HEAD_PACKET = 0x94; | |
| const MOVE_PLAYER_PACKET = 0x95; | |
| //const PLACE_BLOCK_PACKET = 0x96; | |
| const REMOVE_BLOCK_PACKET = 0x97; | |
| const UPDATE_BLOCK_PACKET = 0x98; | |
| const ADD_PAINTING_PACKET = 0x99; | |
| const EXPLODE_PACKET = 0x9a; | |
| const LEVEL_EVENT_PACKET = 0x9b; | |
| const TILE_EVENT_PACKET = 0x9c; | |
| const ENTITY_EVENT_PACKET = 0x9d; | |
| const REQUEST_CHUNK_PACKET = 0x9e; | |
| const CHUNK_DATA_PACKET = 0x9f; | |
| const PLAYER_EQUIPMENT_PACKET = 0xa0; | |
| const PLAYER_ARMOR_EQUIPMENT_PACKET = 0xa1; | |
| const INTERACT_PACKET = 0xa2; | |
| const USE_ITEM_PACKET = 0xa3; | |
| const PLAYER_ACTION_PACKET = 0xa4; | |
| const HURT_ARMOR_PACKET = 0xa6; | |
| const SET_ENTITY_DATA_PACKET = 0xa7; | |
| const SET_ENTITY_MOTION_PACKET = 0xa8; | |
| //const SET_ENTITY_LINK_PACKET = 0xa9; | |
| const SET_HEALTH_PACKET = 0xaa; | |
| const SET_SPAWN_POSITION_PACKET = 0xab; | |
| const ANIMATE_PACKET = 0xac; | |
| const RESPAWN_PACKET = 0xad; | |
| const SEND_INVENTORY_PACKET = 0xae; | |
| const DROP_ITEM_PACKET = 0xaf; | |
| const CONTAINER_OPEN_PACKET = 0xb0; | |
| const CONTAINER_CLOSE_PACKET = 0xb1; | |
| const CONTAINER_SET_SLOT_PACKET = 0xb2; | |
| const CONTAINER_SET_DATA_PACKET = 0xb3; | |
| const CONTAINER_SET_CONTENT_PACKET = 0xb4; | |
| //const CONTAINER_ACK_PACKET = 0xb5; | |
| const CHAT_PACKET = 0xb6; | |
| const ADVENTURE_SETTINGS_PACKET = 0xb7; | |
| const ENTITY_DATA_PACKET = 0xb8; | |
| //const PLAYER_INPUT_PACKET = 0xb9; | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class InteractPacket extends DataPacket{ | |
| public $action; | |
| public $eid; | |
| public $target; | |
| public function pid(){ | |
| return Info::INTERACT_PACKET; | |
| } | |
| public function decode(){ | |
| $this->action = $this->getByte(); | |
| $this->eid = $this->getInt(); | |
| $this->target = $this->getInt(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->action); | |
| $this->putInt($this->eid); | |
| $this->putInt($this->target); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class LevelEventPacket extends DataPacket{ | |
| public $evid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $data; | |
| public function pid(){ | |
| return Info::LEVEL_EVENT_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putShort($this->evid); | |
| $this->putShort($this->x); | |
| $this->putShort($this->y); | |
| $this->putShort($this->z); | |
| $this->putInt($this->data); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class LoginPacket extends DataPacket{ | |
| public $username; | |
| public $protocol1; | |
| public $protocol2; | |
| public $clientId; | |
| public $loginData; | |
| public function pid(){ | |
| return Info::LOGIN_PACKET; | |
| } | |
| public function decode(){ | |
| $this->username = $this->getString(); | |
| $this->protocol1 = $this->getInt(); | |
| $this->protocol2 = $this->getInt(); | |
| $this->clientId = $this->getInt(); | |
| $this->loginData = $this->getString(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class LoginStatusPacket extends DataPacket{ | |
| public $status; | |
| public function pid(){ | |
| return Info::LOGIN_STATUS_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->status); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class MessagePacket extends DataPacket{ | |
| public $source; | |
| public $message; | |
| public function pid(){ | |
| return Info::MESSAGE_PACKET; | |
| } | |
| public function decode(){ | |
| $this->source = $this->getString(); | |
| $this->message = $this->getString(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putString($this->source); | |
| $this->putString($this->message); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class MoveEntityPacket extends DataPacket{ | |
| public function pid(){ | |
| return Info::MOVE_ENTITY_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class MoveEntityPacket_PosRot extends DataPacket{ | |
| public $eid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $yaw; | |
| public $pitch; | |
| public function pid(){ | |
| return Info::MOVE_ENTITY_PACKET_POSROT; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| $this->putFloat($this->yaw); | |
| $this->putFloat($this->pitch); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class MovePlayerPacket extends DataPacket{ | |
| public $eid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $yaw; | |
| public $pitch; | |
| public $bodyYaw; | |
| public function pid(){ | |
| return Info::MOVE_PLAYER_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->x = $this->getFloat(); | |
| $this->y = $this->getFloat(); | |
| $this->z = $this->getFloat(); | |
| $this->yaw = $this->getFloat(); | |
| $this->pitch = $this->getFloat(); | |
| $this->bodyYaw = $this->getFloat(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| $this->putFloat($this->yaw); | |
| $this->putFloat($this->pitch); | |
| $this->putFloat($this->bodyYaw); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class PingPacket extends DataPacket{ | |
| public $time = 0; | |
| public function pid(){ | |
| return Info::PING_PACKET; | |
| } | |
| public function decode(){ | |
| $this->time = $this->getLong(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putLong($this->time); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class PlayerActionPacket extends DataPacket{ | |
| public $action; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $face; | |
| public $eid; | |
| public function pid(){ | |
| return Info::PLAYER_ACTION_PACKET; | |
| } | |
| public function decode(){ | |
| $this->action = $this->getInt(); | |
| $this->x = $this->getInt(); | |
| $this->y = $this->getInt(); | |
| $this->z = $this->getInt(); | |
| $this->face = $this->getInt(); | |
| $this->eid = $this->getInt(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class PlayerArmorEquipmentPacket extends DataPacket{ | |
| public $eid; | |
| public $slots = array(); | |
| public function pid(){ | |
| return Info::PLAYER_ARMOR_EQUIPMENT_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->slots[0] = $this->getByte(); | |
| $this->slots[1] = $this->getByte(); | |
| $this->slots[2] = $this->getByte(); | |
| $this->slots[3] = $this->getByte(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putByte($this->slots[0]); | |
| $this->putByte($this->slots[1]); | |
| $this->putByte($this->slots[2]); | |
| $this->putByte($this->slots[3]); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class PlayerEquipmentPacket extends DataPacket{ | |
| public $eid; | |
| public $item; | |
| public $meta; | |
| public $slot; | |
| public function pid(){ | |
| return Info::PLAYER_EQUIPMENT_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->item = $this->getShort(); | |
| $this->meta = $this->getShort(); | |
| $this->slot = $this->getByte(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putShort($this->item); | |
| $this->putShort($this->meta); | |
| $this->putByte($this->slot); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class PongPacket extends DataPacket{ | |
| public $time = 0; | |
| public $ptime = 0; | |
| public function pid(){ | |
| return Info::PONG_PACKET; | |
| } | |
| public function decode(){ | |
| $this->ptime = $this->getLong(); | |
| $this->time = $this->getLong(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putLong($this->ptime); | |
| $this->putLong($this->time); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ReadyPacket extends DataPacket{ | |
| public $status; | |
| public function pid(){ | |
| return Info::READY_PACKET; | |
| } | |
| public function decode(){ | |
| $this->status = $this->getByte(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class RemoveBlockPacket extends DataPacket{ | |
| public $eid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public function pid(){ | |
| return Info::REMOVE_BLOCK_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->x = $this->getInt(); | |
| $this->z = $this->getInt(); | |
| $this->y = $this->getByte(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class RemoveEntityPacket extends DataPacket{ | |
| public $eid; | |
| public function pid(){ | |
| return Info::REMOVE_ENTITY_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class RemovePlayerPacket extends DataPacket{ | |
| public $eid; | |
| public $clientID; | |
| public function pid(){ | |
| return Info::REMOVE_PLAYER_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putLong($this->clientID); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class RequestChunkPacket extends DataPacket{ | |
| public $chunkX; | |
| public $chunkZ; | |
| public function pid(){ | |
| return Info::REQUEST_CHUNK_PACKET; | |
| } | |
| public function decode(){ | |
| $this->chunkX = $this->getInt(); | |
| $this->chunkZ = $this->getInt(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class RespawnPacket extends DataPacket{ | |
| public $eid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public function pid(){ | |
| return Info::RESPAWN_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->x = $this->getFloat(); | |
| $this->y = $this->getFloat(); | |
| $this->z = $this->getFloat(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class RotateHeadPacket extends DataPacket{ | |
| public $eid; | |
| public $yaw; | |
| public function pid(){ | |
| return Info::ROTATE_HEAD_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putByte($this->yaw); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class SendInventoryPacket extends DataPacket{ | |
| public $eid; | |
| public $windowid; | |
| public $slots = array(); | |
| public $armor = array(); | |
| public function pid(){ | |
| return Info::SEND_INVENTORY_PACKET; | |
| } | |
| public function decode(){ | |
| $this->eid = $this->getInt(); | |
| $this->windowid = $this->getByte(); | |
| $count = $this->getShort(); | |
| for($s = 0; $s < $count and !$this->feof(); ++$s){ | |
| $this->slots[$s] = $this->getSlot(); | |
| } | |
| if($this->windowid === 1){ //Armor is sent | |
| for($s = 0; $s < 4; ++$s){ | |
| $this->armor[$s] = $this->getSlot(); | |
| } | |
| } | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putByte($this->windowid); | |
| $this->putShort(count($this->slots)); | |
| foreach($this->slots as $slot){ | |
| $this->putSlot($slot); | |
| } | |
| if($this->windowid === 1 and count($this->armor) === 4){ | |
| for($s = 0; $s < 4; ++$s){ | |
| $this->putSlot($this->armor[$s]); | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class ServerHandshakePacket extends DataPacket{ | |
| public $port; | |
| public $session; | |
| public $session2; | |
| public function pid(){ | |
| return Info::SERVER_HANDSHAKE_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->put("\x04\x3f\x57\xfe"); //cookie | |
| $this->put("\xcd"); //Security flags | |
| $this->putShort($this->port); | |
| $this->putDataArray(array( | |
| "\xf5\xff\xff\xf5", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| "\xff\xff\xff\xff", | |
| )); | |
| $this->put("\x00\x00"); | |
| $this->putLong($this->session); | |
| $this->putLong($this->session2); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class SetEntityDataPacket extends DataPacket{ | |
| public $eid; | |
| public $metadata; | |
| public function pid(){ | |
| return Info::SET_ENTITY_DATA_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->put(Binary::writeMetadata($this->metadata)); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class SetEntityMotionPacket extends DataPacket{ | |
| public $eid; | |
| public $speedX; | |
| public $speedY; | |
| public $speedZ; | |
| public function pid(){ | |
| return Info::SET_ENTITY_MOTION_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->eid); | |
| $this->putShort((int) ($this->speedX * 400)); | |
| $this->putShort((int) ($this->speedY * 400)); | |
| $this->putShort((int) ($this->speedZ * 400)); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class SetHealthPacket extends DataPacket{ | |
| public $health; | |
| public function pid(){ | |
| return Info::SET_HEALTH_PACKET; | |
| } | |
| public function decode(){ | |
| $this->health = $this->getByte(); | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putByte($this->health); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class SetSpawnPositionPacket extends DataPacket{ | |
| public $x; | |
| public $z; | |
| public $y; | |
| public function pid(){ | |
| return Info::SET_SPAWN_POSITION_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->x); | |
| $this->putInt($this->z); | |
| $this->putByte($this->y); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class SetTimePacket extends DataPacket{ | |
| public $time; | |
| public $started = true; | |
| public function pid(){ | |
| return Info::SET_TIME_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->time); | |
| $this->putByte($this->started == true ? 0x80 : 0x00); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class StartGamePacket extends DataPacket{ | |
| public $seed; | |
| public $generator; | |
| public $gamemode; | |
| public $eid; | |
| public $x; | |
| public $y; | |
| public $z; | |
| public function pid(){ | |
| return Info::START_GAME_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->seed); | |
| $this->putInt($this->generator); | |
| $this->putInt($this->gamemode); | |
| $this->putInt($this->eid); | |
| $this->putFloat($this->x); | |
| $this->putFloat($this->y); | |
| $this->putFloat($this->z); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class TakeItemEntityPacket extends DataPacket{ | |
| public $target; | |
| public $eid; | |
| public function pid(){ | |
| return Info::TAKE_ITEM_ENTITY_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->target); | |
| $this->putInt($this->eid); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class TileEventPacket extends DataPacket{ | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $case1; | |
| public $case2; | |
| public function pid(){ | |
| return Info::TILE_EVENT_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->x); | |
| $this->putInt($this->y); | |
| $this->putInt($this->z); | |
| $this->putInt($this->case1); | |
| $this->putInt($this->case2); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class UnknownPacket extends DataPacket{ | |
| public $packetID = -1; | |
| public function pid(){ | |
| return $this->packetID; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class UpdateBlockPacket extends DataPacket{ | |
| public $x; | |
| public $z; | |
| public $y; | |
| public $block; | |
| public $meta; | |
| public function pid(){ | |
| return Info::UPDATE_BLOCK_PACKET; | |
| } | |
| public function decode(){ | |
| } | |
| public function encode(){ | |
| $this->reset(); | |
| $this->putInt($this->x); | |
| $this->putInt($this->z); | |
| $this->putByte($this->y); | |
| $this->putByte($this->block); | |
| $this->putByte($this->meta); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\protocol; | |
| class UseItemPacket extends DataPacket{ | |
| public $x; | |
| public $y; | |
| public $z; | |
| public $face; | |
| public $item; | |
| public $meta; | |
| public $eid; | |
| public $fx; | |
| public $fy; | |
| public $fz; | |
| public $posX; | |
| public $posY; | |
| public $posZ; | |
| public function pid(){ | |
| return Info::USE_ITEM_PACKET; | |
| } | |
| public function decode(){ | |
| $this->x = $this->getInt(); | |
| $this->y = $this->getInt(); | |
| $this->z = $this->getInt(); | |
| $this->face = $this->getInt(); | |
| $this->item = $this->getShort(); | |
| $this->meta = $this->getByte(); //Mojang: fix this | |
| $this->eid = $this->getInt(); | |
| $this->fx = $this->getFloat(); | |
| $this->fy = $this->getFloat(); | |
| $this->fz = $this->getFloat(); | |
| $this->posX = $this->getFloat(); | |
| $this->posY = $this->getFloat(); | |
| $this->posZ = $this->getFloat(); | |
| } | |
| public function encode(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Implementation of the UT3 Query Protocol (GameSpot) | |
| * Source: http://wiki.unrealadmin.org/UT3_query_protocol | |
| */ | |
| namespace pocketmine\network\query; | |
| use pocketmine\Server; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class QueryHandler{ | |
| private $socket, $server, $lastToken, $token, $longData, $timeout; | |
| public function __construct(){ | |
| console("[INFO] Starting GS4 status listener"); | |
| $this->server = Server::getInstance(); | |
| $addr = ($ip = $this->server->getIp()) != "" ? $ip : "0.0.0.0"; | |
| $port = $this->server->getPort(); | |
| console("[INFO] Setting query port to $port"); | |
| /* | |
| The Query protocol is built on top of the existing Minecraft PE UDP network stack. | |
| Because the 0xFE packet does not exist in the MCPE protocol, | |
| we can identify Query packets and remove them from the packet queue. | |
| Then, the Query class handles itself sending the packets in raw form, because | |
| packets can conflict with the MCPE ones. | |
| */ | |
| $this->regenerateToken(); | |
| $this->lastToken = $this->token; | |
| $this->regenerateInfo(); | |
| console("[INFO] Query running on $addr:$port"); | |
| } | |
| public function regenerateInfo(){ | |
| $str = ""; | |
| $plist = "PocketMine-MP " . $this->server->getPocketMineVersion(); | |
| $pl = $this->server->getPluginManager()->getPlugins(); | |
| if(count($pl) > 0){ | |
| $plist .= ":"; | |
| foreach($pl as $p){ | |
| $d = $p->getDescription(); | |
| $plist .= " " . str_replace(array(";", ":", " "), array("", "", "_"), $d->getName()) . " " . str_replace(array(";", ":", " "), array("", "", "_"), $d->getVersion()) . ";"; | |
| } | |
| $plist = substr($plist, 0, -1); | |
| } | |
| $KVdata = array( | |
| "splitnum" => chr(128), | |
| "hostname" => $this->server->getServerName(), | |
| "gametype" => ($this->server->getGamemode() & 0x01) === 0 ? "SMP" : "CMP", | |
| "game_id" => "MINECRAFTPE", | |
| "version" => $this->server->getVersion(), | |
| "server_engine" => $this->server->getName() . " " . $this->server->getPocketMineVersion(), | |
| "plugins" => $plist, | |
| "map" => $this->server->getDefaultLevel()->getName(), | |
| "numplayers" => count($this->server->getOnlinePlayers()), | |
| "maxplayers" => $this->server->getMaxPlayers(), | |
| "whitelist" => $this->server->hasWhitelist() === true ? "on" : "off", | |
| "hostport" => $this->server->getPort() | |
| ); | |
| foreach($KVdata as $key => $value){ | |
| $str .= $key . "\x00" . $value . "\x00"; | |
| } | |
| $str .= "\x00\x01player_\x00\x00"; | |
| foreach($this->server->getOnlinePlayers() as $player){ | |
| if($player->getName() != ""){ | |
| $str .= $player->getName() . "\x00"; | |
| } | |
| } | |
| $str .= "\x00"; | |
| $this->longData = $str; | |
| $this->timeout = microtime(true) + 5; | |
| } | |
| public function regenerateToken(){ | |
| $this->lastToken = $this->token; | |
| $this->token = Utils::getRandomBytes(16, false); | |
| } | |
| public static function getTokenString($token, $salt){ | |
| return Binary::readInt(substr(hash("sha512", $salt . ":" . $token, true), 7, 4)); | |
| } | |
| public function handle(QueryPacket $packet){ | |
| $packet->decode(); | |
| switch($packet->packetType){ | |
| case QueryPacket::HANDSHAKE: //Handshake | |
| $pk = new QueryPacket; | |
| $pk->ip = $packet->ip; | |
| $pk->port = $packet->port; | |
| $pk->packetType = QueryPacket::HANDSHAKE; | |
| $pk->sessionID = $packet->sessionID; | |
| $pk->payload = self::getTokenString($this->token, $packet->ip) . "\x00"; | |
| $pk->encode(); | |
| $this->server->sendPacket($pk); | |
| break; | |
| case QueryPacket::STATISTICS: //Stat | |
| $token = Binary::readInt(substr($packet->payload, 0, 4)); | |
| if($token !== self::getTokenString($this->token, $packet->ip) and $token !== self::getTokenString($this->lastToken, $packet->ip)){ | |
| break; | |
| } | |
| $pk = new QueryPacket; | |
| $pk->ip = $packet->ip; | |
| $pk->port = $packet->port; | |
| $pk->packetType = QueryPacket::STATISTICS; | |
| $pk->sessionID = $packet->sessionID; | |
| if(strlen($packet->payload) === 8){ | |
| if($this->timeout < microtime(true)){ | |
| $this->regenerateInfo(); | |
| } | |
| $pk->payload = $this->longData; | |
| }else{ | |
| $pk->payload = $this->server->getServerName() . "\x00" . (($this->server->getGamemode() & 0x01) === 0 ? "SMP" : "CMP") . "\x00" . $this->server->getDefaultLevel()->getName() . "\x00" . count($this->server->getOnlinePlayers()) . "\x00" . $this->server->getMaxPlayers() . "\x00" . Binary::writeLShort($this->server->getPort()) . $this->server->getIp() . "\x00"; | |
| } | |
| $pk->encode(); | |
| $this->server->sendPacket($pk); | |
| break; | |
| } | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\query; | |
| use pocketmine\network\Packet; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class QueryPacket extends Packet{ | |
| const HANDSHAKE = 9; | |
| const STATISTICS = 0; | |
| public $packetType; | |
| public $sessionID; | |
| public $payload; | |
| public function decode(){ | |
| $this->packetType = ord($this->buffer{2}); | |
| $this->sessionID = Binary::readInt(substr($this->buffer, 3, 4)); | |
| $this->payload = substr($this->buffer, 7); | |
| } | |
| public function encode(){ | |
| $this->buffer .= chr($this->packetType); | |
| $this->buffer .= Binary::writeInt($this->sessionID); | |
| $this->buffer .= $this->payload; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * RakNet UDP library implementation | |
| */ | |
| namespace pocketmine\network\raknet; | |
| abstract class Info{ | |
| const STRUCTURE = 5; | |
| const MAGIC = "\x00\xff\xff\x00\xfe\xfe\xfe\xfe\xfd\xfd\xfd\xfd\x12\x34\x56\x78"; | |
| const UNCONNECTED_PING = 0x01; | |
| const UNCONNECTED_PING_OPEN_CONNECTIONS = 0x02; | |
| const OPEN_CONNECTION_REQUEST_1 = 0x05; | |
| const OPEN_CONNECTION_REPLY_1 = 0x06; | |
| const OPEN_CONNECTION_REQUEST_2 = 0x07; | |
| const OPEN_CONNECTION_REPLY_2 = 0x08; | |
| const INCOMPATIBLE_PROTOCOL_VERSION = 0x1a; //CHECK THIS | |
| const UNCONNECTED_PONG = 0x1c; | |
| const ADVERTISE_SYSTEM = 0x1d; | |
| const DATA_PACKET_0 = 0x80; | |
| const DATA_PACKET_1 = 0x81; | |
| const DATA_PACKET_2 = 0x82; | |
| const DATA_PACKET_3 = 0x83; | |
| const DATA_PACKET_4 = 0x84; | |
| const DATA_PACKET_5 = 0x85; | |
| const DATA_PACKET_6 = 0x86; | |
| const DATA_PACKET_7 = 0x87; | |
| const DATA_PACKET_8 = 0x88; | |
| const DATA_PACKET_9 = 0x89; | |
| const DATA_PACKET_A = 0x8a; | |
| const DATA_PACKET_B = 0x8b; | |
| const DATA_PACKET_C = 0x8c; | |
| const DATA_PACKET_D = 0x8d; | |
| const DATA_PACKET_E = 0x8e; | |
| const DATA_PACKET_F = 0x8f; | |
| const NACK = 0xa0; | |
| const ACK = 0xc0; | |
| public static function isValid($pid){ | |
| switch((int) $pid){ | |
| case self::UNCONNECTED_PING: | |
| case self::UNCONNECTED_PING_OPEN_CONNECTIONS: | |
| case self::OPEN_CONNECTION_REQUEST_1: | |
| case self::OPEN_CONNECTION_REPLY_1: | |
| case self::OPEN_CONNECTION_REQUEST_2: | |
| case self::OPEN_CONNECTION_REPLY_2: | |
| case self::INCOMPATIBLE_PROTOCOL_VERSION: | |
| case self::UNCONNECTED_PONG: | |
| case self::ADVERTISE_SYSTEM: | |
| case self::DATA_PACKET_0: | |
| case self::DATA_PACKET_1: | |
| case self::DATA_PACKET_2: | |
| case self::DATA_PACKET_3: | |
| case self::DATA_PACKET_4: | |
| case self::DATA_PACKET_5: | |
| case self::DATA_PACKET_6: | |
| case self::DATA_PACKET_7: | |
| case self::DATA_PACKET_8: | |
| case self::DATA_PACKET_9: | |
| case self::DATA_PACKET_A: | |
| case self::DATA_PACKET_B: | |
| case self::DATA_PACKET_C: | |
| case self::DATA_PACKET_D: | |
| case self::DATA_PACKET_E: | |
| case self::DATA_PACKET_F: | |
| case self::NACK: | |
| case self::ACK: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\raknet; | |
| use pocketmine\network\Packet as NetworkPacket; | |
| use pocketmine\network\protocol\AddEntityPacket; | |
| use pocketmine\network\protocol\AddItemEntityPacket; | |
| use pocketmine\network\protocol\AddMobPacket; | |
| use pocketmine\network\protocol\AddPaintingPacket; | |
| use pocketmine\network\protocol\AddPlayerPacket; | |
| use pocketmine\network\protocol\AdventureSettingsPacket; | |
| use pocketmine\network\protocol\AnimatePacket; | |
| use pocketmine\network\protocol\ChatPacket; | |
| use pocketmine\network\protocol\ChunkDataPacket; | |
| use pocketmine\network\protocol\ClientConnectPacket; | |
| use pocketmine\network\protocol\ContainerClosePacket; | |
| use pocketmine\network\protocol\ContainerOpenPacket; | |
| use pocketmine\network\protocol\ContainerSetContentPacket; | |
| use pocketmine\network\protocol\ContainerSetDataPacket; | |
| use pocketmine\network\protocol\ContainerSetSlotPacket; | |
| use pocketmine\network\protocol\DataPacket; | |
| use pocketmine\network\protocol\DisconnectPacket; | |
| use pocketmine\network\protocol\DropItemPacket; | |
| use pocketmine\network\protocol\EntityDataPacket; | |
| use pocketmine\network\protocol\EntityEventPacket; | |
| use pocketmine\network\protocol\ExplodePacket; | |
| use pocketmine\network\protocol\HurtArmorPacket; | |
| use pocketmine\network\protocol\Info as ProtocolInfo; | |
| use pocketmine\network\protocol\InteractPacket; | |
| use pocketmine\network\protocol\LevelEventPacket; | |
| use pocketmine\network\protocol\LoginPacket; | |
| use pocketmine\network\protocol\LoginStatusPacket; | |
| use pocketmine\network\protocol\MessagePacket; | |
| use pocketmine\network\protocol\MoveEntityPacket; | |
| use pocketmine\network\protocol\MoveEntityPacket_PosRot; | |
| use pocketmine\network\protocol\MovePlayerPacket; | |
| use pocketmine\network\protocol\PingPacket; | |
| use pocketmine\network\protocol\PlayerActionPacket; | |
| use pocketmine\network\protocol\PlayerArmorEquipmentPacket; | |
| use pocketmine\network\protocol\PlayerEquipmentPacket; | |
| use pocketmine\network\protocol\PongPacket; | |
| use pocketmine\network\protocol\ReadyPacket; | |
| use pocketmine\network\protocol\RemoveBlockPacket; | |
| use pocketmine\network\protocol\RemoveEntityPacket; | |
| use pocketmine\network\protocol\RemovePlayerPacket; | |
| use pocketmine\network\protocol\RequestChunkPacket; | |
| use pocketmine\network\protocol\RespawnPacket; | |
| use pocketmine\network\protocol\RotateHeadPacket; | |
| use pocketmine\network\protocol\SendInventoryPacket; | |
| use pocketmine\network\protocol\ServerHandshakePacket; | |
| use pocketmine\network\protocol\SetEntityDataPacket; | |
| use pocketmine\network\protocol\SetEntityMotionPacket; | |
| use pocketmine\network\protocol\SetHealthPacket; | |
| use pocketmine\network\protocol\SetSpawnPositionPacket; | |
| use pocketmine\network\protocol\SetTimePacket; | |
| use pocketmine\network\protocol\StartGamePacket; | |
| use pocketmine\network\protocol\TakeItemEntityPacket; | |
| use pocketmine\network\protocol\TileEventPacket; | |
| use pocketmine\network\protocol\UnknownPacket; | |
| use pocketmine\network\protocol\UpdateBlockPacket; | |
| use pocketmine\network\protocol\UseItemPacket; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class Packet extends NetworkPacket{ | |
| private $packetID; | |
| private $offset = 1; | |
| public $data = array(); | |
| public function __construct($packetID){ | |
| $this->packetID = (int) $packetID; | |
| } | |
| public function pid(){ | |
| return $this->packetID; | |
| } | |
| protected function get($len){ | |
| if($len < 0){ | |
| $this->offset = strlen($this->buffer) - 1; | |
| return ""; | |
| }elseif($len === true){ | |
| return substr($this->buffer, $this->offset); | |
| } | |
| $buffer = ""; | |
| for(; $len > 0; --$len, ++$this->offset){ | |
| $buffer .= @$this->buffer{$this->offset}; | |
| } | |
| return $buffer; | |
| } | |
| private function getLong($unsigned = false){ | |
| return Binary::readLong($this->get(8), $unsigned); | |
| } | |
| private function getInt(){ | |
| return Binary::readInt($this->get(4)); | |
| } | |
| private function getShort($unsigned = false){ | |
| return Binary::readShort($this->get(2), $unsigned); | |
| } | |
| private function getLTriad(){ | |
| return Binary::readTriad(strrev($this->get(3))); | |
| } | |
| private function getByte(){ | |
| return ord($this->buffer{$this->offset++}); | |
| } | |
| private function feof(){ | |
| return !isset($this->buffer{$this->offset}); | |
| } | |
| public function decode(){ | |
| $this->offset = 1; | |
| switch($this->packetID){ | |
| case Info::UNCONNECTED_PING: | |
| case Info::UNCONNECTED_PING_OPEN_CONNECTIONS: | |
| $this->pingID = $this->getLong(); | |
| $this->offset += 16; //Magic | |
| break; | |
| case Info::OPEN_CONNECTION_REQUEST_1: | |
| $this->offset += 16; //Magic | |
| $this->structure = $this->getByte(); | |
| $this->mtuSize = strlen($this->get(true)); | |
| break; | |
| case Info::OPEN_CONNECTION_REQUEST_2: | |
| $this->offset += 16; //Magic | |
| $this->security = $this->get(5); | |
| $this->clientPort = $this->getShort(false); | |
| $this->mtuSize = $this->getShort(false); | |
| $this->clientID = $this->getLong(); | |
| break; | |
| case Info::DATA_PACKET_0: | |
| case Info::DATA_PACKET_1: | |
| case Info::DATA_PACKET_2: | |
| case Info::DATA_PACKET_3: | |
| case Info::DATA_PACKET_4: | |
| case Info::DATA_PACKET_5: | |
| case Info::DATA_PACKET_6: | |
| case Info::DATA_PACKET_7: | |
| case Info::DATA_PACKET_8: | |
| case Info::DATA_PACKET_9: | |
| case Info::DATA_PACKET_A: | |
| case Info::DATA_PACKET_B: | |
| case Info::DATA_PACKET_C: | |
| case Info::DATA_PACKET_D: | |
| case Info::DATA_PACKET_E: | |
| case Info::DATA_PACKET_F: | |
| $this->seqNumber = $this->getLTriad(); | |
| $this->data = array(); | |
| while(!$this->feof() and $this->parseDataPacket() !== false){ | |
| } | |
| break; | |
| case Info::NACK: | |
| case Info::ACK: | |
| $count = $this->getShort(); | |
| $this->packets = array(); | |
| for($i = 0; $i < $count and !$this->feof(); ++$i){ | |
| if($this->getByte() === 0){ | |
| $start = $this->getLTriad(); | |
| $end = $this->getLTriad(); | |
| if(($end - $start) > 4096){ | |
| $end = $start + 4096; | |
| } | |
| for($c = $start; $c <= $end; ++$c){ | |
| $this->packets[] = $c; | |
| } | |
| }else{ | |
| $this->packets[] = $this->getLTriad(); | |
| } | |
| } | |
| break; | |
| default: | |
| break; | |
| } | |
| } | |
| private function parseDataPacket(){ | |
| $packetFlags = $this->getByte(); | |
| $reliability = ($packetFlags & 0b11100000) >> 5; | |
| $hasSplit = ($packetFlags & 0b00010000) > 0; | |
| $length = (int) ceil($this->getShort() / 8); | |
| if($reliability === 2 | |
| or $reliability === 3 | |
| or $reliability === 4 | |
| or $reliability === 6 | |
| or $reliability === 7 | |
| ){ | |
| $messageIndex = $this->getLTriad(); | |
| }else{ | |
| $messageIndex = false; | |
| } | |
| if($reliability === 1 | |
| or $reliability === 3 | |
| or $reliability === 4 | |
| or $reliability === 7 | |
| ){ | |
| $orderIndex = $this->getLTriad(); | |
| $orderChannel = $this->getByte(); | |
| }else{ | |
| $orderIndex = false; | |
| $orderChannel = false; | |
| } | |
| if($hasSplit == true){ | |
| $splitCount = $this->getInt(); | |
| $splitID = $this->getShort(); | |
| $splitIndex = $this->getInt(); | |
| }else{ | |
| $splitCount = false; | |
| $splitID = false; | |
| $splitIndex = false; | |
| } | |
| if($length <= 0 | |
| or $orderChannel >= 32 | |
| or ($hasSplit === true and $splitIndex >= $splitCount) | |
| ){ | |
| return false; | |
| }else{ | |
| $pid = $this->getByte(); | |
| $buffer = $this->get($length - 1); | |
| if(strlen($buffer) < ($length - 1)){ | |
| return false; | |
| } | |
| switch($pid){ | |
| case ProtocolInfo::PING_PACKET: | |
| $data = new PingPacket(); | |
| break; | |
| case ProtocolInfo::PONG_PACKET: | |
| $data = new PongPacket(); | |
| break; | |
| case ProtocolInfo::CLIENT_CONNECT_PACKET: | |
| $data = new ClientConnectPacket(); | |
| break; | |
| case ProtocolInfo::SERVER_HANDSHAKE_PACKET: | |
| $data = new ServerHandshakePacket(); | |
| break; | |
| case ProtocolInfo::DISCONNECT_PACKET: | |
| $data = new DisconnectPacket(); | |
| break; | |
| case ProtocolInfo::LOGIN_PACKET: | |
| $data = new LoginPacket(); | |
| break; | |
| case ProtocolInfo::LOGIN_STATUS_PACKET: | |
| $data = new LoginStatusPacket(); | |
| break; | |
| case ProtocolInfo::READY_PACKET: | |
| $data = new ReadyPacket(); | |
| break; | |
| case ProtocolInfo::MESSAGE_PACKET: | |
| $data = new MessagePacket(); | |
| break; | |
| case ProtocolInfo::SET_TIME_PACKET: | |
| $data = new SetTimePacket(); | |
| break; | |
| case ProtocolInfo::START_GAME_PACKET: | |
| $data = new StartGamePacket(); | |
| break; | |
| case ProtocolInfo::ADD_MOB_PACKET: | |
| $data = new AddMobPacket(); | |
| break; | |
| case ProtocolInfo::ADD_PLAYER_PACKET: | |
| $data = new AddPlayerPacket(); | |
| break; | |
| case ProtocolInfo::REMOVE_PLAYER_PACKET: | |
| $data = new RemovePlayerPacket(); | |
| break; | |
| case ProtocolInfo::ADD_ENTITY_PACKET: | |
| $data = new AddEntityPacket(); | |
| break; | |
| case ProtocolInfo::REMOVE_ENTITY_PACKET: | |
| $data = new RemoveEntityPacket(); | |
| break; | |
| case ProtocolInfo::ADD_ITEM_ENTITY_PACKET: | |
| $data = new AddItemEntityPacket(); | |
| break; | |
| case ProtocolInfo::TAKE_ITEM_ENTITY_PACKET: | |
| $data = new TakeItemEntityPacket(); | |
| break; | |
| case ProtocolInfo::MOVE_ENTITY_PACKET: | |
| $data = new MoveEntityPacket(); | |
| break; | |
| case ProtocolInfo::MOVE_ENTITY_PACKET_POSROT: | |
| $data = new MoveEntityPacket_PosRot(); | |
| break; | |
| case ProtocolInfo::ROTATE_HEAD_PACKET: | |
| $data = new RotateHeadPacket(); | |
| break; | |
| case ProtocolInfo::MOVE_PLAYER_PACKET: | |
| $data = new MovePlayerPacket(); | |
| break; | |
| case ProtocolInfo::REMOVE_BLOCK_PACKET: | |
| $data = new RemoveBlockPacket(); | |
| break; | |
| case ProtocolInfo::UPDATE_BLOCK_PACKET: | |
| $data = new UpdateBlockPacket(); | |
| break; | |
| case ProtocolInfo::ADD_PAINTING_PACKET: | |
| $data = new AddPaintingPacket(); | |
| break; | |
| case ProtocolInfo::EXPLODE_PACKET: | |
| $data = new ExplodePacket(); | |
| break; | |
| case ProtocolInfo::LEVEL_EVENT_PACKET: | |
| $data = new LevelEventPacket(); | |
| break; | |
| case ProtocolInfo::TILE_EVENT_PACKET: | |
| $data = new TileEventPacket(); | |
| break; | |
| case ProtocolInfo::ENTITY_EVENT_PACKET: | |
| $data = new EntityEventPacket(); | |
| break; | |
| case ProtocolInfo::REQUEST_CHUNK_PACKET: | |
| $data = new RequestChunkPacket(); | |
| break; | |
| case ProtocolInfo::CHUNK_DATA_PACKET: | |
| $data = new ChunkDataPacket(); | |
| break; | |
| case ProtocolInfo::PLAYER_EQUIPMENT_PACKET: | |
| $data = new PlayerEquipmentPacket(); | |
| break; | |
| case ProtocolInfo::PLAYER_ARMOR_EQUIPMENT_PACKET: | |
| $data = new PlayerArmorEquipmentPacket(); | |
| break; | |
| case ProtocolInfo::INTERACT_PACKET: | |
| $data = new InteractPacket(); | |
| break; | |
| case ProtocolInfo::USE_ITEM_PACKET: | |
| $data = new UseItemPacket(); | |
| break; | |
| case ProtocolInfo::PLAYER_ACTION_PACKET: | |
| $data = new PlayerActionPacket(); | |
| break; | |
| case ProtocolInfo::HURT_ARMOR_PACKET: | |
| $data = new HurtArmorPacket(); | |
| break; | |
| case ProtocolInfo::SET_ENTITY_DATA_PACKET: | |
| $data = new SetEntityDataPacket(); | |
| break; | |
| case ProtocolInfo::SET_ENTITY_MOTION_PACKET: | |
| $data = new SetEntityMotionPacket(); | |
| break; | |
| case ProtocolInfo::SET_HEALTH_PACKET: | |
| $data = new SetHealthPacket(); | |
| break; | |
| case ProtocolInfo::SET_SPAWN_POSITION_PACKET: | |
| $data = new SetSpawnPositionPacket(); | |
| break; | |
| case ProtocolInfo::ANIMATE_PACKET: | |
| $data = new AnimatePacket(); | |
| break; | |
| case ProtocolInfo::RESPAWN_PACKET: | |
| $data = new RespawnPacket(); | |
| break; | |
| case ProtocolInfo::SEND_INVENTORY_PACKET: | |
| $data = new SendInventoryPacket(); | |
| break; | |
| case ProtocolInfo::DROP_ITEM_PACKET: | |
| $data = new DropItemPacket(); | |
| break; | |
| case ProtocolInfo::CONTAINER_OPEN_PACKET: | |
| $data = new ContainerOpenPacket(); | |
| break; | |
| case ProtocolInfo::CONTAINER_CLOSE_PACKET: | |
| $data = new ContainerClosePacket(); | |
| break; | |
| case ProtocolInfo::CONTAINER_SET_SLOT_PACKET: | |
| $data = new ContainerSetSlotPacket(); | |
| break; | |
| case ProtocolInfo::CONTAINER_SET_DATA_PACKET: | |
| $data = new ContainerSetDataPacket(); | |
| break; | |
| case ProtocolInfo::CONTAINER_SET_CONTENT_PACKET: | |
| $data = new ContainerSetContentPacket(); | |
| break; | |
| case ProtocolInfo::CHAT_PACKET: | |
| $data = new ChatPacket(); | |
| break; | |
| case ProtocolInfo::ADVENTURE_SETTINGS_PACKET: | |
| $data = new AdventureSettingsPacket(); | |
| break; | |
| case ProtocolInfo::ENTITY_DATA_PACKET: | |
| $data = new EntityDataPacket(); | |
| break; | |
| default: | |
| $data = new UnknownPacket(); | |
| $data->packetID = $pid; | |
| break; | |
| } | |
| $data->reliability = $reliability; | |
| $data->hasSplit = $hasSplit; | |
| $data->messageIndex = $messageIndex; | |
| $data->orderIndex = $orderIndex; | |
| $data->orderChannel = $orderChannel; | |
| $data->splitCount = $splitCount; | |
| $data->splitID = $splitID; | |
| $data->splitIndex = $splitIndex; | |
| $data->setBuffer($buffer); | |
| $this->data[] = $data; | |
| } | |
| return true; | |
| } | |
| public function encode(){ | |
| if(strlen($this->buffer) > 0){ | |
| return; | |
| } | |
| $this->buffer = chr($this->packetID); | |
| switch($this->packetID){ | |
| case Info::OPEN_CONNECTION_REPLY_1: | |
| $this->buffer .= Info::MAGIC; | |
| $this->putLong($this->serverID); | |
| $this->putByte(0); //server security | |
| $this->putShort($this->mtuSize); | |
| break; | |
| case Info::OPEN_CONNECTION_REPLY_2: | |
| $this->buffer .= Info::MAGIC; | |
| $this->putLong($this->serverID); | |
| $this->putShort($this->serverPort); | |
| $this->putShort($this->mtuSize); | |
| $this->putByte(0); //Server security | |
| break; | |
| case Info::INCOMPATIBLE_PROTOCOL_VERSION: | |
| $this->putByte(Info::STRUCTURE); | |
| $this->buffer .= Info::MAGIC; | |
| $this->putLong($this->serverID); | |
| break; | |
| case Info::UNCONNECTED_PONG: | |
| case Info::ADVERTISE_SYSTEM: | |
| $this->putLong($this->pingID); | |
| $this->putLong($this->serverID); | |
| $this->buffer .= Info::MAGIC; | |
| $this->putString($this->serverType); | |
| break; | |
| case Info::DATA_PACKET_0: | |
| case Info::DATA_PACKET_1: | |
| case Info::DATA_PACKET_2: | |
| case Info::DATA_PACKET_3: | |
| case Info::DATA_PACKET_4: | |
| case Info::DATA_PACKET_5: | |
| case Info::DATA_PACKET_6: | |
| case Info::DATA_PACKET_7: | |
| case Info::DATA_PACKET_8: | |
| case Info::DATA_PACKET_9: | |
| case Info::DATA_PACKET_A: | |
| case Info::DATA_PACKET_B: | |
| case Info::DATA_PACKET_C: | |
| case Info::DATA_PACKET_D: | |
| case Info::DATA_PACKET_E: | |
| case Info::DATA_PACKET_F: | |
| $this->putLTriad($this->seqNumber); | |
| foreach($this->data as $pk){ | |
| $this->encodeDataPacket($pk); | |
| } | |
| break; | |
| case Info::NACK: | |
| case Info::ACK: | |
| $payload = ""; | |
| $records = 0; | |
| $pointer = 0; | |
| sort($this->packets, SORT_NUMERIC); | |
| $max = count($this->packets); | |
| while($pointer < $max){ | |
| $type = true; | |
| $curr = $start = $this->packets[$pointer]; | |
| for($i = $start + 1; $i < $max; ++$i){ | |
| $n = $this->packets[$i]; | |
| if(($n - $curr) === 1){ | |
| $curr = $end = $n; | |
| $type = false; | |
| $pointer = $i + 1; | |
| }else{ | |
| break; | |
| } | |
| } | |
| ++$pointer; | |
| if($type === false){ | |
| $payload .= "\x00"; | |
| $payload .= strrev(Binary::writeTriad($start)); | |
| $payload .= strrev(Binary::writeTriad($end)); | |
| }else{ | |
| $payload .= Binary::writeBool(true); | |
| $payload .= strrev(Binary::writeTriad($start)); | |
| } | |
| ++$records; | |
| } | |
| $this->putShort($records); | |
| $this->buffer .= $payload; | |
| break; | |
| default: | |
| } | |
| } | |
| private function encodeDataPacket(DataPacket $pk){ | |
| $this->putByte(($pk->reliability << 5) | ($pk->hasSplit > 0 ? 0b00010000 : 0)); | |
| $this->putShort(strlen($pk->buffer) << 3); | |
| if($pk->reliability === 2 | |
| or $pk->reliability === 3 | |
| or $pk->reliability === 4 | |
| or $pk->reliability === 6 | |
| or $pk->reliability === 7 | |
| ){ | |
| $this->putLTriad($pk->messageIndex); | |
| } | |
| if($pk->reliability === 1 | |
| or $pk->reliability === 3 | |
| or $pk->reliability === 4 | |
| or $pk->reliability === 7 | |
| ){ | |
| $this->putLTriad($pk->orderIndex); | |
| $this->putByte($pk->orderChannel); | |
| } | |
| if($pk->hasSplit === true){ | |
| $this->putInt($pk->splitCount); | |
| $this->putShort($pk->splitID); | |
| $this->putInt($pk->splitIndex); | |
| } | |
| $this->buffer .= $pk->buffer; | |
| } | |
| protected function put($str){ | |
| $this->buffer .= $str; | |
| } | |
| protected function putLong($v){ | |
| $this->buffer .= Binary::writeLong($v); | |
| } | |
| protected function putInt($v){ | |
| $this->buffer .= Binary::writeInt($v); | |
| } | |
| protected function putShort($v){ | |
| $this->buffer .= Binary::writeShort($v); | |
| } | |
| protected function putTriad($v){ | |
| $this->buffer .= Binary::writeTriad($v); | |
| } | |
| protected function putLTriad($v){ | |
| $this->buffer .= strrev(Binary::writeTriad($v)); | |
| } | |
| protected function putByte($v){ | |
| $this->buffer .= chr($v); | |
| } | |
| protected function putString($v){ | |
| $this->putShort(strlen($v)); | |
| $this->put($v); | |
| } | |
| public function __destruct(){ | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Implementation of the Source RCON Protocol to allow remote console commands | |
| * Source: https://developer.valvesoftware.com/wiki/Source_RCON_Protocol | |
| */ | |
| namespace pocketmine\network\rcon; | |
| use pocketmine\command\RemoteConsoleCommandSender; | |
| use pocketmine\scheduler\CallbackTask; | |
| use pocketmine\Server; | |
| use pocketmine\utils\TextFormat; | |
| class RCON{ | |
| private $socket; | |
| private $password; | |
| /** @var RCONInstance[] */ | |
| private $workers; | |
| private $threads; | |
| private $clientsPerThread; | |
| private $rconSender; | |
| public function __construct($password, $port = 19132, $interface = "0.0.0.0", $threads = 1, $clientsPerThread = 50){ | |
| $this->workers = array(); | |
| $this->password = (string) $password; | |
| console("[INFO] Starting remote control listener"); | |
| if($this->password === ""){ | |
| console("[ERROR] RCON can't be started: Empty password"); | |
| return; | |
| } | |
| $this->threads = (int) max(1, $threads); | |
| $this->clientsPerThread = (int) max(1, $clientsPerThread); | |
| $this->socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP); | |
| if($this->socket === false or !socket_bind($this->socket, $interface, (int) $port) or !socket_listen($this->socket)){ | |
| console("[ERROR] RCON can't be started: " . socket_strerror(socket_last_error())); | |
| return; | |
| } | |
| @socket_set_block($this->socket); | |
| for($n = 0; $n < $this->threads; ++$n){ | |
| $this->workers[$n] = new RCONInstance($this->socket, $this->password, $this->clientsPerThread); | |
| } | |
| @socket_getsockname($this->socket, $addr, $port); | |
| console("[INFO] RCON running on $addr:$port"); | |
| Server::getInstance()->getScheduler()->scheduleRepeatingTask(new CallbackTask(array($this, "check")), 3); | |
| } | |
| public function stop(){ | |
| for($n = 0; $n < $this->threads; ++$n){ | |
| $this->workers[$n]->close(); | |
| usleep(50000); | |
| $this->workers[$n]->kill(); | |
| } | |
| @socket_close($this->socket); | |
| $this->threads = 0; | |
| } | |
| public function check(){ | |
| for($n = 0; $n < $this->threads; ++$n){ | |
| if($this->workers[$n]->isTerminated() === true){ | |
| $this->workers[$n] = new RCONInstance($this->socket, $this->password, $this->clientsPerThread); | |
| }elseif($this->workers[$n]->isWaiting()){ | |
| if($this->workers[$n]->response !== ""){ | |
| console($this->workers[$n]->response); | |
| $this->workers[$n]->notify(); | |
| }else{ | |
| Server::getInstance()->dispatchCommand($response = new RemoteConsoleCommandSender(), $this->workers[$n]->cmd); | |
| $this->workers[$n]->response = TextFormat::clean($response->getMessage()); | |
| $this->workers[$n]->notify(); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\network\rcon; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\Utils; | |
| class RCONInstance extends \Thread{ | |
| public $stop; | |
| public $cmd; | |
| public $response; | |
| private $socket; | |
| private $password; | |
| private $maxClients; | |
| public function __construct($socket, $password, $maxClients = 50){ | |
| $this->stop = false; | |
| $this->cmd = ""; | |
| $this->response = ""; | |
| $this->socket = $socket; | |
| $this->password = $password; | |
| $this->maxClients = (int) $maxClients; | |
| for($n = 0; $n < $this->maxClients; ++$n){ | |
| $this->{"client" . $n} = null; | |
| $this->{"status" . $n} = 0; | |
| $this->{"timeout" . $n} = 0; | |
| } | |
| $this->start(); | |
| } | |
| private function writePacket($client, $requestID, $packetType, $payload){ | |
| $pk = Binary::writeLInt((int) $requestID) | |
| . Binary::writeLInt((int) $packetType) | |
| . $payload | |
| . "\x00\x00"; //Terminate payload and packet | |
| return socket_write($client, Binary::writeLInt(strlen($pk)) . $pk); | |
| } | |
| private function readPacket($client, &$size, &$requestID, &$packetType, &$payload){ | |
| @socket_set_nonblock($client); | |
| $d = socket_read($client, 4); | |
| if($this->stop === true){ | |
| return false; | |
| }elseif($d === false){ | |
| return null; | |
| }elseif($d === "" or strlen($d) < 4){ | |
| return false; | |
| } | |
| @socket_set_block($client); | |
| $size = Binary::readLInt($d); | |
| if($size < 0 or $size > 65535){ | |
| return false; | |
| } | |
| $requestID = Binary::readLInt(socket_read($client, 4)); | |
| $packetType = Binary::readLInt(socket_read($client, 4)); | |
| $payload = rtrim(socket_read($client, $size + 2)); //Strip two null bytes | |
| return true; | |
| } | |
| public function close(){ | |
| $this->stop = true; | |
| } | |
| public function run(){ | |
| while($this->stop !== true){ | |
| usleep(2000); | |
| $r = array($socket = $this->socket); | |
| $w = null; | |
| $e = null; | |
| if(socket_select($r, $w, $e, 0) === 1){ | |
| if(($client = socket_accept($this->socket)) !== false){ | |
| socket_set_block($client); | |
| socket_set_option($client, SOL_SOCKET, SO_KEEPALIVE, 1); | |
| $done = false; | |
| for($n = 0; $n < $this->maxClients; ++$n){ | |
| if($this->{"client" . $n} === null){ | |
| $this->{"client" . $n} = $client; | |
| $this->{"status" . $n} = 0; | |
| $this->{"timeout" . $n} = microtime(true) + 5; | |
| $done = true; | |
| break; | |
| } | |
| } | |
| if($done === false){ | |
| @socket_close($client); | |
| } | |
| } | |
| } | |
| for($n = 0; $n < $this->maxClients; ++$n){ | |
| $client = & $this->{"client" . $n}; | |
| if($client !== null){ | |
| if($this->{"status" . $n} !== -1 and $this->stop !== true){ | |
| if($this->{"status" . $n} === 0 and $this->{"timeout" . $n} < microtime(true)){ //Timeout | |
| $this->{"status" . $n} = -1; | |
| continue; | |
| } | |
| $p = $this->readPacket($client, $size, $requestID, $packetType, $payload); | |
| if($p === false){ | |
| $this->{"status" . $n} = -1; | |
| continue; | |
| }elseif($p === null){ | |
| continue; | |
| } | |
| switch($packetType){ | |
| case 3: //Login | |
| if($this->{"status" . $n} !== 0){ | |
| $this->{"status" . $n} = -1; | |
| continue; | |
| } | |
| if($payload === $this->password){ | |
| @socket_getpeername($client, $addr, $port); | |
| $this->response = "[INFO] Successful Rcon connection from: /$addr:$port"; | |
| $this->wait(); | |
| $this->response = ""; | |
| $this->writePacket($client, $requestID, 2, ""); | |
| $this->{"status" . $n} = 1; | |
| }else{ | |
| $this->{"status" . $n} = -1; | |
| $this->writePacket($client, -1, 2, ""); | |
| continue; | |
| } | |
| break; | |
| case 2: //Command | |
| if($this->{"status" . $n} !== 1){ | |
| $this->{"status" . $n} = -1; | |
| continue; | |
| } | |
| if(strlen($payload) > 0){ | |
| $this->cmd = ltrim($payload); | |
| $this->wait(); | |
| $this->writePacket($client, $requestID, 0, str_replace("\n", "\r\n", trim($this->response))); | |
| $this->response = ""; | |
| $this->cmd = ""; | |
| } | |
| break; | |
| } | |
| usleep(1); | |
| }else{ | |
| @socket_set_option($client, SOL_SOCKET, SO_LINGER, array("l_onoff" => 1, "l_linger" => 1)); | |
| @socket_shutdown($client, 2); | |
| @socket_set_block($client); | |
| @socket_read($client, 1); | |
| @socket_close($client); | |
| $this->{"status" . $n} = 0; | |
| $this->{"client" . $n} = null; | |
| } | |
| } | |
| } | |
| } | |
| unset($this->socket, $this->cmd, $this->response, $this->stop); | |
| exit(0); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Network-related classes | |
| */ | |
| namespace pocketmine\network; | |
| use pocketmine\network\query\QueryPacket; | |
| use pocketmine\network\raknet\Info; | |
| use pocketmine\network\raknet\Packet as RakNetPacket; | |
| class ThreadedHandler extends \Thread{ | |
| protected $bandwidthUp; | |
| protected $bandwidthDown; | |
| protected $bandwidthTime; | |
| private $socket; | |
| protected $packets; | |
| protected $queue; | |
| protected $stop; | |
| protected $server; | |
| protected $port; | |
| protected $serverip; | |
| protected $recvIn; | |
| protected $recvOut; | |
| protected $sendIn; | |
| public $path; | |
| function __construct($server, $port = 19132, $serverip = "0.0.0.0"){ | |
| $this->server = $server; | |
| $this->port = $port; | |
| $this->serverip = $serverip; | |
| $this->bandwidthUp = 0; | |
| $this->bandwidthDown = 0; | |
| $this->bandwidthTime = microtime(true); | |
| $this->packets = new \Threaded(); | |
| $this->queue = new \Threaded(); | |
| $this->stop = false; | |
| //Load the classes so the Thread gets them | |
| Info::isValid(0); | |
| new Packet(0); | |
| new QueryPacket(); | |
| new RakNetPacket(0); | |
| $this->path = \pocketmine\PATH; | |
| $this->start(PTHREADS_INHERIT_ALL & ~PTHREADS_INHERIT_CLASSES); | |
| } | |
| public function close(){ | |
| $this->synchronized(function (){ | |
| $this->stop = true; | |
| socket_close($this->socket); | |
| }); | |
| } | |
| /** | |
| * Upload speed in bytes/s | |
| * | |
| * @return float | |
| */ | |
| public function getUploadSpeed(){ | |
| return $this->bandwidthUp / max(1, microtime(true) - $this->bandwidthTime); | |
| } | |
| /** | |
| * Download speed in bytes/s | |
| * | |
| * @return float | |
| */ | |
| public function getDownloadSpeed(){ | |
| return $this->bandwidthDown / max(1, microtime(true) - $this->bandwidthTime); | |
| } | |
| /** | |
| * @return Packet | |
| */ | |
| public function readPacket(){ | |
| return $this->packets->shift(); | |
| } | |
| /** | |
| * @param Packet $packet | |
| * | |
| * @return int | |
| */ | |
| public function writePacket(Packet $packet){ | |
| $this->queue[] = $packet; | |
| return strlen($packet->buffer); | |
| } | |
| public function run(){ | |
| require($this->path . "src/spl/SplClassLoader.php"); | |
| $autoloader = new \SplClassLoader(); | |
| $autoloader->add("pocketmine", array( | |
| $this->path . "src" | |
| )); | |
| $autoloader->register(true); | |
| $this->socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP); | |
| socket_set_option($this->socket, SOL_SOCKET, SO_BROADCAST, 1); //Allow sending broadcast messages | |
| if(@socket_bind($this->socket, $this->serverip, $this->port) === true){ | |
| socket_set_option($this->socket, SOL_SOCKET, SO_REUSEADDR, 0); | |
| @socket_set_option($this->socket, SOL_SOCKET, SO_SNDBUF, 1024 * 1024 * 2); //2MB | |
| @socket_set_option($this->socket, SOL_SOCKET, SO_RCVBUF, 1024 * 1024); //1MB | |
| }else{ | |
| console("[SEVERE] **** FAILED TO BIND TO " . $this->serverip . ":" . $this->port . "!", true, true, 0); | |
| console("[SEVERE] Perhaps a server is already running on that port?", true, true, 0); | |
| exit(1); | |
| } | |
| socket_set_nonblock($this->socket); | |
| $count = 0; | |
| while($this->stop === false){ | |
| if($this->getPacket() === false and $this->putPacket() === false){ | |
| ++$count; | |
| }else{ | |
| $count = 0; | |
| } | |
| if($count > 128){ | |
| $this->wait(100000); | |
| } | |
| } | |
| } | |
| private function putPacket(){ | |
| if(($packet = $this->queue->shift()) instanceof Packet){ | |
| if($packet instanceof RakNetPacket){ | |
| $packet->encode(); | |
| } | |
| $this->bandwidthUp += @socket_sendto($this->socket, $packet->buffer, strlen($packet->buffer), 0, $packet->ip, $packet->port); | |
| return true; | |
| } | |
| return false; | |
| } | |
| private function getPacket(){ | |
| $buffer = null; | |
| $source = null; | |
| $port = null; | |
| $len = @socket_recvfrom($this->socket, $buffer, 65535, 0, $source, $port); | |
| if($len === false or $len == 0){ | |
| return false; | |
| } | |
| $this->bandwidthDown += $len; | |
| $pid = ord($buffer{0}); | |
| if(Info::isValid($pid)){ | |
| $packet = new RakNetPacket($pid); | |
| $packet->buffer =& $buffer; | |
| $packet->ip = $source; | |
| $packet->port = $port; | |
| $packet->decode(); | |
| }elseif($pid === 0xfe and $buffer{1} === "\xfd"){ | |
| $packet = new QueryPacket; | |
| $packet->ip = $source; | |
| $packet->port = $port; | |
| $packet->buffer =& $buffer; | |
| }else{ | |
| $packet = new Packet($pid); | |
| $packet->ip = $source; | |
| $packet->port = $port; | |
| $packet->buffer =& $buffer; | |
| } | |
| $this->packets[] = $packet; | |
| return true; | |
| } | |
| } | |
| ?><?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * UPnP port forwarding support. Only for Windows | |
| */ | |
| namespace pocketmine\network\upnp; | |
| use pocketmine\utils\Utils; | |
| abstract class UPnP{ | |
| public static function PortForward($port){ | |
| if(Utils::$online === false){ | |
| return false; | |
| } | |
| if(Utils::getOS() != "win" or !class_exists("COM")){ | |
| return false; | |
| } | |
| $port = (int) $port; | |
| $myLocalIP = gethostbyname(trim(`hostname`)); | |
| try{ | |
| $com = new \COM("HNetCfg.NATUPnP"); | |
| if($com === false or !is_object($com->StaticPortMappingCollection)){ | |
| return false; | |
| } | |
| $com->StaticPortMappingCollection->Add($port, "UDP", $port, $myLocalIP, true, "PocketMine-MP"); | |
| }catch(\Exception $e){ | |
| return false; | |
| } | |
| return true; | |
| } | |
| public static function RemovePortForward($port){ | |
| if(Utils::$online === false){ | |
| return false; | |
| } | |
| if(Utils::getOS() != "win" or !class_exists("COM")){ | |
| return false; | |
| } | |
| $port = (int) $port; | |
| try{ | |
| $com = new \COM("HNetCfg.NATUPnP") or false; | |
| if($com === false or !is_object($com->StaticPortMappingCollection)){ | |
| return false; | |
| } | |
| $com->StaticPortMappingCollection->Remove($port, "UDP"); | |
| }catch(\Exception $e){ | |
| return false; | |
| } | |
| return true; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine; | |
| use pocketmine\nbt\tag\Compound; | |
| class OfflinePlayer implements IPlayer{ | |
| private $name; | |
| private $server; | |
| private $namedtag; | |
| /** | |
| * @param Server $server | |
| * @param string $name | |
| */ | |
| public function __construct(Server $server, $name){ | |
| $this->server = $server; | |
| $this->name = $name; | |
| if(file_exists($this->server->getDataPath() . "players/" . strtolower($this->getName()) . ".dat")){ | |
| $this->namedtag = $this->server->getOfflinePlayerData($this->name); | |
| }else{ | |
| $this->namedtag = null; | |
| } | |
| } | |
| public function isOnline(){ | |
| return $this->getPlayer() !== null; | |
| } | |
| public function getName(){ | |
| return $this->name; | |
| } | |
| public function getServer(){ | |
| return $this->server; | |
| } | |
| public function isOp(){ | |
| return $this->server->isOp(strtolower($this->getName())); | |
| } | |
| public function setOp($value){ | |
| if($value === $this->isOp()){ | |
| return; | |
| } | |
| if($value === true){ | |
| $this->server->addOp(strtolower($this->getName())); | |
| }else{ | |
| $this->server->removeOp(strtolower($this->getName())); | |
| } | |
| } | |
| public function isBanned(){ | |
| return $this->server->getNameBans()->isBanned(strtolower($this->getName())); | |
| } | |
| public function setBanned($value){ | |
| if($value === true){ | |
| $this->server->getNameBans()->addBan($this->getName(), null, null, null); | |
| }else{ | |
| $this->server->getNameBans()->remove($this->getName()); | |
| } | |
| } | |
| public function isWhitelisted(){ | |
| return $this->server->isWhitelisted(strtolower($this->getName())); | |
| } | |
| public function setWhitelisted($value){ | |
| if($value === true){ | |
| $this->server->addWhitelist(strtolower($this->getName())); | |
| }else{ | |
| $this->server->removeWhitelist(strtolower($this->getName())); | |
| } | |
| } | |
| public function getPlayer(){ | |
| return $this->server->getPlayerExact($this->getName()); | |
| } | |
| public function getFirstPlayed(){ | |
| return $this->namedtag instanceof Compound ? $this->namedtag["firstPlayed"] : null; | |
| } | |
| public function getLastPlayed(){ | |
| return $this->namedtag instanceof Compound ? $this->namedtag["lastPlayed"] : null; | |
| } | |
| public function hasPlayedBefore(){ | |
| return $this->namedtag instanceof Compound; | |
| } | |
| } | |
| <?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| class BanEntry{ | |
| public static $format = "Y-m-d H:i:s O"; | |
| private $name; | |
| /** @var \DateTime */ | |
| private $creationDate = null; | |
| private $source = "(Unknown)"; | |
| /** @var \DateTime */ | |
| private $expirationDate = null; | |
| private $reason = "Banned by an operator."; | |
| public function __construct($name){ | |
| $this->name = strtolower($name); | |
| $this->creationDate = new \DateTime(); | |
| } | |
| public function getName(){ | |
| return $this->name; | |
| } | |
| public function getCreated(){ | |
| return $this->creationDate; | |
| } | |
| public function setCreated(\DateTime $date){ | |
| $this->creationDate = $date; | |
| } | |
| public function getSource(){ | |
| return $this->source; | |
| } | |
| public function setSource($source){ | |
| $this->source = $source; | |
| } | |
| public function getExpires(){ | |
| return $this->expirationDate; | |
| } | |
| /** | |
| * @param \DateTime $date | |
| */ | |
| public function setExpires($date){ | |
| $this->expirationDate = $date; | |
| } | |
| public function hasExpired(){ | |
| $now = new \DateTime(); | |
| return $this->expirationDate === null ? false : $this->expirationDate < $now; | |
| } | |
| public function getReason(){ | |
| return $this->reason; | |
| } | |
| public function setReason($reason){ | |
| $this->reason = $reason; | |
| } | |
| public function getString(){ | |
| $str = ""; | |
| $str .= $this->getName(); | |
| $str .= "|"; | |
| $str .= $this->getCreated()->format(self::$format); | |
| $str .= "|"; | |
| $str .= $this->getSource(); | |
| $str .= "|"; | |
| $str .= $this->getExpires() === null ? "Forever" : $this->getExpires()->format(self::$format); | |
| $str .= "|"; | |
| $str .= $this->getReason(); | |
| return $str; | |
| } | |
| /** | |
| * @param string $str | |
| * | |
| * @return BanEntry | |
| */ | |
| public static function fromString($str){ | |
| if(strlen($str) < 2){ | |
| return null; | |
| }else{ | |
| $str = explode("|", trim($str)); | |
| $entry = new BanEntry(trim(array_shift($str))); | |
| if(count($str) > 0){ | |
| $entry->setCreated(\DateTime::createFromFormat(self::$format, array_shift($str))); | |
| if(count($str) > 0){ | |
| $entry->setSource(trim(array_shift($str))); | |
| if(count($str) > 0){ | |
| $expire = trim(array_shift($str)); | |
| if(strtolower($expire) !== "forever" and strlen($expire) > 0){ | |
| $entry->setExpires(\DateTime::createFromFormat(self::$format, $expire)); | |
| } | |
| if(count($str) > 0){ | |
| $entry->setReason(trim(array_shift($str))); | |
| return $entry; | |
| }else{ | |
| return $entry; | |
| } | |
| } | |
| }else{ | |
| return $entry; | |
| } | |
| }else{ | |
| return $entry; | |
| } | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| use pocketmine\Server; | |
| class BanList{ | |
| /** @var BanEntry[] */ | |
| private $list = array(); | |
| /** @var string */ | |
| private $file; | |
| /** @var bool */ | |
| private $enabled = true; | |
| /** | |
| * @param string $file | |
| */ | |
| public function __construct($file){ | |
| $this->file = $file; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isEnabled(){ | |
| return $this->enabled === true; | |
| } | |
| /** | |
| * @param bool $flag | |
| */ | |
| public function setEnabled($flag){ | |
| $this->enabled = (bool) $flag; | |
| } | |
| /** | |
| * @return BanEntry[] | |
| */ | |
| public function getEntries(){ | |
| $this->removeExpired(); | |
| return $this->list; | |
| } | |
| /** | |
| * @param string $name | |
| * | |
| * @return bool | |
| */ | |
| public function isBanned($name){ | |
| $name = strtolower($name); | |
| if(!$this->isEnabled()){ | |
| return false; | |
| }else{ | |
| $this->removeExpired(); | |
| return isset($this->list[$name]); | |
| } | |
| } | |
| /** | |
| * @param BanEntry $entry | |
| */ | |
| public function add(BanEntry $entry){ | |
| $this->list[$entry->getName()] = $entry; | |
| $this->save(); | |
| } | |
| /** | |
| * @param string $target | |
| * @param string $reason | |
| * @param \DateTime $expires | |
| * @param string $source | |
| * | |
| * @return BanEntry | |
| */ | |
| public function addBan($target, $reason = null, $expires = null, $source = null){ | |
| $entry = new BanEntry($target); | |
| $entry->setSource($source != null ? $source : $entry->getSource()); | |
| $entry->setExpires($expires); | |
| $entry->setReason($reason != null ? $reason : $entry->getReason()); | |
| $this->list[$entry->getName()] = $entry; | |
| $this->save(); | |
| return $entry; | |
| } | |
| /** | |
| * @param string $name | |
| */ | |
| public function remove($name){ | |
| $name = strtolower($name); | |
| if(isset($this->list[$name])){ | |
| unset($this->list[$name]); | |
| $this->save(); | |
| } | |
| } | |
| public function removeExpired(){ | |
| foreach($this->list as $name => $entry){ | |
| if($entry->hasExpired()){ | |
| unset($this->list[$name]); | |
| } | |
| } | |
| } | |
| public function load(){ | |
| $this->list = array(); | |
| $fp = @fopen($this->file, "r"); | |
| if(is_resource($fp)){ | |
| while(($line = fgets($fp)) !== false){ | |
| if($line{0} !== "#"){ | |
| $entry = BanEntry::fromString($line); | |
| if($entry instanceof BanEntry){ | |
| $this->list[$entry->getName()] = $entry; | |
| } | |
| } | |
| } | |
| fclose($fp); | |
| }else{ | |
| console("[ERROR] Could not load ban list"); | |
| } | |
| } | |
| public function save($flag = true){ | |
| $this->removeExpired(); | |
| $fp = @fopen($this->file, "w"); | |
| if(is_resource($fp)){ | |
| if($flag === true){ | |
| fwrite($fp, "# Updated " . strftime("%x %H:%M", time()) . " by " . Server::getInstance()->getName() . " " . Server::getInstance()->getPocketMineVersion() . "\n"); | |
| fwrite($fp, "# victim name | ban date | banned by | banned until | reason\n\n"); | |
| } | |
| foreach($this->list as $entry){ | |
| fwrite($fp, $entry->getString() . "\n"); | |
| } | |
| fclose($fp); | |
| }else{ | |
| console("[ERROR] Could not save ban list"); | |
| } | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| use pocketmine\Server; | |
| abstract class DefaultPermissions{ | |
| const ROOT = "pocketmine"; | |
| /** | |
| * @param Permission $perm | |
| * @param Permission $parent | |
| * | |
| * @return Permission | |
| */ | |
| public static function registerPermission(Permission $perm, Permission $parent = null){ | |
| if($parent instanceof Permission){ | |
| $parent->getChildren()[$perm->getName()] = true; | |
| return self::registerPermission($perm); | |
| } | |
| Server::getInstance()->getPluginManager()->addPermission($perm); | |
| return Server::getInstance()->getPluginManager()->getPermission($perm->getName()); | |
| } | |
| public static function registerCorePermissions(){ | |
| $parent = self::registerPermission(new Permission(self::ROOT, "Allows using all PocketMine commands and utilities")); | |
| $broadcasts = self::registerPermission(new Permission(self::ROOT . ".broadcast", "Allows the user to receive all broadcast messages"), $parent); | |
| self::registerPermission(new Permission(self::ROOT . ".broadcast.admin", "Allows the user to receive administrative broadcasts", Permission::DEFAULT_OP), $broadcasts); | |
| self::registerPermission(new Permission(self::ROOT . ".broadcast.user", "Allows the user to receive user broadcasts", Permission::DEFAULT_TRUE), $broadcasts); | |
| $broadcasts->recalculatePermissibles(); | |
| $commands = self::registerPermission(new Permission(self::ROOT . ".command", "Allows using all PocketMine commands"), $parent); | |
| $whitelist = self::registerPermission(new Permission(self::ROOT . ".command.whitelist", "Allows the user to modify the server whitelist", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.whitelist.add", "Allows the user to add a player to the server whitelist"), $whitelist); | |
| self::registerPermission(new Permission(self::ROOT . ".command.whitelist.remove", "Allows the user to remove a player to the server whitelist"), $whitelist); | |
| self::registerPermission(new Permission(self::ROOT . ".command.whitelist.reload", "Allows the user to reload the server whitelist"), $whitelist); | |
| self::registerPermission(new Permission(self::ROOT . ".command.whitelist.enable", "Allows the user to enable the server whitelist"), $whitelist); | |
| self::registerPermission(new Permission(self::ROOT . ".command.whitelist.disable", "Allows the user to disable the server whitelist"), $whitelist); | |
| self::registerPermission(new Permission(self::ROOT . ".command.whitelist.list", "Allows the user to list all the players on the server whitelist"), $whitelist); | |
| $whitelist->recalculatePermissibles(); | |
| $ban = self::registerPermission(new Permission(self::ROOT . ".command.ban", "Allows the user to ban people", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.ban.player", "Allows the user to ban players"), $ban); | |
| self::registerPermission(new Permission(self::ROOT . ".command.ban.ip", "Allows the user to ban IP addresses"), $ban); | |
| $ban->recalculatePermissibles(); | |
| $unban = self::registerPermission(new Permission(self::ROOT . ".command.unban", "Allows the user to unban people", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.unban.player", "Allows the user to unban players"), $unban); | |
| self::registerPermission(new Permission(self::ROOT . ".command.unban.ip", "Allows the user to unban IP addresses"), $unban); | |
| $unban->recalculatePermissibles(); | |
| $op = self::registerPermission(new Permission(self::ROOT . ".command.op", "Allows the user to change operators", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.op.give", "Allows the user to give a player operator status"), $op); | |
| self::registerPermission(new Permission(self::ROOT . ".command.op.take", "Allows the user to take a players operator status"), $op); | |
| $op->recalculatePermissibles(); | |
| $save = self::registerPermission(new Permission(self::ROOT . ".command.save", "Allows the user to save the worlds", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.save.enable", "Allows the user to enable automatic saving"), $save); | |
| self::registerPermission(new Permission(self::ROOT . ".command.save.disable", "Allows the user to disable automatic saving"), $save); | |
| self::registerPermission(new Permission(self::ROOT . ".command.save.perform", "Allows the user to perform a manual save"), $save); | |
| $save->recalculatePermissibles(); | |
| $time = self::registerPermission(new Permission(self::ROOT . ".command.time", "Allows the user to alter the time", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.time.add", "Allows the user to fast-forward time"), $time); | |
| self::registerPermission(new Permission(self::ROOT . ".command.time.set", "Allows the user to change the time"), $time); | |
| $time->recalculatePermissibles(); | |
| self::registerPermission(new Permission(self::ROOT . ".command.kill", "Allows the user to commit suicide", Permission::DEFAULT_TRUE), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.me", "Allows the user to perform a chat action", Permission::DEFAULT_TRUE), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.tell", "Allows the user to privately message another player", Permission::DEFAULT_TRUE), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.say", "Allows the user to talk as the console", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.give", "Allows the user to give items to players", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.teleport", "Allows the user to teleport players", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.kick", "Allows the user to kick players", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.stop", "Allows the user to stop the server", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.list", "Allows the user to list all online players", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.help", "Allows the user to view the help menu", Permission::DEFAULT_TRUE), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.plugins", "Allows the user to view the list of plugins", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.reload", "Allows the user to reload the server settings", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.version", "Allows the user to view the version of the server", Permission::DEFAULT_TRUE), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.gamemode", "Allows the user to change the gamemode of players", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.defaultgamemode", "Allows the user to change the default gamemode", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.seed", "Allows the user to view the seed of the world", Permission::DEFAULT_OP), $commands); | |
| self::registerPermission(new Permission(self::ROOT . ".command.status", "Allows the user to view the server performance", Permission::DEFAULT_OP), $commands); | |
| $commands->recalculatePermissibles(); | |
| $parent->recalculatePermissibles(); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| use pocketmine\plugin\Plugin; | |
| interface Permissible extends ServerOperator{ | |
| /** | |
| * Checks if this instance has a permission overridden | |
| * | |
| * @param string|Permission $name | |
| * | |
| * @return boolean | |
| */ | |
| public function isPermissionSet($name); | |
| /** | |
| * Returns the permission value if overridden, or the default value if not | |
| * | |
| * @param string|Permission $name | |
| * | |
| * @return mixed | |
| */ | |
| public function hasPermission($name); | |
| /** | |
| * @param Plugin $plugin | |
| * @param string $name | |
| * @param bool $value | |
| * | |
| * @return PermissionAttachment | |
| */ | |
| public function addAttachment(Plugin $plugin, $name = null, $value = null); | |
| /** | |
| * @param PermissionAttachment $attachment | |
| * | |
| * @return void | |
| */ | |
| public function removeAttachment(PermissionAttachment $attachment); | |
| /** | |
| * @return void | |
| */ | |
| public function recalculatePermissions(); | |
| /** | |
| * TODO: Check this | |
| * @return Permission[] | |
| */ | |
| public function getEffectivePermissions(); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| use pocketmine\plugin\Plugin; | |
| use pocketmine\Server; | |
| class PermissibleBase implements Permissible{ | |
| /** @var ServerOperator */ | |
| private $opable = null; | |
| /** @var Permissible */ | |
| private $parent; | |
| /** | |
| * @var PermissionAttachment[] | |
| */ | |
| private $attachments = array(); | |
| /** | |
| * @var PermissionAttachmentInfo[] | |
| */ | |
| private $permissions = array(); | |
| /** | |
| * @param ServerOperator $opable | |
| */ | |
| public function __construct(ServerOperator $opable){ | |
| $this->opable = $opable; | |
| if($opable instanceof Permissible){ | |
| $this->parent = $opable; | |
| }else{ | |
| $this->parent = $this; | |
| } | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isOp(){ | |
| if($this->opable === null){ | |
| return false; | |
| }else{ | |
| return $this->opable->isOp(); | |
| } | |
| } | |
| /** | |
| * @param bool $value | |
| */ | |
| public function setOp($value){ | |
| if($this->opable === null){ | |
| trigger_error("Cannot change ip value as no ServerOperator is set", E_USER_WARNING); | |
| return; | |
| }else{ | |
| $this->opable->setOp($value); | |
| } | |
| } | |
| /** | |
| * @param Permission|string $name | |
| * | |
| * @return bool | |
| */ | |
| public function isPermissionSet($name){ | |
| return isset($this->permissions[$name instanceof Permission ? $name->getName() : $name]); | |
| } | |
| /** | |
| * @param Permission|string $name | |
| * | |
| * @return bool | |
| */ | |
| public function hasPermission($name){ | |
| if($name instanceof Permission){ | |
| $name = $name->getName(); | |
| } | |
| if($this->isPermissionSet($name)){ | |
| return $this->permissions[$name]->getValue(); | |
| } | |
| if(($perm = Server::getInstance()->getPluginManager()->getPermission($name)) !== null){ | |
| $perm = $perm->getDefault(); | |
| return $perm === Permission::DEFAULT_TRUE or ($this->isOp() and $perm === Permission::DEFAULT_OP) or (!$this->isOp() and $perm === Permission::DEFAULT_NOT_OP); | |
| }else{ | |
| return Permission::$DEFAULT_PERMISSION === Permission::DEFAULT_TRUE or ($this->isOp() and Permission::$DEFAULT_PERMISSION === Permission::DEFAULT_OP) or (!$this->isOp() and Permission::$DEFAULT_PERMISSION === Permission::DEFAULT_NOT_OP); | |
| } | |
| } | |
| /** | |
| * //TODO: tick scheduled attachments | |
| * | |
| * @param Plugin $plugin | |
| * @param string $name | |
| * @param bool $value | |
| * | |
| * @return PermissionAttachment | |
| */ | |
| public function addAttachment(Plugin $plugin, $name = null, $value = null){ | |
| if($plugin === null){ | |
| trigger_error("Plugin cannot be null", E_USER_WARNING); | |
| return null; | |
| }elseif(!$plugin->isEnabled()){ | |
| trigger_error("Plugin " . $plugin->getDescription()->getName() . " is disabled", E_USER_WARNING); | |
| return null; | |
| } | |
| $result = new PermissionAttachment($plugin, $this->parent); | |
| $this->attachments[spl_object_hash($result)] = $result; | |
| if($name !== null and $value !== null){ | |
| $result->setPermission($name, $value); | |
| } | |
| $this->recalculatePermissions(); | |
| return $result; | |
| } | |
| /** | |
| * @param PermissionAttachment $attachment | |
| * | |
| * @return void | |
| */ | |
| public function removeAttachment(PermissionAttachment $attachment){ | |
| if($attachment === null){ | |
| trigger_error("Attachment cannot be null", E_USER_WARNING); | |
| return; | |
| } | |
| if(isset($this->attachments[spl_object_hash($attachment)])){ | |
| unset($this->attachments[spl_object_hash($attachment)]); | |
| if(($ex = $attachment->getRemovalCallback()) !== null){ | |
| $ex->attachmentRemoved($attachment); | |
| } | |
| $this->recalculatePermissions(); | |
| } | |
| } | |
| public function recalculatePermissions(){ | |
| $this->clearPermissions(); | |
| $defaults = Server::getInstance()->getPluginManager()->getDefaultPermissions($this->isOp()); | |
| Server::getInstance()->getPluginManager()->subscribeToDefaultPerms($this->isOp(), $this->parent); | |
| foreach($defaults as $perm){ | |
| $name = $perm->getName(); | |
| $this->permissions[$name] = new PermissionAttachmentInfo($this->parent, $name, null, true); | |
| Server::getInstance()->getPluginManager()->subscribeToPermission($name, $this->parent); | |
| $this->calculateChildPermissions($perm->getChildren(), false, null); | |
| } | |
| foreach($this->attachments as $attachment){ | |
| $this->calculateChildPermissions($attachment->getPermissions(), false, $attachment); | |
| } | |
| } | |
| public function clearPermissions(){ | |
| foreach(array_keys($this->permissions) as $name){ | |
| Server::getInstance()->getPluginManager()->unsubscribeFromPermission($name, $this->parent); | |
| } | |
| Server::getInstance()->getPluginManager()->unsubscribeFromDefaultPerms(false, $this->parent); | |
| Server::getInstance()->getPluginManager()->unsubscribeFromDefaultPerms(true, $this->parent); | |
| $this->permissions = array(); | |
| } | |
| /** | |
| * @param bool[] $children | |
| * @param bool $invert | |
| * @param PermissionAttachment $attachment | |
| */ | |
| public function calculateChildPermissions(array $children, $invert, $attachment){ | |
| foreach(array_keys($children) as $name){ | |
| $perm = Server::getInstance()->getPluginManager()->getPermission($name); | |
| $value = $invert === true ? !$children[$name] : $children[$name]; | |
| $this->permissions[$name] = new PermissionAttachmentInfo($this->parent, $name, $attachment, $value); | |
| Server::getInstance()->getPluginManager()->subscribeToPermission($name, $this->parent); | |
| if($perm instanceof Permission){ | |
| $this->calculateChildPermissions($perm->getChildren(), !$value, $attachment); | |
| } | |
| } | |
| } | |
| /** | |
| * @return PermissionAttachmentInfo[] | |
| */ | |
| public function getEffectivePermissions(){ | |
| return $this->permissions; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| /** | |
| * Permission related classes | |
| */ | |
| namespace pocketmine\permission; | |
| use pocketmine\Server; | |
| /** | |
| * Represents a permission | |
| */ | |
| class Permission{ | |
| const DEFAULT_OP = "op"; | |
| const DEFAULT_NOT_OP = "notop"; | |
| const DEFAULT_TRUE = "true"; | |
| const DEFAULT_FALSE = "false"; | |
| public static $DEFAULT_PERMISSION = self::DEFAULT_OP; | |
| /** | |
| * @param $value | |
| * | |
| * @return string | |
| */ | |
| public static function getByName($value){ | |
| if(is_bool($value)){ | |
| if($value === true){ | |
| return "true"; | |
| }else{ | |
| return "false"; | |
| } | |
| } | |
| switch(strtolower($value)){ | |
| case "op": | |
| case "isop": | |
| case "operator": | |
| case "isoperator": | |
| case "admin": | |
| case "isadmin": | |
| return self::DEFAULT_OP; | |
| case "!op": | |
| case "notop": | |
| case "!operator": | |
| case "notoperator": | |
| case "!admin": | |
| case "notadmin": | |
| return self::DEFAULT_NOT_OP; | |
| case "true": | |
| return self::DEFAULT_TRUE; | |
| default: | |
| return self::DEFAULT_FALSE; | |
| } | |
| } | |
| /** @var string */ | |
| private $name; | |
| /** @var string */ | |
| private $description; | |
| /** | |
| * @var string[] | |
| */ | |
| private $children = array(); | |
| /** @var string */ | |
| private $defaultValue; | |
| /** | |
| * Creates a new Permission object to be attached to Permissible objects | |
| * | |
| * @param string $name | |
| * @param string $description | |
| * @param string $defaultValue | |
| * @param Permission[] $children | |
| */ | |
| public function __construct($name, $description = null, $defaultValue = null, array $children = array()){ | |
| $this->name = $name; | |
| $this->description = $description !== null ? $description : ""; | |
| $this->defaultValue = $defaultValue !== null ? $defaultValue : self::$DEFAULT_PERMISSION; | |
| $this->children = $children; | |
| $this->recalculatePermissibles(); | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getName(){ | |
| return $this->name; | |
| } | |
| /** | |
| * @return string[] | |
| */ | |
| public function &getChildren(){ | |
| return $this->children; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getDefault(){ | |
| return $this->defaultValue; | |
| } | |
| /** | |
| * @param string $value | |
| */ | |
| public function setDefault($value){ | |
| if($value !== $this->defaultValue){ | |
| $this->defaultValue = $value; | |
| $this->recalculatePermissibles(); | |
| } | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getDescription(){ | |
| return $this->description; | |
| } | |
| /** | |
| * @param string $value | |
| */ | |
| public function setDescription($value){ | |
| $this->description = $value; | |
| } | |
| /** | |
| * @return Permissible[] | |
| */ | |
| public function getPermissibles(){ | |
| return Server::getInstance()->getPluginManager()->getPermissionSubscriptions($this->name); | |
| } | |
| public function recalculatePermissibles(){ | |
| $perms = $this->getPermissibles(); | |
| Server::getInstance()->getPluginManager()->recalculatePermissionDefaults($this); | |
| foreach($perms as $p){ | |
| $p->recalculatePermissions(); | |
| } | |
| } | |
| /** | |
| * @param string|Permission $name | |
| * @param $value | |
| * | |
| * @return Permission|void | |
| */ | |
| public function addParent($name, $value){ | |
| if($name instanceof Permission){ | |
| $name->getChildren()[$this->getName()] = $value; | |
| $name->recalculatePermissibles(); | |
| }else{ | |
| $perm = Server::getInstance()->getPluginManager()->getPermission($name); | |
| if($perm === null){ | |
| $perm = new Permission($name); | |
| Server::getInstance()->getPluginManager()->addPermission($perm); | |
| } | |
| $this->addParent($perm, $value); | |
| return $perm; | |
| } | |
| } | |
| /** | |
| * @param array $data | |
| * @param $default | |
| * | |
| * @return Permission[] | |
| */ | |
| public static function loadPermissions(array $data, $default = self::DEFAULT_OP){ | |
| $result = array(); | |
| foreach($data as $key => $entry){ | |
| $result[] = self::loadPermission($key, $entry, $default, $result); | |
| } | |
| return $result; | |
| } | |
| /** | |
| * @param string $name | |
| * @param array $data | |
| * @param string $default | |
| * @param array $output | |
| * | |
| * @return Permission | |
| */ | |
| public static function loadPermission($name, array $data, $default = self::DEFAULT_OP, &$output = array()){ | |
| $desc = null; | |
| $children = array(); | |
| if(isset($data["default"])){ | |
| $value = Permission::getByName($data["default"]); | |
| if($value !== null){ | |
| $default = $value; | |
| }else{ | |
| trigger_error("'default' key contained unknown value", E_USER_WARNING); | |
| } | |
| } | |
| if(isset($data["children"])){ | |
| if(is_array($data["children"])){ | |
| foreach($data["children"] as $k => $v){ | |
| if(is_array($v)){ | |
| if(($perm = self::loadPermission($k, $v, $default, $output)) !== null){ | |
| $output[] = $perm; | |
| } | |
| } | |
| $children[$k] = true; | |
| } | |
| }else{ | |
| trigger_error("'children' key is of wrong type", E_USER_WARNING); | |
| } | |
| } | |
| if(isset($data["description"])){ | |
| $desc = $data["description"]; | |
| } | |
| return new Permission($name, $desc, $default, $children); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| use pocketmine\plugin\Plugin; | |
| class PermissionAttachment{ | |
| /** @var PermissionRemovedExecutor */ | |
| private $removed = null; | |
| /** | |
| * @var bool[] | |
| */ | |
| private $permissions = array(); | |
| /** @var Permissible */ | |
| private $permissible; | |
| /** @var Plugin */ | |
| private $plugin; | |
| /** | |
| * @param Plugin $plugin | |
| * @param Permissible $permissible | |
| */ | |
| public function __construct(Plugin $plugin, Permissible $permissible){ | |
| if(!$plugin->isEnabled()){ | |
| trigger_error("Plugin " . $plugin->getDescription()->getName() . " is disabled", E_USER_WARNING); | |
| return; | |
| } | |
| $this->permissible = $permissible; | |
| $this->plugin = $plugin; | |
| } | |
| /** | |
| * @return Plugin | |
| */ | |
| public function getPlugin(){ | |
| return $this->plugin; | |
| } | |
| /** | |
| * @param PermissionRemovedExecutor $ex | |
| */ | |
| public function setRemovalCallback(PermissionRemovedExecutor $ex){ | |
| $this->removed = $ex; | |
| } | |
| /** | |
| * @return PermissionRemovedExecutor | |
| */ | |
| public function getRemovalCallback(){ | |
| return $this->removed; | |
| } | |
| /** | |
| * @return Permissible | |
| */ | |
| public function getPermissible(){ | |
| return $this->permissible; | |
| } | |
| /** | |
| * @return bool[] | |
| */ | |
| public function getPermissions(){ | |
| return $this->permissions; | |
| } | |
| /** | |
| * @param string|Permission $name | |
| * @param bool $value | |
| */ | |
| public function setPermission($name, $value){ | |
| $this->permissions[$name instanceof Permission ? $name->getName() : $name] = $value; | |
| $this->permissible->recalculatePermissions(); | |
| } | |
| /** | |
| * @param string|Permission $name | |
| */ | |
| public function unsetPermission($name){ | |
| unset($this->permissions[$name instanceof Permission ? $name->getName() : $name]); | |
| } | |
| /** | |
| * @return void | |
| */ | |
| public function remove(){ | |
| $this->permissible->removeAttachment($this); | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| class PermissionAttachmentInfo{ | |
| /** @var Permissible */ | |
| private $permissible; | |
| /** @var string */ | |
| private $permission; | |
| /** @var PermissionAttachment */ | |
| private $attachment; | |
| /** @var bool */ | |
| private $value; | |
| /** | |
| * @param Permissible $permissible | |
| * @param string $permission | |
| * @param PermissionAttachment $attachment | |
| * @param bool $value | |
| */ | |
| public function __construct(Permissible $permissible, $permission, $attachment, $value){ | |
| if($permission === null){ | |
| trigger_error("Permission may not be null", E_USER_WARNING); | |
| return; | |
| } | |
| $this->permissible = $permissible; | |
| $this->permission = $permission; | |
| $this->attachment = $attachment; | |
| $this->value = $value; | |
| } | |
| /** | |
| * @return Permissible | |
| */ | |
| public function getPermissible(){ | |
| return $this->permissible; | |
| } | |
| /** | |
| * @return string | |
| */ | |
| public function getPermission(){ | |
| return $this->permission; | |
| } | |
| /** | |
| * @return PermissionAttachment | |
| */ | |
| public function getAttachment(){ | |
| return $this->attachment; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function getValue(){ | |
| return $this->value; | |
| } | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| interface PermissionRemovedExecutor{ | |
| /** | |
| * @param PermissionAttachment $attachment | |
| * | |
| * @return void | |
| */ | |
| public function attachmentRemoved(PermissionAttachment $attachment); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine\permission; | |
| interface ServerOperator{ | |
| /** | |
| * Checks if the current object has operator permissions | |
| * | |
| * @return bool | |
| */ | |
| public function isOp(); | |
| /** | |
| * Sets the operator permission for the current object | |
| * | |
| * @param bool $value | |
| * | |
| * @return void | |
| */ | |
| public function setOp($value); | |
| }<?php | |
| /* | |
| * | |
| * ____ _ _ __ __ _ __ __ ____ | |
| * | _ \ ___ ___| | _____| |_| \/ (_)_ __ ___ | \/ | _ \ | |
| * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) | | |
| * | __/ (_) | (__| < __/ |_| | | | | | | | __/_____| | | | __/ | |
| * |_| \___/ \___|_|\_\___|\__|_| |_|_|_| |_|\___| |_| |_|_| | |
| * | |
| * This program is free software: you can redistribute it and/or modify | |
| * it under the terms of the GNU Lesser General Public License as published by | |
| * the Free Software Foundation, either version 3 of the License, or | |
| * (at your option) any later version. | |
| * | |
| * @author PocketMine Team | |
| * @link http://www.pocketmine.net/ | |
| * | |
| * | |
| */ | |
| namespace pocketmine; | |
| use pocketmine\block\Block; | |
| use pocketmine\command\CommandSender; | |
| use pocketmine\entity\Human; | |
| use pocketmine\event\player\PlayerAchievementAwardedEvent; | |
| use pocketmine\event\player\PlayerChatEvent; | |
| use pocketmine\event\player\PlayerCommandPreprocessEvent; | |
| use pocketmine\event\player\PlayerGameModeChangeEvent; | |
| use pocketmine\event\player\PlayerItemHeldEvent; | |
| use pocketmine\event\player\PlayerJoinEvent; | |
| use pocketmine\event\player\PlayerKickEvent; | |
| use pocketmine\event\player\PlayerLoginEvent; | |
| use pocketmine\event\player\PlayerPreLoginEvent; | |
| use pocketmine\event\player\PlayerQuitEvent; | |
| use pocketmine\event\player\PlayerRespawnEvent; | |
| use pocketmine\event\server\DataPacketReceiveEvent; | |
| use pocketmine\event\server\DataPacketSendEvent; | |
| use pocketmine\item\Item; | |
| use pocketmine\level\Level; | |
| use pocketmine\level\Position; | |
| use pocketmine\math\Vector3; | |
| use pocketmine\nbt\NBT; | |
| use pocketmine\nbt\tag\Byte; | |
| use pocketmine\nbt\tag\Compound; | |
| use pocketmine\nbt\tag\String; | |
| use pocketmine\network\protocol\AdventureSettingsPacket; | |
| use pocketmine\network\protocol\ChunkDataPacket; | |
| use pocketmine\network\protocol\ContainerClosePacket; | |
| use pocketmine\network\protocol\ContainerSetContentPacket; | |
| use pocketmine\network\protocol\ContainerSetSlotPacket; | |
| use pocketmine\network\protocol\DataPacket; | |
| use pocketmine\network\protocol\DisconnectPacket; | |
| use pocketmine\network\protocol\Info as ProtocolInfo; | |
| use pocketmine\network\protocol\LoginStatusPacket; | |
| use pocketmine\network\protocol\MessagePacket; | |
| use pocketmine\network\protocol\PongPacket; | |
| use pocketmine\network\protocol\ServerHandshakePacket; | |
| use pocketmine\network\protocol\SetSpawnPositionPacket; | |
| use pocketmine\network\protocol\SetTimePacket; | |
| use pocketmine\network\protocol\StartGamePacket; | |
| use pocketmine\network\protocol\TileEventPacket; | |
| use pocketmine\network\protocol\UnknownPacket; | |
| use pocketmine\network\protocol\UpdateBlockPacket; | |
| use pocketmine\network\raknet\Info; | |
| use pocketmine\network\raknet\Packet; | |
| use pocketmine\permission\PermissibleBase; | |
| use pocketmine\permission\PermissionAttachment; | |
| use pocketmine\plugin\Plugin; | |
| use pocketmine\level\format\pmf\LevelFormat; | |
| use pocketmine\recipes\Crafting; | |
| use pocketmine\scheduler\CallbackTask; | |
| use pocketmine\tile\Chest; | |
| use pocketmine\tile\Furnace; | |
| use pocketmine\tile\Sign; | |
| use pocketmine\tile\Spawnable; | |
| use pocketmine\tile\Tile; | |
| use pocketmine\utils\Binary; | |
| use pocketmine\utils\TextFormat; | |
| /** | |
| * Main class that handles networking, recovery, and packet sending to the server part | |
| * TODO: Move reliability layer | |
| */ | |
| class Player extends Human implements CommandSender, IPlayer{ | |
| const SURVIVAL = 0; | |
| const CREATIVE = 1; | |
| const ADVENTURE = 2; | |
| const SPECTATOR = 3; | |
| const VIEW = Player::SPECTATOR; | |
| const MAX_QUEUE = 2048; | |
| const SURVIVAL_SLOTS = 36; | |
| const CREATIVE_SLOTS = 112; | |
| public $CID; | |
| public $MTU; | |
| public $spawned = false; | |
| public $loggedIn = false; | |
| public $gamemode; | |
| public $lastBreak; | |
| public $windowCnt = 2; | |
| public $windows = array(); | |
| public $blocked = true; | |
| public $achievements = array(); | |
| public $chunksLoaded = array(); | |
| public $lastCorrect; | |
| public $craftingItems = array(); | |
| public $toCraft = array(); | |
| public $lastCraft = 0; | |
| public $loginData = array(); | |
| protected $lastMovement = 0; | |
| protected $forceMovement = false; | |
| protected $connected = true; | |
| protected $clientID; | |
| protected $ip; | |
| protected $port; | |
| protected $username; | |
| protected $iusername; | |
| protected $displayName; | |
| protected $startAction = false; | |
| protected $sleeping = false; | |
| protected $chunksOrder = array(); | |
| /** @var Player[] */ | |
| protected $hiddenPlayers = array(); | |
| private $recoveryQueue = array(); | |
| private $receiveQueue = array(); | |
| private $resendQueue = array(); | |
| private $ackQueue = array(); | |
| private $receiveCount = -1; | |
| /** @var \pocketmine\network\raknet\Packet */ | |
| private $buffer; | |
| private $bufferLen = 0; | |
| private $nextBuffer = 0; | |
| private $timeout; | |
| private $counter = array(0, 0, 0, 0); | |
| private $viewDistance; | |
| private $lastMeasure = 0; | |
| private $bandwidthRaw = 0; | |
| private $bandwidthStats = array(0, 0, 0); | |
| private $lag = array(); | |
| private $lagStat = 0; | |
| private $spawnPosition; | |
| private $packetLoss = 0; | |
| private $lastChunk = false; | |
| private $chunkScheduled = 0; | |
| private $inAction = false; | |
| private $bigCnt; | |
| private $packetStats; | |
| private $chunkCount = array(); | |
| private $received = array(); | |
| /** | |
| * @var \pocketmine\scheduler\TaskHandler[] | |
| */ | |
| private $tasks = array(); | |
| /** @var PermissibleBase */ | |
| private $perm = null; | |
| public function isBanned(){ | |
| return $this->server->getNameBans()->isBanned(strtolower($this->getName())); | |
| } | |
| public function setBanned($value){ | |
| if($value === true){ | |
| $this->server->getNameBans()->addBan($this->getName(), null, null, null); | |
| }else{ | |
| $this->server->getNameBans()->remove($this->getName()); | |
| } | |
| } | |
| public function isWhitelisted(){ | |
| return $this->server->isWhitelisted(strtolower($this->getName())); | |
| } | |
| public function setWhitelisted($value){ | |
| if($value === true){ | |
| $this->server->addWhitelist(strtolower($this->getName())); | |
| }else{ | |
| $this->server->removeWhitelist(strtolower($this->getName())); | |
| } | |
| } | |
| public function getPlayer(){ | |
| return $this; | |
| } | |
| public function getFirstPlayed(){ | |
| return $this->namedtag instanceof Compound ? $this->namedtag["firstPlayed"] : null; | |
| } | |
| public function getLastPlayed(){ | |
| return $this->namedtag instanceof Compound ? $this->namedtag["lastPlayed"] : null; | |
| } | |
| public function hasPlayedBefore(){ | |
| return $this->namedtag instanceof Compound; | |
| } | |
| protected function initEntity(){ | |
| $this->level->players[$this->CID] = $this; | |
| parent::initEntity(); | |
| } | |
| /** | |
| * @param Player $player | |
| */ | |
| public function spawnTo(Player $player){ | |
| if($this->spawned === true and $player->getLevel() === $this->getLevel() and $player->canSee($this)){ | |
| parent::spawnTo($player); | |
| } | |
| } | |
| /** | |
| * @param Player $player | |
| */ | |
| public function despawnFrom(Player $player){ | |
| if($this->spawned === true){ | |
| parent::despawnFrom($player); | |
| } | |
| } | |
| /** | |
| * @return Server | |
| */ | |
| public function getServer(){ | |
| return $this->server; | |
| } | |
| /** | |
| * @param Player $player | |
| * | |
| * @return bool | |
| */ | |
| public function canSee(Player $player){ | |
| return !isset($this->hiddenPlayers[$player->getName()]); | |
| } | |
| /** | |
| * @param Player $player | |
| */ | |
| public function hidePlayer(Player $player){ | |
| if($player === $this){ | |
| return; | |
| } | |
| $this->hiddenPlayers[$player->getName()] = $player; | |
| $player->despawnFrom($this); | |
| } | |
| /** | |
| * @param Player $player | |
| */ | |
| public function showPlayer(Player $player){ | |
| if($player === $this){ | |
| return; | |
| } | |
| unset($this->hiddenPlayers[$player->getName()]); | |
| $player->spawnTo($this); | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isOnline(){ | |
| return $this->connected === true and $this->loggedIn === true; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isOp(){ | |
| return $this->server->isOp($this->getName()); | |
| } | |
| /** | |
| * @param bool $value | |
| */ | |
| public function setOp($value){ | |
| if($value === $this->isOp()){ | |
| return; | |
| } | |
| if($value === true){ | |
| $this->server->addOp($this->getName()); | |
| }else{ | |
| $this->server->removeOp($this->getName()); | |
| } | |
| $this->recalculatePermissions(); | |
| } | |
| /** | |
| * @param permission\Permission|string $name | |
| * | |
| * @return bool | |
| */ | |
| public function isPermissionSet($name){ | |
| return $this->perm->isPermissionSet($name); | |
| } | |
| /** | |
| * @param permission\Permission|string $name | |
| * | |
| * @return bool | |
| */ | |
| public function hasPermission($name){ | |
| return $this->perm->hasPermission($name); | |
| } | |
| /** | |
| * @param Plugin $plugin | |
| * @param string $name | |
| * @param bool $value | |
| * | |
| * @return permission\PermissionAttachment | |
| */ | |
| public function addAttachment(Plugin $plugin, $name = null, $value = null){ | |
| return $this->perm->addAttachment($plugin, $name, $value); | |
| } | |
| /** | |
| * @param PermissionAttachment $attachment | |
| */ | |
| public function removeAttachment(PermissionAttachment $attachment){ | |
| $this->perm->removeAttachment($attachment); | |
| } | |
| public function recalculatePermissions(){ | |
| $this->server->getPluginManager()->unsubscribeFromPermission(Server::BROADCAST_CHANNEL_USERS, $this); | |
| $this->server->getPluginManager()->unsubscribeFromPermission(Server::BROADCAST_CHANNEL_ADMINISTRATIVE, $this); | |
| $this->perm->recalculatePermissions(); | |
| if($this->hasPermission(Server::BROADCAST_CHANNEL_USERS)){ | |
| $this->server->getPluginManager()->subscribeToPermission(Server::BROADCAST_CHANNEL_USERS, $this); | |
| } | |
| if($this->hasPermission(Server::BROADCAST_CHANNEL_ADMINISTRATIVE)){ | |
| $this->server->getPluginManager()->subscribeToPermission(Server::BROADCAST_CHANNEL_ADMINISTRATIVE, $this); | |
| } | |
| } | |
| /** | |
| * @return permission\PermissionAttachmentInfo[] | |
| */ | |
| public function getEffectivePermissions(){ | |
| return $this->perm->getEffectivePermissions(); | |
| } | |
| /** | |
| * @param integer $clientID | |
| * @param string $ip | |
| * @param integer $port | |
| * @param integer $MTU | |
| */ | |
| public function __construct($clientID, $ip, $port, $MTU){ | |
| $this->perm = new PermissibleBase($this); | |
| $this->namedtag = new Compound(); | |
| $this->bigCnt = 0; | |
| $this->MTU = $MTU; | |
| $this->server = Server::getInstance(); | |
| $this->lastBreak = microtime(true); | |
| $this->clientID = $clientID; | |
| $this->CID = $ip . ":" . $port; | |
| $this->ip = $ip; | |
| $this->port = $port; | |
| $this->spawnPosition = $this->server->getDefaultLevel()->getSafeSpawn(); | |
| $this->timeout = microtime(true) + 20; | |
| $this->gamemode = $this->server->getGamemode(); | |
| $this->level = $this->server->getDefaultLevel(); | |
| $this->viewDistance = $this->server->getViewDistance(); | |
| $this->slot = 0; | |
| $this->hotbar = array(0, -1, -1, -1, -1, -1, -1, -1, -1); | |
| $this->packetStats = array(0, 0); | |
| $this->buffer = new Packet(Info::DATA_PACKET_0); | |
| $this->buffer->data = array(); | |
| $this->tasks[] = $this->server->getScheduler()->scheduleRepeatingTask(new CallbackTask(array($this, "handlePacketQueues")), 1); | |
| $this->tasks[] = $this->server->getScheduler()->scheduleRepeatingTask(new CallbackTask(array($this, "clearQueue")), 20 * 60); | |
| console("[DEBUG] New Session started with " . $ip . ":" . $port . ". MTU " . $this->MTU . ", Client ID " . $this->clientID, true, true, 2); | |
| } | |
| /** | |
| * @param string $achievementId | |
| */ | |
| public function removeAchievement($achievementId){ | |
| if($this->hasAchievement($achievementId)){ | |
| $this->achievements[$achievementId] = false; | |
| } | |
| } | |
| /** | |
| * @param string $achievementId | |
| * | |
| * @return bool | |
| */ | |
| public function hasAchievement($achievementId){ | |
| if(!isset(Achievement::$list[$achievementId]) or !isset($this->achievements)){ | |
| $this->achievements = array(); | |
| return false; | |
| } | |
| if(!isset($this->achievements[$achievementId]) or $this->achievements[$achievementId] == false){ | |
| return false; | |
| } | |
| return true; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isConnected(){ | |
| return $this->connected === true; | |
| } | |
| /** | |
| * Gets the "friendly" name to display of this player to use in the chat. | |
| * | |
| * @return string | |
| */ | |
| public function getDisplayName(){ | |
| return $this->displayName; | |
| } | |
| /** | |
| * @param string $name | |
| */ | |
| public function setDisplayName($name){ | |
| $this->displayName = $name; | |
| } | |
| /** | |
| * Gets the player IP address | |
| * | |
| * @return string | |
| */ | |
| public function getAddress(){ | |
| return $this->ip; | |
| } | |
| /** | |
| * @return int | |
| */ | |
| public function getPort(){ | |
| return $this->port; | |
| } | |
| /** | |
| * @return bool | |
| */ | |
| public function isSleeping(){ | |
| return $this->sleeping instanceof Vector3; | |
| } | |
| /** | |
| * Sets the chunk send flags for a specific index | |
| * | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param int $index | |
| * @param int $flags | |
| */ | |
| public function setChunkIndex($index, $flags){ | |
| if(isset($this->chunksLoaded[$index])){ | |
| $this->chunksLoaded[$index] |= $flags; | |
| } | |
| } | |
| /** | |
| * @return Position | |
| */ | |
| public function getSpawn(){ | |
| return $this->spawnPosition; | |
| } | |
| /** | |
| * Sends, if available, the next ordered chunk to the client | |
| * | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param bool $force | |
| * @param bool $ev | |
| * | |
| * @return bool|void | |
| */ | |
| public function getNextChunk($force = false, $ev = null){ | |
| if($this->connected === false){ | |
| return; | |
| } | |
| if($ev === true){ | |
| --$this->chunkScheduled; | |
| if($this->chunkScheduled < 0){ | |
| $this->chunkScheduled = 0; | |
| } | |
| } | |
| foreach($this->chunkCount as $count => $t){ | |
| if(isset($this->recoveryQueue[$count]) or isset($this->resendQueue[$count])){ | |
| if($this->chunkScheduled === 0){ | |
| $this->server->getScheduler()->scheduleDelayedTask(new CallbackTask(array($this, "getNextChunk"), array(false, true)), MAX_CHUNK_RATE); | |
| ++$this->chunkScheduled; | |
| } | |
| return; | |
| }else{ | |
| unset($this->chunkCount[$count]); | |
| } | |
| } | |
| if(is_array($this->lastChunk)){ | |
| foreach($this->level->getChunkEntities($this->lastChunk[0], $this->lastChunk[1]) as $entity){ | |
| if($entity !== $this){ | |
| $entity->spawnTo($this); | |
| } | |
| } | |
| foreach($this->level->getChunkTiles($this->lastChunk[0], $this->lastChunk[1]) as $tile){ | |
| if($tile instanceof Spawnable){ | |
| $tile->spawnTo($this); | |
| } | |
| } | |
| $this->lastChunk = false; | |
| } | |
| $index = key($this->chunksOrder); | |
| $distance = @$this->chunksOrder[$index]; | |
| if($index === null or $distance === null){ | |
| if($this->chunkScheduled === 0){ | |
| $this->server->getScheduler()->scheduleDelayedTask(new CallbackTask(array($this, "getNextChunk"), array(false, true)), 60); | |
| } | |
| return false; | |
| } | |
| $X = null; | |
| $Z = null; | |
| LevelFormat::getXZ($index, $X, $Z); | |
| if(!$this->level->isChunkPopulated($X, $Z)){ | |
| $this->orderChunks(); | |
| if($this->chunkScheduled === 0 or $force === true){ | |
| $this->server->getScheduler()->scheduleDelayedTask(new CallbackTask(array($this, "getNextChunk"), array(false, true)), MAX_CHUNK_RATE); | |
| ++$this->chunkScheduled; | |
| } | |
| return false; | |
| } | |
| unset($this->chunksOrder[$index]); | |
| if(!isset($this->chunksLoaded[$index])){ | |
| $this->chunksLoaded[$index] = 0xff; | |
| } | |
| $Yndex = $this->chunksLoaded[$index]; | |
| $this->chunksLoaded[$index] = 0; //Load them all | |
| $this->level->useChunk($X, $Z, $this); | |
| $pk = new ChunkDataPacket; | |
| $pk->chunkX = $X; | |
| $pk->chunkZ = $Z; | |
| $pk->data = $this->level->getOrderedChunk($X, $Z, $Yndex); | |
| $cnt = $this->dataPacket($pk); | |
| if($cnt === false){ | |
| return false; | |
| } | |
| $this->chunkCount = array(); | |
| foreach($cnt as $i => $count){ | |
| $this->chunkCount[$count] = true; | |
| } | |
| $this->lastChunk = array($X, $Z); | |
| if($this->chunkScheduled === 0 or $force === true){ | |
| $this->server->getScheduler()->scheduleDelayedTask(new CallbackTask(array($this, "getNextChunk"), array(false, true)), MAX_CHUNK_RATE); | |
| ++$this->chunkScheduled; | |
| } | |
| } | |
| /** | |
| * | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @return bool | |
| */ | |
| public function orderChunks(){ | |
| if($this->connected === false){ | |
| return false; | |
| } | |
| $newOrder = array(); | |
| $lastChunk = $this->chunksLoaded; | |
| $centerX = $this->x >> 4; | |
| $centerZ = $this->z >> 4; | |
| $startX = $centerX - $this->viewDistance; | |
| $startZ = $centerZ - $this->viewDistance; | |
| $finalX = $centerX + $this->viewDistance; | |
| $finalZ = $centerZ + $this->viewDistance; | |
| for($X = $startX; $X <= $finalX; ++$X){ | |
| for($Z = $startZ; $Z <= $finalZ; ++$Z){ | |
| $distance = abs($X - $centerX) + abs($Z - $centerZ); | |
| $index = LevelFormat::getIndex($X, $Z); | |
| if(!isset($this->chunksLoaded[$index]) or $this->chunksLoaded[$index] !== 0){ | |
| $newOrder[$index] = $distance; | |
| } | |
| unset($lastChunk[$index]); | |
| } | |
| } | |
| asort($newOrder); | |
| $this->chunksOrder = $newOrder; | |
| $index = key($this->chunksOrder); | |
| LevelFormat::getXZ($index, $X, $Z); | |
| $this->level->loadChunk($X, $Z); | |
| if(!$this->level->isChunkPopulated($X, $Z)){ | |
| $this->level->loadChunk($X - 1, $Z); | |
| $this->level->loadChunk($X + 1, $Z); | |
| $this->level->loadChunk($X, $Z - 1); | |
| $this->level->loadChunk($X, $Z + 1); | |
| $this->level->loadChunk($X + 1, $Z + 1); | |
| $this->level->loadChunk($X + 1, $Z - 1); | |
| $this->level->loadChunk($X - 1, $Z - 1); | |
| $this->level->loadChunk($X - 1, $Z + 1); | |
| } | |
| foreach($lastChunk as $index => $Yndex){ | |
| if($Yndex !== 0xff){ | |
| $X = null; | |
| $Z = null; | |
| LevelFormat::getXZ($index, $X, $Z); | |
| foreach($this->level->getChunkEntities($X, $Z) as $entity){ | |
| if($entity !== $this){ | |
| $entity->despawnFrom($this); | |
| } | |
| } | |
| } | |
| unset($this->chunksLoaded[$index]); | |
| } | |
| } | |
| /** | |
| * Sends an ordered DataPacket to the send buffer | |
| * | |
| * @param DataPacket $packet | |
| * | |
| * @return array|bool | |
| */ | |
| public function dataPacket(DataPacket $packet){ | |
| if($this->connected === false){ | |
| return false; | |
| } | |
| $this->server->getPluginManager()->callEvent($ev = new DataPacketSendEvent($this, $packet)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| $packet->encode(); | |
| $len = strlen($packet->buffer) + 1; | |
| $MTU = $this->MTU - 24; | |
| if($len > $MTU){ | |
| return $this->directBigRawPacket($packet); | |
| } | |
| if(($this->bufferLen + $len) >= $MTU){ | |
| $this->sendBuffer(); | |
| } | |
| $packet->messageIndex = $this->counter[3]++; | |
| $packet->reliability = 2; | |
| @$this->buffer->data[] = $packet; | |
| $this->bufferLen += 6 + $len; | |
| return array(); | |
| } | |
| private function directBigRawPacket(DataPacket $packet){ | |
| if($this->connected === false){ | |
| return false; | |
| } | |
| $sendtime = microtime(true); | |
| $size = $this->MTU - 34; | |
| $buffer = str_split($packet->buffer, $size); | |
| $bigCnt = $this->bigCnt; | |
| $this->bigCnt = ($this->bigCnt + 1) % 0x10000; | |
| $cnts = array(); | |
| $bufCount = count($buffer); | |
| foreach($buffer as $i => $buf){ | |
| $cnts[] = $count = $this->counter[0]++; | |
| $pk = new UnknownPacket; | |
| $pk->packetID = $packet->pid(); | |
| $pk->reliability = 2; | |
| $pk->hasSplit = true; | |
| $pk->splitCount = $bufCount; | |
| $pk->splitID = $bigCnt; | |
| $pk->splitIndex = $i; | |
| $pk->buffer = $buf; | |
| $pk->messageIndex = $this->counter[3]++; | |
| $rk = new Packet(Info::DATA_PACKET_0); | |
| $rk->data[] = $pk; | |
| $rk->seqNumber = $count; | |
| $rk->sendtime = $sendtime; | |
| $this->recoveryQueue[$count] = $rk; | |
| $this->send($rk); | |
| } | |
| return $cnts; | |
| } | |
| /** | |
| * Sends a raw Packet to the conection | |
| * | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param Packet $packet | |
| */ | |
| public function send(Packet $packet){ | |
| if($this->connected === true){ | |
| $packet->ip = $this->ip; | |
| $packet->port = $this->port; | |
| $this->bandwidthRaw += $this->server->sendPacket($packet); | |
| } | |
| } | |
| /** | |
| * Forces sending the buffer | |
| * | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| */ | |
| public function sendBuffer(){ | |
| if($this->connected === true){ | |
| if($this->bufferLen > 0 and $this->buffer instanceof Packet){ | |
| $this->buffer->seqNumber = $this->counter[0]++; | |
| $this->send($this->buffer); | |
| } | |
| $this->bufferLen = 0; | |
| $this->buffer = new Packet(Info::DATA_PACKET_0); | |
| $this->buffer->data = array(); | |
| $this->nextBuffer = microtime(true) + 0.1; | |
| } | |
| } | |
| /** | |
| * @param Vector3 $pos | |
| * | |
| * @return boolean | |
| */ | |
| public function sleepOn(Vector3 $pos){ | |
| foreach($this->level->getPlayers() as $p){ | |
| if($p->sleeping instanceof Vector3){ | |
| if($pos->distance($p->sleeping) <= 0.1){ | |
| return false; | |
| } | |
| } | |
| } | |
| $this->sleeping = $pos; | |
| $this->teleport(new Position($pos->x + 0.5, $pos->y + 1, $pos->z + 0.5, $this->level)); | |
| /*if($this->entity instanceof Entity){ | |
| $this->updateMetadata(); | |
| }*/ | |
| $this->setSpawn($pos); | |
| $this->server->getScheduler()->scheduleDelayedTask(new CallbackTask(array($this, "checkSleep")), 60); | |
| return true; | |
| } | |
| /** | |
| * Sets the spawnpoint of the player (and the compass direction) to a Vector3, or set it on another world with a Position object | |
| * | |
| * @param Vector3|Position $pos | |
| */ | |
| public function setSpawn(Vector3 $pos){ | |
| if(!($pos instanceof Position)){ | |
| $level = $this->level; | |
| }else{ | |
| $level = $pos->level; | |
| } | |
| $this->spawnPosition = new Position($pos->x, $pos->y, $pos->z, $level); | |
| $pk = new SetSpawnPositionPacket; | |
| $pk->x = (int) $this->spawnPosition->x; | |
| $pk->y = (int) $this->spawnPosition->y; | |
| $pk->z = (int) $this->spawnPosition->z; | |
| $this->dataPacket($pk); | |
| } | |
| public function stopSleep(){ | |
| $this->sleeping = false; | |
| //if($this->entity instanceof Entity){ | |
| //$this->entity->updateMetadata(); | |
| //} | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| */ | |
| public function checkSleep(){ | |
| if($this->sleeping !== false){ | |
| //TODO | |
| if($this->server->api->time->getPhase($this->level) === "night"){ | |
| foreach($this->level->getPlayers() as $p){ | |
| if($p->sleeping === false){ | |
| return; | |
| } | |
| } | |
| $this->server->api->time->set("day", $this->level); | |
| foreach($this->level->getPlayers() as $p){ | |
| $p->stopSleep(); | |
| } | |
| } | |
| } | |
| return; | |
| } | |
| /*public function eventHandler($data, $event){ | |
| switch($event){ | |
| //TODO, obsolete | |
| case "tile.update": | |
| if($data->level === $this->level){ | |
| if($data instanceof Furnace){ | |
| foreach($this->windows as $id => $w){ | |
| if($w === $data){ | |
| $pk = new ContainerSetDataPacket; | |
| $pk->windowid = $id; | |
| $pk->property = 0; //Smelting | |
| $pk->value = floor($data->namedtag->CookTime); | |
| $this->dataPacket($pk); | |
| $pk = new ContainerSetDataPacket; | |
| $pk->windowid = $id; | |
| $pk->property = 1; //Fire icon | |
| $pk->value = $data->namedtag->BurnTicks; | |
| $this->dataPacket($pk); | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| case "tile.container.slot": | |
| if($data["tile"]->level === $this->level){ | |
| foreach($this->windows as $id => $w){ | |
| if($w === $data["tile"]){ | |
| $pk = new ContainerSetSlotPacket; | |
| $pk->windowid = $id; | |
| $pk->slot = $data["slot"] + (isset($data["offset"]) ? $data["offset"] : 0); | |
| $pk->item = $data["slotdata"]; | |
| $this->dataPacket($pk); | |
| } | |
| } | |
| } | |
| break; | |
| case "player.pickup": | |
| if($data["eid"] === $this->id){ | |
| $data["eid"] = 0; | |
| $pk = new TakeItemEntityPacket; | |
| $pk->eid = 0; | |
| $pk->target = $data["entity"]->getID(); | |
| $this->dataPacket($pk); | |
| if(($this->gamemode & 0x01) === 0x00){ | |
| //$this->addItem($data["entity"]->type, $data["entity"]->meta, $data["entity"]->stack); | |
| } | |
| switch($data["entity"]->type){ | |
| case Item::WOOD: | |
| $this->awardAchievement("mineWood"); | |
| break; | |
| case Item::DIAMOND: | |
| $this->awardAchievement("diamond"); | |
| break; | |
| } | |
| }elseif($data["entity"]->level === $this->level){ | |
| $pk = new TakeItemEntityPacket; | |
| $pk->eid = $data["eid"]; | |
| $pk->target = $data["entity"]->getID(); | |
| $this->dataPacket($pk); | |
| } | |
| break; | |
| case "entity.animate": | |
| if($data["eid"] === $this->id or $data["entity"]->level !== $this->level){ | |
| break; | |
| } | |
| $pk = new AnimatePacket; | |
| $pk->eid = $data["eid"]; | |
| $pk->action = $data["action"]; //1 swing arm, | |
| $this->dataPacket($pk); | |
| break; | |
| case "entity.metadata": | |
| if($data->getID() === $this->id){ | |
| $eid = 0; | |
| }else{ | |
| $eid = $data->getID(); | |
| } | |
| if($data->level === $this->level){ | |
| $pk = new SetEntityDataPacket; | |
| $pk->eid = $eid; | |
| $pk->metadata = $data->getMetadata(); | |
| $this->dataPacket($pk); | |
| } | |
| break; | |
| case "entity.event": | |
| if($data["entity"]->getID() === $this->id){ | |
| $eid = 0; | |
| }else{ | |
| $eid = $data["entity"]->getID(); | |
| } | |
| if($data["entity"]->level === $this->level){ | |
| $pk = new EntityEventPacket; | |
| $pk->eid = $eid; | |
| $pk->event = $data["event"]; | |
| $this->dataPacket($pk); | |
| } | |
| break; | |
| } | |
| }*/ | |
| /** | |
| * @param string $achievementId | |
| * | |
| * @return bool | |
| */ | |
| public function awardAchievement($achievementId){ | |
| if(isset(Achievement::$list[$achievementId]) and !$this->hasAchievement($achievementId)){ | |
| foreach(Achievement::$list[$achievementId]["requires"] as $requerimentId){ | |
| if(!$this->hasAchievement($requerimentId)){ | |
| return false; | |
| } | |
| } | |
| $this->server->getPluginManager()->callEvent($ev = new PlayerAchievementAwardedEvent($this, $achievementId)); | |
| if(!$ev->isCancelled()){ | |
| $this->achievements[$achievementId] = true; | |
| Achievement::broadcast($this, $achievementId); | |
| return true; | |
| }else{ | |
| return false; | |
| } | |
| } | |
| return false; | |
| } | |
| /** | |
| * @return int | |
| */ | |
| public function getGamemode(){ | |
| return $this->gamemode; | |
| } | |
| /** | |
| * Sets the gamemode, and if needed, kicks the player | |
| * TODO: Check if Mojang adds the ability to change gamemode without kicking players | |
| * | |
| * @param int $gm | |
| * | |
| * @return bool | |
| */ | |
| public function setGamemode($gm){ | |
| if($gm < 0 or $gm > 3 or $this->gamemode === $gm){ | |
| return false; | |
| } | |
| $this->server->getPluginManager()->callEvent($ev = new PlayerGameModeChangeEvent($this, (int) $gm)); | |
| if($ev->isCancelled()){ | |
| return false; | |
| } | |
| if(($this->gamemode & 0x01) === ($gm & 0x01)){ | |
| $this->gamemode = $gm; | |
| $this->sendMessage("Your gamemode has been changed to " . Server::getGamemodeString($this->getGamemode()) . ".\n"); | |
| }else{ | |
| $this->blocked = true; | |
| $this->gamemode = $gm; | |
| $this->sendMessage("Your gamemode has been changed to " . Server::getGamemodeString($this->getGamemode()) . ", you've to do a forced reconnect.\n"); | |
| $this->server->getScheduler()->scheduleDelayedTask(new CallbackTask(array($this, "close"), array($this->username . " has left the game", "gamemode change")), 30); | |
| } | |
| $this->sendSettings(); | |
| return true; | |
| } | |
| /** | |
| * Sends all the option flags | |
| * | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param bool $nametags | |
| */ | |
| public function sendSettings($nametags = true){ | |
| /* | |
| bit mask | flag name | |
| 0x00000001 world_inmutable | |
| 0x00000002 - | |
| 0x00000004 - | |
| 0x00000008 - (autojump) | |
| 0x00000010 - | |
| 0x00000020 nametags_visible | |
| 0x00000040 ? | |
| 0x00000080 ? | |
| 0x00000100 ? | |
| 0x00000200 ? | |
| 0x00000400 ? | |
| 0x00000800 ? | |
| 0x00001000 ? | |
| 0x00002000 ? | |
| 0x00004000 ? | |
| 0x00008000 ? | |
| 0x00010000 ? | |
| 0x00020000 ? | |
| 0x00040000 ? | |
| 0x00080000 ? | |
| 0x00100000 ? | |
| 0x00200000 ? | |
| 0x00400000 ? | |
| 0x00800000 ? | |
| 0x01000000 ? | |
| 0x02000000 ? | |
| 0x04000000 ? | |
| 0x08000000 ? | |
| 0x10000000 ? | |
| 0x20000000 ? | |
| 0x40000000 ? | |
| 0x80000000 ? | |
| */ | |
| $flags = 0; | |
| if(($this->gamemode & 0x02) === 0x02){ | |
| $flags |= 0x01; //Do not allow placing/breaking blocks, adventure mode | |
| } | |
| if($nametags !== false){ | |
| $flags |= 0x20; //Show Nametags | |
| } | |
| $pk = new AdventureSettingsPacket; | |
| $pk->flags = $flags; | |
| $this->dataPacket($pk); | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @return bool | |
| */ | |
| public function measureLag(){ | |
| if($this->connected === false){ | |
| return false; | |
| } | |
| if($this->packetStats[1] > 2){ | |
| $this->packetLoss = $this->packetStats[1] / max(1, $this->packetStats[0] + $this->packetStats[1]); | |
| }else{ | |
| $this->packetLoss = 0; | |
| } | |
| $this->packetStats = array(0, 0); | |
| array_shift($this->bandwidthStats); | |
| $this->bandwidthStats[] = $this->bandwidthRaw / max(0.00001, microtime(true) - $this->lastMeasure); | |
| $this->bandwidthRaw = 0; | |
| $this->lagStat = array_sum($this->lag) / max(1, count($this->lag)); | |
| $this->lag = array(); | |
| $this->sendBuffer(); | |
| $this->lastMeasure = microtime(true); | |
| } | |
| /** | |
| * WARNING: Experimental method | |
| * | |
| * @return int | |
| */ | |
| public function getLag(){ | |
| return $this->lagStat * 1000; | |
| } | |
| /** | |
| * WARNING: Experimental method | |
| * | |
| * @return int | |
| */ | |
| public function getPacketLoss(){ | |
| return $this->packetLoss; | |
| } | |
| /** | |
| * WARNING: Experimental method | |
| * | |
| * @return float | |
| */ | |
| public function getBandwidth(){ | |
| return array_sum($this->bandwidthStats) / max(1, count($this->bandwidthStats)); | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @return bool | |
| */ | |
| public function clearQueue(){ | |
| if($this->connected === false){ | |
| return false; | |
| } | |
| ksort($this->received); | |
| if(($cnt = count($this->received)) > self::MAX_QUEUE){ | |
| foreach($this->received as $c => $t){ | |
| unset($this->received[$c]); | |
| --$cnt; | |
| if($cnt <= self::MAX_QUEUE){ | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| /** | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @return bool | |
| */ | |
| public function handlePacketQueues(){ | |
| if($this->connected === false){ | |
| return false; | |
| } | |
| $time = microtime(true); | |
| if($time > $this->timeout){ | |
| $this->close($this->username . " has left the game", "timeout"); | |
| return false; | |
| } | |
| if(($ackCnt = count($this->ackQueue)) > 0){ | |
| rsort($this->ackQueue); | |
| $safeCount = (int) (($this->MTU - 1) / 4); | |
| $packetCnt = (int) ($ackCnt / $safeCount + 1); | |
| for($p = 0; $p < $packetCnt; ++$p){ | |
| $pk = new Packet(Info::ACK); | |
| $pk->packets = array(); | |
| for($c = 0; $c < $safeCount; ++$c){ | |
| if(($k = array_pop($this->ackQueue)) === null){ | |
| break; | |
| } | |
| $pk->packets[] = $k; | |
| } | |
| $this->send($pk); | |
| } | |
| $this->ackQueue = array(); | |
| } | |
| if(($receiveCnt = count($this->receiveQueue)) > 0){ | |
| ksort($this->receiveQueue); | |
| foreach($this->receiveQueue as $count => $packets){ | |
| unset($this->receiveQueue[$count]); | |
| foreach($packets as $p){ | |
| if($p instanceof DataPacket and $p->hasSplit === false){ | |
| if(isset($p->messageIndex) and $p->messageIndex !== false){ | |
| if($p->messageIndex > $this->receiveCount){ | |
| $this->receiveCount = $p->messageIndex; | |
| }elseif($p->messageIndex !== 0){ | |
| if(isset($this->received[$p->messageIndex])){ | |
| continue; | |
| } | |
| switch($p->pid()){ | |
| case 0x01: | |
| case ProtocolInfo::PING_PACKET: | |
| case ProtocolInfo::PONG_PACKET: | |
| case ProtocolInfo::MOVE_PLAYER_PACKET: | |
| case ProtocolInfo::REQUEST_CHUNK_PACKET: | |
| case ProtocolInfo::ANIMATE_PACKET: | |
| case ProtocolInfo::SET_HEALTH_PACKET: | |
| continue; | |
| } | |
| } | |
| $this->received[$p->messageIndex] = true; | |
| } | |
| $p->decode(); | |
| $this->handleDataPacket($p); | |
| } | |
| } | |
| } | |
| } | |
| if($this->nextBuffer <= $time and $this->bufferLen > 0){ | |
| $this->sendBuffer(); | |
| } | |
| $limit = $time - 5; //max lag | |
| foreach($this->recoveryQueue as $count => $data){ | |
| if($data->sendtime > $limit){ | |
| break; | |
| } | |
| unset($this->recoveryQueue[$count]); | |
| $this->resendQueue[$count] = $data; | |
| } | |
| if(($resendCnt = count($this->resendQueue)) > 0){ | |
| foreach($this->resendQueue as $count => $data){ | |
| unset($this->resendQueue[$count]); | |
| $this->packetStats[1]++; | |
| $this->lag[] = microtime(true) - $data->sendtime; | |
| $data->sendtime = microtime(true); | |
| $this->send($data); | |
| $this->recoveryQueue[$count] = $data; | |
| } | |
| } | |
| } | |
| /** | |
| * Handles a Minecraft packet | |
| * TODO: Separate all of this in handlers | |
| * | |
| * WARNING: Do not use this, it's only for internal use. | |
| * Changes to this function won't be recorded on the version. | |
| * | |
| * @param DataPacket $packet | |
| */ | |
| public function handleDataPacket(DataPacket $packet){ | |
| if($this->connected === false){ | |
| return; | |
| } | |
| $this->server->getPluginManager()->callEvent($ev = new DataPacketReceiveEvent($this, $packet)); | |
| if($ev->isCancelled()){ | |
| return; | |
| } | |
| switch($packet->pid()){ | |
| case 0x01: | |
| break; | |
| case ProtocolInfo::PONG_PACKET: | |
| break; | |
| case ProtocolInfo::PING_PACKET: | |
| $pk = new PongPacket; | |
| $pk->ptime = $packet->time; | |
| $pk->time = abs(microtime(true) * 1000); | |
| $this->directDataPacket($pk); | |
| break; | |
| case ProtocolInfo::DISCONNECT_PACKET: | |
| $this->close($this->username . " has left the game", "client disconnect"); | |
| break; | |
| case ProtocolInfo::CLIENT_CONNECT_PACKET: | |
| if($this->loggedIn === true){ | |
| break; | |
| } | |
| $pk = new ServerHandshakePacket; | |
| $pk->port = $this->port; | |
| $pk->session = $packet->session; | |
| $pk->session2 = Binary::readLong("\x00\x00\x00\x00\x04\x44\x0b\xa9"); | |
| $this->dataPacket($pk); | |
| break; | |
| case ProtocolInfo::CLIENT_HANDSHAKE_PACKET: | |
| if($this->loggedIn === true){ | |
| break; | |
| } | |
| break; | |
| case ProtocolInfo::LOGIN_PACKET: | |
| if($this->loggedIn === true){ | |
| break; | |
| } | |
| $this->username = TextFormat::clean($packet->username); | |
| $this->displayName = $this->username; | |
| $this->iusername = strtolower($this->username); | |
| $this->loginData = array("clientId" => $packet->clientId, "loginData" => $packet->loginData); | |
| if(count($this->server->getOnlinePlayers()) > $this->server->getMaxPlayers()){ | |
| if($this->kick("server full") === true){ | |
| return; | |
| } | |
| } | |
| if($packet->protocol1 !== ProtocolInfo::CURRENT_PROTOCOL){ | |
| if($packet->protocol1 < ProtocolInfo::CURRENT_PROTOCOL){ | |
| $pk = new LoginStatusPacket; | |
| $pk->status = 1; | |
| $this->directDataPacket($pk); | |
| }else{ | |
| $pk = new LoginStatusPacket; | |
| $pk->status = 2; | |
| $this->directDataPacket($pk); | |
| } | |
| $this->close("", "Incorrect protocol #" . $packet->protocol1, false); | |
| return; | |
| } | |
| if(preg_match('#^[a-zA-Z0-9_]{3,16}$#', $packet->username) == 0 or $this->username === "" or $this->iusername === "rcon" or $this->iusername === "console"){ | |
| $this->close("", "Bad username"); | |
| return; | |
| } | |
| $this->server->getPluginManager()->callEvent($ev = new PlayerPreLoginEvent($this, "Plugin reason")); | |
| if($ev->isCancelled()){ | |
| $this->close($ev->getKickMessage(), "Plugin reason"); | |
| return; | |
| } | |
| if(!$this->server->isWhitelisted(strtolower($this->getName()))){ | |
| $this->close($this->username . " has left the game", "Server is white-listed"); | |
| return; | |
| }elseif($this->server->getNameBans()->isBanned(strtolower($this->getName())) or $this->server->getIPBans()->isBanned($this->getAddress())){ | |
| $this->close($this->username . " has left the game", "You are banned"); | |
| return; | |
| } | |
| if($this->hasPermission(Server::BROADCAST_CHANNEL_USERS)){ | |
| $this->server->getPluginManager()->subscribeToPermission(Server::BROADCAST_CHANNEL_USERS, $this); | |
| } | |
| if($this->hasPermission(Server::BROADCAST_CHANNEL_ADMINISTRATIVE)){ | |
| $this->server->getPluginManager()->subscribeToPermission(Server::BROADCAST_CHANNEL_ADMINISTRATIVE, $this); | |
| } | |
| foreach($this->server->getOnlinePlayers() as $p){ | |
| if($p !== $this and strtolower($p->getName()) === strtolower($this->getName())){ | |
| if($p->kick("logged in from another location") === false){ | |
| $this->close($this->getName() . " has left the game", "already logged in"); | |
| return; | |
| }else{ | |
| break; | |
| } | |
| } | |
| } | |
| $nbt = $this->server->getOfflinePlayerData($this->username); | |
| if(!isset($nbt->NameTag)){ | |
| $nbt->NameTag = new String("NameTag", $this->username); | |
| }else{ | |
| $nbt["NameTag"] = $this->username; | |
| } | |
| $this->gamemode = $nbt["playerGameType"] & 0x03; | |
| if(($this->level = $this->server->getLevel($nbt["Level"])) === null){ | |
| $this->level = $this->server->getDefaultLevel(); | |
| $nbt["Level"] = $this->level->getName(); | |
| $nbt["Pos"][0] = $this->level->getSpawn()->x; | |
| $nbt["Pos"][1] = $this->level->getSpawn()->y; | |
| $nbt["Pos"][2] = $this->level->getSpawn()->z; | |
| } | |
| if(!($nbt instanceof Compound)){ | |
| $this->close($this->username . " has left the game", "invalid data"); | |
| return; | |
| } | |
| $this->achievements = array(); | |
| foreach($nbt->Achievements as $achievement){ | |
| $this->achievements[$achievement->getName()] = $achievement->getValue() > 0 ? true : false; | |
| } | |
| $nbt["lastPlayed"] = floor(microtime(true) * 1000); | |
| $this->server->saveOfflinePlayerData($this->username, $nbt); | |
| parent::__construct($this->level, $nbt); | |
| $this->loggedIn = true; | |
| if(($this->gamemode & 0x01) === 0x01){ | |
| $this->slot = 0; | |
| $this->hotbar[0] = 0; | |
| }else{ | |
| $this->slot = $this->hotbar[0]; | |
| } | |
| $this->server->getPluginManager()->callEvent($ev = new PlayerLoginEvent($this, "Plugin reason")); | |
| if($ev->isCancelled()){ | |
| $this->close($ev->getKickMessage(), "Plugin reason"); | |
| return; | |
| } | |
| $pk = new LoginStatusPacket; | |
| $pk->status = 0; | |
| $this->dataPacket($pk); | |
| $pk = new StartGamePacket; | |
| $pk->seed = $this->level->getSeed(); | |
| $pk->x = $this->x; | |
| $pk->y = $this->y; | |
| $pk->z = $this->z; | |
| $pk->generator = 0; | |
| $pk->gamemode = $this->gamemode & 0x01; | |
| $pk->eid = 0; //Always use EntityID as zero for the actual player | |
| $this->dataPacket($pk); | |
| if(($level = $this->server->getLevel($this->namedtag["SpawnLevel"])) instanceof Level){ | |
| $this->spawnPosition = new Position($this->namedtag["SpawnX"], $this->namedtag["SpawnY"], $this->namedtag["SpawnZ"], $level); | |
| $pk = new SetSpawnPositionPacket; | |
| $pk->x = (int) $this->spawnPosition->x; | |
| $pk->y = (int) $this->spawnPosition->y; | |
| $pk->z = (int) $this->spawnPosition->z; | |
| $this->dataPacket($pk); | |
| } | |
| //TODO: new events, or remove them! | |
| //$this->evid[] = $this->server->event("entity.animate", array($this, "eventHandler")); | |
| //$this->evid[] = $this->server->event("entity.event", array($this, "eventHandler")); | |
| //$this->evid[] = $this->server->event("entity.metadata", array($this, "eventHandler")); | |
| //$this->evid[] = $this->server->event("player.pickup", array($this, "eventHandler")); | |
| //$this->evid[] = $this->server->event("tile.container.slot", array($this, "eventHandler")); | |
| //$this->evid[] = $this->server->event("tile.update", array($this, "eventHandler")); | |
| $this->lastMeasure = microtime(true); | |
| $this->tasks[] = $this->server->getScheduler()->scheduleRepeatingTask(new CallbackTask(array($this, "measureLag")), 50); | |
| console("[INFO] " . TextFormat::AQUA . $this->username . TextFormat::RESET . "[/" . $this->ip . ":" . $this->port . "] logged in with entity id " . $this->id . " at (" . $this->level->getName() . ", " . round($this->x, 4) . ", " . round($this->y, 4) . ", " . round($this->z, 4) . ")"); | |
| $this->server->getPluginManager()->callEvent(new PlayerJoinEvent($this, $this->username . " joined the game")); | |
| break; | |
| case ProtocolInfo::READY_PACKET: | |
| if($this->loggedIn === false){ | |
| break; | |
| } | |
| switch($packet->status){ | |
| case 1: //Spawn!! | |
| if($this->spawned !== false){ | |
| break; | |
| } | |
| //TODO | |
| //$this->heal($this->data->get("health"), "spawn", true); | |
| $this->spawned = true; | |
| $this->spawnToAll(); | |
| $this->sendInventory(); | |
| $this->sendSettings(); | |
| $this->sendArmor(); | |
| $this->tasks[] = $this->server->getScheduler()->scheduleDelayedTask(new CallbackTask(array($this, "orderChunks")), 30); | |
| $this->blocked = false; | |
| $pk = new SetTimePacket; | |
| $pk->time = $this->level->getTime(); | |
| $pk->started = $this->level->stopTime == false; | |
| $this->dataPacket($pk); | |
| $pos = new Position($this->x, $this->y, $this->z, $this->level); | |
| $pos = $this->level->getSafeSpawn($pos); | |
| $this->server->getPluginManager()->callEvent($ev = new PlayerRespawnEvent($this, $pos)); | |
| $this->teleport($ev->getRespawnPosition()); | |
| $this->sendBuffer(); | |
| break; | |
| case 2: //Chunk loaded? | |
| break; | |
| } | |
| break; | |
| case ProtocolInfo::ROTATE_HEAD_PACKET: | |
| if($this->spawned === false){ | |
| break; | |
| } | |
| $this->setRotation($packet->yaw, $this->pitch); | |
| break; | |
| case ProtocolInfo::MOVE_PLAYER_PACKET: | |
| if($this->spawned === false){ | |
| break; | |
| } | |
| if($packet->messageIndex > $this->lastMovement){ | |
| $this->lastMovement = $packet->messageIndex; | |
| $newPos = new Vector3($packet->x, $packet->y, $packet->z); | |
| if($this->forceMovement instanceof Vector3){ | |
| if($this->forceMovement->distance($newPos) <= 0.7){ | |
| $this->forceMovement = false; | |
| }else{ | |
| $this->setPosition($this->forceMovement); | |
| } | |
| } | |
| /*$speed = $this->entity->getSpeedMeasure(); | |
| if($this->blocked === true or ($this->server->api->getProperty("allow-flight") !== true and (($speed > 9 and ($this->gamemode & 0x01) === 0x00) or $speed > 20 or $this->entity->distance($newPos) > 7)) or $this->server->api->handle("player.move", $this->entity) === false){ | |
| if($this->lastCorrect instanceof Vector3){ | |
| $this->teleport($this->lastCorrect, $this->entity->yaw, $this->entity->pitch, false); | |
| } | |
| if($this->blocked !== true){ | |
| console("[WARNING] ".$this->username." moved too quickly!"); | |
| } | |
| }else{*/ | |
| $this->setPositionAndRotation($newPos, $packet->yaw, $packet->pitch); | |
| //} | |
| } | |
| break; | |
| case ProtocolInfo::PLAYER_EQUIPMENT_PACKET: | |
| if($this->spawned === false){ | |
| break; | |
| } | |
| if($packet->slot === 0x28 or $packet->slot === 0){ //0 for 0.8.0 compatibility | |
| $packet->slot = -1; //Air | |
| }else{ | |
| $packet->slot -= 9; //Get real block slot | |
| } | |
| if(($this->gamemode & 0x01) === 1){ //Creative mode match | |
| $packet->slot = false; | |
| foreach(Block::$creative as $i => $d){ | |
| if($d[0] === $packet->item and $d[1] === $packet->meta){ | |
| $packet->slot = $i; | |
| $item = Item::get($d[0], $d[1], 1); | |
| break; | |
| } | |
| } | |
| }else{ | |
| $item = $this->getSlot($packet->slot); | |
| } | |
| if($packet->slot === false){ | |
| $this->sendInventorySlot($packet->slot); | |
| }else{ | |
| $this->server->getPluginManager()->callEvent($ev = new PlayerItemHeldEvent($this, $item, $packet->slot, 0)); | |
| if($ev->isCancelled()){ | |
| $this->sendInventorySlot($packet->slot); | |
| }elseif($item instanceof Item){ | |
| $this->setEquipmentSlot(0, $packet->slot); | |
| $this->setCurrentEquipmentSlot(0); | |
| if(($this->gamemode & 0x01) === 0){ | |
| if(!in_array($this->slot, $this->hotbar)){ | |
| array_pop($this->hotbar); | |
| array_unshift($this->hotbar, $this->slot); | |
| } | |
| } | |
| } | |
| } | |
| if($this->inAction === true){ | |
| $this->inAction = false; | |
| //$this->entity->updateMetadata(); | |
| } | |
| break; | |
| case ProtocolInfo::REQUEST_CHUNK_PACKET: | |
| break; | |
| case ProtocolInfo::USE_ITEM_PACKET: | |
| $blockVector = new Vector3($packet->x, $packet->y, $packet->z); | |
| if(($this->spawned === false or $this->blocked === true) and $packet->face >= 0 and $packet->face <= 5){ | |
| $target = $this->level->getBlock($blockVector); | |
| $block = $target->getSide($packet->face); | |
| $pk = new UpdateBlockPacket; | |
| $pk->x = $target->x; | |
| $pk->y = $target->y; | |
| $pk->z = $target->z; | |
| $pk->block = $target->getID(); | |
| $pk->meta = $target->getMetadata(); | |
| $this->dataPacket($pk); | |
| $pk = new UpdateBlockPacket; | |
| $pk->x = $block->x; | |
| $pk->y = $block->y; | |
| $pk->z = $block->z; | |
| $pk->block = $block->getID(); | |
| $pk->meta = $block->getMetadata(); | |
| $this->dataPacket($pk); | |
| break; | |
| } | |
| $this->craftingItems = array(); | |
| $this->toCraft = array(); | |
| $packet->eid = $this->id; | |
| if($packet->face >= 0 and $packet->face <= 5){ //Use Block, place | |
| if($this->inAction === true){ | |
| $this->inAction = false; | |
| //$this->entity->updateMetadata(); | |
| } | |
| if($blockVector->distance($this) > 10){ | |
| }elseif(($this->gamemode & 0x01) === 1){ | |
| $item = Item::get(Block::$creative[$this->getCurrentEquipment()][0], Block::$creati |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment