View difference between Paste ID: 7vYekJsh and GLTRj3pP

 <?php
 /**
 * --------------------------------------------------------------------------------
 * - Minecraft Online-Status Image-Generator
 * --------------------------------------------------------------------------------
 * This code is based on Revi's initial idea and work
 * http://forums.bukkit.org/threads/web-beautiful-monitoring.122457
 *
 * Features
 * - supports png, jpg and gif as file_type
 * - per image cache files
 * - keep the cache clean (default is 30 missed unlink actions)
 *
 */
 
 
 /**
 * --------------------------------------------------------------------------------
 * - Configuration Section
 * --------------------------------------------------------------------------------
 */
 error_reporting(0); # set to E_ALL when debugging otherwise you can leave this alone
 
 $config['host'] = '127.0.0.1'; # IP or hostname
 $config['port'] = 25565; # port
 $config['folder_name'] = 'cache'; # folder used for caching; Make sure the folder is created and has the correct access rights
 $config['time_update_cache'] = 60; # update cache every x second, decrease this value if you want a faster response time
 $config['offline_message'] = 'offline';	# this message will be shown, when the server is offline or in case of connection problems
 $config['file_type'] = @$_GET['t']; # supported file_types (png|jpg|gif)
 $config['keep_files'] = 30; # keep n files before rebuilding the cache
 $config['debug'] = false; # set to true for debugging
 
 /**
 * You normally don't have to edit below this line.
 * Only edit below this line if you know what you are doing.
 */
 class MCMonitor {
 
 	protected $host;
 	protected $port;
 
 	protected $offline_message;
 	protected $file_type;
 
 	protected $is_connected = false;
 	protected $is_online = false;
 
 	protected $online = 0;
 	protected $max_online = 0;
 
 	protected $data;
 
 	protected static $cache;
 	protected static $image;
 	protected static $instance;
 
 	public function __construct($host = '127.0.0.1', $port = 25565, $offline_message = 'offline', $file_type = 'png') {
 		$this->setHost($host);
 		$this->setPort($port);
 
 		$this->setOfflineMessage($offline_message);
 		$this->setFileType($file_type);
 
 		// try to connect and set online status
 		$this->getData(true);
 
 		self::$instance = $this;
 	}
 
 	public function getInstance() {
 		if (self::$instance == null) {
 			global $config;
 
 			self::$instance = new MCMonitor($config['host'], $config['port'], $config['offline_message'], $config['file_type']);
 		}
 
 		return self::$instance;
 	}
 
 	public function setOnlineCount($num = 0) {
 		$this->online = $num;
 
 		return $this;
 	}
 
 	public function getOnlineCount() {
 		return $this->online;
 	}
 
 	public function setMaxOnlineCount($num = 0) {
 		$this->max_online = $num;
 
 		return $this;
 	}
 
 	public function getMaxOnlineCount() {
 		return $this->max_online;
 	}
 
 	public function getData($refresh = false) {
 		if (($this->data == null) || ($refresh))
 			return $this->fetchData();
 
 		return $this->data;
 	}
 
 	private function fetchData() {
 		$socket = @fsockopen($this->getHost(), $this->getPort());
 
 		if ($socket !== false) {
 			$this->is_connected = true;
 
 			// connect to host
 			fwrite($socket, "\xFE\x01");
 			$data = fread($socket, 1024);
 			fclose($socket);
 
 			$this->is_connected = false;
 
 			// is the host online?
 			if (($data !== false) && (substr($data, 0, 1) == "\xFF")) {
 				$this->is_online = true;
 				//$info = explode("\xA7", mb_convert_encoding(substr($data, 1), "auto", "UCS-2"));
 				$this->data = explode("\x00", mb_convert_encoding(substr($data, 1), 'auto', 'UCS-2'));
 				//var_dump($info); # uncomment to debug the parsed online packet
 				return $this->data;
 			}
 		}
 
 		$this->data = $this->getOfflineMessage();
 		$this->is_online = false;
 
 		return $this->data;
 	}
 
 	public function setHost($host = '127.0.0.1') {
 		$this->host = $host;
 
 		return $this;
 	}
 
 	public function getHost() {
 		return $this->host;
 	}
 
 	public function setPort($port = 25565) {
 		$this->port = $port;
 
 		return $this;
 	}
 
 	public function getPort() {
 		return $this->port;
 	}
 
 	public function setOfflineMessage($offline_message = 'offline') {
 		$this->offline_message = $offline_message;
 
 		return $this;
 	}
 
 	public function getOfflineMessage() {
 		return $this->offline_message;
 	}
 
 	public function setFileType($file_type = 'png') {
 		$this->file_type = ($this->is_supported_fileType($file_type)) ? $file_type : 'png'; # always fallback to png;
 
 		return $this;
 	}
 
 	public function getFileType() {
 		return $this->file_type;
 	}
 
 	public function is_supported_fileType($file_type) {
 		switch ($file_type) {
 			case 'png':
 			case 'jpg':
 			case 'gif':
 				return true;
 		}
 
 		return false;
 	}
 
 	public function isOnline() {
 		return $this->is_online;
 	}
 
 	public function isConnected() {
 		return $this->is_connected;
 	}
 
 	public function getCacheInstance() {
 		if (self::$cache == null) {
 			global $config;
 
 			self::$cache = new MCMonitor_Cache($config['folder_name'], $config['keep_files'], $config['time_update_cache']);
 		}
 
 		return self::$cache;
 	}
 
 	public function getImageInstance() {
 		if (self::$image == null) {
 			self::$image = new MCMonitor_Image();
 		}
 
 		return self::$image;
 	}
 
 	function send_raw() {
 		return $this->getImageInstance()->send_raw();
 	}
 }
 
 
 class MCMonitor_Cache extends MCMonitor {
 
 	protected $folder_name;
 	protected $time_update_cache;
 
-	protected $file_list;
+	protected $file_list = array();
 	protected $keep_files;
 
 	protected $new_cache_time;
 	protected $old_cache_time;
 
 	public function __construct($folder_name = 'cache', $keep_files = 30, $time_update_cache = 60) {
 		$this->folder_name = $folder_name;
 		$this->keep_files = $keep_files;
 		$this->time_update_cache = $time_update_cache;
 		$this->fetch_fileList();
 	}
 
 	public function setFolderName($folder_name = 'cache') {
 		$this->folder_name = $folder_name;
 
 		return $this;
 	}
 
 	public function setFileList($list) {
 		$this->file_list = $list;
 
 		return $this;
 	}
 
 	public function getFileList() {
 		return $this->file_list;
 	}
 
 	public function getFileListCount() {
 		return count($this->file_list);
 	}
 
 	public function getFileType() {
 		return parent::getInstance()->getFileType();
 	}
 
 	public function getNewCacheTime() {
 		if ($this->new_cache_time == null)
 			$this->fetch_fileList();
 
 		return $this->new_cache_time;
 	}
 
 	public function getOldCacheTime() {
 		if ($this->old_cache_time == null)
 			$this->fetch_fileList();
 
 		return $this->old_cache_time;
 	}
 
 	public function fetch_fileList() {
 		$folder = $this->getFolder();
 
 		if (!file_exists($folder))
 			mkdir($folder);
 
 		$this->new_cache_time = time();
-		$this->setFileList(glob('./' . $folder . '/*.' . $this->getFileType())); # get all image files in $folder_name
+		$file_list = glob('./' . $folder . '/*.' . $this->getFileType());
 		if ((!is_array($file_list)) && ($file_list == false)) {
 			$file_list = array();
 		}
 		$this->setFileList($file_list); # get and set all image files in $folder_name
-		if ($this->getFileListCount() > 0)
+
-			$this->old_cache_time = str_replace('.' . $this->getFileType(), '', str_replace('./' . $folder . '/', '', $this->getFileList()[0])); # get the oldest cache file time from filename
+
-		else
+
 
 		if ($this->getFileListCount() > 0) {
 			$file_list = $this->getFileList();
 			$this->old_cache_time = str_replace('.' . $this->getFileType(), '', str_replace('./' . $folder . '/', '', $file_list[0])); # get the oldest cache file time from filename
 		} else {
 			$this->old_cache_time = $this->new_cache_time;
 		}
 
 		return $this;
 	}
 
 	public function getFolderName() {
 		return $this->folder_name;
 	}
 
 	public function getFolder() {
 		return escapeshellcmd($this->folder_name);
 	}
 
 	public function setTimeUpdateCache($time = 60) {
 		$this->time_update_cache = $time;
 
 		return $this;
 	}
 
 	public function getTimeUpdateCache() {
 		return $this->time_update_cache;
 	}
 
 	public function setKeepFilesCount($file_count = 30) {
 		$this->keep_files = $file_count;
 
 		return $this;
 	}
 
 	public function getKeepFilesCount() {
 		return $this->keep_files;
 	}
 
 	public function clear_cache() {
 		foreach ($this->getFileList() as $file) {
 			unlink($file);
 		}
 
 		return $this;
 	}
 }
 
 class MCMonitor_Image extends MCMonitor {
 
 	protected $x_start = 0;
 	protected $y_start = 0;
 	protected $y_end = 20;
 	protected $height = 20;
 	protected $width = 200;
 
 	protected $img;
 	protected $image_path = '';
 
 	public function __construct($img = NULL) {
 		$this->img = $img;
 	}
 
 	public function getOfflineMessage() {
 		return parent::getInstance()->getOfflineMessage();
 	}
 
 	public function getOnlineCount() {
 		return parent::getInstance()->getOnlineCount();
 	}
 
 	public function getMaxOnlineCount() {
 		return parent::getInstance()->getMaxOnlineCount();
 	}
 
 	public function setMaxOnlineCount($num = 0) {
 		parent::getInstance()->setMaxOnlineCount($num);
 
 		return $this;
 	}
 
 	public function setOnlineCount($num = 0) {
 		parent::getInstance()->setOnlineCount($num);
 
 		return $this;
 	}
 
 	public function getImageRess() {
 		return $this->img;
 	}
 
 	public function getData($refresh = false) {
 		return parent::getInstance()->getData();
 	}
 
 	public function get_path() {
 		return $this->image_path;
 	}
 
 	public function set_path($path) {
 		$this->image_path = escapeshellcmd($path);
 
 		return $this;
 	}
 
 	public function store() {
 		switch ($this->getFileType()) {
 			case 'jpg':
 				imagejpeg($this->img, $this->image_path, 0);
 				break;
 			case 'gif':
 				imagegif($this->img, $this->image_path, 0);
 				break;
 			default:
 				imagepng($this->img, $this->image_path, 0);
 				break;
 		}
 
 		return $this;
 	}
 
 	public function create() {
 		$this->img = imagecreatetruecolor($this->width, $this->height);
 
 		return $this;
 	}
 
 	public function open() {
 		switch ($this->getFileType()) {
 			case 'jpg':
 				$this->img = imagecreatefromjpeg($this->get_path());
 			case 'gif':
 				$this->img = imagecreatefromgif($this->get_path());
 		}
 
 		$this->img = imagecreatefrompng($this->get_path());
 
 		return $this;
 	}
 
 	public function send_raw() {
 		switch ($this->getFileType()) {
 			case 'jpg':
 				return imagejpeg($this->getImageRess());
 			case 'gif':
 				return imagegif($this->getImageRess());
 		}
 
 		return imagepng($this->getImageRess());
 	}
 
 	public function free_mem() {
 		if ($this->img != null)
 			imagedestroy($this->img);
 
 		return $this;
 	}
 
 	public function generate() {
 		$d = imagecolorexact($this->img ,0, 0, 0 );
 		$online_data = $this->getData();
 
 		// if we get the offline message here we got no answer from the server
 		if (is_string($online_data)) {
 			imagefill($this->img, 0, 0, ($blue = imagecolorallocate($this->img, 255, 0, 0)));
 			imagestring($this->img, 5, 70, 2, $this->getOfflineMessage(), $d);
 			return $this;
 		}
 
 		$this->setMaxOnlineCount(end($online_data));
 		$this->setOnlineCount(prev($online_data));
 
 		reset($online_data);
 
 		$this->x_end = $this->getOnlineCount() * ($this->width / $this->getMaxOnlineCount());
 		imagefill($this->img, 0, 0, imagecolorallocate($this->img, 230, 220, 230));
 		$s=0; # saturation (increase red and blue)
 		$red = imagecolorallocate($this->img, 200-$s, 255, 150-$s); # allocate the imagecolor
 
 		// set pixels for y and x
 		for ($i = $this->y_start; $i < $this->y_end; $i++){ // y
 			for ($j = $this->x_start; $j < $this->x_end; $j++){ // x
 				imagesetpixel($this->img, $j, $i, $red);
 				$red = imagecolorallocate($this->img, 180-$s, 255, 150-$s);
 				$s = $s + 0.03;
 			}
 		}
 
 		imagestring($this->img, 5, 80, 2, $this->getOnlineCount() . '/' . $this->getMaxOnlineCount(), $d);
 
 		return $this;
 	}
 }
 
 $monitor = new MCMonitor($config['host'], $config['port'], $config['offline_message'], $config['file_type']);
