private static boolean trySpawnEntity(ItemStack stack, WorldServer world, EntityPlayerMP player) {
int damage = stack.getItemDamage();
if (damage >= stack.getMaxDamage()) return false;
NBTTagCompound tag = ItemUtils.getItemTag(stack);
String structureName = tag.getString(TAG_STRUCTURE);
if (Strings.isNullOrEmpty(structureName)) return false;
Map<String, ChunkPosition> nearbyStructures =
StructureRegistry.instance.getNearestStructures(
world, (int) player.posX, (int) player.posY, (int) player.posZ);
ChunkPosition structurePos = nearbyStructures.get(structureName);
if (structurePos != null) {
if (Config.eyeDebug)
player.addChatComponentMessage(
new ChatComponentTranslation(
"openblocks.misc.structure_pos",
structureName,
structurePos.chunkPosX,
structurePos.chunkPosY,
structurePos.chunkPosZ));
stack.setItemDamage(damage + 1);
EntityGoldenEye eye = new EntityGoldenEye(world, stack, player, structurePos);
world.spawnEntityInWorld(eye);
world.playSoundAtEntity(
player, "random.bow", 0.5F, 0.4F / (itemRand.nextFloat() * 0.4F + 0.8F));
return true;
}
return false;
}
/**
* @author blood - May 21st, 2016
* @reason - adjusted to support {@link DisplaceEntityEvent.Teleport.Portal}
* @param playerIn The player teleporting to another dimension
* @param targetDimensionId The id of target dimension.
* @param teleporter The teleporter used to transport and create the portal
*/
public void transferPlayerToDimension(
EntityPlayerMP playerIn, int targetDimensionId, net.minecraft.world.Teleporter teleporter) {
DisplaceEntityEvent.Teleport.Portal event =
SpongeCommonEventFactory.handleDisplaceEntityPortalEvent(
playerIn, targetDimensionId, teleporter);
if (event == null || event.isCancelled()) {
return;
}
WorldServer fromWorld = (WorldServer) event.getFromTransform().getExtent();
WorldServer toWorld = (WorldServer) event.getToTransform().getExtent();
playerIn.dimension = toWorld.provider.getDimensionId();
// Support vanilla clients teleporting to custom dimensions
int dimension =
DimensionManager.getClientDimensionToSend(
toWorld.provider.getDimensionId(), toWorld, playerIn);
if (((IMixinEntityPlayerMP) playerIn).usesCustomClient()) {
DimensionManager.sendDimensionRegistration(toWorld, playerIn, dimension);
}
playerIn.playerNetServerHandler.sendPacket(
new S07PacketRespawn(
playerIn.dimension,
fromWorld.getDifficulty(),
fromWorld.getWorldInfo().getTerrainType(),
playerIn.theItemInWorldManager.getGameType()));
fromWorld.removePlayerEntityDangerously(playerIn);
playerIn.isDead = false;
// we do not need to call transferEntityToWorld as we already have the correct transform and
// created the portal in handleDisplaceEntityPortalEvent
((IMixinEntity) playerIn).setLocationAndAngles(event.getToTransform());
toWorld.spawnEntityInWorld(playerIn);
toWorld.updateEntityWithOptionalForce(playerIn, false);
playerIn.setWorld(toWorld);
this.preparePlayer(playerIn, fromWorld);
playerIn.playerNetServerHandler.setPlayerLocation(
playerIn.posX, playerIn.posY, playerIn.posZ, playerIn.rotationYaw, playerIn.rotationPitch);
playerIn.theItemInWorldManager.setWorld(toWorld);
this.updateTimeAndWeatherForPlayer(playerIn, toWorld);
this.syncPlayerInventory(playerIn);
for (PotionEffect potioneffect : playerIn.getActivePotionEffects()) {
playerIn.playerNetServerHandler.sendPacket(
new S1DPacketEntityEffect(playerIn.getEntityId(), potioneffect));
}
((IMixinEntityPlayerMP) playerIn).refreshXpHealthAndFood();
// Forge needs to know when a player changes to new a dimension
// This cannot be mapped to DisplaceEntityEvent.Teleport as this event must be called AFTER
// transfer.
net.minecraftforge.fml.common.FMLCommonHandler.instance()
.firePlayerChangedDimensionEvent(
playerIn, fromWorld.provider.getDimensionId(), toWorld.provider.getDimensionId());
}
/**
* Called when a player successfully logs in. Reads player data from disk and inserts the player
* into the world.
*/
public void playerLoggedIn(EntityPlayerMP par1EntityPlayerMP) {
this.sendPacketToAllPlayers(new Packet201PlayerInfo(par1EntityPlayerMP.username, true, 1000));
this.playerEntityList.add(par1EntityPlayerMP);
WorldServer var2 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
var2.spawnEntityInWorld(par1EntityPlayerMP);
this.func_72375_a(par1EntityPlayerMP, (WorldServer) null);
for (int var3 = 0; var3 < this.playerEntityList.size(); ++var3) {
EntityPlayerMP var4 = (EntityPlayerMP) this.playerEntityList.get(var3);
par1EntityPlayerMP.playerNetServerHandler.sendPacketToPlayer(
new Packet201PlayerInfo(var4.username, true, var4.ping));
}
}
/** Teleports the entity to another dimension. Params: Dimension number to teleport to */
public static void travelEntityToDimension(Entity entity, int dimensionId, int x, int y, int z) {
if (!entity.worldObj.isRemote && !entity.isDead) {
entity.worldObj.theProfiler.startSection("changeDimension");
MinecraftServer minecraftserver = MinecraftServer.getServer();
int j = entity.dimension;
WorldServer worldserver = minecraftserver.worldServerForDimension(j);
WorldServer worldserver1 = minecraftserver.worldServerForDimension(dimensionId);
entity.dimension = dimensionId;
if (j == 1 && dimensionId == 1) {
worldserver1 = minecraftserver.worldServerForDimension(0);
entity.dimension = 0;
}
entity.worldObj.removeEntity(entity);
entity.isDead = false;
entity.worldObj.theProfiler.startSection("reposition");
minecraftserver
.getConfigurationManager()
.transferEntityToWorld(entity, j, worldserver, worldserver1);
entity.worldObj.theProfiler.endStartSection("reloading");
Entity newEntity =
EntityList.createEntityByName(EntityList.getEntityString(entity), worldserver1);
if (newEntity != null) {
newEntity.copyDataFrom(entity, true);
if (j == 1 && dimensionId == 1) {
ChunkCoordinates chunkcoordinates = worldserver1.getSpawnPoint();
chunkcoordinates.posY =
entity.worldObj.getTopSolidOrLiquidBlock(
chunkcoordinates.posX, chunkcoordinates.posZ);
newEntity.setLocationAndAngles(
(double) chunkcoordinates.posX,
(double) chunkcoordinates.posY,
(double) chunkcoordinates.posZ,
newEntity.rotationYaw,
newEntity.rotationPitch);
}
worldserver1.spawnEntityInWorld(newEntity);
newEntity.setPosition(x + 0.5D, y, z + 0.5D);
}
entity.isDead = true;
entity.worldObj.theProfiler.endSection();
worldserver.resetUpdateEntityTick();
worldserver1.resetUpdateEntityTick();
entity.worldObj.theProfiler.endSection();
}
}
private void handleFireworks(WorldServer world) {
if (random.nextFloat() < 0.05) {
// Calculate a bounding box for all players in the world.
double minPosX = 1000000000.0f;
double minPosZ = 1000000000.0f;
double maxPosX = -1000000000.0f;
double maxPosZ = -1000000000.0f;
for (Object playerEntity : world.playerEntities) {
EntityPlayer player = (EntityPlayer) playerEntity;
if (player.posX > maxPosX) {
maxPosX = player.posX;
}
if (player.posX < minPosX) {
minPosX = player.posX;
}
if (player.posZ > maxPosZ) {
maxPosZ = player.posZ;
}
if (player.posZ < minPosZ) {
minPosZ = player.posZ;
}
}
double posX = random.nextFloat() * (maxPosX - minPosX + 60.0f) + minPosX - 30.0f;
double posZ = random.nextFloat() * (maxPosZ - minPosZ + 60.0f) + minPosZ - 30.0f;
ItemStack fireworkStack = new ItemStack(Items.fireworks);
NBTTagCompound tag = new NBTTagCompound();
NBTTagCompound fireworks = new NBTTagCompound();
fireworks.setByte("Flight", (byte) 2);
NBTTagList explosions = new NBTTagList();
explosions.appendTag(makeExplosion(tag));
fireworks.setTag("Explosions", explosions);
tag.setTag("Fireworks", fireworks);
fireworkStack.setTagCompound(tag);
int y = world.getTopSolidOrLiquidBlock((int) posX, (int) posZ);
if (y == -1) {
y = 64;
} else {
y += 3;
}
EntityFireworkRocket entityfireworkrocket =
new EntityFireworkRocket(world, posX, y, posZ, fireworkStack);
world.spawnEntityInWorld(entityfireworkrocket);
}
}
/**
* Called when a player successfully logs in. Reads player data from disk and inserts the player
* into the world.
*/
public void playerLoggedIn(EntityPlayerMP playerIn) {
this.playerEntityList.add(playerIn);
this.field_177454_f.put(playerIn.getUniqueID(), playerIn);
this.sendPacketToAllPlayers(
new S38PacketPlayerListItem(
S38PacketPlayerListItem.Action.ADD_PLAYER, new EntityPlayerMP[] {playerIn}));
WorldServer var2 = this.mcServer.worldServerForDimension(playerIn.dimension);
var2.spawnEntityInWorld(playerIn);
this.func_72375_a(playerIn, (WorldServer) null);
for (int var3 = 0; var3 < this.playerEntityList.size(); ++var3) {
EntityPlayerMP var4 = (EntityPlayerMP) this.playerEntityList.get(var3);
playerIn.playerNetServerHandler.sendPacket(
new S38PacketPlayerListItem(
S38PacketPlayerListItem.Action.ADD_PLAYER, new EntityPlayerMP[] {var4}));
}
}
public static void teleportPlayerToCoords(EntityPlayerMP player, int coord, boolean isReturning) {
// LogHelper.info("Teleporting player to: " + coord);
NBTTagCompound playerNBT = player.getEntityData();
// Grab the CompactMachines entry from the player NBT data
NBTTagCompound cmNBT;
if (playerNBT.hasKey(Reference.MOD_ID)) {
cmNBT = playerNBT.getCompoundTag(Reference.MOD_ID);
} else {
cmNBT = new NBTTagCompound();
playerNBT.setTag(Reference.MOD_ID, cmNBT);
}
if (player.dimension != ConfigurationHandler.dimensionId) {
cmNBT.setInteger("oldDimension", player.dimension);
cmNBT.setDouble("oldPosX", player.posX);
cmNBT.setDouble("oldPosY", player.posY);
cmNBT.setDouble("oldPosZ", player.posZ);
int oldDimension = player.dimension;
WorldServer machineWorld =
MinecraftServer.getServer().worldServerForDimension(ConfigurationHandler.dimensionId);
MinecraftServer.getServer()
.getConfigurationManager()
.transferPlayerToDimension(
player, ConfigurationHandler.dimensionId, new TeleporterCM(machineWorld));
// If this is not being called teleporting from The End ends up without
// the client knowing about any blocks, i.e. blank screen, no blocks, but
// server collisions etc.
if (oldDimension == 1) {
machineWorld.spawnEntityInWorld(player);
}
// Since the player is currently not in the machine dimension, we want to clear
// his coord history - in case he exited the machine world not via a shrinking device
// which automatically clears the last entry in the coord history.
if (playerNBT.hasKey("coordHistory")) {
playerNBT.removeTag("coordHistory");
}
}
if (!isReturning) {
NBTTagList coordHistory;
if (playerNBT.hasKey("coordHistory")) {
coordHistory = playerNBT.getTagList("coordHistory", 10);
} else {
coordHistory = new NBTTagList();
}
NBTTagCompound toAppend = new NBTTagCompound();
toAppend.setInteger("coord", coord);
coordHistory.appendTag(toAppend);
playerNBT.setTag("coordHistory", coordHistory);
}
MachineSaveData mHandler = CompactMachines.instance.machineHandler;
double[] destination = mHandler.getSpawnLocation(coord);
// Check whether the spawn location is blocked
WorldServer machineWorld =
MinecraftServer.getServer().worldServerForDimension(ConfigurationHandler.dimensionId);
int dstX = (int) Math.floor(destination[0]);
int dstY = (int) Math.floor(destination[1]);
int dstZ = (int) Math.floor(destination[2]);
if (!machineWorld.isAirBlock(dstX, dstY, dstZ)
|| !machineWorld.isAirBlock(dstX, dstY + 1, dstZ)) {
// If it is blocked, try to find a better position
double[] bestSpot = findBestSpawnLocation(machineWorld, coord);
if (bestSpot != null) {
destination = bestSpot;
}
// otherwise teleport to the default location... player will probably die though.
}
player.setPositionAndUpdate(destination[0], destination[1], destination[2]);
if (destination.length == 5) {
MessagePlayerRotation packet =
new MessagePlayerRotation((float) destination[3], (float) destination[4]);
PacketHandler.INSTANCE.sendTo(packet, player);
}
}
/** Transfers an entity from a world to another world. */
public void transferEntityToWorld(
Entity entityIn, int p_82448_2_, WorldServer p_82448_3_, WorldServer p_82448_4_) {
double var5 = entityIn.posX;
double var7 = entityIn.posZ;
double var9 = 8.0D;
float var11 = entityIn.rotationYaw;
p_82448_3_.theProfiler.startSection("moving");
if (entityIn.dimension == -1) {
var5 =
MathHelper.clamp_double(
var5 / var9,
p_82448_4_.getWorldBorder().minX() + 16.0D,
p_82448_4_.getWorldBorder().maxX() - 16.0D);
var7 =
MathHelper.clamp_double(
var7 / var9,
p_82448_4_.getWorldBorder().minZ() + 16.0D,
p_82448_4_.getWorldBorder().maxZ() - 16.0D);
entityIn.setLocationAndAngles(
var5, entityIn.posY, var7, entityIn.rotationYaw, entityIn.rotationPitch);
if (entityIn.isEntityAlive()) {
p_82448_3_.updateEntityWithOptionalForce(entityIn, false);
}
} else if (entityIn.dimension == 0) {
var5 =
MathHelper.clamp_double(
var5 * var9,
p_82448_4_.getWorldBorder().minX() + 16.0D,
p_82448_4_.getWorldBorder().maxX() - 16.0D);
var7 =
MathHelper.clamp_double(
var7 * var9,
p_82448_4_.getWorldBorder().minZ() + 16.0D,
p_82448_4_.getWorldBorder().maxZ() - 16.0D);
entityIn.setLocationAndAngles(
var5, entityIn.posY, var7, entityIn.rotationYaw, entityIn.rotationPitch);
if (entityIn.isEntityAlive()) {
p_82448_3_.updateEntityWithOptionalForce(entityIn, false);
}
} else {
BlockPos var12;
if (p_82448_2_ == 1) {
var12 = p_82448_4_.getSpawnPoint();
} else {
var12 = p_82448_4_.func_180504_m();
}
var5 = (double) var12.getX();
entityIn.posY = (double) var12.getY();
var7 = (double) var12.getZ();
entityIn.setLocationAndAngles(var5, entityIn.posY, var7, 90.0F, 0.0F);
if (entityIn.isEntityAlive()) {
p_82448_3_.updateEntityWithOptionalForce(entityIn, false);
}
}
p_82448_3_.theProfiler.endSection();
if (p_82448_2_ != 1) {
p_82448_3_.theProfiler.startSection("placing");
var5 = (double) MathHelper.clamp_int((int) var5, -29999872, 29999872);
var7 = (double) MathHelper.clamp_int((int) var7, -29999872, 29999872);
if (entityIn.isEntityAlive()) {
entityIn.setLocationAndAngles(
var5, entityIn.posY, var7, entityIn.rotationYaw, entityIn.rotationPitch);
p_82448_4_.getDefaultTeleporter().func_180266_a(entityIn, var11);
p_82448_4_.spawnEntityInWorld(entityIn);
p_82448_4_.updateEntityWithOptionalForce(entityIn, false);
}
p_82448_3_.theProfiler.endSection();
}
entityIn.setWorld(p_82448_4_);
}
/** Called on respawn */
public EntityPlayerMP recreatePlayerEntity(
EntityPlayerMP playerIn, int dimension, boolean conqueredEnd) {
playerIn.getServerForPlayer().getEntityTracker().removePlayerFromTrackers(playerIn);
playerIn.getServerForPlayer().getEntityTracker().untrackEntity(playerIn);
playerIn.getServerForPlayer().getPlayerManager().removePlayer(playerIn);
this.playerEntityList.remove(playerIn);
this.mcServer
.worldServerForDimension(playerIn.dimension)
.removePlayerEntityDangerously(playerIn);
BlockPos var4 = playerIn.func_180470_cg();
boolean var5 = playerIn.isSpawnForced();
playerIn.dimension = dimension;
Object var6;
if (this.mcServer.isDemo()) {
var6 = new DemoWorldManager(this.mcServer.worldServerForDimension(playerIn.dimension));
} else {
var6 = new ItemInWorldManager(this.mcServer.worldServerForDimension(playerIn.dimension));
}
EntityPlayerMP var7 =
new EntityPlayerMP(
this.mcServer,
this.mcServer.worldServerForDimension(playerIn.dimension),
playerIn.getGameProfile(),
(ItemInWorldManager) var6);
var7.playerNetServerHandler = playerIn.playerNetServerHandler;
var7.clonePlayer(playerIn, conqueredEnd);
var7.setEntityId(playerIn.getEntityId());
var7.func_174817_o(playerIn);
WorldServer var8 = this.mcServer.worldServerForDimension(playerIn.dimension);
this.func_72381_a(var7, playerIn, var8);
BlockPos var9;
if (var4 != null) {
var9 =
EntityPlayer.func_180467_a(
this.mcServer.worldServerForDimension(playerIn.dimension), var4, var5);
if (var9 != null) {
var7.setLocationAndAngles(
(double) ((float) var9.getX() + 0.5F),
(double) ((float) var9.getY() + 0.1F),
(double) ((float) var9.getZ() + 0.5F),
0.0F,
0.0F);
var7.func_180473_a(var4, var5);
} else {
var7.playerNetServerHandler.sendPacket(new S2BPacketChangeGameState(0, 0.0F));
}
}
var8.theChunkProviderServer.loadChunk((int) var7.posX >> 4, (int) var7.posZ >> 4);
while (!var8.getCollidingBoundingBoxes(var7, var7.getEntityBoundingBox()).isEmpty()
&& var7.posY < 256.0D) {
var7.setPosition(var7.posX, var7.posY + 1.0D, var7.posZ);
}
var7.playerNetServerHandler.sendPacket(
new S07PacketRespawn(
var7.dimension,
var7.worldObj.getDifficulty(),
var7.worldObj.getWorldInfo().getTerrainType(),
var7.theItemInWorldManager.getGameType()));
var9 = var8.getSpawnPoint();
var7.playerNetServerHandler.setPlayerLocation(
var7.posX, var7.posY, var7.posZ, var7.rotationYaw, var7.rotationPitch);
var7.playerNetServerHandler.sendPacket(new S05PacketSpawnPosition(var9));
var7.playerNetServerHandler.sendPacket(
new S1FPacketSetExperience(var7.experience, var7.experienceTotal, var7.experienceLevel));
this.updateTimeAndWeatherForPlayer(var7, var8);
var8.getPlayerManager().addPlayer(var7);
var8.spawnEntityInWorld(var7);
this.playerEntityList.add(var7);
this.field_177454_f.put(var7.getUniqueID(), var7);
var7.addSelfToInternalCraftingInventory();
var7.setHealth(var7.getHealth());
return var7;
}
public void initializeConnectionToPlayer(NetworkManager netManager, EntityPlayerMP playerIn) {
GameProfile var3 = playerIn.getGameProfile();
PlayerProfileCache var4 = this.mcServer.getPlayerProfileCache();
GameProfile var5 = var4.func_152652_a(var3.getId());
String var6 = var5 == null ? var3.getName() : var5.getName();
var4.func_152649_a(var3);
NBTTagCompound var7 = this.readPlayerDataFromFile(playerIn);
playerIn.setWorld(this.mcServer.worldServerForDimension(playerIn.dimension));
playerIn.theItemInWorldManager.setWorld((WorldServer) playerIn.worldObj);
String var8 = "local";
if (netManager.getRemoteAddress() != null) {
var8 = netManager.getRemoteAddress().toString();
}
logger.info(
playerIn.getName()
+ "["
+ var8
+ "] logged in with entity id "
+ playerIn.getEntityId()
+ " at ("
+ playerIn.posX
+ ", "
+ playerIn.posY
+ ", "
+ playerIn.posZ
+ ")");
WorldServer var9 = this.mcServer.worldServerForDimension(playerIn.dimension);
WorldInfo var10 = var9.getWorldInfo();
BlockPos var11 = var9.getSpawnPoint();
this.func_72381_a(playerIn, (EntityPlayerMP) null, var9);
NetHandlerPlayServer var12 = new NetHandlerPlayServer(this.mcServer, netManager, playerIn);
var12.sendPacket(
new S01PacketJoinGame(
playerIn.getEntityId(),
playerIn.theItemInWorldManager.getGameType(),
var10.isHardcoreModeEnabled(),
var9.provider.getDimensionId(),
var9.getDifficulty(),
this.getMaxPlayers(),
var10.getTerrainType(),
var9.getGameRules().getGameRuleBooleanValue("reducedDebugInfo")));
var12.sendPacket(
new S3FPacketCustomPayload(
"MC|Brand",
(new PacketBuffer(Unpooled.buffer()))
.writeString(this.getServerInstance().getServerModName())));
var12.sendPacket(
new S41PacketServerDifficulty(var10.getDifficulty(), var10.isDifficultyLocked()));
var12.sendPacket(new S05PacketSpawnPosition(var11));
var12.sendPacket(new S39PacketPlayerAbilities(playerIn.capabilities));
var12.sendPacket(new S09PacketHeldItemChange(playerIn.inventory.currentItem));
playerIn.getStatFile().func_150877_d();
playerIn.getStatFile().func_150884_b(playerIn);
this.func_96456_a((ServerScoreboard) var9.getScoreboard(), playerIn);
this.mcServer.refreshStatusNextTick();
ChatComponentTranslation var13;
if (!playerIn.getName().equalsIgnoreCase(var6)) {
var13 =
new ChatComponentTranslation(
"multiplayer.player.joined.renamed", new Object[] {playerIn.getDisplayName(), var6});
} else {
var13 =
new ChatComponentTranslation(
"multiplayer.player.joined", new Object[] {playerIn.getDisplayName()});
}
var13.getChatStyle().setColor(EnumChatFormatting.YELLOW);
this.sendChatMsg(var13);
this.playerLoggedIn(playerIn);
var12.setPlayerLocation(
playerIn.posX, playerIn.posY, playerIn.posZ, playerIn.rotationYaw, playerIn.rotationPitch);
this.updateTimeAndWeatherForPlayer(playerIn, var9);
if (this.mcServer.getResourcePackUrl().length() > 0) {
playerIn.func_175397_a(
this.mcServer.getResourcePackUrl(), this.mcServer.getResourcePackHash());
}
Iterator var14 = playerIn.getActivePotionEffects().iterator();
while (var14.hasNext()) {
PotionEffect var15 = (PotionEffect) var14.next();
var12.sendPacket(new S1DPacketEntityEffect(playerIn.getEntityId(), var15));
}
playerIn.addSelfToInternalCraftingInventory();
if (var7 != null && var7.hasKey("Riding", 10)) {
Entity var16 = EntityList.createEntityFromNBT(var7.getCompoundTag("Riding"), var9);
if (var16 != null) {
var16.forceSpawn = true;
var9.spawnEntityInWorld(var16);
playerIn.mountEntity(var16);
var16.forceSpawn = false;
}
}
}
/** Transfers an entity from a world to another world. */
public void transferEntityToWorld(
Entity par1Entity, int par2, WorldServer par3WorldServer, WorldServer par4WorldServer) {
double var5 = par1Entity.posX;
double var7 = par1Entity.posZ;
double var9 = 8.0D;
double var11 = par1Entity.posX;
double var13 = par1Entity.posY;
double var15 = par1Entity.posZ;
float var17 = par1Entity.rotationYaw;
par3WorldServer.theProfiler.startSection("moving");
if (par1Entity.dimension == -1) {
var5 /= var9;
var7 /= var9;
par1Entity.setLocationAndAngles(
var5, par1Entity.posY, var7, par1Entity.rotationYaw, par1Entity.rotationPitch);
if (par1Entity.isEntityAlive()) {
par3WorldServer.updateEntityWithOptionalForce(par1Entity, false);
}
} else if (par1Entity.dimension == 0) {
var5 *= var9;
var7 *= var9;
par1Entity.setLocationAndAngles(
var5, par1Entity.posY, var7, par1Entity.rotationYaw, par1Entity.rotationPitch);
if (par1Entity.isEntityAlive()) {
par3WorldServer.updateEntityWithOptionalForce(par1Entity, false);
}
} else {
ChunkCoordinates var18;
if (par2 == 1) {
var18 = par4WorldServer.getSpawnPoint();
} else {
var18 = par4WorldServer.getEntrancePortalLocation();
}
var5 = (double) var18.posX;
par1Entity.posY = (double) var18.posY;
var7 = (double) var18.posZ;
par1Entity.setLocationAndAngles(var5, par1Entity.posY, var7, 90.0F, 0.0F);
if (par1Entity.isEntityAlive()) {
par3WorldServer.updateEntityWithOptionalForce(par1Entity, false);
}
}
par3WorldServer.theProfiler.endSection();
if (par2 != 1) {
par3WorldServer.theProfiler.startSection("placing");
var5 = (double) MathHelper.clamp_int((int) var5, -29999872, 29999872);
var7 = (double) MathHelper.clamp_int((int) var7, -29999872, 29999872);
if (par1Entity.isEntityAlive()) {
par4WorldServer.spawnEntityInWorld(par1Entity);
par1Entity.setLocationAndAngles(
var5, par1Entity.posY, var7, par1Entity.rotationYaw, par1Entity.rotationPitch);
par4WorldServer.updateEntityWithOptionalForce(par1Entity, false);
par4WorldServer.func_85176_s().placeInPortal(par1Entity, var11, var13, var15, var17);
}
par3WorldServer.theProfiler.endSection();
}
par1Entity.setWorld(par4WorldServer);
}
/**
* creates and returns a respawned player based on the provided PlayerEntity. Args are the
* PlayerEntityMP to respawn, an INT for the dimension to respawn into (usually 0), and a boolean
* value that is true if the player beat the game rather than dying
*/
public EntityPlayerMP respawnPlayer(EntityPlayerMP par1EntityPlayerMP, int par2, boolean par3) {
par1EntityPlayerMP
.getServerForPlayer()
.getEntityTracker()
.removeAllTrackingPlayers(par1EntityPlayerMP);
par1EntityPlayerMP
.getServerForPlayer()
.getEntityTracker()
.removeEntityFromAllTrackingPlayers(par1EntityPlayerMP);
par1EntityPlayerMP.getServerForPlayer().getPlayerManager().removePlayer(par1EntityPlayerMP);
this.playerEntityList.remove(par1EntityPlayerMP);
this.mcServer
.worldServerForDimension(par1EntityPlayerMP.dimension)
.removeEntity(par1EntityPlayerMP);
ChunkCoordinates var4 = par1EntityPlayerMP.getBedLocation();
boolean var5 = par1EntityPlayerMP.isSpawnForced();
par1EntityPlayerMP.dimension = par2;
Object var6;
if (this.mcServer.isDemo()) {
var6 =
new DemoWorldManager(this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension));
} else {
var6 =
new ItemInWorldManager(
this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension));
}
EntityPlayerMP var7 =
new EntityPlayerMP(
this.mcServer,
this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension),
par1EntityPlayerMP.username,
(ItemInWorldManager) var6);
var7.playerNetServerHandler = par1EntityPlayerMP.playerNetServerHandler;
var7.clonePlayer(par1EntityPlayerMP, par3);
var7.entityId = par1EntityPlayerMP.entityId;
WorldServer var8 = this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension);
this.func_72381_a(var7, par1EntityPlayerMP, var8);
ChunkCoordinates var9;
if (var4 != null) {
var9 =
EntityPlayer.verifyRespawnCoordinates(
this.mcServer.worldServerForDimension(par1EntityPlayerMP.dimension), var4, var5);
if (var9 != null) {
var7.setLocationAndAngles(
(double) ((float) var9.posX + 0.5F),
(double) ((float) var9.posY + 0.1F),
(double) ((float) var9.posZ + 0.5F),
0.0F,
0.0F);
var7.setSpawnChunk(var4, var5);
} else {
var7.playerNetServerHandler.sendPacketToPlayer(new Packet70GameEvent(0, 0));
}
}
var8.theChunkProviderServer.loadChunk((int) var7.posX >> 4, (int) var7.posZ >> 4);
while (!var8.getCollidingBoundingBoxes(var7, var7.boundingBox).isEmpty()) {
var7.setPosition(var7.posX, var7.posY + 1.0D, var7.posZ);
}
var7.playerNetServerHandler.sendPacketToPlayer(
new Packet9Respawn(
var7.dimension,
(byte) var7.worldObj.difficultySetting,
var7.worldObj.getWorldInfo().getTerrainType(),
var7.worldObj.getHeight(),
var7.theItemInWorldManager.getGameType()));
var9 = var8.getSpawnPoint();
var7.playerNetServerHandler.setPlayerLocation(
var7.posX, var7.posY, var7.posZ, var7.rotationYaw, var7.rotationPitch);
var7.playerNetServerHandler.sendPacketToPlayer(
new Packet6SpawnPosition(var9.posX, var9.posY, var9.posZ));
var7.playerNetServerHandler.sendPacketToPlayer(
new Packet43Experience(var7.experience, var7.experienceTotal, var7.experienceLevel));
this.updateTimeAndWeatherForPlayer(var7, var8);
var8.getPlayerManager().addPlayer(var7);
var8.spawnEntityInWorld(var7);
this.playerEntityList.add(var7);
var7.addSelfToInternalCraftingInventory();
return var7;
}
private static Entity sendEntityToWorld(
Entity entity, int newDimension, Vector3 newPos, Facing3 newLook) {
MinecraftServer server = MinecraftServer.getServer();
Entity currentEntity = entity;
if (entity.dimension != newDimension) {
if (entity instanceof EntityPlayerMP) {
EntityPlayerMP player = (EntityPlayerMP) entity;
ServerConfigurationManager scm = server.getConfigurationManager();
int oldDimension = player.dimension;
player.dimension = newDimension;
WorldServer oldWorld = server.worldServerForDimension(oldDimension);
WorldServer newWorld = server.worldServerForDimension(newDimension);
DimensionRegisterMessage packet =
new DimensionRegisterMessage(
newDimension, DimensionManager.getProviderType(newDimension));
LCRuntime.runtime.network().getPreferredPipe().sendForgeMessageTo(packet, player);
player.closeScreen();
player.playerNetServerHandler.sendPacket(
new S07PacketRespawn(
player.dimension,
player.worldObj.difficultySetting,
newWorld.getWorldInfo().getTerrainType(),
player.theItemInWorldManager.getGameType()));
oldWorld.removePlayerEntityDangerously(player);
player.isDead = false;
player.setLocationAndAngles(
newPos.x, newPos.y, newPos.z, (float) newLook.yaw, (float) newLook.pitch);
newWorld.spawnEntityInWorld(player);
player.setWorld(newWorld);
scm.func_72375_a(player, oldWorld);
player.playerNetServerHandler.setPlayerLocation(
newPos.x, newPos.y, newPos.z, (float) newLook.yaw, (float) newLook.pitch);
player.theItemInWorldManager.setWorld(newWorld);
scm.updateTimeAndWeatherForPlayer(player, newWorld);
scm.syncPlayerInventory(player);
Iterator<?> var6 = player.getActivePotionEffects().iterator();
while (var6.hasNext())
player.playerNetServerHandler.sendPacket(
new S1DPacketEntityEffect(player.getEntityId(), (PotionEffect) var6.next()));
player.playerNetServerHandler.sendPacket(
new S1FPacketSetExperience(
player.experience, player.experienceTotal, player.experienceLevel));
} else {
int oldDimension = entity.dimension;
WorldServer oldWorld = server.worldServerForDimension(oldDimension);
WorldServer newWorld = server.worldServerForDimension(newDimension);
entity.dimension = newDimension;
entity.worldObj.removeEntity(entity);
entity.isDead = false;
server
.getConfigurationManager()
.transferEntityToWorld(entity, oldDimension, oldWorld, newWorld);
currentEntity = EntityList.createEntityByName(EntityList.getEntityString(entity), newWorld);
if (currentEntity != null) {
currentEntity.copyDataFrom(entity, true);
currentEntity.setLocationAndAngles(
newPos.x, newPos.y, newPos.z, (float) newLook.yaw, (float) newLook.pitch);
newWorld.spawnEntityInWorld(currentEntity);
}
entity.isDead = true;
oldWorld.resetUpdateEntityTick();
newWorld.resetUpdateEntityTick();
}
} else {
currentEntity.setLocationAndAngles(
newPos.x, newPos.y, newPos.z, (float) newLook.yaw, (float) newLook.pitch);
if (currentEntity instanceof EntityPlayerMP) {
EntityPlayerMP mpEnt = (EntityPlayerMP) currentEntity;
mpEnt.rotationYaw = (float) newLook.yaw;
mpEnt.setPositionAndUpdate(newPos.x, newPos.y, newPos.z);
mpEnt.worldObj.updateEntityWithOptionalForce(entity, false);
}
}
return currentEntity;
}
