Public Member Functions
	getSkinData ()

	getSkinId ()

	getUniqueId ()

	getRawUniqueId ()

	setSkin ($str, $skinId)

	getFood ()

	setFood (float $new)

	getMaxFood ()

	addFood (float $amount)

	getSaturation ()

	setSaturation (float $saturation)

	addSaturation (float $amount)

	getExhaustion ()

	setExhaustion (float $exhaustion)

	exhaust (float $amount, int $cause=PlayerExhaustEvent::CAUSE_CUSTOM)

	getXpLevel ()

	setXpLevel (int $level)

	addXpLevel (int $level)

	takeXpLevel (int $level)

	getXpProgress ()

	setXpProgress (float $progress)

	getTotalXp ()

	setTotalXp (int $xp, bool $syncLevel=false)

	addXp (int $xp, bool $syncLevel=false)

	takeXp (int $xp, bool $syncLevel=false)

	getRemainderXp ()

	getFilledXp ()

	recalculateXpProgress ()

	getXpSeed ()

	resetXpCooldown ()

	canPickupXp ()

	getInventory ()

	getEnderChestInventory ()

	getFloatingInventory ()

	getTransactionQueue ()

	getAbsorption ()

	setAbsorption (int $absorption)

	entityBaseTick ($tickDiff=1, $EnchantL=0)

	getName ()

	getDrops ()

	saveNBT ()

	spawnTo (Player $player)

	close ()

Public Member Functions inherited from Creature
	onUpdate ($tick)

	willMove ($distance=36)

	attack ($damage, EntityDamageEvent $source)

	ifjump (Level $level, Vector3 $v3, $hate=false, $reason=false)

	whatBlock (Level $level, $v3)

	getMyYaw ($mx, $mz)

	getMyPitch (Vector3 $from, Vector3 $to)

Public Member Functions inherited from Living
	setHealth ($amount)

	saveNBT ()

	getName ()

	hasLineOfSight (Entity $entity)

	heal ($amount, EntityRegainHealthEvent $source)

	attack ($damage, EntityDamageEvent $source)

	knockBack (Entity $attacker, $damage, $x, $z, $base=0.4)

	kill ()

	entityBaseTick ($tickDiff=1, $EnchantL=0)

	getDrops ()

	getLineOfSight ($maxDistance, $maxLength=0, array $transparent=[])

	getTargetBlock ($maxDistance, array $transparent=[])

Public Member Functions inherited from Entity
	__construct (Level $level, CompoundTag $nbt)

	getHeight ()

	getWidth ()

	getLength ()

	setScale ($scale)

	getScale ()

	getDropExpMin ()

	getDropExpMax ()

	getNameTag ()

	isNameTagVisible ()

	isNameTagAlwaysVisible ()

	setNameTag ($name)

	setNameTagVisible ($value=true)

	setNameTagAlwaysVisible ($value=true)

	isSneaking ()

	setSneaking ($value=true)

	isSprinting ()

	setSprinting ($value=true)

	isGliding ()

	setGliding ($value=true)

	isImmobile ()

	setImmobile ($value=true)

	canClimb ()

	setCanClimb (bool $value)

	canClimbWalls ()

	setCanClimbWalls (bool $value=true)

	getOwningEntityId ()

	getOwningEntity ()

	setOwningEntity (Entity $owner)

	getEffects ()

	removeAllEffects ()

	removeEffect ($effectId)

	getEffect ($effectId)

	hasEffect ($effectId)

	addEffect (Effect $effect)

	getSaveId ()

	saveNBT ()

	getViewers ()

	spawnTo (Player $player)

	sendPotionEffects (Player $player)

	sendData ($player, array $data=null)

	despawnFrom (Player $player, bool $send=true)

	attack ($damage, EntityDamageEvent $source)

	heal ($amount, EntityRegainHealthEvent $source)

	getHealth ()

	isAlive ()

	setHealth ($amount)

	setLastDamageCause (EntityDamageEvent $type)

	getLastDamageCause ()

	getAttributeMap ()

	getMaxHealth ()

	setMaxHealth ($amount)

	canCollideWith (Entity $entity)

	entityBaseTick ($tickDiff=1)

	getDirectionVector ()

	getDirectionPlane ()

	onUpdate ($currentTick)

	scheduleUpdate ()

	isOnFire ()

	setOnFire ($seconds)

	isFireProof ()

	getDirection ()

	extinguish ()

	canTriggerWalking ()

	resetFallDistance ()

	getBoundingBox ()

	fall ($fallDistance)

	handleLavaMovement ()

	getEyeHeight ()

	moveFlying ()

	onCollideWithPlayer (Human $entityPlayer)

	getPosition ()

	getLocation ()

	isInsideOfPortal ()

	isInsideOfWater ()

	isInsideOfSolid ()

	isInsideOfFire ()

	fastMove ($dx, $dy, $dz)

	move ($dx, $dy, $dz)

	getBlocksAround ()

	setPositionAndRotation (Vector3 $pos, $yaw, $pitch)

	setRotation ($yaw, $pitch)

	setLocation (Location $pos)

	setPosition (Vector3 $pos)

	getMotion ()

	setMotion (Vector3 $motion)

	isOnGround ()

	kill ()

	teleport (Vector3 $pos, $yaw=null, $pitch=null)

	getId ()

	respawnToAll ()

	spawnToAll ()

	despawnFromAll ()

	close ()

	setDataProperty ($id, $type, $value)

	linkEntity (Entity $entity)

	sendLinkedData ()

	setLinked ($type=0, Entity $entity)

	getLinkedEntity ()

	getLinkedType ()

	getDataProperty ($id)

	getDataPropertyType ($id)

	setDataFlag ($propertyId, $id, $value=true, $type=self::DATA_TYPE_LONG)

	getDataFlag ($propertyId, $id)

	__destruct ()

	setMetadata ($metadataKey, MetadataValue $metadataValue)

	getMetadata ($metadataKey)

	hasMetadata ($metadataKey)

	removeMetadata ($metadataKey, Plugin $plugin)

	__toString ()

