├── .gitignore
├── icon.png
├── src
    └── diduhless
    │   └── parties
    │       ├── event
    │           ├── PartyJoinEvent.php
    │           ├── PartyCreateEvent.php
    │           ├── PartyDisbandEvent.php
    │           ├── PartyLeaveEvent.php
    │           ├── PartyPvpEnableEvent.php
    │           ├── PartySetPublicEvent.php
    │           ├── PartyPvpDisableEvent.php
    │           ├── PartySetPrivateEvent.php
    │           ├── PartyWorldTeleportEnableEvent.php
    │           ├── PartyWorldTeleportDisableEvent.php
    │           ├── PartyUpdateSlotsEvent.php
    │           ├── PartyInviteEvent.php
    │           ├── PartyMemberKickEvent.php
    │           ├── PartyLeaderPromoteEvent.php
    │           └── PartyEvent.php
    │       ├── utils
    │           ├── StoresSession.php
    │           ├── ColorUtils.php
    │           └── ConfigGetter.php
    │       ├── form
    │           ├── element
    │           │   ├── GoBackButton.php
    │           │   └── GoBackPartyButton.php
    │           ├── ConfirmInvitationForm.php
    │           ├── InvitationsForm.php
    │           ├── PublicPartiesForm.php
    │           ├── PartyMembersForm.php
    │           ├── PartyMenuForm.php
    │           ├── PartyMemberForm.php
    │           ├── PartyInviteForm.php
    │           ├── YourPartyForm.php
    │           └── PartyOptionsForm.php
    │       ├── command
    │           ├── PartyCommand.php
    │           ├── PartyChatCommand.php
    │           └── SessionCommand.php
    │       ├── listener
    │           ├── PartyChatListener.php
    │           ├── SessionListener.php
    │           ├── ConfigurationListener.php
    │           └── PartyEventListener.php
    │       ├── party
    │           ├── PartyFactory.php
    │           ├── Invitation.php
    │           └── Party.php
    │       ├── Parties.php
    │       └── session
    │           ├── SessionFactory.php
    │           └── Session.php
├── plugin.yml
├── .poggit.yml
├── resources
    └── config.yml
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea


--------------------------------------------------------------------------------
/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pretendlake/Parties/HEAD/icon.png


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyJoinEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyJoinEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyCreateEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyCreateEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyDisbandEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyDisbandEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyLeaveEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyLeaveEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyPvpEnableEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyPvpEnableEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartySetPublicEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartySetPublicEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyPvpDisableEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyPvpDisableEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartySetPrivateEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartySetPrivateEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyWorldTeleportEnableEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyWorldTeleportEnableEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyWorldTeleportDisableEvent.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | 
4 | namespace diduhless\parties\event;
5 | 
6 | 
7 | class PartyWorldTeleportDisableEvent extends PartyEvent {
8 | 
9 | }


--------------------------------------------------------------------------------
/plugin.yml:
--------------------------------------------------------------------------------
1 | main: diduhless\parties\Parties
2 | name: Parties
3 | description: A parties plugin for PocketMine-MP servers
4 | website: https://github.com/didacdelolmo
5 | author: Didah (@didacdelolmo)
6 | version: 2.0.3
7 | api: 5.0.0


--------------------------------------------------------------------------------
/.poggit.yml:
--------------------------------------------------------------------------------
 1 | --- # Poggit-CI Manifest. Open the CI at https://poggit.pmmp.io/ci/Diduhless/Parties
 2 | build-by-default: true
 3 | projects:
 4 |   Parties:
 5 |     path: ""
 6 |     icon: "icon.png"
 7 |     libs:
 8 |       - src: dresnite/easyui/libEasyUI
 9 |         version: 1.0.3
10 |         branch: pm5
11 | ...
12 | 


