Actually that PlayerConnection wrap was to dangerous. Let's do it simpler and slightly uglier.

This commit is contained in:
Olof Larsson 2013-08-26 10:29:58 +02:00
parent 1b8ae6cf5f
commit d21858d5c7
5 changed files with 41 additions and 695 deletions

View File

@ -31,7 +31,7 @@ public class ConfServer extends SimpleConfig
public static String dburi = "default"; public static String dburi = "default";
public static boolean usingPlayerConnectionWrap = true; public static boolean useRecipientChatEvent = true;
public static boolean forceOnePlayerNameCase = true; public static boolean forceOnePlayerNameCase = true;
public static List<String> aliasesOuterMCore = MUtil.list("mcore"); public static List<String> aliasesOuterMCore = MUtil.list("mcore");

View File

@ -1,6 +1,7 @@
package com.massivecraft.mcore; package com.massivecraft.mcore;
import java.util.HashMap; import java.util.HashMap;
import java.util.HashSet;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import java.util.TreeSet; import java.util.TreeSet;
@ -13,7 +14,7 @@ import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener; import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageByBlockEvent; import org.bukkit.event.entity.EntityDamageByBlockEvent;
import org.bukkit.event.entity.EntityDamageEvent.DamageCause; import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerKickEvent; import org.bukkit.event.player.PlayerKickEvent;
import org.bukkit.event.player.PlayerLoginEvent; import org.bukkit.event.player.PlayerLoginEvent;
import org.bukkit.event.player.PlayerLoginEvent.Result; import org.bukkit.event.player.PlayerLoginEvent.Result;
@ -26,6 +27,7 @@ import com.massivecraft.mcore.event.MCoreAfterPlayerRespawnEvent;
import com.massivecraft.mcore.event.MCoreAfterPlayerTeleportEvent; import com.massivecraft.mcore.event.MCoreAfterPlayerTeleportEvent;
import com.massivecraft.mcore.event.MCorePermissionDeniedFormatEvent; import com.massivecraft.mcore.event.MCorePermissionDeniedFormatEvent;
import com.massivecraft.mcore.event.MCorePlayerLeaveEvent; import com.massivecraft.mcore.event.MCorePlayerLeaveEvent;
import com.massivecraft.mcore.event.MCorePlayerToRecipientChatEvent;
import com.massivecraft.mcore.event.MCoreSenderRegisterEvent; import com.massivecraft.mcore.event.MCoreSenderRegisterEvent;
import com.massivecraft.mcore.event.MCoreSenderUnregisterEvent; import com.massivecraft.mcore.event.MCoreSenderUnregisterEvent;
import com.massivecraft.mcore.mixin.Mixin; import com.massivecraft.mcore.mixin.Mixin;
@ -33,7 +35,6 @@ import com.massivecraft.mcore.store.Coll;
import com.massivecraft.mcore.store.SenderColl; import com.massivecraft.mcore.store.SenderColl;
import com.massivecraft.mcore.util.SenderUtil; import com.massivecraft.mcore.util.SenderUtil;
import com.massivecraft.mcore.util.SmokeUtil; import com.massivecraft.mcore.util.SmokeUtil;
import com.massivecraft.mcore.wrap.PlayerConnectionWrapMCore;
public class InternalListener implements Listener public class InternalListener implements Listener
{ {
@ -55,14 +56,44 @@ public class InternalListener implements Listener
} }
// -------------------------------------------- // // -------------------------------------------- //
// PLAYER CONNECTION WRAP INJECTION // RECIPIENT CHAT
// -------------------------------------------- // // -------------------------------------------- //
// A system to create per recipient events.
// It clears the recipient set so the event isn't cancelled completely.
// It will cause non async chat events not to fire.
@EventHandler(priority = EventPriority.LOWEST) public static void recipientChat(Player sender, String message, String format, Set<CommandSender> recipients)
public void playerConnectionWrapInjection(final PlayerJoinEvent event)
{ {
if (!ConfServer.usingPlayerConnectionWrap) return; // For each of the recipients
new PlayerConnectionWrapMCore(event.getPlayer()); for (CommandSender recipient : recipients)
{
// Run the event for this unique recipient
MCorePlayerToRecipientChatEvent event = new MCorePlayerToRecipientChatEvent(sender, recipient, message, format);
event.run();
// Format and send with the format and message from this recipient's own event.
String recipientMessage = String.format(event.getFormat(), sender.getDisplayName(), event.getMessage());
recipient.sendMessage(recipientMessage);
}
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void recipientChat(final AsyncPlayerChatEvent event)
{
// Return unless we are using the recipient chat event
if (!ConfServer.useRecipientChatEvent) return;
// Prepare vars
final Player sender = event.getPlayer();
String message = event.getMessage();
String format = event.getFormat();
// Pick the recipients to avoid the message getting sent without canceling the event.
Set<CommandSender> recipients = new HashSet<CommandSender>(event.getRecipients());
event.getRecipients().clear();
// Do it!
recipientChat(sender, message, format, recipients);
} }
// -------------------------------------------- // // -------------------------------------------- //

View File

@ -36,9 +36,9 @@ public class MCorePlayerToRecipientChatEvent extends MCoreEvent
// CONSTRUCT // CONSTRUCT
// -------------------------------------------- // // -------------------------------------------- //
public MCorePlayerToRecipientChatEvent(boolean async, Player sender, CommandSender recipient, String message, String format) public MCorePlayerToRecipientChatEvent(Player sender, CommandSender recipient, String message, String format)
{ {
super(async); super(true);
this.sender = sender; this.sender = sender;
this.recipient = recipient; this.recipient = recipient;
this.message = message; this.message = message;

View File

@ -1,412 +0,0 @@
package com.massivecraft.mcore.wrap;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import org.bukkit.Location;
import org.bukkit.craftbukkit.v1_6_R2.util.LazyPlayerSet;
import org.bukkit.craftbukkit.v1_6_R2.CraftServer;
import org.bukkit.craftbukkit.v1_6_R2.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import com.massivecraft.mcore.store.accessor.AccessorUtil;
import com.massivecraft.mcore.store.accessor.PropertyAccessor;
import net.minecraft.server.v1_6_R2.EntityPlayer;
import net.minecraft.server.v1_6_R2.Packet;
import net.minecraft.server.v1_6_R2.Packet0KeepAlive;
import net.minecraft.server.v1_6_R2.Packet101CloseWindow;
import net.minecraft.server.v1_6_R2.Packet102WindowClick;
import net.minecraft.server.v1_6_R2.Packet106Transaction;
import net.minecraft.server.v1_6_R2.Packet107SetCreativeSlot;
import net.minecraft.server.v1_6_R2.Packet108ButtonClick;
import net.minecraft.server.v1_6_R2.Packet130UpdateSign;
import net.minecraft.server.v1_6_R2.Packet15Place;
import net.minecraft.server.v1_6_R2.Packet16BlockItemSwitch;
import net.minecraft.server.v1_6_R2.Packet18ArmAnimation;
import net.minecraft.server.v1_6_R2.Packet19EntityAction;
import net.minecraft.server.v1_6_R2.Packet202Abilities;
import net.minecraft.server.v1_6_R2.Packet203TabComplete;
import net.minecraft.server.v1_6_R2.Packet204LocaleAndViewDistance;
import net.minecraft.server.v1_6_R2.Packet205ClientCommand;
import net.minecraft.server.v1_6_R2.Packet250CustomPayload;
import net.minecraft.server.v1_6_R2.Packet255KickDisconnect;
import net.minecraft.server.v1_6_R2.Packet3Chat;
import net.minecraft.server.v1_6_R2.Packet7UseEntity;
import net.minecraft.server.v1_6_R2.Packet9Respawn;
import net.minecraft.server.v1_6_R2.Packet14BlockDig;
import net.minecraft.server.v1_6_R2.Packet10Flying;
import net.minecraft.server.v1_6_R2.MinecraftServer;
import net.minecraft.server.v1_6_R2.Packet27PlayerInput;
import net.minecraft.server.v1_6_R2.PlayerConnection;
/**
* It's sometime fun to wrap the NMS PlayerConnection with a version that behaves slightly differently.
* This class is an unmodified wrap to be used just for that.
* Just extend this class with the features you want and then instantiate for the player.
* It's perfectly fine to wrap a wrap the wraps a wrap and so on.
*
* Great care should be taken when updating this class to a new NMS version.
* Follow the following steps:
*
* 1. Make sure that all public methods are overriden to call the this.inner.
* 2. Take a look at the method constructor. Does it do something new fancy?
* 3. Where are the public fields altered? Make sure to update them accordingly. (remember to check mc-dev as well as CraftBukkit)
* 4. handleCommandPublic method update though copy paste and minor adjustments.
*
* https://github.com/Bukkit/CraftBukkit/commits/master/src/main/java/net/minecraft/server/PlayerConnection.java
* This file was last updated for the following commit:
* "Fix missed diff for chat packets. Fixes BUKKIT-4666"
* Wolvereness authored 2013-08-07
*/
public abstract class PlayerConnectionWrapAbstract extends PlayerConnection
{
// -------------------------------------------- //
// STATIC UTILS
// -------------------------------------------- //
public static PlayerConnection getPlayerConnection(Player player)
{
CraftPlayer cplayer = (CraftPlayer)player;
EntityPlayer eplayer = cplayer.getHandle();
return eplayer.playerConnection;
}
public static void setPlayerConnection(Player player, PlayerConnection playerConnection)
{
CraftPlayer cplayer = (CraftPlayer)player;
EntityPlayer eplayer = cplayer.getHandle();
eplayer.playerConnection = playerConnection;
}
// -------------------------------------------- //
// FIEDS
// -------------------------------------------- //
private final PlayerConnection inner;
// -------------------------------------------- //
// RAW NATIVE FIELD THEORY
// -------------------------------------------- //
// public final INetworkManager networkManager;
// This one should never change since it's final.
// Using the very same must thus be fine.
// private final MinecraftServer minecraftServer;
// Same argumentation as above.
// public boolean disconnected;
// This one is set in two locations only from within this class
// 1. public void a(String s, Object[] aobject)
// 2. public void disconnect(String s)
// For that reason we update the reference upwards at those locations.
// public EntityPlayer player;
// This one is set in two locations only from within this class
// 1. The constructor
// 2. public void a(Packet205ClientCommand packet205clientcommand)
// For that reason we update the reference upwards at those locations.
// public boolean checkMovement = true; // CraftBukkit - private -> public
// This one was made public but I do not see why.
// It's only used from within this class.
// Thus we do not need to keep it updated in the wrapper.
// -------------------------------------------- //
// MAKING STUFF PUBLIC
// -------------------------------------------- //
public final static transient PropertyAccessor minecraftServerAccessor = AccessorUtil.createPropertyAccessor(PlayerConnection.class, "minecraftServer");
public MinecraftServer getMinecraftServer()
{
return (MinecraftServer) minecraftServerAccessor.get(this);
}
public final static transient PropertyAccessor serverAccessor = AccessorUtil.createPropertyAccessor(PlayerConnection.class, "server");
public CraftServer getServer()
{
return (CraftServer) serverAccessor.get(this);
}
public final static transient PropertyAccessor chatSpamFieldAccessor = AccessorUtil.createPropertyAccessor(PlayerConnection.class, "chatSpamField");
@SuppressWarnings("unchecked")
public AtomicIntegerFieldUpdater<PlayerConnection> getChatSpamField()
{
return (AtomicIntegerFieldUpdater<PlayerConnection>) chatSpamFieldAccessor.get(this);
}
// -------------------------------------------- //
// CONSTRUCT
// -------------------------------------------- //
// Note that instantiating this class or a subclass of this class will cause the PlayerConnection to be injected.
// It's designed that way in the vanilla NMS superclass.
public PlayerConnectionWrapAbstract(Player player)
{
this(getPlayerConnection(player));
}
public PlayerConnectionWrapAbstract(PlayerConnection inner)
{
super(inner.player.server, inner.networkManager, inner.player);
this.inner = inner;
this.disconnected = inner.disconnected;
this.checkMovement = inner.checkMovement;
}
// -------------------------------------------- //
// WRAP
// -------------------------------------------- //
@Override
public CraftPlayer getPlayer()
{
return this.inner.getPlayer();
}
@Override
public void e()
{
this.inner.e();
}
@Override
public void disconnect(String s)
{
this.inner.disconnect(s);
this.disconnected = this.inner.disconnected;
}
@Override
public void a(Packet27PlayerInput packet27playerinput)
{
this.inner.a(packet27playerinput);
}
@Override
public void a(Packet10Flying packet10flying)
{
this.inner.a(packet10flying);
}
@Override
public void a(double d0, double d1, double d2, float f, float f1)
{
this.inner.a(d0, d1, d2, f, f1);
}
@Override
public void teleport(Location dest)
{
this.inner.teleport(dest);
}
@Override
public void a(Packet14BlockDig packet14blockdig)
{
this.inner.a(packet14blockdig);
}
@Override
public void a(Packet15Place packet15place)
{
this.inner.a(packet15place);
}
@Override
public void a(String s, Object[] aobject)
{
this.inner.a(s, aobject);
this.disconnected = this.inner.disconnected;
}
@Override
public void onUnhandledPacket(Packet packet)
{
this.inner.onUnhandledPacket(packet);
}
@Override
public void sendPacket(Packet packet)
{
this.inner.sendPacket(packet);
}
@Override
public void a(Packet16BlockItemSwitch packet16blockitemswitch)
{
this.inner.a(packet16blockitemswitch);
}
@Override
public void a(Packet3Chat packet3chat)
{
this.inner.a(packet3chat);
}
@Override
public void chat(String s, boolean async)
{
this.inner.chat(s, async);
}
public void handleCommandPublic(String s)
{
// CraftBukkit start
CraftPlayer player = this.getPlayer();
PlayerCommandPreprocessEvent event = new PlayerCommandPreprocessEvent(player, s, new LazyPlayerSet());
this.getServer().getPluginManager().callEvent(event);
if (event.isCancelled()) {
return;
}
try {
this.getMinecraftServer().getLogger().info(event.getPlayer().getName() + " issued server command: " + event.getMessage()); // CraftBukkit
if (this.getServer().dispatchCommand(event.getPlayer(), event.getMessage().substring(1))) {
return;
}
} catch (org.bukkit.command.CommandException ex) {
player.sendMessage(org.bukkit.ChatColor.RED + "An internal error occurred while attempting to perform this command");
java.util.logging.Logger.getLogger(PlayerConnection.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
return;
}
// CraftBukkit end
/* CraftBukkit start - No longer needed as we have already handled it in server.dispatchServerCommand above.
this.minecraftServer.getCommandHandler().a(this.player, s);
// CraftBukkit end */
}
@Override
public void a(Packet18ArmAnimation packet18armanimation)
{
this.inner.a(packet18armanimation);
}
@Override
public void a(Packet19EntityAction packet19entityaction)
{
this.inner.a(packet19entityaction);
}
@Override
public void a(Packet255KickDisconnect packet255kickdisconnect)
{
this.inner.a(packet255kickdisconnect);
}
@Override
public int lowPriorityCount()
{
return this.inner.lowPriorityCount();
}
@Override
public void a(Packet7UseEntity packet7useentity)
{
this.inner.a(packet7useentity);
}
@Override
public void a(Packet205ClientCommand packet205clientcommand)
{
this.inner.a(packet205clientcommand);
this.player = this.inner.player;
}
@Override
public boolean b()
{
return this.inner.b();
}
@Override
public void a(Packet9Respawn packet9respawn)
{
this.inner.a(packet9respawn);
}
@Override
public void handleContainerClose(Packet101CloseWindow packet101closewindow)
{
this.inner.handleContainerClose(packet101closewindow);
}
@Override
public void a(Packet102WindowClick packet102windowclick)
{
this.inner.a(packet102windowclick);
}
@Override
public void a(Packet108ButtonClick packet108buttonclick)
{
this.inner.a(packet108buttonclick);
}
@Override
public void a(Packet107SetCreativeSlot packet107setcreativeslot)
{
this.inner.a(packet107setcreativeslot);
}
@Override
public void a(Packet106Transaction packet106transaction)
{
this.inner.a(packet106transaction);
}
@Override
public void a(Packet130UpdateSign packet130updatesign)
{
this.inner.a(packet130updatesign);
}
@Override
public void a(Packet0KeepAlive packet0keepalive)
{
this.inner.a(packet0keepalive);
}
@Override
public boolean a()
{
return this.inner.a();
}
@Override
public void a(Packet202Abilities packet202abilities)
{
this.inner.a(packet202abilities);
}
@Override
public void a(Packet203TabComplete packet203tabcomplete)
{
this.inner.a(packet203tabcomplete);
}
@Override
public void a(Packet204LocaleAndViewDistance packet204localeandviewdistance)
{
this.inner.a(packet204localeandviewdistance);
}
@Override
public void a(Packet250CustomPayload packet250custompayload)
{
this.inner.a(packet250custompayload);
}
@Override
public boolean c()
{
return this.inner.c();
}
}

View File

@ -1,273 +0,0 @@
package com.massivecraft.mcore.wrap;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import net.minecraft.server.v1_6_R2.ChatMessage;
import net.minecraft.server.v1_6_R2.EnumChatFormat;
import net.minecraft.server.v1_6_R2.SharedConstants;
import net.minecraft.server.v1_6_R2.Packet3Chat;
import org.apache.commons.lang3.StringUtils;
import org.bukkit.command.CommandSender;
import org.bukkit.craftbukkit.v1_6_R2.util.LazyPlayerSet;
import org.bukkit.craftbukkit.v1_6_R2.util.Waitable;
import org.bukkit.entity.Player;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerChatEvent;
import com.massivecraft.mcore.event.MCorePlayerToRecipientChatEvent;
/**
* This is the MCore PlayerConnectionWrap.
* It will be injected for all players unless you disable that from the ServerConf.
*
* Currently it adds in the features required for the event MCorePlayerToRecipientChatEvent.
*
* To update void a(Packet3Chat packet3chat):
* 1. Paste in the method a(Packet3Chat packet3chat):
* 2. Change the private field references to the public ones.
*
* To update void chat(String s, boolean async):
* 1. Paste in the method chat(String s, boolean async)
* 2. Change the private field references to the public ones.
* 3. Replace the message distribution parts.
*
* https://github.com/Bukkit/CraftBukkit/commits/master/src/main/java/net/minecraft/server/PlayerConnection.java
* This file was last updated for the following commit:
* "Fix missed diff for chat packets. Fixes BUKKIT-4666"
* Wolvereness authored 2013-08-07
*/
@SuppressWarnings("deprecation")
public class PlayerConnectionWrapMCore extends PlayerConnectionWrapAbstract
{
// -------------------------------------------- //
// CONSTRUCT
// -------------------------------------------- //
public PlayerConnectionWrapMCore(Player player)
{
super(player);
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
public void distributeMessage(boolean async, Player sender, Set<Player> recipients, String message, String format)
{
// The console shall not have special attention!
Set<CommandSender> recipientsAndConsole = new LinkedHashSet<CommandSender>(recipients);
recipientsAndConsole.add(this.getMinecraftServer().console);
// For each of the recipients
for (CommandSender recipient : recipientsAndConsole)
{
// Run the event for this unique recipient
MCorePlayerToRecipientChatEvent event = new MCorePlayerToRecipientChatEvent(async, sender, recipient, message, format);
event.run();
// Format and send with the format and message from this recipient's own event.
String playerMessage = String.format(event.getFormat(), sender.getDisplayName(), event.getMessage());
recipient.sendMessage(playerMessage);
}
}
// -------------------------------------------- //
// OVERRIDE
// -------------------------------------------- //
@SuppressWarnings("rawtypes")
@Override
public void a(Packet3Chat packet3chat)
{
if (this.player.getChatFlags() == 2) {
this.sendPacket(new Packet3Chat(ChatMessage.e("chat.cannotSend").a(EnumChatFormat.RED)));
} else {
String s = packet3chat.message;
if (s.length() > 100) {
// CraftBukkit start
if (packet3chat.a_()) {
Waitable waitable = new Waitable() {
@Override
protected Object evaluate() {
PlayerConnectionWrapMCore.this.disconnect("Chat message too long");
return null;
}
};
this.getMinecraftServer().processQueue.add(waitable);
try {
waitable.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
} else {
this.disconnect("Chat message too long");
}
// CraftBukkit end
} else {
s = StringUtils.normalizeSpace(s);
for (int i = 0; i < s.length(); ++i) {
if (!SharedConstants.isAllowedChatCharacter(s.charAt(i))) {
// CraftBukkit start
if (packet3chat.a_()) {
Waitable waitable = new Waitable() {
@Override
protected Object evaluate() {
PlayerConnectionWrapMCore.this.disconnect("Illegal characters in chat");
return null;
}
};
this.getMinecraftServer().processQueue.add(waitable);
try {
waitable.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
} else {
this.disconnect("Illegal characters in chat");
}
// CraftBukkit end
return;
}
}
// CraftBukkit start
if (this.player.getChatFlags() == 1 && !s.startsWith("/")) {
this.sendPacket(new Packet3Chat(ChatMessage.e("chat.cannotSend").a(EnumChatFormat.RED)));
return;
}
this.chat(s, packet3chat.a_());
// This section stays because it is only applicable to packets
if (this.getChatSpamField().addAndGet(this, 20) > 200 && !this.getMinecraftServer().getPlayerList().isOp(this.player.getName())) { // CraftBukkit use thread-safe spam
if (packet3chat.a_()) {
Waitable waitable = new Waitable() {
@Override
protected Object evaluate() {
PlayerConnectionWrapMCore.this.disconnect("disconnect.spam");
return null;
}
};
this.getMinecraftServer().processQueue.add(waitable);
try {
waitable.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
} else {
this.disconnect("disconnect.spam");
}
}
}
}
}
@SuppressWarnings("rawtypes")
@Override
public void chat(String s, boolean async)
{
if (!this.player.dead) {
if (s.length() == 0) {
this.getMinecraftServer().getLogger().warning(this.player.getName() + " tried to send an empty message");
return;
}
if (getPlayer().isConversing()) {
getPlayer().acceptConversationInput(s);
return;
}
if (s.startsWith("/")) {
this.handleCommandPublic(s);
return;
} else {
Player player = this.getPlayer();
AsyncPlayerChatEvent event = new AsyncPlayerChatEvent(async, player, s, new LazyPlayerSet());
this.getServer().getPluginManager().callEvent(event);
if (PlayerChatEvent.getHandlerList().getRegisteredListeners().length != 0) {
// Evil plugins still listening to deprecated event
final PlayerChatEvent queueEvent = new PlayerChatEvent(player, event.getMessage(), event.getFormat(), event.getRecipients());
queueEvent.setCancelled(event.isCancelled());
Waitable waitable = new Waitable() {
@Override
protected Object evaluate() {
org.bukkit.Bukkit.getPluginManager().callEvent(queueEvent);
if (queueEvent.isCancelled()) {
return null;
}
// MCore - start
distributeMessage(false, queueEvent.getPlayer(), queueEvent.getRecipients(), queueEvent.getMessage(), queueEvent.getFormat());
/*String message = String.format(queueEvent.getFormat(), queueEvent.getPlayer().getDisplayName(), queueEvent.getMessage());
minecraftServerPublic.console.sendMessage(message);
if (((LazyPlayerSet) queueEvent.getRecipients()).isLazy()) {
for (Object player : minecraftServerPublic.getPlayerList().players) {
((EntityPlayer) player).sendMessage(ChatMessage.d(message));
}
} else {
for (Player player : queueEvent.getRecipients()) {
player.sendMessage(message);
}
}*/
// MCore - end
return null;
}};
if (async) {
this.getMinecraftServer().processQueue.add(waitable);
} else {
waitable.run();
}
try {
waitable.get();
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // This is proper habit for java. If we aren't handling it, pass it on!
} catch (ExecutionException e) {
throw new RuntimeException("Exception processing chat event", e.getCause());
}
} else {
if (event.isCancelled()) {
return;
}
// MCore - start
distributeMessage(async, event.getPlayer(), event.getRecipients(), event.getMessage(), event.getFormat());
/*s = String.format(event.getFormat(), event.getPlayer().getDisplayName(), event.getMessage());
minecraftServerPublic.console.sendMessage(s);
if (((LazyPlayerSet) event.getRecipients()).isLazy()) {
for (Object recipient : minecraftServerPublic.getPlayerList().players) {
((EntityPlayer) recipient).sendMessage(ChatMessage.d(s));
}
} else {
for (Player recipient : event.getRecipients()) {
recipient.sendMessage(s);
}
}*/
// MCore - end
}
}
}
return;
}
}