Public Member Functions inherited from Location
	__construct ($x=0, $y=0, $z=0, $yaw=0.0, $pitch=0.0, Level $level=null)

	asLocation ()

	add ($x, $y=0, $z=0, $yaw=0, $pitch=0)

	getYaw ()

	getPitch ()

	fromObjectAdd (Vector3 $pos, $x, $y, $z)

	__toString ()

Public Member Functions inherited from Position
	__construct ($x=0, $y=0, $z=0, Level $level=null)

	asPosition ()

	add ($x, $y=0, $z=0)

	getLevel ()

	setLevel (Level $level=null)

	isValid ()

	getSide ($side, $step=1)

	__toString ()

	setComponents ($x, $y, $z)

	fromObjectAdd (Vector3 $pos, $x, $y, $z)

Public Member Functions inherited from Vector3
	__construct ($x=0, $y=0, $z=0)

	getX ()

	getY ()

	getZ ()

	getFloorX ()

	getFloorY ()

	getFloorZ ()

	getRight ()

	getUp ()

	getForward ()

	getSouth ()

	getWest ()

	add ($x, $y=0, $z=0)

	subtract ($x=0, $y=0, $z=0)

	multiply ($number)

	divide ($number)

	ceil ()

	floor ()

	round ()

	abs ()

	getSide ($side, $step=1)

	asVector3 ()

	distance (Vector3 $pos)

	distanceSquared (Vector3 $pos)

	maxPlainDistance ($x=0, $z=0)

	length ()

	lengthSquared ()

	normalize ()

	dot (Vector3 $v)

	cross (Vector3 $v)

	equals (Vector3 $v)

	getIntermediateWithXValue (Vector3 $v, $x)

	getIntermediateWithYValue (Vector3 $v, $y)

	getIntermediateWithZValue (Vector3 $v, $z)

	setComponents ($x, $y, $z)

	fromObjectAdd (Vector3 $pos, $x, $y, $z)

	__toString ()

Static Public Member Functions
static	getTotalXpRequirement (int $level)

static	getLevelXpRequirement (int $level)

static	getLevelFromXp (int $xp)

Static Public Member Functions inherited from Entity
static	init ()

static	createEntity ($type, Level $level, CompoundTag $nbt,... $args)

static	registerEntity ($className, $force=false)

Static Public Member Functions inherited from Location
static	fromObject (Vector3 $pos, Level $level=null, $yaw=0.0, $pitch=0.0)

Static Public Member Functions inherited from Position
static	fromObject (Vector3 $pos, Level $level=null)

Static Public Member Functions inherited from Vector3
static	getOppositeSide ($side)

static	createRandomDirection (Random $random)

Data Fields
const	DATA_PLAYER_FLAG_SLEEP = 1

const	DATA_PLAYER_FLAG_DEAD = 2

const	DATA_PLAYER_FLAGS = 27

const	DATA_PLAYER_BED_POSITION = 29

	$width = 0.6

	$length = 0.6

	$height = 1.8

	$eyeHeight = 1.62

Data Fields inherited from Creature
	$attackingTick = 0

Data Fields inherited from Entity
const	NETWORK_ID = -1

const	DATA_TYPE_BYTE = 0

const	DATA_TYPE_SHORT = 1

const	DATA_TYPE_INT = 2

const	DATA_TYPE_FLOAT = 3

const	DATA_TYPE_STRING = 4

const	DATA_TYPE_SLOT = 5

const	DATA_TYPE_POS = 6

const	DATA_TYPE_LONG = 7

const	DATA_TYPE_VECTOR3F = 8

const	DATA_FLAGS = 0

const	DATA_HEALTH = 1

const	DATA_VARIANT = 2

const	DATA_COLOR = 3

const	DATA_COLOUR = 3

const	DATA_NAMETAG = 4

const	DATA_OWNER_EID = 5

const	DATA_TARGET_EID = 6

const	DATA_AIR = 7

const	DATA_POTION_COLOR = 8

const	DATA_POTION_AMBIENT = 9

const	DATA_HURT_TIME = 11

const	DATA_HURT_DIRECTION = 12

const	DATA_PADDLE_TIME_LEFT = 13

const	DATA_PADDLE_TIME_RIGHT = 14

const	DATA_EXPERIENCE_VALUE = 15

const	DATA_MINECART_DISPLAY_BLOCK = 16

const	DATA_MINECART_DISPLAY_OFFSET = 17

const	DATA_MINECART_HAS_DISPLAY = 18

const	DATA_ENDERMAN_HELD_ITEM_ID = 23

const	DATA_ENDERMAN_HELD_ITEM_DAMAGE = 24

const	DATA_ENTITY_AGE = 25

const	DATA_FIREBALL_POWER_X = 30

const	DATA_FIREBALL_POWER_Y = 31

const	DATA_FIREBALL_POWER_Z = 32

const	DATA_POTION_AUX_VALUE = 37

const	DATA_LEAD_HOLDER_EID = 38

const	DATA_SCALE = 39

const	DATA_INTERACTIVE_TAG = 40

const	DATA_NPC_SKIN_ID = 41

const	DATA_URL_TAG = 42

const	DATA_MAX_AIR = 43

const	DATA_MARK_VARIANT = 44

const	DATA_BLOCK_TARGET = 48

const	DATA_WITHER_INVULNERABLE_TICKS = 49