--------------------------------------------------------------------------------
/src/diduhless/parties/utils/StoresSession.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\utils;
 5 | 
 6 | 
 7 | use diduhless\parties\session\Session;
 8 | 
 9 | trait StoresSession {
10 | 
11 |     protected ?Session $session = null;
12 | 
13 |     public function getSession(): ?Session {
14 |         return $this->session;
15 |     }
16 | 
17 |     public function setSession(?Session $session): void {
18 |         $this->session = $session;
19 |     }
20 | 
21 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/element/GoBackButton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form\element;
 5 | 
 6 | 
 7 | use EasyUI\element\Button;
 8 | use EasyUI\Form;
 9 | use pocketmine\player\Player;
10 | 
11 | class GoBackButton extends Button {
12 | 
13 |     public function __construct(Form $form) {
14 |         parent::__construct("Go back", null, function(Player $player) use ($form) {
15 |             $player->sendForm($form);
16 |         });
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/element/GoBackPartyButton.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form\element;
 5 | 
 6 | 
 7 | use diduhless\parties\session\SessionFactory;
 8 | use EasyUI\element\Button;
 9 | use pocketmine\player\Player;
10 | 
11 | class GoBackPartyButton extends Button {
12 | 
13 |     public function __construct() {
14 |         parent::__construct("Go back", null, function(Player $player) {
15 |             SessionFactory::getSession($player)->openPartyForm();
16 |         });
17 |     }
18 | 
19 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyUpdateSlotsEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\event;
 5 | 
 6 | 
 7 | use diduhless\parties\party\Party;
 8 | use diduhless\parties\session\Session;
 9 | 
10 | class PartyUpdateSlotsEvent extends PartyEvent {
11 | 
12 |     private int $slots;
13 | 
14 |     public function __construct(Party $party, Session $session, int $slots) {
15 |         $this->slots = $slots;
16 |         parent::__construct($party, $session);
17 |     }
18 | 
19 |     public function getSlots(): ?int {
20 |         return $this->slots;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyInviteEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\event;
 5 | 
 6 | 
 7 | use diduhless\parties\party\Party;
 8 | use diduhless\parties\session\Session;
 9 | 
10 | class PartyInviteEvent extends PartyEvent {
11 | 
12 |     private Session $target;
13 | 
14 |     public function __construct(Party $party, Session $session, Session $target) {
15 |         $this->target = $target;
16 |         parent::__construct($party, $session);
17 |     }
18 | 
19 |     public function getTarget(): Session {
20 |         return $this->target;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyMemberKickEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\event;
 5 | 
 6 | 
 7 | use diduhless\parties\party\Party;
 8 | use diduhless\parties\session\Session;
 9 | 
10 | class PartyMemberKickEvent extends PartyEvent {
11 | 
12 |     private Session $member;
13 | 
14 |     public function __construct(Party $party, Session $session, Session $member) {
15 |         $this->member = $member;
16 |         parent::__construct($party, $session);
17 |     }
18 | 
19 |     public function getMember(): Session {
20 |         return $this->member;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyLeaderPromoteEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\event;
 5 | 
 6 | 
 7 | use diduhless\parties\party\Party;
 8 | use diduhless\parties\session\Session;
 9 | 
10 | class PartyLeaderPromoteEvent extends PartyEvent {
11 | 
12 |     private Session $new_leader;
13 | 
14 |     public function __construct(Party $party, Session $session, Session $newLeader) {
15 |         $this->new_leader = $newLeader;
16 |         parent::__construct($party, $session);
17 |     }
18 | 
19 |     public function getNewLeader(): Session {
20 |         return $this->new_leader;
21 |     }
22 | 
23 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/command/PartyCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\command;
 5 | 
 6 | 
 7 | use diduhless\parties\session\Session;
 8 | 
 9 | class PartyCommand extends SessionCommand {
10 | 
11 |     public function __construct() {
12 |         parent::__construct("party", "Opens the party menu or sends a message to the party chat", null, ["p"]);
13 |     }
14 | 
15 |     public function onCommand(Session $session, array $args): void {
16 |         if(isset($args[0])) {
17 |             if($session->hasParty()) {
18 |                 $session->getParty()->sendColoredMessage($session, implode(" ", $args));
19 |             } else {
20 |                 $session->message("{RED}You must be in a party to talk in the party chat!");
21 |             }
22 |         } else {
23 |             $session->openPartyForm();
24 |         }
25 |     }
26 | 
27 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/listener/PartyChatListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\listener;
 5 | 
 6 | 
 7 | use diduhless\parties\session\SessionFactory;
 8 | use pocketmine\event\Listener;
 9 | use pocketmine\event\player\PlayerChatEvent;
10 | 
11 | class PartyChatListener implements Listener {
12 | 
13 |     /**
14 |      * @param PlayerChatEvent $event
15 |      * @priority HIGHEST
16 |      */
17 |     public function onChat(PlayerChatEvent $event): void {
18 |         $player = $event->getPlayer();
19 |         if(!SessionFactory::hasSession($player)) {
20 |             return;
21 |         }
22 | 
23 |         $session = SessionFactory::getSession($player);
24 |         if($session->hasPartyChat() and $session->hasParty()) {
25 |             $session->getParty()->sendColoredMessage($session, $event->getMessage());
26 | 
27 |             $event->cancel();
28 |         }
29 |     }
30 | 
31 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/event/PartyEvent.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\event;
 5 | 
 6 | 
 7 | use diduhless\parties\party\Party;
 8 | use diduhless\parties\session\Session;
 9 | use pocketmine\event\Cancellable;
10 | use pocketmine\event\CancellableTrait;
11 | use pocketmine\event\Event;
12 | 
13 | abstract class PartyEvent extends Event implements Cancellable {
14 |     use CancellableTrait;
15 | 
16 |     private Party $party;
17 |     private Session $session;
18 | 
19 |     public function __construct(Party $party, Session $session) {
20 |         $this->party = $party;
21 |         $this->session = $session;
22 |     }
23 | 
24 |     public function getParty(): Party {
25 |         return $this->party;
26 |     }
27 | 
28 |     /*
29 |      * Returns the session that executed the event
30 |      */
31 |     public function getSession(): Session {
32 |         return $this->session;
33 |     }
34 | 
35 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/command/PartyChatCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\command;
 5 | 
 6 | 
 7 | use diduhless\parties\session\Session;
 8 | 
 9 | class PartyChatCommand extends SessionCommand {
10 | 
11 |     public function __construct() {
12 |         parent::__construct("pchat", "Toggles the party chat");
13 |     }
14 | 
15 |     public function onCommand(Session $session, array $args): void {
16 |         $party_chat = $session->hasPartyChat();
17 |         if(!$session->hasParty()) {
18 |             $session->message("{RED}You must be in a party to do this!");
19 |             return;
20 |         }
21 | 
22 |         $session->setPartyChat(!$party_chat);
23 |         if($party_chat) {
24 |             $session->message("{GREEN}You have disabled the party chat.");
25 |         } else {
26 |             $session->message("{GREEN}Your messages will now be sent to the party chat!");
27 |         }
28 |     }
29 | 
30 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/party/PartyFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | 
 6 | namespace diduhless\parties\party;
 7 | 
 8 | 
 9 | class PartyFactory {
10 | 
11 |     /** @var Party[] */
12 |     static private array $parties = [];
13 | 
14 |     /**
15 |      * @return Party[]
16 |      */
17 |     public static function getParties(): array {
18 |         return self::$parties;
19 |     }
20 | 
21 |     static public function getParty(string $id): ?Party {
22 |         return self::$parties[$id];
23 |     }
24 | 
25 |     static public function existsParty(Party $party): bool {
26 |         return array_key_exists($party->getId(), self::$parties);
27 |     }
28 | 
29 |     static public function addParty(Party $party): void {
30 |         if(!self::existsParty($party)) {
31 |             self::$parties[$party->getId()] = $party;
32 |         }
33 |     }
34 | 
35 |     static public function removeParty(Party $party): void {
36 |         if(self::existsParty($party)) {
37 |             unset(self::$parties[$party->getId()]);
38 |         }
39 |     }
40 | 
41 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/ConfirmInvitationForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\party\Invitation;
 8 | use diduhless\parties\session\Session;
 9 | use diduhless\parties\utils\StoresSession;
10 | use EasyUI\element\ModalOption;
11 | use EasyUI\variant\ModalForm;
12 | use pocketmine\player\Player;
13 | 
14 | class ConfirmInvitationForm extends ModalForm {
15 |     use StoresSession;
16 | 
17 |     private Invitation $invitation;
18 | 
19 |     public function __construct(Session $session, Invitation $invitation) {
20 |         $this->session = $session;
21 |         $this->invitation = $invitation;
22 |         parent::__construct("Join a party", "Do you want to join this party?", new ModalOption("Yes"), new ModalOption("No"));
23 |     }
24 | 
25 |     protected function onAccept(Player $player): void {
26 |         $this->invitation->attemptToAccept();
27 |     }
28 | 
29 |     protected function onDeny(Player $player): void {
30 |         $this->invitation->getTarget()->removeInvitation($this->invitation);
31 |     }
32 | 
33 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/InvitationsForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\form\element\GoBackPartyButton;
 8 | use diduhless\parties\session\Session;
 9 | use diduhless\parties\utils\StoresSession;
10 | use EasyUI\element\Button;
11 | use EasyUI\variant\SimpleForm;
12 | use pocketmine\player\Player;
13 | 
14 | class InvitationsForm extends SimpleForm {
15 |     use StoresSession;
16 | 
17 |     public function __construct(Session $session) {
18 |         $this->session = $session;
19 |         parent::__construct("Party Invitations");
20 |     }
21 | 
22 |     protected function onCreation(): void {
23 |         $invitations = $this->session->getInvitations();
24 | 
25 |         if(!empty($invitations)) {
26 |             $this->setHeaderText("These are your party invitations:");
27 |             foreach($invitations as $invitation) {
28 |                 $this->addButton(new Button($invitation->getSender()->getUsername() . "'s Party", null, function(Player $player) use ($invitation) {
29 |                     $player->sendForm(new ConfirmInvitationForm($this->session, $invitation));
30 |                 }));
31 |             }
32 |         } else {
33 |             $this->setHeaderText("You do not have any invitations! :(");
34 |         }
35 |         $this->addButton(new GoBackPartyButton());
36 |     }
37 | 
38 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/command/SessionCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\command;
 5 | 
 6 | 
 7 | use diduhless\parties\Parties;
 8 | use diduhless\parties\session\Session;
 9 | use diduhless\parties\session\SessionFactory;
10 | use pocketmine\command\Command;
11 | use pocketmine\command\CommandSender;
12 | use pocketmine\lang\Translatable;
13 | use pocketmine\permission\DefaultPermissions;
14 | use pocketmine\player\Player;
15 | use pocketmine\plugin\Plugin;
16 | use pocketmine\plugin\PluginOwned;
17 | 
18 | abstract class SessionCommand extends Command implements PluginOwned {
19 | 
20 |     public function __construct(string $name, Translatable|string $description = "", Translatable|string|null $usageMessage = null, array $aliases = []) {
21 |         $this->setPermission(DefaultPermissions::ROOT_USER);
22 |         parent::__construct($name, $description, $usageMessage, $aliases);
23 |     }
24 | 
25 |     public function execute(CommandSender $sender, string $commandLabel, array $args): void {
26 |         if($sender instanceof Player and SessionFactory::hasSession($sender)) {
27 |             $this->onCommand(SessionFactory::getSession($sender), $args);
28 |         }
29 |     }
30 | 
31 |     abstract public function onCommand(Session $session, array $args): void;
32 | 
33 |     public function getOwningPlugin(): Plugin {
34 |         return Parties::getInstance();
35 |     }
36 | 
37 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/Parties.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | 
 6 | namespace diduhless\parties;
 7 | 
 8 | 
 9 | use diduhless\parties\command\PartyChatCommand;
10 | use diduhless\parties\command\PartyCommand;
11 | use diduhless\parties\listener\ConfigurationListener;
12 | use diduhless\parties\listener\PartyChatListener;
13 | use diduhless\parties\listener\PartyEventListener;
14 | use diduhless\parties\listener\SessionListener;
15 | use pocketmine\command\Command;
16 | use pocketmine\event\Listener;
17 | use pocketmine\plugin\PluginBase;
18 | use pocketmine\utils\SingletonTrait;
19 | 
20 | class Parties extends PluginBase {
21 |     use SingletonTrait;
22 | 
23 |     protected function onLoad(): void {
24 |         self::setInstance($this);
25 |     }
26 | 
27 |     protected function onEnable(): void {
28 |         $this->registerEvents(new SessionListener());
29 |         $this->registerEvents(new PartyChatListener());
30 |         $this->registerEvents(new PartyEventListener());
31 |         $this->registerEvents(new ConfigurationListener());
32 | 
33 |         $this->registerCommand(new PartyCommand());
34 |         $this->registerCommand(new PartyChatCommand());
35 |     }
36 | 
37 |     private function registerEvents(Listener $listener): void {
38 |        $this->getServer()->getPluginManager()->registerEvents($listener, $this);
39 |    }
40 | 
41 |    public function registerCommand(Command $command): void {
42 |         $this->getServer()->getCommandMap()->register("parties", $command);
43 |    }
44 | 
45 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/PublicPartiesForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\form\element\GoBackPartyButton;
 8 | use diduhless\parties\party\Invitation;
 9 | use diduhless\parties\party\PartyFactory;
10 | use diduhless\parties\session\Session;
11 | use diduhless\parties\utils\StoresSession;
12 | use EasyUI\element\Button;
13 | use EasyUI\variant\SimpleForm;
14 | use pocketmine\player\Player;
15 | 
16 | class PublicPartiesForm extends SimpleForm {
17 |     use StoresSession;
18 | 
19 |     public function __construct(Session $session) {
20 |         $this->session = $session;
21 |         parent::__construct("Join a public party");
22 |     }
23 | 
24 |     protected function onCreation(): void {
25 |         foreach(PartyFactory::getParties() as $party) {
26 |             if($party->isPublic() and !$party->isFull()) {
27 |                 $this->addButton(new Button($party->getLeaderName() . "'s Party", null, function(Player $player) use ($party) {
28 |                     $player->sendForm(new ConfirmInvitationForm($this->session, new Invitation($party->getLeader(), $this->session, $party->getId())));
29 |                 }));
30 |             }
31 |         }
32 |         if(!empty($this->getButtons())) {
33 |             $this->setHeaderText("Press on the party you want to join!");
34 |         } else {
35 |             $this->setHeaderText("There are no public parties to join! :(");
36 |         }
37 |         $this->addButton(new GoBackPartyButton());
38 |     }
39 | 
40 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/PartyMembersForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\form\element\GoBackPartyButton;
 8 | use diduhless\parties\session\Session;
 9 | use diduhless\parties\utils\StoresSession;
10 | use EasyUI\element\Button;
11 | use EasyUI\variant\SimpleForm;
12 | use pocketmine\player\Player;
13 | 
14 | class PartyMembersForm extends SimpleForm {
15 |     use StoresSession;
16 | 
17 |     public function __construct(Session $session) {
18 |         $this->session = $session;
19 |         parent::__construct("Party Members", "Current members in your party:");
20 |     }
21 | 
22 |     protected function onCreation(): void {
23 |         $members = $this->session->getParty()->getMembers();
24 |         unset($members[array_search($this->session, $members, true)]);
25 |         array_unshift($members, $this->session);
26 | 
27 |         foreach($members as $member) {
28 |             $button = new Button($member->getUsername());
29 |             $button->setSubmitListener(function(Player $player) use ($member) {
30 |                 if($this->session->isPartyLeader() and !$member->isPartyLeader()) {
31 |                     $player->sendForm(new PartyMemberForm($this->session, $member));
32 |                 } else {
33 |                     $player->sendForm(new PartyMembersForm($this->session));
34 |                 }
35 |             });
36 |             $this->addButton($button);
37 |         }
38 |         $this->addButton(new GoBackPartyButton());
39 |     }
40 | 
41 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/session/SessionFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | 
 6 | namespace diduhless\parties\session;
 7 | 
 8 | 
 9 | use pocketmine\player\Player;
10 | 
11 | class SessionFactory {
12 | 
13 |     /** @var Session[] */
14 |     static private array $sessions = [];
15 | 
16 |     /**
17 |      * @return Session[]
18 |      */
19 |     static public function getSessions(): array {
20 |         return self::$sessions;
21 |     }
22 | 
23 |     static public function getSessionByName(string $username): ?Session {
24 |         return self::$sessions[strtolower($username)] ?? null;
25 |     }
26 | 
27 |     static public function getSession(Player $player): ?Session {
28 |         return self::getSessionByName(strtolower($player->getName())) ?? null;
29 |     }
30 | 
31 |     static public function hasSessionByName(string $username): bool {
32 |         return array_key_exists(strtolower($username), self::$sessions);
33 |     }
34 | 
35 |     static public function hasSession(Player $player): bool {
36 |         return self::hasSessionByName($player->getName());
37 |     }
38 | 
39 |     static public function createSession(Player $player): void {
40 |         if(!self::hasSession($player)) {
41 |             self::$sessions[strtolower($player->getName())] = new Session($player);
42 |         }
43 |     }
44 | 
45 |     static public function removeSession(Player $player): void {
46 |         if(self::hasSession($player)) {
47 |             unset(self::$sessions[strtolower($player->getName())]);
48 |         }
49 |     }
50 | 
51 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/utils/ColorUtils.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | 
 6 | namespace diduhless\parties\utils;
 7 | 
 8 | 
 9 | use pocketmine\utils\TextFormat;
10 | 
11 | class ColorUtils {
12 | 
13 |     static public function translate(string $message): string {
14 |         $message = str_replace("{BLACK}", TextFormat::BLACK, $message);
15 |         $message = str_replace("{DARK_BLUE}", TextFormat::DARK_BLUE, $message);
16 |         $message = str_replace("{DARK_GREEN}", TextFormat::DARK_GREEN, $message);
17 |         $message = str_replace("{DARK_AQUA}", TextFormat::DARK_AQUA, $message);
18 |         $message = str_replace("{DARK_RED}", TextFormat::DARK_RED, $message);
19 |         $message = str_replace("{DARK_PURPLE}", TextFormat::DARK_PURPLE, $message);
20 |         $message = str_replace("{GOLD}", TextFormat::GOLD, $message);
21 |         $message = str_replace("{GRAY}", TextFormat::GRAY, $message);
22 |         $message = str_replace("{DARK_GRAY}", TextFormat::DARK_GRAY, $message);
23 |         $message = str_replace("{BLUE}", TextFormat::BLUE, $message);
24 |         $message = str_replace("{GREEN}", TextFormat::GREEN, $message);
25 |         $message = str_replace("{AQUA}", TextFormat::AQUA, $message);
26 |         $message = str_replace("{RED}", TextFormat::RED, $message);
27 |         $message = str_replace("{LIGHT_PURPLE}", TextFormat::LIGHT_PURPLE, $message);
28 |         $message = str_replace("{YELLOW}", TextFormat::YELLOW, $message);
29 |         $message = str_replace("{WHITE}", TextFormat::WHITE, $message);
30 |         $message = str_replace("{OBFUSCATED}", TextFormat::OBFUSCATED, $message);
31 |         $message = str_replace("{BOLD}", TextFormat::BOLD, $message);
32 |         $message = str_replace("{STRIKETHROUGH}", TextFormat::STRIKETHROUGH, $message);
33 |         $message = str_replace("{UNDERLINE}", TextFormat::UNDERLINE, $message);
34 |         $message = str_replace("{ITALIC}", TextFormat::ITALIC, $message);
35 |         $message = str_replace("{RESET}", TextFormat::RESET, $message);
36 | 
37 |         return $message;
38 |     }
39 | 
40 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/party/Invitation.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | 
 6 | namespace diduhless\parties\party;
 7 | 
 8 | 
 9 | use diduhless\parties\event\PartyJoinEvent;
10 | use diduhless\parties\session\Session;
11 | 
12 | class Invitation {
13 | 
14 |     public const INVITATION_LENGTH = 60;
15 | 
16 |     private Session $sender;
17 |     private Session $target;
18 | 
19 |     private string $partyId;
20 | 
21 |     public function __construct(Session $sender, Session $target, string $partyId) {
22 |         $this->sender = $sender;
23 |         $this->target = $target;
24 |         $this->partyId = $partyId;
25 |     }
26 | 
27 |     public function getSender(): Session {
28 |         return $this->sender;
29 |     }
30 | 
31 |     public function getTarget(): Session {
32 |         return $this->target;
33 |     }
34 | 
35 |     public function getPartyId(): string {
36 |         return $this->partyId;
37 |     }
38 | 
39 |     public function attemptToAccept(): void {
40 |         $this->target->removeInvitation($this);
41 | 
42 |         if($this->target->hasParty()) {
43 |             $this->target->message("{RED}You cannot be in a party to do this!");
44 |             return;
45 |         } elseif(!$this->sender->isOnline()) {
46 |             $this->target->message("{RED}You could not join the party because the party leader is not online!");
47 |             return;
48 |         }
49 |         $party = $this->sender->getParty();
50 |         if($party === null or $party->getId() !== $this->partyId) {
51 |             $this->target->message("{RED}You could not join the party because the party leader has left the party!");
52 |             return;
53 |         } elseif($party->isFull()) {
54 |             $this->target->message("{RED}You could not join this party because it is full!");
55 |         }
56 | 
57 |         $event = new PartyJoinEvent($party, $this->target);
58 |         $event->call();
59 |         if(!$event->isCancelled()) {
60 |             $party->add($this->target);
61 |             $this->target->removeInvitationsFromParty($party);
62 |         }
63 |     }
64 | 
65 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/listener/SessionListener.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | declare(strict_types=1);
 4 | 
 5 | 
 6 | namespace diduhless\parties\listener;
 7 | 
 8 | 
 9 | use diduhless\parties\event\PartyDisbandEvent;
10 | use diduhless\parties\event\PartyLeaveEvent;
11 | use diduhless\parties\party\Party;
12 | use diduhless\parties\party\PartyFactory;
13 | use diduhless\parties\session\Session;
14 | use diduhless\parties\session\SessionFactory;
15 | use pocketmine\event\Listener;
16 | use pocketmine\event\player\PlayerLoginEvent;
17 | use pocketmine\event\player\PlayerQuitEvent;
18 | 
19 | class SessionListener implements Listener {
20 | 
21 |     /**
22 |      * @param PlayerLoginEvent $event
23 |      * @priority HIGHEST
24 |      * @ignoreCancelled
25 |      */
26 |     public function onLogin(PlayerLoginEvent $event): void {
27 |         SessionFactory::createSession($event->getPlayer());
28 |     }
29 | 
30 |     /**
31 |      * @param PlayerQuitEvent $event
32 |      * @priority LOWEST
33 |      */
34 |     public function onQuit(PlayerQuitEvent $event): void {
35 |         $player = $event->getPlayer();
36 |         if(SessionFactory::hasSession($player)) {
37 |             $this->checkForParty(SessionFactory::getSession($player));
38 |         }
39 | 
40 |         SessionFactory::removeSession($player);
41 |     }
42 | 
43 |     private function checkForParty(Session $session): void {
44 |         if(!$session->hasParty()) {
45 |             return;
46 |         }
47 | 
48 |         $party = $session->getParty();
49 |         if($session->isPartyLeader()) {
50 |             $this->disbandParty($party);
51 |         } else {
52 |             $event = new PartyLeaveEvent($party, $session);
53 |             $event->call();
54 | 
55 |             $party->remove($session);
56 |         }
57 |     }
58 | 
59 |     private function disbandParty(Party $party): void {
60 |         $event = new PartyDisbandEvent($party, $party->getLeader());
61 |         $event->call();
62 | 
63 |         foreach($party->getMembers() as $member) {
64 |             $party->remove($member);
65 |         }
66 |         PartyFactory::removeParty($party);
67 |     }
68 | 
69 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/PartyMenuForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\event\PartyCreateEvent;
 8 | use diduhless\parties\party\Party;
 9 | use diduhless\parties\party\PartyFactory;
10 | use diduhless\parties\session\Session;
11 | use diduhless\parties\utils\StoresSession;
12 | use EasyUI\element\Button;
13 | use EasyUI\variant\SimpleForm;
14 | use pocketmine\player\Player;
15 | 
16 | class PartyMenuForm extends SimpleForm {
17 |     use StoresSession;
18 | 
19 |     public function __construct(Session $session) {
20 |         $this->session = $session;
21 |         parent::__construct("Party Menu", "You do not have a party! Create a party or accept an invitation to join a party.");
22 |     }
23 | 
24 |     protected function onCreation(): void {
25 |         $this->addCreatePartyButton();
26 |         $this->addPublicPartiesButton();
27 |         $this->addInvitationsButton();
28 |     }
29 | 
30 |     private function addCreatePartyButton(): void {
31 |         $button = new Button("Create a party");
32 |         $button->setSubmitListener(function(Player $player) {
33 |             $party = new Party(uniqid(), $this->session);
34 |             $event = new PartyCreateEvent($party, $this->session);
35 | 
36 |             $event->call();
37 |             if(!$event->isCancelled()) {
38 |                 $party->add($this->session);
39 |                 PartyFactory::addParty($party);
40 |                 $this->session->openPartyForm();
41 |             }
42 |         });
43 |         $this->addButton($button);
44 |     }
45 | 
46 |     public function addPublicPartiesButton(): void {
47 |         $this->addButton(new Button("Join a public party", null, function(Player $player) {
48 |             $player->sendForm(new PublicPartiesForm($this->session));
49 |         }));
50 |     }
51 | 
52 |     public function addInvitationsButton(): void {
53 |         $this->addButton(new Button("View invitations [" . count($this->session->getInvitations()) . "]", null, function(Player $player) {
54 |             $player->sendForm(new InvitationsForm($this->session));
55 |         }));
56 |     }
57 | 
58 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/utils/ConfigGetter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\utils;
 5 | 
 6 | 
 7 | use diduhless\parties\Parties;
 8 | 
 9 | class ConfigGetter {
10 | 
11 |     /**
12 |      * @param string $key
13 |      * @return mixed
14 |      */
15 |     static public function get(string $key): mixed {
16 |         return Parties::getInstance()->getConfig()->get($key);
17 |     }
18 | 
19 |     static public function getMaximumSlots(): int {
20 |         return self::get("maximum-party-slots");
21 |     }
22 | 
23 |     static public function isPvpDisabledOption(): bool {
24 |         return self::get("show-disable-pvp-with-party-members-option");
25 |     }
26 | 
27 |     static public function isPvpDisabled(): bool {
28 |         return self::get("default-disable-pvp-with-party-members");
29 |     }
30 | 
31 |     static public function isWorldTeleportOption(): bool {
32 |         return self::get("show-teleport-members-to-leader-on-change-world-option");
33 |     }
34 | 
35 |     static public function isWorldTeleportEnabled(): bool {
36 |         return self::get("default-teleport-members-to-leader-on-change-world");
37 |     }
38 | 
39 |     static public function isTransferTeleportEnabled(): bool {
40 |         return self::get("teleport-members-to-leader-on-transfer-server");
41 |     }
42 | 
43 |     static public function areLeaderCommandsEnabled(): bool {
44 |         return self::get("enable-leader-commands");
45 |     }
46 | 
47 |     static public function getSelectedCommands(): array {
48 |         return self::get("selected-leader-commands");
49 |     }
50 | 
51 |     static public function isPartyItemEnabled(): bool {
52 |         return self::get("give-party-item");
53 |     }
54 | 
55 |     static public function isPartyItemFixed(): bool {
56 |         return self::get("fix-party-item");
57 |     }
58 | 
59 |     static public function getPartyItemIndex(): int {
60 |         return self::get("party-item-index");
61 |     }
62 | 
63 |     static public function getPartyItemWorldNames(): array {
64 |         return self::get("party-item-worlds");
65 |     }
66 | 
67 |     static public function getPartyItemValues(): array {
68 |         return self::get("party-item");
69 |     }
70 | 
71 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/PartyMemberForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\event\PartyLeaderPromoteEvent;
 8 | use diduhless\parties\event\PartyMemberKickEvent;
 9 | use diduhless\parties\form\element\GoBackButton;
10 | use diduhless\parties\session\Session;
11 | use diduhless\parties\utils\StoresSession;
12 | use EasyUI\element\Button;
13 | use EasyUI\variant\SimpleForm;
14 | use pocketmine\player\Player;
15 | 
16 | class PartyMemberForm extends SimpleForm {
17 |     use StoresSession;
18 | 
19 |     private Session $member;
20 | 
21 |     public function __construct(Session $session, Session $member) {
22 |         $this->session = $session;
23 |         $this->member = $member;
24 |         parent::__construct("Party Member", "What do you want to do with this member?");
25 |     }
26 | 
27 |     protected function onCreation(): void {
28 |         $this->addKickButton();
29 |         $this->addPromoteButton();
30 |         $this->addButton(new GoBackButton(new PartyMembersForm($this->session)));
31 |     }
32 | 
33 |     private function addKickButton(): void {
34 |         $button = new Button("Kick from the party");
35 |         $button->setSubmitListener(function(Player $player) {
36 |             if(!$this->member->isOnline()) return;
37 |             $party = $this->session->getParty();
38 | 
39 |             $event = new PartyMemberKickEvent($party, $this->session, $this->member);
40 |             $event->call();
41 | 
42 |             if(!$event->isCancelled()) {
43 |                 $party->remove($this->member);
44 |             }
45 |         });
46 |         $this->addButton($button);
47 |     }
48 | 
49 |     private function addPromoteButton(): void {
50 |         $button = new Button("Promote to party leader");
51 |         $button->setSubmitListener(function(Player $player) {
52 |             if(!$this->member->isOnline()) return;
53 |             $party = $this->session->getParty();
54 | 
55 |             $event = new PartyLeaderPromoteEvent($party, $this->session, $this->member);
56 |             $event->call();
57 | 
58 |             if(!$event->isCancelled()) {
59 |                 $party->setLeader($this->member);
60 |             }
61 |         });
62 |         $this->addButton($button);
63 |     }
64 | 
65 | }


--------------------------------------------------------------------------------
/resources/config.yml:
--------------------------------------------------------------------------------
 1 | #  _____           _
 2 | # |  __ \         | | (_)
 3 | # | |__) |_ _ _ __| |_ _  ___  ___
 4 | # |  ___/ _` | '__| __| |/ _ \/ __|
 5 | # | |  | (_| | |  | |_| |  __/\__ \
 6 | # |_|   \__,_|_|   \__|_|\___||___/
 7 | 
 8 | # These are the maximum party slots
 9 | maximum-party-slots: 8
10 | 
11 | # Do you want this option to be displayed on the party options form so party leaders can enable or disable it?
12 | show-disable-pvp-with-party-members-option: true
13 | show-teleport-members-to-leader-on-change-world-option: true
14 | 
15 | # Do you want to disable the pvp (player versus player) damage between the party members?
16 | default-disable-pvp-with-party-members: true
17 | 
18 | # Do you want to teleport all the party members to the leader when the leader goes to another world?
19 | default-teleport-members-to-leader-on-change-world: true
20 | 
21 | # Do you want to teleport all the party members to the leader gets teleported to another server?
22 | # To transfer a player to another server, use Player->transfer()
23 | teleport-members-to-leader-on-transfer-server: true
24 | 
25 | # If this option is enabled, all the members of the party will execute the same command that the leader has executed
26 | # You must have the commands written on selected-leader-commands. If this option is set to false, it won't do anything.
27 | # If the member does not have permission to use the command, he will not execute it.
28 | enable-leader-commands: true
29 | selected-leader-commands:
30 |   - "tp diduhless didah"
31 |   - "yourcommand"
32 | 
33 | # The party item is an item that is set to the player when he joins the server.
34 | # Interacting with the party item opens the parties form (same as /party).
35 | give-party-item: true
36 | # If this option is enabled, players won't be able to move or drop the party item from their inventory.
37 | fix-party-item: true
38 | # This is the index where the party item will be set.
39 | # For example, if you want to set the item to the 9th slot, you will have to put 8. (indexes start at 0 instead of 1)
40 | party-item-index: 8
41 | # The party item will only be given when a player moves to any of these worlds (uppercases matter).
42 | party-item-worlds:
43 |   - "worldname"
44 |   - "didah"
45 | # These three values represent: item id, item meta and item custom name.
46 | party-item:
47 |   - 467
48 |   - 0
49 |   - "Party"


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Download the plugin on poggit: [![Poggit](https://poggit.pmmp.io/shield.state/Parties)](https://poggit.pmmp.io/p/Parties) <br>
 2 | Join my GitHub discord server: [![Discord](https://img.shields.io/discord/732039634745425972?color=%2392e5fc&label=discord)](https://discord.gg/bsFSwTR)
 3 | 
 4 | # Parties
 5 | 🎉 A parties plugin for PocketMine-MP servers<br><br>
 6 | 
 7 | ## Available features
 8 | 
 9 | - A complete parties API for developers (with custom **events**)
10 | - Usage of **forms** to manage the parties
11 | - Customizable party options:
12 |   - Set the maximum party slots
13 |   - **Disable the pvp** (player versus player) within the members of the party.
14 |   - Teleport the party members to the party leader when the leader gets teleported to a different world.
15 |   - Teleport the party members to the party leader when the leader gets **transfered** to another **server**.
16 |   - Make all the party members execute the same command as the party leader.
17 | 
18 | ## In-game pictures
19 | 
20 | ![Party Menu](https://i.imgur.com/r3KWqoD.png) ![Your Party](https://i.imgur.com/1nIpVEu.png)
21 | ![Party Member](https://i.imgur.com/kShbHCY.png) ![Party Options](https://i.imgur.com/FT24li1.png)
22 | ![Invite a player](https://i.imgur.com/W00fnSz.png) ![Party Chat](https://i.imgur.com/bAqQ0PP.png) 
23 | 
24 | ## Commands
25 | 
26 | - /party — Opens the party form
27 | - /party (message) — Sends a message to the party chat
28 | 
29 | ## Code examples
30 | 
31 | Setting the gamemode to spectator to all the members of the party when the party leader invites a player to join their party:
32 | ```php
33 | public function onPartyInvite(PartyInviteEvent $event): void {
34 |     $session = $event->getSession();
35 |     if($session->isPartyLeader()) {
36 |         foreach($session->getParty()->getMembers() as $member) {
37 |             $member->getPlayer()->setGamemode(GameMode::SPECTATOR);
38 |         }
39 |     }
40 | } 
41 | ```
42 | 
43 | Allow only players with the permission 'slots.limit' to set the maximum slots to more than 3:
44 | ```php
45 | public function onUpdateSlots(PartyUpdateSlotsEvent $event): void {
46 |     $session = $event->getSession();
47 |     if(!$session->getPlayer()->hasPermission("slots.limit") and $event->getSlots() > 3) {
48 |         $event->cancel();
49 |         $session->message("{RED}You do not have permissions to set the maximum slots to more than 3!");
50 |     }
51 | }
52 | ```
53 | 
54 | Setting the party public when an operator joins the party:
55 | ```php
56 | public function onPartyJoin(PartyJoinEvent $event): void {
57 |     if($event->getSession()->getPlayer()->hasPermission(DefaultPermissions::ROOT_OPERATOR)) {
58 |         $event->getParty()->setPublic(true);
59 |     }
60 | }
61 | ```
62 | 
63 | 
64 | 
65 | 


--------------------------------------------------------------------------------
/src/diduhless/parties/form/PartyInviteForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\event\PartyInviteEvent;
 8 | use diduhless\parties\party\Invitation;
 9 | use diduhless\parties\session\Session;
10 | use diduhless\parties\session\SessionFactory;
11 | use diduhless\parties\utils\StoresSession;
12 | use EasyUI\element\Dropdown;
13 | use EasyUI\element\Input;
14 | use EasyUI\element\Option;
15 | use EasyUI\utils\FormResponse;
16 | use EasyUI\variant\CustomForm;
17 | use pocketmine\player\Player;
18 | 
19 | class PartyInviteForm extends CustomForm {
20 |     use StoresSession;
21 | 
22 |     private bool $is_dropdown = false;
23 | 
24 |     public function __construct(Session $session) {
25 |         $this->session = $session;
26 |         parent::__construct("Invite a player");
27 |     }
28 | 
29 |     protected function onCreation(): void {
30 |         $dropdown = new Dropdown("Select an online player:");
31 |         foreach(SessionFactory::getSessions() as $session) {
32 |             if(!$session->hasParty()) {
33 |                 $dropdown->addOption(new Option($session->getUsername(), $session->getUsername()));
34 |             }
35 |         }
36 |         $this->addElement("input_player", new Input("Write the name of the player:"));
37 |         if(!empty($dropdown->getOptions())) {
38 |             $this->addElement("dropdown_player", $dropdown);
39 |             $this->is_dropdown = true;
40 |         }
41 |     }
42 | 
43 |     protected function onSubmit(Player $player, FormResponse $response): void {
44 |         $player_name = $response->getInputSubmittedText("input_player");
45 |         $username = !empty($player_name) ? $player_name : ($this->is_dropdown ? $response->getDropdownSubmittedOptionId("dropdown_player") : null);
46 |         if($username === null) {
47 |             return;
48 |         }
49 | 
50 |         $target = SessionFactory::getSessionByName($username);
51 |         if($target === null) {
52 |             $this->session->message("{RED}The player {WHITE}$username {RED}is not online!");
53 |         } elseif($target->hasParty()) {
54 |             $this->session->message($target->getUsername() . " {RED}is already on a party!");
55 |         } elseif($target->hasSessionInvitation($this->session)) {
56 |             $this->session->message("{RED}You have already invited {WHITE}" . $target->getUsername() . " {RED}to your party!");
57 |         } elseif(!$this->isCancelled($target)) {
58 |             $target->addInvitation(new Invitation($this->session, $target, $this->session->getParty()->getId()));
59 |         }
60 |     }
61 | 
62 |     private function isCancelled(Session $target): bool {
63 |         $session = $this->getSession();
64 |         $event = new PartyInviteEvent($session->getParty(), $session, $target);
65 |         $event->call();
66 |         return $event->isCancelled();
67 |     }
68 | 
69 | 
70 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/YourPartyForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\event\PartyDisbandEvent;
 8 | use diduhless\parties\event\PartyLeaveEvent;
 9 | use diduhless\parties\party\PartyFactory;
10 | use diduhless\parties\session\Session;
11 | use diduhless\parties\utils\StoresSession;
12 | use EasyUI\element\Button;
13 | use EasyUI\variant\SimpleForm;
14 | use pocketmine\player\Player;
15 | 
16 | class YourPartyForm extends SimpleForm {
17 |     use StoresSession;
18 | 
19 |     public function __construct(Session $session) {
20 |         $this->session = $session;
21 |         parent::__construct("Your Party", "What do you want to check?");
22 |     }
23 | 
24 |     protected function onCreation(): void {
25 |         $this->addMembersButton();
26 |         if(!$this->session->isPartyLeader()) {
27 |             $this->addLeavePartyButton();
28 |         } else {
29 |             $this->addPlayerInviteButton();
30 |             $this->addPartyOptionsButton();
31 |             $this->addDisbandPartyButton();
32 |         }
33 |     }
34 | 
35 |     private function addMembersButton(): void {
36 |         if(!$this->session->hasParty()) return;
37 | 
38 |         $this->addButton(new Button("Members (" . count($this->session->getParty()->getMembers()) . ")", null, function(Player $player) {
39 |             $player->sendForm(new PartyMembersForm($this->session));
40 |         }));
41 |     }
42 | 
43 |     private function addPlayerInviteButton(): void {
44 |         if(!$this->session->hasParty()) return;
45 | 
46 |         $this->addButton(new Button("Invite a player", null, function(Player $player) {
47 |             $player->sendForm(new PartyInviteForm($this->session));
48 |         }));
49 |     }
50 | 
51 |     private function addPartyOptionsButton(): void {
52 |         $this->addButton(new Button("Party Options", null, function(Player $player) {
53 |             $player->sendForm(new PartyOptionsForm($this->session));
54 |         }));
55 |     }
56 | 
57 |     public function addDisbandPartyButton(): void {
58 |         $button = new Button("Disband the party");
59 |         $button->setSubmitListener(function(Player $player) {
60 |             $party = $this->session->getParty();
61 | 
62 |             $event = new PartyDisbandEvent($party, $this->session);
63 |             $event->call();
64 |             if($event->isCancelled()) return;
65 | 
66 |             foreach($party->getMembers() as $member) {
67 |                 $party->remove($member);
68 |             }
69 |             PartyFactory::removeParty($party);
70 |         });
71 |         $this->addButton($button);
72 |     }
73 | 
74 |     private function addLeavePartyButton(): void {
75 |         if(!$this->session->hasParty()) return;
76 | 
77 |         $button = new Button("Leave the party");
78 |         $button->setSubmitListener(function(Player $player) {;
79 |             $party = $this->session->getParty();
80 | 
81 |             $event = new PartyLeaveEvent($party, $this->session);
82 |             $event->call();
83 | 
84 |             if(!$event->isCancelled()) {
85 |                 $party->remove($this->session);
86 |             }
87 |         });
88 |         $this->addButton($button);
89 |     }
90 | 
91 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/form/PartyOptionsForm.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | 
 4 | namespace diduhless\parties\form;
 5 | 
 6 | 
 7 | use diduhless\parties\event\PartyPvpDisableEvent;
 8 | use diduhless\parties\event\PartyPvpEnableEvent;
 9 | use diduhless\parties\event\PartySetPrivateEvent;
10 | use diduhless\parties\event\PartySetPublicEvent;
11 | use diduhless\parties\event\PartyUpdateSlotsEvent;
12 | use diduhless\parties\event\PartyWorldTeleportDisableEvent;
13 | use diduhless\parties\event\PartyWorldTeleportEnableEvent;
14 | use diduhless\parties\session\Session;
15 | use diduhless\parties\utils\ConfigGetter;
16 | use diduhless\parties\utils\StoresSession;
17 | use EasyUI\element\Label;
18 | use EasyUI\element\Slider;
19 | use EasyUI\element\Toggle;
20 | use EasyUI\utils\FormResponse;
21 | use EasyUI\variant\CustomForm;
22 | use pocketmine\player\Player;
23 | 
24 | class PartyOptionsForm extends CustomForm {
25 |     use StoresSession;
26 | 
27 |     public function __construct(Session $session) {
28 |         $this->session = $session;
29 |         parent::__construct("Party Options");
30 |     }
31 | 
32 |     protected function onCreation(): void {
33 |         $party = $this->session->getParty();
34 | 
35 |         $this->addElement("label", new Label("Change the party options in this window."));
36 |         $this->addElement("public", new Toggle("Do you want to set your party public?", $party->isPublic()));
37 |         if(ConfigGetter::isPvpDisabledOption()) {
38 |             $this->addElement("disable_pvp", new Toggle("Do you want to disable the damage between the members of your party?", !$party->isPvp()));
39 |         }
40 |         if(ConfigGetter::isWorldTeleportOption()) {
41 |             $this->addElement("leader_world_teleport", new Toggle("Do you want to teleport the members of your party when the leader moves to another world?", $party->isLeaderWorldTeleport()));
42 |         }
43 |         $this->addElement("slots", new Slider("Set your maximum party slots", 1, ConfigGetter::getMaximumSlots(), $party->getSlots(), 1));
44 |     }
45 | 
46 |     protected function onSubmit(Player $player, FormResponse $response): void {
47 |         $party = $this->session->getParty();
48 |         $public = $response->getToggleSubmittedChoice("public");
49 |         $slots = (int) $response->getSliderSubmittedStep("slots");
50 | 
51 |         if($party->isPublic() !== $public) {
52 |             $event = $public ? new PartySetPublicEvent($party, $this->session) : new PartySetPrivateEvent($party, $this->session);
53 |             $event->call();
54 |             if(!$event->isCancelled()) {
55 |                 $party->setPublic($public);
56 |             }
57 |         }
58 |         if(ConfigGetter::isPvpDisabledOption()) {
59 |             $disable_pvp = $response->getToggleSubmittedChoice("disable_pvp");
60 |             if($party->isPvp() === $disable_pvp) {
61 |                 $event = $disable_pvp ? new PartyPvpDisableEvent($party, $this->session) : new PartyPvpEnableEvent($party, $this->session);
62 |                 $event->call();
63 |                 if(!$event->isCancelled()) {
64 |                     $party->setPvp(!$disable_pvp);
65 |                 }
66 |             }
67 |         }
68 |         if(ConfigGetter::isWorldTeleportOption()) {
69 |             $leader_world_teleport = $response->getToggleSubmittedChoice("leader_world_teleport");
70 |             if($party->isLeaderWorldTeleport() !== $leader_world_teleport) {
71 |                 $event = $leader_world_teleport ? new PartyWorldTeleportEnableEvent($party, $this->session) : new PartyWorldTeleportDisableEvent($party, $this->session);
72 |                 $event->call();
73 |                 if(!$event->isCancelled()) {
74 |                     $party->setLeaderWorldTeleport($leader_world_teleport);
75 |                 }
76 |             }
77 |         }
78 |         if($party->getSlots() !== $slots) {
79 |             $event = new PartyUpdateSlotsEvent($party, $this->session, $slots);
80 |             $event->call();
81 |             if(!$event->isCancelled()) {
82 |                 $party->setSlots($slots);
83 |             }
84 |         }
85 |     }
86 | 
87 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/party/Party.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | 
  6 | namespace diduhless\parties\party;
  7 | 
  8 | 
  9 | use diduhless\parties\session\Session;
 10 | use diduhless\parties\session\SessionFactory;
 11 | use diduhless\parties\utils\ConfigGetter;
 12 | 
 13 | class Party {
 14 | 
 15 |     private string $id;
 16 | 
 17 |     private Session $leader;
 18 | 
 19 |     /** @var Session[] */
 20 |     private array $members = [];
 21 | 
 22 |     private bool $public = false;
 23 |     private bool $pvp;
 24 |     private bool $leader_world_teleport;
 25 | 
 26 |     private int $slots;
 27 | 
 28 |     public function __construct(string $id, Session $leader) {
 29 |         $this->id = $id;
 30 |         $this->leader = $leader;
 31 |         $this->members[] = $leader;
 32 |         $this->pvp = !ConfigGetter::isPvpDisabled();
 33 |         $this->leader_world_teleport = ConfigGetter::isWorldTeleportEnabled();
 34 |         $this->slots = ConfigGetter::getMaximumSlots();
 35 |     }
 36 | 
 37 |     public function getId(): string {
 38 |         return $this->id;
 39 |     }
 40 | 
 41 |     public function getMembers(): array {
 42 |         return $this->members;
 43 |     }
 44 | 
 45 |     public function hasMember(Session $session): bool {
 46 |         return in_array($session, $this->members, true);
 47 |     }
 48 | 
 49 |     public function hasMemberByName(string $username): bool {
 50 |         return SessionFactory::hasSessionByName($username) and $this->hasMember(SessionFactory::getSessionByName($username));
 51 |     }
 52 | 
 53 |     public function getLeader(): Session {
 54 |         return $this->leader;
 55 |     }
 56 | 
 57 |     public function getLeaderName(): string {
 58 |         return $this->leader->getPlayer()->getName();
 59 |     }
 60 | 
 61 |     public function setLeader(Session $leader): void {
 62 |         $this->leader = $leader;
 63 |     }
 64 | 
 65 |     public function isFull(): bool {
 66 |         return count($this->members) >= $this->slots;
 67 |     }
 68 | 
 69 |     public function isPublic(): bool {
 70 |         return $this->public;
 71 |     }
 72 | 
 73 |     public function setPublic(bool $public): void {
 74 |         $this->public = $public;
 75 |     }
 76 | 
 77 |     public function isPvp(): bool {
 78 |         return $this->pvp;
 79 |     }
 80 | 
 81 |     public function setPvp(bool $pvp): void {
 82 |         $this->pvp = $pvp;
 83 |     }
 84 | 
 85 |     public function isLeaderWorldTeleport(): bool {
 86 |         return $this->leader_world_teleport;
 87 |     }
 88 | 
 89 |     public function setLeaderWorldTeleport(bool $leader_world_teleport): void {
 90 |         $this->leader_world_teleport = $leader_world_teleport;
 91 |     }
 92 | 
 93 |     public function getSlots(): int {
 94 |         return $this->slots;
 95 |     }
 96 | 
 97 |     public function setSlots(int $slots): void {
 98 |         $this->slots = $slots;
 99 |     }
100 | 
101 |     public function add(Session $session): void {
102 |         if(!$this->hasMember($session)) {
103 |             $this->members[] = $session;
104 |         }
105 |         $session->setParty($this);
106 |     }
107 | 
108 |     public function remove(Session $session): void {
109 |         if($this->hasMember($session)) {
110 |             unset($this->members[array_search($session, $this->members, true)]);
111 |         }
112 |         $session->setParty(null);
113 |         $session->setPartyChat(false);
114 |     }
115 | 
116 |     public function sendColoredMessage(Session $session, string $message): void {
117 |         $this->message("{LIGHT_PURPLE}[Party] {GRAY}" . $session->getUsername() . ": {WHITE}$message");
118 |     }
119 | 
120 |     /*
121 |      * If you set a session instance to $ignored_member, that session will not receive the party message
122 |      */
123 |     public function message(string $message, ?Session $ignored_member = null): void {
124 |         foreach($this->members as $member) {
125 |             if($ignored_member !== null and $member->getUsername() === $ignored_member->getUsername()) continue;
126 |             $member->message($message);
127 |         }
128 |     }
129 | 
130 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/session/Session.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | 
  6 | namespace diduhless\parties\session;
  7 | 
  8 | 
  9 | use diduhless\parties\form\PartyMenuForm;
 10 | use diduhless\parties\form\YourPartyForm;
 11 | use diduhless\parties\party\Invitation;
 12 | use diduhless\parties\party\Party;
 13 | use diduhless\parties\utils\ColorUtils;
 14 | use diduhless\parties\utils\ConfigGetter;
 15 | use pocketmine\item\LegacyStringToItemParser;
 16 | use pocketmine\player\Player;
 17 | use pocketmine\utils\TextFormat;
 18 | 
 19 | class Session {
 20 | 
 21 |     private Player $player;
 22 | 
 23 |     private ?Party $party = null;
 24 |     private bool $party_chat = false;
 25 | 
 26 |     /** @var Invitation[] */
 27 |     private array $invitations = [];
 28 | 
 29 |     public function __construct(Player $player) {
 30 |         $this->player = $player;
 31 |     }
 32 | 
 33 |     public function getUsername(): string {
 34 |         return $this->player->getName();
 35 |     }
 36 | 
 37 |     public function getPlayer(): Player {
 38 |         return $this->player;
 39 |     }
 40 | 
 41 |     public function isOnline(): bool {
 42 |         return SessionFactory::hasSession($this->player);
 43 |     }
 44 | 
 45 |     public function getParty(): ?Party {
 46 |         return $this->party;
 47 |     }
 48 | 
 49 |     public function setParty(?Party $party): void {
 50 |         $this->party = $party;
 51 |     }
 52 | 
 53 |     public function hasParty(): bool {
 54 |         return $this->party !== null;
 55 |     }
 56 | 
 57 |     public function isPartyLeader(): bool {
 58 |         return $this->hasParty() and $this->party->getLeaderName() === $this->getUsername();
 59 |     }
 60 | 
 61 |     public function hasPartyChat(): bool {
 62 |         return $this->party_chat;
 63 |     }
 64 | 
 65 |     public function setPartyChat(bool $party_chat): void {
 66 |         $this->party_chat = $party_chat;
 67 |     }
 68 | 
 69 |     /**
 70 |      * Removes all the invitations that have passed more than the provided invitation length
 71 |      *
 72 |      * @return Invitation[]
 73 |      */
 74 |     public function getInvitations(): array {
 75 |         foreach($this->invitations as $time => $invitation) {
 76 |             if(microtime(true) - $time >= Invitation::INVITATION_LENGTH) {
 77 |                 $this->removeInvitation($invitation);
 78 |             }
 79 |         }
 80 |         return $this->invitations;
 81 |     }
 82 | 
 83 |     public function hasInvitation(Invitation $invitation): bool {
 84 |         return in_array($invitation, $this->invitations, true);
 85 |     }
 86 | 
 87 |     public function hasSessionInvitation(Session $session): bool {
 88 |         foreach($this->getInvitations() as $invitation) {
 89 |             if($invitation->getSender()->getUsername() === $session->getUsername()) {
 90 |                 return true;
 91 |             }
 92 |         }
 93 |         return false;
 94 |     }
 95 | 
 96 |     public function addInvitation(Invitation $invitation): void {
 97 |         $this->invitations[microtime(true)] = $invitation;
 98 |     }
 99 | 
100 |     public function removeInvitation(Invitation $invitation): void {
101 |         if($this->hasInvitation($invitation)) {
102 |             unset($this->invitations[array_search($invitation, $this->invitations, true)]);
103 |         }
104 |     }
105 | 
106 |     public function removeInvitationsFromParty(Party $party): void {
107 |         foreach($this->getInvitations() as $invitation) {
108 |             if($invitation->getPartyId() === $party->getId()) {
109 |                 $this->removeInvitation($invitation);
110 |             }
111 |         }
112 |     }
113 | 
114 |     public function openPartyForm(): void {
115 |         $this->hasParty() ? $this->player->sendForm(new YourPartyForm($this)) : $this->player->sendForm(new PartyMenuForm($this));
116 |     }
117 | 
118 |     public function givePartyItem(int $index): void {
119 |         $values = ConfigGetter::getPartyItemValues();
120 | 
121 |         $item = LegacyStringToItemParser::getInstance()->parse($values[0] . ":" . $values[1]);
122 |         $item->setCustomName(TextFormat::GREEN . $values[2]);
123 |         $item->getNamedTag()->setByte("parties", 1);
124 | 
125 |         $this->getPlayer()->getInventory()->setItem($index, $item);
126 |     }
127 | 
128 |     public function message(string $message): void {
129 |         $this->getPlayer()->sendMessage(ColorUtils::translate($message));
130 |     }
131 | 
132 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/listener/ConfigurationListener.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 
  4 | namespace diduhless\parties\listener;
  5 | 
  6 | 
  7 | use diduhless\parties\session\SessionFactory;
  8 | use diduhless\parties\utils\ConfigGetter;
  9 | use pocketmine\event\entity\EntityDamageByEntityEvent;
 10 | use pocketmine\event\entity\EntityTeleportEvent;
 11 | use pocketmine\event\inventory\InventoryTransactionEvent;
 12 | use pocketmine\event\Listener;
 13 | use pocketmine\event\player\PlayerItemUseEvent;
 14 | use pocketmine\event\player\PlayerJoinEvent;
 15 | use pocketmine\event\player\PlayerRespawnEvent;
 16 | use pocketmine\event\player\PlayerTransferEvent;
 17 | use pocketmine\event\server\CommandEvent;
 18 | use pocketmine\player\Player;
 19 | use pocketmine\Server;
 20 | use pocketmine\world\World;
 21 | 
 22 | class ConfigurationListener implements Listener {
 23 | 
 24 |     public function onFight(EntityDamageByEntityEvent $event): void {
 25 |         $entity = $event->getEntity();
 26 |         $damager = $event->getDamager();
 27 | 
 28 |         if(!$entity instanceof Player or !$damager instanceof Player or !SessionFactory::hasSession($entity)) {
 29 |             return;
 30 |         }
 31 |         $session = SessionFactory::getSession($damager);
 32 |         if(!$session->hasParty()) {
 33 |             return;
 34 |         }
 35 |         $party = $session->getParty();
 36 |         if(!$party->isPvp() and $party->hasMemberByName($entity->getName())) {
 37 |             $event->cancel();
 38 |         }
 39 |     }
 40 | 
 41 |     public function onWorldChange(EntityTeleportEvent $event): void {
 42 |         $world = $event->getTo()->getWorld();
 43 |         if($event->getFrom()->getWorld()->getFolderName() === $world->getFolderName()) {
 44 |             return;
 45 |         }
 46 | 
 47 |         $entity = $event->getEntity();
 48 |         if(!$entity instanceof Player or !SessionFactory::hasSession($entity)) {
 49 |             return;
 50 |         }
 51 |         $this->checkPartyItem($entity, $world);
 52 |         $session = SessionFactory::getSession($entity);
 53 |         if(!$session->isPartyLeader()) {
 54 |             return;
 55 |         }
 56 |         $party = $session->getParty();
 57 |         if($party->isLeaderWorldTeleport()) {
 58 |             foreach($party->getMembers() as $member) {
 59 |                 if(!$member->isPartyLeader()) {
 60 |                     $member->getPlayer()->teleport($world->getSafeSpawn());
 61 |                 }
 62 |             }
 63 |         }
 64 |     }
 65 | 
 66 |     public function onTransfer(PlayerTransferEvent $event): void {
 67 |         if(!ConfigGetter::isTransferTeleportEnabled()) {
 68 |             return;
 69 |         }
 70 |         $session = SessionFactory::getSession($event->getPlayer());
 71 |         if($session->isPartyLeader()) {
 72 |             return;
 73 |         }
 74 |         foreach($session->getParty()->getMembers() as $member) {
 75 |             if(!$member->isPartyLeader()) {
 76 |                 $member->getPlayer()->transfer($event->getAddress(), $event->getPort(), $event->getMessage());
 77 |             }
 78 |         }
 79 |     }
 80 | 
 81 |     public function onCommand(CommandEvent $event): void {
 82 |         if(!ConfigGetter::areLeaderCommandsEnabled()) {
 83 |             return;
 84 |         }
 85 |         $sender = $event->getSender();
 86 |         if(!$sender instanceof Player) {
 87 |             return;
 88 |         }
 89 |         $command = $event->getCommand();
 90 |         if(!in_array($command, ConfigGetter::getSelectedCommands())) {
 91 |             return;
 92 |         }
 93 |         $session = SessionFactory::getSession($sender);
 94 |         if($session->isPartyLeader()) {
 95 |             foreach($session->getParty()->getMembers() as $member) {
 96 |                 if(!$member->isPartyLeader()) {
 97 |                     Server::getInstance()->dispatchCommand($member->getPlayer(), $command);
 98 |                 }
 99 |             }
100 |         }
101 |     }
102 | 
103 |     public function onTransaction(InventoryTransactionEvent $event): void {
104 |         if(ConfigGetter::isPartyItemFixed()) {
105 |             foreach($event->getTransaction()->getActions() as $action) {
106 |                 if($action->getSourceItem()->getNamedTag()->getTag("parties") !== null) {
107 |                     $event->cancel();
108 |                 }
109 |             }
110 |         }
111 |     }
112 | 
113 |     /**
114 |      * @handleCancelled
115 |      */
116 |     public function onItemUse(PlayerItemUseEvent $event): void {
117 |         if($event->getItem()->getNamedTag()->getTag("parties") !== null) {
118 |             SessionFactory::getSession($event->getPlayer())->openPartyForm();
119 |         }
120 |     }
121 | 
122 |     public function onJoin(PlayerJoinEvent $event): void {
123 |         $player = $event->getPlayer();
124 |         $this->checkPartyItem($player, $player->getWorld());
125 |     }
126 | 
127 |     public function onRespawn(PlayerRespawnEvent $event): void {
128 |         $player = $event->getPlayer();
129 |         $this->checkPartyItem($player, $event->getRespawnPosition()->getWorld());
130 |     }
131 | 
132 |     private function checkPartyItem(Player $player, World $world): void {
133 |         if(ConfigGetter::isPartyItemEnabled() and SessionFactory::hasSession($player) and in_array($world->getFolderName(), ConfigGetter::getPartyItemWorldNames())) {
134 |             SessionFactory::getSession($player)->givePartyItem(ConfigGetter::getPartyItemIndex());
135 |         }
136 |     }
137 | 
138 | }


--------------------------------------------------------------------------------
/src/diduhless/parties/listener/PartyEventListener.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | 
  4 | namespace diduhless\parties\listener;
  5 | 
  6 | 
  7 | use diduhless\parties\event\PartyCreateEvent;
  8 | use diduhless\parties\event\PartyDisbandEvent;
  9 | use diduhless\parties\event\PartyInviteEvent;
 10 | use diduhless\parties\event\PartyJoinEvent;
 11 | use diduhless\parties\event\PartyLeaderPromoteEvent;
 12 | use diduhless\parties\event\PartyLeaveEvent;
 13 | use diduhless\parties\event\PartyMemberKickEvent;
 14 | use diduhless\parties\event\PartyPvpDisableEvent;
 15 | use diduhless\parties\event\PartyPvpEnableEvent;
 16 | use diduhless\parties\event\PartySetPrivateEvent;
 17 | use diduhless\parties\event\PartySetPublicEvent;
 18 | use diduhless\parties\event\PartyUpdateSlotsEvent;
 19 | use diduhless\parties\event\PartyWorldTeleportDisableEvent;
 20 | use diduhless\parties\event\PartyWorldTeleportEnableEvent;
 21 | use pocketmine\event\Listener;
 22 | 
 23 | class PartyEventListener implements Listener {
 24 | 
 25 |     /**
 26 |      * @param PartyCreateEvent $event
 27 |      * @ignoreCancelled
 28 |      * @priority HIGHEST
 29 |      */
 30 |     public function onCreate(PartyCreateEvent $event): void {
 31 |         $event->getSession()->message("{GREEN}You have created a party!");
 32 |     }
 33 | 
 34 |     /**
 35 |      * @param PartyDisbandEvent $event
 36 |      * @ignoreCancelled
 37 |      * @priority HIGHEST
 38 |      */
 39 |     public function onDisband(PartyDisbandEvent $event): void {
 40 |         $session = $event->getSession();
 41 |         $party = $event->getParty();
 42 | 
 43 |         $session->message("{RED}You have disbanded the party!");
 44 |         $party->message("{RED}The party has been disbanded because {WHITE}" . $party->getLeaderName() . " {RED}left the party.", $session);
 45 |     }
 46 | 
 47 |     /**
 48 |      * @param PartyInviteEvent $event
 49 |      * @ignoreCancelled
 50 |      * @priority HIGHEST
 51 |      */
 52 |     public function onInvite(PartyInviteEvent $event): void {
 53 |         $session = $event->getSession();
 54 |         $target = $event->getTarget();
 55 | 
 56 |         $targetName = $target->getUsername();
 57 | 
 58 |         $session->message("{GREEN}You have invited {WHITE}$targetName {GREEN}to the party! They have {WHITE}1 minute {GREEN}to accept the invitation.");
 59 |         $target->message("{GREEN}You have received an invitation to join {WHITE}" . $session->getUsername() . "{GREEN}'s party!");
 60 |         $event->getParty()->message("$targetName {GREEN}has been invited to the party!", $session);
 61 |     }
 62 | 
 63 |     /**
 64 |      * @param PartyJoinEvent $event
 65 |      * @ignoreCancelled
 66 |      * @priority HIGHEST
 67 |      */
 68 |     public function onJoin(PartyJoinEvent $event): void {
 69 |         $session = $event->getSession();
 70 |         $party = $event->getParty();
 71 | 
 72 |         $session->message("{GREEN}You have joined {WHITE}" . $party->getLeaderName() . "{GREEN}'s party!");
 73 |         $party->message($session->getUsername() . " {GREEN}has joined the party!");
 74 |     }
 75 | 
 76 |     /**
 77 |      * @param PartyLeaderPromoteEvent $event
 78 |      * @ignoreCancelled
 79 |      * @priority HIGHEST
 80 |      */
 81 |     public function onLeaderPromote(PartyLeaderPromoteEvent $event): void {
 82 |         $session = $event->getSession();
 83 |         $newLeader = $event->getNewLeader();
 84 |         $party = $event->getParty();
 85 | 
 86 |         $sessionName = $session->getUsername();
 87 |         $newLeaderName = $newLeader->getUsername();
 88 | 
 89 |         $session->message("{GREEN}You have promoted {WHITE}$newLeaderName {GREEN}to party leader!");
 90 |         $newLeader->message("{GREEN}You have been promoted by {WHITE}$sessionName {GREEN}to party leader!");
 91 |         $party->message("$sessionName {GREEN}has promoted {WHITE}$newLeaderName {GREEN}to party leader!", $session);
 92 |     }
 93 | 
 94 |     /**
 95 |      * @param PartyLeaveEvent $event
 96 |      * @ignoreCancelled
 97 |      * @priority HIGHEST
 98 |      */
 99 |     public function onLeave(PartyLeaveEvent $event): void {
100 |         $session = $event->getSession();
101 |         $party = $event->getParty();
102 | 
103 |         $session->message("{RED}You have left {WHITE}" . $party->getLeaderName() . "{RED}'s party!");
104 |         $party->message($session->getUsername() . " {RED}has left the party!", $session);
105 |     }
106 | 
107 |     /**
108 |      * @param PartyMemberKickEvent $event
109 |      * @ignoreCancelled
110 |      * @priority HIGHEST
111 |      */
112 |     public function onMemberKick(PartyMemberKickEvent $event): void {
113 |         $member = $event->getMember();
114 | 
115 |         $member->message("{RED}You have been kicked from {WHITE}" . $event->getSession()->getUsername() . "{RED}'s party!");
116 |         $event->getParty()->message($member->getUsername() . " {RED}has been kicked from the party!", $member);
117 |     }
118 | 
119 |     /**
120 |      * @param PartyPvpEnableEvent $event
121 |      * @ignoreCancelled
122 |      * @priority HIGHEST
123 |      */
124 |     public function onEnablePvp(PartyPvpEnableEvent $event): void {
125 |         $event->getParty()->message("{GREEN}The party pvp has been {WHITE}enabled{GREEN}!");
126 |     }
127 | 
128 |     /**
129 |      * @param PartyPvpDisableEvent $event
130 |      * @ignoreCancelled
131 |      * @priority HIGHEST
132 |      */
133 |     public function onDisablePvp(PartyPvpDisableEvent $event): void {
134 |         $event->getParty()->message("{GREEN}The party pvp has been {WHITE}disabled{GREEN}!");
135 |     }
136 | 
137 |     /**
138 |      * @param PartyWorldTeleportEnableEvent $event
139 |      * @ignoreCancelled
140 |      * @priority HIGHEST
141 |      */
142 |     public function onWorldTeleportEnable(PartyWorldTeleportEnableEvent $event): void {
143 |         $event->getParty()->message("{GREEN}The party leader world teleport has been {WHITE}enabled{GREEN}!");
144 |     }
145 | 
146 |     /**
147 |      * @param PartyWorldTeleportDisableEvent $event
148 |      * @ignoreCancelled
149 |      * @priority HIGHEST
150 |      */
151 |     public function onWorldTeleportDisable(PartyWorldTeleportDisableEvent $event): void {
152 |         $event->getParty()->message("{GREEN}The party leader world teleport has been {WHITE}disabled{GREEN}!");
153 |     }
154 | 
155 |     /**
156 |      * @param PartySetPrivateEvent $event
157 |      * @ignoreCancelled
158 |      * @priority HIGHEST
159 |      */
160 |     public function onLock(PartySetPrivateEvent $event): void {
161 |         $event->getParty()->message("{GREEN}The party is now {WHITE}private{GREEN}!");
162 |     }
163 | 
164 |     /**
165 |      * @param PartySetPublicEvent $event
166 |      * @ignoreCancelled
167 |      * @priority HIGHEST
168 |      */
169 |     public function onUnlock(PartySetPublicEvent $event): void {
170 |         $event->getParty()->message("{GREEN}The party is now {WHITE}public{GREEN}!");
171 |     }
172 | 
173 |     /**
174 |      * @param PartyUpdateSlotsEvent $event
175 |      * @ignoreCancelled
176 |      * @priority HIGHEST
177 |      */
178 |     public function onUpdateSlots(PartyUpdateSlotsEvent $event): void {
179 |         $event->getParty()->message("{GREEN}The party slots have been set to {WHITE}" . $event->getSlots() . "{GREEN}!");
180 |     }
181 | 
182 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


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