Fixed wrong paths

src/pocketmine/tile/Chest.php

@@ -0,0 +1,129 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____  
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \ 
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/ 
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_| 
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ * 
+ *
+*/
+
+namespace pocketmine\tile;
+
+use pocketmine\level\Level;
+use pocketmine\math\Vector3 as Vector3;
+use pocketmine\nbt\NBT;
+use pocketmine\nbt\tag\Compound;
+use pocketmine\nbt\tag\Int;
+use pocketmine\nbt\tag\String;
+use pocketmine\network\protocol\EntityDataPacket;
+use pocketmine\Player;
+
+class Chest extends Spawnable{
+	use Container;
+
+	const SLOTS = 27;
+
+	public function __construct(Level $level, Compound $nbt){
+		$nbt["id"] = Tile::CHEST;
+		parent::__construct($level, $nbt);
+	}
+
+	public function isPaired(){
+		if(!isset($this->namedtag->pairx) or !isset($this->namedtag->pairz)){
+			return false;
+		}
+
+		return true;
+	}
+
+	public function getPair(){
+		if($this->isPaired()){
+			return $this->level->getTile(new Vector3((int) $this->namedtag->pairx, $this->y, (int) $this->namedtag->pairz));
+		}
+
+		return false;
+	}
+
+	public function pairWith(Tile $tile){
+		if($this->isPaired() or $tile->isPaired()){
+			return false;
+		}
+
+		$this->namedtag->pairx = $tile->x;
+		$this->namedtag->pairz = $tile->z;
+
+		$tile->namedtag->pairx = $this->x;
+		$tile->namedtag->pairz = $this->z;
+
+		$this->spawnToAll();
+		$tile->spawnToAll();
+		$this->server->handle("tile.update", $this);
+		$this->server->handle("tile.update", $tile);
+
+		return true;
+	}
+
+	public function unpair(){
+		if(!$this->isPaired()){
+			return false;
+		}
+
+		$tile = $this->getPair();
+		unset($this->namedtag->pairx, $this->namedtag->pairz, $tile->namedtag->pairx, $tile->namedtag->pairz);
+
+		$this->spawnToAll();
+		$this->server->handle("tile.update", $this);
+		if($tile instanceof Chest){
+			$tile->spawnToAll();
+			$this->server->handle("tile.update", $tile);
+		}
+
+		return true;
+	}
+
+	public function spawnTo(Player $player){
+		if($this->closed){
+			return false;
+		}
+
+		$nbt = new NBT(NBT::LITTLE_ENDIAN);
+		if($this->isPaired()){
+			$nbt->setData(new Compound("", array(
+				new String("id", Tile::CHEST),
+				new Int("x", (int) $this->x),
+				new Int("y", (int) $this->y),
+				new Int("z", (int) $this->z),
+				new Int("pairx", (int) $this->namedtag->pairx),
+				new Int("pairz", (int) $this->namedtag->pairz)
+			)));
+		}else{
+			$nbt->setData(new Compound("", array(
+				new String("id", Tile::CHEST),
+				new Int("x", (int) $this->x),
+				new Int("y", (int) $this->y),
+				new Int("z", (int) $this->z)
+			)));
+		}
+
+		$pk = new EntityDataPacket;
+		$pk->x = $this->x;
+		$pk->y = $this->y;
+		$pk->z = $this->z;
+		$pk->namedtag = $nbt->write();
+		$player->dataPacket($pk);
+
+		return true;
+	}
+}

src/pocketmine/tile/Container.php