const	DATA_WITHER_TARGET_1 = 50

const	DATA_WITHER_TARGET_2 = 51

const	DATA_WITHER_TARGET_3 = 52

const	DATA_BOUNDING_BOX_WIDTH = 54

const	DATA_BOUNDING_BOX_HEIGHT = 55

const	DATA_FUSE_LENGTH = 56

const	DATA_RIDER_SEAT_POSITION = 57

const	DATA_RIDER_ROTATION_LOCKED = 58

const	DATA_RIDER_MAX_ROTATION = 59

const	DATA_RIDER_MIN_ROTATION = 60

const	DATA_AREA_EFFECT_CLOUD_RADIUS = 61

const	DATA_AREA_EFFECT_CLOUD_WAITING = 62

const	DATA_AREA_EFFECT_CLOUD_PARTICLE_ID = 63

const	DATA_SHULKER_ATTACH_FACE = 65

const	DATA_SHULKER_ATTACH_POS = 67

const	DATA_TRADING_PLAYER_EID = 68

const	DATA_COMMAND_BLOCK_COMMAND = 71

const	DATA_COMMAND_BLOCK_LAST_OUTPUT = 72

const	DATA_COMMAND_BLOCK_TRACK_OUTPUT = 73

const	DATA_CONTROLLING_RIDER_SEAT_NUMBER = 74

const	DATA_STRENGTH = 75

const	DATA_MAX_STRENGTH = 76

const	DATA_FLAG_ONFIRE = 0

const	DATA_FLAG_SNEAKING = 1

const	DATA_FLAG_RIDING = 2

const	DATA_FLAG_SPRINTING = 3

const	DATA_FLAG_ACTION = 4

const	DATA_FLAG_INVISIBLE = 5

const	DATA_FLAG_TEMPTED = 6

const	DATA_FLAG_INLOVE = 7

const	DATA_FLAG_SADDLED = 8

const	DATA_FLAG_POWERED = 9

const	DATA_FLAG_IGNITED = 10

const	DATA_FLAG_BABY = 11

const	DATA_FLAG_CONVERTING = 12

const	DATA_FLAG_CRITICAL = 13

const	DATA_FLAG_CAN_SHOW_NAMETAG = 14

const	DATA_FLAG_ALWAYS_SHOW_NAMETAG = 15

const	DATA_FLAG_IMMOBILE = 16

const	DATA_FLAG_NO_AI = 16

const	DATA_FLAG_SILENT = 17

const	DATA_FLAG_WALLCLIMBING = 18

const	DATA_FLAG_CAN_CLIMB = 19

const	DATA_FLAG_SWIMMER = 20

const	DATA_FLAG_CAN_FLY = 21

const	DATA_FLAG_RESTING = 22

const	DATA_FLAG_SITTING = 23

const	DATA_FLAG_ANGRY = 24

const	DATA_FLAG_INTERESTED = 25

const	DATA_FLAG_CHARGED = 26

const	DATA_FLAG_TAMED = 27

const	DATA_FLAG_LEASHED = 28

const	DATA_FLAG_SHEARED = 29

const	DATA_FLAG_GLIDING = 30

const	DATA_FLAG_ELDER = 31

const	DATA_FLAG_MOVING = 32

const	DATA_FLAG_BREATHING = 33

const	DATA_FLAG_CHESTED = 34

const	DATA_FLAG_STACKABLE = 35

const	DATA_FLAG_SHOWBASE = 36

const	DATA_FLAG_REARING = 37

const	DATA_FLAG_VIBRATING = 38

const	DATA_FLAG_IDLING = 39

const	DATA_FLAG_EVOKER_SPELL = 40

const	DATA_FLAG_CHARGE_ATTACK = 41

const	DATA_FLAG_LINGER = 45

const	SOUTH = 0

const	WEST = 1

const	NORTH = 2

const	EAST = 3

	$passenger = null

	$vehicle = null

	$chunk

	$lastX = null

	$lastY = null

	$lastZ = null

	$motionX

	$motionY

	$motionZ

	$temporalVector

	$lastMotionX

	$lastMotionY

	$lastMotionZ

	$lastYaw

	$lastPitch

	$boundingBox

	$onGround

	$inBlock = false

	$positionChanged

	$motionChanged

	$deadTicks = 0

	$height

	$eyeHeight = null

	$width

	$length

	$keepMovement = false

	$fallDistance = 0

	$ticksLived = 0

	$lastUpdate

	$maxFireTicks

	$fireTicks = 0

	$namedtag

	$canCollide = true

	$isCollided = false

	$isCollidedHorizontally = false

	$isCollidedVertically = false

	$noDamageTicks

	$closed = false

	$dropExp = [0, 0]

Data Fields inherited from Location
	$yaw

	$pitch

Data Fields inherited from Position
	$level = null

Data Fields inherited from Vector3
const	SIDE_DOWN = 0

const	SIDE_UP = 1

const	SIDE_NORTH = 2

const	SIDE_SOUTH = 3

const	SIDE_WEST = 4

const	SIDE_EAST = 5

	$x

	$y

	$z

Protected Member Functions
	initEntity ()

	addAttributes ()

Protected Member Functions inherited from Living
	initEntity ()

Protected Member Functions inherited from Entity
	recalculateEffectColor ()

	initEntity ()

	addAttributes ()

	checkObstruction ($x, $y, $z)

	updateMovement ()

	updateFallState ($distanceThisTick, $onGround)

	switchLevel (Level $targetLevel)

	checkGroundState ($movX, $movY, $movZ, $dx, $dy, $dz)

	checkBlockCollision ()

	checkChunks ()

