A frequently asked question in PocketMine-MP plugin development is how the get the attacker of a died player using `PlayerDeathEvent`, which is not obvious especially for beginners in PocketMine-MP plugin development.

First, we need to listen on the `PlayerDeathEvent`, which provides us with the killed player. Using the killed player object, we can get the last damage cause.

```php
/**
 * Get the killer of a player on death
 *
 * @param PlayerDeathEvent $ev
 */
public function onPlayerDeath(PlayerDeathEvent $ev): void {
    $diedPlayer = $ev->getPlayer();
    $lastDamageCause = $diedPlayer->getLastDamageCause();
```

Next, we check if the last damage was caused by an entity (`instanceof EntityDamageByEntityEvent`). It’s also possible that the attacker already left the game or died itself, so we need to check if it’s null.

```php
    if(!($lastDamageCause instanceof EntityDamageByEntityEvent)) {
        return;
    }

    $killer = $lastDamageCause->getDamager();

    if($killer === null) {
        return;
    }
```

As a final step, we check if the attacking entity was a player. If it was, we send a message to the attacking player.

```php
    if(!($killer instanceof Player)) {
        return;
    }

    $killer->sendMessage("You've killed a player!");
```

That’s it! There are some things you need to check, but on the whole, it’s not that difficult.

The full code of getting the attacker in the PlayerDeathEvent function:

```php
/**
 * Get the killer of a player on death
 *
 * @param PlayerDeathEvent $ev
 */
public function onPlayerDeath(PlayerDeathEvent $ev): void {
    $diedPlayer = $ev->getPlayer();
    $lastDamageCause = $diedPlayer->getLastDamageCause();

    if(!($lastDamageCause instanceof EntityDamageByEntityEvent)) {
        return;
    }

    $killer = $lastDamageCause->getDamager();

    if($killer === null) {
        return;
    }

    if(!($killer instanceof Player)) {
        return;
    }

    $killer->sendMessage("You've killed a player!");
}
```

How to get the attacker using PlayerDeathEvent

A common tool you frequently need when programming with the PocketMine-MP API are tasks. Using tasks, you’re able to repeat running code e. g. each 30 seconds, or to run delayed code for e. g. after 10 seconds.

Before we’re beginning creating our first task, it’s important to understand how PocketMine’s timing system works. We specify time in *ticks*, not in seconds. Conversion is easy, **ticks = seconds * 20**, so 3 seconds are 60 ticks.

## Creating a task

As an example, we’re going to create a task which broadcasts “Hello and welcome on my server!” each 30 seconds to all players on the server.

Let’s create a new class `BroadcastHelloTask.php` and extend the `Task`-class.

```php
<?php
/**
 * ExamplePlugin | hello broadcasting task
 */

namespace surva\exampleplugin\task;

use pocketmine\scheduler\Task;

class BroadcastHelloTask extends Task {

}
```

Smart IDE’s already indicate that we’re missing the implementation of some methods, so we’re going to add them now.

```php
/**
 * Broadcast message to players on task run
 *
 * @param int $currentTick
 */
public function onRun(int $currentTick): void {
    // TODO: Implement onRun() method.
}
```

The `onRun` method is called when the task is executed, e. g. after the 30 seconds are over. So we’re going to add our code we want to execute to this method.

In order to get all players on the server, access to the plugin’s main class is needed, so it’s time to add a variable containing it to our task class.

```php
/* @var ExamplePlugin */
private $examplePlugin;

public function __construct(ExamplePlugin $exmpPl) {
    $this->examplePlugin = $exmpPl;
}
```

Now, we’re able to access our plugin’s main class, so let’s implement the `onRun` method:

```php
/**
 * Broadcast message to players on task run
 *
 * @param int $currentTick
 */
public function onRun(int $currentTick): void {
    $plsOnServer = $this->examplePlugin->getServer()->getOnlinePlayers();

    foreach($plsOnServer as $player) {
        $player->sendMessage("Hello and welcome on my server!");
    }
}
```

## Scheduling the task

