/**
* Returns the entities near the current one inside the AxisAlignedBB
*
* @param AxisAlignedBB $bb
* @param Entity $entity
*
* @return Entity[]
*/
public function getNearbyEntities(AxisAlignedBB $bb, Entity $entity = null)
{
$nearby = [];
$minX = Math::floorFloat(($bb->minX - 2) / 16);
$maxX = Math::ceilFloat(($bb->maxX + 2) / 16);
$minZ = Math::floorFloat(($bb->minZ - 2) / 16);
$maxZ = Math::ceilFloat(($bb->maxZ + 2) / 16);
for ($x = $minX; $x <= $maxX; ++$x) {
for ($z = $minZ; $z <= $maxZ; ++$z) {
foreach ($this->getChunkEntities($x, $z) as $ent) {
if ($ent !== $entity and $ent->boundingBox->intersectsWith($bb)) {
$nearby[] = $ent;
}
}
}
}
return $nearby;
}
public function isInsideOfWater()
{
$block = $this->level->getBlock($this->temporalVector->setComponents(Math::floorFloat($this->x), Math::floorFloat($y = $this->y + $this->getEyeHeight()), Math::floorFloat($this->z)));
if ($block instanceof Water) {
$f = $block->y + 1 - ($block->getFluidHeightPercent() - 0.1111111);
return $y < $f;
}
return false;
}
public function getBlocksAround()
{
if ($this->blocksAround === null) {
$minX = Math::floorFloat($this->boundingBox->minX);
$minY = Math::floorFloat($this->boundingBox->minY);
$minZ = Math::floorFloat($this->boundingBox->minZ);
$maxX = Math::ceilFloat($this->boundingBox->maxX);
$maxY = Math::ceilFloat($this->boundingBox->maxY);
$maxZ = Math::ceilFloat($this->boundingBox->maxZ);
$this->blocksAround = [];
for ($z = $minZ; $z <= $maxZ; ++$z) {
for ($x = $minX; $x <= $maxX; ++$x) {
for ($y = $minY; $y <= $maxY; ++$y) {
$block = $this->level->getBlock($this->temporalVector->setComponents($x, $y, $z));
if ($block->hasEntityCollision()) {
$this->blocksAround[] = $block;
}
}
}
}
}
return $this->blocksAround;
}
protected function checkBlockCollision()
{
$minX = Math::floorFloat($this->boundingBox->minX + 0.001);
$minY = Math::floorFloat($this->boundingBox->minY + 0.001);
$minZ = Math::floorFloat($this->boundingBox->minZ + 0.001);
$maxX = Math::floorFloat($this->boundingBox->maxX - 0.001);
$maxY = Math::floorFloat($this->boundingBox->maxY - 0.001);
$maxZ = Math::floorFloat($this->boundingBox->maxZ - 0.001);
$vector = new Vector3(0, 0, 0);
$v = new Vector3(0, 0, 0);
for ($v->z = $minZ; $v->z <= $maxZ; ++$v->z) {
for ($v->x = $minX; $v->x <= $maxX; ++$v->x) {
for ($v->y = $minY; $v->y <= $maxY; ++$v->y) {
$block = $this->level->getBlock($v);
if ($block->hasEntityCollision()) {
$block->onEntityCollide($this);
if (!$this instanceof Player) {
$block->addVelocityToEntity($this, $vector);
}
}
}
}
}
if (!$this instanceof Player and $vector->length() > 0) {
$vector = $vector->normalize();
$d = 0.014;
$this->motionX += $vector->x * $d;
$this->motionY += $vector->y * $d;
$this->motionZ += $vector->z * $d;
}
}
/**
* Converts a quantity of exp into a level and a progress percentage
*
* @param int $xp
*
* @return int[]
*/
public static function getLevelFromXp(int $xp) : array
{
$xp &= 0x7fffffff;
/** These values are correct up to and including level 16 */
$a = 1;
$b = 6;
$c = -$xp;
if ($xp > self::getTotalXpRequirement(16)) {
/** Modify the coefficients to fit the relevant equation */
if ($xp <= self::getTotalXpRequirement(31)) {
/** Levels 16-31 */
$a = 2.5;
$b = -40.5;
$c += 360;
} else {
/** Level 32+ */
$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];
}
public function onTick()
{
foreach ($this->getServer()->getOnlinePlayers() as $p) {
if ($p->hasPermission("debe.damageblock.inv")) {
continue;
}
$bb = $p->getBoundingBox();
$minX = Math::floorFloat($bb->minX - 0.001);
$minY = Math::floorFloat($bb->minY - 0.001);
$minZ = Math::floorFloat($bb->minZ - 0.001);
$maxX = Math::floorFloat($bb->maxX + 0.001);
$maxY = Math::floorFloat($bb->maxY + 0.001);
$maxZ = Math::floorFloat($bb->maxZ + 0.001);
$block = [];
$damage = 0;
for ($z = $minZ; $z <= $maxZ; ++$z) {
for ($x = $minX; $x <= $maxX; ++$x) {
for ($y = $minY; $y <= $maxY; ++$y) {
$getDamage = $this->getDamage($p->getLevel()->getBlock(new Vector3($x, $y, $z)));
if (!in_array($getDamage[1], $block)) {
$damage += $getDamage[0];
$block[] = $getDamage[1];
}
}
}
}
if ($damage !== 0) {
$p->attack($damage);
}
}
}
public function updateMove()
{
if (!$this->isMovement()) {
return null;
}
/** @var Vector3 $target */
if ($this->attacker instanceof Entity) {
if ($this->atkTime == 16) {
$target = $this->attacker;
$x = $target->x - $this->x;
$z = $target->z - $this->z;
$diff = abs($x) + abs($z);
$this->motionX = -0.5 * ($diff == 0 ? 0 : $x / $diff);
$this->motionZ = -0.5 * ($diff == 0 ? 0 : $z / $diff);
--$this->atkTime;
}
$y = [11 => 0.3, 12 => 0.3, 13 => 0.4, 14 => 0.4, 15 => 0.5, 16 => 0.5];
$this->move($this->motionX, isset($y[$this->atkTime]) ? $y[$this->atkTime] : -0.2, $this->motionZ);
if (--$this->atkTime <= 0) {
$this->attacker = null;
$this->motionX = 0;
$this->motionY = 0;
$this->motionZ = 0;
}
return null;
}
$before = $this->baseTarget;
$this->checkTarget();
if ($this->baseTarget instanceof Creature or $before !== $this->baseTarget) {
$x = $this->baseTarget->x - $this->x;
$y = $this->baseTarget->y - $this->y;
$z = $this->baseTarget->z - $this->z;
if ($this->stayTime > 0 || $x ** 2 + $z ** 2 < 0.5) {
$this->motionX = 0;
$this->motionZ = 0;
} else {
$diff = abs($x) + abs($z);
$this->motionX = $this->speed * 0.15 * ($x / $diff);
$this->motionZ = $this->speed * 0.15 * ($z / $diff);
}
//$this->yaw = rad2deg(atan2($z, $x) - M_PI_2);
$this->yaw = -atan2($this->motionX, $this->motionZ) * 180 / M_PI;
$this->pitch = $y == 0 ? 0 : rad2deg(-atan2($y, sqrt($x ** 2 + $z ** 2)));
}
$target = $this->mainTarget != null ? $this->mainTarget : $this->baseTarget;
if ($this->stayTime > 0) {
--$this->stayTime;
} else {
$isJump = false;
$dx = $this->motionX;
$dy = $this->motionY;
$dz = $this->motionZ;
$be = new Vector2($this->x + $dx, $this->z + $dz);
$this->move($dx, $dy, $dz);
$af = new Vector2($this->x, $this->z);
if ($be->x != $af->x || $be->y != $af->y) {
$x = 0;
$z = 0;
if ($be->x - $af->x != 0) {
$x += $be->x - $af->x > 0 ? 1 : -1;
}
if ($be->y - $af->y != 0) {
$z += $be->y - $af->y > 0 ? 1 : -1;
}
$block = $this->level->getBlock((new Vector3(Math::floorFloat($be->x) + $x, $this->y, Math::floorFloat($af->y) + $z))->floor());
$block2 = $this->level->getBlock((new Vector3(Math::floorFloat($be->x) + $x, $this->y + 1, Math::floorFloat($af->y) + $z))->floor());
if (!$block->canPassThrough()) {
$bb = $block2->getBoundingBox();
if ($block2->canPassThrough() || ($bb == null || $bb != null && $bb->maxY - $this->y <= 1)) {
$isJump = true;
$this->motionY = 0.2;
} else {
if ($this->level->getBlock($block->add(-$x, 0, -$z))->getId() == Item::LADDER) {
$isJump = true;
$this->motionY = 0.2;
}
}
}
if (!$isJump) {
$this->moveTime = 0;
}
}
if ($this->onGround && !$isJump) {
$this->motionY = 0;
} elseif (!$isJump) {
$this->motionY -= $this->gravity;
}
}
$this->updateMovement();
return $target;
}
/**
* @return Rail
*/
public function getNearestRail()
{
$minX = Math::floorFloat($this->boundingBox->minX);
$minY = Math::floorFloat($this->boundingBox->minY);
$minZ = Math::floorFloat($this->boundingBox->minZ);
$maxX = Math::ceilFloat($this->boundingBox->maxX);
$maxY = Math::ceilFloat($this->boundingBox->maxY);
$maxZ = Math::ceilFloat($this->boundingBox->maxZ);
$rails = [];
for ($z = $minZ; $z <= $maxZ; ++$z) {
for ($x = $minX; $x <= $maxX; ++$x) {
for ($y = $minY; $y <= $maxY; ++$y) {
$block = $this->level->getBlock($this->temporalVector->setComponents($x, $y, $z));
if (in_array($block->getId(), [Block::RAIL, Block::ACTIVATOR_RAIL, Block::DETECTOR_RAIL, Block::POWERED_RAIL])) {
$rails[] = $block;
}
}
}
}
$minDistance = PHP_INT_MAX;
$nearestRail = null;
foreach ($rails as $rail) {
$dis = $this->distance($rail);
if ($dis < $minDistance) {
$nearestRail = $rail;
$minDistance = $dis;
}
}
return $nearestRail;
}
public function updateMove(int $tickDiff)
{
if (!$this->isMovement()) {
return null;
}
if ($this->isKnockback()) {
$this->move($this->motionX * $tickDiff, $this->motionY, $this->motionZ * $tickDiff);
$this->motionY -= 0.15 * $tickDiff;
$this->updateMovement();
return null;
}
$before = $this->baseTarget;
$this->checkTarget();
if ($this->baseTarget instanceof Creature or $before !== $this->baseTarget) {
$x = $this->baseTarget->x - $this->x;
$y = $this->baseTarget->y - $this->y;
$z = $this->baseTarget->z - $this->z;
if ($this->stayTime > 0 || $x ** 2 + $z ** 2 < 0.7) {
$this->motionX = 0;
$this->motionZ = 0;
} else {
$diff = abs($x) + abs($z);
$this->motionX = $this->getSpeed() * 0.15 * ($x / $diff);
$this->motionZ = $this->getSpeed() * 0.15 * ($z / $diff);
}
$this->yaw = -atan2($this->motionX, $this->motionZ) * 180 / M_PI;
$this->pitch = $y == 0 ? 0 : rad2deg(-atan2($y, sqrt($x ** 2 + $z ** 2)));
}
$target = $this->mainTarget != null ? $this->mainTarget : $this->baseTarget;
if ($this->stayTime > 0) {
$this->stayTime -= 1;
} else {
$isJump = false;
$dx = $this->motionX * $tickDiff;
$dy = $this->motionY * $tickDiff;
$dz = $this->motionZ * $tickDiff;
$be = new Vector2($this->x + $dx, $this->z + $dz);
$this->move($dx, $dy, $dz);
$af = new Vector2($this->x, $this->z);
if ($be->x != $af->x || $be->y != $af->y) {
$x = 0;
$z = 0;
if ($be->x - $af->x != 0) {
$x += $be->x - $af->x > 0 ? 1 : -1;
}
if ($be->y - $af->y != 0) {
$z += $be->y - $af->y > 0 ? 1 : -1;
}
$vec = new Vector3(Math::floorFloat($be->x), (int) $this->y, Math::floorFloat($be->y));
$block = $this->level->getBlock($vec->add($x, 0, $z));
$block2 = $this->level->getBlock($vec->add($x, 1, $z));
if (!$block->canPassThrough()) {
$bb = $block2->getBoundingBox();
if ($this->motionY > -$this->gravity * 4 && ($block2->canPassThrough() || ($bb == null || $bb != null && $bb->maxY - $this->y <= 1))) {
$isJump = true;
if ($this->motionY >= 0.3) {
$this->motionY += $this->gravity;
} else {
$this->motionY = 0.3;
}
} elseif ($this->level->getBlock($vec)->getId() == Item::LADDER) {
$isJump = true;
$this->motionY = 0.15;
}
}
if (!$isJump) {
$this->moveTime -= 90 * $tickDiff;
}
}
if ($this->onGround && !$isJump) {
$this->motionY = 0;
} elseif (!$isJump) {
if ($this->motionY > -$this->gravity * 4) {
$this->motionY = -$this->gravity * 4;
} else {
$this->motionY -= $this->gravity;
}
}
}
$this->updateMovement();
return $target;
}
protected function checkBlockCollision()
{
$minX = Math::ceilFloat($this->boundingBox->minX);
$minY = Math::ceilFloat($this->boundingBox->minY);
$minZ = Math::ceilFloat($this->boundingBox->minZ);
$maxX = Math::floorFloat($this->boundingBox->maxX);
$maxY = Math::floorFloat($this->boundingBox->maxY);
$maxZ = Math::floorFloat($this->boundingBox->maxZ);
$blocksInside = [];
for ($z = $minZ; $z <= $maxZ; ++$z) {
for ($x = $minX; $x <= $maxX; ++$x) {
for ($y = $minY; $y <= $maxY; ++$y) {
$block = $this->level->getBlock($this->temporalVector->setComponents($x, $y, $z));
if ($block->hasEntityCollision()) {
$blocksInside[Level::blockHash($block->x, $block->y, $block->z)] = $block;
}
}
}
}
foreach ($blocksInside as $block) {
$block->onEntityCollide($this);
}
}
public function entityBaseTick($tickDiff = 1)
{
Timings::$timerEntityBaseTick->startTiming();
if (!$this->isCreated()) {
return false;
}
$hasUpdate = Entity::entityBaseTick($tickDiff);
if ($this->attackTime > 0) {
$this->attackTime -= $tickDiff;
}
if ($this->isInsideOfSolid()) {
$hasUpdate = true;
$ev = new EntityDamageEvent($this, EntityDamageEvent::CAUSE_SUFFOCATION, 1);
$this->attack($ev->getFinalDamage(), $ev);
}
if ($this instanceof Enderman) {
if ($this->level->getBlock(new Vector3(Math::floorFloat($this->x), (int) $this->y, Math::floorFloat($this->z))) instanceof Water) {
$ev = new EntityDamageEvent($this, EntityDamageEvent::CAUSE_DROWNING, 2);
$this->attack($ev->getFinalDamage(), $ev);
$this->move(mt_rand(-20, 20), mt_rand(-20, 20), mt_rand(-20, 20));
}
} else {
if (!$this->hasEffect(Effect::WATER_BREATHING) && $this->isInsideOfWater()) {
$hasUpdate = true;
$airTicks = $this->getDataProperty(self::DATA_AIR) - $tickDiff;
if ($airTicks <= -20) {
$airTicks = 0;
$ev = new EntityDamageEvent($this, EntityDamageEvent::CAUSE_DROWNING, 2);
$this->attack($ev->getFinalDamage(), $ev);
}
$this->setDataProperty(self::DATA_AIR, self::DATA_TYPE_SHORT, $airTicks);
} else {
$this->setDataProperty(self::DATA_AIR, self::DATA_TYPE_SHORT, 300);
}
}
Timings::$timerEntityBaseTick->stopTiming();
return $hasUpdate;
}
public function isInsidePortal(Player $player)
{
$block = $player->getLevel()->getBlock($player->temporalVector->setComponents(Math::floorFloat($player->x), Math::floorFloat($y = $player->y + $player->getEyeHeight()), Math::floorFloat($player->z)));
return $block->getId() == 90;
}
/**
* @param AxisAlignedBB $bb
*
* @return Block[]|Entity[]
*/
public function getCollisionCubes(AxisAlignedBB $bb)
{
$minX = Math::floorFloat($bb->minX);
$minY = Math::floorFloat($bb->minY);
$minZ = Math::floorFloat($bb->minZ);
$maxX = Math::ceilFloat($bb->maxX);
$maxY = Math::ceilFloat($bb->maxY);
$maxZ = Math::ceilFloat($bb->maxZ);
$collides = [];
$v = new Vector3();
for ($v->z = $minZ; $v->z <= $maxZ; ++$v->z) {
for ($v->x = $minX; $v->x <= $maxX; ++$v->x) {
for ($v->y = $minY - 1; $v->y <= $maxY; ++$v->y) {
$block = $this->level->getBlock($v);
if ($block->getBoundingBox() !== null) {
$collides[] = $block;
}
}
}
}
return $collides;
}
private function clamp(Vector3 $pos)
{
return new Vector3(Math::clamp($pos->getFloorX(), 0, 16), Math::clamp($pos->getFloorY(), 1, 120), Math::clamp($pos->getFloorZ(), 0, 16));
}
/**
* @param Vector3 $spawn default null
*
* @return bool|Position
*/
public function getSafeSpawn($spawn = null)
{
if (!$spawn instanceof Vector3) {
$spawn = $this->getSpawnLocation();
}
if ($spawn instanceof Vector3) {
$v = $spawn->floor();
$chunk = $this->getChunk($v->x >> 4, $v->z >> 4, false);
$x = $v->x & 0xf;
$z = $v->z & 0xf;
if ($chunk !== null) {
for (; $v->y > 0; --$v->y) {
if ($v->y < 127 and Block::$solid[$chunk->getBlockId($x, $v->y & 0x7f, $z)]) {
$v->y++;
break;
}
}
for (; $v->y < 128; ++$v->y) {
if (!Block::$solid[$chunk->getBlockId($x, $v->y + 1, $z)]) {
if (!Block::$solid[$chunk->getBlockId($x, $v->y, $z)]) {
return new Position($spawn->x, $v->y === Math::floorFloat($spawn->y) ? $spawn->y : $v->y, $spawn->z, $this);
}
} else {
++$v->y;
}
}
}
return new Position($spawn->x, $v->y, $spawn->z, $this);
}
return false;
}
public function explodeB()
{
$send = [];
$updateBlocks = [];
$source = (new Vector3($this->source->x, $this->source->y, $this->source->z))->floor();
$yield = 1 / $this->size * 100;
if ($this->what instanceof Entity) {
$this->level->getServer()->getPluginManager()->callEvent($ev = new EntityExplodeEvent($this->what, $this->source, $this->affectedBlocks, $yield));
if ($ev->isCancelled()) {
return \false;
} else {
$yield = $ev->getYield();
$this->affectedBlocks = $ev->getBlockList();
}
}
$explosionSize = $this->size * 2;
$minX = Math::floorFloat($this->source->x - $explosionSize - 1);
$maxX = Math::ceilFloat($this->source->x + $explosionSize + 1);
$minY = Math::floorFloat($this->source->y - $explosionSize - 1);
$maxY = Math::ceilFloat($this->source->y + $explosionSize + 1);
$minZ = Math::floorFloat($this->source->z - $explosionSize - 1);
$maxZ = Math::ceilFloat($this->source->z + $explosionSize + 1);
$explosionBB = new AxisAlignedBB($minX, $minY, $minZ, $maxX, $maxY, $maxZ);
$list = $this->level->getNearbyEntities($explosionBB, $this->what instanceof Entity ? $this->what : \null);
foreach ($list as $entity) {
$distance = $entity->distance($this->source) / $explosionSize;
if ($distance <= 1) {
$motion = $entity->subtract($this->source)->normalize();
$impact = (1 - $distance) * ($exposure = 1);
$damage = (int) (($impact * $impact + $impact) / 2 * 8 * $explosionSize + 1);
if ($this->what instanceof Entity) {
$ev = new EntityDamageByEntityEvent($this->what, $entity, EntityDamageEvent::CAUSE_ENTITY_EXPLOSION, $damage);
} elseif ($this->what instanceof Block) {
$ev = new EntityDamageByBlockEvent($this->what, $entity, EntityDamageEvent::CAUSE_BLOCK_EXPLOSION, $damage);
} else {
$ev = new EntityDamageEvent($entity, EntityDamageEvent::CAUSE_BLOCK_EXPLOSION, $damage);
}
$entity->attack($ev->getFinalDamage(), $ev);
$entity->setMotion($motion->multiply($impact));
}
}
$air = Item::get(Item::AIR);
foreach ($this->affectedBlocks as $block) {
if ($block->getId() === Block::TNT) {
$mot = (new Random())->nextSignedFloat() * M_PI * 2;
$tnt = Entity::createEntity("PrimedTNT", $this->level->getChunk($block->x >> 4, $block->z >> 4), new Compound("", ["Pos" => new Enum("Pos", [new Double("", $block->x + 0.5), new Double("", $block->y), new Double("", $block->z + 0.5)]), "Motion" => new Enum("Motion", [new Double("", -\sin($mot) * 0.02), new Double("", 0.2), new Double("", -\cos($mot) * 0.02)]), "Rotation" => new Enum("Rotation", [new Float("", 0), new Float("", 0)]), "Fuse" => new Byte("Fuse", \mt_rand(10, 30))]));
$tnt->spawnToAll();
} elseif (\mt_rand(0, 100) < $yield) {
foreach ($block->getDrops($air) as $drop) {
$this->level->dropItem($block->add(0.5, 0.5, 0.5), Item::get(...$drop));
}
}
$this->level->setBlockIdAt($block->x, $block->y, $block->z, 0);
$pos = new Vector3($block->x, $block->y, $block->z);
for ($side = 0; $side < 5; $side++) {
$sideBlock = $pos->getSide($side);
if (!isset($this->affectedBlocks[$index = ($sideBlock->x & 0xfffffff) << 35 | ($sideBlock->y & 0x7f) << 28 | $sideBlock->z & 0xfffffff]) and !isset($updateBlocks[$index])) {
$this->level->getServer()->getPluginManager()->callEvent($ev = new BlockUpdateEvent($this->level->getBlock($sideBlock)));
if (!$ev->isCancelled()) {
$ev->getBlock()->onUpdate(Level::BLOCK_UPDATE_NORMAL);
}
$updateBlocks[$index] = \true;
}
}
$send[] = new Vector3($block->x - $source->x, $block->y - $source->y, $block->z - $source->z);
}
$pk = new ExplodePacket();
$pk->x = $this->source->x;
$pk->y = $this->source->y;
$pk->z = $this->source->z;
$pk->radius = $this->size;
$pk->records = $send;
$this->level->addChunkPacket($source->x >> 4, $source->z >> 4, $pk);
return \true;
}
public function isInsideOfSolid()
{
$block = $this->level->getBlock(new Vector3(Math::floorFloat($this->x), Math::floorFloat($y = $this->y + $this->getEyeHeight()), Math::floorFloat($this->z)));
$bb = $block->getBoundingBox();
if ($bb !== null and $block->isSolid() and !$block->isTransparent() and $bb->intersectsWith($this->getBoundingBox())) {
return true;
}
return false;
}
public function onTick()
{
$ps = $this->player;
foreach ($this->getServer()->getOnlinePlayers() as $p) {
$n = $p->getName();
if (!isset($ps[$n])) {
$ps[$n] = 0;
}
if (!$p->isSurvival() || microtime(true) - $ps[$n] < 0 || $p->hasPermission("mineblock.damageblock.inv")) {
continue;
}
$bb = $p->getBoundingBox();
$minX = Math::floorFloat($bb->minX - 0.001);
$minY = Math::floorFloat($bb->minY - 0.001);
$minZ = Math::floorFloat($bb->minZ - 0.001);
$maxX = Math::floorFloat($bb->maxX + 0.001);
$maxY = Math::floorFloat($bb->maxY + 0.001);
$maxZ = Math::floorFloat($bb->maxZ + 0.001);
$block = [];
$damage = 0;
for ($z = $minZ; $z <= $maxZ; ++$z) {
for ($x = $minX; $x <= $maxX; ++$x) {
for ($y = $minY; $y <= $maxY; ++$y) {
$getDamage = $this->getDamage($p->getLevel()->getBlock(new Vector3($x, $y, $z)));
if (!in_array($getDamage[1], $block)) {
$damage += $getDamage[0];
$block[] = $getDamage[1];
}
}
}
}
if ($damage !== 0) {
$p->attack($damage);
}
$ps[$n] = microtime(true) + 1;
}
$this->player = $ps;
}