Protected Attributes
	$inventory

	$enderChestInventory

	$floatingInventory

	$transactionQueue = null

	$uuid

	$rawUUID

	$skinId

	$skin

	$foodTickTimer = 0

	$totalXp = 0

	$xpSeed

	$xpCooldown = 0

Protected Attributes inherited from Living
	$gravity = 0.08

	$drag = 0.02

	$attackTime = 0

	$invisible = false

Protected Attributes inherited from Entity
	$hasSpawned = []

	$effects = []

	$id

	$dataFlags = 0

	$dataProperties

	$lastDamageCause = null

	$age = 0

	$ySize = 0

	$stepHeight = 0

	$isStatic = false

	$justCreated

	$attributeMap

	$gravity

	$drag

	$server

	$timings

	$isPlayer = false

	$linkedEntity = null

	$linkedType = null

	$riding = null

	$activatedPressurePlates = []

Additional Inherited Members
Static Public Attributes inherited from Entity
static	$entityCount = 1

Member Function Documentation

◆ addAttributes()

addAttributes ( )

protected

                                       {
         parent::addAttributes();
 
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::SATURATION));
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::EXHAUSTION));
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::HUNGER));
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::EXPERIENCE_LEVEL));
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::EXPERIENCE));
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::HEALTH));
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::MOVEMENT_SPEED));
         $this->attributeMap->addAttribute(Attribute::getAttribute(Attribute::ABSORPTION));
     }

◆ addFood()

addFood ( float $amount )

Parameters

float $amount

                                           {
         $attr = $this->attributeMap->getAttribute(Attribute::HUNGER);
         $amount += $attr->getValue();
         $amount = max(min($amount, $attr->getMaxValue()), $attr->getMinValue());
         $this->setFood($amount);
     }

◆ addSaturation()

addSaturation ( float $amount )

Parameters

float $amount

                                                 {
         $attr = $this->attributeMap->getAttribute(Attribute::SATURATION);
         $attr->setValue($attr->getValue() + $amount, true);
     }

◆ addXp()

addXp	(	int	$xp,
		bool	$syncLevel = `false`
	)

Parameters

int	$xp
bool	$syncLevel

Returns: bool

                                                             : bool{
         return $this->setTotalXp($this->totalXp + $xp, $syncLevel);
     }

◆ addXpLevel()

addXpLevel ( int $level )

Parameters

int $level

Returns: bool

                                            : bool{
         return $this->setXpLevel($this->getXpLevel() + $level);
     }

◆ canPickupXp()

canPickupXp ( )

Returns: bool

                                   : bool{
         return microtime(true) - $this->xpCooldown > 0.5;
     }

◆ close()

close ( )

                            {
         if(!$this->closed){
             if($this->getFloatingInventory() instanceof FloatingInventory){
                 foreach($this->getFloatingInventory()->getContents() as $craftingItem){
                     $this->level->dropItem($this, $craftingItem);
                 }
             }else{
                 $this->server->getLogger()->debug("Attempted to drop a null crafting inventory\n");
             }
             if(!($this instanceof Player) or $this->loggedIn){
                 foreach($this->inventory->getViewers() as $viewer){
                     $viewer->removeWindow($this->inventory);
                 }
             }
             parent::close();
         }
     }

◆ entityBaseTick()

entityBaseTick	(	$tickDiff = `1`,
		$EnchantL = `0`
	)

Parameters

int	$tickDiff
int	$EnchantL

Returns: bool

                                                                 {
         if($this->getInventory() instanceof PlayerInventory){
             $EnchantL = $this->getInventory()->getHelmet()->getEnchantmentLevel(Enchantment::TYPE_WATER_BREATHING);
         }
         $hasUpdate = parent::entityBaseTick($tickDiff, $EnchantL);
 
         if($this->isAlive()){
             $food = $this->getFood();
             $health = $this->getHealth();
             if($food >= 18){
                 $this->foodTickTimer++;
                 if($this->foodTickTimer >= 80 and $health < $this->getMaxHealth()){
                     $this->heal(1, new EntityRegainHealthEvent($this, 1, EntityRegainHealthEvent::CAUSE_SATURATION));
                     $this->exhaust(3.0, PlayerExhaustEvent::CAUSE_HEALTH_REGEN);
                     $this->foodTickTimer = 0;
 
                 }
             }elseif($food === 0){
                 $this->foodTickTimer++;
                 if($this->foodTickTimer >= 80){
                     $diff = $this->server->getDifficulty();
                     $can = false;
                     if($diff === 1){
                         $can = $health > 10;
                     }elseif($diff === 2){
                         $can = $health > 1;
                     }elseif($diff === 3){
                         $can = true;
                     }
                     if($can){
                         $this->attack(1, new EntityDamageEvent($this, EntityDamageEvent::CAUSE_STARVATION, 1));
                     }
                 }
             }
             if($food <= 6){
                 if($this->isSprinting()){
                     $this->setSprinting(false);
                 }
             }
         }
 
         return $hasUpdate;
     }

◆ exhaust()

exhaust	(	float	$amount,
		int	$cause = `PlayerExhaustEvent::CAUSE_CUSTOM`
	)

Increases a human's exhaustion level.

Parameters

float	$amount
int	$cause

Returns: float the amount of exhaustion level increased

                                                                                         : float{
         $this->server->getPluginManager()->callEvent($ev = new PlayerExhaustEvent($this, $amount, $cause));
         if($ev->isCancelled()){
             return 0.0;
         }
 
         $exhaustion = $this->getExhaustion();
         $exhaustion += $ev->getAmount();
 
         while($exhaustion >= 4.0){
             $exhaustion -= 4.0;
 
             $saturation = $this->getSaturation();
             if($saturation > 0){
                 $saturation = max(0, $saturation - 1.0);
                 $this->setSaturation($saturation);
             }else{
                 $food = $this->getFood();
                 if($food > 0){
                     $food--;
                     $this->setFood($food);
                 }
             }
         }
         $this->setExhaustion($exhaustion);
 
         return $ev->getAmount();
     }