Our task is ready now, we just need to schedule it.

To continue our example, we’re going the set the task to repeat each 30 seconds:

```php
public function onEnable(): void {
    $this->getScheduler()->scheduleRepeatingTask(new BroadcastHelloTask($this), 600);
}
```

When the plugin gets enabled, our task gets immediately executed, after 30 seconds again, and again.

I’ve used `$this` as an argument for `BroadcastHelloTask`’s constructor (see `BroadcastHelloTask` class) and 600 as the period argument as 30 seconds * 20 ticks are 600.

Of course, there are also other ways of scheduling our task, e. g. we could execute it only once, but with 10 seconds delay:

```php
$this->getScheduler()->scheduleDelayedTask(new BroadcastHelloTask($this), 200);
```

Creating repeating/delayed tasks in PocketMine-MP

Many plugins provide a translation feature where the language of the plugin
messages can be set server-wide in the config file.
To enhance the experience for players, a better way is to automatically
detect which language the player has set on its device and send
translated messages for each player's own language.

## Getting the language short code

This is possible using the `getLocale()` method of the player or command sender object, like in this example:

```php
echo $player->getLocale();
```

This will simply print the player's locale (language and country) to the server console.

Example output:

```
en_US
de_DE
```

First one is English (US), second one is German (Germany).

For a simple translation, it's enough to know the language without the country, so we just cut this off:

```php
preg_match("/^[a-z][a-z]/", $player->getLocale(), $language);

echo $language;
```

Will now output: `en` and `de`.

## Using language files

Let's look at a full example on how to handle translations in a plugin.

We'll store our translations as `.yml` files in the `resources/languages` directory.

First, some default values should be defined, and we'll use an array to store the language config files:

```php
public const AVAILABLE_LANGUAGES = ["en", "de"];
public const DEFAULT_LANGUAGE = "en";

/**
 * @var \pocketmine\utils\Config[] translation files
 */
private array $translations;
```

We'll also need a method to load the language files into the array:

```php
/**
 * Load all language translation files
 *
 * @return void
 */
public function loadTranslationFiles(): void
{
    foreach (self::AVAILABLE_LANGUAGES as $availableLanguage) {
        $this->translations[$availableLanguage] = new Config(
            $this->getFile() . "resources/languages/" . $availableLanguage . ".yml"
        );
    }
}
```

Now, we can write the most important function which will detect the players language and load the translation value from the correct language file:

```php
/**
 * Get a translated message
 *
 * @param  \pocketmine\player\Player  $player
 * @param  string  $key
 *
 * @return string
 */
public function getMessage(Player $player, string $key): string
{
    preg_match("/^[a-z][a-z]/", $player->getLocale(), $language);

    if (count($language) > 0 && isset($this->translations[$language[0]])) {
        return $this->translations[$language[0]]->getNested($key);
    } else {
        return $this->translations[self::DEFAULT_LANGUAGE]->getNested($key);
    }
}
```

The first line is already known, it is extracting the language short code.
The following if-statement checks if there is a language file for the player's preferred language. If not, the default language (defined above) will be used.

Here is an example on how you could use the translation method:

```php
/**
 * Send a welcome message when a player joins the game
 *
 * @param  \pocketmine\event\player\PlayerJoinEvent  $event
 *
 * @return void
 */
public function onPlayerJoin(PlayerJoinEvent $event): void
{
    $player = $event->getPlayer();

    $player->sendMessage($this->getMessage($player, "join.welcome"));
}
```

This code in the event listener class sends a translated welcome message to every player at game join.

Translation files in the `resources/languages` directory could look like this:

`en.yml`:

```yaml
join:
    welcome: "Welcome on our server!"
```

`de.yml`:

```yaml
join:
    welcome: "Willkommen auf unserem Server!"
```


Using automatic language detection for translated messages in PocketMine-MP plugins

Position checks and calculation with vectors can sometimes a bit complicated,
so we've created an article describing the most common checks and how to solve them.
There are different types of checks, e.g. if you want to check if a player is in an area
created by two positions or next to a specific position.

