Updated Levels :D

src/pocketmine/level/generator/GenerationManager.php

@@ -0,0 +1,257 @@
+<?php
+
+/*
+ *
+ *  ____            _        _   __  __ _                  __  __ ____
+ * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
+ * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
+ * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
+ * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software 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\level\format\SimpleChunk;
+use pocketmine\utils\Binary;
+
+class GenerationManager{
+
+
+	/*
+	 * IPC protocol:
+	 * int32 (total length)
+	 * byte (packet id)
+	 * byte[] (length - 1 bytes)
+	 */
+
+	/*
+	 * Direction: Server->Thread
+	 * byte[] payload:
+	 * string root namespace
+	 * byte[] path
+	 */
+	const PACKET_ADD_NAMESPACE = 0x00;
+
+	/*
+	 * Direction: Both
+	 * If Server->Thread, request chunk generation
+	 * If Thread->Server, request chunk contents / loading
+	 * byte[] payload:
+	 * int32 levelID
+	 * int32 chunkX
+	 * int32 chunkZ
+	 */
+	const PACKET_REQUEST_CHUNK = 0x01;
+
+	/*
+	 * Direction: Both
+	 * byte[] payload:
+	 * int32 levelID
+	 * int32 chunkX
+	 * int32 chunkZ
+	 * byte flags (1 generated, 2 populated)
+	 * byte[] chunk (none if generated flag is not set)
+	 */
+	const PACKET_SEND_CHUNK = 0x02;
+
+	/*
+	 * Direction: Server->Thread
+	 * byte[] payload:
+	 * int32 levelID
+	 * int32 seed
+	 * string class that extends pocketmine\level\generator\Generator
+	 * byte[] serialized options array
+	 */
+	const PACKET_OPEN_LEVEL = 0x03;
+
+	/*
+	 * Direction: Server->Thread
+	 * byte[] payload:
+	 * int32 levelID
+	 */
+	const PACKET_CLOSE_LEVEL = 0x04;
+
+	/*
+	 * Direction: Server->Thread
+	 * no payload
+	 */
+	const PACKET_SHUTDOWN = 0xff;
+
+
+
+	protected $socket;
+	/** @var \Logger */
+	protected $logger;
+	/** @var \SplAutoLoader */
+	protected $loader;
+
+	/** @var GenerationChunkManager[] */
+	protected $levels = [];
+
+	/** @var \SplQueue */
+	protected $requestQueue;
+
+	protected $needsChunk = null;
+
+	protected $shutdown = false;
+
+	/**
+	 * @param resource       $socket
+	 * @param \Logger        $logger
+	 * @param \SplAutoloader $loader
+	 */
+	public function __construct($socket, \Logger $logger, \SplAutoloader $loader){
+		$this->socket = $socket;
+		$this->logger = $logger;
+		$this->loader = $loader;
+		$this->requestQueue = new \SplQueue();
+
+		while($this->shutdown !== true){
+			if($this->requestQueue->count() > 0){
+				$r = $this->requestQueue->dequeue();
+				$levelID = $r[0];
+				$chunkX = $r[1];
+				$chunkZ = $r[2];
+				$this->generateChunk($levelID, $chunkX, $chunkZ);
+
+			}
+			$this->readPacket();
+		}
+	}
+
+	protected function openLevel($levelID, $seed, $class, array $options){
+		if(!isset($this->levels[$levelID])){
+			$this->levels[$levelID] = new GenerationChunkManager($this, $levelID, $seed, $class, $options);
+		}
+	}
+
+	protected function generateChunk($levelID, $chunkX, $chunkZ){
+		if(isset($this->levels[$levelID])){
+			$this->levels[$levelID]->populateChunk($chunkX, $chunkZ); //Request population directly
+			//TODO: wait for queue generation (to wait for extra chunk changes)
+		}
+	}
+
+	protected function closeLevel($levelID){
+		if(!isset($this->levels[$levelID])){
+			$this->levels[$levelID]->shutdown();
+			unset($this->levels[$levelID]);
+		}
+	}
+
+	protected function enqueueChunk($levelID, $chunkX, $chunkZ){
+		$this->requestQueue->enqueue([$levelID, $chunkX, $chunkZ]);
+	}
+
+	protected function receiveChunk($levelID, SimpleChunk $chunk){
+		if($this->needsChunk !== null and $this->needsChunk[0] === $levelID){
+			if($this->needsChunk[1] === $chunk->getX() and $this->needsChunk[2] === $chunk->getZ()){
+				$this->needsChunk = $chunk;
+			}
+		}
+		//TODO: set new received chunks
+	}
+
+	/**
+	 * @param $levelID
+	 * @param $chunkX
+	 * @param $chunkZ
+	 *
+	 * @return SimpleChunk
+	 */
+	public function requestChunk($levelID, $chunkX, $chunkZ){
+		$this->needsChunk = [$levelID, $chunkX, $chunkZ];
+		$binary = chr(self::PACKET_REQUEST_CHUNK . Binary::writeInt($levelID) . Binary::writeInt($chunkX) . Binary::writeInt($chunkZ));
+		@socket_write($this->socket, Binary::writeInt(strlen($binary)) . $binary);
+		do{
+			$this->readPacket();
+		}while($this->shutdown !== true and !($this->needsChunk instanceof SimpleChunk));
+
+		$chunk = $this->needsChunk;
+		$this->needsChunk = null;
+		if($chunk instanceof SimpleChunk){
+			return $chunk;
+		}else{
+			return new SimpleChunk($chunkX, $chunkZ, 0);
+		}
+	}
+
+	public function sendChunk($levelID, SimpleChunk $chunk){
+		$binary = chr(self::PACKET_SEND_CHUNK . Binary::writeInt($levelID) . $chunk->toBinary());
+		@socket_write($this->socket, Binary::writeInt(strlen($binary)) . $binary);
+	}
+
+	protected function readPacket(){
+		$len = socket_read($this->socket, 4);
+		if($len === false or $len === ""){
+			usleep(5000);
+			return;
+		}
+		$packet = socket_read($this->socket, Binary::readInt($len));
+		$pid = ord($packet{0});
+		$offset = 1;
+		if($pid === self::PACKET_REQUEST_CHUNK){
+			$levelID = Binary::readInt(substr($packet, $offset, 4));
+			$offset += 4;
+			$chunkX = Binary::readInt(substr($packet, $offset, 4));
+			$offset += 4;
+			$chunkZ = Binary::readInt(substr($packet, $offset, 4));
+			$this->enqueueChunk($levelID, $chunkX, $chunkZ);
+
+		}elseif($pid === self::PACKET_SEND_CHUNK){
+			$levelID = Binary::readInt(substr($packet, $offset, 4));
+			$offset += 4;
+			$chunk = SimpleChunk::fromBinary(substr($packet, $offset));
+			$this->receiveChunk($levelID, $chunk);
+
+		}elseif($pid === self::PACKET_OPEN_LEVEL){
+			$levelID = Binary::readInt(substr($packet, $offset, 4));
+			$offset += 4;
+			$seed = Binary::readInt(substr($packet, $offset, 4));
+			$offset += 4;
+			$len = Binary::readShort(substr($packet, $offset, 2));
+			$offset += 2;
+			$class = substr($packet, $offset, $len);
+			$offset += $len;
+			$options = unserialize(substr($packet, $offset));
+			$this->openLevel($levelID, $seed, $class, $options);
+
+		}elseif($pid === self::PACKET_CLOSE_LEVEL){
+			$levelID = Binary::readInt(substr($packet, $offset, 4));
+			$this->closeLevel($levelID);
+		}elseif($pid === self::PACKET_ADD_NAMESPACE){
+			$len = Binary::readShort(substr($packet, $offset, 2));
+			$offset += 2;
+			$namespace = substr($packet, $offset, $len);
+			$offset += $len;
+			$path = substr($packet, $offset);
+			$this->loader->add($namespace, [$path]);
+		}elseif($pid === self::PACKET_SHUTDOWN){
+			foreach($this->levels as $level){
+				$level->shutdown();
+			}
+			$this->levels = [];
+
+			$this->shutdown = true;
+			socket_close($this->socket);
+		}
+	}
+
+	/**
+	 * @return \Logger
+	 */
+	public function getLogger(){
+		return $this->logger;
+	}
+
+}