◆ getAbsorption()

getAbsorption ( )

Returns: int

                                     : int{
         return $this->attributeMap->getAttribute(Attribute::ABSORPTION)->getValue();
     }

◆ getDrops()

getDrops ( )

Returns: array

                               {
         $drops = [];
         if($this->inventory !== null){
             foreach($this->inventory->getContents() as $item){
                 $drops[] = $item;
             }
         }
 
         return $drops;
     }

◆ getEnderChestInventory()

getEnderChestInventory ( )

Returns: EnderChestInventory

                                             {
         return $this->enderChestInventory;
     }

◆ getExhaustion()

getExhaustion ( )

Returns: float

                                     : float{
         return $this->attributeMap->getAttribute(Attribute::EXHAUSTION)->getValue();
     }

◆ getFilledXp()

getFilledXp ( )

Returns: int

                                   : int{
         return self::getLevelXpRequirement($this->getXpLevel()) * $this->getXpProgress();
     }

◆ getFloatingInventory()

getFloatingInventory ( )

Returns: FloatingInventory

                                           {
         return $this->floatingInventory;
     }

◆ getFood()

getFood ( )

Returns: float

                               : float{
         return $this->attributeMap->getAttribute(Attribute::HUNGER)->getValue();
     }

◆ getInventory()

getInventory ( )

Returns: PlayerInventory

Implements InventoryHolder.

                                   {
         return $this->inventory;
     }

◆ getLevelFromXp()

static getLevelFromXp ( int $xp )

static

Converts a quantity of exp into a level and a progress percentage

Parameters

int $xp

Returns: int[]

These values are correct up to and including level 16

Modify the coefficients to fit the relevant equation

Levels 16-31

Level 32+

                                                    : array{
         $xp &= 0x7fffffff;
 
         $a = 1;
         $b = 6;
         $c = -$xp;
         if($xp > self::getTotalXpRequirement(16)){
             if($xp <= self::getTotalXpRequirement(31)){
                 $a = 2.5;
                 $b = -40.5;
                 $c += 360;
             }else{
                 $a = 4.5;
                 $b = -162.5;
                 $c += 2220;
             }
         }
 
         $answer = max(Math::solveQuadratic($a, $b, $c)); //Use largest result value
         $level = floor($answer);
         $progress = $answer - $level;
         return [$level, $progress];
     }

◆ getLevelXpRequirement()

static getLevelXpRequirement ( int $level )

static

Returns the amount of exp required to complete the specified level.

Parameters

int $level

Returns: int

                                                              : int{
         if($level <= 16){
             return (2 * $level) + 7;
         }elseif($level <= 31){
             return (5 * $level) - 38;
         }elseif($level <= 21863){
             return (9 * $level) - 158;
         }
         return PHP_INT_MAX;
     }

◆ getMaxFood()

getMaxFood ( )

Returns: float

                                  : float{
         return $this->attributeMap->getAttribute(Attribute::HUNGER)->getMaxValue();
     }

◆ getName()

getName ( )

Returns: string

                              {
         return $this->getNameTag();
     }

◆ getRawUniqueId()

getRawUniqueId ( )

Returns: string

                                     {
         return $this->rawUUID;
     }

◆ getRemainderXp()

getRemainderXp ( )

Returns: int

                                      : int{
         return self::getLevelXpRequirement($this->getXpLevel()) - $this->getFilledXp();
     }

◆ getSaturation()

getSaturation ( )

Returns: float

                                     : float{
         return $this->attributeMap->getAttribute(Attribute::SATURATION)->getValue();
     }

◆ getSkinData()

getSkinData ( )

Returns: mixed

                                  {
         return $this->skin;
     }

◆ getSkinId()

getSkinId ( )

Returns: mixed

                                {
         return $this->skinId;
     }

◆ getTotalXp()

getTotalXp ( )

Returns: int

                                  : int{
         return $this->totalXp;
     }

◆ getTotalXpRequirement()

static getTotalXpRequirement ( int $level )

static

Returns the total amount of exp required to reach the specified level.

Parameters

int $level

Returns: int

                                                              : int{
         if($level <= 16){
             return ($level ** 2) + (6 * $level);
         }elseif($level <= 31){
             return (2.5 * ($level ** 2)) - (40.5 * $level) + 360;
         }elseif($level <= 21863){
             return (4.5 * ($level ** 2)) - (162.5 * $level) + 2220;
         }
         return PHP_INT_MAX; //prevent float returns for invalid levels on 32-bit systems
     }

◆ getTransactionQueue()

getTransactionQueue ( )

Returns: SimpleTransactionQueue

                                          {
         //Is creating the transaction queue ondemand a good idea? I think only if it's destroyed afterwards. hmm...
         if($this->transactionQueue === null){
             //Potential for crashes here if a plugin attempts to use this, say for an NPC plugin or something...
             $this->transactionQueue = new SimpleTransactionQueue($this);
         }
         return $this->transactionQueue;
     }

◆ getUniqueId()

getUniqueId ( )

Returns: UUID|null

                                  {
         return $this->uuid;
     }

◆ getXpLevel()

getXpLevel ( )

Returns: int

                                  : int{
         return (int) $this->attributeMap->getAttribute(Attribute::EXPERIENCE_LEVEL)->getValue();
     }

◆ getXpProgress()

getXpProgress ( )

Returns: float

                                     : float{
         return $this->attributeMap->getAttribute(Attribute::EXPERIENCE)->getValue();
     }

