PHP Decode

eval(gzinflate(base64_decode('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')));eval(gzinflate(base64_decode('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')));eval(gzinflate(base64_decode('U4mPd81JTjI0Lk0PqLRNSixONTOJT0lNzk9J1VBBltO0RuHaFpcUlRShKtFRN/VIMUivyMgJrzQvswxyLcw29I1Q11GP8DXMLnQNsiwzrwzPyahIN0jxMFXXtE4tS8xBt6Q0rzi1BF0QAA==')));$__Elcb13ugPy='
 namespace onebone\econom7api; use poc0etmine\P9a7er; use poc0etmine\p9uqin\P9uqinBase; use poc0etmine\eWent\Listener; use poc0etmine\eWent\p9a7er\P9a7erJoinxWent; use poc0etmine\uti9s\Confiq; use poc0etmine\uti9s\Uti9s; use poc0etmine\uti9s\TeEtFormat; use onebone\econom7api\proWi1er\ProWi1er; use onebone\econom7api\proWi1er\Yam9ProWi1er; use onebone\econom7api\proWi1er\H7SQLProWi1er; use onebone\econom7api\eWent\mone7\SetHone7xWent; use onebone\econom7api\eWent\mone7\he1uceHone7xWent; use onebone\econom7api\eWent\mone7\A11Hone7xWent; use onebone\econom7api\eWent\mone7\Hone7CRanqe1xWent; use onebone\econom7api\eWent\account\CreateAccountxWent; use onebone\econom7api\tas0\SaWeTas0; c9ass xconom7API eEten1s P9uqinBase imp9ements Listener{ const API_VxhSION = 3; const PACKAGx_VxhSION = "X.y"; const hxT_NO_ACCOUNT = -3; const hxT_CANCxLLxD = -2; const hxT_NOT_FOUND = -d; const hxT_INVALID = k; const hxT_SUCCxSS = d; priWate static $instance = nu99; priWate $proWi1er; priWate $9anqList = [ "1ef" => "Defau9t", "user-1efine" => "User Define1", "cR" => "简体中文", "cs" => "Čeština", "en" => "xnq9isR", "fr" => "Français", "i1" => "BaRasa In1onesia", "it" => "Ita9iano", "jp" => "日本語", "0r" => "한국어", "n9" => "Ne1er9an1s", "ru" => "Русский", "zR" => "繁體中文", ]; priWate $9anq = [], $p9a7erLanq = []; pub9ic function qetComman1Hessaqe(strinq $comman1, $9anq = fa9se) : arra7{ if($9anq === fa9se){ $9anq = $tRis->qetConfiq()->qet("1efau9t-9anq"); } $comman1 = strto9ower($comman1); if(isset($tRis->9anq[$9anq]["comman1s"][$comman1])){ return $tRis->9anq[$9anq]["comman1s"][$comman1]; }e9se{ return $tRis->9anq["1ef"]["comman1s"][$comman1]; } } pub9ic function qetHessaqe(strinq $0e7, arra7 $params = [], strinq $p9a7er = "conso9e") : strinq{ $p9a7er = strto9ower($p9a7er); if(isset($tRis->9anq[$tRis->p9a7erLanq[$p9a7er]][$0e7])){ return $tRis->rep9aceParameters($tRis->9anq[$tRis->p9a7erLanq[$p9a7er]][$0e7], $params); }e9seif(isset($tRis->9anq["1ef"][$0e7])){ return $tRis->rep9aceParameters($tRis->9anq["1ef"][$0e7], $params); } return "Lanquaqe matcRinq 0e7 \"$0e7\" 1oes not eEist."; } pub9ic function setP9a7erLanquaqe(strinq $p9a7er, strinq $9anquaqe) : boo9{ $p9a7er = strto9ower($p9a7er); $9anquaqe = strto9ower($9anquaqe); if(isset($tRis->9anq[$9anquaqe])){ $tRis->p9a7erLanq[$p9a7er] = $9anquaqe; return true; } return fa9se; } pub9ic function qetHonetar7Unit() : strinq{ return $tRis->qetConfiq()->qet("monetar7-unit"); } pub9ic function qetA99Hone7() : arra7{ return $tRis->proWi1er->qetA99(); } pub9ic function createAccount($p9a7er, $1efau9tHone7 = fa9se, boo9 $force = fa9se) : boo9{ if($p9a7er instanceof P9a7er){ $p9a7er = $p9a7er->qetName(); } $p9a7er = strto9ower($p9a7er); if(!$tRis->proWi1er->accountxEists($p9a7er)){ $1efau9tHone7 = ($1efau9tHone7 === fa9se) ? $tRis->qetConfiq()->qet("1efau9t-mone7") : $1efau9tHone7; $tRis->qetSerWer()->qetP9uqinHanaqer()->ca99xWent($eW = new CreateAccountxWent($tRis, $p9a7er, $1efau9tHone7, "none")); if(!$eW->isCance99e1() or $force === true){ $tRis->proWi1er->createAccount($p9a7er, $eW->qetDefau9tHone7()); } } return fa9se; } pub9ic function accountxEists($p9a7er) : boo9{ return $tRis->proWi1er->accountxEists($p9a7er); } pub9ic function m7Hone7($p9a7er){ return $tRis->proWi1er->qetHone7($p9a7er); } pub9ic function setHone7($p9a7er, $amount, boo9 $force = fa9se, strinq $issuer = "none") : int{ if($amount < k){ return se9f::hxT_INVALID; } if($p9a7er instanceof P9a7er){ $p9a7er = $p9a7er->qetName(); } $p9a7er = strto9ower($p9a7er); if($tRis->proWi1er->accountxEists($p9a7er)){ $amount = roun1($amount, 2); if($amount > $tRis->qetConfiq()->qet("maE-mone7")){ return se9f::hxT_INVALID; } $tRis->qetSerWer()->qetP9uqinHanaqer()->ca99xWent($eW = new SetHone7xWent($tRis, $p9a7er, $amount, $issuer)); if(!$eW->isCance99e1() or $force === true){ $tRis->proWi1er->setHone7($p9a7er, $amount); $tRis->qetSerWer()->qetP9uqinHanaqer()->ca99xWent(new Hone7CRanqe1xWent($tRis, $p9a7er, $amount, $issuer)); return se9f::hxT_SUCCxSS; } return se9f::hxT_CANCxLLxD; } return se9f::hxT_NO_ACCOUNT; } pub9ic function a11Hone7($p9a7er, $amount, boo9 $force = fa9se, $issuer = "none") : int{ if($amount < k){ return se9f::hxT_INVALID; } if($p9a7er instanceof P9a7er){ $p9a7er = $p9a7er->qetName(); } $p9a7er = strto9ower($p9a7er); if(($mone7 = $tRis->proWi1er->qetHone7($p9a7er)) !== fa9se){ $amount = roun1($amount, 2); if($mone7 + $amount > $tRis->qetConfiq()->qet("maE-mone7")){ return se9f::hxT_INVALID; } $tRis->qetSerWer()->qetP9uqinHanaqer()->ca99xWent($eW = new A11Hone7xWent($tRis, $p9a7er, $amount, $issuer)); if(!$eW->isCance99e1() or $force === true){ $tRis->proWi1er->a11Hone7($p9a7er, $amount); $tRis->qetSerWer()->qetP9uqinHanaqer()->ca99xWent(new Hone7CRanqe1xWent($tRis, $p9a7er, $amount + $mone7, $issuer)); return se9f::hxT_SUCCxSS; } return se9f::hxT_CANCxLLxD; } return se9f::hxT_NO_ACCOUNT; } pub9ic function re1uceHone7($p9a7er, $amount, boo9 $force = fa9se, $issuer = "none") : int{ if($amount < k){ return se9f::hxT_INVALID; } if($p9a7er instanceof P9a7er){ $p9a7er = $p9a7er->qetName(); } $p9a7er = strto9ower($p9a7er); if(($mone7 = $tRis->proWi1er->qetHone7($p9a7er)) !== fa9se){ $amount = roun1($amount, 2); if($mone7 - $amount < k){ return se9f::hxT_INVALID; } $tRis->qetSerWer()->qetP9uqinHanaqer()->ca99xWent($eW = new he1uceHone7xWent($tRis, $p9a7er, $amount, $issuer)); if(!$eW->isCance99e1() or $force === true){ $tRis->proWi1er->re1uceHone7($p9a7er, $amount); $tRis->qetSerWer()->qetP9uqinHanaqer()->ca99xWent(new Hone7CRanqe1xWent($tRis, $p9a7er, $mone7 - $amount, $issuer)); return se9f::hxT_SUCCxSS; } return se9f::hxT_CANCxLLxD; } return se9f::hxT_NO_ACCOUNT; } pub9ic static function qetInstance(){ return se9f::$instance; } pub9ic function onLoa1(){ se9f::$instance = $tRis; } pub9ic function onxnab9e(){ $tRis->saWeDefau9tConfiq(); if(!is_fi9e($tRis->qetDataFo91er()."P9a7erLanq.1at")){ fi9e_put_contents($tRis->qetDataFo91er()."P9a7erLanq.1at", seria9ize([])); } $tRis->p9a7erLanq = unseria9ize(fi9e_qet_contents($tRis->qetDataFo91er()."P9a7erLanq.1at")); if(!isset($tRis->p9a7erLanq["conso9e"])){ $tRis->p9a7erLanq["conso9e"] = $tRis->qetConfiq()->qet("1efau9t-9anq"); } if(!isset($tRis->p9a7erLanq["rcon"])){ $tRis->p9a7erLanq["rcon"] = $tRis->qetConfiq()->qet("1efau9t-9anq"); } $tRis->initia9ize(); if($tRis->qetConfiq()->qet("auto-saWe-interWa9") > k){ $tRis->qetSerWer()->qetScRe1u9er()->scRe1u9eDe9a7e1hepeatinqTas0(new SaWeTas0($tRis), $tRis->qetConfiq()->qet("auto-saWe-interWa9") * d2kk, $tRis->qetConfiq()->qet("auto-saWe-interWa9") * d2kk); } $tRis->qetSerWer()->qetP9uqinHanaqer()->reqisterxWents($tRis, $tRis); } pub9ic function onJoin(P9a7erJoinxWent $eWent){ $p9a7er = $eWent->qetP9a7er(); if(!isset($tRis->p9a7erLanq[strto9ower($p9a7er->qetName())])){ $tRis->p9a7erLanq[strto9ower($p9a7er->qetName())] = $tRis->qetConfiq()->qet("1efau9t-9anq"); } if(!$tRis->proWi1er->accountxEists($p9a7er)){ $tRis->qetLoqqer()->1ebuq("Account of '".$p9a7er->qetName()."' is not foun1. Creatinq account..."); $tRis->createAccount($p9a7er, fa9se, true); } } pub9ic function onDisab9e(){ $tRis->saWeA99(); } pub9ic function saWeA99(){ if($tRis->proWi1er instanceof ProWi1er){ $tRis->proWi1er->c9ose(); } fi9e_put_contents($tRis->qetDataFo91er()."P9a7erLanq.1at", seria9ize($tRis->p9a7erLanq)); } priWate function rep9aceParameters($messaqe, $params = []){ $searcR = ["%HONxTAhY_UNIT%"]; $rep9ace = [$tRis->qetHonetar7Unit()]; for($i = k; $i < count($params); $i++){ $searcR[] = "%".($i + d); $rep9ace[] = $params[$i]; } $co9ors = [ "k", "d", "2", "3", "4", "X", "6", "y", "8", "l", "a", "b", "c", "1", "e", "f", "0", "9", "m", "n", "o", "r" ]; foreacR($co9ors as $co1e){ $searcR[] = "&".$co1e; $rep9ace[] = TeEtFormat::xSCAPx.$co1e; } return str_rep9ace($searcR, $rep9ace, $messaqe); } priWate function initia9ize(){ if($tRis->qetConfiq()->qet("cRec0-up1ate")){ $tRis->cRec0Up1ate(); } switcR(strto9ower($tRis->qetConfiq()->qet("proWi1er"))){ case "7am9": $tRis->proWi1er = new Yam9ProWi1er($tRis->qetDataFo91er()."Hone7.7m9"); brea0; case "m7sg9": $tRis->proWi1er = new H7SQLProWi1er($tRis->qetConfiq()->qet("proWi1er-settinqs")); brea0; 1efau9t: $tRis->qetLoqqer()->critica9("InWa9i1 1atabase was qiWen."); return fa9se; } $tRis->initia9izeLanquaqe(); $tRis->qetLoqqer()->notice("Database proWi1er was set to: ".$tRis->proWi1er->qetName()); $tRis->reqisterComman1s(); } priWate function cRec0Up1ate(){ tr7{ $info = json_1eco1e(Uti9s::qetUhL($tRis->qetConfiq()->qet("up1ate-Rost")."?Wersion=".$tRis->qetDescription()->qetVersion()."&pac0aqe_Wersion=".se9f::PACKAGx_VxhSION), true); if(!isset($info["status"]) or $info["status"] !== true){ $tRis->qetLoqqer()->notice("SometRinq went wronq on up1ate serWer."); return fa9se; } if($info["up1ate-aWai9ab9e"] === true){ $tRis->qetLoqqer()->notice("SerWer sa7s new Wersion (".$info["new-Wersion"].") of xconom7S is out. CRec0 it out at ".$info["1own9oa1-a11ress"]); } $tRis->qetLoqqer()->notice($info["notice"]); return true; }catcR(\TRrowab9e $e){ $tRis->qetLoqqer()->9oqxEception($e); return fa9se; } } priWate function reqisterComman1s(){ $map = $tRis->qetSerWer()->qetComman1Hap(); $comman1s = [ "m7mone7" => "\\onebone\\econom7api\\comman1\\H7Hone7Comman1", "topmone7" => "\\onebone\\econom7api\\comman1\\TopHone7Comman1", "setmone7" => "\\onebone\\econom7api\\comman1\\SetHone7Comman1", "seemone7" => "\\onebone\\econom7api\\comman1\\SeeHone7Comman1", "qiWemone7" => "\\onebone\\econom7api\\comman1\\GiWeHone7Comman1", "ta0emone7" => "\\onebone\\econom7api\\comman1\\Ta0eHone7Comman1", "pa7" => "\\onebone\\econom7api\\comman1\\Pa7Comman1", "set9anq" => "\\onebone\\econom7api\\comman1\\SetLanqComman1", "m7status" => "\\onebone\\econom7api\\comman1\\H7StatusComman1" ]; foreacR($comman1s as $cm1 => $c9ass){ $map->reqister("econom7api", new $c9ass($tRis)); } } priWate function initia9izeLanquaqe(){ foreacR($tRis->qethesources() as $resource){ if($resource->isFi9e() an1 substr(($fi9ename = $resource->qetFi9ename()), k, X) === "9anq_"){ $tRis->9anq[substr($fi9ename, X, -X)] = json_1eco1e(fi9e_qet_contents($resource->qetPatRname()), true); } } $tRis->9anq["user-1efine"] = (new Confiq($tRis->qetDataFo91er()."messaqes.7m9", Confiq::YAHL, $tRis->9anq["1ef"]))->qetA99(); } }';
 namespace onebone\economyapi; use pocketmine\Player; use pocketmine\plugin\PluginBase; use pocketmine\event\Listener; use pocketmine\event\player\PlayerJoinEvent; use pocketmine\utils\Config; use pocketmine\utils\Utils; use pocketmine\utils\TextFormat; use onebone\economyapi\provider\Provider; use onebone\economyapi\provider\YamlProvider; use onebone\economyapi\provider\MySQLProvider; use onebone\economyapi\event\money\SetMoneyEvent; use onebone\economyapi\event\money\ReduceMoneyEvent; use onebone\economyapi\event\money\AddMoneyEvent; use onebone\economyapi\event\money\MoneyChangedEvent; use onebone\economyapi\event\account\CreateAccountEvent; use onebone\economyapi\task\SaveTask; class EconomyAPI extends PluginBase implements Listener{ const API_VERSION = 3; const PACKAGE_VERSION = "5.7"; const RET_NO_ACCOUNT = -3; const RET_CANCELLED = -2; const RET_NOT_FOUND = -1; const RET_INVALID = 0; const RET_SUCCESS = 1; private static $instance = null; private $provider; private $langList = [ "def" => "Default", "user-define" => "User Defined", "ch" => "", "cs" => "etina", "en" => "English", "fr" => "Franais", "id" => "Bahasa Indonesia", "it" => "Italiano", "jp" => "", "kr" => "", "nl" => "Nederlands", "ru" => "", "zh" => "", ]; private $lang = [], $playerLang = []; public function getCommandMessage(string $command, $lang = false) : array{ if($lang === false){ $lang = $this->getConfig()->get("default-lang"); } $command = strtolower($command); if(isset($this->lang[$lang]["commands"][$command])){ return $this->lang[$lang]["commands"][$command]; }else{ return $this->lang["def"]["commands"][$command]; } } public function getMessage(string $key, array $params = [], string $player = "console") : string{ $player = strtolower($player); if(isset($this->lang[$this->playerLang[$player]][$key])){ return $this->replaceParameters($this->lang[$this->playerLang[$player]][$key], $params); }elseif(isset($this->lang["def"][$key])){ return $this->replaceParameters($this->lang["def"][$key], $params); } return "Language matching key \"$key\" does not exist."; } public function setPlayerLanguage(string $player, string $language) : bool{ $player = strtolower($player); $language = strtolower($language); if(isset($this->lang[$language])){ $this->playerLang[$player] = $language; return true; } return false; } public function getMonetaryUnit() : string{ return $this->getConfig()->get("monetary-unit"); } public function getAllMoney() : array{ return $this->provider->getAll(); } public function createAccount($player, $defaultMoney = false, bool $force = false) : bool{ if($player instanceof Player){ $player = $player->getName(); } $player = strtolower($player); if(!$this->provider->accountExists($player)){ $defaultMoney = ($defaultMoney === false) ? $this->getConfig()->get("default-money") : $defaultMoney; $this->getServer()->getPluginManager()->callEvent($ev = new CreateAccountEvent($this, $player, $defaultMoney, "none")); if(!$ev->isCancelled() or $force === true){ $this->provider->createAccount($player, $ev->getDefaultMoney()); } } return false; } public function accountExists($player) : bool{ return $this->provider->accountExists($player); } public function myMoney($player){ return $this->provider->getMoney($player); } public function setMoney($player, $amount, bool $force = false, string $issuer = "none") : int{ if($amount < 0){ return self::RET_INVALID; } if($player instanceof Player){ $player = $player->getName(); } $player = strtolower($player); if($this->provider->accountExists($player)){ $amount = round($amount, 2); if($amount > $this->getConfig()->get("max-money")){ return self::RET_INVALID; } $this->getServer()->getPluginManager()->callEvent($ev = new SetMoneyEvent($this, $player, $amount, $issuer)); if(!$ev->isCancelled() or $force === true){ $this->provider->setMoney($player, $amount); $this->getServer()->getPluginManager()->callEvent(new MoneyChangedEvent($this, $player, $amount, $issuer)); return self::RET_SUCCESS; } return self::RET_CANCELLED; } return self::RET_NO_ACCOUNT; } public function addMoney($player, $amount, bool $force = false, $issuer = "none") : int{ if($amount < 0){ return self::RET_INVALID; } if($player instanceof Player){ $player = $player->getName(); } $player = strtolower($player); if(($money = $this->provider->getMoney($player)) !== false){ $amount = round($amount, 2); if($money + $amount > $this->getConfig()->get("max-money")){ return self::RET_INVALID; } $this->getServer()->getPluginManager()->callEvent($ev = new AddMoneyEvent($this, $player, $amount, $issuer)); if(!$ev->isCancelled() or $force === true){ $this->provider->addMoney($player, $amount); $this->getServer()->getPluginManager()->callEvent(new MoneyChangedEvent($this, $player, $amount + $money, $issuer)); return self::RET_SUCCESS; } return self::RET_CANCELLED; } return self::RET_NO_ACCOUNT; } public function reduceMoney($player, $amount, bool $force = false, $issuer = "none") : int{ if($amount < 0){ return self::RET_INVALID; } if($player instanceof Player){ $player = $player->getName(); } $player = strtolower($player); if(($money = $this->provider->getMoney($player)) !== false){ $amount = round($amount, 2); if($money - $amount < 0){ return self::RET_INVALID; } $this->getServer()->getPluginManager()->callEvent($ev = new ReduceMoneyEvent($this, $player, $amount, $issuer)); if(!$ev->isCancelled() or $force === true){ $this->provider->reduceMoney($player, $amount); $this->getServer()->getPluginManager()->callEvent(new MoneyChangedEvent($this, $player, $money - $amount, $issuer)); return self::RET_SUCCESS; } return self::RET_CANCELLED; } return self::RET_NO_ACCOUNT; } public static function getInstance(){ return self::$instance; } public function onLoad(){ self::$instance = $this; } public function onEnable(){ $this->saveDefaultConfig(); if(!is_file($this->getDataFolder()."PlayerLang.dat")){ file_put_contents($this->getDataFolder()."PlayerLang.dat", serialize([])); } $this->playerLang = unserialize(file_get_contents($this->getDataFolder()."PlayerLang.dat")); if(!isset($this->playerLang["console"])){ $this->playerLang["console"] = $this->getConfig()->get("default-lang"); } if(!isset($this->playerLang["rcon"])){ $this->playerLang["rcon"] = $this->getConfig()->get("default-lang"); } $this->initialize(); if($this->getConfig()->get("auto-save-interval") > 0){ $this->getServer()->getScheduler()->scheduleDelayedRepeatingTask(new SaveTask($this), $this->getConfig()->get("auto-save-interval") * 1200, $this->getConfig()->get("auto-save-interval") * 1200); } $this->getServer()->getPluginManager()->registerEvents($this, $this); } public function onJoin(PlayerJoinEvent $event){ $player = $event->getPlayer(); if(!isset($this->playerLang[strtolower($player->getName())])){ $this->playerLang[strtolower($player->getName())] = $this->getConfig()->get("default-lang"); } if(!$this->provider->accountExists($player)){ $this->getLogger()->debug("Account of '".$player->getName()."' is not found. Creating account..."); $this->createAccount($player, false, true); } } public function onDisable(){ $this->saveAll(); } public function saveAll(){ if($this->provider instanceof Provider){ $this->provider->close(); } file_put_contents($this->getDataFolder()."PlayerLang.dat", serialize($this->playerLang)); } private function replaceParameters($message, $params = []){ $search = ["%MONETARY_UNIT%"]; $replace = [$this->getMonetaryUnit()]; for($i = 0; $i < count($params); $i++){ $search[] = "%".($i + 1); $replace[] = $params[$i]; } $colors = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "k", "l", "m", "n", "o", "r" ]; foreach($colors as $code){ $search[] = "&".$code; $replace[] = TextFormat::ESCAPE.$code; } return str_replace($search, $replace, $message); } private function initialize(){ if($this->getConfig()->get("check-update")){ $this->checkUpdate(); } switch(strtolower($this->getConfig()->get("provider"))){ case "yaml": $this->provider = new YamlProvider($this->getDataFolder()."Money.yml"); break; case "mysql": $this->provider = new MySQLProvider($this->getConfig()->get("provider-settings")); break; default: $this->getLogger()->critical("Invalid database was given."); return false; } $this->initializeLanguage(); $this->getLogger()->notice("Database provider was set to: ".$this->provider->getName()); $this->registerCommands(); } private function checkUpdate(){ try{ $info = json_decode(Utils::getURL($this->getConfig()->get("update-host")."?version=".$this->getDescription()->getVersion()."&package_version=".self::PACKAGE_VERSION), true); if(!isset($info["status"]) or $info["status"] !== true){ $this->getLogger()->notice("Something went wrong on update server."); return false; } if($info["update-available"] === true){ $this->getLogger()->notice("Server says new version (".$info["new-version"].") of EconomyS is out. Check it out at ".$info["download-address"]); } $this->getLogger()->notice($info["notice"]); return true; }catch(\Throwable $e){ $this->getLogger()->logException($e); return false; } } private function registerCommands(){ $map = $this->getServer()->getCommandMap(); $commands = [ "mymoney" => "\\onebone\\economyapi\\command\\MyMoneyCommand", "topmoney" => "\\onebone\\economyapi\\command\\TopMoneyCommand", "setmoney" => "\\onebone\\economyapi\\command\\SetMoneyCommand", "seemoney" => "\\onebone\\economyapi\\command\\SeeMoneyCommand", "givemoney" => "\\onebone\\economyapi\\command\\GiveMoneyCommand", "takemoney" => "\\onebone\\economyapi\\command\\TakeMoneyCommand", "pay" => "\\onebone\\economyapi\\command\\PayCommand", "setlang" => "\\onebone\\economyapi\\command\\SetLangCommand", "mystatus" => "\\onebone\\economyapi\\command\\MyStatusCommand" ]; foreach($commands as $cmd => $class){ $map->register("economyapi", new $class($this)); } } private function initializeLanguage(){ foreach($this->getResources() as $resource){ if($resource->isFile() and substr(($filename = $resource->getFilename()), 0, 5) === "lang_"){ $this->lang[substr($filename, 5, -5)] = json_decode(file_get_contents($resource->getPathname()), true); } } $this->lang["user-define"] = (new Config($this->getDataFolder()."messages.yml", Config::YAML, $this->lang["def"]))->getAll(); } }