Skip to content

Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
mdcfe merged 4 commits into from
Feb 13, 2023
Merged

Add separate events for local and global chat #4683

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
7bd890d
Add separate events for local and global chat
brawaru Dec 12, 2021
f739317
Merge branch '2.x' into feat/add-chat-type-events
JRoy Aug 22, 2022
9e42f9e
Merge branch '2.x' into feat/add-chat-type-events
JRoy Oct 11, 2022
bbd9c1c
Merge branch '2.x' into feat/add-chat-type-events
mdcfe Feb 13, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
97 changes: 5 additions & 92 deletions Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
* Fired when a player uses local chat.
*/
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
private static final HandlerList handlers = new HandlerList();
private final Player player;
private final Set<Player> recipients;
private boolean cancelled = false;
private String message;
private String format;

public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
super(async);
this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
this.message = message;
recipients = players;
player = who;
public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
}

public static HandlerList getHandlerList() {
return handlers;
}

/**
* Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
*
* @return Message the player is attempting to send
*/
public String getMessage() {
return message;
}

/**
* Sets the message that the player will send. This message will be used with {@link #getFormat()}.
*
* @param message New message that the player will send
*/
public void setMessage(final String message) {
this.message = message;
}

/**
* Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
* first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
*
* @return {@link String#format(String, Object...)} compatible format string
*/
public String getFormat() {
return format;
}

/**
* Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
* first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
*
* @param format {@link String#format(String, Object...)} compatible format string
* @throws IllegalFormatException if the underlying API throws the exception
* @throws NullPointerException if format is null
* @see String#format(String, Object...)
*/
public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
// Oh for a better way to do this!
try {
String.format(format, player, message);
} catch (final RuntimeException ex) {
ex.fillInStackTrace();
throw ex;
}

this.format = format;
}

/**
* Gets a set of recipients that this chat message will be displayed to.
*
* @return All Players who will see this chat message
*/
public Set<Player> getRecipients() {
return recipients;
}

/**
* Returns the player involved in this event
*
* @return Player who is involved in this event
*/
public final Player getPlayer() {
return player;
}

@Override
public boolean isCancelled() {
return cancelled;
}

@Override
public void setCancelled(final boolean cancel) {
this.cancelled = cancel;
}

@Override
public HandlerList getHandlers() {
return handlers;
Expand Down
49 changes: 49 additions & 0 deletions Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
* Represents chat type for a message
*/
public enum ChatType {
/**
* Message is being sent to global chat as a shout
*/
SHOUT,

/**
* Message is being sent to global chat as a question
*/
QUESTION,

/**
* Message is being sent locally
*/
LOCAL,

/**
* Message is being sent to spy channel
*/
SPY,

/**
* Chat type is not determined
*
* <p>This type used when local/global chat features are disabled
*/
UNKNOWN,
;

private final String key;

ChatType() {
this.key = name().toLowerCase(Locale.ENGLISH);
}

/**
* @return Lowercase name of the chat type.
*/
public String key() {
return key;
}
Comment thread
brawaru marked this conversation as resolved.
}
123 changes: 123 additions & 0 deletions Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
* This handles common boilerplate for other ChatEvents
*/
public abstract class ChatEvent extends Event implements Cancellable {
private final ChatType chatType;
private final Player player;
private final Set<Player> recipients;
private String message;
private String format;

private boolean cancelled = false;

public ChatEvent(final boolean async, final ChatType chatType, final Player player,
final String format, final String message, final Set<Player> recipients) {
super(async);

this.chatType = chatType;
this.player = player;
this.format = format;
this.message = message;
this.recipients = recipients;
}

/**
* Gets the message that the player is attempting to send. This message will be used with
* {@link #getFormat()}.
*
* @return Message the player is attempting to send
*/
public String getMessage() {
return message;
}

/**
* Sets the message that the player will send. This message will be used with
* {@link #getFormat()}.
*
* @param message New message that the player will send
*/
public void setMessage(final String message) {
this.message = message;
}

/**
* Gets the format to use to display this chat message. When this event finishes execution, the
* first format parameter is the {@link Player#getDisplayName()} and the second parameter is
* {@link #getMessage()}
*
* @return {@link String#format(String, Object...)} compatible format string
*/
public String getFormat() {
return format;
}

/**
* Sets the format to use to display this chat message. When this event finishes execution, the
* first format parameter is the {@link Player#getDisplayName()} and the second parameter is
* {@link #getMessage()}
*
* @param format {@link String#format(String, Object...)} compatible format string
* @throws IllegalFormatException if the underlying API throws the exception
* @throws NullPointerException if format is null
* @see String#format(String, Object...)
*/
public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
// Oh for a better way to do this!
try {
String.format(format, player, message);
} catch (final RuntimeException ex) {
ex.fillInStackTrace();
throw ex;
}

this.format = format;
}

/**
* Gets a set of recipients that this chat message will be displayed to.
*
* @return All Players who will see this chat message
*/
public Set<Player> getRecipients() {
return recipients;
}

/**
* Returns the player involved in this event
*
* @return Player who is involved in this event
*/
public final Player getPlayer() {
return player;
}

/**
* Returns the type of chat this event is fired for
*
* @return Type of chat this event is fired for
*/
public ChatType getChatType() {
return chatType;
}

@Override
public boolean isCancelled() {
return cancelled;
}

@Override
public void setCancelled(final boolean cancel) {
this.cancelled = cancel;
}
}
28 changes: 28 additions & 0 deletions Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
* Fired when a player uses global chat
*/
public class GlobalChatEvent extends ChatEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();