◆ getXpSeed()

getXpSeed ( )

Returns: int

                                 : int{
         //TODO: use this for randomizing enchantments in enchanting tables
         return $this->xpSeed;
     }

◆ initEntity()

initEntity ( )

protected

                                    {
         $this->setDataFlag(self::DATA_PLAYER_FLAGS, self::DATA_PLAYER_FLAG_SLEEP, false, self::DATA_TYPE_BYTE);
         $this->setDataProperty(self::DATA_PLAYER_BED_POSITION, self::DATA_TYPE_POS, [0, 0, 0], false);
 
         $inventoryContents = ($this->namedtag->Inventory ?? null);
         $this->inventory = new PlayerInventory($this, $inventoryContents);
         $this->enderChestInventory = new EnderChestInventory($this, ($this->namedtag->EnderChestInventory ?? null));
 
         //Virtual inventory for desktop GUI crafting and anti-cheat transaction processing
         $this->floatingInventory = new FloatingInventory($this);
 
         if($this instanceof Player){
             $this->addWindow($this->inventory, 0);
         }else{
             if(isset($this->namedtag->NameTag)){
                 $this->setNameTag($this->namedtag["NameTag"]);
             }
 
             if(isset($this->namedtag->Skin) and $this->namedtag->Skin instanceof CompoundTag){
                 $this->setSkin($this->namedtag->Skin["Data"], $this->namedtag->Skin["Name"]);
             }
 
             $this->uuid = UUID::fromData($this->getId(), $this->getSkinData(), $this->getNameTag());
         }
 
         parent::initEntity();
 
         if(!isset($this->namedtag->foodLevel) or !($this->namedtag->foodLevel instanceof IntTag)){
             $this->namedtag->foodLevel = new IntTag("foodLevel", $this->getFood());
         }else{
             $this->setFood($this->namedtag["foodLevel"]);
         }
 
         if(!isset($this->namedtag->foodExhaustionLevel) or !($this->namedtag->foodExhaustionLevel instanceof IntTag)){
             $this->namedtag->foodExhaustionLevel = new FloatTag("foodExhaustionLevel", $this->getExhaustion());
         }else{
             $this->setExhaustion($this->namedtag["foodExhaustionLevel"]);
         }
 
         if(!isset($this->namedtag->foodSaturationLevel) or !($this->namedtag->foodSaturationLevel instanceof IntTag)){
             $this->namedtag->foodSaturationLevel = new FloatTag("foodSaturationLevel", $this->getSaturation());
         }else{
             $this->setSaturation($this->namedtag["foodSaturationLevel"]);
         }
 
         if(!isset($this->namedtag->foodTickTimer) or !($this->namedtag->foodTickTimer instanceof IntTag)){
             $this->namedtag->foodTickTimer = new IntTag("foodTickTimer", $this->foodTickTimer);
         }else{
             $this->foodTickTimer = $this->namedtag["foodTickTimer"];
         }
 
         if(!isset($this->namedtag->XpLevel) or !($this->namedtag->XpLevel instanceof IntTag)){
             $this->namedtag->XpLevel = new IntTag("XpLevel", 0);
         }
         $this->setXpLevel($this->namedtag["XpLevel"]);
 
         if(!isset($this->namedtag->XpP) or !($this->namedtag->XpP instanceof FloatTag)){
             $this->namedtag->XpP = new FloatTag("XpP", 0);
         }
         $this->setXpProgress($this->namedtag["XpP"]);
 
         if(!isset($this->namedtag->XpTotal) or !($this->namedtag->XpTotal instanceof IntTag)){
             $this->namedtag->XpTotal = new IntTag("XpTotal", 0);
         }
         $this->totalXp = $this->namedtag["XpTotal"];
 
         if(!isset($this->namedtag->XpSeed) or !($this->namedtag->XpSeed instanceof IntTag)){
             $this->namedtag->XpSeed = new IntTag("XpSeed", mt_rand(PHP_INT_MIN, PHP_INT_MAX));
         }
         $this->xpSeed = $this->namedtag["XpSeed"];
     }

◆ recalculateXpProgress()

recalculateXpProgress ( )

Returns: float

                                             : float{
         $this->setXpProgress($progress = $this->getRemainderXp() / self::getLevelXpRequirement($this->getXpLevel()));
         return $progress;
     }

◆ resetXpCooldown()

resetXpCooldown ( )

                                      {
         $this->xpCooldown = microtime(true);
     }

◆ saveNBT()

