load(K key);
+}
\ No newline at end of file
diff --git a/src/net/jodah/expiringmap/ExpiringMap.java b/src/net/jodah/expiringmap/ExpiringMap.java
new file mode 100644
index 0000000..df3dcaa
--- /dev/null
+++ b/src/net/jodah/expiringmap/ExpiringMap.java
@@ -0,0 +1,1385 @@
+package net.jodah.expiringmap;
+
+import java.lang.ref.WeakReference;
+import java.util.AbstractCollection;
+import java.util.AbstractSet;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import net.jodah.expiringmap.internal.Assert;
+import net.jodah.expiringmap.internal.NamedThreadFactory;
+
+/**
+ * A thread-safe map that expires entries. Optional features include expiration policies, variable entry expiration,
+ * lazy entry loading, and expiration listeners.
+ *
+ *
+ * Entries are tracked by expiration time and expired by a single thread.
+ *
+ *
+ * Expiration listeners are called synchronously as entries are expired and block write operations to the map until they
+ * completed. Asynchronous expiration listeners are called on a separate thread pool and do not block map operations.
+ *
+ *
+ * When variable expiration is disabled (default), put/remove operations have a time complexity O(1). When
+ * variable expiration is enabled, put/remove operations have time complexity of O(log n).
+ *
+ *
+ * Example usages:
+ *
+ *
+ * {@code
+ * Map map = ExpiringMap.create();
+ * Map map = ExpiringMap.builder().expiration(30, TimeUnit.SECONDS).build();
+ * Map map = ExpiringMap.builder()
+ * .expiration(10, TimeUnit.MINUTES)
+ * .entryLoader(new EntryLoader() {
+ * public Connection load(String address) {
+ * return new Connection(address);
+ * }
+ * })
+ * .expirationListener(new ExpirationListener() {
+ * public void expired(String key, Connection connection) {
+ * connection.close();
+ * }
+ * })
+ * .build();
+ * }
+ *
+ *
+ * @author Jonathan Halterman
+ * @param Key type
+ * @param Value type
+ */
+public class ExpiringMap implements ConcurrentMap {
+ static volatile ScheduledExecutorService EXPIRER;
+ static volatile ThreadPoolExecutor LISTENER_SERVICE;
+ static ThreadFactory THREAD_FACTORY;
+
+ List> expirationListeners;
+ List> asyncExpirationListeners;
+ private AtomicLong expirationNanos;
+ private int maxSize;
+ private final AtomicReference expirationPolicy;
+ private final EntryLoader entryLoader;
+ private final ExpiringEntryLoader expiringEntryLoader;
+ private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
+ private final Lock readLock = readWriteLock.readLock();
+ private final Lock writeLock = readWriteLock.writeLock();
+ /** Guarded by "readWriteLock" */
+ private final EntryMap entries;
+ private final boolean variableExpiration;
+
+ /**
+ * Sets the {@link ThreadFactory} that is used to create expiration and listener callback threads for all ExpiringMap
+ * instances.
+ *
+ * @param threadFactory
+ * @throws NullPointerException if {@code threadFactory} is null
+ */
+ public static void setThreadFactory(ThreadFactory threadFactory) {
+ THREAD_FACTORY = Assert.notNull(threadFactory, "threadFactory");
+ }
+
+ /**
+ * Creates a new instance of ExpiringMap.
+ *
+ * @param builder The map builder
+ */
+ private ExpiringMap(final Builder builder) {
+ if (EXPIRER == null) {
+ synchronized (ExpiringMap.class) {
+ if (EXPIRER == null) {
+ EXPIRER = Executors.newSingleThreadScheduledExecutor(
+ THREAD_FACTORY == null ? new NamedThreadFactory("ExpiringMap-Expirer") : THREAD_FACTORY);
+ }
+ }
+ }
+
+ if (LISTENER_SERVICE == null && builder.asyncExpirationListeners != null) {
+ synchronized (ExpiringMap.class) {
+ if (LISTENER_SERVICE == null) {
+ LISTENER_SERVICE = (ThreadPoolExecutor) Executors.newCachedThreadPool(
+ THREAD_FACTORY == null ? new NamedThreadFactory("ExpiringMap-Listener-%s") : THREAD_FACTORY);
+ }
+ }
+ }
+
+ variableExpiration = builder.variableExpiration;
+ entries = variableExpiration ? new EntryTreeHashMap() : new EntryLinkedHashMap();
+ if (builder.expirationListeners != null)
+ expirationListeners = new CopyOnWriteArrayList>(builder.expirationListeners);
+ if (builder.asyncExpirationListeners != null)
+ asyncExpirationListeners = new CopyOnWriteArrayList>(builder.asyncExpirationListeners);
+ expirationPolicy = new AtomicReference(builder.expirationPolicy);
+ expirationNanos = new AtomicLong(TimeUnit.NANOSECONDS.convert(builder.duration, builder.timeUnit));
+ maxSize = builder.maxSize;
+ entryLoader = builder.entryLoader;
+ expiringEntryLoader = builder.expiringEntryLoader;
+ }
+
+ /**
+ * Builds ExpiringMap instances. Defaults to ExpirationPolicy.CREATED, expiration of 60 TimeUnit.SECONDS and
+ * a maxSize of Integer.MAX_VALUE.
+ */
+ public static final class Builder {
+ private ExpirationPolicy expirationPolicy = ExpirationPolicy.CREATED;
+ private List> expirationListeners;
+ private List> asyncExpirationListeners;
+ private TimeUnit timeUnit = TimeUnit.SECONDS;
+ private boolean variableExpiration;
+ private long duration = 60;
+ private int maxSize = Integer.MAX_VALUE;
+ private EntryLoader entryLoader;
+ private ExpiringEntryLoader expiringEntryLoader;
+
+ /**
+ * Creates a new Builder object.
+ */
+ private Builder() {
+ }
+
+ /**
+ * Builds and returns an expiring map.
+ *
+ * @param Key type
+ * @param Value type
+ */
+ @SuppressWarnings("unchecked")
+ public ExpiringMap build() {
+ return new ExpiringMap((Builder) this);
+ }
+
+ /**
+ * Sets the default map entry expiration.
+ *
+ * @param duration the length of time after an entry is created that it should be removed
+ * @param timeUnit the unit that {@code duration} is expressed in
+ * @throws NullPointerException if {@code timeUnit} is null
+ */
+ public Builder expiration(long duration, TimeUnit timeUnit) {
+ this.duration = duration;
+ this.timeUnit = Assert.notNull(timeUnit, "timeUnit");
+ return this;
+ }
+
+ /**
+ * Sets the maximum size of the map. Once this size has been reached, adding an additional entry will expire the
+ * first entry in line for expiration based on the expiration policy.
+ *
+ * @param maxSize The maximum size of the map.
+ */
+ public Builder maxSize(int maxSize) {
+ Assert.operation(maxSize > 0, "maxSize");
+ this.maxSize = maxSize;
+ return this;
+ }
+
+ /**
+ * Sets the EntryLoader to use when loading entries. Either an EntryLoader or ExpiringEntryLoader may be set, not
+ * both.
+ *
+ * @param loader to set
+ * @throws NullPointerException if {@code loader} is null
+ * @throws IllegalStateException if an {@link #expiringEntryLoader(ExpiringEntryLoader) ExpiringEntryLoader} is set
+ */
+ @SuppressWarnings("unchecked")
+ public Builder entryLoader(EntryLoader loader) {
+ assertNoLoaderSet();
+ entryLoader = (EntryLoader) Assert.notNull(loader, "loader");
+ return (Builder) this;
+ }
+
+ /**
+ * Sets the ExpiringEntryLoader to use when loading entries and configures {@link #variableExpiration() variable
+ * expiration}. Either an EntryLoader or ExpiringEntryLoader may be set, not both.
+ *
+ * @param loader to set
+ * @throws NullPointerException if {@code loader} is null
+ * @throws IllegalStateException if an {@link #entryLoader(EntryLoader) EntryLoader} is set
+ */
+ @SuppressWarnings("unchecked")
+ public Builder expiringEntryLoader(
+ ExpiringEntryLoader loader) {
+ assertNoLoaderSet();
+ expiringEntryLoader = (ExpiringEntryLoader) Assert.notNull(loader, "loader");
+ variableExpiration();
+ return (Builder) this;
+ }
+
+ /**
+ * Configures the expiration listener that will receive notifications upon each map entry's expiration.
+ * Notifications are delivered synchronously and block map write operations.
+ *
+ * @param listener to set
+ * @throws NullPointerException if {@code listener} is null
+ */
+ @SuppressWarnings("unchecked")
+ public Builder expirationListener(
+ ExpirationListener listener) {
+ Assert.notNull(listener, "listener");
+ if (expirationListeners == null)
+ expirationListeners = new ArrayList>();
+ expirationListeners.add((ExpirationListener) listener);
+ return (Builder) this;
+ }
+
+ /**
+ * Configures the expiration listeners which will receive notifications upon each map entry's expiration.
+ * Notifications are delivered synchronously and block map write operations.
+ *
+ * @param listeners to set
+ * @throws NullPointerException if {@code listener} is null
+ */
+ @SuppressWarnings("unchecked")
+ public Builder expirationListeners(
+ List> listeners) {
+ Assert.notNull(listeners, "listeners");
+ if (expirationListeners == null)
+ expirationListeners = new ArrayList>(listeners.size());
+ for (ExpirationListener listener : listeners)
+ expirationListeners.add((ExpirationListener) listener);
+ return (Builder) this;
+ }
+
+ /**
+ * Configures the expiration listener which will receive asynchronous notifications upon each map entry's
+ * expiration.
+ *
+ * @param listener to set
+ * @throws NullPointerException if {@code listener} is null
+ */
+ @SuppressWarnings("unchecked")
+ public Builder asyncExpirationListener(
+ ExpirationListener listener) {
+ Assert.notNull(listener, "listener");
+ if (asyncExpirationListeners == null)
+ asyncExpirationListeners = new ArrayList>();
+ asyncExpirationListeners.add((ExpirationListener) listener);
+ return (Builder) this;
+ }
+
+ /**
+ * Configures the expiration listeners which will receive asynchronous notifications upon each map entry's
+ * expiration.
+ *
+ * @param listeners to set
+ * @throws NullPointerException if {@code listener} is null
+ */
+ @SuppressWarnings("unchecked")
+ public Builder asyncExpirationListeners(
+ List> listeners) {
+ Assert.notNull(listeners, "listeners");
+ if (asyncExpirationListeners == null)
+ asyncExpirationListeners = new ArrayList>(listeners.size());
+ for (ExpirationListener listener : listeners)
+ asyncExpirationListeners.add((ExpirationListener) listener);
+ return (Builder) this;
+ }
+
+ /**
+ * Configures the map entry expiration policy.
+ *
+ * @param expirationPolicy
+ * @throws NullPointerException if {@code expirationPolicy} is null
+ */
+ public Builder expirationPolicy(ExpirationPolicy expirationPolicy) {
+ this.expirationPolicy = Assert.notNull(expirationPolicy, "expirationPolicy");
+ return this;
+ }
+
+ /**
+ * Allows for map entries to have individual expirations and for expirations to be changed.
+ */
+ public Builder variableExpiration() {
+ variableExpiration = true;
+ return this;
+ }
+
+ private void assertNoLoaderSet() {
+ Assert.state(entryLoader == null && expiringEntryLoader == null,
+ "Either entryLoader or expiringEntryLoader may be set, not both");
+ }
+ }
+
+ /** Entry map definition. */
+ private interface EntryMap extends Map> {
+ /** Returns the first entry in the map or null if the map is empty. */
+ ExpiringEntry first();
+
+ /**
+ * Reorders the given entry in the map.
+ *
+ * @param entry to reorder
+ */
+ void reorder(ExpiringEntry entry);
+
+ /** Returns a values iterator. */
+ Iterator> valuesIterator();
+ }
+
+ /** Entry LinkedHashMap implementation. */
+ private static class EntryLinkedHashMap extends LinkedHashMap>
+ implements EntryMap {
+ private static final long serialVersionUID = 1L;
+
+ @Override
+ public boolean containsValue(Object value) {
+ for (ExpiringEntry entry : values()) {
+ V v = entry.value;
+ if (v == value || (value != null && value.equals(v)))
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public ExpiringEntry first() {
+ return isEmpty() ? null : values().iterator().next();
+ }
+
+ @Override
+ public void reorder(ExpiringEntry value) {
+ remove(value.key);
+ value.resetExpiration();
+ put(value.key, value);
+ }
+
+ @Override
+ public Iterator> valuesIterator() {
+ return values().iterator();
+ }
+
+ abstract class AbstractHashIterator {
+ private final Iterator>> iterator = entrySet().iterator();
+ private ExpiringEntry next;
+
+ public boolean hasNext() {
+ return iterator.hasNext();
+ }
+
+ public ExpiringEntry getNext() {
+ next = iterator.next().getValue();
+ return next;
+ }
+
+ public void remove() {
+ iterator.remove();
+ }
+ }
+
+ final class KeyIterator extends AbstractHashIterator implements Iterator {
+ public final K next() {
+ return getNext().key;
+ }
+ }
+
+ final class ValueIterator extends AbstractHashIterator implements Iterator {
+ public final V next() {
+ return getNext().value;
+ }
+ }
+
+ public final class EntryIterator extends AbstractHashIterator implements Iterator> {
+ public final Map.Entry next() {
+ return mapEntryFor(getNext());
+ }
+ }
+ }
+
+ /** Entry TreeHashMap implementation for variable expiration ExpiringMap entries. */
+ private static class EntryTreeHashMap extends HashMap> implements EntryMap {
+ private static final long serialVersionUID = 1L;
+ SortedSet> sortedSet = new TreeSet>();
+
+ @Override
+ public void clear() {
+ super.clear();
+ sortedSet.clear();
+ }
+
+ @Override
+ public boolean containsValue(Object value) {
+ for (ExpiringEntry entry : values()) {
+ V v = entry.value;
+ if (v == value || (value != null && value.equals(v)))
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public ExpiringEntry first() {
+ return sortedSet.isEmpty() ? null : sortedSet.first();
+ }
+
+ @Override
+ public ExpiringEntry put(K key, ExpiringEntry value) {
+ sortedSet.add(value);
+ return super.put(key, value);
+ }
+
+ @Override
+ public ExpiringEntry remove(Object key) {
+ ExpiringEntry entry = super.remove(key);
+ if (entry != null)
+ sortedSet.remove(entry);
+ return entry;
+ }
+
+ @Override
+ public void reorder(ExpiringEntry value) {
+ sortedSet.remove(value);
+ value.resetExpiration();
+ sortedSet.add(value);
+ }
+
+ @Override
+ public Iterator> valuesIterator() {
+ return new ExpiringEntryIterator();
+ }
+
+ abstract class AbstractHashIterator {
+ private final Iterator> iterator = sortedSet.iterator();
+ protected ExpiringEntry next;
+
+ public boolean hasNext() {
+ return iterator.hasNext();
+ }
+
+ public ExpiringEntry getNext() {
+ next = iterator.next();
+ return next;
+ }
+
+ public void remove() {
+ EntryTreeHashMap.super.remove(next.key);
+ iterator.remove();
+ }
+ }
+
+ final class ExpiringEntryIterator extends AbstractHashIterator implements Iterator> {
+ public final ExpiringEntry next() {
+ return getNext();
+ }
+ }
+
+ final class KeyIterator extends AbstractHashIterator implements Iterator {
+ public final K next() {
+ return getNext().key;
+ }
+ }
+
+ final class ValueIterator extends AbstractHashIterator implements Iterator {
+ public final V next() {
+ return getNext().value;
+ }
+ }
+
+ final class EntryIterator extends AbstractHashIterator implements Iterator> {
+ public final Map.Entry next() {
+ return mapEntryFor(getNext());
+ }
+ }
+ }
+
+ /** Expiring map entry implementation. */
+ static class ExpiringEntry implements Comparable> {
+ final AtomicLong expirationNanos;
+ /** Epoch time at which the entry is expected to expire */
+ final AtomicLong expectedExpiration;
+ final AtomicReference expirationPolicy;
+ final K key;
+ /** Guarded by "this" */
+ volatile Future entryFuture;
+ /** Guarded by "this" */
+ V value;
+ /** Guarded by "this" */
+ volatile boolean scheduled;
+
+ /**
+ * Creates a new ExpiringEntry object.
+ *
+ * @param key for the entry
+ * @param value for the entry
+ * @param expirationPolicy for the entry
+ * @param expirationNanos for the entry
+ */
+ ExpiringEntry(K key, V value, AtomicReference expirationPolicy, AtomicLong expirationNanos) {
+ this.key = key;
+ this.value = value;
+ this.expirationPolicy = expirationPolicy;
+ this.expirationNanos = expirationNanos;
+ this.expectedExpiration = new AtomicLong();
+ resetExpiration();
+ }
+
+ @Override
+ public int compareTo(ExpiringEntry other) {
+ if (key.equals(other.key))
+ return 0;
+ return expectedExpiration.get() < other.expectedExpiration.get() ? -1 : 1;
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((key == null) ? 0 : key.hashCode());
+ result = prime * result + ((value == null) ? 0 : value.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (getClass() != obj.getClass())
+ return false;
+ ExpiringEntry other = (ExpiringEntry) obj;
+ if (!key.equals(other.key))
+ return false;
+ if (value == null) {
+ if (other.value != null)
+ return false;
+ } else if (!value.equals(other.value))
+ return false;
+ return true;
+ }
+
+ @Override
+ public String toString() {
+ return value.toString();
+ }
+
+ /**
+ * Marks the entry as canceled.
+ *
+ * @return true if the entry was scheduled
+ */
+ synchronized boolean cancel() {
+ boolean result = scheduled;
+ if (entryFuture != null)
+ entryFuture.cancel(false);
+
+ entryFuture = null;
+ scheduled = false;
+ return result;
+ }
+
+ /** Gets the entry value. */
+ synchronized V getValue() {
+ return value;
+ }
+
+ /** Resets the entry's expected expiration. */
+ void resetExpiration() {
+ expectedExpiration.set(expirationNanos.get() + System.nanoTime());
+ }
+
+ /** Marks the entry as scheduled. */
+ synchronized void schedule(Future entryFuture) {
+ this.entryFuture = entryFuture;
+ scheduled = true;
+ }
+
+ /** Sets the entry value. */
+ synchronized void setValue(V value) {
+ this.value = value;
+ }
+ }
+
+ /**
+ * Creates an ExpiringMap builder.
+ *
+ * @return New ExpiringMap builder
+ */
+ public static Builder builder() {
+ return new Builder();
+ }
+
+ /**
+ * Creates a new instance of ExpiringMap with ExpirationPolicy.CREATED and an expiration of 60 seconds.
+ */
+ @SuppressWarnings("unchecked")
+ public static ExpiringMap create() {
+ return new ExpiringMap((Builder) ExpiringMap.builder());
+ }
+
+ /**
+ * Adds an expiration listener.
+ *
+ * @param listener to add
+ * @throws NullPointerException if {@code listener} is null
+ */
+ public synchronized void addExpirationListener(ExpirationListener listener) {
+ Assert.notNull(listener, "listener");
+ if (expirationListeners == null)
+ expirationListeners = new CopyOnWriteArrayList>();
+ expirationListeners.add(listener);
+ }
+
+ /**
+ * Adds an asynchronous expiration listener.
+ *
+ * @param listener to add
+ * @throws NullPointerException if {@code listener} is null
+ */
+ public synchronized void addAsyncExpirationListener(ExpirationListener listener) {
+ Assert.notNull(listener, "listener");
+ if (asyncExpirationListeners == null)
+ asyncExpirationListeners = new CopyOnWriteArrayList>();
+ asyncExpirationListeners.add(listener);
+ }
+
+ @Override
+ public void clear() {
+ writeLock.lock();
+ try {
+ for (ExpiringEntry entry : entries.values())
+ entry.cancel();
+ entries.clear();
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ @Override
+ public boolean containsKey(Object key) {
+ readLock.lock();
+ try {
+ return entries.containsKey(key);
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public boolean containsValue(Object value) {
+ readLock.lock();
+ try {
+ return entries.containsValue(value);
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public Set> entrySet() {
+ return new AbstractSet>() {
+ @Override
+ public void clear() {
+ ExpiringMap.this.clear();
+ }
+
+ @Override
+ public boolean contains(Object entry) {
+ if (!(entry instanceof Map.Entry))
+ return false;
+ Map.Entry e = (Map.Entry) entry;
+ return containsKey(e.getKey());
+ }
+
+ @Override
+ public Iterator> iterator() {
+ return (entries instanceof EntryLinkedHashMap) ? ((EntryLinkedHashMap) entries).new EntryIterator()
+ : ((EntryTreeHashMap) entries).new EntryIterator();
+ }
+
+ @Override
+ public boolean remove(Object entry) {
+ if (entry instanceof Map.Entry) {
+ Map.Entry e = (Map.Entry) entry;
+ return ExpiringMap.this.remove(e.getKey()) != null;
+ }
+ return false;
+ }
+
+ @Override
+ public int size() {
+ return ExpiringMap.this.size();
+ }
+ };
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ readLock.lock();
+ try {
+ return entries.equals(obj);
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public V get(Object key) {
+ ExpiringEntry entry = getEntry(key);
+
+ if (entry == null) {
+ return load((K) key);
+ } else if (ExpirationPolicy.ACCESSED.equals(entry.expirationPolicy.get()))
+ resetEntry(entry, false);
+
+ return entry.getValue();
+ }
+
+ private V load(K key) {
+ if (entryLoader == null && expiringEntryLoader == null)
+ return null;
+
+ writeLock.lock();
+ try {
+ // Double check for entry
+ ExpiringEntry entry = getEntry(key);
+ if (entry != null)
+ return entry.getValue();
+
+ if (entryLoader != null) {
+ V value = entryLoader.load(key);
+ put(key, value);
+ return value;
+ } else {
+ ExpiringValue expiringValue = expiringEntryLoader.load(key);
+ if (expiringValue == null) {
+ put(key, null);
+ return null;
+ } else {
+ long duration = expiringValue.getTimeUnit() == null ? expirationNanos.get() : expiringValue.getDuration();
+ TimeUnit timeUnit = expiringValue.getTimeUnit() == null ? TimeUnit.NANOSECONDS : expiringValue.getTimeUnit();
+ put(key, expiringValue.getValue(), expiringValue.getExpirationPolicy() == null ? expirationPolicy.get()
+ : expiringValue.getExpirationPolicy(), duration, timeUnit);
+ return expiringValue.getValue();
+ }
+ }
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ /**
+ * Returns the map's default expiration duration in milliseconds.
+ *
+ * @return The expiration duration (milliseconds)
+ */
+ public long getExpiration() {
+ return TimeUnit.NANOSECONDS.toMillis(expirationNanos.get());
+ }
+
+ /**
+ * Gets the expiration duration in milliseconds for the entry corresponding to the given key.
+ *
+ * @param key
+ * @return The expiration duration in milliseconds
+ * @throws NullPointerException if {@code key} is null
+ * @throws NoSuchElementException If no entry exists for the given key
+ */
+ public long getExpiration(K key) {
+ Assert.notNull(key, "key");
+ ExpiringEntry entry = getEntry(key);
+ Assert.element(entry, key);
+ return TimeUnit.NANOSECONDS.toMillis(entry.expirationNanos.get());
+ }
+
+ /**
+ * Gets the ExpirationPolicy for the entry corresponding to the given {@code key}.
+ *
+ * @param key
+ * @return The ExpirationPolicy for the {@code key}
+ * @throws NullPointerException if {@code key} is null
+ * @throws NoSuchElementException If no entry exists for the given key
+ */
+ public ExpirationPolicy getExpirationPolicy(K key) {
+ Assert.notNull(key, "key");
+ ExpiringEntry entry = getEntry(key);
+ Assert.element(entry, key);
+ return entry.expirationPolicy.get();
+ }
+
+ /**
+ * Gets the expected expiration, in milliseconds from the current time, for the entry corresponding to the given
+ * {@code key}.
+ *
+ * @param key
+ * @return The expiration duration in milliseconds
+ * @throws NullPointerException if {@code key} is null
+ * @throws NoSuchElementException If no entry exists for the given key
+ */
+ public long getExpectedExpiration(K key) {
+ Assert.notNull(key, "key");
+ ExpiringEntry entry = getEntry(key);
+ Assert.element(entry, key);
+ return TimeUnit.NANOSECONDS.toMillis(entry.expectedExpiration.get() - System.nanoTime());
+ }
+
+ /**
+ * Gets the maximum size of the map. Once this size has been reached, adding an additional entry will expire the
+ * first entry in line for expiration based on the expiration policy.
+ *
+ * @return The maximum size of the map.
+ */
+ public int getMaxSize() {
+ return maxSize;
+ }
+
+ @Override
+ public int hashCode() {
+ readLock.lock();
+ try {
+ return entries.hashCode();
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public boolean isEmpty() {
+ readLock.lock();
+ try {
+ return entries.isEmpty();
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public Set keySet() {
+ return new AbstractSet() {
+ @Override
+ public void clear() {
+ ExpiringMap.this.clear();
+ }
+
+ @Override
+ public boolean contains(Object key) {
+ return containsKey(key);
+ }
+
+ @Override
+ public Iterator iterator() {
+ return (entries instanceof EntryLinkedHashMap) ? ((EntryLinkedHashMap) entries).new KeyIterator()
+ : ((EntryTreeHashMap) entries).new KeyIterator();
+ }
+
+ @Override
+ public boolean remove(Object value) {
+ return ExpiringMap.this.remove(value) != null;
+ }
+
+ @Override
+ public int size() {
+ return ExpiringMap.this.size();
+ }
+ };
+ }
+
+ /**
+ * Puts {@code value} in the map for {@code key}. Resets the entry's expiration unless an entry already exists for the
+ * same {@code key} and {@code value}.
+ *
+ * @param key to put value for
+ * @param value to put for key
+ * @return the old value
+ * @throws NullPointerException if {@code key} is null
+ */
+ @Override
+ public V put(K key, V value) {
+ Assert.notNull(key, "key");
+ return putInternal(key, value, expirationPolicy.get(), expirationNanos.get());
+ }
+
+ /**
+ * @see #put(Object, Object, ExpirationPolicy, long, TimeUnit)
+ */
+ public V put(K key, V value, ExpirationPolicy expirationPolicy) {
+ return put(key, value, expirationPolicy, expirationNanos.get(), TimeUnit.NANOSECONDS);
+ }
+
+ /**
+ * @see #put(Object, Object, ExpirationPolicy, long, TimeUnit)
+ */
+ public V put(K key, V value, long duration, TimeUnit timeUnit) {
+ return put(key, value, expirationPolicy.get(), duration, timeUnit);
+ }
+
+ /**
+ * Puts {@code value} in the map for {@code key}. Resets the entry's expiration unless an entry already exists for the
+ * same {@code key} and {@code value}. Requires that variable expiration be enabled.
+ *
+ * @param key Key to put value for
+ * @param value Value to put for key
+ * @param duration the length of time after an entry is created that it should be removed
+ * @param timeUnit the unit that {@code duration} is expressed in
+ * @return the old value
+ * @throws UnsupportedOperationException If variable expiration is not enabled
+ * @throws NullPointerException if {@code key}, {@code expirationPolicy} or {@code timeUnit} are null
+ */
+ public V put(K key, V value, ExpirationPolicy expirationPolicy, long duration, TimeUnit timeUnit) {
+ Assert.notNull(key, "key");
+ Assert.notNull(expirationPolicy, "expirationPolicy");
+ Assert.notNull(timeUnit, "timeUnit");
+ Assert.operation(variableExpiration, "Variable expiration is not enabled");
+ return putInternal(key, value, expirationPolicy, TimeUnit.NANOSECONDS.convert(duration, timeUnit));
+ }
+
+ @Override
+ public void putAll(Map map) {
+ Assert.notNull(map, "map");
+ long expiration = expirationNanos.get();
+ ExpirationPolicy expirationPolicy = this.expirationPolicy.get();
+ writeLock.lock();
+ try {
+ for (Map.Entry entry : map.entrySet())
+ putInternal(entry.getKey(), entry.getValue(), expirationPolicy, expiration);
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ @Override
+ public V putIfAbsent(K key, V value) {
+ Assert.notNull(key, "key");
+ writeLock.lock();
+ try {
+ if (!entries.containsKey(key))
+ return putInternal(key, value, expirationPolicy.get(), expirationNanos.get());
+ else
+ return entries.get(key).getValue();
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ @Override
+ public V remove(Object key) {
+ Assert.notNull(key, "key");
+ writeLock.lock();
+ try {
+ ExpiringEntry entry = entries.remove(key);
+ if (entry == null)
+ return null;
+ if (entry.cancel())
+ scheduleEntry(entries.first());
+ return entry.getValue();
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ @Override
+ public boolean remove(Object key, Object value) {
+ Assert.notNull(key, "key");
+ writeLock.lock();
+ try {
+ ExpiringEntry entry = entries.get(key);
+ if (entry != null && entry.getValue().equals(value)) {
+ entries.remove(key);
+ if (entry.cancel())
+ scheduleEntry(entries.first());
+ return true;
+ } else
+ return false;
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ @Override
+ public V replace(K key, V value) {
+ Assert.notNull(key, "key");
+ writeLock.lock();
+ try {
+ if (entries.containsKey(key)) {
+ return putInternal(key, value, expirationPolicy.get(), expirationNanos.get());
+ } else
+ return null;
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ @Override
+ public boolean replace(K key, V oldValue, V newValue) {
+ Assert.notNull(key, "key");
+ writeLock.lock();
+ try {
+ ExpiringEntry entry = entries.get(key);
+ if (entry != null && entry.getValue().equals(oldValue)) {
+ putInternal(key, newValue, expirationPolicy.get(), expirationNanos.get());
+ return true;
+ } else
+ return false;
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ /**
+ * Removes an expiration listener.
+ *
+ * @param listener
+ * @throws NullPointerException if {@code listener} is null
+ */
+ public void removeExpirationListener(ExpirationListener listener) {
+ Assert.notNull(listener, "listener");
+ for (int i = 0; i < expirationListeners.size(); i++) {
+ if (expirationListeners.get(i).equals(listener)) {
+ expirationListeners.remove(i);
+ return;
+ }
+ }
+ }
+
+ /**
+ * Removes an asynchronous expiration listener.
+ *
+ * @param listener
+ * @throws NullPointerException if {@code listener} is null
+ */
+ public void removeAsyncExpirationListener(ExpirationListener listener) {
+ Assert.notNull(listener, "listener");
+ for (int i = 0; i < asyncExpirationListeners.size(); i++) {
+ if (asyncExpirationListeners.get(i).equals(listener)) {
+ asyncExpirationListeners.remove(i);
+ return;
+ }
+ }
+ }
+
+ /**
+ * Resets expiration for the entry corresponding to {@code key}.
+ *
+ * @param key to reset expiration for
+ * @throws NullPointerException if {@code key} is null
+ */
+ public void resetExpiration(K key) {
+ Assert.notNull(key, "key");
+ ExpiringEntry entry = getEntry(key);
+ if (entry != null)
+ resetEntry(entry, false);
+ }
+
+ /**
+ * Sets the expiration duration for the entry corresponding to the given key. Supported only if variable expiration is
+ * enabled.
+ *
+ * @param key Key to set expiration for
+ * @param duration the length of time after an entry is created that it should be removed
+ * @param timeUnit the unit that {@code duration} is expressed in
+ * @throws NullPointerException if {@code key} or {@code timeUnit} are null
+ * @throws UnsupportedOperationException If variable expiration is not enabled
+ */
+ public void setExpiration(K key, long duration, TimeUnit timeUnit) {
+ Assert.notNull(key, "key");
+ Assert.notNull(timeUnit, "timeUnit");
+ Assert.operation(variableExpiration, "Variable expiration is not enabled");
+ writeLock.lock();
+ try {
+ ExpiringEntry entry = entries.get(key);
+ if (entry != null) {
+ entry.expirationNanos.set(TimeUnit.NANOSECONDS.convert(duration, timeUnit));
+ resetEntry(entry, true);
+ }
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ /**
+ * Updates the default map entry expiration. Supported only if variable expiration is enabled.
+ *
+ * @param duration the length of time after an entry is created that it should be removed
+ * @param timeUnit the unit that {@code duration} is expressed in
+ * @throws NullPointerException {@code timeUnit} is null
+ * @throws UnsupportedOperationException If variable expiration is not enabled
+ */
+ public void setExpiration(long duration, TimeUnit timeUnit) {
+ Assert.notNull(timeUnit, "timeUnit");
+ Assert.operation(variableExpiration, "Variable expiration is not enabled");
+ expirationNanos.set(TimeUnit.NANOSECONDS.convert(duration, timeUnit));
+ }
+
+ /**
+ * Sets the global expiration policy for the map. Individual expiration policies may override the global policy.
+ *
+ * @param expirationPolicy
+ * @throws NullPointerException {@code expirationPolicy} is null
+ */
+ public void setExpirationPolicy(ExpirationPolicy expirationPolicy) {
+ Assert.notNull(expirationPolicy, "expirationPolicy");
+ this.expirationPolicy.set(expirationPolicy);
+ }
+
+ /**
+ * Sets the expiration policy for the entry corresponding to the given key.
+ *
+ * @param key to set policy for
+ * @param expirationPolicy to set
+ * @throws NullPointerException if {@code key} or {@code expirationPolicy} are null
+ * @throws UnsupportedOperationException If variable expiration is not enabled
+ */
+ public void setExpirationPolicy(K key, ExpirationPolicy expirationPolicy) {
+ Assert.notNull(key, "key");
+ Assert.notNull(expirationPolicy, "expirationPolicy");
+ Assert.operation(variableExpiration, "Variable expiration is not enabled");
+ ExpiringEntry entry = getEntry(key);
+ if (entry != null)
+ entry.expirationPolicy.set(expirationPolicy);
+ }
+
+ /**
+ * Sets the maximum size of the map. Once this size has been reached, adding an additional entry will expire the
+ * first entry in line for expiration based on the expiration policy.
+ *
+ * @param maxSize The maximum size of the map.
+ */
+ public void setMaxSize(int maxSize) {
+ Assert.operation(maxSize > 0, "maxSize");
+ this.maxSize = maxSize;
+ }
+
+ @Override
+ public int size() {
+ readLock.lock();
+ try {
+ return entries.size();
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public String toString() {
+ readLock.lock();
+ try {
+ return entries.toString();
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ @Override
+ public Collection values() {
+ return new AbstractCollection() {
+ @Override
+ public void clear() {
+ ExpiringMap.this.clear();
+ }
+
+ @Override
+ public boolean contains(Object value) {
+ return containsValue(value);
+ }
+
+ @Override
+ public Iterator iterator() {
+ return (entries instanceof EntryLinkedHashMap) ? ((EntryLinkedHashMap) entries).new ValueIterator()
+ : ((EntryTreeHashMap) entries).new ValueIterator();
+ }
+
+ @Override
+ public int size() {
+ return ExpiringMap.this.size();
+ }
+ };
+ }
+
+ /**
+ * Notifies expiration listeners that the given entry expired. Must not be called from within a locked context.
+ *
+ * @param entry Entry to expire
+ */
+ void notifyListeners(final ExpiringEntry entry) {
+ if (asyncExpirationListeners != null)
+ for (final ExpirationListener listener : asyncExpirationListeners) {
+ LISTENER_SERVICE.execute(new Runnable() {
+ public void run() {
+ try {
+ listener.expired(entry.key, entry.getValue());
+ } catch (Exception ignoreUserExceptions) {
+ }
+ }
+ });
+ }
+
+ if (expirationListeners != null)
+ for (final ExpirationListener listener : expirationListeners) {
+ try {
+ listener.expired(entry.key, entry.getValue());
+ } catch (Exception ignoreUserExceptions) {
+ }
+ }
+ }
+
+ /**
+ * Returns the internal ExpiringEntry for the {@code key}, obtaining a read lock.
+ */
+ ExpiringEntry getEntry(Object key) {
+ readLock.lock();
+ try {
+ return entries.get(key);
+ } finally {
+ readLock.unlock();
+ }
+ }
+
+ /**
+ * Puts the given key/value in storage, scheduling the new entry for expiration if needed. If a previous value existed
+ * for the given key, it is first cancelled and the entries reordered to reflect the new expiration.
+ */
+ V putInternal(K key, V value, ExpirationPolicy expirationPolicy, long expirationNanos) {
+ writeLock.lock();
+ try {
+ ExpiringEntry entry = entries.get(key);
+ V oldValue = null;
+
+ if (entry == null) {
+ entry = new ExpiringEntry(key, value,
+ variableExpiration ? new AtomicReference(expirationPolicy) : this.expirationPolicy,
+ variableExpiration ? new AtomicLong(expirationNanos) : this.expirationNanos);
+ if (entries.size() >= maxSize) {
+ ExpiringEntry expiredEntry = entries.first();
+ entries.remove(expiredEntry.key);
+ notifyListeners(expiredEntry);
+ }
+ entries.put(key, entry);
+ if (entries.size() == 1 || entries.first().equals(entry))
+ scheduleEntry(entry);
+ } else {
+ oldValue = entry.getValue();
+ if (!ExpirationPolicy.ACCESSED.equals(expirationPolicy)
+ && ((oldValue == null && value == null) || (oldValue != null && oldValue.equals(value))))
+ return value;
+
+ entry.setValue(value);
+ resetEntry(entry, false);
+ }
+
+ return oldValue;
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ /**
+ * Resets the given entry's schedule canceling any existing scheduled expiration and reordering the entry in the
+ * internal map. Schedules the next entry in the map if the given {@code entry} was scheduled or if
+ * {@code scheduleNext} is true.
+ *
+ * @param entry to reset
+ * @param scheduleFirstEntry whether the first entry should be automatically scheduled
+ */
+ void resetEntry(ExpiringEntry entry, boolean scheduleFirstEntry) {
+ writeLock.lock();
+ try {
+ boolean scheduled = entry.cancel();
+ entries.reorder(entry);
+
+ if (scheduled || scheduleFirstEntry)
+ scheduleEntry(entries.first());
+ } finally {
+ writeLock.unlock();
+ }
+ }
+
+ /**
+ * Schedules an entry for expiration. Guards against concurrent schedule/schedule, cancel/schedule and schedule/cancel
+ * calls.
+ *
+ * @param entry Entry to schedule
+ */
+ void scheduleEntry(ExpiringEntry entry) {
+ if (entry == null || entry.scheduled)
+ return;
+
+ Runnable runnable = null;
+ synchronized (entry) {
+ if (entry.scheduled)
+ return;
+
+ final WeakReference> entryReference = new WeakReference>(entry);
+ runnable = new Runnable() {
+ @Override
+ public void run() {
+ ExpiringEntry entry = entryReference.get();
+
+ writeLock.lock();
+ try {
+ if (entry != null && entry.scheduled) {
+ entries.remove(entry.key);
+ notifyListeners(entry);
+ }
+
+ try {
+ // Expires entries and schedules the next entry
+ Iterator> iterator = entries.valuesIterator();
+ boolean schedulePending = true;
+
+ while (iterator.hasNext() && schedulePending) {
+ ExpiringEntry nextEntry = iterator.next();
+ if (nextEntry.expectedExpiration.get() <= System.nanoTime()) {
+ iterator.remove();
+ notifyListeners(nextEntry);
+ } else {
+ scheduleEntry(nextEntry);
+ schedulePending = false;
+ }
+ }
+ } catch (NoSuchElementException ignored) {
+ }
+ } finally {
+ writeLock.unlock();
+ }
+ }
+ };
+
+ Future entryFuture = EXPIRER.schedule(runnable, entry.expectedExpiration.get() - System.nanoTime(),
+ TimeUnit.NANOSECONDS);
+ entry.schedule(entryFuture);
+ }
+ }
+
+ private static Map.Entry mapEntryFor(final ExpiringEntry entry) {
+ return new Map.Entry() {
+ @Override
+ public K getKey() {
+ return entry.key;
+ }
+
+ @Override
+ public V getValue() {
+ return entry.value;
+ }
+
+ @Override
+ public V setValue(V value) {
+ throw new UnsupportedOperationException();
+ }
+ };
+ }
+}
diff --git a/src/net/jodah/expiringmap/ExpiringValue.java b/src/net/jodah/expiringmap/ExpiringValue.java
new file mode 100644
index 0000000..9b68fee
--- /dev/null
+++ b/src/net/jodah/expiringmap/ExpiringValue.java
@@ -0,0 +1,122 @@
+package net.jodah.expiringmap;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A value which should be stored in an {@link ExpiringMap} with optional control over its expiration.
+ *
+ * @param the type of value being stored
+ */
+public final class ExpiringValue {
+ private static final long UNSET_DURATION = -1L;
+ private final V value;
+ private final ExpirationPolicy expirationPolicy;
+ private final long duration;
+ private final TimeUnit timeUnit;
+
+ /**
+ * Creates an ExpiringValue to be stored in an {@link ExpiringMap}. The map's default values for
+ * {@link ExpirationPolicy expiration policy} and {@link ExpiringMap#getExpiration()} expiration} will be used.
+ *
+ * @param value the value to store
+ * @see ExpiringMap#put(Object, Object)
+ */
+ public ExpiringValue(V value) {
+ this(value, UNSET_DURATION, null, null);
+ }
+
+ /**
+ * Creates an ExpiringValue to be stored in an {@link ExpiringMap}. The map's default
+ * {@link ExpiringMap#getExpiration()} expiration} will be used.
+ *
+ * @param value the value to store
+ * @param expirationPolicy the expiration policy for the value
+ * @see ExpiringMap#put(Object, Object, ExpirationPolicy)
+ */
+ public ExpiringValue(V value, ExpirationPolicy expirationPolicy) {
+ this(value, UNSET_DURATION, null, expirationPolicy);
+ }
+
+ /**
+ * Creates an ExpiringValue to be stored in an {@link ExpiringMap}. The map's default {@link ExpirationPolicy
+ * expiration policy} will be used.
+ *
+ * @param value the value to store
+ * @param duration the length of time after an entry is created that it should be removed
+ * @param timeUnit the unit that {@code duration} is expressed in
+ * @see ExpiringMap#put(Object, Object, long, TimeUnit)
+ * @throws NullPointerException on null timeUnit
+ */
+ public ExpiringValue(V value, long duration, TimeUnit timeUnit) {
+ this(value, duration, timeUnit, null);
+ if (timeUnit == null) {
+ throw new NullPointerException();
+ }
+ }
+
+ /**
+ * Creates an ExpiringValue to be stored in an {@link ExpiringMap}.
+ *
+ * @param value the value to store
+ * @param duration the length of time after an entry is created that it should be removed
+ * @param timeUnit the unit that {@code duration} is expressed in
+ * @param expirationPolicy the expiration policy for the value
+ * @see ExpiringMap#put(Object, Object, ExpirationPolicy, long, TimeUnit)
+ * @throws NullPointerException on null timeUnit
+ */
+ public ExpiringValue(V value, ExpirationPolicy expirationPolicy, long duration, TimeUnit timeUnit) {
+ this(value, duration, timeUnit, expirationPolicy);
+ if (timeUnit == null) {
+ throw new NullPointerException();
+ }
+ }
+
+ private ExpiringValue(V value, long duration, TimeUnit timeUnit, ExpirationPolicy expirationPolicy) {
+ this.value = value;
+ this.expirationPolicy = expirationPolicy;
+ this.duration = duration;
+ this.timeUnit = timeUnit;
+ }
+
+ public V getValue() {
+ return value;
+ }
+
+ public ExpirationPolicy getExpirationPolicy() {
+ return expirationPolicy;
+ }
+
+ public long getDuration() {
+ return duration;
+ }
+
+ public TimeUnit getTimeUnit() {
+ return timeUnit;
+ }
+
+ @Override
+ public int hashCode() {
+ return value != null ? value.hashCode() : 0;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+
+ ExpiringValue that = (ExpiringValue) o;
+ return !(value != null ? !value.equals(that.value) : that.value != null)
+ && expirationPolicy == that.expirationPolicy && duration == that.duration && timeUnit == that.timeUnit;
+
+ }
+
+ @Override
+ public String toString() {
+ return "ExpiringValue{" + "value=" + value + ", expirationPolicy=" + expirationPolicy + ", duration=" + duration
+ + ", timeUnit=" + timeUnit + '}';
+ }
+}
diff --git a/src/net/jodah/expiringmap/internal/Assert.java b/src/net/jodah/expiringmap/internal/Assert.java
new file mode 100644
index 0000000..7c1b1fc
--- /dev/null
+++ b/src/net/jodah/expiringmap/internal/Assert.java
@@ -0,0 +1,32 @@
+package net.jodah.expiringmap.internal;
+
+import java.util.NoSuchElementException;
+
+/**
+ * @author Jonathan Halterman
+ */
+public final class Assert {
+ private Assert() {
+ }
+
+ public static T notNull(T reference, String parameterName) {
+ if (reference == null)
+ throw new NullPointerException(parameterName + " cannot be null");
+ return reference;
+ }
+
+ public static void operation(boolean condition, String message) {
+ if (!condition)
+ throw new UnsupportedOperationException(message);
+ }
+
+ public static void state(boolean expression, String errorMessageFormat, Object... args) {
+ if (!expression)
+ throw new IllegalStateException(String.format(errorMessageFormat, args));
+ }
+
+ public static void element(Object element, Object key) {
+ if (element == null)
+ throw new NoSuchElementException(key.toString());
+ }
+}
\ No newline at end of file
diff --git a/src/net/jodah/expiringmap/internal/NamedThreadFactory.java b/src/net/jodah/expiringmap/internal/NamedThreadFactory.java
new file mode 100644
index 0000000..d266ba7
--- /dev/null
+++ b/src/net/jodah/expiringmap/internal/NamedThreadFactory.java
@@ -0,0 +1,27 @@
+package net.jodah.expiringmap.internal;
+
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * Named thread factory.
+ */
+public class NamedThreadFactory implements ThreadFactory {
+ private final AtomicInteger threadNumber = new AtomicInteger(1);
+ private final String nameFormat;
+
+ /**
+ * Creates a thread factory that names threads according to the {@code nameFormat} by supplying a
+ * single argument to the format representing the thread number.
+ */
+ public NamedThreadFactory(String nameFormat) {
+ this.nameFormat = nameFormat;
+ }
+
+ @Override
+ public Thread newThread(Runnable r) {
+ Thread thread = new Thread(r, String.format(nameFormat, threadNumber.getAndIncrement()));
+ thread.setDaemon(true);
+ return thread;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/HardcoreFactionsPlugin.java b/src/notifyz/hardcorefactions/HardcoreFactionsPlugin.java
new file mode 100644
index 0000000..4b9e70b
--- /dev/null
+++ b/src/notifyz/hardcorefactions/HardcoreFactionsPlugin.java
@@ -0,0 +1,1147 @@
+package notifyz.hardcorefactions;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ShapelessRecipe;
+import org.bukkit.material.MaterialData;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.RegisteredServiceProvider;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.sk89q.worldedit.CuboidClipboard;
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.MaxChangedBlocksException;
+import com.sk89q.worldedit.bukkit.BukkitUtil;
+import com.sk89q.worldedit.bukkit.BukkitWorld;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.world.DataException;
+
+import lombok.Getter;
+import lombok.Setter;
+import net.milkbowl.vault.chat.Chat;
+import net.milkbowl.vault.permission.Permission;
+import net.minecraft.util.com.google.common.base.Joiner;
+import net.minecraft.util.org.apache.commons.lang3.time.DurationFormatUtils;
+import notifyz.hardcorefactions.chests.Teller;
+import notifyz.hardcorefactions.chests.VirtualChestManager;
+import notifyz.hardcorefactions.chests.commands.ChestCommand;
+import notifyz.hardcorefactions.chests.commands.ClearChestCommand;
+import notifyz.hardcorefactions.chests.commands.DisposalCommand;
+import notifyz.hardcorefactions.chests.commands.SaveChestsCommand;
+import notifyz.hardcorefactions.chests.commands.WorkbenchCommand;
+import notifyz.hardcorefactions.chests.listeners.PlayerListener;
+import notifyz.hardcorefactions.classes.manager.PvPClassManager;
+import notifyz.hardcorefactions.classes.type.bard.utilties.EffectRestorer;
+import notifyz.hardcorefactions.combatloggers.CombatLogListener;
+import notifyz.hardcorefactions.combatloggers.CustomEntityRegistration;
+import notifyz.hardcorefactions.commands.essentials.BackCommand;
+import notifyz.hardcorefactions.commands.essentials.BroadcastCommand;
+import notifyz.hardcorefactions.commands.essentials.DisableChatCommand;
+import notifyz.hardcorefactions.commands.essentials.EnchantCommand;
+import notifyz.hardcorefactions.commands.essentials.FeedCommand;
+import notifyz.hardcorefactions.commands.essentials.FlyCommand;
+import notifyz.hardcorefactions.commands.essentials.FreezeAllCommand;
+import notifyz.hardcorefactions.commands.essentials.FreezeCommand;
+import notifyz.hardcorefactions.commands.essentials.GamemodeCommand;
+import notifyz.hardcorefactions.commands.essentials.GiveCommand;
+import notifyz.hardcorefactions.commands.essentials.GiveawayCommand;
+import notifyz.hardcorefactions.commands.essentials.GodCommand;
+import notifyz.hardcorefactions.commands.essentials.GuiFreezeCommand;
+import notifyz.hardcorefactions.commands.essentials.HatCommand;
+import notifyz.hardcorefactions.commands.essentials.HealCommand;
+import notifyz.hardcorefactions.commands.essentials.HideStaffCommand;
+import notifyz.hardcorefactions.commands.essentials.IgnoreCommand;
+import notifyz.hardcorefactions.commands.essentials.InvseeCommand;
+import notifyz.hardcorefactions.commands.essentials.InvseeOfflineCommand;
+import notifyz.hardcorefactions.commands.essentials.KillCommand;
+import notifyz.hardcorefactions.commands.essentials.LagCommand;
+import notifyz.hardcorefactions.commands.essentials.ListCommand;
+import notifyz.hardcorefactions.commands.essentials.MessageCommand;
+import notifyz.hardcorefactions.commands.essentials.MessageSpyCommand;
+import notifyz.hardcorefactions.commands.essentials.MoreItemsCommand;
+import notifyz.hardcorefactions.commands.essentials.NewVideoCommand;
+import notifyz.hardcorefactions.commands.essentials.RecCommand;
+import notifyz.hardcorefactions.commands.essentials.RemovePermCommand;
+import notifyz.hardcorefactions.commands.essentials.RenameCommand;
+import notifyz.hardcorefactions.commands.essentials.ReplyCommand;
+import notifyz.hardcorefactions.commands.essentials.ServerTimeCommand;
+import notifyz.hardcorefactions.commands.essentials.SetBorderCommand;
+import notifyz.hardcorefactions.commands.essentials.SettingsCommand;
+import notifyz.hardcorefactions.commands.essentials.SlowchatCommand;
+import notifyz.hardcorefactions.commands.essentials.SpawnCommand;
+import notifyz.hardcorefactions.commands.essentials.SpawnerCommand;
+import notifyz.hardcorefactions.commands.essentials.SpeedCommand;
+import notifyz.hardcorefactions.commands.essentials.StaffChatCommand;
+import notifyz.hardcorefactions.commands.essentials.StatsCommand;
+import notifyz.hardcorefactions.commands.essentials.TeleportCommand;
+import notifyz.hardcorefactions.commands.essentials.ToggleChatCommand;
+import notifyz.hardcorefactions.commands.essentials.ToggleMessagesCommand;
+import notifyz.hardcorefactions.commands.essentials.ToggleSoundsCommand;
+import notifyz.hardcorefactions.commands.essentials.TopCommand;
+import notifyz.hardcorefactions.commands.essentials.UptimeCommand;
+import notifyz.hardcorefactions.commands.essentials.VanishCommand;
+import notifyz.hardcorefactions.commands.essentials.WorldCommand;
+import notifyz.hardcorefactions.commands.hcf.BardEnergyCommand;
+import notifyz.hardcorefactions.commands.hcf.CobbleCommand;
+import notifyz.hardcorefactions.commands.hcf.CrowbarCommand;
+import notifyz.hardcorefactions.commands.hcf.EOTWCommand;
+import notifyz.hardcorefactions.commands.hcf.EOTWReviveCommand;
+import notifyz.hardcorefactions.commands.hcf.EconomyCommand;
+import notifyz.hardcorefactions.commands.hcf.EndPortalCommand;
+import notifyz.hardcorefactions.commands.hcf.FFACommand;
+import notifyz.hardcorefactions.commands.hcf.FocusCommand;
+import notifyz.hardcorefactions.commands.hcf.InfoCommand;
+import notifyz.hardcorefactions.commands.hcf.KitMapGUICommand;
+import notifyz.hardcorefactions.commands.hcf.LFFCommand;
+import notifyz.hardcorefactions.commands.hcf.LocationCommand;
+import notifyz.hardcorefactions.commands.hcf.LogoutCommand;
+import notifyz.hardcorefactions.commands.hcf.MapKitCommand;
+import notifyz.hardcorefactions.commands.hcf.MobDropsCommand;
+import notifyz.hardcorefactions.commands.hcf.PanicCommand;
+import notifyz.hardcorefactions.commands.hcf.PayCommand;
+import notifyz.hardcorefactions.commands.hcf.PlayTimeCommand;
+import notifyz.hardcorefactions.commands.hcf.PvPTimerCommand;
+import notifyz.hardcorefactions.commands.hcf.RebootCommand;
+import notifyz.hardcorefactions.commands.hcf.ReclaimCommand;
+import notifyz.hardcorefactions.commands.hcf.ReclaimResetCommand;
+import notifyz.hardcorefactions.commands.hcf.RegenCommand;
+import notifyz.hardcorefactions.commands.hcf.RestoreInventoryCommand;
+import notifyz.hardcorefactions.commands.hcf.SOTWCommand;
+import notifyz.hardcorefactions.commands.hcf.SaleCommand;
+import notifyz.hardcorefactions.commands.hcf.SetCommand;
+import notifyz.hardcorefactions.commands.hcf.SpawnCannonCommand;
+import notifyz.hardcorefactions.commands.hcf.StaffModeCommand;
+import notifyz.hardcorefactions.commands.hcf.StaffReviveCommand;
+import notifyz.hardcorefactions.commands.hcf.TeamCoordinatesCommand;
+import notifyz.hardcorefactions.commands.hcf.ToggleCapzoneEntryCommand;
+import notifyz.hardcorefactions.commands.hcf.ToggleDiamondAlertsCommand;
+import notifyz.hardcorefactions.commands.hcf.ToggleLightningCommand;
+import notifyz.hardcorefactions.commands.hcf.ToggleSidebarCommand;
+import notifyz.hardcorefactions.commands.help.CoordinatesCommand;
+import notifyz.hardcorefactions.commands.help.FamousCommand;
+import notifyz.hardcorefactions.commands.help.HelpCommand;
+import notifyz.hardcorefactions.commands.help.ReportCommand;
+import notifyz.hardcorefactions.commands.help.RequestCommand;
+import notifyz.hardcorefactions.commands.help.StoreCommand;
+import notifyz.hardcorefactions.commands.help.TeamSpeakCommand;
+import notifyz.hardcorefactions.commands.help.WebsiteCommand;
+import notifyz.hardcorefactions.commands.help.YoutubeCommand;
+import notifyz.hardcorefactions.commands.revive.Revive1;
+import notifyz.hardcorefactions.commands.revive.Revive2;
+import notifyz.hardcorefactions.commands.revive.ReviveHandler;
+import notifyz.hardcorefactions.commands.warp.WarpExecutor;
+import notifyz.hardcorefactions.commands.warp.utilities.FlatFileWarpManager;
+import notifyz.hardcorefactions.commands.warp.utilities.Warp;
+import notifyz.hardcorefactions.commands.warp.utilities.WarpManager;
+import notifyz.hardcorefactions.deathban.Deathban;
+import notifyz.hardcorefactions.deathban.lives.LivesExecutor;
+import notifyz.hardcorefactions.deathban.managers.DeathbanFile;
+import notifyz.hardcorefactions.deathban.managers.DeathbanManager;
+import notifyz.hardcorefactions.economy.Economy;
+import notifyz.hardcorefactions.economy.manager.EconomyFile;
+import notifyz.hardcorefactions.games.EventExecutor;
+import notifyz.hardcorefactions.games.conquest.ConquestExecutor;
+import notifyz.hardcorefactions.games.endevent.EndEventCommand;
+import notifyz.hardcorefactions.games.endevent.EndEventHandler;
+import notifyz.hardcorefactions.games.eotw.EOTWHandler;
+import notifyz.hardcorefactions.games.fury.FuryExecutor;
+import notifyz.hardcorefactions.games.key.KeyListener;
+import notifyz.hardcorefactions.games.key.KeyManager;
+import notifyz.hardcorefactions.games.key.LootExecutor;
+import notifyz.hardcorefactions.games.key.RewardableItemStack;
+import notifyz.hardcorefactions.games.koth.KothExecutor;
+import notifyz.hardcorefactions.games.mountain.GlowstoneMountainCommand;
+import notifyz.hardcorefactions.games.skygear.SkyGearCommand;
+import notifyz.hardcorefactions.games.skygear.listeners.SkyGearListener;
+import notifyz.hardcorefactions.games.sotw.SOTWHandler;
+import notifyz.hardcorefactions.games.utilities.capturezone.CaptureZone;
+import notifyz.hardcorefactions.games.utilities.scheduler.EventScheduler2;
+import notifyz.hardcorefactions.games.utilities.scheduler.IEventScheduler;
+import notifyz.hardcorefactions.kit.FlatFileKitManager;
+import notifyz.hardcorefactions.kit.Kit;
+import notifyz.hardcorefactions.kit.KitExecutor;
+import notifyz.hardcorefactions.kit.KitListener;
+import notifyz.hardcorefactions.kit.KitManager;
+import notifyz.hardcorefactions.listeners.CoreListener;
+import notifyz.hardcorefactions.listeners.claim.ClaimWandListener;
+import notifyz.hardcorefactions.listeners.claim.SubclaimWandListener;
+import notifyz.hardcorefactions.listeners.essentials.AutoMuteListener;
+import notifyz.hardcorefactions.listeners.essentials.BreedListener;
+import notifyz.hardcorefactions.listeners.essentials.ChatListener;
+import notifyz.hardcorefactions.listeners.essentials.FreezeAllListener;
+import notifyz.hardcorefactions.listeners.essentials.FreezeListener;
+import notifyz.hardcorefactions.listeners.essentials.FurnaceSmeltSpeederListener;
+import notifyz.hardcorefactions.listeners.essentials.PlayTimeListener;
+import notifyz.hardcorefactions.listeners.essentials.RestoreInventoryListener;
+import notifyz.hardcorefactions.listeners.essentials.SkullListener;
+import notifyz.hardcorefactions.listeners.essentials.StaffChatListener;
+import notifyz.hardcorefactions.listeners.essentials.WhitelistMessageListener;
+import notifyz.hardcorefactions.listeners.hcf.AnvilSpamListener;
+import notifyz.hardcorefactions.listeners.hcf.BedBombingListener;
+import notifyz.hardcorefactions.listeners.hcf.BookDeenchantListener;
+import notifyz.hardcorefactions.listeners.hcf.BorderListener;
+import notifyz.hardcorefactions.listeners.hcf.BottledExpListener;
+import notifyz.hardcorefactions.listeners.hcf.CobwebListener;
+import notifyz.hardcorefactions.listeners.hcf.ColorSignListener;
+import notifyz.hardcorefactions.listeners.hcf.CrowbarListener;
+import notifyz.hardcorefactions.listeners.hcf.DeathListener;
+import notifyz.hardcorefactions.listeners.hcf.DeathMessageListener;
+import notifyz.hardcorefactions.listeners.hcf.DeathSignListener;
+import notifyz.hardcorefactions.listeners.hcf.DeathbanListener;
+import notifyz.hardcorefactions.listeners.hcf.EOTWListener;
+import notifyz.hardcorefactions.listeners.hcf.ElevatorListener;
+import notifyz.hardcorefactions.listeners.hcf.EnchantLimitListener;
+import notifyz.hardcorefactions.listeners.hcf.EntityLimitListener;
+import notifyz.hardcorefactions.listeners.hcf.EventSignListener;
+import notifyz.hardcorefactions.listeners.hcf.ExpMultiplierListener;
+import notifyz.hardcorefactions.listeners.hcf.FoundDiamondListener;
+import notifyz.hardcorefactions.listeners.hcf.ItemStatTrackingListener;
+import notifyz.hardcorefactions.listeners.hcf.KillStreaks;
+import notifyz.hardcorefactions.listeners.hcf.KillstreakListener;
+import notifyz.hardcorefactions.listeners.hcf.KitMapKitsListener;
+import notifyz.hardcorefactions.listeners.hcf.KitMapListener;
+import notifyz.hardcorefactions.listeners.hcf.MinecartElevatorListener;
+import notifyz.hardcorefactions.listeners.hcf.PickaxeStatsListener;
+import notifyz.hardcorefactions.listeners.hcf.PortalListener;
+import notifyz.hardcorefactions.listeners.hcf.PotionLimitListener;
+import notifyz.hardcorefactions.listeners.hcf.ProtectionListener;
+import notifyz.hardcorefactions.listeners.hcf.SOTWListener;
+import notifyz.hardcorefactions.listeners.hcf.ShopListener;
+import notifyz.hardcorefactions.listeners.hcf.StaffModeListener;
+import notifyz.hardcorefactions.listeners.hcf.Strength2Listener;
+import notifyz.hardcorefactions.listeners.hcf.StrengthListener;
+import notifyz.hardcorefactions.listeners.hcf.SubclaimListener;
+import notifyz.hardcorefactions.listeners.hcf.TeamListener;
+import notifyz.hardcorefactions.listeners.hcf.ThrowableCobwebsListener;
+import notifyz.hardcorefactions.listeners.hcf.WorldListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.ArmorFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.BeaconStrengthFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.BlockHitFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.BoatGlitchFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.CrashFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.DuplicationGlitchListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.EnderChestRemovalListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.HungerFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.InfinityArrowFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.MobFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.PearlGlitchListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.SplashPotionListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.SugarCaneFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.VoidGlitchFixListener;
+import notifyz.hardcorefactions.listeners.hcf.fixes.WeatherFixListener;
+import notifyz.hardcorefactions.scoreboard.provider.PvPClassHolder;
+import notifyz.hardcorefactions.scoreboard.timer.TimerExecutor;
+import notifyz.hardcorefactions.scoreboard.timer.TimerManager;
+import notifyz.hardcorefactions.scoreboard.timer.utilities.type.ClassWarmupTimer;
+import notifyz.hardcorefactions.scoreboard.utilities.ScoreboardHandler;
+import notifyz.hardcorefactions.scoreboard.utilities.SidebarFiller;
+import notifyz.hardcorefactions.team.TeamManager;
+import notifyz.hardcorefactions.team.claim.Claim;
+import notifyz.hardcorefactions.team.claim.subclaim.Subclaim;
+import notifyz.hardcorefactions.team.claim.team.ClaimManager;
+import notifyz.hardcorefactions.team.commands.TeamExecutor;
+import notifyz.hardcorefactions.team.type.ClaimableTeam;
+import notifyz.hardcorefactions.team.type.PlayerTeam;
+import notifyz.hardcorefactions.team.type.system.CapturableFaction;
+import notifyz.hardcorefactions.team.type.system.ConquestFaction;
+import notifyz.hardcorefactions.team.type.system.EndPortalFaction;
+import notifyz.hardcorefactions.team.type.system.FuryFaction;
+import notifyz.hardcorefactions.team.type.system.GlowstoneMountainFaction;
+import notifyz.hardcorefactions.team.type.system.KothFaction;
+import notifyz.hardcorefactions.team.type.system.RoadFaction;
+import notifyz.hardcorefactions.team.type.system.SpawnFaction;
+import notifyz.hardcorefactions.team.utilities.ITeam;
+import notifyz.hardcorefactions.team.utilities.TeamFile;
+import notifyz.hardcorefactions.team.utilities.TeamMember;
+import notifyz.hardcorefactions.team.utilities.TeamUser;
+import notifyz.hardcorefactions.utilities.Configuration;
+import notifyz.hardcorefactions.utilities.api.IPluginAPI;
+import notifyz.hardcorefactions.utilities.chat.BukkitUtils;
+import notifyz.hardcorefactions.utilities.chat.Color;
+import notifyz.hardcorefactions.utilities.chat.Cooldowns;
+import notifyz.hardcorefactions.utilities.freeze.FrozenInventory;
+import notifyz.hardcorefactions.utilities.freeze.FrozenManager;
+import notifyz.hardcorefactions.utilities.inventory.item.ItemDB;
+import notifyz.hardcorefactions.utilities.inventory.restoration.InventoryManager;
+import notifyz.hardcorefactions.utilities.inventory.restoration.RestoreManager;
+import notifyz.hardcorefactions.utilities.user.IUser;
+import notifyz.hardcorefactions.utilities.user.IUserManager;
+import notifyz.hardcorefactions.utilities.user.UserManager;
+import notifyz.hardcorefactions.utilities.utils.DataHandler;
+import notifyz.hardcorefactions.utilities.utils.DateTimeFormats;
+import notifyz.hardcorefactions.utilities.utils.ServerHandler;
+import notifyz.hardcorefactions.utilities.utils.SignHandler;
+import notifyz.hardcorefactions.utilities.visualise.ProtocolLibHook;
+import notifyz.hardcorefactions.utilities.visualise.VisualiseHandler;
+import notifyz.hardcorefactions.utilities.visualise.WallBorderListener;
+
+public class HardcoreFactionsPlugin extends JavaPlugin {
+
+ @Getter public static HardcoreFactionsPlugin instance;
+
+ @Getter
+ @Setter
+ private PvPClassHolder pvpClassHolder = uuid -> null;
+
+ @Getter
+ private List postFillers = new ArrayList<>();
+
+ @Getter
+ private static HardcoreFactionsPlugin plugin;
+
+ @Getter
+ private Random random = new Random();
+
+ @Getter
+ private EffectRestorer effectRestorer;
+
+ @Getter
+ private PvPClassManager PvPClassManager;
+
+ @Getter
+ private ClassWarmupTimer pvpClassWarmupTimer;
+
+ @Getter
+ private Configuration configuration;
+
+ @Getter
+ private ClaimManager claimHandler;
+
+ @Getter
+ private CombatLogListener combatLogListener;
+
+ @Getter
+ private DeathbanManager deathbanManager;
+
+ @Getter
+ private Economy economyManager;
+
+ @Getter
+ public PlayTimeListener playTimeManager;
+
+ @Getter
+ private EOTWHandler eotwHandler;
+
+ @Getter
+ private FreezeListener freezeListener;
+
+ @Getter
+ private TeamManager factionManager;
+
+
+ @Getter
+ private IEventScheduler eventScheduler;
+
+ @Getter
+ private ScoreboardHandler scoreboardHandler;
+
+ @Getter
+ private SOTWHandler sotwTimer;
+
+ @Getter
+ private TimerManager timerManager;
+
+ @Getter
+ private UserManager userManager;
+
+ @Getter
+ private VisualiseHandler visualiseHandler;
+
+ @Getter
+ private StaffModeListener staffModeListener;
+
+ @Getter
+ private WorldEditPlugin worldEdit;
+
+ @Getter
+ private boolean paperPatch;
+
+ private boolean configurationLoaded = true;
+
+ @Getter
+ private ItemDB itemDb;
+
+ @Getter
+ private IPluginAPI basePlugin;
+
+ @Getter
+ private SignHandler signHandler;
+
+ @Getter
+ private KitManager kitManager;
+
+ @Getter
+ private KitExecutor kitExecutor;
+
+ @Getter
+ private VirtualChestManager chestManager;
+
+ @Getter
+ private EndEventHandler endEventHandler;
+
+ @Getter
+ private FreezeAllListener freezeAllListener;
+
+ @Getter
+ private InventoryManager restoreInventoryManager;
+
+ @Getter
+ private RestoreManager restoreManager;
+
+ @Getter
+ private ReviveHandler reviveHandler;
+
+ public static Joiner SPACE_JOINER = Joiner.on(' ');
+ public static Joiner COMMA_JOINER = Joiner.on(", ");
+ private static long MINUTE = TimeUnit.MINUTES.toMillis(1);
+ private static long HOUR = TimeUnit.HOURS.toMillis(1);
+ private static int spamCooldown;
+ private static HashMap database;
+ public List donators = new ArrayList<>();
+ public static List killStreaks = new ArrayList<>();
+ private FrozenInventory inventoryManager;
+ private FrozenManager frozenManager;
+ private DataHandler dataHandler;
+ private WarpManager warpManager;
+ private ServerHandler serverHandler;
+ public IUserManager userManagerr;
+ private YamlConfiguration reclaimConfig;
+ private YamlConfiguration reclaimSettingsConfig;
+ private KeyManager keyManager;
+ public Chat chat = null;
+ public Permission permission = null;
+
+ public File reclaimFile = new File(this.getDataFolder(), "reclaims.yml");
+ public File reclaimSettingsFile = new File(this.getDataFolder(), "reclaimsettings.yml");
+
+ public static String getRemaining(long millis, boolean milliseconds) {
+ return HardcoreFactionsPlugin.getRemaining(millis, milliseconds, true);
+ }
+
+ public static String getRemaining(long duration, boolean milliseconds, boolean trail) {
+ if (milliseconds && duration < MINUTE) {
+ return (trail ? DateTimeFormats.REMAINING_SECONDS_TRAILING : DateTimeFormats.REMAINING_SECONDS).get().format(duration * 0.001) + 's';
+ }
+ return DurationFormatUtils.formatDuration(duration, (duration >= HOUR ? "HH:" : "") + "mm:ss");
+ }
+
+ private void registerManagersBase() {
+ this.basePlugin = IPluginAPI.getPlugin();
+ this.basePlugin.init(this);
+ this.signHandler = this.basePlugin.getSignHandler();
+ this.itemDb = IPluginAPI.getPlugin().getItemDb();
+ }
+
+ private boolean setupChat() {
+ RegisteredServiceProvider chatProvider = Bukkit.getServicesManager().getRegistration(Chat.class);
+ if (chatProvider != null) {
+ chat = chatProvider.getProvider();
+ }
+
+ return (chat != null);
+ }
+
+ private boolean setupPermission() {
+ RegisteredServiceProvider permissionProvider = Bukkit.getServicesManager().getRegistration(Permission.class);
+ if (permissionProvider != null) {
+ permission = permissionProvider.getProvider();
+ }
+
+ return (permission != null);
+ }
+
+ @Override
+ public void onEnable() {
+ instance = this;
+
+ setupChat();
+ setupPermission();
+
+ File chestFolder = new File(getDataFolder(), "chests");
+ chestManager = new VirtualChestManager(chestFolder, getLogger());
+ new Teller(this);
+ int autosaveInterval = getConfig().getInt("chest-configuration.autosave") * 1200;
+
+ if (autosaveInterval > 0) {
+ getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable() {
+ @Override
+ public void run() {
+ int savedChests = chestManager.save();
+
+ if (savedChests > 0 && !getConfig().getBoolean("chest-configuration.silentAutosave")) {
+ }
+ }
+ }, autosaveInterval, autosaveInterval);
+ }
+
+ registerSerialization();
+ registerConfiguration();
+ registerManagersBase();
+ getConfig().options().copyDefaults(true);
+ saveConfig();
+ if (!configurationLoaded) {
+ getLogger().severe("Disabling plugin..");
+ setEnabled(false);
+ return;
+ }
+
+ this.getConfig().set("chat.spam-cooldown", 5);
+ this.saveConfig();
+ HardcoreFactionsPlugin.spamCooldown = this.getConfig().getInt("chat.spam-cooldown");
+ HardcoreFactionsPlugin.spamCooldown = ((HardcoreFactionsPlugin.spamCooldown <= 0) ? 5 : HardcoreFactionsPlugin.spamCooldown);
+
+ this.dataHandler = new DataHandler(this);
+ this.inventoryManager = new FrozenInventory(this);
+ this.frozenManager = new FrozenManager();
+
+ CustomEntityRegistration.registerCustomEntities();
+
+ HardcoreFactionsPlugin.plugin = this;
+ DateTimeFormats.reload(configuration.getServerTimeZone()); // Initialise the static fields.
+ ///////////////////////////
+ Plugin wep = getServer().getPluginManager().getPlugin("WorldEdit"); // Initialise WorldEdit hook.
+ worldEdit = wep instanceof WorldEditPlugin && wep.isEnabled() ? (WorldEditPlugin) wep : null;
+ try {
+ if(!reclaimFile.exists())
+ reclaimFile.createNewFile();
+ if(!reclaimSettingsFile.exists()) {
+ saveResource("reclaimsettings.yml", false);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ reclaimConfig = YamlConfiguration.loadConfiguration(reclaimFile);
+ reclaimSettingsConfig = YamlConfiguration.loadConfiguration(reclaimSettingsFile);
+ ShapelessRecipe recipe = new ShapelessRecipe(new ItemStack(Material.SPECKLED_MELON, 1));
+ recipe.addIngredient(1, new MaterialData(Material.GOLD_NUGGET));
+ recipe.addIngredient(1, new MaterialData(Material.MELON));
+ getServer().addRecipe(recipe);
+ registerEnableMessage();
+ registerCommands();
+ registerManagers();
+ registerListeners();
+ registerCooldowns();
+ setLocation();
+ saveAll();
+
+ for (String item : plugin.getConfig().getConfigurationSection("killstreaks.items").getKeys(false)) {
+ String name = plugin.getConfig().getString("killstreaks.items." + item + ".name");
+ int kills = plugin.getConfig().getInt("killstreaks.items." + item + ".kills");
+ String command = plugin.getConfig().getString("killstreaks.items." + item + ".command");
+ KillStreaks killsAdd = new KillStreaks(name, kills, command);
+ killStreaks.add(killsAdd);
+ }
+ paperPatch = true;
+
+ //TODO: More reliable, SQL based.
+ long dataSaveInterval = TimeUnit.MINUTES.toMillis(10L);
+ getServer().getScheduler().scheduleSyncRepeatingTask(this, this::saveData, dataSaveInterval, dataSaveInterval);
+ Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "save-all");
+ getServer().broadcast(ChatColor.RED.toString() + ChatColor.BOLD + "Saving!" + "\n" + ChatColor.RED + "Saved all teams and player data to the database.", "hcf.seesaves");
+
+ ProtocolLibHook.hook(this); // Initialise ProtocolLib hook.
+
+// new BukkitRunnable() {
+// @Override
+// public void run() {
+// Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "save-all");
+// getServer().broadcast(ChatColor.RED.toString() + ChatColor.BOLD + "Saving!" + "\n" + ChatColor.RED + "Saved all teams and player data to the database.", "hcf.seesaves");
+// saveData();
+// }
+// }.runTaskTimerAsynchronously(this, TimeUnit.MINUTES.toMillis(3L), TimeUnit.MINUTES.toMillis(3L));
+ }
+
+
+
+
+private void registerEnableMessage() {
+ long timeMillis = System.currentTimeMillis();
+ Bukkit.getConsoleSender().sendMessage(ChatColor.GREEN + BukkitUtils.STRAIGHT_LINE_DEFAULT);
+ Bukkit.getConsoleSender().sendMessage("");
+ Bukkit.getConsoleSender().sendMessage(Color.translate("&a[HardcoreFactions] Plugin loaded in &f" + (System.currentTimeMillis() - timeMillis) + "ms."));
+ Bukkit.getConsoleSender().sendMessage(Color.translate("&aVersion: &fv" + HardcoreFactionsPlugin.getPlugin().getDescription().getVersion()));
+ Bukkit.getConsoleSender().sendMessage("");
+ Bukkit.getConsoleSender().sendMessage(ChatColor.GREEN + BukkitUtils.STRAIGHT_LINE_DEFAULT);
+}
+
+
+
+
+
+private void saveAll() {
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("auto-save.enabled")) {
+ Bukkit.getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable() {
+ @Override
+ public void run() {
+ saveData();
+ Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), HardcoreFactionsPlugin.getInstance().getConfig().getString("auto-save.command"));
+ getServer().broadcastMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("auto-save.message")));
+ }
+ }, 0L, 18000L);
+ }
+}
+
+
+
+
+
+private void registerCooldowns() {
+ Cooldowns.createCooldown("Revive1");
+ Cooldowns.createCooldown("Revive2");
+ Cooldowns.createCooldown("report_cooldown");
+ Cooldowns.createCooldown("request_cooldown");
+ Cooldowns.createCooldown("rename_cooldown");
+ Cooldowns.createCooldown("spawntoken");
+ Cooldowns.createCooldown("endportaltoken");
+ Cooldowns.createCooldown("Assassin_item_cooldown");
+ Cooldowns.createCooldown("Cobwebs");
+}
+
+
+
+
+
+private void saveData() {
+ keyManager.saveKeyData();
+ deathbanManager.saveDeathbanData();
+ economyManager.saveEconomyData();
+ factionManager.saveFactionData();
+ timerManager.saveTimerData();
+ userManager.saveUserData();
+ warpManager.saveWarpData();
+ playTimeManager.savePlaytimeData();
+ serverHandler.saveServerData();
+ userManagerr.saveParticipatorData();
+ chestManager.save();
+ kitManager.saveKitData();
+}
+
+
+
+
+
+@Override
+public void onDisable() {
+ //kitManager.saveKitData();
+ //chestManager.save();
+ HardcoreFactionsPlugin.plugin = this;
+ if (!configurationLoaded) {
+ // Ignore everything.
+ return;
+ }
+
+ try {
+ String configFileName = "config.cdl";
+ configuration.save(new File(getDataFolder(), configFileName),
+ HardcoreFactionsPlugin.class.getResource("/" + configFileName));
+ } catch (IOException | InvalidConfigurationException ex) {
+ getLogger().warning("Unable to save config.");
+ ex.printStackTrace();
+ }
+ scoreboardHandler.clearBoards();
+ PvPClassManager.onDisable();
+
+ CustomEntityRegistration.unregisterCustomEntities();
+
+ saveData();
+ basePlugin.disable();
+ basePlugin = null;
+ HardcoreFactionsPlugin.plugin = null; // Always uninitialise last.
+ instance = null;
+}
+
+
+
+
+
+private void registerConfiguration() {
+ configuration = new Configuration();
+ try {
+ String configFileName = "config.cdl";
+ File file = new File(getDataFolder(), configFileName);
+ if (!file.exists()) {
+ saveResource(configFileName, false);
+ }
+
+ configuration.load(file, HardcoreFactionsPlugin.class.getResource("/" + configFileName));
+ configuration.updateFields(this);
+ } catch (IOException | InvalidConfigurationException ex) {
+ getLogger().log(Level.SEVERE, "Failed to load configuration", ex);
+ configurationLoaded = false;
+ }
+}
+
+
+
+
+
+//TODO: More reliable, SQL based.
+private void registerSerialization() {
+ ConfigurationSerialization.registerClass(Kit.class);
+ ConfigurationSerialization.registerClass(Warp.class);
+ ConfigurationSerialization.registerClass(CaptureZone.class);
+ ConfigurationSerialization.registerClass(Deathban.class);
+ ConfigurationSerialization.registerClass(Claim.class);
+ ConfigurationSerialization.registerClass(Subclaim.class);
+ ConfigurationSerialization.registerClass(Deathban.class);
+ ConfigurationSerialization.registerClass(TeamUser.class);
+ ConfigurationSerialization.registerClass(ClaimableTeam.class);
+ ConfigurationSerialization.registerClass(ConquestFaction.class);
+ ConfigurationSerialization.registerClass(FuryFaction.class);
+ ConfigurationSerialization.registerClass(CapturableFaction.class);
+ ConfigurationSerialization.registerClass(KothFaction.class);
+ ConfigurationSerialization.registerClass(EndPortalFaction.class);
+ ConfigurationSerialization.registerClass(ITeam.class);
+ ConfigurationSerialization.registerClass(TeamMember.class);
+ ConfigurationSerialization.registerClass(PlayerTeam.class);
+ ConfigurationSerialization.registerClass(RoadFaction.class);
+ ConfigurationSerialization.registerClass(SpawnFaction.class);
+ ConfigurationSerialization.registerClass(GlowstoneMountainFaction.class);
+ ConfigurationSerialization.registerClass(RoadFaction.NorthRoadFaction.class);
+ ConfigurationSerialization.registerClass(RoadFaction.EastRoadFaction.class);
+ ConfigurationSerialization.registerClass(RoadFaction.SouthRoadFaction.class);
+ ConfigurationSerialization.registerClass(RoadFaction.WestRoadFaction.class);
+ ConfigurationSerialization.registerClass(RewardableItemStack.class);
+ ConfigurationSerialization.registerClass(IUser.class);
+}
+
+
+
+
+
+private void registerListeners() {
+ PluginManager manager = getServer().getPluginManager();
+
+ freezeListener = new FreezeListener();
+ Bukkit.getServer().getPluginManager().registerEvents(freezeListener, this);
+ if (plugin.getConfig().getBoolean("staffmode.enabled")) {
+ staffModeListener = new StaffModeListener();
+ freezeAllListener = new FreezeAllListener(this);
+ Bukkit.getServer().getPluginManager().registerEvents(staffModeListener, this);
+ }
+ manager.registerEvents(this.playTimeManager = new PlayTimeListener(this), this);
+ manager.registerEvents(new WhitelistMessageListener(), this);
+ manager.registerEvents(new BottledExpListener(this), this);
+ manager.registerEvents(new FoundDiamondListener(), this);
+ manager.registerEvents(new BlockHitFixListener(), this);
+if (plugin.getConfig().getBoolean("staffmode.enabled")) {
+ manager.registerEvents(new StaffChatListener(), this);
+}
+ manager.registerEvents(new WeatherFixListener(), this);
+ manager.registerEvents(new DuplicationGlitchListener(), this);
+ manager.registerEvents(new BoatGlitchFixListener(this), this);
+ manager.registerEvents(new ColorSignListener(), this);
+ manager.registerEvents(new BookDeenchantListener(this), this);
+ manager.registerEvents(new ChatListener(this), this);
+ manager.registerEvents(new ClaimWandListener(this), this);
+ manager.registerEvents(new CombatLogListener(this), this);
+ manager.registerEvents(new CoreListener(this), this);
+ manager.registerEvents(new CrowbarListener(this), this);
+ manager.registerEvents(new DeathListener(this), this);
+ manager.registerEvents(new BreedListener(), this);
+ manager.registerEvents(new CrashFixListener(), this);
+ manager.registerEvents(new SugarCaneFixListener(), this);
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("deathmessages.enabled")) {
+ manager.registerEvents(new DeathMessageListener(this), this);
+ }
+ new DeathSignListener(this);
+ manager.registerEvents(new DeathbanListener(this), this);
+ manager.registerEvents(new EnchantLimitListener(this), this);
+ manager.registerEvents(new BedBombingListener(), this);
+ manager.registerEvents(new ArmorFixListener(), this);
+ manager.registerEvents(new EnderChestRemovalListener(this), this);
+ manager.registerEvents(new EntityLimitListener(this), this);
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("faction-utilities.elevators.sign.enabled")) {
+ manager.registerEvents(new ElevatorListener(), this);
+ }
+ manager.registerEvents(new EOTWListener(this), this);
+ manager.registerEvents(new EventSignListener(), this);
+ manager.registerEvents(new ExpMultiplierListener(this), this);
+ manager.registerEvents(new TeamListener(this), this);
+ manager.registerEvents(new FurnaceSmeltSpeederListener(this), this);
+ manager.registerEvents(new InfinityArrowFixListener(this), this);
+ manager.registerEvents(new KitMapListener(this), this);
+ manager.registerEvents(new PearlGlitchListener(this), this);
+ manager.registerEvents(new PortalListener(this), this);
+ manager.registerEvents(new PotionLimitListener(this), this);
+ manager.registerEvents(new ProtectionListener(this), this);
+ manager.registerEvents(new SubclaimWandListener(this), this);
+ manager.registerEvents(new SubclaimListener(this), this);
+ manager.registerEvents(new ShopListener(this), this);
+ manager.registerEvents(new SkullListener(this), this);
+ manager.registerEvents(new SOTWListener(this), this);
+ manager.registerEvents(new BeaconStrengthFixListener(this), this);
+ //manager.registerEvents(new ArcherBeaconSpeedFixListener(this), this);
+ manager.registerEvents(new VoidGlitchFixListener(), this);
+ manager.registerEvents(new WallBorderListener(this), this);
+ manager.registerEvents(new WorldListener(), this);
+ manager.registerEvents(new MobFixListener(), this);
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("faction-utilities.elevators.minecart.enabled")) {
+ manager.registerEvents(new MinecartElevatorListener(), this);
+ }
+ manager.registerEvents(new AutoMuteListener(), this);
+ manager.registerEvents(new CobwebListener(this), this);
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("anvil-spam-fixer.enabled")) {
+ manager.registerEvents(new AnvilSpamListener(this), this);
+ }
+ manager.registerEvents(new HungerFixListener(this), this);
+ manager.registerEvents(new StrengthListener(), this);
+ manager.registerEvents(new Strength2Listener(this), this);
+ manager.registerEvents(new PickaxeStatsListener(), this);
+ //manager.registerEvents(new EventListener(this), this);
+ //manager.registerEvents(new AnvilDupeFixListener(this), this);
+ manager.registerEvents(new CobbleCommand(), this);
+ manager.registerEvents(new MobDropsCommand(), this);
+ manager.registerEvents(new SettingsCommand(this), this);
+ manager.registerEvents(new EndPortalCommand(this), this);
+ manager.registerEvents(new StatsCommand(), this);
+ manager.registerEvents(new GiveawayCommand(), this);
+ manager.registerEvents(new GuiFreezeCommand(this), this);
+ manager.registerEvents(new ItemStatTrackingListener(), this);
+ manager.registerEvents(new KitListener(this), this);
+ manager.registerEvents(new PlayerListener(this, chestManager), this);
+ manager.registerEvents(new SplashPotionListener(this), this);
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("killstreaks.enabled")) {
+ manager.registerEvents(new KillstreakListener(this), this);
+ }
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("skygear.enabled")) {
+ manager.registerEvents(new SkyGearListener(), this);
+ }
+ manager.registerEvents(new BorderListener(), this);
+ manager.registerEvents(new ThrowableCobwebsListener(), this);
+ if (plugin.getConfig().getBoolean("kitmap-selector.enabled")) {
+ manager.registerEvents(new KitMapKitsListener(this), this);
+ }
+ manager.registerEvents(this.endEventHandler, this);
+ manager.registerEvents(new RestoreInventoryListener(this), this);
+ //manager.registerEvents(new PearlThroughListener(), this);
+ //manager.registerEvents(new PickaxeStatisticsListener(), this);
+ //manager.registerEvents(new MobstackListener(this), this);
+}
+
+
+
+
+private void registerCommands() {
+ getCommand("kit").setExecutor(new KitExecutor(this));
+ getCommand("restoreinventory").setExecutor(new RestoreInventoryCommand(this));
+ getCommand("sale").setExecutor(new SaleCommand(this));
+ getCommand("reboot").setExecutor(new RebootCommand(this));
+ getCommand("oinvsee").setExecutor(new InvseeOfflineCommand());
+ getCommand("ffa").setExecutor(new FFACommand());
+ getCommand("freezeall").setExecutor(new FreezeAllCommand(this));
+ getCommand("famous").setExecutor(new FamousCommand());
+ getCommand("youtube").setExecutor(new YoutubeCommand());
+ getCommand("store").setExecutor(new StoreCommand(this));
+ getCommand("website").setExecutor(new WebsiteCommand(this));
+ getCommand("teamspeak").setExecutor(new TeamSpeakCommand());
+ getCommand("removeperm").setExecutor(new RemovePermCommand());
+if (plugin.getConfig().getBoolean("staffmode.enabled")) {
+ getCommand("staffmode").setExecutor(new StaffModeCommand());
+}
+ getCommand("info").setExecutor(new InfoCommand());
+ getCommand("focus").setExecutor(new FocusCommand());
+if (plugin.getConfig().getBoolean("staffmode.enabled")) {
+ getCommand("staffchat").setExecutor(new StaffChatCommand());
+}
+ getCommand("conquest").setExecutor(new ConquestExecutor(this));
+ getCommand("fury").setExecutor(new FuryExecutor(this));
+ getCommand("economy").setExecutor(new EconomyCommand(this));
+ getCommand("rec").setExecutor(new RecCommand());
+ getCommand("coords").setExecutor(new CoordinatesCommand());
+ getCommand("freeze").setExecutor(new FreezeCommand());
+ getCommand("playtime").setExecutor(new PlayTimeCommand());
+ getCommand("endportal").setExecutor(new EndPortalCommand(this));
+ getCommand("settings").setExecutor(new SettingsCommand(this));
+ getCommand("spawn").setExecutor(new SpawnCommand());
+ getCommand("eotw").setExecutor(new EOTWCommand(this));
+ getCommand("help").setExecutor(new HelpCommand());
+ getCommand("event").setExecutor(new EventExecutor(this));
+ if (plugin.getConfig().getBoolean("kitmap-gui.enabled")) {
+ getCommand("mapkit").setExecutor(new KitMapGUICommand());
+ } else {
+ getCommand("mapkit").setExecutor(new MapKitCommand());
+ }
+ getCommand("newvideo").setExecutor(new NewVideoCommand());
+ getCommand("cobble").setExecutor(new CobbleCommand());
+ getCommand("platinum").setExecutor(new Revive1(this));
+ getCommand("spawner").setExecutor(new SpawnerCommand());
+ getCommand("gold").setExecutor(new Revive2(this));
+ getCommand("team").setExecutor(new TeamExecutor(this));
+ getCommand("vanish").setExecutor(new VanishCommand());
+ getCommand("koth").setExecutor(new KothExecutor(this));
+ getCommand("lives").setExecutor(new LivesExecutor(this));
+ getCommand("location").setExecutor(new LocationCommand(this));
+ getCommand("set").setExecutor(new SetCommand());
+ getCommand("logout").setExecutor(new LogoutCommand(this));
+ getCommand("lff").setExecutor(new LFFCommand());
+ getCommand("giveaway").setExecutor(new GiveawayCommand());
+ getCommand("pay").setExecutor(new PayCommand(this));
+ getCommand("pvptimer").setExecutor(new PvPTimerCommand(this));
+ getCommand("regen").setExecutor(new RegenCommand(this));
+ getCommand("servertime").setExecutor(new ServerTimeCommand(this));
+ getCommand("sotw").setExecutor(new SOTWCommand(this));
+ getCommand("spawncannon").setExecutor(new SpawnCannonCommand(this));
+ getCommand("stats").setExecutor(new StatsCommand());
+ getCommand("staffrevive").setExecutor(new StaffReviveCommand(this));
+ getCommand("glow").setExecutor(new GlowstoneMountainCommand(this));
+ getCommand("timer").setExecutor(new TimerExecutor(this));
+ getCommand("togglecapzoneentry").setExecutor(new ToggleCapzoneEntryCommand(this));
+ getCommand("togglelightning").setExecutor(new ToggleLightningCommand(this));
+ getCommand("mobdrops").setExecutor(new MobDropsCommand());
+ getCommand("togglesidebar").setExecutor(new ToggleSidebarCommand(this));
+ getCommand("togglefd").setExecutor(new ToggleDiamondAlertsCommand(this));
+ getCommand("guifreeze").setExecutor(new GuiFreezeCommand(this));
+ getCommand("request").setExecutor(new RequestCommand());
+ getCommand("report").setExecutor(new ReportCommand());
+ getCommand("warp").setExecutor(new WarpExecutor(this));
+ getCommand("teleport").setExecutor(new TeleportCommand());
+ getCommand("tphere").setExecutor(new TeleportCommand());
+ getCommand("fly").setExecutor(new FlyCommand());
+ getCommand("list").setExecutor(new ListCommand());
+ getCommand("world").setExecutor(new WorldCommand());
+ getCommand("gamemode").setExecutor(new GamemodeCommand());
+ getCommand("gamemodes").setExecutor(new GamemodeCommand());
+ getCommand("gamemodec").setExecutor(new GamemodeCommand());
+ getCommand("gamemodea").setExecutor(new GamemodeCommand());
+ getCommand("disablechat").setExecutor(new DisableChatCommand(this));
+ getCommand("feed").setExecutor(new FeedCommand());
+ getCommand("lag").setExecutor(new LagCommand());
+ getCommand("slowchat").setExecutor(new SlowchatCommand(this));
+ getCommand("give").setExecutor(new GiveCommand());
+ getCommand("heal").setExecutor(new HealCommand());
+ getCommand("uptime").setExecutor(new UptimeCommand());
+ getCommand("top").setExecutor(new TopCommand());
+ getCommand("hat").setExecutor(new HatCommand());
+ getCommand("invsee").setExecutor(new InvseeCommand());
+ getCommand("god").setExecutor(new GodCommand());
+ getCommand("tppos").setExecutor(new TeleportCommand());
+ getCommand("tpall").setExecutor(new TeleportCommand());
+ getCommand("broadcast").setExecutor(new BroadcastCommand());
+ getCommand("rename").setExecutor(new RenameCommand());
+ getCommand("enchant").setExecutor(new EnchantCommand());
+ getCommand("kill").setExecutor(new KillCommand());
+ getCommand("message").setExecutor(new MessageCommand(this));
+ getCommand("ignore").setExecutor(new IgnoreCommand(this));
+ getCommand("reply").setExecutor(new ReplyCommand(this));
+ getCommand("messagespy").setExecutor(new MessageSpyCommand(this));
+ getCommand("togglemessages").setExecutor(new ToggleMessagesCommand(this));
+ getCommand("sounds").setExecutor(new ToggleSoundsCommand(this));
+ getCommand("togglechat").setExecutor(new ToggleChatCommand(this));
+ getCommand("reclaim").setExecutor(new ReclaimCommand(this));
+ getCommand("chest").setExecutor(new ChestCommand(chestManager));
+ getCommand("clearchest").setExecutor(new ClearChestCommand(chestManager));
+ getCommand("disposal").setExecutor(new DisposalCommand(chestManager));
+ getCommand("savechests").setExecutor(new SaveChestsCommand(chestManager));
+ getCommand("workbench").setExecutor(new WorkbenchCommand());
+ getCommand("panic").setExecutor(new PanicCommand());
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("skygear.enabled")) {
+ getCommand("skygear").setExecutor(new SkyGearCommand());
+ }
+ getCommand("setborder").setExecutor(new SetBorderCommand());
+ getCommand("eotwrevive").setExecutor(new EOTWReviveCommand(this));
+ getCommand("tc").setExecutor(new TeamCoordinatesCommand());
+ getCommand("hidestaff").setExecutor(new HideStaffCommand());
+ getCommand("speed").setExecutor(new SpeedCommand());
+ getCommand("more").setExecutor(new MoreItemsCommand());
+ getCommand("back").setExecutor(new BackCommand(this));
+ getCommand("bardenergy").setExecutor(new BardEnergyCommand());
+ getCommand("endevent").setExecutor(new EndEventCommand(this));
+ getCommand("crowbar").setExecutor(new CrowbarCommand());
+ getCommand("reclaimreset").setExecutor(new ReclaimResetCommand());
+
+ //getCommand("bottle").setExecutor(new BottleCommand(this));
+ Map> map = getDescription().getCommands();
+ for (Map.Entry> entry : map.entrySet()) {
+ PluginCommand command = getCommand(entry.getKey());
+ command.setPermission("hcf.command." + entry.getKey());
+ command.setPermissionMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("cmd-messages.no-permission")));
+ }
+
+}
+
+
+private void registerManagers() {
+
+
+ kitManager = new FlatFileKitManager(this);
+ claimHandler = new ClaimManager(this);
+ deathbanManager = new DeathbanFile(this);
+ serverHandler = new ServerHandler(this);
+ warpManager = new FlatFileWarpManager(this);
+ economyManager = new EconomyFile(this);
+ userManagerr = new IUserManager(this);
+ effectRestorer = new EffectRestorer(this);
+ PvPClassManager = new PvPClassManager(this);
+ eotwHandler = new EOTWHandler(this);
+ factionManager = new TeamFile(this);
+ eventScheduler = new EventScheduler2(this);
+ sotwTimer = new SOTWHandler();
+ timerManager = new TimerManager(this); // Needs to be registered before ScoreboardHandler.
+ scoreboardHandler = new ScoreboardHandler(this);
+ userManager = new UserManager(this);
+ visualiseHandler = new VisualiseHandler();
+ keyManager = new KeyManager(this);
+ restoreInventoryManager = new InventoryManager(this);
+ restoreManager = new RestoreManager(this);
+ endEventHandler = new EndEventHandler(this);
+ reviveHandler = new ReviveHandler(this);
+ getServer().getPluginManager().registerEvents(new KeyListener(this), this);
+ getCommand("key").setExecutor(new LootExecutor(this));
+}
+
+
+
+
+
+public void setLocation() {
+ Long hours = Long.valueOf(getConfig().getLong("glowstone-mountain.regeneration"));
+ Bukkit.getScheduler().scheduleSyncDelayedTask(Bukkit.getPluginManager().getPlugin("HCF"), new Runnable() {
+ @Override
+ public void run() {
+ HardcoreFactionsPlugin.this.setLocation();
+ if (getConfig().getBoolean("glowstone-mountain.enabled")) {
+ try {
+ Location loc = GlowstoneMountainCommand.destringifyLocation(getConfig().getString("glowstone-mountain.location"));
+ loadGlowstone(loc);
+ String message = ChatColor.translateAlternateColorCodes('&', getConfig().getString("glowstone-mountain-messages.regenerated"));
+ Bukkit.broadcastMessage(message);
+ } catch (MaxChangedBlocksException | DataException | IOException e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ }, hours.longValue());
+ for (Player all : Bukkit.getOnlinePlayers()) {
+ all.playSound(all.getLocation(), Sound.NOTE_PIANO, 30.0F, 1.0F);
+ }
+}
+
+
+
+
+
+public void loadGlowstone(Location loc) throws DataException, IOException, MaxChangedBlocksException {
+ String stg = File.separator;
+ File file = new File(getDataFolder() + stg + "glowstone-mountain.schematic");
+ EditSession es = new EditSession(new BukkitWorld(loc.getWorld()), 999999999);
+ CuboidClipboard cc = CuboidClipboard.loadSchematic(file);
+ cc.paste(es, BukkitUtil.toVector(loc), false);
+}
+
+
+
+public static int getSpamCooldown() {
+ return HardcoreFactionsPlugin.spamCooldown;
+}
+
+public static boolean databaseContains(String name) {
+ return HardcoreFactionsPlugin.database.containsKey(name);
+}
+
+public static int getMessageCount(String name) {
+ return HardcoreFactionsPlugin.database.get(name);
+}
+
+public static void addMessage(String name) {
+ int messageCount;
+ if (HardcoreFactionsPlugin.database.containsKey(name)) {
+ messageCount = HardcoreFactionsPlugin.database.get(name);
+ HardcoreFactionsPlugin.database.remove(name);
+ }
+ else {
+ messageCount = 0;
+ }
+ ++messageCount;
+ HardcoreFactionsPlugin.database.put(name, messageCount);
+}
+
+public static void removeMessageCount(String name) {
+ HardcoreFactionsPlugin.database.remove(name);
+}
+
+static {
+ HardcoreFactionsPlugin.database = new HashMap<>();
+}
+
+public WarpManager getWarpManager() {
+ return this.warpManager;
+}
+
+public ServerHandler getServerHandler() {
+ return this.serverHandler;
+}
+
+public DataHandler getDataHandler() {
+ return this.dataHandler;
+}
+
+public IUserManager getUserManagerr() {
+ return this.userManagerr;
+}
+
+public FrozenInventory getInventoryManager() {
+ return this.inventoryManager;
+}
+
+public FrozenManager getFrozenManager() {
+ return this.frozenManager;
+}
+
+public KeyManager getKeyManager()
+{
+ return this.keyManager;
+}
+
+public YamlConfiguration getReclaimConfig() {
+ return reclaimConfig;
+ }
+
+public YamlConfiguration getReclaimSettingsConfig() {
+ return reclaimSettingsConfig;
+ }
+
+/*
+ * In case you want to automatically register Koth games
+ * you may use this method. Do not forget to import the required
+ * packages and add your HCF plugin as a library.
+ */
+
+/*private void registerFromFactions(){
+ koths.clear();
+ for(Faction faction : getFactionManager().getFactions()){
+ if(faction instanceof EventFaction){
+ if(faction instanceof KothFaction) {
+ koths.add(faction.getName());
+ this.getLogger().info("Registered " + faction.getName() + " in eventGames list.");
+ }
+ }
+ }
+}*/
+
+}
\ No newline at end of file
diff --git a/src/notifyz/hardcorefactions/chests/InventoryIO.java b/src/notifyz/hardcorefactions/chests/InventoryIO.java
new file mode 100644
index 0000000..507ea69
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/InventoryIO.java
@@ -0,0 +1,119 @@
+package notifyz.hardcorefactions.chests;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+/**
+ * Utility class to store inventories to file and read them back again.
+ */
+public class InventoryIO {
+
+ /**
+ * Loads an inventory from a plain-text file.
+ *
+ * @param file the text file to load
+ * @return the loaded inventory
+ * @throws IOException if the file could not be read
+ * @deprecated use {@link #loadFromYaml} instead
+ */
+ @Deprecated
+ public static Inventory loadFromTextFile(File file) throws IOException {
+ final Inventory inventory = Bukkit.getServer().createInventory(null, HardcoreFactionsPlugin.getInstance().getConfig().getInt("chest-configuration.size"));
+
+ final BufferedReader in = new BufferedReader(new FileReader(file));
+
+ String line;
+ int slot = 0;
+
+ while ((line = in.readLine()) != null) {
+ if (!line.equals("")) {
+ final String[] parts = line.split(":");
+
+ try {
+ int type = Integer.parseInt(parts[0]);
+ int amount = Integer.parseInt(parts[1]);
+ short damage = Short.parseShort(parts[2]);
+
+ if (type != 0) {
+ inventory.setItem(slot, new ItemStack(type, amount, damage));
+ }
+ } catch (NumberFormatException e) {
+ // ignore
+ }
+
+ ++slot;
+ }
+ }
+
+ in.close();
+
+ return inventory;
+ }
+
+ /**
+ * Loads an inventory from a YAML configuration file.
+ *
+ * @param file the YAML file to load
+ * @return the loaded inventory
+ * @throws IOException if the file could not be read
+ * @throws InvalidConfigurationException if the file could not be parsed
+ */
+ public static Inventory loadFromYaml(File file) throws IOException, InvalidConfigurationException {
+ YamlConfiguration yaml = new YamlConfiguration();
+ yaml.load(file);
+
+ int inventorySize = yaml.getInt("size", HardcoreFactionsPlugin.getInstance().getConfig().getInt("chest-configuration.size"));
+
+ Inventory inventory = Bukkit.getServer().createInventory(null, inventorySize);
+
+ ConfigurationSection items = yaml.getConfigurationSection("items");
+
+ for (int slot = 0; slot < inventorySize; slot++) {
+ String slotString = String.valueOf(slot);
+
+ if (items.isItemStack(slotString)) {
+ ItemStack itemStack = items.getItemStack(slotString);
+ inventory.setItem(slot, itemStack);
+ }
+ }
+
+ return inventory;
+ }
+
+ /**
+ * Saves an inventory to a YAML configuration file.
+ *
+ * @param inventory the inventory to save
+ * @param file the YAML file to write
+ * @throws IOException if the file could not be written
+ */
+ public static void saveToYaml(Inventory inventory, File file) throws IOException {
+ YamlConfiguration yaml = new YamlConfiguration();
+
+ int inventorySize = inventory.getSize();
+ yaml.set("size", inventorySize);
+
+ ConfigurationSection items = yaml.createSection("items");
+
+ for (int slot = 0; slot < inventorySize; slot++) {
+ ItemStack stack = inventory.getItem(slot);
+
+ if (stack != null) {
+ items.set(String.valueOf(slot), stack);
+ }
+ }
+
+ yaml.save(file);
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/Teller.java b/src/notifyz/hardcorefactions/chests/Teller.java
new file mode 100644
index 0000000..56a855f
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/Teller.java
@@ -0,0 +1,75 @@
+package notifyz.hardcorefactions.chests;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+public class Teller {
+
+ private final HardcoreFactionsPlugin plugin;
+
+ private static String prefix;
+
+ private static String infoColor;
+ private static String successColor;
+ private static String warningColor;
+ private static String errorColor;
+ private static String miscColor;
+
+ public Teller(HardcoreFactionsPlugin plugin) {
+ this.plugin = plugin;
+
+ init();
+ }
+
+ public enum Type {
+ INFO, SUCCESS, WARNING, ERROR, MISC;
+ }
+
+ /**
+ * Initializes the Teller prefix and colors.
+ */
+ public void init() {
+ prefix = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("chest-messages.prefix"));
+
+ infoColor = ChatColor.GREEN.toString();
+ successColor = ChatColor.GREEN.toString();
+ warningColor = ChatColor.RED.toString();
+ errorColor = ChatColor.DARK_RED.toString();
+ miscColor = ChatColor.RED.toString();
+ }
+
+ /**
+ * Sends a formatted and colored message to a specified CommandSender with a given type and message.
+ *
+ * @param sender the CommandSender to message
+ * @param type the type of tell message to send
+ * @param message the message to send
+ */
+ public static void tell(CommandSender sender, Type type, String message) {
+ String color = "";
+
+ switch (type) {
+ case INFO:
+ color = infoColor;
+ break;
+ case SUCCESS:
+ color = successColor;
+ break;
+ case WARNING:
+ color = warningColor;
+ break;
+ case ERROR:
+ color = errorColor;
+ break;
+ case MISC:
+ color = miscColor;
+ }
+
+ String parsedMessage = prefix + " " + ChatColor.RESET + color + message;
+ parsedMessage = ChatColor.translateAlternateColorCodes('&', parsedMessage);
+
+ sender.sendMessage(parsedMessage);
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/VirtualChestManager.java b/src/notifyz/hardcorefactions/chests/VirtualChestManager.java
new file mode 100644
index 0000000..7a5a4b4
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/VirtualChestManager.java
@@ -0,0 +1,178 @@
+package notifyz.hardcorefactions.chests;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.UUID;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.inventory.Inventory;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+public class VirtualChestManager {
+
+ private static final String YAML_CHEST_EXTENSION = ".chest.yml";
+ private static final int YAML_EXTENSION_LENGTH = YAML_CHEST_EXTENSION.length();
+
+ private final File dataFolder;
+ private final Logger logger;
+ private final Map chests = new HashMap<>();
+
+ public VirtualChestManager(File dataFolder, Logger logger) {
+ this.logger = logger;
+ this.dataFolder = dataFolder;
+
+ load();
+ }
+
+ /**
+ * Loads all existing chests from the data folder.
+ */
+ private void load() {
+ dataFolder.mkdirs();
+
+ FilenameFilter filter = new FilenameFilter() {
+ public boolean accept(File dir, String name) {
+ return name.endsWith(YAML_CHEST_EXTENSION);
+ }
+ };
+
+ for (File chestFile : dataFolder.listFiles(filter)) {
+ String chestFileName = chestFile.getName();
+ try {
+ try {
+ UUID playerUUID = UUID.fromString(chestFileName.substring(0, chestFileName.length() - YAML_EXTENSION_LENGTH));
+ chests.put(playerUUID, InventoryIO.loadFromYaml(chestFile));
+ } catch (IllegalArgumentException e) {
+ // Assume that the filename isn't a UUID, and is therefore an old player-name chest
+ String playerName = chestFileName.substring(0, chestFileName.length() - YAML_EXTENSION_LENGTH);
+ boolean flagPlayerNotFound = true;
+
+ for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
+ // Search all the known players, load inventory, flag old file for deletion
+ if (player.getName().equalsIgnoreCase(playerName)) {
+ flagPlayerNotFound = false;
+ chests.put(player.getUniqueId(), InventoryIO.loadFromYaml(chestFile));
+ chestFile.deleteOnExit();
+ }
+ }
+
+ if (flagPlayerNotFound) {
+ logger.log(Level.WARNING, "Couldn't load chest file: " + chestFileName);
+ }
+ }
+ } catch (Exception e) {
+ logger.log(Level.WARNING, "Couldn't load chest file: " + chestFileName);
+ }
+ }
+
+ logger.info("Loaded " + chests.size() + " chests");
+ }
+
+ /**
+ * Saves all existing chests to the data folder.
+ *
+ * @return the number of successfully written chests
+ */
+ public int save() {
+ int savedChests = 0;
+
+ dataFolder.mkdirs();
+
+ Iterator> chestIterator = chests.entrySet().iterator();
+
+ while (chestIterator.hasNext()) {
+ final Entry entry = chestIterator.next();
+ final UUID playerUUID = entry.getKey();
+ final Inventory chest = entry.getValue();
+
+ final File chestFile = new File(dataFolder, playerUUID.toString() + YAML_CHEST_EXTENSION);
+
+ if (chest == null) {
+ // Chest got removed, so we have to delete the file.
+ chestFile.delete();
+ chestIterator.remove();
+ } else {
+ try {
+ // Write the chest file in YAML format
+ InventoryIO.saveToYaml(chest, chestFile);
+
+ savedChests++;
+ } catch (IOException e) {
+ logger.log(Level.WARNING, "Couldn't save chest file: " + chestFile.getName(), e);
+ }
+ }
+ }
+
+ return savedChests;
+ }
+
+ /**
+ * Saves a specified player's chest to the data folder.
+ *
+ * @param playerUUID the UUID of the player to save the chest of
+ */
+ public void saveChest(UUID playerUUID) {
+ dataFolder.mkdirs();
+
+ final String uuidString = playerUUID.toString();
+ final Inventory chest = chests.get(playerUUID);
+ final File chestFile = new File(dataFolder, uuidString + YAML_CHEST_EXTENSION);
+
+ if (chest == null) {
+ // Chest got removed, so we have to delete the file.
+ chestFile.delete();
+ } else {
+ try {
+ // Write the chest file in YAML format
+ InventoryIO.saveToYaml(chest, chestFile);
+ } catch (IOException e) {
+ logger.log(Level.WARNING, "Couldn't save chest file: " + chestFile.getName(), e);
+ }
+ }
+ }
+
+ /**
+ * Gets a player's virtual chest.
+ *
+ * @param playerUUID the UUID of the player
+ * @return the player's virtual chest.
+ */
+ public Inventory getChest(UUID playerUUID) {
+ Inventory chest = chests.get(playerUUID);
+
+ if (chest == null) {
+ chest = Bukkit.getServer().createInventory(null, HardcoreFactionsPlugin.getInstance().getConfig().getInt("chest-configuration.size"));
+ chests.put(playerUUID, chest);
+ }
+
+ return chest;
+ }
+
+ /**
+ * Clears a player's virtual chest.
+ *
+ * @param playerUUID the UUID of the player
+ */
+ public void removeChest(UUID playerUUID) {
+ // Put a null to the map so we remember to delete the file when saving!
+ chests.put(playerUUID, null);
+ }
+
+ /**
+ * Gets the number of virtual chests.
+ *
+ * @return the number of virtual chests
+ */
+ public int getChestCount() {
+ return chests.size();
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/commands/ChestCommand.java b/src/notifyz/hardcorefactions/chests/commands/ChestCommand.java
new file mode 100644
index 0000000..c9d498a
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/commands/ChestCommand.java
@@ -0,0 +1,87 @@
+package notifyz.hardcorefactions.chests.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.chests.Teller;
+import notifyz.hardcorefactions.chests.Teller.Type;
+import notifyz.hardcorefactions.chests.VirtualChestManager;
+import notifyz.hardcorefactions.chests.utils.BukkitUtil;
+import notifyz.hardcorefactions.team.utilities.ITeam;
+
+
+public class ChestCommand implements CommandExecutor {
+
+ private final VirtualChestManager chestManager;
+
+ public ChestCommand(VirtualChestManager chestManager) {
+ this.chestManager = chestManager;
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (command.getName().equalsIgnoreCase("chest")) {
+ // Make sure the sender is a player
+ if (!(sender instanceof Player)) {
+ Teller.tell(sender, Type.ERROR, "Only players are able to open chests.");
+ return true;
+ }
+
+ Player player = (Player) sender;
+
+ Location location = player.getLocation();
+ ITeam factionAt = HardcoreFactionsPlugin.getInstance().getFactionManager().getFactionAt(location);
+ if ((!factionAt.isSafezone())) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-safezone")));
+ return false;
+ }
+
+ // Prevent opening of the chest in Creative Mode
+ if (player.getGameMode().equals(GameMode.CREATIVE) && !player.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-bypass")))) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.gamemode-error")));
+ return true;
+ }
+
+ switch (args.length) {
+ case 0:
+ // Open the player's own chest
+ if (player.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-use-chest")))) {
+ Inventory chest = chestManager.getChest(player.getUniqueId());
+ player.openInventory(chest);
+ } else {
+ ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission"));
+ }
+
+ return true;
+ case 1:
+ // Open someone else's chest
+ if (player.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-others-chest")))) {
+ OfflinePlayer target = BukkitUtil.getOfflinePlayerByName(args[0]);
+
+ if (target != null) {
+ Inventory chest = chestManager.getChest(target.getUniqueId());
+ player.openInventory(chest);
+ } else {
+ Teller.tell(player, Type.ERROR, String.format("Chest for %s not found", args[0]));
+ }
+ } else {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission")));
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ return false;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/commands/ClearChestCommand.java b/src/notifyz/hardcorefactions/chests/commands/ClearChestCommand.java
new file mode 100644
index 0000000..f314227
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/commands/ClearChestCommand.java
@@ -0,0 +1,67 @@
+package notifyz.hardcorefactions.chests.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.chests.Teller;
+import notifyz.hardcorefactions.chests.Teller.Type;
+import notifyz.hardcorefactions.chests.VirtualChestManager;
+import notifyz.hardcorefactions.chests.utils.BukkitUtil;
+
+public class ClearChestCommand implements CommandExecutor {
+
+ private final VirtualChestManager chestManager;
+
+ public ClearChestCommand(VirtualChestManager chestManager) {
+ this.chestManager = chestManager;
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (command.getName().equalsIgnoreCase("clearchest")) {
+ switch (args.length) {
+ case 0:
+ // Make sure the sender is a player
+ if (!(sender instanceof Player)) {
+ Teller.tell(sender, Type.ERROR, "Only players are able to clear their own chests.");
+ return true;
+ }
+
+ Player player = (Player) sender;
+
+ if (player.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-clear-chest")))) {
+ chestManager.removeChest(player.getUniqueId());
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.cleared-chest")));
+ } else {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission")));
+ }
+
+ return true;
+ case 1:
+ if (sender.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-others-clear")))) {
+ OfflinePlayer target = BukkitUtil.getOfflinePlayerByName(args[0]);
+
+ if (target != null) {
+ chestManager.removeChest(target.getUniqueId());
+ Teller.tell(sender, Type.SUCCESS, "Successfully cleared " + args[0] + "\'s chest.");
+ } else {
+ Teller.tell(sender, Type.ERROR, String.format("Chest for %s not found", args[0]));
+ }
+ } else {
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission")));
+ }
+
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ return false;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/commands/DisposalCommand.java b/src/notifyz/hardcorefactions/chests/commands/DisposalCommand.java
new file mode 100644
index 0000000..cc28190
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/commands/DisposalCommand.java
@@ -0,0 +1,44 @@
+package notifyz.hardcorefactions.chests.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.chests.Teller;
+import notifyz.hardcorefactions.chests.VirtualChestManager;
+
+
+public class DisposalCommand implements CommandExecutor {
+
+ public DisposalCommand(VirtualChestManager chestManager) {
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (command.getName().equalsIgnoreCase("disposal")) {
+ // Make sure the sender is a player
+ if (!(sender instanceof Player)) {
+ Teller.tell(sender, Teller.Type.ERROR, "Only players are able to open virtual workbenches.");
+ return true;
+ }
+
+ Player player = (Player) sender;
+
+ if (player.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-use-disposal")))) {
+ Inventory disposal = Bukkit.getServer().createInventory(player, 27, "Disposal");
+ player.openInventory(disposal);
+ } else {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission")));
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/commands/SaveChestCommand.java b/src/notifyz/hardcorefactions/chests/commands/SaveChestCommand.java
new file mode 100644
index 0000000..1f27a43
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/commands/SaveChestCommand.java
@@ -0,0 +1,47 @@
+package notifyz.hardcorefactions.chests.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.chests.Teller;
+import notifyz.hardcorefactions.chests.VirtualChestManager;
+import notifyz.hardcorefactions.chests.utils.BukkitUtil;
+
+public class SaveChestCommand implements CommandExecutor {
+
+ private final VirtualChestManager chestManager;
+
+ public SaveChestCommand(VirtualChestManager chestManager) {
+ this.chestManager = chestManager;
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (command.getName().equalsIgnoreCase("savechest")) {
+ if (args.length == 1) {
+ if (sender.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-savechest")))) {
+ OfflinePlayer target = BukkitUtil.getOfflinePlayerByName(args[0]);
+
+ if (target != null) {
+ chestManager.saveChest(target.getUniqueId());
+ Teller.tell(sender, Teller.Type.SUCCESS, "Successfully saved " + args[0] + "\'s chest.");
+ } else {
+ Teller.tell(sender, Teller.Type.ERROR, String.format("Chest for %s not found", args[0]));
+ }
+ } else {
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission")));
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ return false;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/commands/SaveChestsCommand.java b/src/notifyz/hardcorefactions/chests/commands/SaveChestsCommand.java
new file mode 100644
index 0000000..4a6c9d7
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/commands/SaveChestsCommand.java
@@ -0,0 +1,36 @@
+package notifyz.hardcorefactions.chests.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.chests.Teller;
+import notifyz.hardcorefactions.chests.Teller.Type;
+import notifyz.hardcorefactions.chests.VirtualChestManager;
+
+public class SaveChestsCommand implements CommandExecutor {
+
+ private final VirtualChestManager chestManager;
+
+ public SaveChestsCommand(VirtualChestManager chestManager) {
+ this.chestManager = chestManager;
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (command.getName().equalsIgnoreCase("savechests")) {
+ if (sender.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-savechests")))) {
+ int savedChests = chestManager.save();
+ Teller.tell(sender, Type.SUCCESS, "Saved " + savedChests + " chests.");
+ } else {
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission")));
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/commands/WorkbenchCommand.java b/src/notifyz/hardcorefactions/chests/commands/WorkbenchCommand.java
new file mode 100644
index 0000000..10533ec
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/commands/WorkbenchCommand.java
@@ -0,0 +1,38 @@
+package notifyz.hardcorefactions.chests.commands;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.chests.Teller;
+import notifyz.hardcorefactions.chests.Teller.Type;
+
+
+public class WorkbenchCommand implements CommandExecutor {
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (command.getName().equalsIgnoreCase("workbench")) {
+ // Make sure the sender is a player
+ if (!(sender instanceof Player)) {
+ Teller.tell(sender, Type.ERROR, "Only players are able to open virtual workbenches.");
+ return true;
+ }
+
+ Player player = (Player) sender;
+
+ if (player.hasPermission(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-configuration.permission-use-workbench")))) {
+ player.openWorkbench(null, true);
+ } else {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("chest-messages.no-permission")));
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/listeners/PlayerListener.java b/src/notifyz/hardcorefactions/chests/listeners/PlayerListener.java
new file mode 100644
index 0000000..f028946
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/listeners/PlayerListener.java
@@ -0,0 +1,64 @@
+package notifyz.hardcorefactions.chests.listeners;
+
+import java.util.List;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.chests.VirtualChestManager;
+
+public class PlayerListener implements Listener {
+
+ private final VirtualChestManager chestManager;
+
+ private boolean clearOnDeath;
+ private boolean dropOnDeath;
+
+ public PlayerListener(HardcoreFactionsPlugin hardcoreFactionsPlugin, VirtualChestManager chestManager) {
+ this.chestManager = chestManager;
+
+ // Load the death event settings
+ clearOnDeath = hardcoreFactionsPlugin.getConfig().getBoolean("clearOnDeath");
+ dropOnDeath = hardcoreFactionsPlugin.getConfig().getBoolean("dropOnDeath");
+ }
+
+ /**
+ * Handles a player's death and clears the chest or drops its contents depending on configuration and permissions.
+ */
+ @EventHandler(ignoreCancelled = true)
+ public void onPlayerDeath(final PlayerDeathEvent event) {
+ final Player player = event.getEntity();
+
+ boolean drop = dropOnDeath;
+ boolean clear = dropOnDeath || clearOnDeath;
+
+ if (player.hasPermission("chest.keepOnDeath")) {
+ drop = false;
+ clear = false;
+ } else if (player.hasPermission("chest.dropOnDeath")) {
+ drop = true;
+ clear = true;
+ } else if (player.hasPermission("chest.clearOnDeath")) {
+ drop = false;
+ clear = true;
+ }
+
+ if (drop) {
+ List drops = event.getDrops();
+ Inventory chest = chestManager.getChest(player.getUniqueId());
+
+ for (int i = 0; i < chest.getSize(); i++) {
+ drops.add(chest.getItem(i));
+ }
+ }
+
+ if (clear) {
+ chestManager.removeChest(player.getUniqueId());
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/chests/utils/BukkitUtil.java b/src/notifyz/hardcorefactions/chests/utils/BukkitUtil.java
new file mode 100644
index 0000000..bbddf39
--- /dev/null
+++ b/src/notifyz/hardcorefactions/chests/utils/BukkitUtil.java
@@ -0,0 +1,25 @@
+package notifyz.hardcorefactions.chests.utils;
+
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+
+public class BukkitUtil {
+
+ /**
+ * Searches for and retrieves an offline player by their name.
+ *
+ * @param name the name to search for
+ * @return the found player or null
+ */
+ public static OfflinePlayer getOfflinePlayerByName(String name) {
+ OfflinePlayer[] offlinePlayers = Bukkit.getOfflinePlayers();
+
+ for (OfflinePlayer player : offlinePlayers) {
+ if (player.getName().equalsIgnoreCase(name)) {
+ return player;
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/PvPClass.java b/src/notifyz/hardcorefactions/classes/PvPClass.java
new file mode 100644
index 0000000..f930c8e
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/PvPClass.java
@@ -0,0 +1,62 @@
+package notifyz.hardcorefactions.classes;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+
+import lombok.Getter;
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+/**
+ * Represents a class that can apply PVP buffs for players.
+ */
+@SuppressWarnings({ "deprecation" })
+public abstract class PvPClass {
+
+ public static final long DEFAULT_MAX_DURATION = TimeUnit.MINUTES.toMillis(8L);
+
+ private final List passiveEffects = new ArrayList<>();
+
+ @Getter
+ protected final String name;
+
+ @Getter
+ protected final long warmupDelay;
+
+ protected void addPassiveEffect(PotionEffect potionEffect) {
+ Objects.requireNonNull(potionEffect);
+ passiveEffects.add(potionEffect);
+ }
+
+ public PvPClass(String name, long warmupDelay) {
+ this.name = name;
+ this.warmupDelay = warmupDelay;
+ }
+
+ public boolean onEquip(Player player) {
+ for (PotionEffect effect : passiveEffects) {
+ player.addPotionEffect(effect, true);
+ }
+ for (String pvpclass : HardcoreFactionsPlugin.getPlugin().getConfig().getStringList("classes.class-equiped")) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', pvpclass).replace("%class%", name));
+ }
+ return true;
+ }
+
+ public void onUnequip(Player player) {
+ for (PotionEffect effect : passiveEffects) {
+ player.removePotionEffect(effect.getType());
+ }
+
+ for (String pvpclass : HardcoreFactionsPlugin.getPlugin().getConfig().getStringList("classes.class-un-equiped")) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', pvpclass).replace("%class%", name));
+ }
+ }
+
+ public abstract boolean isApplicableFor(Player player);
+}
diff --git a/src/notifyz/hardcorefactions/classes/events/PvPClassEquipEvent.java b/src/notifyz/hardcorefactions/classes/events/PvPClassEquipEvent.java
new file mode 100644
index 0000000..2b79205
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/events/PvPClassEquipEvent.java
@@ -0,0 +1,30 @@
+package notifyz.hardcorefactions.classes.events;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+import lombok.Getter;
+import notifyz.hardcorefactions.classes.PvPClass;
+
+public class PvPClassEquipEvent extends PlayerEvent {
+
+ private static final HandlerList handlers = new HandlerList();
+
+ @Getter
+ private final PvPClass PvPClass;
+
+ public PvPClassEquipEvent(Player player, PvPClass PvPClass) {
+ super(player);
+ this.PvPClass = PvPClass;
+ }
+
+ @Override
+ public HandlerList getHandlers() {
+ return handlers;
+ }
+
+ public static HandlerList getHandlerList() {
+ return handlers;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/events/PvPClassUnEquipEvent.java b/src/notifyz/hardcorefactions/classes/events/PvPClassUnEquipEvent.java
new file mode 100644
index 0000000..8ec25f2
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/events/PvPClassUnEquipEvent.java
@@ -0,0 +1,30 @@
+package notifyz.hardcorefactions.classes.events;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+
+import lombok.Getter;
+import notifyz.hardcorefactions.classes.PvPClass;
+
+public class PvPClassUnEquipEvent extends PlayerEvent {
+
+ private static final HandlerList handlers = new HandlerList();
+
+ @Getter
+ private final PvPClass PvPClass;
+
+ public PvPClassUnEquipEvent(Player player, PvPClass PvPClass) {
+ super(player);
+ this.PvPClass = PvPClass;
+ }
+
+ @Override
+ public HandlerList getHandlers() {
+ return handlers;
+ }
+
+ public static HandlerList getHandlerList() {
+ return handlers;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/manager/PvPClassManager.java b/src/notifyz/hardcorefactions/classes/manager/PvPClassManager.java
new file mode 100644
index 0000000..dfc3006
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/manager/PvPClassManager.java
@@ -0,0 +1,95 @@
+package notifyz.hardcorefactions.classes.manager;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import javax.annotation.Nullable;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.plugin.PluginManager;
+
+import lombok.Getter;
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.classes.PvPClass;
+import notifyz.hardcorefactions.classes.events.PvPClassEquipEvent;
+import notifyz.hardcorefactions.classes.events.PvPClassUnEquipEvent;
+import notifyz.hardcorefactions.classes.type.archer.ArcherClass;
+import notifyz.hardcorefactions.classes.type.bard.BardClass;
+import notifyz.hardcorefactions.classes.type.ghost.GhostClass;
+import notifyz.hardcorefactions.classes.type.miner.MinerClass;
+import notifyz.hardcorefactions.classes.type.rogue.RogueClass;
+
+public class PvPClassManager implements Listener {
+
+ private final Map equippedClasses = new HashMap<>();
+
+ @Getter
+ private final List pvpClasses = new ArrayList<>();
+
+ public ArcherClass archerClass;
+
+ public PvPClassManager(HardcoreFactionsPlugin plugin) {
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("classes.archer.enabled")) {
+ pvpClasses.add(archerClass = new ArcherClass(plugin));
+ }
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("classes.bard.enabled")) {
+ pvpClasses.add(new BardClass(plugin));
+ }
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("classes.miner.enabled")) {
+ pvpClasses.add(new MinerClass(plugin));
+ }
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("classes.rogue.enabled")) {
+ pvpClasses.add(new RogueClass(plugin));
+ }
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("classes.ghost.enabled")) {
+ pvpClasses.add(new GhostClass(plugin));
+ }
+ PluginManager manager = plugin.getServer().getPluginManager();
+ manager.registerEvents(this, plugin);
+ pvpClasses.stream().filter(pvpClass -> pvpClass instanceof Listener).forEach(pvpClass -> {
+ manager.registerEvents((Listener) pvpClass, plugin);
+ });
+ }
+
+ public void onDisable() {
+ for (Map.Entry entry : new HashMap<>(equippedClasses).entrySet()) {
+ setEquippedClass(Bukkit.getPlayer(entry.getKey()), null);
+ }
+
+ pvpClasses.clear();
+ equippedClasses.clear();
+ }
+
+ @EventHandler
+ public void onPlayerDeath(PlayerDeathEvent event) {
+ setEquippedClass(event.getEntity(), null);
+ }
+
+ public PvPClass getEquippedClass(Player player) {
+ return equippedClasses.get(player.getUniqueId());
+ }
+
+ public boolean hasClassEquipped(Player player, PvPClass pvpClass) {
+ return getEquippedClass(player) == pvpClass;
+ }
+
+ public void setEquippedClass(Player player, @Nullable PvPClass pvpClass) {
+ if (pvpClass == null) {
+ PvPClass equipped = equippedClasses.remove(player.getUniqueId());
+ if (equipped != null) {
+ equipped.onUnequip(player);
+ Bukkit.getPluginManager().callEvent(new PvPClassUnEquipEvent(player, equipped));
+ }
+ } else if (pvpClass != this.getEquippedClass(player) && pvpClass.onEquip(player)) {
+ equippedClasses.put(player.getUniqueId(), pvpClass);
+ Bukkit.getPluginManager().callEvent(new PvPClassEquipEvent(player, pvpClass));
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/Holder.java b/src/notifyz/hardcorefactions/classes/type/Holder.java
new file mode 100644
index 0000000..cd6ae42
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/Holder.java
@@ -0,0 +1,24 @@
+package notifyz.hardcorefactions.classes.type;
+
+import java.util.UUID;
+
+import org.bukkit.scheduler.BukkitRunnable;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.scoreboard.provider.PvPClassHolder;
+import notifyz.hardcorefactions.utilities.utils.Tuple;
+
+public class Holder implements PvPClassHolder {
+
+ private HardcoreFactionsPlugin plugin;
+
+ public Holder(HardcoreFactionsPlugin plugin) {
+ this.plugin = plugin;
+ }
+
+ @SuppressWarnings("static-access")
+ @Override
+ public Tuple getArcherTag(UUID uuid) {
+ return plugin.getPvPClassManager().archerClass.tagged.get(uuid);
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/archer/ArcherClass.java b/src/notifyz/hardcorefactions/classes/type/archer/ArcherClass.java
new file mode 100644
index 0000000..7e4c2d5
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/archer/ArcherClass.java
@@ -0,0 +1,240 @@
+package notifyz.hardcorefactions.classes.type.archer;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.lang.time.DurationFormatUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Color;
+import org.bukkit.Material;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerKickEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.LeatherArmorMeta;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import net.minecraft.util.gnu.trove.map.TObjectLongMap;
+import net.minecraft.util.gnu.trove.map.hash.TObjectLongHashMap;
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.classes.PvPClass;
+import notifyz.hardcorefactions.classes.events.PvPClassUnEquipEvent;
+import notifyz.hardcorefactions.scoreboard.utilities.PlayerBoard;
+import notifyz.hardcorefactions.utilities.chat.BukkitUtils;
+import notifyz.hardcorefactions.utilities.utils.JavaUtils;
+import notifyz.hardcorefactions.utilities.utils.Tuple;
+
+/**
+ * Represents a {@link PvPClass} used to buff Archer game-play such as Bows.
+ */
+public class ArcherClass extends PvPClass implements Listener {
+
+ private static final int DAMAGE_BONUS_PERCENT = HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.archer.damage-percentage");
+
+ private static final PotionEffect ARCHER_SPEED_EFFECT = new PotionEffect(PotionEffectType.SPEED, 160, 3);
+ private static final long ARCHER_SPEED_COOLDOWN_DELAY = TimeUnit.SECONDS.toMillis(HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.archer.speed-cooldown"));
+
+ public final static Map> tagged = new HashMap<>();//added static
+ public final static TObjectLongMap archerSpeedCooldowns = new TObjectLongHashMap<>();
+
+ public static final HashMap tagged2 = new HashMap<>();
+
+ private final HardcoreFactionsPlugin plugin;
+
+ public ArcherClass(HardcoreFactionsPlugin plugin) {
+ super(HardcoreFactionsPlugin.getInstance().getConfig().getString("classes.archer.name"), JavaUtils.parse(HardcoreFactionsPlugin.getInstance().getConfig().getString("scoreboard.archer-time")));
+ this.plugin = plugin;
+
+ addPassiveEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 1));
+ addPassiveEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 2));
+ }
+
+ private void untag(Player player) {
+ tagged.remove(player.getUniqueId());
+ for (PlayerBoard playerBoard : plugin.getScoreboardHandler().getPlayerBoards().values()) {
+ playerBoard.addUpdates(Bukkit.getOnlinePlayers());
+ }
+ }
+
+ public TObjectLongMap getSpeedCooldown(){
+ return ArcherClass.archerSpeedCooldowns;
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerClassUnequip(PvPClassUnEquipEvent event) {
+ untag(event.getPlayer());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerDeath(PlayerDeathEvent event) {
+ untag(event.getEntity());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerQuit(PlayerQuitEvent event) {
+ untag(event.getPlayer());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerKick(PlayerKickEvent event) {
+ untag(event.getPlayer());
+ }
+
+ private static final long TAG_DURATION = TimeUnit.SECONDS.toMillis(10L);
+ private static final long TAG_DURATION_TICKS = TAG_DURATION / 50L;
+ private static final String TAG_DURATION_WORDS = DurationFormatUtils.formatDurationWords(TAG_DURATION,true,true);
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+ public void onEntityDamage(EntityDamageByEntityEvent event) {
+ Entity entity = event.getEntity();
+ Player attacker = BukkitUtils.getFinalAttacker(event, true);
+ if (attacker != null && !attacker.equals(entity) && entity instanceof Player) {
+ Player attacked = (Player) entity;
+
+ Tuple tuple = tagged.get(attacked.getUniqueId());
+
+ if (event.getDamager() instanceof Arrow && plugin.getPvPClassManager().getEquippedClass(attacker) instanceof ArcherClass) {
+ if (plugin.getPvPClassManager().getEquippedClass(attacked) instanceof ArcherClass) {
+ attacker.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.archer.cannot-tag-archers")));
+ return;
+ }
+
+ if (tuple != null) {
+ tuple.getValue().cancel();
+ }
+
+ BukkitRunnable runnable = new BukkitRunnable() {
+ @Override
+ public void run() {
+ untag(attacked);
+ }
+ };
+ LeatherArmorMeta helmMeta = (LeatherArmorMeta)attacker.getInventory().getHelmet().getItemMeta();
+ LeatherArmorMeta chestMeta = (LeatherArmorMeta)attacker.getInventory().getChestplate().getItemMeta();
+ LeatherArmorMeta leggingsMeta = (LeatherArmorMeta)attacker.getInventory().getLeggings().getItemMeta();
+ LeatherArmorMeta bootsMeta = (LeatherArmorMeta)attacker.getInventory().getBoots().getItemMeta();
+
+ if (plugin.getConfig().getBoolean("classes.archer.use-colorful-armor")) {
+ Color green = Color.fromRGB(6717235);
+ if ((helmMeta.getColor().equals(green)) && (chestMeta.getColor().equals(green)) && (leggingsMeta.getColor().equals(green)) && (bootsMeta.getColor().equals(green)))
+ {
+ attacked.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 120, 0));
+ attacker.sendMessage(ChatColor.translateAlternateColorCodes('&', "&c&lPoison! &eSince your armor is green, you gave " + attacked.getName() + " the poison effect for 6 seconds."));
+ attacked.sendMessage(ChatColor.translateAlternateColorCodes('&', "&2&lPoison! &aSince " + attacker.getName() + "'s armor is green, you were given the poison effect for 6 seconds."));
+ }
+ Color blue = Color.fromRGB(3361970);
+ if ((helmMeta.getColor().equals(blue)) && (chestMeta.getColor().equals(blue)) && (leggingsMeta.getColor().equals(blue)) && (bootsMeta.getColor().equals(blue)))
+ {
+ attacked.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 120, 0));
+ attacker.sendMessage(ChatColor.translateAlternateColorCodes('&', "&c&lSlowness! &eSince your armor is blue, you gave " + attacked.getName() + " the slowness effect for 6 seconds."));
+ attacked.sendMessage(ChatColor.translateAlternateColorCodes('&', "&3&lSlowness! &bSince " + attacker.getName() + "'s armor is blue, you were given the slowness effect for 6 seconds."));
+ }
+ Color gray = Color.fromRGB(5000268);
+ if ((helmMeta.getColor().equals(gray)) && (chestMeta.getColor().equals(gray)) && (leggingsMeta.getColor().equals(gray)) && (bootsMeta.getColor().equals(gray)))
+ {
+ attacked.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, 120, 0));
+ attacker.sendMessage(ChatColor.translateAlternateColorCodes('&', "&c&lBlindness! &eSince your armor is gray, you gave " + attacked.getName() + " the blindness effect for 6 seconds."));
+ attacked.sendMessage(ChatColor.translateAlternateColorCodes('&', "&8&lBlindness! &7Since " + attacker.getName() + "'s armor is gray, you were given the blindness effect for 6 seconds."));
+ }
+ Color black = Color.fromRGB(1644825);
+ if ((helmMeta.getColor().equals(black)) && (chestMeta.getColor().equals(black)) && (leggingsMeta.getColor().equals(black)) && (bootsMeta.getColor().equals(black)))
+ {
+ attacked.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, 120, 0));
+ attacker.sendMessage(ChatColor.translateAlternateColorCodes('&', "&c&lWither! &eSince your armor is black, you gave " + attacked.getName() + " the wither effect for 6 seconds."));
+ attacked.sendMessage(ChatColor.translateAlternateColorCodes('&', "&7&lWither! &fSince " + attacker.getName() + "'s armor is black, you were given the wither effect for 6 seconds."));
+ }
+ }
+
+ /*attacker.sendMessage(ChatColor.RED + "You have tagged " + attacked.getName()
+ + " for " + TAG_DURATION_WORDS + ", their received damage will be " + DAMAGE_BONUS_PERCENT + "% higher.");
+ attacked.sendMessage(ChatColor.RED + "You have been archer tagged for " + TAG_DURATION_WORDS
+ + ", received damage will be " + DAMAGE_BONUS_PERCENT + "% higher."); */
+ double distance = attacker.getLocation().distance(attacked.getLocation());
+ attacker.sendMessage(ChatColor.translateAlternateColorCodes('&', ("&e[&9Arrow Range &e(&c" + String.format("%.0f", Double.valueOf(distance)) + "&e)] " + "&6Marked " + attacked.getName() + " &6for 10 seconds. &9&l(1 heart)")));
+ attacked.sendMessage(ChatColor.translateAlternateColorCodes('&', "&c&lMarked! &eAn archer has shot you and marked you (+" + DAMAGE_BONUS_PERCENT + "&e% damage) for " + TAG_DURATION_WORDS + '.'));
+ //attacker.sendMessage(ChatColor.GOLD + "You have marked " + ChatColor.YELLOW + attacked.getName() + ChatColor.GOLD + " for " + ChatColor.AQUA + TAG_DURATION_WORDS + ChatColor.GOLD + "." + ChatColor.GRAY + " (" + DAMAGE_BONUS_PERCENT + "% damage)");
+ //attacked.sendMessage(ChatColor.RED.toString() + "MARKED! " + ChatColor.GOLD + "You are now " + ChatColor.YELLOW + "Archer Tagged " + ChatColor.GOLD + "for " + ChatColor.AQUA + TAG_DURATION_WORDS + ChatColor.GOLD + " by " + attacker.getName() + "." + ChatColor.GRAY + " (" + DAMAGE_BONUS_PERCENT + "% damage)");
+ runnable.runTaskLater(plugin, TAG_DURATION_TICKS);
+
+
+ tagged.put(attacked.getUniqueId(), tuple = new Tuple<>(System.currentTimeMillis() + TAG_DURATION, runnable));
+ for (PlayerBoard playerBoard : plugin.getScoreboardHandler().getPlayerBoards().values()) {
+ playerBoard.addUpdates(Bukkit.getOnlinePlayers());
+ }
+ }
+
+ if (tuple != null) {
+ long remaining = tuple.getKey() - System.currentTimeMillis();
+ if (remaining > 0L) {
+ event.setDamage(event.getDamage() * (1.0 + (DAMAGE_BONUS_PERCENT / 100.0)));
+ }
+ }
+ }
+ }
+
+ @EventHandler(ignoreCancelled = false, priority = EventPriority.HIGH)
+ public void onPlayerInteract(PlayerInteractEvent event) {
+ Action action = event.getAction();
+ if (action == Action.RIGHT_CLICK_AIR || action == Action.RIGHT_CLICK_BLOCK) {
+ if (event.hasItem() && event.getItem().getType() == Material.SUGAR) {
+ if (plugin.getPvPClassManager().getEquippedClass(event.getPlayer()) != this) {
+ return;
+ }
+
+ Player player = event.getPlayer();
+ UUID uuid = player.getUniqueId();
+ long timestamp = archerSpeedCooldowns.get(uuid);
+ long millis = System.currentTimeMillis();
+ long remaining = timestamp == archerSpeedCooldowns.getNoEntryValue() ? -1L : timestamp - millis;
+ if (remaining > 0L) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.archer.speed-cooldown").replace("%cooldown%", DurationFormatUtils.formatDurationWords(remaining, true, true))));
+ } else {
+ ItemStack stack = player.getItemInHand();
+ if (stack.getAmount() == 1) {
+ player.setItemInHand(new ItemStack(Material.AIR, 1));
+ } else {
+ stack.setAmount(stack.getAmount() - 1);
+ }
+
+ plugin.getEffectRestorer().setRestoreEffect(player, ARCHER_SPEED_EFFECT);
+ archerSpeedCooldowns.put(event.getPlayer().getUniqueId(), System.currentTimeMillis() + ARCHER_SPEED_COOLDOWN_DELAY);
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean isApplicableFor(Player player) {
+ PlayerInventory playerInventory = player.getInventory();
+
+ ItemStack helmet = playerInventory.getHelmet();
+ if (helmet == null || helmet.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.archer.equipment.helmet")))
+ return false;
+
+ ItemStack chestplate = playerInventory.getChestplate();
+ if (chestplate == null || chestplate.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.archer.equipment.chestplate")))
+ return false;
+
+ ItemStack leggings = playerInventory.getLeggings();
+ if (leggings == null || leggings.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.archer.equipment.leggings")))
+ return false;
+
+ ItemStack boots = playerInventory.getBoots();
+ return !(boots == null || boots.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.archer.equipment.boots")));
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/bard/BardClass.java b/src/notifyz/hardcorefactions/classes/type/bard/BardClass.java
new file mode 100644
index 0000000..63038b1
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/bard/BardClass.java
@@ -0,0 +1,340 @@
+package notifyz.hardcorefactions.classes.type.bard;
+
+import java.util.Collection;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerItemHeldEvent;
+import org.bukkit.event.player.PlayerKickEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import gnu.trove.map.TObjectLongMap;
+import gnu.trove.map.hash.TObjectLongHashMap;
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.classes.PvPClass;
+import notifyz.hardcorefactions.classes.type.bard.utilties.BardData;
+import notifyz.hardcorefactions.classes.type.bard.utilties.BardEffect;
+import notifyz.hardcorefactions.team.type.PlayerTeam;
+import notifyz.hardcorefactions.team.utilities.ITeam;
+import notifyz.hardcorefactions.utilities.chat.BukkitUtils;
+import notifyz.hardcorefactions.utilities.chat.Lang;
+
+@SuppressWarnings("deprecation")
+public class BardClass extends PvPClass implements Listener {
+
+ public static final long HELD_EFFECT_DURATION_TICKS = TimeUnit.SECONDS.toMillis(HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.bard.buff-duration")); // the amount of time in ticks to apply a Held potion effect for faction members
+
+ private static final long BUFF_COOLDOWN_MILLIS = TimeUnit.SECONDS.toMillis(HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.bard.buff-cooldown")); // time in milliseconds for Bard buff cooldowns
+ private static final int TEAMMATE_NEARBY_RADIUS = HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.bard.teammate-nearby");
+ private static final long HELD_REAPPLY_TICKS = 20L;
+ @SuppressWarnings("unused")
+ private static final String MARK = BukkitUtils.STRAIGHT_LINE_DEFAULT.substring(0, 8);
+ private final Map bardDataMap = new HashMap<>();
+ private final Map bardEffects = new EnumMap<>(Material.class);
+ private final HardcoreFactionsPlugin plugin;
+ private final TObjectLongMap msgCooldowns = new TObjectLongHashMap<>();
+
+ public BardClass(HardcoreFactionsPlugin plugin) {
+ super(HardcoreFactionsPlugin.getInstance().getConfig().getString("classes.bard.name"), TimeUnit.SECONDS.toMillis(1L));
+ this.plugin = plugin;
+
+ addPassiveEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 1));
+ addPassiveEffect(new PotionEffect(PotionEffectType.REGENERATION, Integer.MAX_VALUE, 0));
+ addPassiveEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 1));
+
+ this.bardEffects.put(Material.FERMENTED_SPIDER_EYE, new BardEffect(60, new PotionEffect(PotionEffectType.INVISIBILITY, 120, 1),new PotionEffect(PotionEffectType.INVISIBILITY, 100, 0)));
+ this.bardEffects.put(Material.WHEAT, new BardEffect(35, new PotionEffect(PotionEffectType.SATURATION, 120, 1), new PotionEffect(PotionEffectType.SATURATION, 100, 0)));
+ this.bardEffects.put(Material.SUGAR, new BardEffect(25, new PotionEffect(PotionEffectType.SPEED, 120, 2), new PotionEffect(PotionEffectType.SPEED, 100, 1)));
+ this.bardEffects.put(Material.BLAZE_POWDER, new BardEffect(50, new PotionEffect(PotionEffectType.INCREASE_DAMAGE, 120, 1), new PotionEffect(PotionEffectType.INCREASE_DAMAGE, 100, 0)));
+ this.bardEffects.put(Material.IRON_INGOT, new BardEffect(35, new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, 80, 2), new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, 100, 0)));
+ this.bardEffects.put(Material.GHAST_TEAR, new BardEffect(45, new PotionEffect(PotionEffectType.REGENERATION, 60, 2), new PotionEffect(PotionEffectType.REGENERATION, 100, 0)));
+ this.bardEffects.put(Material.FEATHER, new BardEffect(30, new PotionEffect(PotionEffectType.JUMP, 120, 5), new PotionEffect(PotionEffectType.JUMP, 100, 0)));
+ this.bardEffects.put(Material.SPIDER_EYE, new BardEffect(50, new PotionEffect(PotionEffectType.WITHER, 100, 1), null));
+ this.bardEffects.put(Material.MAGMA_CREAM, new BardEffect(10, new PotionEffect(PotionEffectType.FIRE_RESISTANCE, 900, 0), new PotionEffect(PotionEffectType.FIRE_RESISTANCE, 120, 0)));
+ }
+
+ @Override
+ public boolean onEquip(Player player) {
+ if (HardcoreFactionsPlugin.getPlugin().getTimerManager().getInvincibilityTimer().getRemainingCooldown(player) > 0L) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.bard.cannot-equip-class")));
+ return false;
+ }
+
+ if (!super.onEquip(player)) {
+ return false;
+ }
+
+ BardData bardData = new BardData();
+ bardDataMap.put(player.getUniqueId(), bardData);
+ bardData.startEnergyTracking();
+ bardData.heldTask = new BukkitRunnable() {
+ int lastEnergy;
+
+ @Override
+ public void run() {
+ // Apply the bard effects here.
+ ItemStack held = player.getItemInHand();
+ if (held != null) {
+ BardEffect bardEffect = bardEffects.get(held.getType());
+ if (bardEffect == null || bardEffect.heldable == null) {
+ return;
+ }
+
+ if (bardEffect.heldable.getType() == PotionEffectType.JUMP) {
+ plugin.getEffectRestorer().setRestoreEffect(player, bardEffect.heldable);
+ }
+
+ if (!HardcoreFactionsPlugin.getPlugin().getFactionManager().getFactionAt(player.getLocation()).isSafezone()) {
+ // Apply the held effect to faction members.
+ PlayerTeam playerFaction = HardcoreFactionsPlugin.getPlugin().getFactionManager().getPlayerFaction(player);
+ if (playerFaction != null) {
+ Collection nearbyEntities = player.getNearbyEntities(TEAMMATE_NEARBY_RADIUS, TEAMMATE_NEARBY_RADIUS, TEAMMATE_NEARBY_RADIUS);
+ for (Entity nearby : nearbyEntities) {
+ if (nearby instanceof Player && !player.equals(nearby)) {
+ Player target = (Player) nearby;
+ if (playerFaction.getMembers().containsKey(target.getUniqueId())) {
+ plugin.getEffectRestorer().setRestoreEffect(target, bardEffect.heldable);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ int energy = (int) getEnergy(player);
+ // the -1 check is for offsets with the energy per millisecond
+ if (energy != 0 && energy != lastEnergy && (energy % 10 == 0 || lastEnergy - energy - 1 > 0 || energy == BardData.MAX_ENERGY)) {
+ lastEnergy = energy;
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.bard.energy-announcer").replace("%energy%", energy + "")));
+ }
+ }
+ }.runTaskTimer(plugin, 0L, HELD_REAPPLY_TICKS);
+ return true;
+ }
+
+ @Override
+ public void onUnequip(Player player) {
+ super.onUnequip(player);
+ clearBardData(player.getUniqueId());
+ }
+
+ private void clearBardData(UUID uuid) {
+ BardData bardData = bardDataMap.remove(uuid);
+ if (bardData != null && bardData.getHeldTask() != null) {
+ bardData.getHeldTask().cancel();
+ }
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerQuit(PlayerQuitEvent event) {
+ clearBardData(event.getPlayer().getUniqueId());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerKick(PlayerKickEvent event) {
+ clearBardData(event.getPlayer().getUniqueId());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onItemHeld(PlayerItemHeldEvent event) {
+ Player player = event.getPlayer();
+ PvPClass equipped = plugin.getPvPClassManager().getEquippedClass(player);
+ if (equipped == null || !equipped.equals(this)) {
+ return;
+ }
+
+ UUID uuid = player.getUniqueId();
+ long lastMessage = msgCooldowns.get(uuid);
+ long millis = System.currentTimeMillis();
+ if (lastMessage != msgCooldowns.getNoEntryValue() && lastMessage - millis > 0L) {
+ return;
+ }
+
+ ItemStack newStack = player.getInventory().getItem(event.getNewSlot());
+ if (newStack != null) {
+ BardEffect bardEffect = bardEffects.get(newStack.getType());
+ if (bardEffect != null) {
+ msgCooldowns.put(uuid, millis + 1500L);
+ //player.sendMessage(ChatColor.GOLD + "Bard Effect: " + ChatColor.GOLD);
+ //player.sendMessage(ChatColor.GOLD + "\u00bb " + ChatColor.YELLOW + "Clickable Effect: " + ChatColor.AQUA + Lang.fromPotionEffectType(bardEffect.clickable.getType()) + ' ' + (bardEffect.clickable.getAmplifier() + 1) + ChatColor.GRAY + " (" + (bardEffect.clickable.getDuration() / 20) + "s)");
+ //player.sendMessage(ChatColor.GOLD + "\u00bb " + ChatColor.YELLOW + "Energy Cost: " + ChatColor.AQUA + bardEffect.energyCost);
+ if (HardcoreFactionsPlugin.getInstance().getConfig().getBoolean("classes.bard.held-item-message")) {
+ for (String bard : HardcoreFactionsPlugin.getPlugin().getConfig().getStringList("classes.bard.effect-message")) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', bard).replace("%energycost%", Integer.toString(bardEffect.energyCost)).replace("%effect%", Lang.fromPotionEffectType(bardEffect.clickable.getType()) + ' ' + (bardEffect.clickable.getAmplifier() + 1) + ChatColor.GRAY + " (" + (bardEffect.clickable.getDuration() / 20) + "s)"));
+ }
+ }
+ }
+ }
+ }
+
+ @EventHandler(ignoreCancelled = false, priority = EventPriority.MONITOR)
+ public void onPlayerInteract(final PlayerInteractEvent event) {
+ if (!event.hasItem()) {
+ return;
+ }
+ final Action action = event.getAction();
+ if (action == Action.RIGHT_CLICK_AIR || (!event.isCancelled() && action == Action.RIGHT_CLICK_BLOCK)) {
+ final ItemStack stack = event.getItem();
+ final BardEffect bardEffect = this.bardEffects.get(stack.getType());
+ if (bardEffect == null || bardEffect.clickable == null) {
+ return;
+ }
+ event.setUseItemInHand(Event.Result.DENY);
+ final Player player = event.getPlayer();
+ final BardData bardData = this.bardDataMap.get(player.getUniqueId());
+ if (bardData != null) {
+ if (!this.canUseBardEffect(player, bardData, bardEffect, true)) {
+ return;
+ }
+ if (stack.getAmount() > 1) {
+ stack.setAmount(stack.getAmount() - 1);
+ HardcoreFactionsPlugin.getPlugin().getTimerManager().getCombatTimer().setCooldown(player, player.getUniqueId());
+ } else {
+ player.setItemInHand(new ItemStack(Material.AIR, 1));
+ }
+ if (bardEffect != null && !HardcoreFactionsPlugin.getPlugin().getFactionManager().getFactionAt(player.getLocation()).isSafezone()) {
+ final PlayerTeam playerFaction = HardcoreFactionsPlugin.getPlugin().getFactionManager().getPlayerFaction(player);
+ if (playerFaction != null && !bardEffect.clickable.getType().equals(PotionEffectType.WITHER)) {
+ final Collection nearbyEntities = player.getNearbyEntities(25.0, 25.0, 25.0);
+ for (final Entity nearby : nearbyEntities) {
+ if (nearby instanceof Player && !player.equals(nearby)) {
+ final Player target = (Player) nearby;
+ if (!playerFaction.getMembers().containsKey(target.getUniqueId())) {
+ continue;
+ }
+ plugin.getEffectRestorer().setRestoreEffect(target, bardEffect.clickable);
+ }
+ }
+ } else if (playerFaction != null && bardEffect.clickable.getType().equals(PotionEffectType.WITHER)) {
+ final Collection nearbyEntities = player.getNearbyEntities(25.0, 25.0, 25.0);
+ for (final Entity nearby : nearbyEntities) {
+ if (nearby instanceof Player && !player.equals(nearby)) {
+ final Player target = (Player) nearby;
+ if (playerFaction.getMembers().containsKey(target.getUniqueId())) {
+ continue;
+ }
+ HardcoreFactionsPlugin.getPlugin().getTimerManager().getCombatTimer().setCooldown(target, target.getUniqueId());
+ plugin.getEffectRestorer().setRestoreEffect(target, bardEffect.clickable);
+ }
+ }
+ } else if (bardEffect.clickable.getType().equals(PotionEffectType.WITHER)) {
+ final Collection nearbyEntities = player.getNearbyEntities(25.0, 25.0, 25.0);
+ for (final Entity nearby : nearbyEntities) {
+ if (nearby instanceof Player && !player.equals(nearby)) {
+ final Player target = (Player) nearby;
+ plugin.getEffectRestorer().setRestoreEffect(target, bardEffect.clickable);
+ }
+ }
+ }
+ }
+ plugin.getEffectRestorer().setRestoreEffect(player, bardEffect.clickable);
+ bardData.setBuffCooldown(BUFF_COOLDOWN_MILLIS);
+
+ @SuppressWarnings("unused")
+ double newEnergy = this.setEnergy(player, bardData.getEnergy() - bardEffect.energyCost);
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.bard.buff-used").replace("%cost%", bardEffect.energyCost + "")));
+ //player.sendMessage(ChatColor.GOLD + "You have just used " + name + " buff " + ChatColor.RED + Lang.fromPotionEffectType(bardEffect.clickable.getType()) + ' '
+ // + (bardEffect.clickable.getAmplifier() + 1) + ChatColor.GOLD + " costing you " + ChatColor.BOLD + bardEffect.energyCost + ChatColor.YELLOW + " energy. "
+ // + "Your energy is now " + ChatColor.GREEN + ((newEnergy * 10.0) / 10.0)/* TODO:neeeded? */+ ChatColor.YELLOW + '.');
+ }
+ }
+ }
+
+ private boolean canUseBardEffect(Player player, BardData bardData, BardEffect bardEffect, boolean sendFeedback) {
+ String errorFeedback = null;
+ double currentEnergy = bardData.getEnergy();
+ if (bardEffect.energyCost > currentEnergy) {
+ errorFeedback = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.bard.no-enough-energy").replace("%energy%", currentEnergy + "").replace("%cost%", bardEffect.energyCost + ""));
+ }
+
+ long remaining = bardData.getRemainingBuffDelay() / 1000;
+ if (remaining > 0L) {
+ errorFeedback = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.bard.buff-cooldown").replace("%cooldown%", remaining + ""));
+ }
+
+ ITeam factionAt = HardcoreFactionsPlugin.getPlugin().getFactionManager().getFactionAt(player.getLocation());
+ if (factionAt.isSafezone()) {
+ errorFeedback = ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.bard.buff-in-safezone"));
+ }
+
+ if (sendFeedback && errorFeedback != null) {
+ player.sendMessage(errorFeedback);
+ }
+
+ return errorFeedback == null;
+ }
+
+ @Override
+ public boolean isApplicableFor(Player player) {
+ ItemStack helmet = player.getInventory().getHelmet();
+ if (helmet == null || helmet.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.bard.equipment.helmet"))) return false;
+
+ ItemStack chestplate = player.getInventory().getChestplate();
+ if (chestplate == null || chestplate.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.bard.equipment.chestplate"))) return false;
+
+ ItemStack leggings = player.getInventory().getLeggings();
+ if (leggings == null || leggings.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.bard.equipment.leggings"))) return false;
+
+ ItemStack boots = player.getInventory().getBoots();
+ return !(boots == null || boots.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.bard.equipment.boots")));
+ }
+
+ public long getRemainingBuffDelay(Player player) {
+ synchronized (bardDataMap) {
+ BardData bardData = bardDataMap.get(player.getUniqueId());
+ return bardData == null ? 0L : bardData.getRemainingBuffDelay();
+ }
+ }
+
+ /**
+ * Gets the energy of a {@link Player}.
+ *
+ * @param player the {@link Player} to get for
+ * @return the energy, or 0 if not tracking this player
+ */
+ public double getEnergy(Player player) {
+ synchronized (bardDataMap) {
+ BardData bardData = bardDataMap.get(player.getUniqueId());
+ return bardData == null ? 0 : bardData.getEnergy();
+ }
+ }
+
+ public long getEnergyMillis(Player player) {
+ synchronized (bardDataMap) {
+ BardData bardData = bardDataMap.get(player.getUniqueId());
+ return bardData == null ? 0 : bardData.getEnergyMillis();
+ }
+ }
+
+ /**
+ * Sets the energy of a {@link Player}.
+ *
+ * @param player the {@link Player} to set for
+ * @param energy the energy amount to set
+ * @return the new energy amount
+ */
+ public double setEnergy(Player player, double energy) {
+ BardData bardData = bardDataMap.get(player.getUniqueId());
+ if (bardData == null) return 0.0;
+
+ bardData.setEnergy(energy);
+ return bardData.getEnergy();
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/bard/utilties/BardData.java b/src/notifyz/hardcorefactions/classes/type/bard/utilties/BardData.java
new file mode 100644
index 0000000..3dcf4c2
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/bard/utilties/BardData.java
@@ -0,0 +1,66 @@
+package notifyz.hardcorefactions.classes.type.bard.utilties;
+
+import org.bukkit.scheduler.BukkitTask;
+
+import com.google.common.base.Preconditions;
+
+import lombok.Getter;
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.classes.type.bard.BardClass;
+
+/**
+ * Holds data about a {@link BardClass}.
+ */
+public class BardData {
+
+ public static final double ENERGY_PER_MILLISECOND = HardcoreFactionsPlugin.getInstance().getConfig().getDouble("classes.bard.energy-per-second");
+ public static final double MIN_ENERGY = 0.0D;
+ public static final double MAX_ENERGY = HardcoreFactionsPlugin.getInstance().getConfig().getDouble("classes.bard.max-energy");
+ public static final long MAX_ENERGY_MILLIS = (long) (MAX_ENERGY * 1000L);
+
+ @Getter
+ private long buffCooldown;
+
+ @Getter
+ public BukkitTask heldTask; //TODO: find a way to make private
+
+ private long energyStart;
+
+ public void setBuffCooldown(long millis) {
+ this.buffCooldown = System.currentTimeMillis() + millis;
+ }
+
+ public long getRemainingBuffDelay() {
+ return this.buffCooldown - System.currentTimeMillis();
+ }
+
+ /**
+ * Begins tracking energy.
+ */
+ public void startEnergyTracking() {
+ this.setEnergy(0);
+ }
+
+ /**
+ * Gets the energy in milliseconds.
+ *
+ * @return energy in milliseconds
+ */
+ public long getEnergyMillis() {
+ if (this.energyStart == 0L) {
+ return 0L;
+ }
+
+ return Math.min(MAX_ENERGY_MILLIS, (long) (ENERGY_PER_MILLISECOND * (System.currentTimeMillis() - this.energyStart)));
+ }
+
+ public double getEnergy() {
+ return Math.round(this.getEnergyMillis() / MAX_ENERGY) / 10.0;
+ }
+
+ public void setEnergy(double energy) {
+ Preconditions.checkArgument(energy >= MIN_ENERGY, "Energy cannot be less than " + MIN_ENERGY);
+ Preconditions.checkArgument(energy <= MAX_ENERGY, "Energy cannot be more than " + MAX_ENERGY);
+ this.energyStart = (long) (System.currentTimeMillis() - (1000L * energy));
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/bard/utilties/BardEffect.java b/src/notifyz/hardcorefactions/classes/type/bard/utilties/BardEffect.java
new file mode 100644
index 0000000..213172b
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/bard/utilties/BardEffect.java
@@ -0,0 +1,21 @@
+package notifyz.hardcorefactions.classes.type.bard.utilties;
+
+import org.bukkit.potion.PotionEffect;
+
+import notifyz.hardcorefactions.classes.type.bard.BardClass;
+
+/**
+ * Represents a {@link BardClass} effect.
+ */
+public class BardEffect {
+
+ public final int energyCost;
+ public final PotionEffect clickable;
+ public final PotionEffect heldable;
+
+ public BardEffect(int energyCost, PotionEffect clickable, PotionEffect heldable) {
+ this.energyCost = energyCost;
+ this.clickable = clickable;
+ this.heldable = heldable;
+ }
+}
\ No newline at end of file
diff --git a/src/notifyz/hardcorefactions/classes/type/bard/utilties/EffectRestorer.java b/src/notifyz/hardcorefactions/classes/type/bard/utilties/EffectRestorer.java
new file mode 100644
index 0000000..d53f1e8
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/bard/utilties/EffectRestorer.java
@@ -0,0 +1,76 @@
+package notifyz.hardcorefactions.classes.type.bard.utilties;
+
+import java.util.Collection;
+import java.util.UUID;
+
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PotionEffectExpireEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+
+import notifyz.hardcorefactions.classes.PvPClass;
+import notifyz.hardcorefactions.classes.events.PvPClassUnEquipEvent;
+import notifyz.hardcorefactions.classes.type.bard.BardClass;
+
+public class EffectRestorer implements Listener {
+
+ private final Table restores = HashBasedTable.create();
+
+ public EffectRestorer(JavaPlugin plugin) {
+ plugin.getServer().getPluginManager().registerEvents(this, plugin);
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPvpClassUnequip(PvPClassUnEquipEvent event) {
+ restores.rowKeySet().remove(event.getPlayer().getUniqueId());
+ }
+
+ public void setRestoreEffect(Player player, PotionEffect effect) {
+ boolean shouldCancel = true;
+ Collection activeList = player.getActivePotionEffects();
+ for (PotionEffect active : activeList) {
+ if (!active.getType().equals(effect.getType())) continue;
+
+ // If the current potion effect has a higher amplifier, ignore this one.
+ if (effect.getAmplifier() < active.getAmplifier()) {
+ return;
+ } else if (effect.getAmplifier() == active.getAmplifier()) {
+ // If the current potion effect has a longer duration, ignore this one.
+ if (effect.getDuration() < active.getDuration()) {
+ return;
+ }
+ }
+
+ restores.put(player.getUniqueId(), active.getType(), active);
+ shouldCancel = false;
+ break;
+ }
+
+ // Cancel the previous restore.
+ player.addPotionEffect(effect, true);
+ if (shouldCancel && effect.getDuration() > BardClass.HELD_EFFECT_DURATION_TICKS && effect.getDuration() < PvPClass.DEFAULT_MAX_DURATION) {
+ restores.remove(player.getUniqueId(), effect.getType());
+ }
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPotionEffectExpire(PotionEffectExpireEvent event) {
+ LivingEntity livingEntity = event.getEntity();
+ if (livingEntity instanceof Player) {
+ Player player = (Player) livingEntity;
+ PotionEffect previous = restores.remove(player.getUniqueId(), event.getEffect().getType());
+ if (previous != null) {
+ event.setCancelled(true);
+ player.addPotionEffect(previous, true);
+ }
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/ghost/GhostClass.java b/src/notifyz/hardcorefactions/classes/type/ghost/GhostClass.java
new file mode 100644
index 0000000..e931c34
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/ghost/GhostClass.java
@@ -0,0 +1,237 @@
+package notifyz.hardcorefactions.classes.type.ghost;
+
+import java.util.HashMap;
+import java.util.concurrent.TimeUnit;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.classes.PvPClass;
+import notifyz.hardcorefactions.classes.events.PvPClassUnEquipEvent;
+import notifyz.hardcorefactions.utilities.chat.Cooldowns;
+
+
+
+public class GhostClass
+ extends PvPClass
+ implements Listener
+{
+ private HardcoreFactionsPlugin plugin;
+ public HashMap firstAssassinEffects;
+ public HashMap modes;
+ public GhostClass(HardcoreFactionsPlugin plugin)
+ {
+ super(HardcoreFactionsPlugin.getInstance().getConfig().getString("classes.ghost.name"), TimeUnit.SECONDS.toMillis(1L));
+ this.firstAssassinEffects = new HashMap<>();
+ this.modes = new HashMap<>();
+ this.plugin = plugin;
+ addPassiveEffect(new PotionEffect(PotionEffectType.FIRE_RESISTANCE, Integer.MAX_VALUE, 0));
+ addPassiveEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 1));
+ addPassiveEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 1));
+ }
+
+ @EventHandler
+ public void onUnEquip(PvPClassUnEquipEvent e)
+ {
+ Player p = e.getPlayer();
+ for (Player on : Bukkit.getOnlinePlayers()) {
+ if ((!on.canSee(p)) && (!on.hasPermission("hcf.command.staffmode"))) {
+ on.showPlayer(p);
+ }
+ }
+ this.firstAssassinEffects.remove(p);
+ }
+
+ @EventHandler
+ public void onDamageSelf(EntityDamageEvent e)
+ {
+ if ((e.getEntity() instanceof Player))
+ {
+ Player p = (Player)e.getEntity();
+ if ((this.plugin.getPvPClassManager().getEquippedClass(p) == null) || (!this.plugin.getPvPClassManager().getEquippedClass(p).equals(this))) {
+ return;
+ }
+ if ((this.firstAssassinEffects.containsKey(p.getName())) && (this.firstAssassinEffects.get(p.getName()).intValue() == 1)) {
+ for (Entity entity : p.getNearbyEntities(20.0D, 20.0D, 20.0D)) {
+ if ((entity instanceof Player))
+ {
+ Player players = (Player)entity;
+ players.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.ghost.damage-near")));
+ }
+ }
+ }
+ }
+ }
+
+ @EventHandler
+ public void onHitOtherPlayers(EntityDamageByEntityEvent e)
+ {
+ if (((e.getDamager() instanceof Player)) && ((e.getEntity() instanceof Player)))
+ {
+ Player p = (Player)e.getDamager();
+ if ((this.firstAssassinEffects.containsKey(p.getName())) && (this.firstAssassinEffects.get(p.getName()).intValue() == 1)) {
+ afterFiveSeconds(p, true);
+ }
+ }
+ }
+
+ @EventHandler
+ public void onClickItem(PlayerInteractEvent e)
+ {
+ Player p = e.getPlayer();
+ if ((e.getAction() == Action.RIGHT_CLICK_BLOCK) || (e.getAction() == Action.RIGHT_CLICK_AIR))
+ {
+ PvPClass equipped = this.plugin.getPvPClassManager().getEquippedClass(p);
+ if ((equipped == null) || (!equipped.equals(this))) {
+ return;
+ }
+ if (p.getItemInHand().getType() == Material.QUARTZ)
+ {
+ if (Cooldowns.isOnCooldown("Assassin_item_cooldown", p))
+ {
+ p.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.ghost.cooldown").replace("%cooldown%", HardcoreFactionsPlugin.getRemaining(Cooldowns.getCooldownForPlayerLong("Assassin_item_cooldown", p), true))));
+ return;
+ }
+ if (p.getItemInHand().getAmount() == 1) {
+ p.getInventory().remove(p.getItemInHand());
+ }
+ p.getItemInHand().setAmount(p.getItemInHand().getAmount() - 1);
+ p.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.ghost.stealth-mode")));
+ for (Player on : Bukkit.getOnlinePlayers())
+ {
+ on.playEffect(p.getLocation().add(0.5D, 2.0D, 0.5D), Effect.ENDER_SIGNAL, 5);
+ on.playEffect(p.getLocation().add(0.5D, 1.5D, 0.5D), Effect.ENDER_SIGNAL, 5);
+ on.playEffect(p.getLocation().add(0.5D, 1.0D, 0.5D), Effect.ENDER_SIGNAL, 5);
+ on.playSound(p.getLocation(), Sound.ENDERMAN_TELEPORT, 1.0F, 1.0F);
+ if (!on.hasPermission("hcf.command.staffmode")) {
+ on.hidePlayer(p);
+ }
+ }
+ for (Entity entity : p.getNearbyEntities(20.0D, 20.0D, 20.0D)) {
+ if ((entity instanceof Player))
+ {
+ Player players = (Player)entity;
+ players.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.ghost.damage-near")));
+ }
+ }
+ Cooldowns.addCooldown("Assassin_item_cooldown", p, HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.ghost.mode-cooldown"));
+ ((CraftPlayer)p).removePotionEffect(PotionEffectType.SPEED);
+ this.firstAssassinEffects.put(p.getName(), Integer.valueOf(1));
+ p.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, 100, 4), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.ABSORPTION, 100, 0), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY, 100, 0), true);
+ new BukkitRunnable()
+ {
+ @Override
+ public void run()
+ {
+ if ((GhostClass.this.isApplicableFor(p)) && (GhostClass.this.firstAssassinEffects.containsKey(p.getName())) && (GhostClass.this.firstAssassinEffects.get(p.getName()).intValue() == 1)) {
+ GhostClass.this.afterFiveSeconds(p, false);
+ }
+ }
+ }
+
+ .runTaskLater(this.plugin, 100L);
+ }
+ }
+ }
+
+ public void afterFiveSeconds(Player p, boolean force)
+ {
+ if ((this.firstAssassinEffects.containsKey(p.getName())) && (isApplicableFor(p)))
+ {
+ for (Player on : Bukkit.getOnlinePlayers())
+ {
+ if ((!on.canSee(p)) && (!on.hasPermission("hcf.command.staffmode"))) {
+ on.showPlayer(p);
+ }
+ on.playEffect(p.getLocation().add(0.0D, 2.0D, 0.0D), Effect.ENDER_SIGNAL, 3);
+ on.playEffect(p.getLocation().add(0.0D, 1.5D, 0.0D), Effect.ENDER_SIGNAL, 3);
+ on.playEffect(p.getLocation().add(0.0D, 1.0D, 0.0D), Effect.ENDER_SIGNAL, 3);
+ on.playEffect(p.getLocation().add(0.0D, 2.0D, 0.0D), Effect.BLAZE_SHOOT, 5);
+ on.playEffect(p.getLocation().add(0.0D, 1.5D, 0.0D), Effect.BLAZE_SHOOT, 5);
+ on.playEffect(p.getLocation().add(0.0D, 1.0D, 0.0D), Effect.BLAZE_SHOOT, 5);
+ }
+ new BukkitRunnable()
+ {
+ @Override
+ public void run()
+ {
+ if ((GhostClass.this.firstAssassinEffects.containsKey(p.getName())) && (GhostClass.this.firstAssassinEffects.get(p.getName()).intValue() == 2))
+ {
+ GhostClass.this.firstAssassinEffects.remove(p.getName());
+ p.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.ghost.normal-mode")));
+ if (GhostClass.this.isApplicableFor(p))
+ {
+ p.addPotionEffect(new PotionEffect(PotionEffectType.FIRE_RESISTANCE, Integer.MAX_VALUE, 0), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 1), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 1), true);
+ }
+ }
+ }
+ }
+
+ .runTaskLater(this.plugin, 100L);
+ if (force)
+ {
+ p.addPotionEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 1), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 0), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.INCREASE_DAMAGE, 120, 1), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, 120, 0), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.ABSORPTION, 120, 1), true);
+ ((CraftPlayer)p).removePotionEffect(PotionEffectType.INVISIBILITY);
+ this.firstAssassinEffects.remove(p.getName());
+ this.firstAssassinEffects.put(p.getName(), Integer.valueOf(2));
+ p.sendMessage(ChatColor.YELLOW + "You have been forced into " + ChatColor.RED + "Power" + ChatColor.YELLOW + " Mode" + ChatColor.GRAY.toString() + ChatColor.ITALIC + " (5 Seconds)");
+ return;
+ }
+ this.firstAssassinEffects.remove(p.getName());
+ this.firstAssassinEffects.put(p.getName(), Integer.valueOf(2));
+ p.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.ghost.power-mode")));
+ p.addPotionEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 1), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 0), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.INCREASE_DAMAGE, 120, 1), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, 120, 0), true);
+ p.addPotionEffect(new PotionEffect(PotionEffectType.ABSORPTION, 120, 1), true);
+ ((CraftPlayer)p).removePotionEffect(PotionEffectType.INVISIBILITY);
+ }
+ }
+
+ @Override
+public boolean isApplicableFor(Player player)
+ {
+ PlayerInventory playerInventory = player.getInventory();
+ ItemStack helmet = playerInventory.getHelmet();
+ if ((helmet == null) || (helmet.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.ghost.equipment.helmet")))) {
+ return false;
+ }
+ ItemStack chestplate = playerInventory.getChestplate();
+ if ((chestplate == null) || (chestplate.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.ghost.equipment.chestplate")))) {
+ return false;
+ }
+ ItemStack leggings = playerInventory.getLeggings();
+ if ((leggings == null) || (leggings.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.ghost.equipment.leggings")))) {
+ return false;
+ }
+ ItemStack boots = playerInventory.getBoots();
+ return (boots != null) && (boots.getType() == Material.matchMaterial(plugin.getConfig().getString("classes.ghost.equipment.boots")));
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/miner/MinerClass.java b/src/notifyz/hardcorefactions/classes/type/miner/MinerClass.java
new file mode 100644
index 0000000..bbb9ccb
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/miner/MinerClass.java
@@ -0,0 +1,138 @@
+package notifyz.hardcorefactions.classes.type.miner;
+
+import java.util.concurrent.TimeUnit;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.classes.PvPClass;
+import notifyz.hardcorefactions.classes.events.PvPClassEquipEvent;
+import notifyz.hardcorefactions.utilities.chat.BukkitUtils;
+
+/**
+ * Represents a {@link PvPClass} used to enhance mining quality.
+ */
+public class MinerClass extends PvPClass implements Listener {
+
+ // The minimum height level to obtain the Invisibility effect.
+ private static final int INVISIBILITY_HEIGHT_LEVEL = HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.miner.invisibility-y");
+ private static final PotionEffect HEIGHT_INVISIBILITY = new PotionEffect(PotionEffectType.INVISIBILITY, Integer.MAX_VALUE, 0);
+
+ private final HardcoreFactionsPlugin plugin;
+
+ public MinerClass(HardcoreFactionsPlugin plugin) {
+ super(HardcoreFactionsPlugin.getInstance().getConfig().getString("classes.miner.name"), TimeUnit.SECONDS.toMillis(1L));
+ this.plugin = plugin;
+
+ addPassiveEffect(new PotionEffect(PotionEffectType.FAST_DIGGING, Integer.MAX_VALUE, 1));
+ addPassiveEffect(new PotionEffect(PotionEffectType.NIGHT_VISION, Integer.MAX_VALUE, 0));
+ addPassiveEffect(new PotionEffect(PotionEffectType.FIRE_RESISTANCE, Integer.MAX_VALUE, 0));
+ }
+
+ private void removeInvisibilitySafely(Player player) {
+ for (PotionEffect active : player.getActivePotionEffects()) {
+ if (active.getType().equals(PotionEffectType.INVISIBILITY) && active.getDuration() > DEFAULT_MAX_DURATION) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.miner.invisibility-removed")));
+ player.removePotionEffect(active.getType());
+ break;
+ }
+ }
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerDamage(EntityDamageByEntityEvent event) {
+ Entity entity = event.getEntity();
+ if (entity instanceof Player && BukkitUtils.getFinalAttacker(event, false) != null) {
+ Player player = (Player) entity;
+ if (plugin.getPvPClassManager().hasClassEquipped(player, this)) {
+ removeInvisibilitySafely(player);
+ }
+ }
+ }
+
+ @Override
+ public void onUnequip(Player player) {
+ super.onUnequip(player);
+ removeInvisibilitySafely(player);
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerMove(PlayerMoveEvent event) {
+ conformMinerInvisibility(event.getPlayer(), event.getFrom(), event.getTo());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerTeleport(PlayerTeleportEvent event) {
+ conformMinerInvisibility(event.getPlayer(), event.getFrom(), event.getTo());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onClassEquip(PvPClassEquipEvent event) {
+ Player player = event.getPlayer();
+ if (event.getPvPClass() == this && player.getLocation().getBlockY() <= INVISIBILITY_HEIGHT_LEVEL) {
+ player.addPotionEffect(HEIGHT_INVISIBILITY, true);
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.miner.invisibility-added")));
+ }
+ }
+
+
+ /**
+ * Applies the {@link MinerClass} invisibility {@link PotionEffect} depending
+ * on the {@link Player}s {@link Location}.
+ *
+ * @param player the {@link Player} to apply for
+ * @param from the from {@link Location}
+ * @param to the to {@link Location}
+ */
+ private void conformMinerInvisibility(Player player, Location from, Location to) {
+ int fromY = from.getBlockY();
+ int toY = to.getBlockY();
+ if (fromY != toY && plugin.getPvPClassManager().hasClassEquipped(player, this)) {
+ boolean isInvisible = player.hasPotionEffect(PotionEffectType.INVISIBILITY);
+ if (toY > INVISIBILITY_HEIGHT_LEVEL) {
+ if (fromY <= INVISIBILITY_HEIGHT_LEVEL && isInvisible) {
+ removeInvisibilitySafely(player);
+ }
+ } else {
+ if (!isInvisible) {
+ player.addPotionEffect(HEIGHT_INVISIBILITY, true);
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.miner.invisibility-added")));
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean isApplicableFor(Player player) {
+ PlayerInventory playerInventory = player.getInventory();
+
+ ItemStack helmet = playerInventory.getHelmet();
+ if (helmet == null || helmet.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.miner.equipment.helmet")))
+ return false;
+
+ ItemStack chestplate = playerInventory.getChestplate();
+ if (chestplate == null || chestplate.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.miner.equipment.chestplate")))
+ return false;
+
+ ItemStack leggings = playerInventory.getLeggings();
+ if (leggings == null || leggings.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.miner.equipment.leggings")))
+ return false;
+
+ ItemStack boots = playerInventory.getBoots();
+ return !(boots == null || boots.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.miner.equipment.boots")));
+ }
+}
diff --git a/src/notifyz/hardcorefactions/classes/type/rogue/RogueClass.java b/src/notifyz/hardcorefactions/classes/type/rogue/RogueClass.java
new file mode 100644
index 0000000..bb55bb0
--- /dev/null
+++ b/src/notifyz/hardcorefactions/classes/type/rogue/RogueClass.java
@@ -0,0 +1,197 @@
+package notifyz.hardcorefactions.classes.type.rogue;
+
+import java.util.UUID;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.lang.time.DurationFormatUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Damageable;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import net.minecraft.util.gnu.trove.map.TObjectLongMap;
+import net.minecraft.util.gnu.trove.map.hash.TObjectLongHashMap;
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.classes.PvPClass;
+
+public class RogueClass extends PvPClass implements Listener {
+
+ private final HardcoreFactionsPlugin plugin;
+
+ private static final PotionEffect ROGUE_SPEED_EFFECT = new PotionEffect(PotionEffectType.SPEED, 160, 3);
+ private static final long ROGUE_SPEED_COOLDOWN_DELAY = TimeUnit.MINUTES.toMillis(HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.rogue.speed-cooldown"));
+
+ private static final PotionEffect ROGUE_JUMP_EFFECT = new PotionEffect(PotionEffectType.JUMP, 160, 5);
+ private static final long ROGUE_JUMP_COOLDOWN_DELAY = TimeUnit.MINUTES.toMillis(HardcoreFactionsPlugin.getInstance().getConfig().getInt("classes.rogue.jump-cooldown"));
+
+ public final static TObjectLongMap rogueSpeedCooldowns = new TObjectLongHashMap<>();
+ public final static TObjectLongMap rogueJumpCooldowns = new TObjectLongHashMap<>();
+
+ public RogueClass(HardcoreFactionsPlugin plugin) {
+ super(HardcoreFactionsPlugin.getInstance().getConfig().getString("classes.rogue.name"), TimeUnit.SECONDS.toMillis(1L));
+
+ this.plugin = plugin;
+ addPassiveEffect(new PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, Integer.MAX_VALUE, 0));
+ addPassiveEffect(new PotionEffect(PotionEffectType.REGENERATION, Integer.MAX_VALUE, 0));
+ addPassiveEffect(new PotionEffect(PotionEffectType.SPEED, Integer.MAX_VALUE, 2));
+ addPassiveEffect(new PotionEffect(PotionEffectType.JUMP, Integer.MAX_VALUE, 1));
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
+ public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
+ if (((event.getEntity() instanceof Player)) && ((event.getDamager() instanceof Player))) {
+ Entity entity = event.getEntity();
+ Entity damager = event.getDamager();
+ Player attacker = (Player) damager;
+ if (this.plugin.getPvPClassManager().getEquippedClass(attacker) == this) {
+ ItemStack stack = attacker.getItemInHand();
+ if ((stack != null) && (stack.getType() == Material.GOLD_SWORD) && (stack.getEnchantments().isEmpty())) {
+ Player player = (Player) entity;
+ if (direction(attacker) == direction(player)) {
+ Damageable damage = player;
+ if (damage.getHealth() <= 0.0D) {
+ return;
+ }
+ if (damage.getHealth() <= 6.0D) {
+ damage.damage(20.0D);
+ } else {
+ damage.setHealth(damage.getHealth() - 6.0D);
+ }
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.rogue.backstabbed-you").replace("%player%", attacker.getName())));
+ player.playSound(player.getLocation(), Sound.ITEM_BREAK, 1.0F, 1.0F);
+ attacker.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.rogue.you-backstabbed").replace("%player%", player.getName())));
+ attacker.setItemInHand(new ItemStack(Material.AIR, 1));
+ attacker.playSound(player.getLocation(), Sound.ITEM_BREAK, 1.0F, 1.0F);
+ attacker.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 60, 1));
+ event.setCancelled(true);
+ }
+ }
+ }
+ }
+ }
+
+ @EventHandler(ignoreCancelled = false, priority = EventPriority.HIGH)
+ public void onSpeed(PlayerInteractEvent event) {
+ Action action = event.getAction();
+ if (action == Action.RIGHT_CLICK_AIR || action == Action.RIGHT_CLICK_BLOCK) {
+ if (event.hasItem() && event.getItem().getType() == Material.SUGAR) {
+ if (plugin.getPvPClassManager().getEquippedClass(event.getPlayer()) != this) {
+ return;
+ }
+
+ Player player = event.getPlayer();
+ UUID uuid = player.getUniqueId();
+ long timestamp = rogueSpeedCooldowns.get(uuid);
+ long millis = System.currentTimeMillis();
+ long remaining = timestamp == rogueSpeedCooldowns.getNoEntryValue() ? -1L : timestamp - millis;
+ if (remaining > 0L) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.rogue.speed-cooldown").replace("%cooldown%", DurationFormatUtils.formatDurationWords(remaining, true, true))));
+ } else {
+ ItemStack stack = player.getItemInHand();
+ if (stack.getAmount() == 1) {
+ player.setItemInHand(new ItemStack(Material.AIR, 1));
+ } else {
+ stack.setAmount(stack.getAmount() - 1);
+ }
+
+ plugin.getEffectRestorer().setRestoreEffect(player, ROGUE_SPEED_EFFECT);
+ rogueSpeedCooldowns.put(event.getPlayer().getUniqueId(), System.currentTimeMillis() + ROGUE_SPEED_COOLDOWN_DELAY);
+ }
+ }
+ }
+ }
+
+ @EventHandler(ignoreCancelled = false, priority = EventPriority.HIGH)
+ public void onJump(PlayerInteractEvent event) {
+ Action action = event.getAction();
+ if (action == Action.RIGHT_CLICK_AIR || action == Action.RIGHT_CLICK_BLOCK) {
+ if (event.hasItem() && event.getItem().getType() == Material.FEATHER) {
+ if (plugin.getPvPClassManager().getEquippedClass(event.getPlayer()) != this) {
+ return;
+ }
+
+ Player player = event.getPlayer();
+ UUID uuid = player.getUniqueId();
+ long timestamp = rogueJumpCooldowns.get(uuid);
+ long millis = System.currentTimeMillis();
+ long remaining = timestamp == rogueJumpCooldowns.getNoEntryValue() ? -1L : timestamp - millis;
+ if (remaining > 0L) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', plugin.getConfig().getString("classes-messages.rogue.jump-cooldown").replace("%cooldown%", DurationFormatUtils.formatDurationWords(remaining, true, true))));
+ } else {
+ ItemStack stack = player.getItemInHand();
+ if (stack.getAmount() == 1) {
+ player.setItemInHand(new ItemStack(Material.AIR, 1));
+ } else {
+ stack.setAmount(stack.getAmount() - 1);
+ }
+
+ plugin.getEffectRestorer().setRestoreEffect(player, ROGUE_JUMP_EFFECT);
+ rogueJumpCooldowns.put(event.getPlayer().getUniqueId(), System.currentTimeMillis() + ROGUE_JUMP_COOLDOWN_DELAY);
+ }
+ }
+ }
+ }
+
+ public Byte direction(Player player) {
+ double rotation = (player.getLocation().getYaw() - 90) % 360;
+ if (rotation < 0) {
+ rotation += 360.0;
+ }
+ if (0 <= rotation && rotation < 22.5) {
+ return 0xC; // S > E
+ } else if (22.5 <= rotation && rotation < 67.5) {
+ return 0xE; // SW > SE
+ } else if (67.5 <= rotation && rotation < 112.5) {
+ return 0x0; // W > E
+ } else if (112.5 <= rotation && rotation < 157.5) {
+ return 0x2; // NW > SW
+ } else if (157.5 <= rotation && rotation < 202.5) {
+ return 0x4; // N > W
+ } else if (202.5 <= rotation && rotation < 247.5) {
+ return 0x6; // NE > NW
+ } else if (247.5 <= rotation && rotation < 292.5) {
+ return 0x8; // E > N
+ } else if (292.5 <= rotation && rotation < 337.5) {
+ return 0xA; // SE > NE
+ } else if (337.5 <= rotation && rotation < 360.0) {
+ return 0xC; // S > E
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ public boolean isApplicableFor(Player player) {
+ PlayerInventory playerInventory = player.getInventory();
+
+ ItemStack helmet = playerInventory.getHelmet();
+ if (helmet == null || helmet.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.rogue.equipment.helmet"))) {
+ return false;
+ }
+
+ ItemStack chestplate = playerInventory.getChestplate();
+ if (chestplate == null || chestplate.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.rogue.equipment.chestplate"))) {
+ return false;
+ }
+
+ ItemStack leggings = playerInventory.getLeggings();
+ if (leggings == null || leggings.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.rogue.equipment.leggings"))) {
+ return false;
+ }
+
+ ItemStack boots = playerInventory.getBoots();
+ return !(boots == null || boots.getType() != Material.matchMaterial(plugin.getConfig().getString("classes.rogue.equipment.boots")));
+ }
+}
diff --git a/src/notifyz/hardcorefactions/combatloggers/CombatLogEntry.java b/src/notifyz/hardcorefactions/combatloggers/CombatLogEntry.java
new file mode 100644
index 0000000..60c49c7
--- /dev/null
+++ b/src/notifyz/hardcorefactions/combatloggers/CombatLogEntry.java
@@ -0,0 +1,15 @@
+package notifyz.hardcorefactions.combatloggers;
+
+import org.bukkit.scheduler.BukkitTask;
+
+public class CombatLogEntry
+{
+ public final LoggerEntity loggerEntity;
+ public final BukkitTask task;
+
+ public CombatLogEntry(LoggerEntity loggerEntity, BukkitTask task)
+ {
+ this.loggerEntity = loggerEntity;
+ this.task = task;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/combatloggers/CombatLogListener.java b/src/notifyz/hardcorefactions/combatloggers/CombatLogListener.java
new file mode 100644
index 0000000..9ba7578
--- /dev/null
+++ b/src/notifyz/hardcorefactions/combatloggers/CombatLogListener.java
@@ -0,0 +1,176 @@
+package notifyz.hardcorefactions.combatloggers;
+
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_7_R4.entity.CraftLivingEntity;
+import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityInteractEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.inventory.EntityEquipment;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.spigotmc.event.player.PlayerSpawnLocationEvent;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+public class CombatLogListener
+ implements Listener
+{
+ @SuppressWarnings("rawtypes")
+private static final Set SAFE_DISCONNECTS = new HashSet();
+ @SuppressWarnings("rawtypes")
+private static final Map LOGGERS = new HashMap();
+ private final HardcoreFactionsPlugin plugin;
+
+ public CombatLogListener(HardcoreFactionsPlugin plugin)
+ {
+ this.plugin = plugin;
+ }
+
+ public static void safelyDisconnect(Player player, String reason)
+ {
+ if (SAFE_DISCONNECTS.add(player.getUniqueId())) {
+ player.kickPlayer(reason);
+ }
+ }
+
+ public static void removeCombatLoggers()
+ {
+ Iterator iterator = LOGGERS.values().iterator();
+ while (iterator.hasNext())
+ {
+ CombatLogEntry entry = iterator.next();
+ entry.task.cancel();
+ entry.loggerEntity.getBukkitEntity().remove();
+ iterator.remove();
+ }
+ SAFE_DISCONNECTS.clear();
+ }
+
+ @EventHandler(ignoreCancelled=true, priority=EventPriority.MONITOR)
+ public void onPlayerQuitSafe(PlayerQuitEvent event)
+ {
+ SAFE_DISCONNECTS.remove(event.getPlayer().getUniqueId());
+ }
+
+ @EventHandler(ignoreCancelled=true, priority=EventPriority.HIGH)
+ public void onLoggerInteract(EntityInteractEvent event)
+ {
+ Collection entries = LOGGERS.values();
+ Iterator var3 = entries.iterator();
+ while (var3.hasNext())
+ {
+ CombatLogEntry entry = var3.next();
+ if (entry.loggerEntity.getBukkitEntity().equals(event.getEntity()))
+ {
+ event.setCancelled(true);
+ break;
+ }
+ }
+ }
+
+ @EventHandler(ignoreCancelled=true, priority=EventPriority.MONITOR)
+ public void onLoggerDeath(LoggerDeathEvent event)
+ {
+ CombatLogEntry entry = LOGGERS.remove(event.getLoggerEntity().getPlayerUUID());
+ if (entry != null) {
+ entry.task.cancel();
+ }
+ this.plugin.getTimerManager().getCombatTimer().clearCooldown(event.getLoggerEntity().getPlayerUUID());
+ System.out.println("Logger died with combat timer on so we cleared it.");
+ }
+
+ @EventHandler(ignoreCancelled=true, priority=EventPriority.HIGHEST)
+ public void onPlayerSpawnLocation(PlayerSpawnLocationEvent event)
+ {
+ CombatLogEntry combatLogEntry = LOGGERS.remove(event.getPlayer().getUniqueId());
+ if (combatLogEntry != null)
+ {
+ CraftLivingEntity loggerEntity = combatLogEntry.loggerEntity.getBukkitEntity();
+ Player player = event.getPlayer();
+ event.setSpawnLocation(loggerEntity.getLocation());
+ player.setFallDistance(loggerEntity.getFallDistance());
+ player.setHealth(Math.min(((CraftPlayer)player).getMaxHealth(), loggerEntity.getHealth()));
+
+ player.setRemainingAir(loggerEntity.getRemainingAir());
+ loggerEntity.remove();
+ combatLogEntry.task.cancel();
+ }
+ }
+
+ @EventHandler(ignoreCancelled=true, priority=EventPriority.NORMAL)
+ public void onPlayerQuit(PlayerQuitEvent event)
+ {
+ Player player = event.getPlayer();
+ UUID uuid = player.getUniqueId();
+ PlayerInventory inventory = player.getInventory();
+ if ((player.getGameMode() != GameMode.CREATIVE) && (!player.isDead()) && (!SAFE_DISCONNECTS.contains(uuid)))
+ {
+ if ((this.plugin.getTimerManager().getInvincibilityTimer().getRemainingCooldown(uuid) > 0L)) {
+ return;
+ }
+ if (this.plugin.getTimerManager().teleportTimer.getNearbyEnemies(player, 64) <= 0) {
+ return;
+ }
+ Location location = player.getLocation();
+ if (this.plugin.getFactionManager().getFactionAt(location).isSafezone()) {
+ return;
+ }
+ if (LOGGERS.containsKey(player.getUniqueId())) {
+ return;
+ }
+ World world = location.getWorld();
+ LoggerEntity loggerEntity = new LoggerEntity(world, location, player);
+ LoggerSpawnEvent calledEvent = new LoggerSpawnEvent(loggerEntity);
+ Bukkit.getPluginManager().callEvent(calledEvent);
+ LOGGERS.put(uuid, new CombatLogEntry(loggerEntity, new LoggerRemovable(uuid, loggerEntity).runTaskLater(this.plugin, plugin.getConfiguration().getCombatlogDespawnDelayTicks())));
+ CraftLivingEntity craftEntity = loggerEntity.getBukkitEntity();
+ if (craftEntity != null)
+ {
+ CraftLivingEntity craftLivingEntity = craftEntity;
+ EntityEquipment entityEquipment = craftLivingEntity.getEquipment();
+ entityEquipment.setItemInHand(inventory.getItemInHand());
+ entityEquipment.setArmorContents(inventory.getArmorContents());
+ craftLivingEntity.addPotionEffect(new PotionEffect(PotionEffectType.FIRE_RESISTANCE, 999999, 1));
+ }
+ }
+ }
+
+ private static class LoggerRemovable
+ extends BukkitRunnable
+ {
+ private final UUID uuid;
+ private final LoggerEntity loggerEntity;
+
+ public LoggerRemovable(UUID uuid, LoggerEntity loggerEntity)
+ {
+ this.uuid = uuid;
+ this.loggerEntity = loggerEntity;
+ }
+
+ @Override
+ public void run()
+ {
+ if (CombatLogListener.LOGGERS.remove(this.uuid) != null) {
+ this.loggerEntity.dead = true;
+ }
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/combatloggers/CustomEntityRegistration.java b/src/notifyz/hardcorefactions/combatloggers/CustomEntityRegistration.java
new file mode 100644
index 0000000..b048dae
--- /dev/null
+++ b/src/notifyz/hardcorefactions/combatloggers/CustomEntityRegistration.java
@@ -0,0 +1,61 @@
+package notifyz.hardcorefactions.combatloggers;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+import net.minecraft.server.v1_7_R4.EntityTypes;
+
+public class CustomEntityRegistration
+{
+ public static void registerCustomEntities()
+ {
+ try
+ {
+ registerCustomEntity(LoggerEntity.class, "CraftSkeleton", 51);
+ }
+ catch (Exception var1)
+ {
+ var1.printStackTrace();
+ }
+ }
+
+ @SuppressWarnings("rawtypes")
+public static void registerCustomEntity(Class entityClass, String name, int id)
+ {
+ setFieldPrivateStaticMap("d", entityClass, name);
+ setFieldPrivateStaticMap("f", entityClass, Integer.valueOf(id));
+ }
+
+ public static void unregisterCustomEntities() {}
+
+ @SuppressWarnings("rawtypes")
+public static void setFieldPrivateStaticMap(String fieldName, Object key, Object value)
+ {
+ try
+ {
+ Field ex = EntityTypes.class.getDeclaredField(fieldName);
+ ex.setAccessible(true);
+ Map map = (Map)ex.get(null);
+ map.put(key, value);
+ ex.set(null, map);
+ }
+ catch (SecurityException|IllegalArgumentException|IllegalAccessException|NoSuchFieldException var5)
+ {
+ var5.printStackTrace();
+ }
+ }
+
+ public static void setField(String fieldName, Object key, Object value)
+ {
+ try
+ {
+ Field ex = key.getClass().getDeclaredField(fieldName);
+ ex.setAccessible(true);
+ ex.set(key, value);
+ ex.setAccessible(false);
+ }
+ catch (Exception var4)
+ {
+ var4.printStackTrace();
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/combatloggers/LoggerDeathEvent.java b/src/notifyz/hardcorefactions/combatloggers/LoggerDeathEvent.java
new file mode 100644
index 0000000..b7ce213
--- /dev/null
+++ b/src/notifyz/hardcorefactions/combatloggers/LoggerDeathEvent.java
@@ -0,0 +1,31 @@
+package notifyz.hardcorefactions.combatloggers;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class LoggerDeathEvent
+ extends Event
+{
+ private static final HandlerList handlers = new HandlerList();
+ private final LoggerEntity loggerEntity;
+
+ public LoggerDeathEvent(LoggerEntity loggerEntity)
+ {
+ this.loggerEntity = loggerEntity;
+ }
+
+ public static HandlerList getHandlerList()
+ {
+ return handlers;
+ }
+
+ public LoggerEntity getLoggerEntity()
+ {
+ return this.loggerEntity;
+ }
+
+ public HandlerList getHandlers()
+ {
+ return handlers;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/combatloggers/LoggerEntity.java b/src/notifyz/hardcorefactions/combatloggers/LoggerEntity.java
new file mode 100644
index 0000000..a059a71
--- /dev/null
+++ b/src/notifyz/hardcorefactions/combatloggers/LoggerEntity.java
@@ -0,0 +1,189 @@
+package notifyz.hardcorefactions.combatloggers;
+
+import java.util.ArrayList;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_7_R4.CraftServer;
+import org.bukkit.craftbukkit.v1_7_R4.CraftWorld;
+import org.bukkit.craftbukkit.v1_7_R4.entity.CraftLivingEntity;
+import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
+import org.bukkit.craftbukkit.v1_7_R4.event.CraftEventFactory;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+
+import com.google.common.base.Function;
+
+import net.minecraft.server.v1_7_R4.DamageSource;
+import net.minecraft.server.v1_7_R4.Entity;
+import net.minecraft.server.v1_7_R4.EntityHuman;
+import net.minecraft.server.v1_7_R4.EntityPlayer;
+import net.minecraft.server.v1_7_R4.EntitySkeleton;
+import net.minecraft.server.v1_7_R4.PlayerInteractManager;
+import net.minecraft.server.v1_7_R4.WorldServer;
+import net.minecraft.util.com.mojang.authlib.GameProfile;
+
+public class LoggerEntity extends EntitySkeleton
+{
+ @SuppressWarnings("rawtypes")
+ private static final Function DAMAGE_FUNCTION;
+ private final UUID playerUUID;
+
+ public LoggerEntity(final World world, final Location location, final Player player) {
+ super(((CraftWorld)world).getHandle());
+ this.lastDamager = ((CraftPlayer)player).getHandle().lastDamager;
+ final double x = location.getX();
+ final double y = location.getY();
+ final double z = location.getZ();
+ final String playerName = player.getName();
+ final boolean hasSpawned = ((CraftWorld)world).getHandle().addEntity(this, CreatureSpawnEvent.SpawnReason.CUSTOM);
+ Bukkit.getConsoleSender().sendMessage(ChatColor.GOLD + "Combat Logger for [" + playerName + "] " + (hasSpawned ? (ChatColor.GREEN + "successfully spawned") : (ChatColor.RED + "failed to spawn")) + ChatColor.GOLD + " at (" + String.format("%.1f", x) + ", " + String.format("%.1f", y) + ", " + String.format("%.1f", z) + ')');
+ this.playerUUID = player.getUniqueId();
+ if (hasSpawned) {
+ this.setCustomName(playerName);
+ this.setCustomNameVisible(true);
+ this.setPositionRotation(x, y, z, location.getYaw(), location.getPitch());
+ }
+ }
+
+ private static PlayerNmsResult getResult(final World world, final UUID playerUUID) {
+ final OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(playerUUID);
+ if (offlinePlayer.hasPlayedBefore()) {
+ final WorldServer worldServer = ((CraftWorld)world).getHandle();
+ final EntityPlayer entityPlayer = new EntityPlayer(((CraftServer)Bukkit.getServer()).getServer(), worldServer, new GameProfile(playerUUID, offlinePlayer.getName()), new PlayerInteractManager(worldServer));
+ final CraftPlayer player = entityPlayer.getBukkitEntity();
+ if (player != null) {
+ player.loadData();
+ return new PlayerNmsResult(player, entityPlayer);
+ }
+ }
+ return null;
+ }
+
+ public UUID getPlayerUUID() {
+ return this.playerUUID;
+ }
+
+ @Override
+ public void move(final double d0, final double d1, final double d2) {
+ }
+
+ @Override
+ public void b(final int i) {
+ }
+
+ @Override
+ public void dropDeathLoot(final boolean flag, final int i) {
+ }
+
+ @Override
+ public Entity findTarget() {
+ return null;
+ }
+
+ @Override
+ public boolean damageEntity(final DamageSource damageSource, final float amount) {
+ final PlayerNmsResult nmsResult = getResult(this.world.getWorld(), this.playerUUID);
+ if (nmsResult == null) {
+ return true;
+ }
+ final EntityPlayer entityPlayer = nmsResult.entityPlayer;
+ if (entityPlayer != null) {
+ entityPlayer.setPosition(this.locX, this.locY, this.locZ);
+ final EntityDamageEvent event = CraftEventFactory.handleLivingEntityDamageEvent(entityPlayer, damageSource, amount, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, LoggerEntity.DAMAGE_FUNCTION, LoggerEntity.DAMAGE_FUNCTION, LoggerEntity.DAMAGE_FUNCTION, LoggerEntity.DAMAGE_FUNCTION, LoggerEntity.DAMAGE_FUNCTION, LoggerEntity.DAMAGE_FUNCTION);
+ if (event.isCancelled()) {
+ return false;
+ }
+ }
+ return super.damageEntity(damageSource, amount);
+ }
+
+ @Override
+ public boolean a(final EntityHuman entityHuman) {
+ return false;
+ }
+
+ @Override
+ public void h() {
+ super.h();
+ }
+
+ @Override
+ public void collide(final Entity entity) {
+ }
+
+ @Override
+ @SuppressWarnings("rawtypes")
+ public void die(final DamageSource damageSource) {
+ final PlayerNmsResult playerNmsResult = getResult(this.world.getWorld(), this.playerUUID);
+ if (playerNmsResult != null) {
+ final Player player = playerNmsResult.player;
+ final PlayerInventory inventory = player.getInventory();
+ final boolean keepInventory = this.world.getGameRules().getBoolean("keepInventory");
+ final ArrayList drops = new ArrayList();
+ if (!keepInventory) {
+ for (final ItemStack loggerDeathEvent : inventory.getContents()) {
+ if (loggerDeathEvent != null && loggerDeathEvent.getType() != Material.AIR) {
+ drops.add(loggerDeathEvent);
+ }
+ }
+ for (final ItemStack loggerDeathEvent : inventory.getArmorContents()) {
+ if (loggerDeathEvent != null && loggerDeathEvent.getType() != Material.AIR) {
+ drops.add(loggerDeathEvent);
+ }
+ }
+ }
+ String var13 = ChatColor.RED + "(Combat-Logger) " + this.combatTracker.b().c();
+ final EntityPlayer var14 = playerNmsResult.entityPlayer;
+ var14.combatTracker = this.combatTracker;
+ if (Bukkit.getPlayer(var14.getName()) != null) {
+ Bukkit.getPlayer(var14.getUniqueID()).getInventory().clear();
+ Bukkit.getPlayer(var14.getUniqueID()).kickPlayer("error");
+ }
+ final PlayerDeathEvent var15 = CraftEventFactory.callPlayerDeathEvent(var14, drops, var13, keepInventory);
+ var13 = var15.getDeathMessage();
+ if (var13 != null && !var13.isEmpty()) {
+ Bukkit.broadcastMessage(var13);
+ }
+ super.die(damageSource);
+ final LoggerDeathEvent var16 = new LoggerDeathEvent(this);
+ Bukkit.getPluginManager().callEvent(var16);
+ if (!var15.getKeepInventory()) {
+ inventory.clear();
+ inventory.setArmorContents(new ItemStack[inventory.getArmorContents().length]);
+ }
+ var14.setLocation(this.locX, this.locY, this.locZ, this.yaw, this.pitch);
+ var14.setHealth(0.0f);
+ player.saveData();
+ }
+ }
+
+ @Override
+ public CraftLivingEntity getBukkitEntity() {
+ return (CraftLivingEntity)super.getBukkitEntity();
+ }
+
+ static {
+ DAMAGE_FUNCTION = (f1 -> 0.0);
+ }
+
+ public static final class PlayerNmsResult
+ {
+ public final Player player;
+ public final EntityPlayer entityPlayer;
+
+ public PlayerNmsResult(final Player player, final EntityPlayer entityPlayer) {
+ this.player = player;
+ this.entityPlayer = entityPlayer;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/notifyz/hardcorefactions/combatloggers/LoggerSpawnEvent.java b/src/notifyz/hardcorefactions/combatloggers/LoggerSpawnEvent.java
new file mode 100644
index 0000000..ae7d86c
--- /dev/null
+++ b/src/notifyz/hardcorefactions/combatloggers/LoggerSpawnEvent.java
@@ -0,0 +1,31 @@
+package notifyz.hardcorefactions.combatloggers;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class LoggerSpawnEvent
+ extends Event
+{
+ private static final HandlerList handlers = new HandlerList();
+ private final LoggerEntity loggerEntity;
+
+ public LoggerSpawnEvent(LoggerEntity loggerEntity)
+ {
+ this.loggerEntity = loggerEntity;
+ }
+
+ public static HandlerList getHandlerList()
+ {
+ return handlers;
+ }
+
+ public LoggerEntity getLoggerEntity()
+ {
+ return this.loggerEntity;
+ }
+
+ public HandlerList getHandlers()
+ {
+ return handlers;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/BackCommand.java b/src/notifyz/hardcorefactions/commands/essentials/BackCommand.java
new file mode 100644
index 0000000..72a6335
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/BackCommand.java
@@ -0,0 +1,79 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.utilities.api.utilties.command.ICommandAPI;
+import notifyz.hardcorefactions.utilities.api.utilties.command.IConstantsAPI;
+import notifyz.hardcorefactions.utilities.chat.BukkitUtils;
+import notifyz.hardcorefactions.utilities.user.IUser;
+
+public class BackCommand extends ICommandAPI implements Listener
+{
+ private HardcoreFactionsPlugin plugin;
+
+ public BackCommand(HardcoreFactionsPlugin plugin) {
+ super("back", "Go to a players last known location.");
+ this.setUsage("/(command) [playerName]");
+ Bukkit.getPluginManager().registerEvents(this, this.plugin = plugin);
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "This command is only executable by players.");
+ return true;
+ }
+ Player target;
+ if (args.length > 0 && sender.hasPermission(command.getPermission() + ".others")) {
+ target = BukkitUtils.playerWithNameOrUUID(args[0]);
+ if (target == null) {
+ sender.sendMessage(String.format(IConstantsAPI.PLAYER_WITH_NAME_OR_UUID_NOT_FOUND, args[0]));
+ return true;
+ }
+ }
+ else {
+ target = (Player)sender;
+ }
+ IUser targetUser = this.plugin.getUserManagerr().getUser(target.getUniqueId());
+ Location previous = targetUser.getBackLocation();
+ if (previous == null) {
+ sender.sendMessage(ChatColor.RED + target.getName() + " doesn't have a back location.");
+ return true;
+ }
+ ((Player)sender).teleport(previous);
+ sender.sendMessage(ChatColor.YELLOW + "Teleported to back location of " + target.getName() + '.');
+ return true;
+ }
+
+ @Override
+ public List onTabComplete(CommandSender sender, Command command, String label, String[] args) {
+ return (args.length == 1) ? null : Collections.emptyList();
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerDeath(PlayerDeathEvent event) {
+ Player player = event.getEntity();
+ this.plugin.getUserManagerr().getUser(player.getUniqueId()).setBackLocation(player.getLocation().clone());
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+ public void onPlayerTeleport(PlayerTeleportEvent event) {
+ if (event.getCause() != PlayerTeleportEvent.TeleportCause.ENDER_PEARL) {
+ this.plugin.getUserManagerr().getUser(event.getPlayer().getUniqueId()).setBackLocation(event.getFrom().clone());
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/BroadcastCommand.java b/src/notifyz/hardcorefactions/commands/essentials/BroadcastCommand.java
new file mode 100644
index 0000000..bb19db1
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/BroadcastCommand.java
@@ -0,0 +1,33 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+public class BroadcastCommand implements CommandExecutor {
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+ if (cmd.getName().equalsIgnoreCase("broadcast")) {
+ if (!sender.hasPermission("hcf.command.broadcast") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+ if (args.length == 0) {
+ sender.sendMessage("§cUsage: /broadcast ");
+ return true;
+ }
+ StringBuilder str = new StringBuilder();
+ for(int i = 0; i < args.length; i++) {
+ str.append(args[i] + " ");
+ }
+ String msg = str.toString();
+ Bukkit.broadcastMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.alert-message").replace("%message%", msg.toString())));
+ }
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/DisableChatCommand.java b/src/notifyz/hardcorefactions/commands/essentials/DisableChatCommand.java
new file mode 100644
index 0000000..edf38bb
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/DisableChatCommand.java
@@ -0,0 +1,51 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import java.util.concurrent.TimeUnit;
+
+import org.apache.commons.lang.StringUtils;
+import org.apache.commons.lang.time.DurationFormatUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.utilities.api.utilties.command.ICommandAPI;
+import notifyz.hardcorefactions.utilities.utils.JavaUtils;
+
+public class DisableChatCommand extends ICommandAPI {
+ private static final long DEFAULT_DELAY;
+ private final HardcoreFactionsPlugin plugin;
+
+ public DisableChatCommand(HardcoreFactionsPlugin plugin) {
+ super("disablechat", "Disables the chat for non-staff.");
+ this.setAliases(new String[] { "mutechat", "restrictchat", "mc", "rc" });
+ this.setUsage("/(command)");
+ this.plugin = plugin;
+ }
+
+ @Override
+ public boolean onCommand(final CommandSender sender, final Command command, final String label,
+ final String[] args) {
+ final long oldTicks = this.plugin.getServerHandler().getRemainingChatDisabledMillis();
+ long newTicks;
+ if (oldTicks > 0L) {
+ newTicks = 0L;
+ } else if (args.length < 1) {
+ newTicks = DisableChatCommand.DEFAULT_DELAY;
+ } else {
+ newTicks = JavaUtils.parse(StringUtils.join(args, ' ', 0, args.length));
+ if (newTicks == -1L) {
+ sender.sendMessage(ChatColor.RED + "Invalid duration, use the correct format: 10m1s");
+ return true;
+ }
+ }
+ this.plugin.getServerHandler().setChatDisabledMillis(newTicks);
+ Bukkit.broadcastMessage(ChatColor.YELLOW + "Global chat is now " + ((newTicks > 0L) ? (ChatColor.RED + "disabled" + ChatColor.YELLOW + " for " + ChatColor.GOLD + DurationFormatUtils.formatDurationWords(newTicks, true, true)) : (ChatColor.GREEN + "enabled")));
+ return true;
+ }
+
+ static {
+ DEFAULT_DELAY = TimeUnit.MINUTES.toMillis(3L);
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/EnchantCommand.java b/src/notifyz/hardcorefactions/commands/essentials/EnchantCommand.java
new file mode 100644
index 0000000..d31ea9a
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/EnchantCommand.java
@@ -0,0 +1,147 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class EnchantCommand implements CommandExecutor {
+
+
+ public static String convertEnchantmentAliases(String args) {
+ String s = args;
+ if (args.equalsIgnoreCase("protection") || args.equalsIgnoreCase("prot")) {
+ s = "PROTECTION_ENVIRONMENTAL";
+ }
+ if (args.equalsIgnoreCase("fireprotection") || args.equalsIgnoreCase("fireprot")) {
+ s = "PROTECTION_FIRE";
+ }
+ if (args.equalsIgnoreCase("silktouch") || args.equalsIgnoreCase("silk")) {
+ s = "SILK_TOUCH";
+ }
+ if (args.equalsIgnoreCase("featherfalling") || args.equalsIgnoreCase("ff") || args.equalsIgnoreCase("fallprotection") || args.equalsIgnoreCase("fallprot")) {
+ s = "PROTECTION_FALL";
+ }
+ if (args.equalsIgnoreCase("unbreaking") || args.equalsIgnoreCase("dura")) {
+ s = "DURABILITY";
+ }
+ if (args.equalsIgnoreCase("blastprotection") || args.equalsIgnoreCase("blastprot")) {
+ s = "PROTECTION_EXPLOSIONS";
+ }
+ if (args.equalsIgnoreCase("fortune") || args.equalsIgnoreCase("fort")) {
+ s = "LOOT_BONUS_BLOCKS";
+ }
+ if (args.equalsIgnoreCase("efficiency") || args.equalsIgnoreCase("eff")) {
+ s = "DIG_SPEED";
+ }
+ if (args.equalsIgnoreCase("projectileprotection") || args.equalsIgnoreCase("projectileprot") || args.equalsIgnoreCase("projprot") || args.equalsIgnoreCase("proj")) {
+ s = "PROTECTION_PROJECTILE";
+ }
+ if (args.equalsIgnoreCase("sharpness") || args.equalsIgnoreCase("sharp")) {
+ s = "DAMAGE_ALL";
+ }
+ if (args.equalsIgnoreCase("power")) {
+ s = "ARROW_DAMAGE";
+ }
+ if (args.equalsIgnoreCase("smite")) {
+ s = "DAMAGE_UNDEAD";
+ }
+ if (args.equalsIgnoreCase("punch")) {
+ s = "ARROW_KNOCKBACK";
+ }
+ if (args.equalsIgnoreCase("baneofarthropods") || args.equalsIgnoreCase("arthropods") || args.equalsIgnoreCase("bane")) {
+ s = "DAMAGE_ARTHROPODS";
+ }
+ if (args.equalsIgnoreCase("flame")) {
+ s = "ARROW_FIRE";
+ }
+ if (args.equalsIgnoreCase("kb")) {
+ s = "KNOCKBACK";
+ }
+ if (args.equalsIgnoreCase("infinity") || args.equalsIgnoreCase("infinite")) {
+ s = "ARROW_INFINITE";
+ }
+ if (args.equalsIgnoreCase("fireaspect") || args.equalsIgnoreCase("fire") || args.equalsIgnoreCase("aspect")) {
+ s = "FIRE_ASPECT";
+ }
+ if (args.equalsIgnoreCase("looting") || args.equalsIgnoreCase("loot")) {
+ s = "LOOT_BONUS_MOBS";
+ }
+ int n = 0;
+ Enchantment[] enchants = Enchantment.values();
+ for (Enchantment enchant : enchants) {
+ if (s.equalsIgnoreCase(enchant.getName())) {
+ n++;
+ }
+ }
+ if (n == 0) {
+ s = "Invalid";
+ }
+ return s.toUpperCase();
+ }
+
+ public boolean isInt(String s) {
+ try{
+ Integer.parseInt(s);
+ return true;
+ } catch(NumberFormatException e) {
+ return false;
+ }
+ }
+
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+ if (cmd.getName().equalsIgnoreCase("enchant")) {
+ if (!sender.hasPermission("hcf.command.enchant") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+ if (args.length == 0 || args.length == 1) {
+ sender.sendMessage("§c/enchant [enchantment] [level]");
+ return true;
+ }
+ Player p = (Player) sender;
+
+ ItemStack i = p.getItemInHand();
+ String enchantment = convertEnchantmentAliases(args[0]);
+ if (enchantment.equalsIgnoreCase("Invalid")) {
+ sender.sendMessage("§cInvalid enchantment ID.");
+ return true;
+ }
+ if (i.getType() == Material.AIR) {
+ sender.sendMessage("§cYou must have an item in your hand.");
+ return true;
+ }
+ if (!isInt(args[1])) {
+ sender.sendMessage("§cLevel must be an integer.");
+ return true;
+ }
+ int level = Integer.parseInt(args[1]);
+ if (level < 0) {
+ sender.sendMessage("§cLevel cannot be negative of less than 0.");
+ return true;
+ }
+ if (level == 0) {
+ if (!i.containsEnchantment(Enchantment.getByName(enchantment))) {
+ sender.sendMessage("§eThis item doesn't contain the enchantment §c" + args[0] + "§e.");
+ return true;
+ }
+ i.removeEnchantment(Enchantment.getByName(enchantment));
+ sender.sendMessage("§eYou have removed the enchantment §c" + args[0] + " §efrom the item in your hand.");
+ }else{
+ i.addUnsafeEnchantment(Enchantment.getByName(enchantment), level);
+ sender.sendMessage("§eYou have binded §c" + args[0] + " §elevel §c" + level + " §eto the item in your hand.");
+ }
+ }
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/FeedCommand.java b/src/notifyz/hardcorefactions/commands/essentials/FeedCommand.java
new file mode 100644
index 0000000..9df985d
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/FeedCommand.java
@@ -0,0 +1,50 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+public class FeedCommand implements CommandExecutor {
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+ if (cmd.getName().equalsIgnoreCase("feed")) {
+ if (!sender.hasPermission("hcf.command.feed") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+ if (args.length == 0) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage("§cNo Console");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.feed-message")));
+ p.setFoodLevel(20);
+ p.setSaturation(10);
+ return true;
+ }
+ if (args.length > 1) {
+ sender.sendMessage("§c/feed ");
+ return true;
+ }
+ Player t = Bukkit.getPlayer(args[0]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ sender.sendMessage("§c" + t.getName() + "'s §eappetite has been repleted.");
+ t.sendMessage("§eYour appetite has been repleted by §c" + sender.getName() + "§e.");
+ t.setFoodLevel(20);
+ t.setSaturation(10);
+ return true;
+ }
+ return true;
+ }
+
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/FlyCommand.java b/src/notifyz/hardcorefactions/commands/essentials/FlyCommand.java
new file mode 100644
index 0000000..d93f1dd
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/FlyCommand.java
@@ -0,0 +1,65 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+public class FlyCommand implements CommandExecutor {
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+ if (cmd.getName().equalsIgnoreCase("fly")) {
+ if (!sender.hasPermission("hcf.command.fly") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+
+ if (args.length == 0) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+ Player p = (Player) sender;
+ if (!p.getAllowFlight()) {
+ p.setAllowFlight(true);
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.flight-enabled")));
+ return true;
+ }
+ if (p.getAllowFlight()) {
+ p.setAllowFlight(false);
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.flight-disabled")));
+ return true;
+ }
+ }
+
+ if (args.length == 1) {
+ Player t = Bukkit.getPlayer(args[0]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ if (!t.getAllowFlight()) {
+ t.setAllowFlight(true);
+ sender.sendMessage("§c" + t.getName() + " §enow has flight set to §cenabled§e.");
+ t.sendMessage("§eYou now have flight §cenabled§e.");
+ return true;
+ }
+ if (t.getAllowFlight()) {
+ t.setAllowFlight(false);
+ sender.sendMessage("§c" + t.getName() + " §enow has flight set to §cdisabled§e.");
+ t.sendMessage("§eYou now have flight §cdisabled§e.");
+ return true;
+ }
+ return true;
+ }
+
+ sender.sendMessage("§cUsage: /fly [player]");
+ }
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/FreezeAllCommand.java b/src/notifyz/hardcorefactions/commands/essentials/FreezeAllCommand.java
new file mode 100644
index 0000000..706673e
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/FreezeAllCommand.java
@@ -0,0 +1,36 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+
+public class FreezeAllCommand implements CommandExecutor {
+
+ private final HardcoreFactionsPlugin plugin;
+
+ public FreezeAllCommand(HardcoreFactionsPlugin plugin) {
+ this.plugin = plugin;
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+
+ if (args.length > 0) {
+ sender.sendMessage(ChatColor.RED + "Usage: /freezeall");
+ return true;
+ }
+
+ if (plugin.getFreezeAllListener().isServerFrozen()) {
+ plugin.getFreezeAllListener().setServerFreeze(false);
+ sender.sendMessage(ChatColor.GREEN + "Server is no longer frozen.");
+ return true;
+ } else {
+ plugin.getFreezeAllListener().setServerFreeze(true);
+ sender.sendMessage(ChatColor.RED + "Server is now frozen.");
+ return true;
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/FreezeCommand.java b/src/notifyz/hardcorefactions/commands/essentials/FreezeCommand.java
new file mode 100644
index 0000000..5979a8c
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/FreezeCommand.java
@@ -0,0 +1,67 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.entity.Player;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.utilities.chat.Color;
+import notifyz.hardcorefactions.utilities.utils.Utils;
+
+public class FreezeCommand implements CommandExecutor, TabCompleter {
+
+ private final HardcoreFactionsPlugin staffMode = HardcoreFactionsPlugin.getPlugin();
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+ if (args.length == 0 || args.length > 1) {
+ sender.sendMessage(Color.translate("&cUsage: /" + label + " "));
+ } else {
+ Player target = Bukkit.getServer().getPlayerExact(args[0]);
+ if (target == null) {
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.freeze-player-not-found").replace("%target%", args[0])));
+ } else {
+ if (target.equals(sender)) {
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.freeze-no-yourself")));
+ } else {
+ if (sender instanceof Player) {
+ if (target.hasPermission("hcf.command.freeze") || target.isOp()) {
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.freeze-no-staffmember")));
+ } else {
+ if (staffMode.getFreezeListener().isFrozen(target)) {
+ staffMode.getFreezeListener().setFreeze(sender, target, false);
+ } else {
+ Bukkit.dispatchCommand(sender, "msg " + args[0]+ " You have been frozen. Please, join our teamspeak, " + Utils.TEAMSPEAK + ". If you logout it'll result in a permanent ban due to your refusing to screenshare.");
+ staffMode.getFreezeListener().setFreeze(sender, target, true);
+ }
+ }
+ } else {
+ if (staffMode.getFreezeListener().isFrozen(target)) {
+ staffMode.getFreezeListener().setFreeze(sender, target, false);
+ } else {
+ Bukkit.dispatchCommand(sender, "msg " + args[0] + " You have been frozen. Please, join our teamspeak, " + Utils.TEAMSPEAK + ". If you logout it'll result in a permanent ban due to your refusing to screenshare.");
+ staffMode.getFreezeListener().setFreeze(sender, target, true);
+ }
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+
+ @Override
+ public List onTabComplete(CommandSender sender, Command command, String label, String[] args) {
+ if (args.length > 1) {
+ return Collections.emptyList();
+ }
+ return null;
+ }
+}
\ No newline at end of file
diff --git a/src/notifyz/hardcorefactions/commands/essentials/GamemodeCommand.java b/src/notifyz/hardcorefactions/commands/essentials/GamemodeCommand.java
new file mode 100644
index 0000000..e4b10ee
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/GamemodeCommand.java
@@ -0,0 +1,188 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class GamemodeCommand implements CommandExecutor {
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+ if (cmd.getName().equalsIgnoreCase("gamemode")) {
+ if (!sender.hasPermission("hcf.command.gamemode") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+
+ if (args.length != 0) {
+ if (args[0].equalsIgnoreCase("survival") || args[0].equalsIgnoreCase("s") || args[0].equalsIgnoreCase("0")) {
+ if (args.length == 1) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.setGameMode(GameMode.SURVIVAL);
+ sender.sendMessage("§eYou have set your gamemode to §cSurvival§e.");
+ return true;
+ }
+ if (args.length == 2) {
+ Player t = Bukkit.getPlayer(args[1]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ t.setGameMode(GameMode.SURVIVAL);
+ sender.sendMessage("§eYou have set the gamemode of §c" + t.getName() + " §eto §cSurvival§e.");
+ return true;
+ }
+ }
+
+ if (args[0].equalsIgnoreCase("creative") || args[0].equalsIgnoreCase("c") || args[0].equalsIgnoreCase("1")) {
+ if (args.length == 1) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.setGameMode(GameMode.CREATIVE);
+ sender.sendMessage("§eYou have set your gamemode to §cCreative§e.");
+ return true;
+ }
+ if (args.length == 2) {
+ Player t = Bukkit.getPlayer(args[1]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ t.setGameMode(GameMode.CREATIVE);
+ sender.sendMessage("§eYou have set the gamemode of §c" + t.getName() + " §eto §cCreative§e.");
+ return true;
+ }
+ }
+
+ if (args[0].equalsIgnoreCase("adventure") || args[0].equalsIgnoreCase("a") || args[0].equalsIgnoreCase("2")) {
+ if (args.length == 1) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.setGameMode(GameMode.ADVENTURE);
+ sender.sendMessage("§eYou have set your gamemode to §cAdventure§e.");
+ return true;
+ }
+ if (args.length == 2) {
+ Player t = Bukkit.getPlayer(args[1]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ t.setGameMode(GameMode.ADVENTURE);
+ sender.sendMessage("§eYou have set the gamemode of §c" + t.getName() + " §eto §cAdventure§e.");
+ return true;
+ }
+ }
+ }
+
+ sender.sendMessage("§c/gamemode ");
+ }
+
+ if (cmd.getName().equalsIgnoreCase("gamemodes")) {
+ if (!sender.hasPermission("hcf.command.gamemode") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+
+ if (args.length == 0) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.setGameMode(GameMode.SURVIVAL);
+ sender.sendMessage("§eYou have set your gamemode to §cSurvival§e.");
+ return true;
+ }
+
+ if (args.length == 1) {
+ Player t = Bukkit.getPlayer(args[0]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ t.setGameMode(GameMode.SURVIVAL);
+ sender.sendMessage("§eYou have set the gamemode of §c" + t.getName() + " §eto §cSurvival§e.");
+ return true;
+ }
+
+ sender.sendMessage("§c/gms ");
+ }
+
+ if (cmd.getName().equalsIgnoreCase("gamemodec")) {
+ if (!sender.hasPermission("hcf.command.gamemode") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+
+ if (args.length == 0) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.setGameMode(GameMode.CREATIVE);
+ sender.sendMessage("§eYou have set your gamemode to §cCreative§e.");
+ return true;
+ }
+ if (args.length == 1) {
+ Player t = Bukkit.getPlayer(args[0]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ t.setGameMode(GameMode.CREATIVE);
+ sender.sendMessage("§eYou have set the gamemode of §c" + t.getName() + " §eto §cCreative§e.");
+ return true;
+ }
+
+ sender.sendMessage("§c/gmc ");
+ }
+
+ if (cmd.getName().equalsIgnoreCase("gamemodea")) {
+ if (!sender.hasPermission("hcf.command.gamemode") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+
+ if (args.length == 0) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.setGameMode(GameMode.ADVENTURE);
+ sender.sendMessage("§eYou have set your gamemode to §cAdventure§e.");
+ return true;
+ }
+ if (args.length == 1) {
+ Player t = Bukkit.getPlayer(args[0]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ t.setGameMode(GameMode.ADVENTURE);
+ sender.sendMessage("§eYou have set the gamemode of §c" + t.getName() + " §eto §cAdventure§e.");
+ return true;
+ }
+
+ sender.sendMessage("§c/gma ");
+ }
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/GiveCommand.java b/src/notifyz/hardcorefactions/commands/essentials/GiveCommand.java
new file mode 100644
index 0000000..20d5733
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/GiveCommand.java
@@ -0,0 +1,84 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import notifyz.hardcorefactions.utilities.api.IPluginAPI;
+import notifyz.hardcorefactions.utilities.api.utilties.command.ICommandAPI;
+
+public class GiveCommand extends ICommandAPI {
+ public GiveCommand() {
+ super("give", "Spawns an item.");
+ this.setAliases(new String[] { "i", "get", "item" });
+ this.setUsage("/(command) [quantity]");
+ }
+
+ @Override
+ public boolean onCommand(final CommandSender sender, final Command command, final String label,
+ final String[] args) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "This command is only executable for players.");
+ return true;
+ }
+ final Player p = (Player) sender;
+ if (args.length == 0) {
+ p.sendMessage(ChatColor.RED + this.getUsage());
+ return true;
+ }
+ if (IPluginAPI.getPlugin().getItemDb().getItem(args[0]) == null) {
+ sender.sendMessage(ChatColor.GOLD + "Item named or with ID '" + ChatColor.RESET + args[0] + ChatColor.GOLD
+ + "' not found.");
+ return true;
+ }
+ if (args.length == 1) {
+ if (!p.getInventory().addItem(new ItemStack[] { IPluginAPI.getPlugin().getItemDb().getItem(args[0],
+ IPluginAPI.getPlugin().getItemDb().getItem(args[0]).getMaxStackSize()) }).isEmpty()) {
+ p.sendMessage(ChatColor.RED + "Your inventory is full.");
+ return true;
+ }
+ for (final Player on : Bukkit.getOnlinePlayers()) {
+ if (on.hasPermission("base.command.give")) {
+ if (on != p) {
+ on.sendMessage(ChatColor.GRAY + "[" + ChatColor.GOLD + p.getName() + ChatColor.YELLOW
+ + " has given himself " + ChatColor.GRAY
+ + IPluginAPI.getPlugin().getItemDb().getItem(args[0]).getMaxStackSize() + ", "
+ + IPluginAPI.getPlugin().getItemDb()
+ .getName(IPluginAPI.getPlugin().getItemDb().getItem(args[0]))
+ + "]");
+ } else {
+ on.sendMessage(ChatColor.GOLD + "You gave yourself "
+ + IPluginAPI.getPlugin().getItemDb().getItem(args[0]).getMaxStackSize() + ", "
+ + IPluginAPI.getPlugin().getItemDb()
+ .getName(IPluginAPI.getPlugin().getItemDb().getItem(args[0])));
+ }
+ }
+ }
+ }
+ if (args.length == 2) {
+ if (!p.getInventory().addItem(
+ new ItemStack[] { IPluginAPI.getPlugin().getItemDb().getItem(args[0], Integer.parseInt(args[1])) })
+ .isEmpty()) {
+ p.sendMessage(ChatColor.RED + "Your inventory is full.");
+ return true;
+ }
+ for (final Player on : Bukkit.getOnlinePlayers()) {
+ if (on.hasPermission("base.command.give")) {
+ if (on != p) {
+ on.sendMessage(ChatColor.GRAY + "[" + ChatColor.GOLD + p.getName() + ChatColor.YELLOW
+ + " has given himself" + ChatColor.GRAY + " " + args[1] + ", " + IPluginAPI.getPlugin()
+ .getItemDb().getName(IPluginAPI.getPlugin().getItemDb().getItem(args[0]))
+ + " ]");
+ } else {
+ on.sendMessage(ChatColor.GOLD + "You gave yourself " + args[1] + ", " + IPluginAPI.getPlugin()
+ .getItemDb().getName(IPluginAPI.getPlugin().getItemDb().getItem(args[0])));
+ }
+ }
+ }
+ }
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/GiveawayCommand.java b/src/notifyz/hardcorefactions/commands/essentials/GiveawayCommand.java
new file mode 100644
index 0000000..bed366c
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/GiveawayCommand.java
@@ -0,0 +1,89 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import java.util.IllegalFormatException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+
+import notifyz.hardcorefactions.utilities.utils.RandomUtils;
+import notifyz.hardcorefactions.utilities.utils.Utils;
+
+public class GiveawayCommand implements CommandExecutor, Listener {
+ public static boolean giveawayActive = false;
+ public static int giveawayNumber = 0;
+
+ public static void endGiveaway() {
+ giveawayActive = false;
+ giveawayNumber = 0;
+ }
+
+ public static void endGiveaway(Player winner) {
+ if (winner.getType() + "giveawayNumber" != null)
+ Bukkit.getServer().dispatchCommand(Bukkit.getServer().getConsoleSender(), "disablechat");
+ Bukkit.broadcastMessage("§8[§4§l" + Utils.SERVER_NAME + "§8] §4» §cThe giveaway has been §cended§c. The winner is §4§l" + winner.getName() + "§c who guessed the correct number, §c" + giveawayNumber + "§c.");
+ giveawayActive = false;
+ giveawayNumber = 0;
+ }
+
+ @EventHandler
+ public void playerWinGiveaway(AsyncPlayerChatEvent e) {
+ if (giveawayActive) {
+ try {
+ //int no = Integer.parseInt(e.getMessage());
+ if (e.getMessage().contains(giveawayNumber + "")) {
+ endGiveaway(e.getPlayer());
+ }
+ } catch (IllegalFormatException ee) {
+ }
+ }
+ }
+
+ @Override
+ public boolean onCommand(CommandSender s, Command cmd, String label, String[] args) {
+
+ if (s.isOp()) {
+ if (args.length == 0) {
+ s.sendMessage("§cTo start the giveaway use /giveaway start (maxNumber).");
+ s.sendMessage("§cTo end the giveaway use /giveaway end.");
+ } else if (args.length == 1) {
+ if (args[0].equalsIgnoreCase("end") || args[0].equalsIgnoreCase("stop")
+ || args[0].equalsIgnoreCase("cancel")) {
+ if (giveawayActive) {
+ giveawayActive = false;
+ Bukkit.broadcastMessage("§8[§4§l" + Utils.SERVER_NAME + "§8] §4» §cThe giveaway has been §ccancelled§c. The correct number was §c" + giveawayNumber + "§c.");
+ } else {
+ s.sendMessage("§cThere is no active giveaway.");
+ }
+ } else {
+ s.sendMessage("§cTo start the giveaway use /giveaway start (maxNumber).");
+ s.sendMessage("§cTo end the giveaway use /giveaway end.");
+ }
+ } else if (args.length == 2) {
+ if (args[0].equalsIgnoreCase("start")) {
+ try {
+ int no = Integer.parseInt(args[1]);
+ giveawayActive = true;
+ RandomUtils utils = new RandomUtils();
+ giveawayNumber = utils.getRandomNumber(1, no);
+ s.sendMessage("§aThe winning number is " + giveawayNumber + "!");
+ Bukkit.broadcastMessage("§8[§4§l" + Utils.SERVER_NAME + "§8] §4» §cA giveaway has started. Type a number in chat between 1 and "
+ + no + " to enter!");
+ } catch (IllegalFormatException e) {
+ s.sendMessage("§cYou did not enter a valid integer. (0-" + Integer.MAX_VALUE + ")");
+ }
+ }
+ }
+ } else {
+ s.sendMessage("§cYou do not have permission.");
+ }
+
+ return true;
+ }
+
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/GodCommand.java b/src/notifyz/hardcorefactions/commands/essentials/GodCommand.java
new file mode 100644
index 0000000..0d47669
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/GodCommand.java
@@ -0,0 +1,64 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import java.util.ArrayList;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class GodCommand implements CommandExecutor {
+
+ public static ArrayList god = new ArrayList();
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+
+ if (cmd.getName().equalsIgnoreCase("god")) {
+ if (!sender.hasPermission("hcf.command.god") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have access to this command.");
+ return true;
+ }
+ if (args.length == 0) {
+ if (!god.contains(sender.getName())) {
+ god.add(sender.getName());
+ sender.sendMessage("§eYou have §cenabled §egod mode.");
+ }else{
+ god.remove(sender.getName());
+ sender.sendMessage("§eYou have §cdisabled §egod mode.");
+ }
+ return true;
+ }
+
+ if (args.length == 1) {
+ if (!sender.hasPermission("hcf.command.god.others") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+ Player t = Bukkit.getPlayer(args[0]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ if (!god.contains(t.getName())) {
+ god.add(t.getName());
+ t.sendMessage("§eGod mode §cenabled§e by §c" + sender.getName() + "§e!");
+ sender.sendMessage("§eGod mode §cenabled §efor §c" + t.getName() + "§e.");
+ }else{
+ god.remove(t.getName());
+ t.sendMessage("§eGod mode §cdisabled§e by §c" + sender.getName() + "§e!");
+ sender.sendMessage("§eGod mode §cdisabled §efor §c" + t.getName() + "§e.");
+ }
+ return true;
+ }
+ sender.sendMessage("§cUsage: /god [player]");
+ }
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/GuiFreezeCommand.java b/src/notifyz/hardcorefactions/commands/essentials/GuiFreezeCommand.java
new file mode 100644
index 0000000..43b8277
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/GuiFreezeCommand.java
@@ -0,0 +1,114 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.utilities.chat.BukkitUtils;
+import notifyz.hardcorefactions.utilities.chat.Color;
+import notifyz.hardcorefactions.utilities.utils.Utils;
+
+public class GuiFreezeCommand implements CommandExecutor, Listener {
+ private HardcoreFactionsPlugin plugin;
+
+ public GuiFreezeCommand(HardcoreFactionsPlugin plugin) {
+ this.plugin = plugin;
+ }
+
+ @Override
+ public boolean onCommand(CommandSender sender, Command command, String s, String[] args) {
+ if (!sender.hasPermission("hcf.command.guifreeze")) {
+ sender.sendMessage(ChatColor.RED + "You do not have permission to execute this command.");
+ return true;
+ }
+ if (args.length != 1) {
+ return false;
+ }
+ Player target = this.plugin.getServer().getPlayer(args[0]);
+ if (target == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline.");
+ return true;
+ }
+ if(target == sender) {
+ sender.sendMessage(ChatColor.RED + "You cannot freeze yourself.");
+ return true;
+ }
+ if (this.plugin.getFrozenManager().isFrozen(target.getUniqueId())) {
+ this.plugin.getFrozenManager().unfreezeUUID(target.getUniqueId());
+ sender.sendMessage(ChatColor.GREEN + "You unfroze " + target.getName());
+ target.sendMessage(ChatColor.GREEN + "You have been unfrozen by a staff member.");
+ target.closeInventory();
+ return true;
+ }
+ this.plugin.getFrozenManager().freezeUUID(target.getUniqueId());
+ sender.sendMessage(ChatColor.GREEN + "You froze " + target.getName());
+ target.sendMessage(ChatColor.GRAY + BukkitUtils.STRAIGHT_LINE_DEFAULT);
+ target.sendMessage("");
+ target.sendMessage(Color.translate("&eYou have been&4&l Frozen&e."));
+ target.sendMessage(Color.translate(" &eYou have 3 minutes to join teamspeak."));
+ target.sendMessage(Color.translate(" &eTeamSpeak: &4&l" + Utils.TEAMSPEAK));
+ target.sendMessage("");
+ target.sendMessage(Color.translate("&eIf you log out you will be&4&l BANNED&e."));
+ target.sendMessage("");
+ target.sendMessage(ChatColor.GRAY + BukkitUtils.STRAIGHT_LINE_DEFAULT);
+ target.openInventory(this.plugin.getInventoryManager().getFrozenInv());
+ return true;
+ }
+
+ @EventHandler
+ public void onEntityDamageByEntity(EntityDamageByEntityEvent e) {
+ if (e.getEntity() instanceof Player && e.getDamager() instanceof Player) {
+ Player playerDamaged = (Player)e.getEntity();
+ Player playerDamager = (Player)e.getDamager();
+ if (this.plugin.getFrozenManager().isFrozen(playerDamaged.getUniqueId()) || this.plugin.getFrozenManager().isFrozen(playerDamager.getUniqueId())) {
+ e.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler
+ public void onInventoryClick(InventoryClickEvent event) {
+ if (event.getClickedInventory() != null) {
+ Inventory inv = event.getInventory();
+ if ((inv.getName() != null) && (inv.getName().contains(ChatColor.DARK_RED + ChatColor.BOLD.toString() + "Frozen!"))) {
+ event.setCancelled(true);
+ if ((event.getCurrentItem() == null) && (event.getCurrentItem().getType() == Material.AIR)) {
+ event.setCancelled(true);
+ return;
+ }
+ ItemStack item = event.getCurrentItem();
+ switch (item.getType()) {
+ case BOOK_AND_QUILL:
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+
+ @EventHandler
+ public void onInvClose(InventoryCloseEvent e) {
+ Player player = (Player)e.getPlayer();
+ if (this.plugin.getFrozenManager().isFrozen(player.getUniqueId())) {
+ new BukkitRunnable() {
+ @Override
+ public void run() {
+ player.openInventory(HardcoreFactionsPlugin.getPlugin().getInventoryManager().getFrozenInv());
+ }
+ }.runTaskLater(this.plugin, 1L);
+ }
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/HatCommand.java b/src/notifyz/hardcorefactions/commands/essentials/HatCommand.java
new file mode 100644
index 0000000..200dce5
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/HatCommand.java
@@ -0,0 +1,54 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+
+import notifyz.hardcorefactions.utilities.api.utilties.command.ICommandAPI;
+
+public class HatCommand extends ICommandAPI {
+ public HatCommand() {
+ super("hat", "Wear something on your head.");
+ this.setUsage("/(command)");
+ }
+
+ @Override
+ public boolean onCommand(final CommandSender sender, final Command command, final String label,
+ final String[] args) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage(ChatColor.RED + "This command is only executable by players.");
+ return true;
+ }
+ final Player player = (Player) sender;
+ final ItemStack stack = player.getItemInHand();
+ if (stack == null || stack.getType() == Material.AIR) {
+ sender.sendMessage(ChatColor.RED + "You are not holding anything.");
+ return true;
+ }
+ if (stack.getType().getMaxDurability() != 0) {
+ sender.sendMessage(ChatColor.RED + "The item you are holding is not suitable to wear for a hat.");
+ return true;
+ }
+ final PlayerInventory inventory = player.getInventory();
+ ItemStack helmet = inventory.getHelmet();
+ if (helmet != null && helmet.getType() != Material.AIR) {
+ sender.sendMessage(ChatColor.RED + "You are already wearing something as your hat.");
+ return true;
+ }
+ int amount = stack.getAmount();
+ if (amount > 1) {
+ --amount;
+ stack.setAmount(amount);
+ } else {
+ player.setItemInHand(new ItemStack(Material.AIR, 1));
+ }
+ helmet = stack.clone();
+ helmet.setAmount(1);
+ inventory.setHelmet(helmet);
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/HealCommand.java b/src/notifyz/hardcorefactions/commands/essentials/HealCommand.java
new file mode 100644
index 0000000..bee201c
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/HealCommand.java
@@ -0,0 +1,53 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class HealCommand implements CommandExecutor {
+
+ @Override
+ @SuppressWarnings("deprecation")
+ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+ if (cmd.getName().equalsIgnoreCase("heal")) {
+ if (!sender.hasPermission("hcf.command.heal") && !sender.hasPermission("hcf.command.*") && !sender.hasPermission("*")) {
+ sender.sendMessage(ChatColor.RED + "You do not have acces to this command.");
+ return true;
+ }
+ if (args.length == 0) {
+ if (!(sender instanceof Player)) {
+ sender.sendMessage("§cNo Console");
+ return true;
+ }
+ Player p = (Player) sender;
+ p.sendMessage("§eYou have been §ccured §eof any diseases.");
+ p.setHealth(20);
+ p.setFireTicks(0);
+ p.setFoodLevel(20);
+ p.setSaturation(10);
+ return true;
+ }
+ if (args.length > 1) {
+ sender.sendMessage("§c/heal ");
+ return true;
+ }
+ Player t = Bukkit.getPlayer(args[0]);
+ if (t == null) {
+ sender.sendMessage(ChatColor.RED + "That player is currently offline");
+ return true;
+ }
+ sender.sendMessage("§c" + t.getName() + " §ehas been cured of any diseases.");
+ t.sendMessage("§eYou have been §ccured §eof any diseases thanks to §c" + sender.getName() + "§e.");
+ t.setHealth(20);
+ t.setFireTicks(0);
+ t.setFoodLevel(20);
+ t.setSaturation(10);
+ return true;
+ }
+ return true;
+ }
+
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/HideStaffCommand.java b/src/notifyz/hardcorefactions/commands/essentials/HideStaffCommand.java
new file mode 100644
index 0000000..ba7024b
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/HideStaffCommand.java
@@ -0,0 +1,41 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.listeners.essentials.HideStaffListener;
+
+public class HideStaffCommand implements CommandExecutor
+{
+
+ @Override
+ public boolean onCommand(CommandSender player, Command cmd, String label, String[] args) {
+ Player sender = (Player)player;
+ HideStaffListener.getStaff();
+ if (!(player instanceof Player)) {
+ player.sendMessage(ChatColor.RED + "You must be a player to use this commad.");
+ }
+ else if (!player.hasPermission("hcf.command.hidestaff")) {
+ player.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.no-permission")));
+ }
+ else if (HideStaffListener.showStaffEnabled(sender)) {
+ HideStaffListener.showStaff.put(sender, false);
+ for (int i = 0; i < HideStaffListener.staff.size(); ++i) {
+ sender.hidePlayer(HideStaffListener.staff.get(i));
+ }
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.hidestaff-hide")));
+ }
+ else {
+ HideStaffListener.showStaff.put(sender, true);
+ for (int i = 0; i < HideStaffListener.staff.size(); ++i) {
+ sender.showPlayer(HideStaffListener.staff.get(i));
+ }
+ sender.sendMessage(ChatColor.translateAlternateColorCodes('&', HardcoreFactionsPlugin.getInstance().getConfig().getString("cmd-messages.hidestaff-show")));
+ }
+ return true;
+ }
+}
diff --git a/src/notifyz/hardcorefactions/commands/essentials/IgnoreCommand.java b/src/notifyz/hardcorefactions/commands/essentials/IgnoreCommand.java
new file mode 100644
index 0000000..3fef14f
--- /dev/null
+++ b/src/notifyz/hardcorefactions/commands/essentials/IgnoreCommand.java
@@ -0,0 +1,220 @@
+package notifyz.hardcorefactions.commands.essentials;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+import org.apache.commons.lang.StringUtils;
+import org.bukkit.ChatColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import notifyz.hardcorefactions.HardcoreFactionsPlugin;
+import notifyz.hardcorefactions.utilities.api.utilties.command.ICommandAPI;
+import notifyz.hardcorefactions.utilities.api.utilties.command.ICommandArgument;
+import notifyz.hardcorefactions.utilities.api.utilties.command.ICommandWrapper;
+import notifyz.hardcorefactions.utilities.api.utilties.command.IConstantsAPI;
+import notifyz.hardcorefactions.utilities.chat.BukkitUtils;
+import notifyz.hardcorefactions.utilities.user.IUser;
+import notifyz.hardcorefactions.utilities.utils.StaffPriority;
+
+public class IgnoreCommand extends ICommandAPI {
+ private final ICommandWrapper handler;
+
+ public IgnoreCommand(HardcoreFactionsPlugin plugin) {
+ super("ignore", "Ignores a player from messages.");
+ this.setUsage("/(command)