-if (count($cache->getFileList()) > 0) {
+
 $image = $monitor->getImageInstance();
 
 if (!($config['debug']))
 	header("Content-type: image/" . $cache->getFileType());
 
 if ($cache->getFileListCount() > 0) {
 	if ($cache->getNewCacheTime() - $cache->getOldCacheTime() >= $cache->getTimeUpdateCache()) {
 		if ($config['debug'])
 			echo "update cache\n";
 
 		$image->create()->generate()->set_path('./' . $cache->getFolder() . '/' . $cache->getNewCacheTime() . '.' . $cache->getFileType())->store();
 		$image->send_raw();
 		$image->free_mem();
 
 		// unlink old file after the new one has been created
 		unlink('./' . $cache->getFolder() . '/' . $cache->getOldCacheTime() . '.' . $cache->getFileType());
 	} else {
 		if ($config['debug'])
 			echo "load image from cache\n";
 
 		$image->set_path('./' . $cache->getFolderName() . '/' . $cache->getOldCacheTime() . '.' . $cache->getFileType())->open()->send_raw();
 		$image->free_mem();
 	}
 } else {
 	if ($config['debug'])
 		echo "empty cache, create image\n";
 
 	$image->create()->generate()->set_path('./' . $cache->getFolder() . '/' . $cache->getNewCacheTime() . '.' . $cache->getFileType())->store();
 	$image->send_raw();
 	$image->free_mem();
 }
 ?>