## Check if player is next to a position

That's an easy check because PocketMine already has a method to accomplish this.

First, we need the vector coordinates (x, y, z) of a position, this could be treasure chest a player must find, for example.

You would usually store those values in a config file:

```yaml
treasure:
    pos:
        x: 15
        y: 81
        z: 63
```

Let's let those values:

```php
$pos = new Vector3(
    $this->getConfig()->getNested("treasure.pos.x"),
    $this->getConfig()->getNested("treasure.pos.y"),
    $this->getConfig()->getNested("treasure.pos.z")
);
```

To check if a player is next to this position, use the `distance()` method of the player's position object:

```php
if ($player->getPosition()->distance($pos) <= 5) {
    // player is next to position, not more than 5 blocks away, do something
}
```

When it comes to choose an event for checking, please keep in mind that checking at each `PlayerMoveEvent` would be bad for the performance. Instead, you could use a command the player should execute or `PlayerInteractEvent` to let the player interact with a button, for example.

## Check if player is inside an area

This is a bit more complex, but also possible. To define an area, you need two vector coordinates which span up a square (imagine like a square in WorldEdit with position 1 and 2).

This could be the config file then:

```yaml
area:
  pos1:
    x: 10
    y: 50
    z: 10
  pos2:
    x: 50
    y: 70
    z: 50
```

We need to create two variables to store the minimum and maximum coordinate values:

```php
private Vector3 $minPos;
private Vector3 $maxPos;
```

This function is responsible for loading the coordinate values from the config file and find the minimum and maximum values:

```php
/**
 * Read the area config into variables
 *
 * @return void
 */
private function readAreaConfig(): void
{
    $pos1 = new Vector3(
        $this->getConfig()->getNested("area.pos1.x"),
        $this->getConfig()->getNested("area.pos1.y"),
        $this->getConfig()->getNested("area.pos1.z")
    );
    $pos2 = new Vector3(
        $this->getConfig()->getNested("area.pos2.x"),
        $this->getConfig()->getNested("area.pos2.y"),
        $this->getConfig()->getNested("area.pos2.z")
    );

    $this->minPos = Vector3::minComponents($pos1, $pos2);
    $this->maxPos = Vector3::maxComponents($pos1, $pos2);
}
```

We'll use `minPos` and `maxPos` in the next step to check if the player's position is between those two (in the defined area).

```php
/**
 * Check if a position is in the area
 *
 * @param  \pocketmine\math\Vector3  $pos
 *
 * @return bool
 */
public function isInArea(Vector3 $pos): bool
{
    return ($this->minPos->x <= $pos->x && $pos->x <= $this->maxPos->x)
            && ($this->minPos->y <= $pos->y
                && $pos->y <= $this->maxPos->y)
            && ($this->minPos->z <= $pos->z && $pos->z <= $this->maxPos->z);
}
```

This method checks for each vector coordinate (x, y, z) if it's between our minimum and maximum coordinate value.

Example on how to use the method above:

```php
if ($this->isInArea($player->getPosition())) {
    $player->sendMessage("You're inside the area!");
}
```

### What does this code do

We have this config as an example:

```yaml
area:
  pos1:
    x: 10
    y: 20
    z: 30
  pos2:
    x: 5
    y: 40
    z: 5
```

Our code will create the minimum and maximum vector out of those two, so we can compare it easier later. It checks every vector coordinate (x, y and z) and chooses the minimum or maximum out of the two positions defined in the config file.

The minimum vector is (5, 20, 5) and the maximum one is (10, 40, 30).

Now we can easily compare if the player is in the area for each coordinate. If the x value is between 5 and 10, the y value between 20 and 40 and the z value between 5 and 30, the player is inside the defined area.


surva network: development blog

Latest posts on our dev-blog 💻

How to get the attacker using PlayerDeathEvent

Creating repeating/delayed tasks in PocketMine-MP

Using automatic language detection for translated messages in PocketMine-MP plugins

How to check if a player's position is next to a point or inside an area