| package net.glowstone.entity; |
| |
| import com.flowpowered.networking.Message; |
| import io.netty.buffer.ByteBuf; |
| import io.netty.buffer.Unpooled; |
| import net.glowstone.*; |
| import net.glowstone.block.entity.TileEntity; |
| import net.glowstone.constants.*; |
| import net.glowstone.entity.meta.ClientSettings; |
| import net.glowstone.entity.meta.MetadataIndex; |
| import net.glowstone.entity.meta.MetadataMap; |
| import net.glowstone.entity.meta.profile.PlayerProfile; |
| import net.glowstone.entity.objects.GlowItem; |
| import net.glowstone.inventory.GlowInventory; |
| import net.glowstone.inventory.InventoryMonitor; |
| import net.glowstone.io.PlayerDataService; |
| import net.glowstone.net.GlowSession; |
| import net.glowstone.net.message.login.LoginSuccessMessage; |
| import net.glowstone.net.message.play.entity.DestroyEntitiesMessage; |
| import net.glowstone.net.message.play.entity.EntityMetadataMessage; |
| import net.glowstone.net.message.play.entity.EntityVelocityMessage; |
| import net.glowstone.net.message.play.game.*; |
| import net.glowstone.net.message.play.inv.*; |
| import net.glowstone.net.message.play.player.PlayerAbilitiesMessage; |
| import net.glowstone.net.message.play.player.ResourcePackSendMessage; |
| import net.glowstone.net.protocol.ProtocolType; |
| import net.glowstone.util.StatisticMap; |
| import net.glowstone.util.TextMessage; |
| import net.glowstone.util.nbt.CompoundTag; |
| import org.apache.commons.lang.Validate; |
| import org.bukkit.*; |
| import org.bukkit.World.Environment; |
| import org.bukkit.configuration.serialization.DelegateDeserialization; |
| import org.bukkit.conversations.Conversation; |
| import org.bukkit.conversations.ConversationAbandonedEvent; |
| import org.bukkit.entity.EntityType; |
| import org.bukkit.entity.Player; |
| import org.bukkit.event.player.*; |
| import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause; |
| import org.bukkit.inventory.InventoryView; |
| import org.bukkit.inventory.ItemStack; |
| import org.bukkit.inventory.PlayerInventory; |
| import org.bukkit.map.MapView; |
| import org.bukkit.material.MaterialData; |
| import org.bukkit.plugin.Plugin; |
| import org.bukkit.plugin.messaging.StandardMessenger; |
| import org.bukkit.scoreboard.Scoreboard; |
| import org.bukkit.util.BlockVector; |
| import org.bukkit.util.Vector; |
| |
| import java.net.InetSocketAddress; |
| import java.nio.charset.StandardCharsets; |
| import java.util.*; |
| import java.util.logging.Level; |
| |
| /** |
| * Represents an in-game player. |
| * @author Graham Edgecombe |
| */ |
| @DelegateDeserialization(GlowOfflinePlayer.class) |
| public final class GlowPlayer extends GlowHumanEntity implements Player { |
| |
| /** |
| * A static entity id to use when telling the client about itself. |
| */ |
| private static final int SELF_ID = 0; |
| |
| /** |
| * This player's session. |
| */ |
| private final GlowSession session; |
| |
| /** |
| * The entities that the client knows about. |
| */ |
| private final Set<GlowEntity> knownEntities = new HashSet<>(); |
| |
| /** |
| * The entities that are hidden from the client. |
| */ |
| private final Set<UUID> hiddenEntities = new HashSet<>(); |
| |
| /** |
| * The chunks that the client knows about. |
| */ |
| private final Set<GlowChunk.Key> knownChunks = new HashSet<>(); |
| |
| /** |
| * A queue of BlockChangeMessages to be sent. |
| */ |
| private final List<BlockChangeMessage> blockChanges = new LinkedList<>(); |
| |
| /** |
| * A queue of messages that should be sent after block changes are processed. |
| * Used for sign updates and other situations where the block must be sent first. |
| */ |
| private final List<Message> afterBlockChanges = new LinkedList<>(); |
| |
| /** |
| * The set of plugin channels this player is listening on |
| */ |
| private final Set<String> listeningChannels = new HashSet<>(); |
| |
| /** |
| * The player's statistics, achievements, and related data. |
| */ |
| private final StatisticMap stats = new StatisticMap(); |
| |
| /** |
| * Whether the player has played before (will be false on first join). |
| */ |
| private final boolean hasPlayedBefore; |
| |
| /** |
| * The time the player first played, or 0 if unknown. |
| */ |
| private final long firstPlayed; |
| |
| /** |
| * The time the player last played, or 0 if unknown. |
| */ |
| private final long lastPlayed; |
| |
| /** |
| * The time the player joined. |
| */ |
| private final long joinTime; |
| |
| /** |
| * The settings sent by the client. |
| */ |
| private ClientSettings settings = ClientSettings.DEFAULT; |
| |
| /** |
| * The lock used to prevent chunks from unloading near the player. |
| */ |
| private ChunkManager.ChunkLock chunkLock; |
| |
| /** |
| * The tracker for changes to the currently open inventory. |
| */ |
| private InventoryMonitor invMonitor; |
| |
| /** |
| * The display name of this player, for chat purposes. |
| */ |
| private String displayName; |
| |
| /** |
| * The name a player has in the player list |
| */ |
| private String playerListName; |
| |
| /** |
| * Cumulative amount of experience points the player has collected. |
| */ |
| private int totalExperience = 0; |
| |
| /** |
| * The current level (or skill point amount) of the player. |
| */ |
| private int level = 0; |
| |
| /** |
| * The progress made to the next level, from 0 to 1. |
| */ |
| private float experience = 0; |
| |
| /** |
| * The human entity's current food level |
| */ |
| private int food = 20; |
| |
| /** |
| * The player's current exhaustion level. |
| */ |
| private float exhaustion = 0; |
| |
| /** |
| * The player's current saturation level. |
| */ |
| private float saturation = 0; |
| |
| /** |
| * Whether to perform special scaling of the player's health. |
| */ |
| private boolean healthScaled = false; |
| |
| /** |
| * The scale at which to display the player's health. |
| */ |
| private double healthScale = 20; |
| |
| /** |
| * This player's current time offset. |
| */ |
| private long timeOffset = 0; |
| |
| /** |
| * Whether the time offset is relative. |
| */ |
| private boolean timeRelative = true; |
| |
| /** |
| * The player-specific weather, or null for normal weather. |
| */ |
| private WeatherType playerWeather = null; |
| |
| /** |
| * The player's compass target. |
| */ |
| private Location compassTarget; |
| |
| /** |
| * Whether this player's sleeping state is ignored when changing time. |
| */ |
| private boolean sleepingIgnored; |
| |
| /** |
| * The bed spawn location of a player |
| */ |
| private Location bedSpawn; |
| |
| /** |
| * The location of the sign the player is currently editing, or null. |
| */ |
| private Location signLocation; |
| |
| /** |
| * Whether the player is permitted to fly. |
| */ |
| private boolean canFly; |
| |
| /** |
| * Whether the player is currently flying. |
| */ |
| private boolean flying; |
| |
| /** |
| * The player's base flight speed. |
| */ |
| private float flySpeed = 0.1f; |
| |
| /** |
| * The player's base walking speed. |
| */ |
| private float walkSpeed = 0.2f; |
| |
| /** |
| * Creates a new player and adds it to the world. |
| * @param session The player's session. |
| * @param profile The player's profile with name and UUID information. |
| * @param reader The PlayerReader to be used to initialize the player. |
| */ |
| public GlowPlayer(GlowSession session, PlayerProfile profile, PlayerDataService.PlayerReader reader) { |
| super(initLocation(session, reader), profile); |
| setBoundingBox(0.6, 1.8); |
| this.session = session; |
| |
| chunkLock = world.newChunkLock(getName()); |
| |
| // enable compression if needed |
| int compression = session.getServer().getCompressionThreshold(); |
| if (compression > 0) { |
| session.enableCompression(compression); |
| } |
| |
| // send login response |
| session.send(new LoginSuccessMessage(profile.getUniqueId().toString(), profile.getName())); |
| session.setProtocol(ProtocolType.PLAY); |
| |
| // send join game |
| // in future, handle hardcore, difficulty, and level type |
| String type = world.getWorldType().getName().toLowerCase(); |
| int gameMode = getGameMode().getValue(); |
| if (server.isHardcore()) { |
| gameMode |= 0x8; |
| } |
| session.send(new JoinGameMessage(SELF_ID, gameMode, world.getEnvironment().getId(), world.getDifficulty().getValue(), session.getServer().getMaxPlayers(), type, world.getGameRuleMap().getBoolean("reducedDebugInfo"))); |
| setGameModeDefaults(); |
| |
| // send server brand and supported plugin channels |
| session.send(PluginMessage.fromString("MC|Brand", server.getName())); |
| sendSupportedChannels(); |
| |
| // read data from player reader |
| hasPlayedBefore = reader.hasPlayedBefore(); |
| if (hasPlayedBefore) { |
| firstPlayed = reader.getFirstPlayed(); |
| lastPlayed = reader.getLastPlayed(); |
| bedSpawn = reader.getBedSpawnLocation(); |
| } else { |
| firstPlayed = 0; |
| lastPlayed = 0; |
| } |
| joinTime = System.currentTimeMillis(); |
| reader.readData(this); |
| reader.close(); |
| |
| // Add player to list of online players |
| getServer().setPlayerOnline(this, true); |
| |
| // save data back out |
| saveData(); |
| |
| streamBlocks(); // stream the initial set of blocks |
| setCompassTarget(world.getSpawnLocation()); // set our compass target |
| sendTime(); |
| sendWeather(); |
| sendRainDensity(); |
| sendSkyDarkness(); |
| sendAbilities(); |
| |
| invMonitor = new InventoryMonitor(getOpenInventory()); |
| updateInventory(); // send inventory contents |
| |
| // send initial location |
| session.send(new PositionRotationMessage(location)); |
| |
| if (!server.getResourcePackURL().isEmpty()) { |
| setResourcePack(server.getResourcePackURL(), server.getResourcePackHash()); |
| } |
| } |
| |
| /** |
| * Read the location from a PlayerReader for entity initialization. Will |
| * fall back to a reasonable default rather than returning null. |
| * @param session The player's session. |
| * @param reader The PlayerReader to get the location from. |
| * @return The location to spawn the player. |
| */ |
| private static Location initLocation(GlowSession session, PlayerDataService.PlayerReader reader) { |
| if (reader.hasPlayedBefore()) { |
| Location loc = reader.getLocation(); |
| if (loc != null) { |
| return loc; |
| } |
| } |
| return session.getServer().getWorlds().get(0).getSpawnLocation(); |
| } |
| |
| @Override |
| public String toString() { |
| return "GlowPlayer{name=" + getName() + "}"; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Internals |
| |
| /** |
| * Get the network session attached to this player. |
| * @return The GlowSession of the player. |
| */ |
| public GlowSession getSession() { |
| return session; |
| } |
| |
| /** |
| * Get the join time in milliseconds, to be saved as last played time. |
| * @return The player's join time. |
| */ |
| public long getJoinTime() { |
| return joinTime; |
| } |
| |
| /** |
| * Destroys this entity by removing it from the world and marking it as not |
| * being active. |
| */ |
| @Override |
| public void remove() { |
| knownChunks.clear(); |
| chunkLock.clear(); |
| saveData(); |
| getInventory().removeViewer(this); |
| getInventory().getCraftingInventory().removeViewer(this); |
| permissions.clearPermissions(); |
| getServer().setPlayerOnline(this, false); |
| super.remove(); |
| } |
| |
| @Override |
| public boolean shouldSave() { |
| return false; |
| } |
| |
| @Override |
| public void pulse() { |
| super.pulse(); |
| |
| // stream world |
| streamBlocks(); |
| processBlockChanges(); |
| |
| // add to playtime |
| incrementStatistic(Statistic.PLAY_ONE_TICK); |
| |
| // update inventory |
| for (InventoryMonitor.Entry entry : invMonitor.getChanges()) { |
| sendItemChange(entry.slot, entry.item); |
| } |
| |
| // send changed metadata |
| List<MetadataMap.Entry> changes = metadata.getChanges(); |
| if (changes.size() > 0) { |
| session.send(new EntityMetadataMessage(SELF_ID, changes)); |
| } |
| |
| // update or remove entities |
| List<Integer> destroyIds = new LinkedList<>(); |
| for (Iterator<GlowEntity> it = knownEntities.iterator(); it.hasNext(); ) { |
| GlowEntity entity = it.next(); |
| if (isWithinDistance(entity)) { |
| for (Message msg : entity.createUpdateMessage()) { |
| session.send(msg); |
| } |
| } else { |
| destroyIds.add(entity.getEntityId()); |
| it.remove(); |
| } |
| } |
| if (destroyIds.size() > 0) { |
| session.send(new DestroyEntitiesMessage(destroyIds)); |
| } |
| |
| // add entities |
| for (GlowEntity entity : world.getEntityManager()) { |
| if (entity != this && isWithinDistance(entity) && |
| !knownEntities.contains(entity) && !hiddenEntities.contains(entity.getUniqueId())) { |
| knownEntities.add(entity); |
| for (Message msg : entity.createSpawnMessage()) { |
| session.send(msg); |
| } |
| } |
| } |
| |
| getAttributeManager().sendMessages(session); |
| } |
| |
| /** |
| * Process and send pending BlockChangeMessages. |
| */ |
| private void processBlockChanges() { |
| List<BlockChangeMessage> messages = new ArrayList<>(blockChanges); |
| blockChanges.clear(); |
| |
| // separate messages by chunk |
| // inner map is used to only send one entry for same coordinates |
| Map<GlowChunk.Key, Map<BlockVector, BlockChangeMessage>> chunks = new HashMap<>(); |
| for (BlockChangeMessage message : messages) { |
| GlowChunk.Key key = new GlowChunk.Key(message.getX() >> 4, message.getZ() >> 4); |
| Map<BlockVector, BlockChangeMessage> map = chunks.get(key); |
| if (map == null) { |
| map = new HashMap<>(); |
| chunks.put(key, map); |
| } |
| map.put(new BlockVector(message.getX(), message.getY(), message.getZ()), message); |
| } |
| |
| // send away |
| for (Map.Entry<GlowChunk.Key, Map<BlockVector, BlockChangeMessage>> entry : chunks.entrySet()) { |
| GlowChunk.Key key = entry.getKey(); |
| List<BlockChangeMessage> value = new ArrayList<>(entry.getValue().values()); |
| |
| if (value.size() == 1) { |
| session.send(value.get(0)); |
| } else if (value.size() > 1) { |
| session.send(new MultiBlockChangeMessage(key.getX(), key.getZ(), value)); |
| } |
| } |
| |
| // now send post-block-change messages |
| List<Message> postMessages = new ArrayList<>(afterBlockChanges); |
| afterBlockChanges.clear(); |
| for (Message message : postMessages) { |
| session.send(message); |
| } |
| } |
| |
| /** |
| * Streams chunks to the player's client. |
| */ |
| private void streamBlocks() { |
| Set<GlowChunk.Key> previousChunks = new HashSet<>(knownChunks); |
| ArrayList<GlowChunk.Key> newChunks = new ArrayList<>(); |
| |
| int centralX = location.getBlockX() >> 4; |
| int centralZ = location.getBlockZ() >> 4; |
| |
| int radius = Math.min(server.getViewDistance(), 1 + settings.getViewDistance()); |
| for (int x = (centralX - radius); x <= (centralX + radius); x++) { |
| for (int z = (centralZ - radius); z <= (centralZ + radius); z++) { |
| GlowChunk.Key key = new GlowChunk.Key(x, z); |
| if (knownChunks.contains(key)) { |
| previousChunks.remove(key); |
| } else { |
| newChunks.add(key); |
| } |
| } |
| } |
| |
| // early end if there's no changes |
| if (newChunks.size() == 0 && previousChunks.size() == 0) { |
| return; |
| } |
| |
| // sort chunks by distance from player - closer chunks sent first |
| Collections.sort(newChunks, new Comparator<GlowChunk.Key>() { |
| @Override |
| public int compare(GlowChunk.Key a, GlowChunk.Key b) { |
| double dx = 16 * a.getX() + 8 - location.getX(); |
| double dz = 16 * a.getZ() + 8 - location.getZ(); |
| double da = dx * dx + dz * dz; |
| dx = 16 * b.getX() + 8 - location.getX(); |
| dz = 16 * b.getZ() + 8 - location.getZ(); |
| double db = dx * dx + dz * dz; |
| return Double.compare(da, db); |
| } |
| }); |
| |
| // populate then send chunks to the player |
| // done in two steps so that all the new chunks are finalized before any of them are sent |
| // this prevents sending a chunk then immediately sending block changes in it because |
| // one of its neighbors has populated |
| |
| // first step: force population then acquire lock on each chunk |
| for (GlowChunk.Key key : newChunks) { |
| world.getChunkManager().forcePopulation(key.getX(), key.getZ()); |
| knownChunks.add(key); |
| chunkLock.acquire(key); |
| } |
| |
| // second step: package chunks into bulk packets |
| final int maxSize = 0x1fff00; // slightly under protocol max size of 0x200000 |
| final boolean skylight = world.getEnvironment() == World.Environment.NORMAL; |
| final List<ChunkDataMessage> messages = new LinkedList<>(); |
| int bulkSize = 6; // size of bulk header |
| |
| // split the chunks into bulk packets based on how many fit |
| for (GlowChunk.Key key : newChunks) { |
| GlowChunk chunk = world.getChunkAt(key.getX(), key.getZ()); |
| ChunkDataMessage message = chunk.toMessage(skylight); |
| // 10 bytes of header in bulk packet, plus data length |
| int messageSize = 10 + message.getData().length; |
| |
| // if this chunk would make the message too big, |
| if (bulkSize + messageSize > maxSize) { |
| // send out what we have so far |
| session.send(new ChunkBulkMessage(skylight, messages)); |
| messages.clear(); |
| bulkSize = 6; |
| } |
| |
| bulkSize += messageSize; |
| messages.add(message); |
| } |
| |
| // send the leftovers |
| if (!messages.isEmpty()) { |
| session.send(new ChunkBulkMessage(skylight, messages)); |
| messages.clear(); |
| } |
| |
| // send visible tile entity data |
| for (GlowChunk.Key key : newChunks) { |
| GlowChunk chunk = world.getChunkAt(key.getX(), key.getZ()); |
| for (TileEntity entity : chunk.getRawTileEntities()) { |
| entity.update(this); |
| } |
| } |
| |
| // and remove old chunks |
| for (GlowChunk.Key key : previousChunks) { |
| session.send(ChunkDataMessage.empty(key.getX(), key.getZ())); |
| knownChunks.remove(key); |
| chunkLock.release(key); |
| } |
| |
| previousChunks.clear(); |
| } |
| |
| /** |
| * Spawn the player at the given location after they have already joined. |
| * Used for changing worlds and respawning after death. |
| * @param location The location to place the player. |
| */ |
| private void spawnAt(Location location) { |
| // switch worlds |
| GlowWorld oldWorld = world; |
| world.getEntityManager().unregister(this); |
| world = (GlowWorld) location.getWorld(); |
| world.getEntityManager().register(this); |
| |
| // switch chunk set |
| // no need to send chunk unload messages - respawn unloads all chunks |
| knownChunks.clear(); |
| chunkLock.clear(); |
| chunkLock = world.newChunkLock(getName()); |
| |
| // spawn into world |
| String type = world.getWorldType().getName().toLowerCase(); |
| session.send(new RespawnMessage(world.getEnvironment().getId(), world.getDifficulty().getValue(), getGameMode().getValue(), type)); |
| setRawLocation(location); // take us to spawn position |
| streamBlocks(); // stream blocks |
| setCompassTarget(world.getSpawnLocation()); // set our compass target |
| session.send(new PositionRotationMessage(location)); |
| sendWeather(); |
| sendRainDensity(); |
| sendSkyDarkness(); |
| sendTime(); |
| updateInventory(); |
| |
| // fire world change if needed |
| if (oldWorld != world) { |
| EventFactory.callEvent(new PlayerChangedWorldEvent(this, oldWorld)); |
| } |
| } |
| |
| /** |
| * Respawn the player after they have died. |
| */ |
| public void respawn() { |
| // restore health |
| setHealth(getMaxHealth()); |
| |
| // determine spawn destination |
| boolean spawnAtBed = false; |
| Location dest = world.getSpawnLocation(); |
| if (bedSpawn != null) { |
| if (bedSpawn.getBlock().getType() == Material.BED_BLOCK) { |
| // todo: spawn next to the bed instead of inside it |
| dest = bedSpawn.clone(); |
| spawnAtBed = true; |
| } |
| } |
| |
| // fire event and perform spawn |
| PlayerRespawnEvent event = new PlayerRespawnEvent(this, dest, spawnAtBed); |
| EventFactory.callEvent(event); |
| if (event.getRespawnLocation().getWorld().equals(getWorld()) && knownEntities.size() > 0) { |
| // we need to manually reset all known entities if the player respawns in the same world |
| List<Integer> entityIds = new ArrayList<>(knownEntities.size()); |
| for (GlowEntity e : knownEntities) { |
| entityIds.add(e.getEntityId()); |
| } |
| session.send(new DestroyEntitiesMessage(entityIds)); |
| knownEntities.clear(); |
| } |
| spawnAt(event.getRespawnLocation()); |
| |
| // just in case any items are left in their inventory after they respawn |
| updateInventory(); |
| } |
| |
| /** |
| * Checks whether the player can see the given chunk. |
| * @return If the chunk is known to the player's client. |
| */ |
| public boolean canSeeChunk(GlowChunk.Key chunk) { |
| return knownChunks.contains(chunk); |
| } |
| |
| /** |
| * Checks whether the player can see the given entity. |
| * @return If the entity is known to the player's client. |
| */ |
| public boolean canSeeEntity(GlowEntity entity) { |
| return knownEntities.contains(entity); |
| } |
| |
| /** |
| * Open the sign editor interface at the specified location. |
| * @param loc The location to open the editor at |
| */ |
| public void openSignEditor(Location loc) { |
| signLocation = loc.clone(); |
| signLocation.setX(loc.getBlockX()); |
| signLocation.setY(loc.getBlockY()); |
| signLocation.setZ(loc.getBlockZ()); |
| session.send(new SignEditorMessage(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ())); |
| } |
| |
| /** |
| * Check that the specified location matches that of the last opened sign |
| * editor, and if so, clears the last opened sign editor. |
| * @param loc The location to check |
| * @return Whether the location matched. |
| */ |
| public boolean checkSignLocation(Location loc) { |
| if (loc.equals(signLocation)) { |
| signLocation = null; |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| /** |
| * Get a UserListItemMessage entry representing adding this player. |
| * @return The entry (action ADD_PLAYER) with this player's information. |
| */ |
| public UserListItemMessage.Entry getUserListEntry() { |
| TextMessage displayName = null; |
| if (playerListName != null && !playerListName.isEmpty()) { |
| displayName = new TextMessage(playerListName); |
| } |
| return UserListItemMessage.add(getProfile(), getGameMode().getValue(), 0, displayName); |
| } |
| |
| /** |
| * Send a UserListItemMessage to every player that can see this player. |
| * @param updateMessage The message to send. |
| */ |
| private void updateUserListEntries(UserListItemMessage updateMessage) { |
| for (GlowPlayer player : server.getOnlinePlayers()) { |
| if (player.canSee(this)) { |
| player.getSession().send(updateMessage); |
| } |
| } |
| } |
| |
| @Override |
| public void setVelocity(Vector velocity) { |
| PlayerVelocityEvent event = EventFactory.callEvent(new PlayerVelocityEvent(this, velocity)); |
| if (!event.isCancelled()) { |
| velocity = event.getVelocity(); |
| super.setVelocity(velocity); |
| session.send(new EntityVelocityMessage(SELF_ID, velocity)); |
| } |
| } |
| |
| /** |
| * Set the client settings for this player. |
| * @param settings The new client settings. |
| */ |
| public void setSettings(ClientSettings settings) { |
| this.settings = settings; |
| metadata.set(MetadataIndex.PLAYER_SKIN_FLAGS, settings.getSkinFlags()); |
| } |
| |
| /** |
| * Get this player's client settings. |
| * @return The player's client settings. |
| */ |
| public ClientSettings getSettings() { |
| return settings; |
| } |
| |
| @Override |
| public Map<String, Object> serialize() { |
| Map<String, Object> ret = new HashMap<>(); |
| ret.put("name", getName()); |
| return ret; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Basic stuff |
| |
| @Override |
| public EntityType getType() { |
| return EntityType.PLAYER; |
| } |
| |
| @Override |
| public InetSocketAddress getAddress() { |
| return session.getAddress(); |
| } |
| |
| @Override |
| public boolean isOnline() { |
| return session.isActive(); |
| } |
| |
| @Override |
| public boolean isBanned() { |
| return server.getBanList(BanList.Type.NAME).isBanned(getName()); |
| } |
| |
| @Override |
| @Deprecated |
| public void setBanned(boolean banned) { |
| server.getBanList(BanList.Type.NAME).addBan(getName(), null, null, null); |
| } |
| |
| @Override |
| public boolean isWhitelisted() { |
| return server.getWhitelist().containsUUID(getUniqueId()); |
| } |
| |
| @Override |
| public void setWhitelisted(boolean value) { |
| if (value) { |
| server.getWhitelist().add(this); |
| } else { |
| server.getWhitelist().remove(getUniqueId()); |
| } |
| } |
| |
| @Override |
| public Player getPlayer() { |
| return this; |
| } |
| |
| @Override |
| public boolean hasPlayedBefore() { |
| return hasPlayedBefore; |
| } |
| |
| @Override |
| public long getFirstPlayed() { |
| return firstPlayed; |
| } |
| |
| @Override |
| public long getLastPlayed() { |
| return lastPlayed; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // HumanEntity overrides |
| |
| @Override |
| public boolean isOp() { |
| return getServer().getOpsList().containsUUID(getUniqueId()); |
| } |
| |
| @Override |
| public void setOp(boolean value) { |
| if (value) { |
| getServer().getOpsList().add(this); |
| } else { |
| getServer().getOpsList().remove(getUniqueId()); |
| } |
| permissions.recalculatePermissions(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Editable properties |
| |
| @Override |
| public String getDisplayName() { |
| return displayName == null ? getName() : displayName; |
| } |
| |
| @Override |
| public void setDisplayName(String name) { |
| displayName = name; |
| } |
| |
| @Override |
| public String getPlayerListName() { |
| return playerListName == null || playerListName.isEmpty() ? getName() : playerListName; |
| } |
| |
| @Override |
| public void setPlayerListName(String name) { |
| // update state |
| playerListName = name; |
| |
| // send update message |
| TextMessage displayName = null; |
| if (playerListName != null && !playerListName.isEmpty()) { |
| displayName = new TextMessage(playerListName); |
| } |
| updateUserListEntries(UserListItemMessage.displayNameOne(getUniqueId(), displayName)); |
| } |
| |
| @Override |
| public Location getCompassTarget() { |
| return compassTarget; |
| } |
| |
| @Override |
| public void setCompassTarget(Location loc) { |
| compassTarget = loc; |
| session.send(new SpawnPositionMessage(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ())); |
| } |
| |
| @Override |
| public Location getBedSpawnLocation() { |
| return bedSpawn; |
| } |
| |
| @Override |
| public void setBedSpawnLocation(Location bedSpawn) { |
| setBedSpawnLocation(bedSpawn, false); |
| } |
| |
| @Override |
| public void setBedSpawnLocation(Location location, boolean force) { |
| this.bedSpawn = location; |
| } |
| |
| @Override |
| public boolean isSleepingIgnored() { |
| return sleepingIgnored; |
| } |
| |
| @Override |
| public void setSleepingIgnored(boolean isSleeping) { |
| sleepingIgnored = isSleeping; |
| } |
| |
| @Override |
| public void setGameMode(GameMode mode) { |
| if (getGameMode() != mode) { |
| PlayerGameModeChangeEvent event = new PlayerGameModeChangeEvent(this, mode); |
| if (EventFactory.callEvent(event).isCancelled()) { |
| return; |
| } |
| |
| super.setGameMode(mode); |
| updateUserListEntries(UserListItemMessage.gameModeOne(getUniqueId(), mode.getValue())); |
| session.send(new StateChangeMessage(StateChangeMessage.Reason.GAMEMODE, mode.getValue())); |
| } |
| setGameModeDefaults(); |
| } |
| |
| private void setGameModeDefaults() { |
| GameMode mode = getGameMode(); |
| setAllowFlight(mode == GameMode.CREATIVE || mode == GameMode.SPECTATOR); |
| metadata.setBit(MetadataIndex.STATUS, MetadataIndex.StatusFlags.INVISIBLE, mode == GameMode.SPECTATOR); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Entity status |
| |
| @Override |
| public boolean isSneaking() { |
| return metadata.getBit(MetadataIndex.STATUS, MetadataIndex.StatusFlags.SNEAKING); |
| } |
| |
| @Override |
| public void setSneaking(boolean sneak) { |
| if (EventFactory.callEvent(new PlayerToggleSneakEvent(this, sneak)).isCancelled()) { |
| return; |
| } |
| |
| metadata.setBit(MetadataIndex.STATUS, MetadataIndex.StatusFlags.SNEAKING, sneak); |
| } |
| |
| @Override |
| public boolean isSprinting() { |
| return metadata.getBit(MetadataIndex.STATUS, MetadataIndex.StatusFlags.SPRINTING); |
| } |
| |
| @Override |
| public void setSprinting(boolean sprinting) { |
| if (EventFactory.callEvent(new PlayerToggleSprintEvent(this, sprinting)).isCancelled()) { |
| return; |
| } |
| |
| metadata.setBit(MetadataIndex.STATUS, MetadataIndex.StatusFlags.SPRINTING, sprinting); |
| } |
| |
| @Override |
| public double getEyeHeight() { |
| return getEyeHeight(false); |
| } |
| |
| @Override |
| public double getEyeHeight(boolean ignoreSneaking) { |
| // Height of player's eyes above feet. Matches CraftBukkit. |
| if (ignoreSneaking || !isSneaking()) { |
| return 1.62; |
| } else { |
| return 1.54; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Player capabilities |
| |
| @Override |
| public boolean getAllowFlight() { |
| return canFly; |
| } |
| |
| @Override |
| public void setAllowFlight(boolean flight) { |
| canFly = flight; |
| if (!canFly) flying = false; |
| sendAbilities(); |
| } |
| |
| @Override |
| public boolean isFlying() { |
| return flying; |
| } |
| |
| @Override |
| public void setFlying(boolean value) { |
| flying = value && canFly; |
| sendAbilities(); |
| } |
| |
| @Override |
| public float getFlySpeed() { |
| return flySpeed; |
| } |
| |
| @Override |
| public void setFlySpeed(float value) throws IllegalArgumentException { |
| flySpeed = value; |
| sendAbilities(); |
| } |
| |
| @Override |
| public float getWalkSpeed() { |
| return walkSpeed; |
| } |
| |
| @Override |
| public void setWalkSpeed(float value) throws IllegalArgumentException { |
| walkSpeed = value; |
| sendAbilities(); |
| } |
| |
| private void sendAbilities() { |
| boolean creative = getGameMode() == GameMode.CREATIVE; |
| int flags = (creative ? 8 : 0) | (canFly ? 4 : 0) | (flying ? 2 : 0) | (creative ? 1 : 0); |
| // division is conversion from Bukkit to MC units |
| session.send(new PlayerAbilitiesMessage(flags, flySpeed / 2f, walkSpeed / 2f)); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Experience and levelling |
| |
| @Override |
| public int getLevel() { |
| return level; |
| } |
| |
| @Override |
| public void setLevel(int level) { |
| this.level = Math.max(level, 0); |
| sendExperience(); |
| } |
| |
| @Override |
| public int getTotalExperience() { |
| return totalExperience; |
| } |
| |
| @Override |
| public void setTotalExperience(int exp) { |
| this.totalExperience = Math.max(exp, 0); |
| sendExperience(); |
| } |
| |
| @Override |
| public void giveExp(int xp) { |
| totalExperience += xp; |
| |
| // gradually award levels based on xp points |
| float value = 1.0f / getExpToLevel(); |
| for (int i = 0; i < xp; ++i) { |
| experience += value; |
| if (experience >= 1) { |
| experience -= 1; |
| value = 1.0f / getExpToLevel(++level); |
| } |
| } |
| sendExperience(); |
| } |
| |
| @Override |
| public float getExp() { |
| return experience; |
| } |
| |
| @Override |
| public void setExp(float percentToLevel) { |
| experience = Math.min(Math.max(percentToLevel, 0), 1); |
| sendExperience(); |
| } |
| |
| @Override |
| public int getExpToLevel() { |
| return getExpToLevel(level); |
| } |
| |
| private int getExpToLevel(int level) { |
| if (level >= 30) { |
| return 62 + (level - 30) * 7; |
| } else if (level >= 15) { |
| return 17 + (level - 15) * 3; |
| } else { |
| return 17; |
| } |
| } |
| |
| @Override |
| public void giveExpLevels(int amount) { |
| setLevel(getLevel() + amount); |
| } |
| |
| private void sendExperience() { |
| session.send(new ExperienceMessage(getExp(), getLevel(), getTotalExperience())); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Health and food handling |
| |
| @Override |
| public void setHealth(double health) { |
| super.setHealth(health); |
| sendHealth(); |
| } |
| |
| @Override |
| public void setMaxHealth(double health) { |
| super.setMaxHealth(health); |
| sendHealth(); |
| } |
| |
| @Override |
| public boolean isHealthScaled() { |
| return healthScaled; |
| } |
| |
| @Override |
| public void setHealthScaled(boolean scale) { |
| healthScaled = scale; |
| sendHealth(); |
| } |
| |
| @Override |
| public double getHealthScale() { |
| return healthScale; |
| } |
| |
| @Override |
| public void setHealthScale(double scale) throws IllegalArgumentException { |
| healthScaled = true; |
| healthScale = scale; |
| sendHealth(); |
| } |
| |
| @Override |
| public int getFoodLevel() { |
| return food; |
| } |
| |
| @Override |
| public void setFoodLevel(int food) { |
| this.food = Math.min(food, 20); |
| sendHealth(); |
| } |
| |
| @Override |
| public float getExhaustion() { |
| return exhaustion; |
| } |
| |
| @Override |
| public void setExhaustion(float value) { |
| exhaustion = value; |
| } |
| |
| @Override |
| public float getSaturation() { |
| return saturation; |
| } |
| |
| @Override |
| public void setSaturation(float value) { |
| saturation = value; |
| sendHealth(); |
| } |
| |
| private void sendHealth() { |
| float finalHealth = (float) (getHealth() / getMaxHealth() * getHealthScale()); |
| session.send(new HealthMessage(finalHealth, getFoodLevel(), getSaturation())); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Actions |
| |
| @Override |
| public boolean teleport(Location location) { |
| return teleport(location, TeleportCause.UNKNOWN); |
| } |
| |
| @Override |
| public boolean teleport(Location location, TeleportCause cause) { |
| Validate.notNull(location, "location cannot be null"); |
| Validate.notNull(location.getWorld(), "location's world cannot be null"); |
| Validate.notNull(cause, "cause cannot be null"); |
| |
| if (this.location != null && this.location.getWorld() != null) { |
| PlayerTeleportEvent event = new PlayerTeleportEvent(this, this.location, location, cause); |
| if (EventFactory.callEvent(event).isCancelled()) { |
| return false; |
| } |
| location = event.getTo(); |
| } |
| |
| if (location.getWorld() != world) { |
| spawnAt(location); |
| } else { |
| session.send(new PositionRotationMessage(location)); |
| setRawLocation(location); |
| } |
| |
| teleported = true; |
| return true; |
| } |
| |
| @Override |
| protected boolean teleportToSpawn() { |
| Location target = getBedSpawnLocation(); |
| if (target == null) { |
| target = server.getWorlds().get(0).getSpawnLocation(); |
| } |
| |
| PlayerPortalEvent event = EventFactory.callEvent(new PlayerPortalEvent(this, location.clone(), target, null)); |
| if (event.isCancelled()) { |
| return false; |
| } |
| target = event.getTo(); |
| |
| spawnAt(target); |
| teleported = true; |
| |
| awardAchievement(Achievement.THE_END, false); |
| return true; |
| } |
| |
| @Override |
| protected boolean teleportToEnd() { |
| if (!server.getAllowEnd()) { |
| return false; |
| } |
| Location target = null; |
| for (World world : server.getWorlds()) { |
| if (world.getEnvironment() == Environment.THE_END) { |
| target = world.getSpawnLocation(); |
| break; |
| } |
| } |
| if (target == null) { |
| return false; |
| } |
| |
| PlayerPortalEvent event = EventFactory.callEvent(new PlayerPortalEvent(this, location.clone(), target, null)); |
| if (event.isCancelled()) { |
| return false; |
| } |
| target = event.getTo(); |
| |
| spawnAt(target); |
| teleported = true; |
| |
| awardAchievement(Achievement.END_PORTAL, false); |
| return true; |
| } |
| |
| @Override |
| public void sendMessage(String message) { |
| sendRawMessage(message); |
| } |
| |
| @Override |
| public void sendMessage(String[] messages) { |
| for (String line : messages) { |
| sendMessage(line); |
| } |
| } |
| |
| @Override |
| public void sendRawMessage(String message) { |
| // old-style formatting to json conversion is in TextMessage |
| session.send(new ChatMessage(message)); |
| } |
| |
| @Override |
| public void kickPlayer(String message) { |
| session.disconnect(message == null ? "" : message); |
| } |
| |
| @Override |
| public boolean performCommand(String command) { |
| return getServer().dispatchCommand(this, command); |
| } |
| |
| @Override |
| public void chat(String text) { |
| chat(text, false); |
| } |
| |
| /** |
| * Says a message (or runs a command). |
| * @param text message sent by the player. |
| * @param async whether the message was received asynchronously. |
| */ |
| public void chat(final String text, boolean async) { |
| if (text.startsWith("/")) { |
| Runnable task = new Runnable() { |
| @Override |
| public void run() { |
| server.getLogger().info(getName() + " issued command: " + text); |
| try { |
| PlayerCommandPreprocessEvent event = new PlayerCommandPreprocessEvent(GlowPlayer.this, text); |
| if (!EventFactory.callEvent(event).isCancelled()) { |
| server.dispatchCommand(GlowPlayer.this, event.getMessage().substring(1)); |
| } |
| } catch (Exception ex) { |
| sendMessage(ChatColor.RED + "An internal error occurred while executing your command."); |
| server.getLogger().log(Level.SEVERE, "Exception while executing command: " + text, ex); |
| } |
| } |
| }; |
| |
| // if async is true, this task should happen synchronously |
| // otherwise, we're sync already, it can happen here |
| if (async) { |
| server.getScheduler().runTask(null, task); |
| } else { |
| task.run(); |
| } |
| } else { |
| AsyncPlayerChatEvent event = EventFactory.onPlayerChat(async, this, text); |
| if (event.isCancelled()) { |
| return; |
| } |
| |
| String message = String.format(event.getFormat(), getDisplayName(), event.getMessage()); |
| getServer().getLogger().info(message); |
| for (Player recipient : event.getRecipients()) { |
| recipient.sendMessage(message); |
| } |
| } |
| } |
| |
| @Override |
| public void saveData() { |
| saveData(true); |
| } |
| |
| public void saveData(boolean async) { |
| if (async) { |
| server.getScheduler().runTaskAsynchronously(null, new Runnable() { |
| @Override |
| public void run() { |
| server.getPlayerDataService().writeData(GlowPlayer.this); |
| } |
| }); |
| } else { |
| server.getPlayerDataService().writeData(this); |
| } |
| } |
| |
| @Override |
| public void loadData() { |
| server.getPlayerDataService().readData(this); |
| } |
| |
| @Override |
| @Deprecated |
| public void setTexturePack(String url) { |
| setResourcePack(url); |
| } |
| |
| @Override |
| public void setResourcePack(String url) { |
| setResourcePack(url, ""); |
| } |
| |
| @Override |
| public void setResourcePack(String url, String hash) { |
| session.send(new ResourcePackSendMessage(url, hash)); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Effect and data transmission |
| |
| @Override |
| public void playNote(Location loc, Instrument instrument, Note note) { |
| playNote(loc, instrument.getType(), note.getId()); |
| } |
| |
| @Override |
| public void playNote(Location loc, byte instrument, byte note) { |
| session.send(new BlockActionMessage(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), instrument, note, Material.NOTE_BLOCK.getId())); |
| } |
| |
| @Override |
| public void playEffect(Location loc, Effect effect, int data) { |
| int id = effect.getId(); |
| boolean ignoreDistance = effect.isDistanceIgnored(); |
| session.send(new PlayEffectMessage(id, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), data, ignoreDistance)); |
| } |
| |
| @Override |
| public <T> void playEffect(Location loc, Effect effect, T data) { |
| playEffect(loc, effect, GlowEffect.getDataValue(effect, data)); |
| } |
| |
| @Override |
| public void playSound(Location location, Sound sound, float volume, float pitch) { |
| playSound(location, GlowSound.getName(sound), volume, pitch); |
| } |
| |
| @Override |
| public void playSound(Location location, String sound, float volume, float pitch) { |
| if (location == null || sound == null) return; |
| // the loss of precision here is a bit unfortunate but it's what CraftBukkit does |
| double x = location.getBlockX() + 0.5; |
| double y = location.getBlockY() + 0.5; |
| double z = location.getBlockZ() + 0.5; |
| session.send(new PlaySoundMessage(sound, x, y, z, volume, pitch)); |
| } |
| |
| @Override |
| public void showParticle(Location loc, Particle particle, float offsetX, float offsetY, float offsetZ, float speed, int amount) { |
| showParticle(loc, particle, null, offsetX, offsetY, offsetZ, speed, amount); |
| } |
| |
| @Override |
| public void showParticle(Location loc, Particle particle, MaterialData material, float offsetX, float offsetY, float offsetZ, float speed, int amount) { |
| if (location == null || particle == null) return; |
| |
| int id = GlowParticle.getId(particle); |
| boolean longDistance = GlowParticle.isLongDistance(particle); |
| float x = (float) loc.getX(); |
| float y = (float) loc.getY(); |
| float z = (float) loc.getZ(); |
| int[] extData = GlowParticle.getData(particle, material); |
| session.send(new PlayParticleMessage(id, longDistance, x, y, z, offsetX, offsetY, offsetZ, speed, amount, extData)); |
| } |
| |
| @Override |
| public void sendBlockChange(Location loc, Material material, byte data) { |
| sendBlockChange(loc, material.getId(), data); |
| } |
| |
| @Override |
| public void sendBlockChange(Location loc, int material, byte data) { |
| sendBlockChange(new BlockChangeMessage(loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), material, data)); |
| } |
| |
| public void sendBlockChange(BlockChangeMessage message) { |
| // only send message if the chunk is within visible range |
| GlowChunk.Key key = new GlowChunk.Key(message.getX() >> 4, message.getZ() >> 4); |
| if (canSeeChunk(key)) { |
| blockChanges.add(message); |
| } |
| } |
| |
| @Override |
| public boolean sendChunkChange(Location loc, int sx, int sy, int sz, byte[] data) { |
| throw new UnsupportedOperationException("Not supported yet."); |
| } |
| |
| @Override |
| public void sendSignChange(Location location, String[] lines) throws IllegalArgumentException { |
| Validate.notNull(location, "location cannot be null"); |
| Validate.notNull(lines, "lines cannot be null"); |
| Validate.isTrue(lines.length == 4, "lines.length must equal 4"); |
| |
| afterBlockChanges.add(UpdateSignMessage.fromPlainText(location.getBlockX(), location.getBlockY(), location.getBlockZ(), lines)); |
| } |
| |
| /** |
| * Send a sign change, similar to {@link #sendSignChange(Location, String[])}, |
| * but using complete TextMessages instead of strings. |
| * @param location the location of the sign |
| * @param lines the new text on the sign or null to clear it |
| * @throws IllegalArgumentException if location is null |
| * @throws IllegalArgumentException if lines is non-null and has a length less than 4 |
| */ |
| public void sendSignChange(Location location, TextMessage[] lines) { |
| Validate.notNull(location, "location cannot be null"); |
| Validate.notNull(lines, "lines cannot be null"); |
| Validate.isTrue(lines.length == 4, "lines.length must equal 4"); |
| |
| afterBlockChanges.add(new UpdateSignMessage(location.getBlockX(), location.getBlockY(), location.getBlockZ(), lines)); |
| } |
| |
| /** |
| * Send a block entity change to the given location. |
| * @param location The location of the block entity. |
| * @param type The type of block entity being sent. |
| * @param nbt The NBT structure to send to the client. |
| */ |
| public void sendBlockEntityChange(Location location, GlowBlockEntity type, CompoundTag nbt) { |
| Validate.notNull(location, "Location cannot be null"); |
| Validate.notNull(type, "Type cannot be null"); |
| Validate.notNull(nbt, "NBT cannot be null"); |
| |
| afterBlockChanges.add(new UpdateBlockEntityMessage(location.getBlockX(), location.getBlockY(), location.getBlockZ(), type.getValue(), nbt)); |
| } |
| |
| @Override |
| public void sendMap(MapView map) { |
| throw new UnsupportedOperationException("Not supported yet."); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Achievements and statistics |
| |
| @Override |
| public boolean hasAchievement(Achievement achievement) { |
| return stats.hasAchievement(achievement); |
| } |
| |
| @Override |
| public void awardAchievement(Achievement achievement) { |
| awardAchievement(achievement, true); |
| } |
| |
| /** |
| * Awards the given achievement if the player already has the parent achievement, |
| * otherwise does nothing. If {@code awardParents} is true, award the player all |
| * parent achievements and the given achievement, making this method equivalent |
| * to {@link #awardAchievement(Achievement)}. |
| * @param achievement the achievement to award. |
| * @param awardParents whether parent achievements should be awarded. |
| * @return {@code true} if the achievement was awarded, {@code false} otherwise |
| */ |
| public boolean awardAchievement(Achievement achievement, boolean awardParents) { |
| if (hasAchievement(achievement)) return false; |
| |
| Achievement parent = achievement.getParent(); |
| if (parent != null && !hasAchievement(parent)) { |
| if (!awardParents || !awardAchievement(parent, true)) { |
| // does not have or failed to award required parent achievement |
| return false; |
| } |
| } |
| |
| PlayerAchievementAwardedEvent event = new PlayerAchievementAwardedEvent(this, achievement); |
| if (EventFactory.callEvent(event).isCancelled()) { |
| return false; // event was cancelled |
| } |
| |
| stats.setAchievement(achievement, true); |
| sendAchievement(achievement, true); |
| |
| if (server.getAnnounceAchievements()) { |
| // todo: make message fancier (hover, translated names) |
| server.broadcastMessage(getName() + " earned achievement " + ChatColor.GREEN + "[" + achievement.name() + "]"); |
| } |
| return true; |
| } |
| |
| @Override |
| public void removeAchievement(Achievement achievement) { |
| if (!hasAchievement(achievement)) return; |
| |
| stats.setAchievement(achievement, false); |
| sendAchievement(achievement, false); |
| } |
| |
| private void sendAchievement(Achievement achievement, boolean has) { |
| Map<String, Integer> values = new HashMap<>(); |
| values.put(GlowAchievement.getName(achievement), has ? 1 : 0); |
| session.send(new StatisticMessage(values)); |
| } |
| |
| @Override |
| public int getStatistic(Statistic statistic) throws IllegalArgumentException { |
| return stats.get(statistic); |
| } |
| |
| @Override |
| public int getStatistic(Statistic statistic, Material material) throws IllegalArgumentException { |
| return stats.get(statistic, material); |
| } |
| |
| @Override |
| public int getStatistic(Statistic statistic, EntityType entityType) throws IllegalArgumentException { |
| return stats.get(statistic, entityType); |
| } |
| |
| @Override |
| public void setStatistic(Statistic statistic, int newValue) throws IllegalArgumentException { |
| stats.set(statistic, newValue); |
| } |
| |
| @Override |
| public void setStatistic(Statistic statistic, Material material, int newValue) throws IllegalArgumentException { |
| stats.set(statistic, material, newValue); |
| } |
| |
| @Override |
| public void setStatistic(Statistic statistic, EntityType entityType, int newValue) { |
| stats.set(statistic, entityType, newValue); |
| } |
| |
| @Override |
| public void incrementStatistic(Statistic statistic) { |
| stats.add(statistic, 1); |
| } |
| |
| @Override |
| public void incrementStatistic(Statistic statistic, int amount) { |
| stats.add(statistic, amount); |
| } |
| |
| @Override |
| public void incrementStatistic(Statistic statistic, Material material) { |
| stats.add(statistic, material, 1); |
| } |
| |
| @Override |
| public void incrementStatistic(Statistic statistic, Material material, int amount) { |
| stats.add(statistic, material, amount); |
| } |
| |
| @Override |
| public void incrementStatistic(Statistic statistic, EntityType entityType) throws IllegalArgumentException { |
| stats.add(statistic, entityType, 1); |
| } |
| |
| @Override |
| public void incrementStatistic(Statistic statistic, EntityType entityType, int amount) throws IllegalArgumentException { |
| stats.add(statistic, entityType, amount); |
| } |
| |
| @Override |
| public void decrementStatistic(Statistic statistic) throws IllegalArgumentException { |
| stats.add(statistic, -1); |
| } |
| |
| @Override |
| public void decrementStatistic(Statistic statistic, int amount) throws IllegalArgumentException { |
| stats.add(statistic, -amount); |
| } |
| |
| @Override |
| public void decrementStatistic(Statistic statistic, Material material) throws IllegalArgumentException { |
| stats.add(statistic, material, -1); |
| } |
| |
| @Override |
| public void decrementStatistic(Statistic statistic, Material material, int amount) throws IllegalArgumentException { |
| stats.add(statistic, material, -amount); |
| } |
| |
| @Override |
| public void decrementStatistic(Statistic statistic, EntityType entityType) throws IllegalArgumentException { |
| stats.add(statistic, entityType, -1); |
| } |
| |
| @Override |
| public void decrementStatistic(Statistic statistic, EntityType entityType, int amount) { |
| stats.add(statistic, entityType, -amount); |
| } |
| |
| public void sendStats() { |
| session.send(stats.toMessage()); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Inventory |
| |
| @Override |
| public void updateInventory() { |
| session.send(new SetWindowContentsMessage(invMonitor.getId(), invMonitor.getContents())); |
| } |
| |
| public void sendItemChange(int slot, ItemStack item) { |
| session.send(new SetWindowSlotMessage(invMonitor.getId(), slot, item)); |
| } |
| |
| @Override |
| public void setItemOnCursor(ItemStack item) { |
| super.setItemOnCursor(item); |
| session.send(new SetWindowSlotMessage(-1, -1, item)); |
| } |
| |
| @Override |
| public boolean setWindowProperty(InventoryView.Property prop, int value) { |
| if (!super.setWindowProperty(prop, value)) return false; |
| session.send(new WindowPropertyMessage(invMonitor.getId(), prop.getId(), value)); |
| return true; |
| } |
| |
| @Override |
| public void openInventory(InventoryView view) { |
| session.send(new CloseWindowMessage(invMonitor.getId())); |
| |
| super.openInventory(view); |
| |
| invMonitor = new InventoryMonitor(getOpenInventory()); |
| int viewId = invMonitor.getId(); |
| if (viewId != 0) { |
| String title = view.getTitle(); |
| boolean defaultTitle = view.getType().getDefaultTitle().equals(title); |
| if (view.getTopInventory() instanceof PlayerInventory && defaultTitle) { |
| title = ((PlayerInventory) view.getTopInventory()).getHolder().getName(); |
| } |
| Message open = new OpenWindowMessage(viewId, invMonitor.getType(), title, ((GlowInventory) view.getTopInventory()).getRawSlots()); |
| session.send(open); |
| } |
| |
| updateInventory(); |
| } |
| |
| @Override |
| public GlowItem drop(ItemStack stack) { |
| GlowItem dropping = super.drop(stack); |
| if (dropping != null) { |
| PlayerDropItemEvent event = new PlayerDropItemEvent(this, dropping); |
| EventFactory.callEvent(event); |
| if (event.isCancelled()) { |
| dropping.remove(); |
| dropping = null; |
| } |
| } |
| return dropping; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Player-specific time and weather |
| |
| @Override |
| public void setPlayerTime(long time, boolean relative) { |
| timeOffset = (time % GlowWorld.DAY_LENGTH + GlowWorld.DAY_LENGTH) % GlowWorld.DAY_LENGTH; |
| timeRelative = relative; |
| sendTime(); |
| } |
| |
| @Override |
| public long getPlayerTime() { |
| if (timeRelative) { |
| // add timeOffset ticks to current time |
| return (world.getTime() + timeOffset) % GlowWorld.DAY_LENGTH; |
| } else { |
| // return time offset |
| return timeOffset; |
| } |
| } |
| |
| @Override |
| public long getPlayerTimeOffset() { |
| return timeOffset; |
| } |
| |
| @Override |
| public boolean isPlayerTimeRelative() { |
| return timeRelative; |
| } |
| |
| @Override |
| public void resetPlayerTime() { |
| setPlayerTime(0, true); |
| } |
| |
| public void sendTime() { |
| long time = getPlayerTime(); |
| if (!timeRelative || !world.getGameRuleMap().getBoolean("doDaylightCycle")) { |
| time = -time; // negative value indicates fixed time |
| } |
| session.send(new TimeMessage(world.getFullTime(), time)); |
| } |
| |
| @Override |
| public void setPlayerWeather(WeatherType type) { |
| playerWeather = type; |
| sendWeather(); |
| } |
| |
| @Override |
| public WeatherType getPlayerWeather() { |
| return playerWeather; |
| } |
| |
| @Override |
| public void resetPlayerWeather() { |
| playerWeather = null; |
| sendWeather(); |
| sendRainDensity(); |
| sendSkyDarkness(); |
| } |
| |
| public void sendWeather() { |
| boolean stormy = playerWeather == null ? getWorld().hasStorm() : playerWeather == WeatherType.DOWNFALL; |
| session.send(new StateChangeMessage(stormy ? StateChangeMessage.Reason.START_RAIN : StateChangeMessage.Reason.STOP_RAIN, 0)); |
| } |
| |
| public void sendRainDensity() { |
| session.send(new StateChangeMessage(StateChangeMessage.Reason.RAIN_DENSITY, getWorld().getRainDensity())); |
| } |
| |
| public void sendSkyDarkness() { |
| session.send(new StateChangeMessage(StateChangeMessage.Reason.SKY_DARKNESS, getWorld().getSkyDarkness())); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Player visibility |
| |
| @Override |
| public void hidePlayer(Player player) { |
| Validate.notNull(player, "player cannot be null"); |
| if (equals(player) || !player.isOnline() || !session.isActive()) return; |
| if (hiddenEntities.contains(player.getUniqueId())) return; |
| |
| hiddenEntities.add(player.getUniqueId()); |
| if (knownEntities.remove(player)) { |
| session.send(new DestroyEntitiesMessage(Arrays.asList(player.getEntityId()))); |
| } |
| session.send(UserListItemMessage.removeOne(player.getUniqueId())); |
| } |
| |
| @Override |
| public void showPlayer(Player player) { |
| Validate.notNull(player, "player cannot be null"); |
| if (equals(player) || !player.isOnline() || !session.isActive()) return; |
| if (!hiddenEntities.contains(player.getUniqueId())) return; |
| |
| hiddenEntities.remove(player.getUniqueId()); |
| session.send(new UserListItemMessage(UserListItemMessage.Action.ADD_PLAYER, ((GlowPlayer) player).getUserListEntry())); |
| } |
| |
| @Override |
| public boolean canSee(Player player) { |
| return !hiddenEntities.contains(player.getUniqueId()); |
| } |
| |
| /** |
| * Called when a player hidden to this player disconnects. |
| * This is necessary so the player is visible again after they reconnected. |
| * @param player The disconnected player |
| */ |
| public void stopHidingDisconnectedPlayer(Player player) { |
| hiddenEntities.remove(player.getUniqueId()); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Scoreboard |
| |
| @Override |
| public Scoreboard getScoreboard() { |
| return null; |
| } |
| |
| @Override |
| public void setScoreboard(Scoreboard scoreboard) throws IllegalArgumentException, IllegalStateException { |
| |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Conversable |
| |
| @Override |
| public boolean isConversing() { |
| return false; |
| } |
| |
| @Override |
| public void acceptConversationInput(String input) { |
| |
| } |
| |
| @Override |
| public boolean beginConversation(Conversation conversation) { |
| return false; |
| } |
| |
| @Override |
| public void abandonConversation(Conversation conversation) { |
| |
| } |
| |
| @Override |
| public void abandonConversation(Conversation conversation, ConversationAbandonedEvent details) { |
| |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // Plugin messages |
| |
| @Override |
| public void sendPluginMessage(Plugin source, String channel, byte[] message) { |
| StandardMessenger.validatePluginMessage(getServer().getMessenger(), source, channel, message); |
| if (listeningChannels.contains(channel)) { |
| // only send if player is listening for it |
| session.send(new PluginMessage(channel, message)); |
| } |
| } |
| |
| @Override |
| public Set<String> getListeningPluginChannels() { |
| return Collections.unmodifiableSet(listeningChannels); |
| } |
| |
| /** |
| * Add a listening channel to this player. |
| * @param channel The channel to add. |
| */ |
| public void addChannel(String channel) { |
| if (listeningChannels.add(channel)) { |
| EventFactory.callEvent(new PlayerRegisterChannelEvent(this, channel)); |
| } |
| } |
| |
| /** |
| * Remove a listening channel from this player. |
| * @param channel The channel to remove. |
| */ |
| public void removeChannel(String channel) { |
| if (listeningChannels.remove(channel)) { |
| EventFactory.callEvent(new PlayerUnregisterChannelEvent(this, channel)); |
| } |
| } |
| |
| /** |
| * Send the supported plugin channels to the client. |
| */ |
| private void sendSupportedChannels() { |
| Set<String> listening = server.getMessenger().getIncomingChannels(); |
| |
| if (!listening.isEmpty()) { |
| // send NUL-separated list of channels we support |
| ByteBuf buf = Unpooled.buffer(16 * listening.size()); |
| for (String channel : listening) { |
| buf.writeBytes(channel.getBytes(StandardCharsets.UTF_8)); |
| buf.writeByte(0); |
| } |
| session.send(new PluginMessage("REGISTER", buf.array())); |
| } |
| } |
| } |