Added a rules system. (#110)

* NEW: rules can be set in the config and broadcasted to the players when they join and/or when the game start.

src/main/java/eu/carrade/amaury/UHCReloaded/UHCReloaded.java

@@ -47,6 +47,7 @@
 import eu.carrade.amaury.UHCReloaded.misc.MOTDManager;
 import eu.carrade.amaury.UHCReloaded.misc.PlayerListHeaderFooterManager;
 import eu.carrade.amaury.UHCReloaded.misc.ProTipsSender;
+import eu.carrade.amaury.UHCReloaded.misc.RulesManager;
 import eu.carrade.amaury.UHCReloaded.misc.RuntimeCommandsExecutor;
 import eu.carrade.amaury.UHCReloaded.recipes.RecipesManager;
 import eu.carrade.amaury.UHCReloaded.scoreboard.ScoreboardManager;
@@ -72,6 +73,7 @@ public class UHCReloaded extends ZPlugin
     private SpectatorsManager spectatorsManager = null;
     private ScoreboardManager scoreboardManager = null;
     private MOTDManager motdManager = null;
+    private RulesManager rulesManager = null;
     private PlayerListHeaderFooterManager playerListHeaderFooterManager = null;
     private BorderManager borderManager = null;
     private RecipesManager recipesManager = null;
@@ -137,6 +139,7 @@ public void onEnable()
 
         scoreboardManager = new ScoreboardManager(this);
         motdManager = new MOTDManager(this);
+        rulesManager = new RulesManager();
         playerListHeaderFooterManager = new PlayerListHeaderFooterManager();
 
         UHCommandExecutor executor = new UHCommandExecutor(this);
@@ -246,6 +249,14 @@ public MOTDManager getMOTDManager()
         return motdManager;
     }
 
