PluginBase.php

<?php
 
/*
 *
 *  ____            _        _   __  __ _                  __  __ ____
 * |  _ \ ___   ___| | _____| |_|  \/  (_)_ __   ___      |  \/  |  _ \
 * | |_) / _ \ / __| |/ / _ \ __| |\/| | | '_ \ / _ \_____| |\/| | |_) |
 * |  __/ (_) | (__|   <  __/ |_| |  | | | | | |  __/_____| |  | |  __/
 * |_|   \___/ \___|_|\_\___|\__|_|  |_|_|_| |_|\___|     |_|  |_|_|
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * @author PocketMine Team
 * @link http://www.pocketmine.net/
 *
 *
 */
 
declare(strict_types=1);
 
namespace pocketmine\plugin;
 
use pocketmine\command\Command;
use pocketmine\command\CommandExecutor;
use pocketmine\command\CommandSender;
use pocketmine\command\PluginCommand;
use pocketmine\lang\KnownTranslationFactory;
use pocketmine\scheduler\TaskScheduler;
use pocketmine\Server;
use pocketmine\utils\Config;
use pocketmine\utils\Utils;
use Symfony\Component\Filesystem\Path;
use function copy;
use function count;
use function dirname;
use function file_exists;
use function fopen;
use function is_dir;
use function mkdir;
use function rtrim;
use function str_contains;
use function str_replace;
use function strlen;
use function strtolower;
use function substr;
use function trim;
use const DIRECTORY_SEPARATOR;
 
abstract class PluginBase implements Plugin, CommandExecutor{
    private bool $isEnabled = false;
 
    private ?Config $config = null;
    private string $configFile;
 
    private PluginLogger $logger;
    private TaskScheduler $scheduler;
 
    public function __construct(
        private Server $server,
        private PluginDescription $description,
        private string $dataFolder,
        private string $file,
        private string $resourceFolder,
    ){
        $this->dataFolder = rtrim($dataFolder, "/" . DIRECTORY_SEPARATOR) . "/";
        $this->file = rtrim($file, "/" . DIRECTORY_SEPARATOR) . "/";
        $this->resourceFolder = rtrim(str_replace(DIRECTORY_SEPARATOR, "/", $resourceFolder), "/") . "/";
 
        $this->configFile = Path::join($this->dataFolder, "config.yml");
 
        $prefix = $this->description->getPrefix();
        $this->logger = new PluginLogger($server->getLogger(), $prefix !== "" ? $prefix : $this->getName());
        $this->scheduler = new TaskScheduler($this->getFullName());
 
        $this->onLoad();
 
        $this->registerYamlCommands();
    }
 
    protected function onLoad() : void{
 
    }
 
    protected function onEnable() : void{
 
    }
 
    protected function onDisable() : void{
 
    }
 
    final public function isEnabled() : bool{
        return $this->isEnabled;
    }
 
    final public function onEnableStateChange(bool $enabled) : void{
        if($this->isEnabled !== $enabled){
            $this->isEnabled = $enabled;
            if($this->isEnabled){
                $this->onEnable();
            }else{
                $this->onDisable();
            }
        }
    }
 
    final public function isDisabled() : bool{
        return !$this->isEnabled;
    }
 
    final public function getDataFolder() : string{
        return $this->dataFolder;
    }
 
    final public function getDescription() : PluginDescription{
        return $this->description;
    }
 
    public function getLogger() : \AttachableLogger{
        return $this->logger;
    }
 
    private function registerYamlCommands() : void{
        $pluginCmds = [];
 
        foreach(Utils::stringifyKeys($this->description->getCommands()) as $key => $data){
            if(str_contains($key, ":")){
                $this->logger->error($this->server->getLanguage()->translate(KnownTranslationFactory::pocketmine_plugin_commandError($key, $this->description->getFullName(), ":")));
                continue;
            }
 
            $newCmd = new PluginCommand($key, $this, $this);
            if(($description = $data->getDescription()) !== null){
                $newCmd->setDescription($description);
            }
 
            if(($usageMessage = $data->getUsageMessage()) !== null){
                $newCmd->setUsage($usageMessage);
            }
 
            $aliasList = [];
            foreach($data->getAliases() as $alias){
                if(str_contains($alias, ":")){
                    $this->logger->error($this->server->getLanguage()->translate(KnownTranslationFactory::pocketmine_plugin_aliasError($alias, $this->description->getFullName(), ":")));
                    continue;
                }
                $aliasList[] = $alias;
            }
 
            $newCmd->setAliases($aliasList);
 
            $newCmd->setPermission($data->getPermission());
 
            if(($permissionDeniedMessage = $data->getPermissionDeniedMessage()) !== null){
                $newCmd->setPermissionMessage($permissionDeniedMessage);
            }
 
            $pluginCmds[] = $newCmd;
        }
 
        if(count($pluginCmds) > 0){
            $this->server->getCommandMap()->registerAll($this->description->getName(), $pluginCmds);
        }
    }
 
    public function getCommand(string $name){
        $command = $this->server->getPluginCommand($name);
        if($command === null || $command->getOwningPlugin() !== $this){
            $command = $this->server->getPluginCommand(strtolower($this->description->getName()) . ":" . $name);
        }
 
        if($command instanceof PluginOwned && $command->getOwningPlugin() === $this){
            return $command;
        }else{
            return null;
        }
    }
 
    public function onCommand(CommandSender $sender, Command $command, string $label, array $args) : bool{
        return false;
    }
 
    public function getResourceFolder() : string{
        return $this->resourceFolder;
    }
 
    public function getResourcePath(string $filename) : string{
        return Path::join($this->getResourceFolder(), $filename);
    }
 
    public function saveResource(string $filename, bool $replace = false) : bool{
        if(trim($filename) === ""){
            return false;
        }
 
        $source = Path::join($this->resourceFolder, $filename);
        if(!file_exists($source)){
            return false;
        }
 
        $destination = Path::join($this->dataFolder, $filename);
        if(file_exists($destination) && !$replace){
            return false;
        }
 
        if(!file_exists(dirname($destination))){
            mkdir(dirname($destination), 0755, true);
        }
 
        return copy($source, $destination);
    }
 
    public function getResources() : array{
        $resources = [];
        if(is_dir($this->resourceFolder)){
            foreach(new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($this->resourceFolder)) as $resource){
                if($resource->isFile()){
                    $path = str_replace(DIRECTORY_SEPARATOR, "/", substr((string) $resource, strlen($this->resourceFolder)));
                    $resources[$path] = $resource;
                }
            }
        }
 
        return $resources;
    }
 
    public function getConfig() : Config{
        if($this->config === null){
            $this->reloadConfig();
        }
 
        return $this->config;
    }
 
    public function saveConfig() : void{
        $this->getConfig()->save();
    }
 
    public function saveDefaultConfig() : bool{
        if(!file_exists($this->configFile)){
            return $this->saveResource("config.yml", false);
        }
        return false;
    }
 
    public function reloadConfig() : void{
        $this->saveDefaultConfig();
        $this->config = new Config($this->configFile);
    }
 
    final public function getServer() : Server{
        return $this->server;
    }
 
    final public function getName() : string{
        return $this->description->getName();
    }
 
    final public function getFullName() : string{
        return $this->description->getFullName();
    }
 
    public function getFile() : string{
        return $this->file;
    }
 
    public function getScheduler() : TaskScheduler{
        return $this->scheduler;
    }
}