@@ -0,0 +1,195 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____  
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \ 
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/ 
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_| 
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ * 
+ *
+*/
+
+namespace pocketmine\tile;
+
+use pocketmine\event\tile\TileInventoryChangeEvent;
+use pocketmine\item\Item;
+use pocketmine\nbt\tag\Byte;
+use pocketmine\nbt\tag\Compound;
+use pocketmine\nbt\tag\Short;
+use pocketmine\Network;
+use pocketmine\network\protocol\ContainerOpenPacket;
+use pocketmine\network\protocol\ContainerSetContentPacket;
+use pocketmine\network\protocol\TileEventPacket;
+use pocketmine\Player;
+use pocketmine\Server;
+
+trait Container{
+	public function openInventory(Player $player){
+		if($this instanceof Chest){
+			$player->windowCnt++;
+			$player->windowCnt = $id = max(2, $player->windowCnt % 99);
+			if(($pair = $this->getPair()) !== false){
+				if(($pair->x + ($pair->z << 13)) > ($this->x + ($this->z << 13))){ //Order them correctly
+					$player->windows[$id] = array(
+						$pair,
+						$this
+					);
+				}else{
+					$player->windows[$id] = array(
+						$this,
+						$pair
+					);
+				}
+			}else{
+				$player->windows[$id] = $this;
+			}
+
+			$pk = new ContainerOpenPacket();
+			$pk->windowid = $id;
+			$pk->type = 0;
+			$pk->slots = is_array($player->windows[$id]) ? Chest::SLOTS << 1 : Chest::SLOTS;
+			$pk->x = $this->x;
+			$pk->y = $this->y;
+			$pk->z = $this->z;
+			$player->dataPacket($pk);
+			$slots = array();
+
+			if(is_array($player->windows[$id])){
+				$all = $this->level->getPlayers();
+				foreach($player->windows[$id] as $ob){
+					$pk = new TileEventPacket();
+					$pk->x = $ob->x;
+					$pk->y = $ob->y;
+					$pk->z = $ob->z;
+					$pk->case1 = 1;
+					$pk->case2 = 2;
+					Player::broadcastPacket($all, $pk);
+					for($s = 0; $s < Chest::SLOTS; ++$s){
+						$slot = $ob->getSlot($s);
+						if($slot->getID() > Item::AIR and $slot->getCount() > 0){
+							$slots[] = $slot;
+						}else{
+							$slots[] = Item::get(Item::AIR, 0, 0);
+						}
+					}
+				}
+			}else{
+				$pk = new TileEventPacket();
+				$pk->x = $this->x;
+				$pk->y = $this->y;
+				$pk->z = $this->z;
+				$pk->case1 = 1;
+				$pk->case2 = 2;
+				Player::broadcastPacket($this->level->getPlayers(), $pk);
+				for($s = 0; $s < Chest::SLOTS; ++$s){
+					$slot = $this->getSlot($s);
+					if($slot->getID() > Item::AIR and $slot->getCount() > 0){
+						$slots[] = $slot;
+					}else{
+						$slots[] = Item::get(Item::AIR, 0, 0);
+					}
+				}
+			}
+
+			$pk = new ContainerSetContentPacket();
+			$pk->windowid = $id;
+			$pk->slots = $slots;
+			$player->dataPacket($pk);
+
+			return true;
+		}elseif($this instanceof Furnace){
+			$player->windowCnt++;
+			$player->windowCnt = $id = max(2, $player->windowCnt % 99);
+			$player->windows[$id] = $this;
+
+			$pk = new ContainerOpenPacket();
+			$pk->windowid = $id;
+			$pk->type = 2;
+			$pk->slots = Furnace::SLOTS;
+			$pk->x = $this->x;
+			$pk->y = $this->y;
+			$pk->z = $this->z;
+			$player->dataPacket($pk);
+
+			$slots = array();
+			for($s = 0; $s < Furnace::SLOTS; ++$s){
+				$slot = $this->getSlot($s);
+				if($slot->getID() > Item::AIR and $slot->getCount() > 0){
+					$slots[] = $slot;
+				}else{
+					$slots[] = Item::get(Item::AIR, 0, 0);
+				}
+			}
+			$pk = new ContainerSetContentPacket();
+			$pk->windowid = $id;
+			$pk->slots = $slots;
+			$player->dataPacket($pk);
+
+			return true;
+		}
+	}
+
+	public function getSlotIndex($s){
+		foreach($this->namedtag->Items as $i => $slot){
+			if($slot["Slot"] === $s){
+				return $i;
+			}
+		}
+
+		return -1;
+	}
+
+	public function getSlot($s){
+		$i = $this->getSlotIndex($s);
+		if($i === false or $i < 0){
+			return Item::get(Item::AIR, 0, 0);
+		}else{
+			return Item::get($this->namedtag->Items[$i]["id"], $this->namedtag->Items[$i]["Damage"], $this->namedtag->Items[$i]["Count"]);
+		}
+	}
+
+	public function setSlot($s, Item $item, $update = true, $offset = 0){
+		$i = $this->getSlotIndex($s);
+		if($i === false){
+			return false;
+		}
+		Server::getInstance()->getPluginManager()->callEvent($ev = new TileInventoryChangeEvent($this, $this->getSlot($s), $item, $s, $offset));
+		if($ev->isCancelled()){
+			return false;
+		}
+
+		$item = $ev->getNewItem();
+		$d = new Compound(false, array(
+			new Byte("Count", $item->getCount()),
+			new Byte("Slot", $s),
+			new Short("id", $item->getID()),
+			new Short("Damage", $item->getMetadata()),
+		));
+
+		if($item->getID() === Item::AIR or $item->getCount() <= 0){
+			if($i >= 0){
+				unset($this->namedtag->Items[$i]);
+			}
+		}elseif($i < 0){
+			$this->namedtag->Items[] = $d;
+		}else{
+			$this->namedtag->Items[$i] = $d;
+		}
+
+		if($update === true){
+			$this->scheduleUpdate();
+		}
+
+		return true;
+	}
+}