saveNBT ( )

                              {
         parent::saveNBT();
         $this->namedtag->Inventory = new ListTag("Inventory", []);
         $this->namedtag->Inventory->setTagType(NBT::TAG_Compound);
         if($this->inventory !== null){
 
             //Hotbar
             for($slot = 0; $slot < $this->inventory->getHotbarSize(); ++$slot){
                 $inventorySlotIndex = $this->inventory->getHotbarSlotIndex($slot);
                 $item = $this->inventory->getItem($inventorySlotIndex);
                 $tag = $item->nbtSerialize($slot);
                 $tag->TrueSlot = new ByteTag("TrueSlot", $inventorySlotIndex);
                 $this->namedtag->Inventory[$slot] = $tag;
             }
 
             //Normal inventory
             $slotCount = $this->inventory->getSize() + $this->inventory->getHotbarSize();
             for($slot = $this->inventory->getHotbarSize(); $slot < $slotCount; ++$slot){
                 $item = $this->inventory->getItem($slot - $this->inventory->getHotbarSize());
                 //As NBT, real inventory slots are slots 9-44, NOT 0-35
                 $this->namedtag->Inventory[$slot] = $item->nbtSerialize($slot);
             }
 
             //Armour
             for($slot = 100; $slot < 104; ++$slot){
                 $item = $this->inventory->getItem($this->inventory->getSize() + $slot - 100);
                 if($item instanceof ItemItem and $item->getId() !== ItemItem::AIR){
                     $this->namedtag->Inventory[$slot] = $item->nbtSerialize($slot);
                 }
             }
         }
 
         $this->namedtag->EnderChestInventory = new ListTag("EnderChestInventory", []);
         $this->namedtag->Inventory->setTagType(NBT::TAG_Compound);
         if($this->enderChestInventory !== null){
             for($slot = 0; $slot < $this->enderChestInventory->getSize(); $slot++){
                 if(($item = $this->enderChestInventory->getItem($slot)) instanceof ItemItem){
                     $this->namedtag->EnderChestInventory[$slot] = $item->nbtSerialize($slot);
                 }
             }
         }
 
         if(strlen($this->getSkinData()) > 0){
             $this->namedtag->Skin = new CompoundTag("Skin", [
                 "Data" => new StringTag("Data", $this->getSkinData()),
                 "Name" => new StringTag("Name", $this->getSkinId())
             ]);
         }
 
         //Xp
         $this->namedtag->XpLevel = new IntTag("XpLevel", $this->getXpLevel());
         $this->namedtag->XpTotal = new IntTag("XpTotal", $this->getTotalXp());
         $this->namedtag->XpP = new FloatTag("XpP", $this->getXpProgress());
         $this->namedtag->XpSeed = new IntTag("XpSeed", $this->getXpSeed());
 
         //Food
         $this->namedtag->foodLevel = new IntTag("foodLevel", $this->getFood());
         $this->namedtag->foodExhaustionLevel = new FloatTag("foodExhaustionLevel", $this->getExhaustion());
         $this->namedtag->foodSaturationLevel = new FloatTag("foodSaturationLevel", $this->getSaturation());
         $this->namedtag->foodTickTimer = new IntTag("foodTickTimer", $this->foodTickTimer);
     }

◆ setAbsorption()

setAbsorption ( int $absorption )

Parameters

int $absorption

                                                   {
         $this->attributeMap->getAttribute(Attribute::ABSORPTION)->setValue($absorption);
     }

◆ setExhaustion()

setExhaustion ( float $exhaustion )

WARNING: This method does not check if exhausted and does not consume saturation/food. Use Human::exhaust() for this purpose.

Parameters

float $exhaustion

                                                     {
         $this->attributeMap->getAttribute(Attribute::EXHAUSTION)->setValue($exhaustion);
     }

◆ setFood()

setFood ( float $new )

WARNING: This method does not check if full and may throw an exception if out of bounds. Use Human::addFood() for this purpose

Parameters

float $new

Exceptions

                                        {
         $attr = $this->attributeMap->getAttribute(Attribute::HUNGER);
         $old = $attr->getValue();
         $attr->setValue($new);
         // ranges: 18-20 (regen), 7-17 (none), 1-6 (no sprint), 0 (health depletion)
         foreach([17, 6, 0] as $bound){
             if(($old > $bound) !== ($new > $bound)){
                 $reset = true;
             }
         }
         if(isset($reset)){
             $this->foodTickTimer = 0;
         }
 
     }

◆ setSaturation()

setSaturation ( float $saturation )

WARNING: This method does not check if saturated and may throw an exception if out of bounds. Use Human::addSaturation() for this purpose

Parameters

float $saturation

Exceptions

                                                     {
         $this->attributeMap->getAttribute(Attribute::SATURATION)->setValue($saturation);
     }

◆ setSkin()

setSkin	(	$str,
		$skinId
	)

Parameters

string	$str
string	$skinId

                                           {
         $this->skin = $str;
         $this->skinId = $skinId;
     }

◆ setTotalXp()

setTotalXp	(	int	$xp,
		bool	$syncLevel = `false`
	)

Changes the total exp of a player

Parameters

int	$xp
bool	$syncLevel	This will reset the level to be in sync with the total. Usually you don't want to do this, because it'll mess up use of xp in anvils and enchanting tables.

Returns: bool

                                                                  : bool{
         $xp &= 0x7fffffff;
         if($xp === $this->totalXp){
             return false;
         }
         if(!$syncLevel){
             $level = $this->getXpLevel();
             $diff = $xp - $this->totalXp + $this->getFilledXp();
             if($diff > 0){ //adding xp
                 while($diff > ($v = self::getLevelXpRequirement($level))){
                     $diff -= $v;
                     if(++$level >= 21863){
                         $diff = $v; //fill exp bar
                         break;
                     }
                 }
             }else{ //taking xp
                 while($diff < ($v = self::getLevelXpRequirement($level - 1))){
                     $diff += $v;
                     if(--$level <= 0){
                         $diff = 0;
                         break;
                     }
                 }
             }
             $progress = ($diff / $v);
         }else{
             $values = self::getLevelFromXp($xp);
             $level = $values[0];
             $progress = $values[1];
         }
 
         $this->server->getPluginManager()->callEvent($ev = new PlayerExperienceChangeEvent($this, $level, $progress));
         if(!$ev->isCancelled()){
             $this->totalXp = $xp;
             $this->setXpLevel($ev->getExpLevel());
             $this->setXpProgress($ev->getProgress());
             return true;
         }
         return false;
     }

◆ setXpLevel()

setXpLevel ( int $level )

Parameters

int $level

Returns: bool

                                            : bool{
         $this->server->getPluginManager()->callEvent($ev = new PlayerExperienceChangeEvent($this, $level, $this->getXpProgress()));
         if(!$ev->isCancelled()){
             $this->attributeMap->getAttribute(Attribute::EXPERIENCE_LEVEL)->setValue($ev->getExpLevel());
             return true;
         }
         return false;
     }