+    /**
+     * @return the rules manager.
+     */
+    public RulesManager getRulesManager()
+    {
+        return rulesManager;
+    }
+
     /**
      * Returns the players list's headers & footers manager.
      *

src/main/java/eu/carrade/amaury/UHCReloaded/listeners/GameListener.java

@@ -470,7 +470,7 @@ public void onPlayerJoin(final PlayerJoinEvent ev)
                 // Teams selector.
                 if (p.getConfig().getBoolean("teams-options.gui.autoDisplay") && p.getTeamManager().getTeams().size() != 0)
                 {
-                    p.getServer().getScheduler().runTaskLater(p, new Runnable()
+                    RunTask.later(new Runnable()
                     {
                         @Override
                         public void run()
@@ -482,6 +482,18 @@ public void run()
                         }
                     }, 20l * p.getConfig().getInt("teams-options.gui.delay"));
                 }
+
+                // Rules
+                if (p.getRulesManager().displayOnJoin())
+                {
+                    RunTask.later(new Runnable() {
+                        @Override
+                        public void run()
+                        {
+                            p.getRulesManager().displayRulesTo(ev.getPlayer());
+                        }
+                    }, 15 * 20l);
+                }
             }
             else
             {
@@ -746,6 +758,18 @@ public void onGameStarts(UHGameStartsEvent ev)
 
         // List headers & footers.
         p.getPlayerListHeaderFooterManager().updateHeadersFooters();
+
+        // Rules
+        if (p.getRulesManager().displayOnStart())
+        {
+            RunTask.later(new Runnable() {
+                @Override
+                public void run()
+                {
+                    p.getRulesManager().broadcastRules();
+                }
+            }, 15 * 20l);
+        }
     }
 
     /**

src/main/java/eu/carrade/amaury/UHCReloaded/misc/RulesManager.java

@@ -0,0 +1,153 @@
+/*
+ * Copyright or © or Copr. Amaury Carrade (2014 - 2016)
+ *
+ * http://amaury.carrade.eu
+ *
+ * This software is governed by the CeCILL-B license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL-B
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ *
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited
+ * liability.
+ *
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ *
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL-B license and that you accept its terms.
+ */
+package eu.carrade.amaury.UHCReloaded.misc;
+
+import eu.carrade.amaury.UHCReloaded.UHCReloaded;
+import eu.carrade.amaury.UHCReloaded.commands.core.utils.CommandUtils;
+import eu.carrade.amaury.UHCReloaded.i18n.I18n;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class RulesManager
+{
+    private final boolean DISPLAY_ON_JOIN;
+    private final boolean DISPLAY_ON_START;
+
+    private final I18n i;
+
+    private final List<String> rules = new ArrayList<>();
+
+
+    public RulesManager()
+    {
+        i = UHCReloaded.i();
+
+        ConfigurationSection config = UHCReloaded.get().getConfig().getConfigurationSection("rules");
+
+        if (config != null)
+        {
+            DISPLAY_ON_JOIN  = config.getBoolean("display.onJoin", false);
+            DISPLAY_ON_START = config.getBoolean("display.onStart", true);
+
+
+            // We check if the list is non-empty, i.e. if there is at least a non-empty rule.
+            boolean empty = true;
+
+            for (String rule : config.getStringList("rules"))
+            {
+                rule = rule.trim();
+                rules.add(ChatColor.translateAlternateColorCodes('&',rule));
+
+                if (!rule.isEmpty())
+                    empty = false;
+            }
+
+            // If the list is empty, no rules are displayed. We reset the list.
+            if (empty) rules.clear();
+        }
+        else
+        {
+            DISPLAY_ON_JOIN  = false;
+            DISPLAY_ON_START = true;
+        }
+    }
+
+    /**
+     * @return {@code true} if the rules system is enabled
+     */
+    public boolean isEnabled()
+    {
+        return rules.size() != 0;
+    }
+
+    /**
+     * @return {@code true} if the rules have to be displayed to every joining player.
+     */
+    public boolean displayOnJoin()
+    {
+        return isEnabled() && DISPLAY_ON_JOIN;
+    }
+
+    /**
+     * @return {@code true} if the rules have to be displayed when the game starts.
+     */
+    public boolean displayOnStart()
+    {
+        return isEnabled() && DISPLAY_ON_START;
+    }
+
+
+    /**
+     * Displays the rules to the given receiver.
+     *
+     * @param receiver The receiver.
+     */
+    public void displayRulesTo(CommandSender receiver)
+    {
+        CommandUtils.displaySeparator(receiver);
+        receiver.sendMessage(i.t("rules.header"));
+
+        for (String rule : rules)
+        {
+            if (rule.isEmpty())
+            {
+                receiver.sendMessage("");
+            }
+            else
+            {
+                receiver.sendMessage(i.t("rules.bullet", rule));
+            }
+        }
+
+        CommandUtils.displaySeparator(receiver);
+    }
+
+    /**
+     * Broadcasts the rules to the whole server.
+     */
+    public void broadcastRules()
+    {
+        for (Player player : Bukkit.getOnlinePlayers())
+        {
+            displayRulesTo(player);
+        }
+
+        displayRulesTo(Bukkit.getConsoleSender());
+    }
+}

src/main/resources/config.yml

@@ -398,6 +398,21 @@ spectatorModeWhenNewPlayerJoinAfterStart: true
 
 
 
+# Rules are a way to display rules & other informations to the players.
+# The content is completly up to you, formatting included (using standard
+# formatting codes with either § or &). It will be displayed as a list to
+# the players (one bullet per line in the `rules.rules` entry).
+# Empty entries (« - "" ») are replaced by a completly blank line, if you
+# need a separator.
+rules:
+    display:
+        onJoin: false
+        onStart: true
+    rules:
+        -
+
+
+
 # Execute commands during the game or after the end of it, and after a configurable delay?
 # Format explained below.
 # Respect the spaces before the keywords ("exec" and "delay" need to be aligned).

src/main/resources/i18n/en_US.yml

@@ -572,3 +572,6 @@ keys:
         start:
             invincibility: "{gray}Fallen on a tree? Jump, you have 25 seconds left to remain invincible."
 
+    rules:
+        header: "{red}{bold}Rules and informations"
+        bullet: "{darkgray}- {reset}{0}"

src/main/resources/i18n/fr_FR.yml

@@ -572,3 +572,6 @@ keys:
         start:
             invincibility: "{gray}Tombé(e) sur un arbre ? Sautez, il vous reste 25 secondes d'invincibilité."
 
+    rules:
+        header: "{red}{bold}Règles et informations"
+        bullet: "{darkgray}- {reset}{0}"