src/pocketmine/tile/Furnace.php

@@ -0,0 +1,118 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____  
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \ 
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/ 
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_| 
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ * 
+ *
+*/
+
+namespace pocketmine\tile;
+
+use pocketmine\block\Block;
+use pocketmine\item\Item;
+use pocketmine\level\Level;
+use pocketmine\nbt\tag\Compound;
+
+class Furnace extends Tile{
+	use Container;
+
+	const SLOTS = 3;
+
+	public function __construct(Level $level, Compound $nbt){
+		$nbt["id"] = Tile::FURNACE;
+		parent::__construct($level, $nbt);
+		if(!isset($this->namedtag->BurnTime) or $this->namedtag->BurnTime < 0){
+			$this->namedtag->BurnTime = 0;
+		}
+		if(!isset($this->namedtag->CookTime) or $this->namedtag->CookTime < 0 or ($this->namedtag->BurnTime === 0 and $this->namedtag->CookTime > 0)){
+			$this->namedtag->CookTime = 0;
+		}
+		if(!isset($this->namedtag->MaxTime)){
+			$this->namedtag->MaxTime = $this->namedtag->BurnTime;
+			$this->namedtag->BurnTicks = 0;
+		}
+		if($this->namedtag->BurnTime > 0){
+			$this->scheduleUpdate();
+		}
+	}
+
+	public function onUpdate(){
+		if($this->closed === true){
+			return false;
+		}
+
+		$ret = false;
+
+		$fuel = $this->getSlot(1);
+		$raw = $this->getSlot(0);
+		$product = $this->getSlot(2);
+		$smelt = $raw->getSmeltItem();
+		$canSmelt = ($smelt !== false and $raw->getCount() > 0 and (($product->getID() === $smelt->getID() and $product->getMetadata() === $smelt->getMetadata() and $product->getCount() < $product->getMaxStackSize()) or $product->getID() === Item::AIR));
+		if($this->namedtag->BurnTime <= 0 and $canSmelt and $fuel->getFuelTime() !== false and $fuel->getCount() > 0){
+			$this->lastUpdate = microtime(true);
+			$this->namedtag->MaxTime = $this->namedtag->BurnTime = floor($fuel->getFuelTime() * 20);
+			$this->namedtag->BurnTicks = 0;
+			$fuel->setCount($fuel->getCount() - 1);
+			if($fuel->getCount() === 0){
+				$fuel = Item::get(Item::AIR, 0, 0);
+			}
+			$this->setSlot(1, $fuel, false);
+			$current = $this->level->getBlock($this);
+			if($current->getID() === Item::FURNACE){
+				$this->level->setBlock($this, Block::get(Item::BURNING_FURNACE, $current->getMetadata()), true, false, true);
+			}
+		}
+		if($this->namedtag->BurnTime > 0){
+			$ticks = (microtime(true) - $this->lastUpdate) * 20;
+			$this->namedtag->BurnTime -= $ticks;
+			$this->namedtag->BurnTicks = ceil(($this->namedtag->BurnTime / $this->namedtag->MaxTime) * 200);
+			if($smelt !== false and $canSmelt){
+				$this->namedtag->CookTime += $ticks;
+				if($this->namedtag->CookTime >= 200){ //10 seconds
+					$product = Item::get($smelt->getID(), $smelt->getMetadata(), $product->getCount() + 1);
+					$this->setSlot(2, $product, false);
+					$raw->setCount($raw->getCount() - 1);
+					if($raw->getCount() === 0){
+						$raw = Item::get(Item::AIR, 0, 0);
+					}
+					$this->setSlot(0, $raw, false);
+					$this->namedtag->CookTime -= 200;
+				}
+			}elseif($this->namedtag->BurnTime <= 0){
+				$this->namedtag->BurnTime = 0;
+				$this->namedtag->CookTime = 0;
+				$this->namedtag->BurnTicks = 0;
+			}else{
+				$this->namedtag->CookTime = 0;
+			}
+			$ret = true;
+		}else{
+			$current = $this->level->getBlock($this);
+			if($current->getID() === Item::BURNING_FURNACE){
+				$this->level->setBlock($this, Block::get(Item::FURNACE, $current->getMetadata()), true, false, true);
+			}
+			$this->namedtag->CookTime = 0;
+			$this->namedtag->BurnTime = 0;
+			$this->namedtag->BurnTicks = 0;
+		}
+
+
+		$this->server->handle("tile.update", $this);
+		$this->lastUpdate = microtime(true);
+
+		return $ret;
+	}
+}