public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
super(async, chatType, player, format, message, recipients);
}

public static HandlerList getHandlerList() {
return handlers;
}

@Override
public HandlerList getHandlers() {
return handlers;
}
}
42 changes: 42 additions & 0 deletions Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
* Fired when a player uses local chat
*/
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.
private static final HandlerList handlers = new HandlerList();

private final long radius;

public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
super(async, ChatType.LOCAL, player, format, message, recipients);
this.radius = radius;
}

/**
* Returns local chat radius used to calculate recipients of this message.
* <p>
* <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
* to player who sent the message ({@link ChatEvent#getPlayer()}).
* @return Non-squared local chat radius.
*/
public long getRadius() {
return radius;
}

public static HandlerList getHandlerList() {
return handlers;
}

@Override
public HandlerList getHandlers() {
return handlers;
}
}
Loading
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
Add separate events for local and global chat by brawaru · Pull Request #4683 · EssentialsX/Essentials · GitHub
Skip to content
Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

mdcfe
merged 4 commits into

from

Feb 13, 2023
 Merged


Add separate events for local and global chat
#4683
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


4 commits


Select commit
Hold shift + click to select a range
7bd890d

Add separate events for local and global chat


brawaru Dec 12, 2021
f739317

Merge branch '2.x' into feat/add-chat-type-events


JRoy Aug 22, 2022
9e42f9e

Merge branch '2.x' into feat/add-chat-type-events


JRoy Oct 11, 2022
bbd9c1c

Merge branch '2.x' into feat/add-chat-type-events


mdcfe Feb 13, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


97 changes: 5 additions & 92 deletions
Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
 * Fired when a player uses local chat.
 */
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
 private static final HandlerList handlers = new HandlerList();
 private final Player player;
 private final Set<Player> recipients;
 private boolean cancelled = false;
 private String message;
 private String format;

 public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
 super(async);
 this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
 this.message = message;
 recipients = players;
 player = who;
 public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
Expand Down

49 changes: 49 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
 * Represents chat type for a message
 */
public enum ChatType {
 /**
 * Message is being sent to global chat as a shout
 */
 SHOUT,

 /**
 * Message is being sent to global chat as a question
 */
 QUESTION,

 /**
 * Message is being sent locally
 */
 LOCAL,

 /**
 * Message is being sent to spy channel
 */
 SPY,

 /**
 * Chat type is not determined
 *
 * <p>This type used when local/global chat features are disabled
 */
 UNKNOWN,
 ;

 private final String key;

 ChatType() {
 this.key = name().toLowerCase(Locale.ENGLISH);
 }

 /**
 * @return Lowercase name of the chat type.
 */
 public String key() {
 return key;
 }
Comment thread
brawaru marked this conversation as resolved.

}

123 changes: 123 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
 * This handles common boilerplate for other ChatEvents
 */
public abstract class ChatEvent extends Event implements Cancellable {
 private final ChatType chatType;
 private final Player player;
 private final Set<Player> recipients;
 private String message;
 private String format;

