├── virion.yml
├── .poggit.yml
├── src
    └── skh6075
    │   └── lib
    │       └── minigame
    │           ├── MiniGameHandler.php
    │           ├── team
    │               ├── MiniGameTeamManager.php
    │               └── MiniGameTeam.php
    │           ├── room
    │               ├── MiniGameRoomManager.php
    │               └── MiniGameRoom.php
    │           ├── MiniGameEventHandler.php
    │           ├── utils
    │               └── MiniGameRoomTrait.php
    │           └── inventory
    │               └── PlayerInventoryManager.php
├── LICENSE
└── README.md


/virion.yml:
--------------------------------------------------------------------------------
1 | name: libMiniGame
2 | antigen: skh6075\lib\minigame
3 | version: 1.0.0
4 | api: 3.0.0
5 | author: AvasKr
6 | php: 8.0


--------------------------------------------------------------------------------
/.poggit.yml:
--------------------------------------------------------------------------------
1 | --- # Poggit-CI Manifest. Open the CI at https://poggit.pmmp.io/ci/GodVas/MiniGameAPI
2 | build-by-default: true
3 | branches:
4 | - master
5 | projects:
6 |   MiniGameAPI:
7 |     path: MiniGameAPI/
8 | ...
9 | 


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/MiniGameHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame;
 6 | 
 7 | use InvalidArgumentException;
 8 | use pocketmine\plugin\Plugin;
 9 | 