src/pocketmine/tile/Sign.php

@@ -0,0 +1,85 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____  
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \ 
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/ 
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_| 
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ * 
+ *
+*/
+
+namespace pocketmine\tile;
+
+use pocketmine\level\Level;
+use pocketmine\nbt\NBT;
+use pocketmine\nbt\tag\Compound;
+use pocketmine\nbt\tag\Int;
+use pocketmine\nbt\tag\String;
+use pocketmine\network\protocol\EntityDataPacket;
+use pocketmine\Player;
+
+class Sign extends Spawnable{
+
+	public function __construct(Level $level, Compound $nbt){
+		$nbt["id"] = Tile::SIGN;
+		parent::__construct($level, $nbt);
+	}
+
+	public function setText($line1 = "", $line2 = "", $line3 = "", $line4 = ""){
+		$this->namedtag->Text1 = $line1;
+		$this->namedtag->Text2 = $line2;
+		$this->namedtag->Text3 = $line3;
+		$this->namedtag->Text4 = $line4;
+		$this->spawnToAll();
+		$this->server->handle("tile.update", $this);
+
+		return true;
+	}
+
+	public function getText(){
+		return array(
+			$this->namedtag->Text1,
+			$this->namedtag->Text2,
+			$this->namedtag->Text3,
+			$this->namedtag->Text4
+		);
+	}
+
+	public function spawnTo(Player $player){
+		if($this->closed){
+			return false;
+		}
+
+		$nbt = new NBT(NBT::LITTLE_ENDIAN);
+		$nbt->setData(new Compound("", array(
+			new String("Text1", $this->namedtag->Text1),
+			new String("Text2", $this->namedtag->Text2),
+			new String("Text3", $this->namedtag->Text3),
+			new String("Text4", $this->namedtag->Text4),
+			new String("id", Tile::SIGN),
+			new Int("x", (int) $this->x),
+			new Int("y", (int) $this->y),
+			new Int("z", (int) $this->z)
+		)));
+		$pk = new EntityDataPacket;
+		$pk->x = $this->x;
+		$pk->y = $this->y;
+		$pk->z = $this->z;
+		$pk->namedtag = $nbt->write();
+		$player->dataPacket($pk);
+
+		return true;
+	}
+
+}