 private boolean cancelled = false;

 public ChatEvent(final boolean async, final ChatType chatType, final Player player,
 final String format, final String message, final Set<Player> recipients) {
 super(async);

 this.chatType = chatType;
 this.player = player;
 this.format = format;
 this.message = message;
 this.recipients = recipients;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with
 * {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with
 * {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 /**
 * Returns the type of chat this event is fired for
 *
 * @return Type of chat this event is fired for
 */
 public ChatType getChatType() {
 return chatType;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }
}

28 changes: 28 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses global chat
 */
public class GlobalChatEvent extends ChatEvent implements Cancellable {
 private static final HandlerList handlers = new HandlerList();

 public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, chatType, player, format, message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}

42 changes: 42 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses local chat
 */
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.

 private static final HandlerList handlers = new HandlerList();

 private final long radius;

 public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
 super(async, ChatType.LOCAL, player, format, message, recipients);
 this.radius = radius;
 }

 /**
 * Returns local chat radius used to calculate recipients of this message.
 * <p>
 * <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
 * to player who sent the message ({@link ChatEvent#getPlayer()}).
 * @return Non-squared local chat radius.
 */
 public long getRadius() {
 return radius;
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Add separate events for local and global chat by brawaru · Pull Request #4683 · EssentialsX/Essentials · GitHub
Skip to content
Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

mdcfe
merged 4 commits into

from

Feb 13, 2023
 Merged


Add separate events for local and global chat
#4683
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


4 commits


Select commit
Hold shift + click to select a range
7bd890d

Add separate events for local and global chat


brawaru Dec 12, 2021
f739317

Merge branch '2.x' into feat/add-chat-type-events


JRoy Aug 22, 2022
9e42f9e

Merge branch '2.x' into feat/add-chat-type-events


JRoy Oct 11, 2022
bbd9c1c

Merge branch '2.x' into feat/add-chat-type-events


mdcfe Feb 13, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


97 changes: 5 additions & 92 deletions
Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
 * Fired when a player uses local chat.
 */
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
 private static final HandlerList handlers = new HandlerList();
 private final Player player;
 private final Set<Player> recipients;
 private boolean cancelled = false;
 private String message;
 private String format;

 public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
 super(async);
 this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
 this.message = message;
 recipients = players;
 player = who;
 public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
Expand Down

49 changes: 49 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
 * Represents chat type for a message
 */
public enum ChatType {
 /**
 * Message is being sent to global chat as a shout
 */
 SHOUT,

 /**
 * Message is being sent to global chat as a question
 */
 QUESTION,

 /**
 * Message is being sent locally
 */
 LOCAL,

 /**
 * Message is being sent to spy channel
 */
 SPY,

 /**
 * Chat type is not determined
 *
 * <p>This type used when local/global chat features are disabled
 */
 UNKNOWN,
 ;

 private final String key;

 ChatType() {
 this.key = name().toLowerCase(Locale.ENGLISH);
 }

 /**
 * @return Lowercase name of the chat type.
 */
 public String key() {
 return key;
 }
Comment thread
brawaru marked this conversation as resolved.

}

123 changes: 123 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
 * This handles common boilerplate for other ChatEvents
 */
public abstract class ChatEvent extends Event implements Cancellable {
 private final ChatType chatType;
 private final Player player;
 private final Set<Player> recipients;
 private String message;
 private String format;

 private boolean cancelled = false;

 public ChatEvent(final boolean async, final ChatType chatType, final Player player,
 final String format, final String message, final Set<Player> recipients) {
 super(async);

 this.chatType = chatType;
 this.player = player;
 this.format = format;
 this.message = message;
 this.recipients = recipients;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with
 * {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with
 * {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 /**
 * Returns the type of chat this event is fired for
 *
 * @return Type of chat this event is fired for
 */
 public ChatType getChatType() {
 return chatType;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }
}

28 changes: 28 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses global chat
 */
public class GlobalChatEvent extends ChatEvent implements Cancellable {
 private static final HandlerList handlers = new HandlerList();

 public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, chatType, player, format, message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}

42 changes: 42 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses local chat
 */
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.

 private static final HandlerList handlers = new HandlerList();

 private final long radius;

 public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
 super(async, ChatType.LOCAL, player, format, message, recipients);
 this.radius = radius;
 }

 /**
 * Returns local chat radius used to calculate recipients of this message.
 * <p>
 * <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
 * to player who sent the message ({@link ChatEvent#getPlayer()}).
 * @return Non-squared local chat radius.
 */
 public long getRadius() {
 return radius;
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Add separate events for local and global chat by brawaru · Pull Request #4683 · EssentialsX/Essentials · GitHub
Skip to content
Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

mdcfe
merged 4 commits into

from

Feb 13, 2023
 Merged


Add separate events for local and global chat
#4683
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


4 commits


Select commit
Hold shift + click to select a range
7bd890d

Add separate events for local and global chat


brawaru Dec 12, 2021
f739317

Merge branch '2.x' into feat/add-chat-type-events


JRoy Aug 22, 2022
9e42f9e

Merge branch '2.x' into feat/add-chat-type-events


JRoy Oct 11, 2022
bbd9c1c

Merge branch '2.x' into feat/add-chat-type-events


mdcfe Feb 13, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


97 changes: 5 additions & 92 deletions
Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
 * Fired when a player uses local chat.
 */
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
 private static final HandlerList handlers = new HandlerList();
 private final Player player;
 private final Set<Player> recipients;
 private boolean cancelled = false;
 private String message;
 private String format;

 public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
 super(async);
 this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
 this.message = message;
 recipients = players;
 player = who;
 public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
Expand Down

49 changes: 49 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
 * Represents chat type for a message
 */
public enum ChatType {
 /**
 * Message is being sent to global chat as a shout
 */
 SHOUT,

 /**
 * Message is being sent to global chat as a question
 */
 QUESTION,

 /**
 * Message is being sent locally
 */
 LOCAL,

 /**
 * Message is being sent to spy channel
 */
 SPY,

 /**
 * Chat type is not determined
 *
 * <p>This type used when local/global chat features are disabled
 */
 UNKNOWN,
 ;

 private final String key;

 ChatType() {
 this.key = name().toLowerCase(Locale.ENGLISH);
 }

 /**
 * @return Lowercase name of the chat type.
 */
 public String key() {
 return key;
 }
Comment thread
brawaru marked this conversation as resolved.

}

123 changes: 123 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
 * This handles common boilerplate for other ChatEvents
 */
public abstract class ChatEvent extends Event implements Cancellable {
 private final ChatType chatType;
 private final Player player;
 private final Set<Player> recipients;
 private String message;
 private String format;

 private boolean cancelled = false;

 public ChatEvent(final boolean async, final ChatType chatType, final Player player,
 final String format, final String message, final Set<Player> recipients) {
 super(async);

 this.chatType = chatType;
 this.player = player;
 this.format = format;
 this.message = message;
 this.recipients = recipients;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with
 * {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with
 * {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 /**
 * Returns the type of chat this event is fired for
 *
 * @return Type of chat this event is fired for
 */
 public ChatType getChatType() {
 return chatType;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }
}

28 changes: 28 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses global chat
 */
public class GlobalChatEvent extends ChatEvent implements Cancellable {
 private static final HandlerList handlers = new HandlerList();

 public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, chatType, player, format, message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}

42 changes: 42 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses local chat
 */
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.

 private static final HandlerList handlers = new HandlerList();

 private final long radius;

 public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
 super(async, ChatType.LOCAL, player, format, message, recipients);
 this.radius = radius;
 }

 /**
 * Returns local chat radius used to calculate recipients of this message.
 * <p>
 * <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
 * to player who sent the message ({@link ChatEvent#getPlayer()}).
 * @return Non-squared local chat radius.
 */
 public long getRadius() {
 return radius;
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
Add separate events for local and global chat by brawaru · Pull Request #4683 · EssentialsX/Essentials · GitHub
Skip to content
Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

mdcfe
merged 4 commits into

from

Feb 13, 2023
 Merged


Add separate events for local and global chat
#4683
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


4 commits


Select commit
Hold shift + click to select a range
7bd890d

Add separate events for local and global chat


brawaru Dec 12, 2021
f739317

Merge branch '2.x' into feat/add-chat-type-events


JRoy Aug 22, 2022
9e42f9e

Merge branch '2.x' into feat/add-chat-type-events


JRoy Oct 11, 2022
bbd9c1c

Merge branch '2.x' into feat/add-chat-type-events


mdcfe Feb 13, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


97 changes: 5 additions & 92 deletions
Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
 * Fired when a player uses local chat.
 */
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
 private static final HandlerList handlers = new HandlerList();
 private final Player player;
 private final Set<Player> recipients;
 private boolean cancelled = false;
 private String message;
 private String format;

 public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
 super(async);
 this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
 this.message = message;
 recipients = players;
 player = who;
 public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
Expand Down

49 changes: 49 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
 * Represents chat type for a message
 */
public enum ChatType {
 /**
 * Message is being sent to global chat as a shout
 */
 SHOUT,

 /**
 * Message is being sent to global chat as a question
 */
 QUESTION,

 /**
 * Message is being sent locally
 */
 LOCAL,

 /**
 * Message is being sent to spy channel
 */
 SPY,

 /**
 * Chat type is not determined
 *
 * <p>This type used when local/global chat features are disabled
 */
 UNKNOWN,
 ;

 private final String key;

 ChatType() {
 this.key = name().toLowerCase(Locale.ENGLISH);
 }

 /**
 * @return Lowercase name of the chat type.
 */
 public String key() {
 return key;
 }
Comment thread
brawaru marked this conversation as resolved.

}

123 changes: 123 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
 * This handles common boilerplate for other ChatEvents
 */
public abstract class ChatEvent extends Event implements Cancellable {
 private final ChatType chatType;
 private final Player player;
 private final Set<Player> recipients;
 private String message;
 private String format;

 private boolean cancelled = false;

 public ChatEvent(final boolean async, final ChatType chatType, final Player player,
 final String format, final String message, final Set<Player> recipients) {
 super(async);

 this.chatType = chatType;
 this.player = player;
 this.format = format;
 this.message = message;
 this.recipients = recipients;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with
 * {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with
 * {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 /**
 * Returns the type of chat this event is fired for
 *
 * @return Type of chat this event is fired for
 */
 public ChatType getChatType() {
 return chatType;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }
}

28 changes: 28 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses global chat
 */
public class GlobalChatEvent extends ChatEvent implements Cancellable {
 private static final HandlerList handlers = new HandlerList();

 public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, chatType, player, format, message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}

42 changes: 42 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses local chat
 */
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.

 private static final HandlerList handlers = new HandlerList();

 private final long radius;

 public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
 super(async, ChatType.LOCAL, player, format, message, recipients);
 this.radius = radius;
 }

 /**
 * Returns local chat radius used to calculate recipients of this message.
 * <p>
 * <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
 * to player who sent the message ({@link ChatEvent#getPlayer()}).
 * @return Non-squared local chat radius.
 */
 public long getRadius() {
 return radius;
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Add separate events for local and global chat by brawaru · Pull Request #4683 · EssentialsX/Essentials · GitHub
Skip to content
Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

mdcfe
merged 4 commits into

from

Feb 13, 2023
 Merged


Add separate events for local and global chat
#4683
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


4 commits


Select commit
Hold shift + click to select a range
7bd890d

Add separate events for local and global chat


brawaru Dec 12, 2021
f739317

Merge branch '2.x' into feat/add-chat-type-events


JRoy Aug 22, 2022
9e42f9e

Merge branch '2.x' into feat/add-chat-type-events


JRoy Oct 11, 2022
bbd9c1c

Merge branch '2.x' into feat/add-chat-type-events


mdcfe Feb 13, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


97 changes: 5 additions & 92 deletions
Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
 * Fired when a player uses local chat.
 */
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
 private static final HandlerList handlers = new HandlerList();
 private final Player player;
 private final Set<Player> recipients;
 private boolean cancelled = false;
 private String message;
 private String format;

 public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
 super(async);
 this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
 this.message = message;
 recipients = players;
 player = who;
 public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
Expand Down

49 changes: 49 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
 * Represents chat type for a message
 */
public enum ChatType {
 /**
 * Message is being sent to global chat as a shout
 */
 SHOUT,

 /**
 * Message is being sent to global chat as a question
 */
 QUESTION,

 /**
 * Message is being sent locally
 */
 LOCAL,

 /**
 * Message is being sent to spy channel
 */
 SPY,

 /**
 * Chat type is not determined
 *
 * <p>This type used when local/global chat features are disabled
 */
 UNKNOWN,
 ;

 private final String key;

 ChatType() {
 this.key = name().toLowerCase(Locale.ENGLISH);
 }

 /**
 * @return Lowercase name of the chat type.
 */
 public String key() {
 return key;
 }
Comment thread
brawaru marked this conversation as resolved.

}

123 changes: 123 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
 * This handles common boilerplate for other ChatEvents
 */
public abstract class ChatEvent extends Event implements Cancellable {
 private final ChatType chatType;
 private final Player player;
 private final Set<Player> recipients;
 private String message;
 private String format;

 private boolean cancelled = false;

 public ChatEvent(final boolean async, final ChatType chatType, final Player player,
 final String format, final String message, final Set<Player> recipients) {
 super(async);

 this.chatType = chatType;
 this.player = player;
 this.format = format;
 this.message = message;
 this.recipients = recipients;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with
 * {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with
 * {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 /**
 * Returns the type of chat this event is fired for
 *
 * @return Type of chat this event is fired for
 */
 public ChatType getChatType() {
 return chatType;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }
}

28 changes: 28 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses global chat
 */
public class GlobalChatEvent extends ChatEvent implements Cancellable {
 private static final HandlerList handlers = new HandlerList();

 public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, chatType, player, format, message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}

42 changes: 42 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses local chat
 */
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.

 private static final HandlerList handlers = new HandlerList();

 private final long radius;

 public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
 super(async, ChatType.LOCAL, player, format, message, recipients);
 this.radius = radius;
 }

 /**
 * Returns local chat radius used to calculate recipients of this message.
 * <p>
 * <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
 * to player who sent the message ({@link ChatEvent#getPlayer()}).
 * @return Non-squared local chat radius.
 */
 public long getRadius() {
 return radius;
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
Add separate events for local and global chat by brawaru · Pull Request #4683 · EssentialsX/Essentials · GitHub
Skip to content
Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

mdcfe
merged 4 commits into

from

Feb 13, 2023
 Merged


Add separate events for local and global chat
#4683
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


4 commits


Select commit
Hold shift + click to select a range
7bd890d

Add separate events for local and global chat


brawaru Dec 12, 2021
f739317

Merge branch '2.x' into feat/add-chat-type-events


JRoy Aug 22, 2022
9e42f9e

Merge branch '2.x' into feat/add-chat-type-events


JRoy Oct 11, 2022
bbd9c1c

Merge branch '2.x' into feat/add-chat-type-events


mdcfe Feb 13, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


97 changes: 5 additions & 92 deletions
Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
 * Fired when a player uses local chat.
 */
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
 private static final HandlerList handlers = new HandlerList();
 private final Player player;
 private final Set<Player> recipients;
 private boolean cancelled = false;
 private String message;
 private String format;

 public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
 super(async);
 this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
 this.message = message;
 recipients = players;
 player = who;
 public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
Expand Down

49 changes: 49 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
 * Represents chat type for a message
 */
public enum ChatType {
 /**
 * Message is being sent to global chat as a shout
 */
 SHOUT,

 /**
 * Message is being sent to global chat as a question
 */
 QUESTION,

 /**
 * Message is being sent locally
 */
 LOCAL,

 /**
 * Message is being sent to spy channel
 */
 SPY,

 /**
 * Chat type is not determined
 *
 * <p>This type used when local/global chat features are disabled
 */
 UNKNOWN,
 ;

 private final String key;

 ChatType() {
 this.key = name().toLowerCase(Locale.ENGLISH);
 }

 /**
 * @return Lowercase name of the chat type.
 */
 public String key() {
 return key;
 }
Comment thread
brawaru marked this conversation as resolved.

}

123 changes: 123 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
 * This handles common boilerplate for other ChatEvents
 */
public abstract class ChatEvent extends Event implements Cancellable {
 private final ChatType chatType;
 private final Player player;
 private final Set<Player> recipients;
 private String message;
 private String format;

 private boolean cancelled = false;

 public ChatEvent(final boolean async, final ChatType chatType, final Player player,
 final String format, final String message, final Set<Player> recipients) {
 super(async);

 this.chatType = chatType;
 this.player = player;
 this.format = format;
 this.message = message;
 this.recipients = recipients;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with
 * {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with
 * {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 /**
 * Returns the type of chat this event is fired for
 *
 * @return Type of chat this event is fired for
 */
 public ChatType getChatType() {
 return chatType;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }
}

28 changes: 28 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses global chat
 */
public class GlobalChatEvent extends ChatEvent implements Cancellable {
 private static final HandlerList handlers = new HandlerList();

 public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, chatType, player, format, message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}

42 changes: 42 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses local chat
 */
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.

 private static final HandlerList handlers = new HandlerList();

 private final long radius;

 public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
 super(async, ChatType.LOCAL, player, format, message, recipients);
 this.radius = radius;
 }

 /**
 * Returns local chat radius used to calculate recipients of this message.
 * <p>
 * <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
 * to player who sent the message ({@link ChatEvent#getPlayer()}).
 * @return Non-squared local chat radius.
 */
 public long getRadius() {
 return radius;
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}
Loading

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
Add separate events for local and global chat by brawaru · Pull Request #4683 · EssentialsX/Essentials · GitHub
Skip to content
Add separate events for local and global chat#4683

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

 Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and
privacy statement. We’ll occasionally send you account related emails.

Already on GitHub?
Sign in
to your account

 Merged

mdcfe
merged 4 commits into

from

Feb 13, 2023
 Merged


Add separate events for local and global chat
#4683
Show file tree
Hide file tree
 Changes from all commits
Commits

Show all changes


4 commits


Select commit
Hold shift + click to select a range
7bd890d

Add separate events for local and global chat


brawaru Dec 12, 2021
f739317

Merge branch '2.x' into feat/add-chat-type-events


JRoy Aug 22, 2022
9e42f9e

Merge branch '2.x' into feat/add-chat-type-events


JRoy Oct 11, 2022
bbd9c1c

Merge branch '2.x' into feat/add-chat-type-events


mdcfe Feb 13, 2023

File filter

Filter by extension
Filter by extension
Conversations

Failed to load comments. 
Loading
Jump to

Jump to file


Failed to load files. 
Loading
 Diff view

 Diff view


97 changes: 5 additions & 92 deletions
Essentials/src/main/java/net/ess3/api/events/LocalChatSpyEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -1,115 +1,28 @@
package net.ess3.api.events;

import net.essentialsx.api.v2.ChatType;
import net.essentialsx.api.v2.events.chat.ChatEvent;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;

import java.util.IllegalFormatException;
import java.util.Set;

import static com.earth2me.essentials.I18n.tl;

/**
 * Fired when a player uses local chat.
 */
public class LocalChatSpyEvent extends Event implements Cancellable {
public class LocalChatSpyEvent extends ChatEvent {
 private static final HandlerList handlers = new HandlerList();
 private final Player player;
 private final Set<Player> recipients;
 private boolean cancelled = false;
 private String message;
 private String format;

 public LocalChatSpyEvent(final boolean async, final Player who, final String format, final String message, final Set<Player> players) {
 super(async);
 this.format = tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format);
 this.message = message;
 recipients = players;
 player = who;
 public LocalChatSpyEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, ChatType.SPY, player, tl("chatTypeLocal").concat(tl("chatTypeSpy")).concat(format), message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message to spy recipients. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
Expand Down

49 changes: 49 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/ChatType.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
package net.essentialsx.api.v2;

import java.util.Locale;

/**
 * Represents chat type for a message
 */
public enum ChatType {
 /**
 * Message is being sent to global chat as a shout
 */
 SHOUT,

 /**
 * Message is being sent to global chat as a question
 */
 QUESTION,

 /**
 * Message is being sent locally
 */
 LOCAL,

 /**
 * Message is being sent to spy channel
 */
 SPY,

 /**
 * Chat type is not determined
 *
 * <p>This type used when local/global chat features are disabled
 */
 UNKNOWN,
 ;

 private final String key;

 ChatType() {
 this.key = name().toLowerCase(Locale.ENGLISH);
 }

 /**
 * @return Lowercase name of the chat type.
 */
 public String key() {
 return key;
 }
Comment thread
brawaru marked this conversation as resolved.

}

123 changes: 123 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/ChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,123 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;

import java.util.IllegalFormatException;
import java.util.Set;

/**
 * This handles common boilerplate for other ChatEvents
 */
public abstract class ChatEvent extends Event implements Cancellable {
 private final ChatType chatType;
 private final Player player;
 private final Set<Player> recipients;
 private String message;
 private String format;

 private boolean cancelled = false;

 public ChatEvent(final boolean async, final ChatType chatType, final Player player,
 final String format, final String message, final Set<Player> recipients) {
 super(async);

 this.chatType = chatType;
 this.player = player;
 this.format = format;
 this.message = message;
 this.recipients = recipients;
 }

 /**
 * Gets the message that the player is attempting to send. This message will be used with
 * {@link #getFormat()}.
 *
 * @return Message the player is attempting to send
 */
 public String getMessage() {
 return message;
 }

 /**
 * Sets the message that the player will send. This message will be used with
 * {@link #getFormat()}.
 *
 * @param message New message that the player will send
 */
 public void setMessage(final String message) {
 this.message = message;
 }

 /**
 * Gets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @return {@link String#format(String, Object...)} compatible format string
 */
 public String getFormat() {
 return format;
 }

 /**
 * Sets the format to use to display this chat message. When this event finishes execution, the
 * first format parameter is the {@link Player#getDisplayName()} and the second parameter is
 * {@link #getMessage()}
 *
 * @param format {@link String#format(String, Object...)} compatible format string
 * @throws IllegalFormatException if the underlying API throws the exception
 * @throws NullPointerException if format is null
 * @see String#format(String, Object...)
 */
 public void setFormat(final String format) throws IllegalFormatException, NullPointerException {
 // Oh for a better way to do this!
 try {
 String.format(format, player, message);
 } catch (final RuntimeException ex) {
 ex.fillInStackTrace();
 throw ex;
 }

 this.format = format;
 }

 /**
 * Gets a set of recipients that this chat message will be displayed to.
 *
 * @return All Players who will see this chat message
 */
 public Set<Player> getRecipients() {
 return recipients;
 }

 /**
 * Returns the player involved in this event
 *
 * @return Player who is involved in this event
 */
 public final Player getPlayer() {
 return player;
 }

 /**
 * Returns the type of chat this event is fired for
 *
 * @return Type of chat this event is fired for
 */
 public ChatType getChatType() {
 return chatType;
 }

 @Override
 public boolean isCancelled() {
 return cancelled;
 }

 @Override
 public void setCancelled(final boolean cancel) {
 this.cancelled = cancel;
 }
}

28 changes: 28 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/GlobalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses global chat
 */
public class GlobalChatEvent extends ChatEvent implements Cancellable {
 private static final HandlerList handlers = new HandlerList();

 public GlobalChatEvent(final boolean async, final ChatType chatType, final Player player, final String format, final String message, final Set<Player> recipients) {
 super(async, chatType, player, format, message, recipients);
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}

42 changes: 42 additions & 0 deletions
Essentials/src/main/java/net/essentialsx/api/v2/events/chat/LocalChatEvent.java

View file


Open in desktop

Original file line numberDiff line numberDiff line change
@@ -0,0 +1,42 @@
package net.essentialsx.api.v2.events.chat;

import net.essentialsx.api.v2.ChatType;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;

import java.util.Set;

/**
 * Fired when a player uses local chat
 */
public class LocalChatEvent extends ChatEvent implements Cancellable {
Comment thread
brawaru marked this conversation as resolved.

 private static final HandlerList handlers = new HandlerList();

 private final long radius;

 public LocalChatEvent(final boolean async, final Player player, final String format, final String message, final Set<Player> recipients, final long radius) {
 super(async, ChatType.LOCAL, player, format, message, recipients);
 this.radius = radius;
 }

 /**
 * Returns local chat radius used to calculate recipients of this message.
 * <p>
 * <p>This is not a radius between players: for that use {@link ChatEvent#getRecipients()} and calculate distance
 * to player who sent the message ({@link ChatEvent#getPlayer()}).
 * @return Non-squared local chat radius.
 */
 public long getRadius() {
 return radius;
 }

 public static HandlerList getHandlerList() {
 return handlers;
 }

 @Override
 public HandlerList getHandlers() {
 return handlers;
 }
}
Loading