10 | final class MiniGameHandler{
11 | 
12 | 	private static ?Plugin $registrant = null;
13 | 
14 | 	public static function isRegistered(): bool{
15 | 		return self::$registrant !== null;
16 | 	}
17 | 
18 | 	public static function getRegistrant(): ?Plugin{
19 | 		return self::$registrant;
20 | 	}
21 | 
22 | 	public static function register(Plugin $plugin): void{
23 | 		if(self::isRegistered()){
24 | 			throw new InvalidArgumentException("{$plugin->getName()} attempted to register " . self::class . " twice.");
25 | 		}
26 | 		self::$registrant = $plugin;
27 | 		self::$registrant->getServer()->getPluginManager()->registerEvents(new MiniGameEventHandler(), self::$registrant);
28 | 	}
29 | }


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/team/MiniGameTeamManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame\team;
 6 | 
 7 | final class MiniGameTeamManager{
 8 | 
 9 | 	/** @var MiniGameTeam[] */
10 | 	private static array $teams = [];
11 | 
12 | 	public function __construct(MiniGameTeam ...$teams){
13 | 		foreach($teams as $team){
14 | 			self::$teams[$team->getName()] = $team;
15 | 		}
16 | 	}
17 | 
18 | 	public function getTeams(): array{
19 | 		return self::$teams;
20 | 	}
21 | 
22 | 	public function addTeam(MiniGameTeam $team): void{
23 | 		if(isset(self::$teams[$team->getName()])){
24 | 			return;
25 | 		}
26 | 		self::$teams[$team->getName()] = $team;
27 | 	}
28 | 
29 | 	public function removeTeam(MiniGameTeam $team): void{
30 | 		if(!isset(self::$teams[$team->getName()])){
31 | 			return;
32 | 		}
33 | 		unset(self::$teams[$team->getName()]);
34 | 	}
35 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Song ki ho
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/team/MiniGameTeam.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame\team;
 6 | 
 7 | use JetBrains\PhpStorm\Pure;
 8 | use pocketmine\Player;
 9 | 
10 | class MiniGameTeam{
11 | 
12 | 	public function __construct(
13 | 		private string $name,
14 | 		private array $players = []
15 | 	){}
16 | 
17 | 	final public function getName(): string{
18 | 		return $this->name;
19 | 	}
20 | 
21 | 	final public function getPlayers(): array{
22 | 		return $this->players;
23 | 	}
24 | 
25 | 	#[Pure]
26 | 	final public function isJoinedPlayer(Player $player): bool{
27 | 		return isset($this->players[strtolower($player->getName())]);
28 | 	}
29 | 
30 | 	public function addPlayer(Player $player): bool{
31 | 		if(!isset($this->players[strtolower($player->getName())])){
32 | 			$this->players[strtolower($player->getName())] = time();
33 | 			return true;
34 | 		}
35 | 		return false;
36 | 	}
37 | 
38 | 	public function removePlayer($player): void{
39 | 		if($player instanceof Player){
40 | 			$player = $player->getName();
41 | 		}
42 | 		if(!isset($this->players[strtolower($player)])){
43 | 			return;
44 | 		}
45 | 		unset($this->players[strtolower($player)]);
46 | 	}
47 | 
48 | 	public function reset(): void{
49 | 		$this->players = [];
50 | 	}
51 | }


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/room/MiniGameRoomManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame\room;
 6 | 
 7 | use InvalidArgumentException;
 8 | use pocketmine\Player;
 9 | use pocketmine\utils\SingletonTrait;
10 | 
11 | final class MiniGameRoomManager{
12 | 	use SingletonTrait;
13 | 
14 | 	/** @var MiniGameRoom[] */
15 | 	private static array $rooms = [];
16 | 
17 | 	public function register(MiniGameRoom $room): void{
18 | 		if(isset(self::$rooms[$room->getName()])){
19 | 			throw new InvalidArgumentException("The game room named " . $room->getName() . " already exists.");
20 | 		}
21 | 		self::$rooms[$room->getName()] = $room;
22 | 	}
23 | 
24 | 	public function unregister(MiniGameRoom $room): void{
25 | 		if(!isset(self::$rooms[$room->getName()])){
26 | 			return;
27 | 		}
28 | 		unset(self::$rooms[$room->getName()]);
29 | 	}
30 | 
31 | 	public function get(string $name): ?MiniGameRoom{
32 | 		return self::$rooms[$name] ?? null;
33 | 	}
34 | 
35 | 	public function getAll(): array{
36 | 		return self::$rooms;
37 | 	}
38 | 
39 | 	/**
40 | 	 * @param Player $player
41 | 	 *
42 | 	 * @return MiniGameRoom[]
43 | 	 */
44 | 	public function getPlayerJoinedRooms(Player $player): array{
45 | 		return array_filter(array_map(static function(MiniGameRoom $room) use ($player){
46 | 			return $room->isJoinedPlayer($player) ? $room : null;
47 | 		}, self::$rooms));
48 | 	}
49 | }


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/room/MiniGameRoom.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame\room;
 6 | 
 7 | use pocketmine\plugin\Plugin;
 8 | use skh6075\lib\minigame\inventory\PlayerInventoryManager;
 9 | use skh6075\lib\minigame\team\MiniGameTeamManager;
10 | use skh6075\lib\minigame\utils\MiniGameRoomTrait;
11 | 
12 | class MiniGameRoom{
13 | 	use MiniGameRoomTrait;
14 | 
15 | 	public const GAMEMODE_DEFAULT = 0;
16 | 
17 | 	public function __construct(
18 | 		private string $name,
19 | 		private int $minPlayerCount,
20 | 		private int $maxPlayerCount,
21 | 		private Plugin $plugin,
22 | 		private int $gamemode = self::GAMEMODE_DEFAULT,
23 | 		private array $players = [],
24 | 		private ?MiniGameTeamManager $teamManager = null
25 | 	){}
26 | 
27 | 	public function onStartGame(): void{
28 | 	}
29 | 
30 | 	public function onEndGame(): void{
31 | 	}
32 | 
33 | 	public function unloadGameRoom(): void{
34 | 		$invManager = PlayerInventoryManager::getInstance();
35 | 		if(!mkdir("invData/") && !is_dir("invData/")){
36 | 			throw new \RuntimeException('Directory "invData/" was not created');
37 | 		}
38 | 
39 | 		foreach(array_keys($this->players) as $player){
40 | 			$invData = $invManager->getInventoryData($player);
41 | 			if($invData === null){
42 | 				continue;
43 | 			}
44 | 			file_put_contents("invData/" . $this->name . "_" . strtolower($player) . ".yml", yaml_emit($invData, YAML_UTF8_ENCODING));
45 | 		}
46 | 	}
47 | }


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/MiniGameEventHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame;
 6 | 
 7 | use JsonException;
 8 | use pocketmine\event\Listener;
 9 | use pocketmine\event\player\PlayerJoinEvent;
10 | use pocketmine\event\player\PlayerQuitEvent;
11 | use skh6075\lib\minigame\inventory\PlayerInventoryManager;
12 | use skh6075\lib\minigame\room\MiniGameRoomManager;
13 | 
14 | final class MiniGameEventHandler implements Listener{
15 | 
16 | 	/**
17 | 	 * @param PlayerQuitEvent $event
18 | 	 * @priority HIGHEST
19 | 	 */
20 | 	public function onPlayerQuitEvent(PlayerQuitEvent $event): void{
21 | 		$player = $event->getPlayer();
22 | 		$roomManager = MiniGameRoomManager::getInstance();
23 | 		foreach($roomManager->getPlayerJoinedRooms($player) as $room){
24 | 			$room->removePlayer($player);
25 | 		}
26 | 	}
27 | 
28 | 	/**
29 | 	 * @param PlayerJoinEvent $event
30 | 	 *
31 | 	 * @priority LOWEST
32 | 	 * @throws JsonException
33 | 	 */
34 | 	public function onPlayerJoinEvent(PlayerJoinEvent $event): void{
35 | 		$player = $event->getPlayer();
36 | 		if(is_dir("invData/")){
37 | 			$invManager = PlayerInventoryManager::getInstance();
38 | 			$files = array_diff(scandir("invData/"), ['.', '..']);
39 | 			foreach($files as $file){
40 | 				if(str_contains($file, strtolower($player->getName()))){
41 | 					$invData = yaml_parse(file_get_contents("invData/" . $file));
42 | 					unlink("invData/" . $file);
43 | 					$invManager->push($player, $invData);
44 | 					$invManager->send($player);
45 | 				}
46 | 			}
47 | 		}
48 | 	}
49 | }


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/utils/MiniGameRoomTrait.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame\utils;
 6 | 
 7 | use pocketmine\Player;
 8 | use pocketmine\plugin\Plugin;
 9 | use skh6075\lib\minigame\team\MiniGameTeamManager;
10 | 
11 | trait MiniGameRoomTrait{
12 | 
13 | 	final public function getName(): string{
14 | 		return $this->name;
15 | 	}
16 | 
17 | 	final public function getMinPlayerCount(): int{
18 | 		return $this->minPlayerCount;
19 | 	}
20 | 
21 | 	final public function getMaxPlayerCount(): int{
22 | 		return $this->maxPlayerCount;
23 | 	}
24 | 
25 | 	final public function getPlugin(): Plugin{
26 | 		return $this->plugin;
27 | 	}
28 | 
29 | 	final public function getGamemode(): int{
30 | 		return $this->gamemode;
31 | 	}
32 | 
33 | 	public function setGamemode(int $gamemode): void{
34 | 		$this->gamemode = $gamemode;
35 | 	}
36 | 
37 | 	final public function getJoinedPlayers(): array{
38 | 		return $this->players;
39 | 	}
40 | 
41 | 	final public function isJoinedPlayer(Player $player): bool{
42 | 		return isset($this->players[strtolower($player->getName())]);
43 | 	}
44 | 
45 | 	public function addPlayer(Player $player): bool{
46 | 		if($this->maxPlayerCount <= count($this->players) || $this->isJoinedPlayer($player)){
47 | 			return false;
48 | 		}
49 | 		$this->players[strtolower($player->getName())] = time();
50 | 		return true;
51 | 	}
52 | 
53 | 	public function removePlayer($player): bool{
54 | 		if($player instanceof Player){
55 | 			$player = $player->getName();
56 | 		}
57 | 		if(isset($this->players[strtolower($player)])){
58 | 			unset($this->players[strtolower($player)]);
59 | 			return true;
60 | 		}
61 | 		return false;
62 | 	}
63 | 
64 | 	final public function getTeamManager(): ?MiniGameTeamManager{
65 | 		return $this->teamManager;
66 | 	}
67 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # MiniGameAPI
 2 | Tools that make it easy for developers to create MiniGames.
 3 | 
 4 | ```PHP Version: 8.0.9```
 5 | 
 6 | # Usage
 7 | 
 8 | Write the code below in the onEnable method of the minigame plugin you are creating.
 9 | ```php
10 | public function onEnable() : void{
11 |     if(!MiniGameHandler::isRegistered()){
12 |         MiniGameHandler::register($this);
13 |     }
14 | }
15 | ```
16 | </br>
17 | </br>
18 | 
19 | Team overrides are as follows:
20 | ```php
21 | final class ColorMatchRoom extends MiniGameRoom{
22 | 	
23 | 	public function __construct(
24 | 		string $name,
25 | 		int $minPlayerCount, 
26 | 		int $maxPlayerCount, 
27 | 		Plugin $plugin, 
28 | 		int $gamemode = self::GAMEMODE_DEFAULT, 
29 | 		array $players = [], 
30 | 		?MiniGameTeamManager $teamManager = null){
31 | 		parent::__construct($name, $minPlayerCount, $maxPlayerCount, $plugin, $gamemode, $players, $teamManager);
32 | 	}
33 | }
34 | ```
35 | </br>
36 | </br>
37 | 
38 | This plugin supports team features.
39 | If you create a game room without using the team feature.
40 | ```php
41 | final class RedTeam extends MiniGameTeam{}
42 | ```
43 | ```php
44 | final class BlueTeam extends MiniGameteam{}
45 | ```
46 | </br>
47 | 
48 | ```php
49 | $teamManager = new MiniGameTeamManager(
50 |     new RedTeam("RED", []),
51 |     new BlueTeam("BLUE", [])
52 | );
53 | ```
54 | 
55 | </br>
56 | </br>
57 | 
58 | This library manages the player's inventory.
59 | ```php
60 | $invManager = PlayerInventoryManager::getInstance();
61 | ```
62 | 
63 | </br>
64 | 
65 | You can save or load the player's inventory.
66 | ```php
67 | public function onPlayerJoinEvent(PlayerJoinEvent $event) : void{
68 |     $invManager = PlayerInventoryManager::getInstance();
69 |     $invManager->send($event->getPlayer());
70 | }
71 | ```
72 | ```php
73 | public function onPlayerQuitEvent(PlayerQuitEvent $event) : void{
74 |     $invManager = PlayerInventoryManager::getInstance();
75 |     $invManager->save($event->getPlayer());
76 | }
77 | ```
78 | 


--------------------------------------------------------------------------------
/src/skh6075/lib/minigame/inventory/PlayerInventoryManager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | namespace skh6075\lib\minigame\inventory;
 6 | 
 7 | use JetBrains\PhpStorm\Pure;
 8 | use JsonException;
 9 | use pocketmine\Player;
10 | use pocketmine\utils\SingletonTrait;
11 | 
12 | final class PlayerInventoryManager{
13 | 	use SingletonTrait;
14 | 
15 | 	public const PLAYER_INVENTORY = 0;
16 | 	public const CURSOR_INVENTORY = 1;
17 | 	public const ARMOR_INVENTORY = 2;
18 | 
19 | 	private array $inventories = [];
20 | 
21 | 	/**
22 | 	 * @throws JsonException
23 | 	 */
24 | 	public function send(Player $player): bool{
25 | 		if(!isset($this->inventories[strtolower($player->getName())])){
26 | 			return false;
27 | 		}
28 | 		$invData = $this->inventories[strtolower($player->getName())];
29 | 		for($sync = self::PLAYER_INVENTORY; $sync <= self::ARMOR_INVENTORY; $sync++){
30 | 			$method = $this->syncToMethod($sync);
31 | 			if($method === "" || !method_exists(Player::class, $method)){
32 | 				continue;
33 | 			}
34 | 			$player->{$method . "()"}->setContents(json_decode($invData[$sync], true, 512, JSON_THROW_ON_ERROR));
35 | 		}
36 | 		unset($this->inventories[strtolower($player->getName())]);
37 | 		return true;
38 | 	}
39 | 
40 | 	public function push(Player $player, array $data): void{
41 | 		$this->inventories[strtolower($player->getName())] = $data;
42 | 	}
43 | 
44 | 	private function syncToMethod(int $sync = self::PLAYER_INVENTORY): string{
45 | 		return match ($sync){
46 | 			self::PLAYER_INVENTORY => "getInventory",
47 | 			self::CURSOR_INVENTORY => "getCursorInventory",
48 | 			self::ARMOR_INVENTORY => "getArmorInventory",
49 | 			default => ""
50 | 		};
51 | 	}
52 | 
53 | 	/**
54 | 	 * @throws JsonException
55 | 	 */
56 | 	public function save(Player $player): void{
57 | 		$invData = [];
58 | 		$invData[self::PLAYER_INVENTORY] = json_encode($player->getInventory()->getContents(true), JSON_THROW_ON_ERROR);
59 | 		$invData[self::CURSOR_INVENTORY] = json_encode($player->getCursorInventory()->getContents(true), JSON_THROW_ON_ERROR);
60 | 		$invData[self::ARMOR_INVENTORY] = json_encode($player->getArmorInventory()->getContents(true), JSON_THROW_ON_ERROR);
61 | 
62 | 		$this->inventories[strtolower($player->getName())] = $invData;
63 | 	}
64 | 
65 | 	#[Pure]
66 | 	public function getInventoryData($player): ?array{
67 | 		if($player instanceof Player){
68 | 			$player = $player->getName();
69 | 		}
70 | 		return $this->inventories[strtolower($player)] ?? null;
71 | 	}
72 | }
73 | 


--------------------------------------------------------------------------------