src/pocketmine/tile/Spawnable.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____  
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \ 
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/ 
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_| 
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * @author PocketMine Team
+ * @link http://www.pocketmine.net/
+ * 
+ *
+*/
+
+namespace pocketmine\tile;
+
+use pocketmine\Player;
+
+abstract class Spawnable extends Tile{
+	public abstract function spawnTo(Player $player);
+
+	public function spawnToAll(){
+		foreach($this->level->getPlayers() as $player){
+			if($player->eid !== false or $player->spawned !== true){
+				$this->spawnTo($player);
+			}
+		}
+	}
+}

src/pocketmine/tile/Tile.php

@@ -0,0 +1,122 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____  
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \ 
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/ 
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_| 
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the 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 Tile classes and related classes
+ * TODO: Add Nether Reactor tile
+ */
+namespace pocketmine\tile;
+
+use pocketmine\level\Level;
+use pocketmine\level\Position;
+use pocketmine\nbt\tag\Compound;
+use pocketmine\pmf\LevelFormat;
+use pocketmine\Server;
+
+abstract class Tile extends Position{
+	const SIGN = "Sign";
+	const CHEST = "Chest";
+	const FURNACE = "Furnace";
+
+	public static $tileCount = 1;
+
+	/**
+	 * @var Tile[]
+	 */
+	public static $list = array();
+
+	/**
+	 * @var Tile[]
+	 */
+	public static $needUpdate = array();
+
+	public $chunkIndex;
+	public $name;
+	public $id;
+	public $x;
+	public $y;
+	public $z;
+	public $attach;
+	public $metadata;
+	public $closed;
+	public $namedtag;
+	protected $lastUpdate;
+	protected $server;
+
+	public static function getByID($tileID){
+		return isset(Tile::$list[$tileID]) ? Tile::$list[$tileID] : false;
+	}
+
+	public static function getAll(){
+		return Tile::$list;
+	}
+
+	public function getID(){
+		return $this->id;
+	}
+
+
+	public function __construct(Level $level, Compound $nbt){
+		$this->server = Server::getInstance();
+		$this->level = $level;
+		$this->namedtag = $nbt;
+		$this->closed = false;
+		$this->name = "";
+		$this->lastUpdate = microtime(true);
+		$this->id = Tile::$tileCount++;
+		Tile::$list[$this->id] = $this;
+		$this->x = (int) $this->namedtag->x;
+		$this->y = (int) $this->namedtag->y;
+		$this->z = (int) $this->namedtag->z;
+
+		$index = LevelFormat::getIndex($this->x >> 4, $this->z >> 4);
+		$this->chunkIndex = $index;
+		$this->level->tiles[$this->id] = $this;
+		$this->level->chunkTiles[$this->chunkIndex][$this->id] = $this;
+	}
+
+	public function onUpdate(){
+		return false;
+	}
+
+	public final function scheduleUpdate(){
+		Tile::$needUpdate[$this->id] = $this;
+	}
+
+	public function close(){
+		if($this->closed === false){
+			$this->closed = true;
+			unset(Tile::$needUpdate[$this->id]);
+			unset($this->level->tiles[$this->id]);
+			unset($this->level->chunkTiles[$this->chunkIndex][$this->id]);
+			unset(Tile::$list[$this->id]);
+		}
+	}
+
+	public function __destruct(){
+		$this->close();
+	}
+
+	public function getName(){
+		return $this->name;
+	}
+
+}