Weather Class Reference

Public Member Functions
	__construct (Level $level, $duration=1200)
	canCalculate ()
	setCanCalculate (bool $canCalc)
	calcWeather ($currentTick)
	setWeather (int $wea, int $duration=12000)
	getRandomWeatherData ()
	setRandomWeatherData (array $randomWeatherData)
	getWeather ()
	isSunny ()
	isRainy ()
	isRainyThunder ()
	isThunder ()
	getStrength ()
	sendWeather (Player $p)
	sendWeatherToAll ()

Static Public Member Functions
static	getWeatherFromString ($weather)

Data Fields
const	CLEAR = 0
const	SUNNY = 0
const	RAIN = 1
const	RAINY = 1
const	RAINY_THUNDER = 2
const	THUNDER = 3

Constructor & Destructor Documentation

__construct()

__construct	(	Level	$level,
			$duration = 1200
	)

Weather constructor.

Parameters

Level	$level
int	$duration

                                                               {
        $this->level = $level;
        $this->weatherNow = self::SUNNY;
        $this->duration = $duration;
        $this->lastUpdate = $level->getServer()->getTick();
        $this->temporalVector = new Vector3(0, 0, 0);
    }

Member Function Documentation

calcWeather()

calcWeather

(

$currentTick

)

Parameters

$currentTick

                                             {
        if($this->canCalculate()){
            $tickDiff = $currentTick - $this->lastUpdate;
            $this->duration -= $tickDiff;

            if($this->duration <= 0){
                $duration = mt_rand(
                    min($this->level->getServer()->weatherRandomDurationMin, $this->level->getServer()->weatherRandomDurationMax),
                    max($this->level->getServer()->weatherRandomDurationMin, $this->level->getServer()->weatherRandomDurationMax));

                if($this->weatherNow === self::SUNNY){
                    $weather = $this->randomWeatherData[array_rand($this->randomWeatherData)];
                    $this->setWeather($weather, $duration);
                }else{
                    $weather = self::SUNNY;
                    $this->setWeather($weather, $duration);
                }
            }
            if(($this->weatherNow >= self::RAINY_THUNDER) and ($this->level->getServer()->lightningTime > 0) and is_int($this->duration / $this->level->getServer()->lightningTime)){
                $players = $this->level->getPlayers();
                if(count($players) > 0){
                    $p = $players[array_rand($players)];
                    $x = $p->x + mt_rand(-64, 64);
                    $z = $p->z + mt_rand(-64, 64);
                    $y = $this->level->getHighestBlockAt($x, $z);
                    $this->level->spawnLightning($this->temporalVector->setComponents($x, $y, $z));
                }
            }
        }
        $this->lastUpdate = $currentTick;
    }

canCalculate()

canCalculate

(

)

Returns

bool

                                   : bool{
        return $this->canCalculate;
    }

getRandomWeatherData()

getRandomWeatherData

(

)

Returns

array

                                           : array{
        return $this->randomWeatherData;
    }

getStrength()

getStrength

(

)

Returns

array

                                  : array{
        return [$this->strength1, $this->strength2];
    }

getWeather()

getWeather

(

)

Returns

int

                                 : int{
        return $this->weatherNow;
    }

getWeatherFromString()

static getWeatherFromString (   $weather )

static

Parameters

$weather

Returns

int

                                                         {
        if(is_int($weather)){
            if($weather <= 3){
                return $weather;
            }
            return self::SUNNY;
        }
        switch(strtolower($weather)){
            case "clear":
            case "sunny":
            case "fine":
                return self::SUNNY;
            case "rain":
            case "rainy":
                return self::RAINY;
            case "thunder":
                return self::THUNDER;
            case "rain_thunder":
            case "rainy_thunder":
            case "storm":
                return self::RAINY_THUNDER;
            default:
                return self::SUNNY;
        }
    }

isRainy()

isRainy

(

)

Returns

bool

                              : bool{
        return $this->getWeather() === self::RAINY;
    }

isRainyThunder()

isRainyThunder

(

)

Returns

bool

                                     : bool{
        return $this->getWeather() === self::RAINY_THUNDER;
    }

isSunny()

isSunny

(

)

Returns

bool

                              : bool{
        return $this->getWeather() === self::SUNNY;
    }

isThunder()

isThunder

(

)

Returns

bool

                                : bool{
        return $this->getWeather() === self::THUNDER;
    }

sendWeather()

sendWeather

(

Player

$p

)

Parameters

Player

$p

                                          {
        $pks = [
            new LevelEventPacket(),
            new LevelEventPacket()
        ];

        //Set defaults. These will be sent if the case statement defaults.
        $pks[0]->evid = LevelEventPacket::EVENT_STOP_RAIN;
        $pks[0]->data = $this->strength1;
        $pks[1]->evid = LevelEventPacket::EVENT_STOP_THUNDER;
        $pks[1]->data = $this->strength2;

        switch($this->weatherNow){
            //If the weather is not clear, overwrite the packet values with these
            case self::RAIN:
                $pks[0]->evid = LevelEventPacket::EVENT_START_RAIN;
                $pks[0]->data = $this->strength1;
                break;
            case self::RAINY_THUNDER:
                $pks[0]->evid = LevelEventPacket::EVENT_START_RAIN;
                $pks[0]->data = $this->strength1;
                $pks[1]->evid = LevelEventPacket::EVENT_START_THUNDER;
                $pks[1]->data = $this->strength2;
                break;
            case self::THUNDER:
                $pks[1]->evid = LevelEventPacket::EVENT_START_THUNDER;
                $pks[1]->data = $this->strength2;
                break;
            default:
                break;
        }

        foreach($pks as $pk){
            $p->dataPacket($pk);
        }
        $p->weatherData = [$this->weatherNow, $this->strength1, $this->strength2];
    }

sendWeatherToAll()

sendWeatherToAll

(

)

                                      {
        foreach($this->level->getPlayers() as $player){
            $this->sendWeather($player);
        }
    }

setCanCalculate()

setCanCalculate

(

bool

$canCalc

)

Parameters

bool

$canCalc

                                                  {
        $this->canCalculate = $canCalc;
    }

setRandomWeatherData()

setRandomWeatherData

(

array

$randomWeatherData

)

Parameters

array

$randomWeatherData

                                                                  {
        $this->randomWeatherData = $randomWeatherData;
    }

setWeather()

setWeather	(	int	$wea,
		int	$duration = 12000
	)

Parameters

int	$wea
int	$duration

                                                               {
        $this->level->getServer()->getPluginManager()->callEvent($ev = new WeatherChangeEvent($this->level, $wea, $duration));
        if(!$ev->isCancelled()){
            $this->weatherNow = $ev->getWeather();
            $this->strength1 = mt_rand(90000, 110000); //If we're clearing the weather, it doesn't matter what strength values we set
            $this->strength2 = mt_rand(30000, 40000);
            $this->duration = $ev->getDuration();
            $this->sendWeatherToAll();
        }
    }

Field Documentation

CLEAR

const CLEAR = 0

RAIN

const RAIN = 1

RAINY

const RAINY = 1

RAINY_THUNDER

const RAINY_THUNDER = 2

SUNNY

const SUNNY = 0

THUNDER

const THUNDER = 3

---

The documentation for this class was generated from the following file:

• src/pocketmine/level/weather/Weather.php