◆ setXpProgress()

setXpProgress ( float $progress )

Parameters

float $progress

Returns: bool

                                                    : bool{
         $this->attributeMap->getAttribute(Attribute::EXPERIENCE)->setValue($progress);
         return true;
     }

◆ spawnTo()

spawnTo ( Player $player )

Parameters

Player $player

                                            {
         if(strlen($this->skin) < 64 * 32 * 4){
             $e = new \InvalidStateException((new \ReflectionClass($this))->getShortName() . " must have a valid skin set");
             $this->server->getLogger()->logException($e);
             $this->close();
         }elseif($player !== $this and !isset($this->hasSpawned[$player->getLoaderId()])){
             $this->hasSpawned[$player->getLoaderId()] = $player;
 
             if(!($this instanceof Player)){
                 $this->server->updatePlayerListData($this->getUniqueId(), $this->getId(), $this->getName(), $this->skinId, $this->skin, [$player]);
             }
 
             $pk = new AddPlayerPacket();
             $pk->uuid = $this->getUniqueId();
             $pk->username = $this->getName();
             $pk->eid = $this->getId();
             $pk->x = $this->x;
             $pk->y = $this->y;
             $pk->z = $this->z;
             $pk->speedX = $this->motionX;
             $pk->speedY = $this->motionY;
             $pk->speedZ = $this->motionZ;
             $pk->yaw = $this->yaw;
             $pk->pitch = $this->pitch;
             $pk->item = $this->getInventory()->getItemInHand();
             $pk->metadata = $this->dataProperties;
             $player->dataPacket($pk);
 
             $this->sendLinkedData();
 
             $this->inventory->sendArmorContents($player);
 
             if(!($this instanceof Player)){
                 $this->server->removePlayerListData($this->getUniqueId(), [$player]);
             }
         }
     }

◆ takeXp()

takeXp	(	int	$xp,
		bool	$syncLevel = `false`
	)

Parameters

int	$xp
bool	$syncLevel

Returns: bool

                                                              : bool{
         return $this->setTotalXp($this->totalXp - $xp, $syncLevel);
     }

◆ takeXpLevel()

takeXpLevel ( int $level )

Parameters

int $level

Returns: bool

                                             : bool{
         return $this->setXpLevel($this->getXpLevel() - $level);
     }

Field Documentation

◆ $enderChestInventory

$enderChestInventory

protected

◆ $eyeHeight

$eyeHeight = 1.62

◆ $floatingInventory

$floatingInventory

protected

◆ $foodTickTimer

$foodTickTimer = 0

protected

◆ $height

$height = 1.8

◆ $inventory

$inventory

protected

◆ $length

$length = 0.6

◆ $rawUUID

$rawUUID

protected

◆ $skin

$skin

protected

◆ $skinId

$skinId

protected

◆ $totalXp

$totalXp = 0

protected

◆ $transactionQueue

$transactionQueue = null

protected

◆ $uuid

$uuid

protected

◆ $width

$width = 0.6

◆ $xpCooldown

$xpCooldown = 0

protected

◆ $xpSeed

$xpSeed

protected

◆ DATA_PLAYER_BED_POSITION

const DATA_PLAYER_BED_POSITION = 29

◆ DATA_PLAYER_FLAG_DEAD

const DATA_PLAYER_FLAG_DEAD = 2

◆ DATA_PLAYER_FLAG_SLEEP

const DATA_PLAYER_FLAG_SLEEP = 1

◆ DATA_PLAYER_FLAGS

const DATA_PLAYER_FLAGS = 27

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

src/pocketmine/entity/Human.php

Public Member Functions

Static Public Member Functions

Data Fields

Protected Member Functions

Protected Attributes

Additional Inherited Members

Member Function Documentation

◆ addAttributes()

◆ addFood()

◆ addSaturation()

◆ addXp()

◆ addXpLevel()

◆ canPickupXp()

◆ close()

◆ entityBaseTick()

◆ exhaust()

◆ getAbsorption()

◆ getDrops()

◆ getEnderChestInventory()

◆ getExhaustion()

◆ getFilledXp()

◆ getFloatingInventory()

◆ getFood()

◆ getInventory()

◆ getLevelFromXp()

◆ getLevelXpRequirement()

◆ getMaxFood()

◆ getName()

◆ getRawUniqueId()

◆ getRemainderXp()

◆ getSaturation()

◆ getSkinData()

◆ getSkinId()

◆ getTotalXp()

◆ getTotalXpRequirement()

◆ getTransactionQueue()

◆ getUniqueId()

◆ getXpLevel()

◆ getXpProgress()

◆ getXpSeed()

◆ initEntity()

◆ recalculateXpProgress()

◆ resetXpCooldown()

◆ saveNBT()

◆ setAbsorption()

◆ setExhaustion()

◆ setFood()

◆ setSaturation()

◆ setSkin()

◆ setTotalXp()

◆ setXpLevel()

◆ setXpProgress()

◆ spawnTo()

◆ takeXp()

◆ takeXpLevel()

Field Documentation

◆ $enderChestInventory

◆ $eyeHeight

◆ $floatingInventory

◆ $foodTickTimer

◆ $height

◆ $inventory

◆ $length

◆ $rawUUID

◆ $skin

◆ $skinId

◆ $totalXp

◆ $transactionQueue

◆ $uuid

◆ $width

◆ $xpCooldown

◆ $xpSeed

◆ DATA_PLAYER_BED_POSITION

◆ DATA_PLAYER_FLAG_DEAD

◆ DATA_PLAYER_FLAG_SLEEP

◆ DATA_PLAYER_FLAGS