69 | * Constructor with no callback argument. Note that you must override
70 | * the onClick method if you use this constructor
71 | *
72 | */
73 | public ArrayPromptGui(Player player, String title, T[] data, boolean closeOnChoice) {
74 | this(player, title, data, closeOnChoice, null);
75 | }
76 |
77 | /**
78 | * Convert an object to an ItemStack.
79 | *
80 | * @return The ItemStack to display
81 | */
82 | public abstract ItemStack getViewItem(T data);
83 |
84 | /**
85 | * Called when player made a choice if no callback was provided.
86 | *
87 | * @param data The data given to the callback.
88 | */
89 | public void onClick(T data) {
90 | throw new NotImplementedException("Override this method or use a callback.");
91 | }
92 |
93 | @Override
94 | protected void onRightClick(T data) {
95 | if (cb != null) {
96 | cb.call(data);
97 | } else {
98 | onClick(data);
99 | }
100 |
101 | if (closeOnChoice) {
102 | close();
103 | }
104 | }
105 |
106 | @Override
107 | protected void onUpdate() {
108 | setTitle(title);
109 | setMode(Mode.READONLY);
110 | setData(data);
111 | }
112 | }
113 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/components/i18n/translators/properties/ZLibResourceBundleControl.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. QuartzLib contributors (2015 - 2020)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.quartzlib.components.i18n.translators.properties;
32 |
33 | import java.io.File;
34 | import java.io.FileInputStream;
35 | import java.io.IOException;
36 | import java.io.InputStream;
37 | import java.util.Locale;
38 | import java.util.PropertyResourceBundle;
39 | import java.util.ResourceBundle;
40 | import org.apache.commons.lang.StringUtils;
41 |
42 |
43 | public class ZLibResourceBundleControl extends ResourceBundle.Control {
44 | private final File bundleFile;
45 | private final String resourceReference;
46 |
47 | public ZLibResourceBundleControl(File bundleFile) {
48 | this.bundleFile = bundleFile;
49 | this.resourceReference = null;
50 | }
51 |
52 | public ZLibResourceBundleControl(String resourceReference) {
53 | this.bundleFile = null;
54 | this.resourceReference = resourceReference;
55 | }
56 |
57 | /**
58 | * Uses the file name as the bundle name.
59 | *
60 | *
61 | * {@inheritDoc}
62 | */
63 | @Override
64 | public String toBundleName(String baseName, Locale locale) {
65 | final String[] nameParts = (bundleFile != null ? bundleFile.getName() : resourceReference).split("\\.");
66 |
67 | if (nameParts.length >= 2) {
68 | nameParts[nameParts.length - 1] = "";
69 | }
70 |
71 | return baseName + "." + StringUtils.join(nameParts, ".");
72 | }
73 |
74 | /**
75 | * Loads the bundles from the file system instead of the JAR file, to allow modifications by
76 | * the end user, if a file was provided.
77 | *
78 | *
79 | * {@inheritDoc}
80 | */
81 | @Override
82 | public ResourceBundle newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload)
83 | throws IllegalAccessException, InstantiationException, IOException {
84 | if (format.equals("java.properties") && bundleFile != null) {
85 | final ResourceBundle bundle;
86 | try (InputStream stream = new FileInputStream(bundleFile)) {
87 | bundle = new PropertyResourceBundle(stream);
88 | }
89 |
90 | return bundle;
91 | }
92 |
93 | return super.newBundle(baseName, locale, format, loader, reload);
94 | }
95 |
96 | /**
97 | * The bundles are only loaded on startup, one time, so the cache is not needed.
98 | * Plus, the cache may cause problems if one reloads the plugin to update the translation.
99 | *
100 | *
101 | * {@inheritDoc}
102 | */
103 | @Override
104 | public boolean needsReload(String baseName, Locale locale, String format, ClassLoader loader, ResourceBundle bundle,
105 | long loadTime) {
106 | return true;
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/tools/mojang/MojangHead.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Plugin UHCReloaded : Alliances
3 | *
4 | * Copyright ou © ou Copr. Amaury Carrade (2016)
5 | * Idées et réflexions : Alexandre Prokopowicz, Amaury Carrade, "Vayan".
6 | *
7 | * Ce logiciel est régi par la licence CeCILL soumise au droit français et
8 | * respectant les principes de diffusion des logiciels libres. Vous pouvez
9 | * utiliser, modifier et/ou redistribuer ce programme sous les conditions
10 | * de la licence CeCILL telle que diffusée par le CEA, le CNRS et l'INRIA
11 | * sur le site "http://www.cecill.info".
12 | *
13 | * En contrepartie de l'accessibilité au code source et des droits de copie,
14 | * de modification et de redistribution accordés par cette licence, il n'est
15 | * offert aux utilisateurs qu'une garantie limitée. Pour les mêmes raisons,
16 | * seule une responsabilité restreinte pèse sur l'auteur du programme, le
17 | * titulaire des droits patrimoniaux et les concédants successifs.
18 | *
19 | * A cet égard l'attention de l'utilisateur est attirée sur les risques
20 | * associés au chargement, à l'utilisation, à la modification et/ou au
21 | * développement et à la reproduction du logiciel par l'utilisateur étant
22 | * donné sa spécificité de logiciel libre, qui peut le rendre complexe à
23 | * manipuler et qui le réserve donc à des développeurs et des professionnels
24 | * avertis possédant des connaissances informatiques approfondies. Les
25 | * utilisateurs sont donc invités à charger et tester l'adéquation du
26 | * logiciel à leurs besoins dans des conditions permettant d'assurer la
27 | * sécurité de leurs systèmes et ou de leurs données et, plus généralement,
28 | * à l'utiliser et l'exploiter dans les mêmes conditions de sécurité.
29 | *
30 | * Le fait que vous puissiez accéder à cet en-tête signifie que vous avez
31 | * pris connaissance de la licence CeCILL, et que vous en avez accepté les
32 | * termes.
33 | */
34 |
35 | package fr.zcraft.quartzlib.tools.mojang;
36 |
37 | import com.google.common.base.CaseFormat;
38 | import fr.zcraft.quartzlib.tools.items.ItemStackBuilder;
39 | import org.bukkit.Material;
40 | import org.bukkit.inventory.ItemStack;
41 | import org.bukkit.inventory.meta.SkullMeta;
42 |
43 | /**
44 | * Easier access to Mojang's “Marc's Head Format” Heads, e.g. for use in GUIs.
45 | *
46 | * See https://minecraft.gamepedia.com/Head#Mojang_Studios_skins for the complete list.
47 | */
48 | public enum MojangHead {
49 | /* Mobs */
50 | ALEX,
51 | BLAZE,
52 | CAVE_SPIDER,
53 | CHICKEN,
54 | COW,
55 | CREEPER,
56 | ENDERMAN,
57 | GHAST,
58 | GOLEM,
59 | HEROBRINE,
60 | LAVA_SLIME,
61 | MUSHROOM_COW,
62 | OCELOT,
63 | PIG,
64 | PIG_ZOMBIE,
65 | SHEEP,
66 | SKELETON,
67 | SLIME,
68 | SPIDER,
69 | SQUID,
70 | STEVE,
71 | VILLAGER,
72 | WITHER_SKELETON("MHF_WSkeleton"),
73 | ZOMBIE,
74 |
75 | /* Blocks */
76 | CACTUS,
77 | CAKE,
78 | CHEST,
79 | COCONUT_BROWN("MHF_CoconutB"),
80 | COCONUT_GREEN("MHF_CoconutG"),
81 | MELON,
82 | OAK_LOG,
83 | PRESENT("MHF_Present1"),
84 | PRESENT_2,
85 | PUMPKIN,
86 | TNT("MHF_TNT"),
87 | TNT_2("MHF_TNT2"),
88 |
89 | /* Bonus */
90 | ARROW_UP,
91 | ARROW_DOWN,
92 | ARROW_LEFT,
93 | ARROW_RIGHT,
94 | EXCLAMATION,
95 | QUESTION;
96 |
97 |
98 | private final String headName;
99 |
100 | MojangHead() {
101 | this.headName = "MHF_" + CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, name());
102 | }
103 |
104 | MojangHead(final String headName) {
105 | this.headName = headName;
106 | }
107 |
108 | /**
109 | * Returns the head's name.
110 | * @return The Mojang head's name, to be used as skull owner.
111 | */
112 | public String getHeadName() {
113 | return headName;
114 | }
115 |
116 | /**
117 | * Returns the head as an ItemStack.
118 | * @return The head as an ItemStack (of type {@link Material#PLAYER_HEAD}).
119 | */
120 | public ItemStack asItem() {
121 | return asItemBuilder().item();
122 | }
123 |
124 | /**
125 | * Returns the head as an ItemStackBuilder.
126 | * @return The head as an {@link ItemStackBuilder}, ready to be completed.
127 | */
128 | // Silence the setOwner deprecation warning, because a string name is the only clean way to get a MHF head.
129 | @SuppressWarnings("deprecation")
130 | public ItemStackBuilder asItemBuilder() {
131 | return new ItemStackBuilder(Material.PLAYER_HEAD)
132 | .withMeta((SkullMeta s) -> s.setOwner(headName));
133 | }
134 | }
135 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/external/ExternalPluginComponent.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. QuartzLib contributors (2015 - 2020)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.quartzlib.external;
32 |
33 | import fr.zcraft.quartzlib.core.QuartzComponent;
34 | import fr.zcraft.quartzlib.tools.PluginLogger;
35 | import org.bukkit.Bukkit;
36 | import org.bukkit.plugin.Plugin;
37 |
38 | /**
39 | * This class is a component to interface with other plugins.
40 | * When enabled, the plugin will be looked for using the provided name, and
41 | * casted to the given class.
42 | * If any of this fails, the component will not be enabled.
43 | * Note these components may even fail during instanciation (if the other
44 | * plugin's classes are not found).
45 | *
46 | * @param The class of the plugin to interface with.
47 | */
48 | public class ExternalPluginComponent extends QuartzComponent {
49 | private final String pluginName;
50 | private T plugin;
51 |
52 | /**
53 | * Instantiates a new external plugin component with the given name.
54 | *
55 | * @param pluginName The name of the plugin to interface with.
56 | */
57 | protected ExternalPluginComponent(String pluginName) {
58 | this.pluginName = pluginName;
59 | }
60 |
61 | @Override
62 | protected final void onEnable() {
63 | Plugin bukkitPlugin = Bukkit.getServer().getPluginManager().getPlugin(pluginName);
64 | if (bukkitPlugin == null) {
65 | setEnabled(false);
66 | return;
67 | } else if (!bukkitPlugin.isEnabled()) {
68 | // We try to load the plugin (required if we're a startup plugin
69 | // depending on a non-startup one).
70 | Bukkit.getServer().getPluginManager().enablePlugin(bukkitPlugin);
71 | if (!bukkitPlugin.isEnabled()) {
72 | setEnabled(false);
73 | return;
74 | }
75 | }
76 |
77 | try {
78 | plugin = (T) bukkitPlugin;
79 | } catch (Exception e) {
80 | PluginLogger.error("Exception while loading plugin '{0}'. Is it up-to-date ?", e, pluginName);
81 | this.setEnabled(false);
82 | return;
83 | }
84 |
85 | onLoad();
86 | }
87 |
88 | /**
89 | * Returns the external plugin.
90 | * If this component failed to inizialize, an IllegalStateException will be
91 | * thrown.
92 | *
93 | * @return The external plugin.
94 | */
95 | protected T get() {
96 | if (!this.isEnabled()) {
97 | throw new IllegalStateException("External plugin " + pluginName + " could not be loaded.");
98 | }
99 | return plugin;
100 | }
101 |
102 | /**
103 | * This method is called after the external plugin has been found.
104 | * It replaces onEnable().
105 | */
106 | protected void onLoad() {
107 | }
108 |
109 | /**
110 | * Returns the name of the external plugin.
111 | *
112 | * @return The specified name of the external plugin.
113 | */
114 | public String getPluginName() {
115 | return pluginName;
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/components/configuration/ConfigurationMap.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. QuartzLib contributors (2015 - 2020)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.quartzlib.components.configuration;
32 |
33 | import java.util.Collection;
34 | import java.util.Collections;
35 | import java.util.Iterator;
36 | import java.util.Map;
37 | import java.util.Map.Entry;
38 | import java.util.Set;
39 |
40 | public class ConfigurationMap extends ConfigurationItem> implements Map, Iterable> {
41 | private final Class keyType;
42 | private final Class valueType;
43 |
44 | /**
45 | * Creates a new configuration map.
46 | */
47 | public ConfigurationMap(String name, Map defaultValue, Class keyType, Class valueType,
48 | String... deprecatedNames) {
49 | super(name, defaultValue, deprecatedNames);
50 | this.keyType = keyType;
51 | this.valueType = valueType;
52 | }
53 |
54 | @Override
55 | protected Map getValue(Object value) throws ConfigurationParseException {
56 | if (value == null) {
57 | return null;
58 | }
59 |
60 | return ConfigurationValueHandlers.handleMapValue(value, keyType, valueType, this);
61 | }
62 |
63 | @Override
64 | boolean validate() {
65 | boolean isValid = super.validate();
66 |
67 | if (ConfigurationSection.class.isAssignableFrom(valueType)) {
68 | for (Object value : values()) {
69 | if (!((ConfigurationSection) value).validate()) {
70 | isValid = false;
71 | }
72 | }
73 | }
74 |
75 | return isValid;
76 | }
77 |
78 | @Override
79 | public int size() {
80 | return get().size();
81 | }
82 |
83 | @Override
84 | public boolean isEmpty() {
85 | return get().isEmpty();
86 | }
87 |
88 | @Override
89 | public boolean containsKey(Object key) {
90 | return get().containsKey(key);
91 | }
92 |
93 | @Override
94 | public boolean containsValue(Object value) {
95 | return get().containsValue(value);
96 | }
97 |
98 | @Override
99 | public V get(Object key) {
100 | return get().get(key);
101 | }
102 |
103 | @Override
104 | public V put(K key, V value) {
105 | throw new UnsupportedOperationException();
106 | }
107 |
108 | @Override
109 | public V remove(Object key) {
110 | throw new UnsupportedOperationException();
111 | }
112 |
113 | @Override
114 | public void putAll(Map m) {
115 | throw new UnsupportedOperationException();
116 | }
117 |
118 | @Override
119 | public void clear() {
120 | throw new UnsupportedOperationException();
121 | }
122 |
123 | @Override
124 | public Set keySet() {
125 | return Collections.unmodifiableSet(get().keySet());
126 | }
127 |
128 | @Override
129 | public Collection values() {
130 | return Collections.unmodifiableCollection(get().values());
131 | }
132 |
133 | @Override
134 | public Set> entrySet() {
135 | return Collections.unmodifiableSet(get().entrySet());
136 | }
137 |
138 | @Override
139 | public Iterator> iterator() {
140 | return entrySet().iterator();
141 | }
142 | }
143 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/tools/runners/RunTask.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. QuartzLib contributors (2015 - 2020)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.quartzlib.tools.runners;
32 |
33 | import fr.zcraft.quartzlib.core.QuartzLib;
34 | import org.bukkit.Bukkit;
35 | import org.bukkit.scheduler.BukkitRunnable;
36 | import org.bukkit.scheduler.BukkitScheduler;
37 | import org.bukkit.scheduler.BukkitTask;
38 |
39 |
40 | /**
41 | * This utility class shortens the code used to execute tasks.
42 | */
43 | public final class RunTask {
44 | private static final BukkitScheduler scheduler = Bukkit.getScheduler();
45 |
46 | private RunTask() {
47 | }
48 |
49 | /**
50 | * Returns a task that will run on the next server tick.
51 | *
52 | * @param runnable The task to be run.
53 | * @return The BukkitTask that will run.
54 | */
55 | public static BukkitTask nextTick(Runnable runnable) {
56 | return scheduler.runTask(QuartzLib.getPlugin(), runnable);
57 | }
58 |
59 | /**
60 | * Returns a task that will run on the next server tick.
61 | *
62 | * @param runnable The task to be run.
63 | * @return The BukkitTask that will run.
64 | */
65 | public static BukkitTask nextTick(BukkitRunnable runnable) {
66 | return runnable.runTask(QuartzLib.getPlugin());
67 | }
68 |
69 | /**
70 | * Returns a task that will run after the specified number of server ticks.
71 | *
72 | * @param runnable The task to be run.
73 | * @param delay The ticks to wait before running the task.
74 | * @return The BukkitTask that will run.
75 | */
76 | public static BukkitTask later(Runnable runnable, long delay) {
77 | return scheduler.runTaskLater(QuartzLib.getPlugin(), runnable, delay);
78 | }
79 |
80 | /**
81 | * Returns a task that will run after the specified number of server ticks.
82 | *
83 | * @param runnable The task to be run.
84 | * @param delay The ticks to wait before running the task.
85 | * @return The BukkitTask that will run.
86 | */
87 | public static BukkitTask later(BukkitRunnable runnable, long delay) {
88 | return runnable.runTaskLater(QuartzLib.getPlugin(), delay);
89 | }
90 |
91 | /**
92 | * Returns a task that will repeatedly run until cancelled, starting after the specified number
93 | * of server ticks.
94 | *
95 | * @param runnable The task to be run.
96 | * @param wait The ticks to wait before running the task.
97 | * @param period The ticks to wait between runs
98 | * @return The BukkitTask that will run.
99 | */
100 | public static BukkitTask timer(Runnable runnable, long wait, long period) {
101 | return scheduler.runTaskTimer(QuartzLib.getPlugin(), runnable, wait, period);
102 | }
103 |
104 | /**
105 | * Returns a task that will repeatedly run until cancelled, starting after the specified number
106 | * of server ticks.
107 | *
108 | * @param runnable The task to be run.
109 | * @param wait The ticks to wait before running the task.
110 | * @param period The ticks to wait between runs
111 | * @return The BukkitTask that will run.
112 | */
113 | public static BukkitTask timer(BukkitRunnable runnable, long wait, long period) {
114 | return runnable.runTaskTimer(QuartzLib.getPlugin(), wait, period);
115 | }
116 | }
117 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/tools/PluginLogger.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. QuartzLib contributors (2015 - 2020)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.quartzlib.tools;
32 |
33 | import fr.zcraft.quartzlib.core.QuartzLib;
34 | import java.util.HashMap;
35 | import java.util.logging.Level;
36 | import java.util.logging.LogRecord;
37 | import java.util.logging.Logger;
38 |
39 | public final class PluginLogger {
40 | private static Thread mainThread;
41 | private static HashMap loggers;
42 |
43 | private PluginLogger() {
44 | }
45 |
46 | public static void init() {
47 | mainThread = Thread.currentThread();
48 | loggers = new HashMap<>();
49 | }
50 |
51 | public static void log(Level level, String message, Throwable ex) {
52 | getLogger().log(level, message, ex);
53 | }
54 |
55 | public static void log(Level level, String message, Object... args) {
56 | getLogger().log(level, message, args);
57 | }
58 |
59 | public static void log(Level level, String message, Throwable ex, Object... args) {
60 | log(level, message, args);
61 | log(level, "Exception : ", ex);
62 | }
63 |
64 | public static void info(String message, Object... args) {
65 | log(Level.INFO, message, args);
66 | }
67 |
68 | public static void warning(String message, Object... args) {
69 | log(Level.WARNING, message, args);
70 | }
71 |
72 | public static void warning(String message, Throwable ex) {
73 | log(Level.WARNING, message, ex);
74 | }
75 |
76 | public static void warning(String message, Throwable ex, Object... args) {
77 | log(Level.WARNING, message, ex, args);
78 | }
79 |
80 | public static void error(String message) {
81 | log(Level.SEVERE, message);
82 | }
83 |
84 | public static void error(String message, Throwable ex) {
85 | log(Level.SEVERE, message, ex);
86 | }
87 |
88 | public static void error(String message, Throwable ex, Object... args) {
89 | log(Level.SEVERE, message, ex, args);
90 | }
91 |
92 | public static void error(String message, Object... args) {
93 | log(Level.SEVERE, message, args);
94 | }
95 |
96 | private static Logger getLogger() {
97 | Thread currentThread = Thread.currentThread();
98 | if (currentThread.equals(mainThread)) {
99 | return QuartzLib.getPlugin().getLogger();
100 | }
101 | return getLogger(currentThread);
102 | }
103 |
104 | private static Logger getLogger(Thread thread) {
105 | PluginThreadLogger logger = loggers.get(thread);
106 | if (logger == null) {
107 | logger = new PluginThreadLogger(thread);
108 | loggers.put(thread, logger);
109 | }
110 | return logger;
111 | }
112 |
113 | private static class PluginThreadLogger extends Logger {
114 | private final String loggerName;
115 |
116 | public PluginThreadLogger(Thread thread) {
117 | super(QuartzLib.getPlugin().getClass().getCanonicalName(), null);
118 | setParent(QuartzLib.getPlugin().getLogger());
119 | setLevel(Level.ALL);
120 | loggerName = "[" + thread.getName() + "] ";
121 | }
122 |
123 | @Override
124 | public void log(LogRecord logRecord) {
125 | logRecord.setMessage(loggerName + logRecord.getMessage());
126 | super.log(logRecord);
127 | }
128 | }
129 | }
130 |
--------------------------------------------------------------------------------
/ztoaster/src/main/java/fr/zcraft/ztoaster/Toaster.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. ZLib contributors (2015)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.ztoaster;
32 |
33 | import fr.zcraft.quartzlib.components.commands.Commands;
34 | import fr.zcraft.quartzlib.components.gui.Gui;
35 | import fr.zcraft.quartzlib.components.i18n.I18n;
36 | import fr.zcraft.quartzlib.components.scoreboard.Sidebar;
37 | import fr.zcraft.quartzlib.components.scoreboard.SidebarScoreboard;
38 | import fr.zcraft.quartzlib.core.QuartzPlugin;
39 | import fr.zcraft.quartzlib.tools.PluginLogger;
40 | import fr.zcraft.quartzlib.tools.items.GlowEffect;
41 | import fr.zcraft.ztoaster.commands.AddCommand;
42 | import fr.zcraft.ztoaster.commands.ListCommand;
43 | import fr.zcraft.ztoaster.commands.OpenCommand;
44 | import java.io.File;
45 | import java.util.ArrayList;
46 | import java.util.Locale;
47 | import org.bukkit.entity.Player;
48 | import org.bukkit.event.EventHandler;
49 | import org.bukkit.event.EventPriority;
50 | import org.bukkit.event.Listener;
51 | import org.bukkit.event.player.PlayerJoinEvent;
52 | import org.bukkit.plugin.PluginDescriptionFile;
53 | import org.bukkit.plugin.java.JavaPluginLoader;
54 |
55 |
56 | public class Toaster extends QuartzPlugin implements Listener {
57 | /**
58 | * A counter for all the toasts created (until toaster restart).
59 | */
60 | private static int toastCounter = 0;
61 |
62 | /**
63 | * A list of all the toasts.
64 | */
65 | private static ArrayList toasts;
66 |
67 | /**
68 | * The screen of the toaster.
69 | */
70 | private Sidebar toasterSidebar;
71 |
72 | public Toaster () {}
73 |
74 | protected Toaster(JavaPluginLoader loader, PluginDescriptionFile description, File dataFolder, File file) {
75 | super(loader, description, dataFolder, file);
76 | }
77 |
78 | /**
79 | * .
80 | * @return The id for a new toast.
81 | */
82 | public static int newToastId() {
83 | return toastCounter++;
84 | }
85 |
86 | /**
87 | * .
88 | * @return an array of all the toasts ever created (until toaster restart).
89 | */
90 | public static Toast[] getToasts() {
91 | return toasts.toArray(new Toast[toasts.size()]);
92 | }
93 |
94 | /**
95 | * Adds a new toast to the world.
96 | *
97 | * @return the newly created toast.
98 | */
99 | public static Toast newToast() {
100 | Toast toast = new Toast();
101 | toasts.add(toast);
102 | return toast;
103 | }
104 |
105 | @Override
106 | public void onEnable() {
107 | PluginLogger.info("Setting up toaster.");
108 |
109 | toasts = new ArrayList<>();
110 | toastCounter = 0;
111 |
112 | loadComponents(Gui.class, Commands.class, ToasterWorker.class, SidebarScoreboard.class, I18n.class, GlowEffect.class);
113 |
114 | Commands.register("toaster", AddCommand.class, OpenCommand.class, ListCommand.class);
115 |
116 | I18n.useDefaultPrimaryLocale();
117 | I18n.setFallbackLocale(Locale.US);
118 |
119 | getServer().getPluginManager().registerEvents(this, this);
120 |
121 |
122 | toasterSidebar = new ToasterSidebar();
123 |
124 | for (Player player : getServer().getOnlinePlayers()) {
125 | toasterSidebar.addRecipient(player);
126 | }
127 |
128 | toasterSidebar.runAutoRefresh(true);
129 | }
130 |
131 | @Override
132 | public void onDisable() {
133 | PluginLogger.info("Unplugging toaster.");
134 | }
135 |
136 | @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
137 | public void onPlayerJoin(PlayerJoinEvent ev) {
138 | toasterSidebar.addRecipient(ev.getPlayer());
139 | }
140 | }
141 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/components/worker/WorkerCallbackManager.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. QuartzLib contributors (2015 - 2020)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.quartzlib.components.worker;
32 |
33 | import fr.zcraft.quartzlib.core.QuartzLib;
34 | import java.util.ArrayDeque;
35 | import java.util.HashMap;
36 | import org.bukkit.Bukkit;
37 | import org.bukkit.scheduler.BukkitTask;
38 |
39 | class WorkerCallbackManager implements Runnable {
40 | private static final int WATCH_LOOP_DELAY = 5;
41 |
42 | private final HashMap callbacks;
43 | private final ArrayDeque callbackQueue;
44 |
45 | private final String name;
46 |
47 | private BukkitTask selfTask;
48 |
49 | public WorkerCallbackManager(String name) {
50 | callbacks = new HashMap<>();
51 | callbackQueue = new ArrayDeque<>();
52 | this.name = name;
53 | }
54 |
55 | public void init() {
56 | selfTask = Bukkit.getScheduler().runTaskTimer(QuartzLib.getPlugin(), this, 0, WATCH_LOOP_DELAY);
57 | }
58 |
59 | public void setupCallback(WorkerRunnable runnable, WorkerCallback callback) {
60 | synchronized (callbacks) {
61 | callbacks.put(runnable, new WorkerRunnableInfo(callback));
62 | }
63 | }
64 |
65 | public void callback(WorkerRunnable runnable, T result) {
66 | callback(runnable, result, null);
67 | }
68 |
69 | public void callback(WorkerRunnable runnable, T result, Throwable exception) {
70 | WorkerRunnableInfo runnableInfo;
71 | synchronized (callbacks) {
72 | runnableInfo = callbacks.get(runnable);
73 | }
74 | if (runnableInfo == null) {
75 | return;
76 | }
77 | runnableInfo.setRunnableException(exception);
78 | runnableInfo.setResult(result);
79 |
80 | enqueueCallback(runnableInfo);
81 | }
82 |
83 | public void exit() {
84 | if (selfTask != null) {
85 | selfTask.cancel();
86 | }
87 | }
88 |
89 | private void enqueueCallback(WorkerRunnableInfo runnableInfo) {
90 | synchronized (callbackQueue) {
91 | callbackQueue.add(runnableInfo);
92 | }
93 | }
94 |
95 | @Override
96 | public void run() {
97 | WorkerRunnableInfo currentRunnableInfo;
98 | synchronized (callbackQueue) {
99 | if (callbackQueue.isEmpty()) {
100 | return;
101 | }
102 | currentRunnableInfo = callbackQueue.pop();
103 | }
104 |
105 | currentRunnableInfo.runCallback();
106 | }
107 |
108 | private class WorkerRunnableInfo {
109 | private final WorkerCallback callback;
110 | private T result;
111 | private Throwable runnableException;
112 |
113 | public WorkerRunnableInfo(WorkerCallback callback) {
114 | this.callback = callback;
115 | this.runnableException = null;
116 | }
117 |
118 | public WorkerCallback getCallback() {
119 | return callback;
120 | }
121 |
122 | public void runCallback() {
123 | if (runnableCrashed()) {
124 | callback.errored(runnableException);
125 | } else {
126 | callback.finished(result);
127 | }
128 | }
129 |
130 | public void setResult(T result) {
131 | this.result = result;
132 | }
133 |
134 | public Throwable getRunnableException() {
135 | return runnableException;
136 | }
137 |
138 | public void setRunnableException(Throwable runnableException) {
139 | this.runnableException = runnableException;
140 | }
141 |
142 | public boolean runnableCrashed() {
143 | return this.runnableException != null;
144 | }
145 | }
146 | }
147 |
--------------------------------------------------------------------------------
/src/main/java/fr/zcraft/quartzlib/components/configuration/ConfigurationSection.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright or © or Copr. QuartzLib contributors (2015 - 2020)
3 | *
4 | * This software is governed by the CeCILL-B license under French law and
5 | * abiding by the rules of distribution of free software. You can use,
6 | * modify and/ or redistribute the software under the terms of the CeCILL-B
7 | * license as circulated by CEA, CNRS and INRIA at the following URL
8 | * "http://www.cecill.info".
9 | *
10 | * As a counterpart to the access to the source code and rights to copy,
11 | * modify and redistribute granted by the license, users are provided only
12 | * with a limited warranty and the software's author, the holder of the
13 | * economic rights, and the successive licensors have only limited
14 | * liability.
15 | *
16 | * In this respect, the user's attention is drawn to the risks associated
17 | * with loading, using, modifying and/or developing or reproducing the
18 | * software by the user in light of its specific status of free software,
19 | * that may mean that it is complicated to manipulate, and that also
20 | * therefore means that it is reserved for developers and experienced
21 | * professionals having in-depth computer knowledge. Users are therefore
22 | * encouraged to load and test the software's suitability as regards their
23 | * requirements in conditions enabling the security of their systems and/or
24 | * data to be ensured and, more generally, to use and operate it in the
25 | * same conditions as regards security.
26 | *
27 | * The fact that you are presently reading this means that you have had
28 | * knowledge of the CeCILL-B license and that you accept its terms.
29 | */
30 |
31 | package fr.zcraft.quartzlib.components.configuration;
32 |
33 | import java.lang.reflect.Field;
34 | import java.util.Collection;
35 | import java.util.Collections;
36 | import java.util.HashMap;
37 | import java.util.Iterator;
38 | import java.util.Map;
39 | import java.util.Set;
40 |
41 | public class ConfigurationSection
42 | extends ConfigurationItem