diff options
Diffstat (limited to 'EssentialsUpdate/src/net/ess3/update/states')
12 files changed, 734 insertions, 0 deletions
diff --git a/EssentialsUpdate/src/net/ess3/update/states/AbstractState.java b/EssentialsUpdate/src/net/ess3/update/states/AbstractState.java new file mode 100644 index 000000000..5d4e03a2c --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/AbstractState.java @@ -0,0 +1,115 @@ +package net.ess3.update.states; + +import net.ess3.update.AbstractWorkListener; +import net.ess3.update.AbstractWorkListener; +import org.bukkit.entity.Player; + + +public abstract class AbstractState +{ + private transient boolean abortion = false; + private final transient StateMap stateMap; + + public AbstractState(final StateMap stateMap) + { + this.stateMap = stateMap; + } + + public <T extends AbstractState> T getState(final Class<? extends T> stateClass) + { + if (!stateMap.containsKey(stateClass)) + { + try + { + final AbstractState state = stateClass.getConstructor(StateMap.class).newInstance(stateMap); + stateMap.put(stateClass, state); + } + catch (Exception ex) + { + /* + * This should never happen. All states, that are added to the map automatically, have to have a + * Constructor that accepts the StateMap. + */ + throw new RuntimeException(ex); + } + } + return (T)stateMap.get(stateClass); + } + + public abstract AbstractState getNextState(); + + /** + * Check if we already know the answer, so the user does not have to answer the question. + * + * @return true, if the answer could be guessed. + */ + public boolean guessAnswer() + { + return false; + } + + /** + * Ask the user the question. + * + * @param sender + */ + public abstract void askQuestion(Player sender); + + /** + * React on the answer and set internal variables + * + * @param answer + * @return true, if the answer could be recognized as a valid answer + */ + public abstract boolean reactOnAnswer(String answer); + + public final AbstractState reactOnAnswer(final Player sender, final String answer) + { + final String trimmedAnswer = answer.trim(); + if (trimmedAnswer.equalsIgnoreCase("quit") + || trimmedAnswer.equalsIgnoreCase("bye") + || trimmedAnswer.equalsIgnoreCase("abort") + || trimmedAnswer.equalsIgnoreCase("cancel") + || trimmedAnswer.equalsIgnoreCase("exit")) + { + abort(); + return null; + } + try + { + final boolean found = reactOnAnswer(trimmedAnswer); + if (found) + { + return getNextState(); + } + else + { + sender.sendMessage("Answer not recognized."); + return this; + } + } + catch (RuntimeException ex) + { + sender.sendMessage(ex.toString()); + return this; + } + } + + /** + * Do something based on the answer, that the user gave. + */ + public void doWork(final AbstractWorkListener listener) + { + listener.onWorkDone(); + } + + public boolean isAbortion() + { + return abortion; + } + + protected void abort() + { + abortion = true; + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/AbstractYesNoState.java b/EssentialsUpdate/src/net/ess3/update/states/AbstractYesNoState.java new file mode 100644 index 000000000..3ee7d0ee2 --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/AbstractYesNoState.java @@ -0,0 +1,57 @@ +package net.ess3.update.states; + + +public abstract class AbstractYesNoState extends AbstractState +{ + private boolean answer = false; + private final transient Class<? extends AbstractState> yesState; + private final transient Class<? extends AbstractState> noState; + + public AbstractYesNoState(final StateMap states, final Class<? extends AbstractState> nextState) + { + this(states, nextState, nextState); + } + + public AbstractYesNoState(final StateMap states, final Class<? extends AbstractState> yesState, final Class<? extends AbstractState> noState) + { + super(states); + this.yesState = yesState; + this.noState = noState; + } + + @Override + public AbstractState getNextState() + { + return answer + ? (yesState == null ? null : getState(yesState)) + : (noState == null ? null : getState(noState)); + } + + @Override + public boolean reactOnAnswer(final String answer) + { + if (answer.equalsIgnoreCase("yes") + || answer.equalsIgnoreCase("y")) + { + this.answer = true; + return true; + } + if (answer.equalsIgnoreCase("no") + || answer.equalsIgnoreCase("n")) + { + this.answer = false; + return true; + } + return false; + } + + public boolean getAnswer() + { + return answer; + } + + protected void setAnswer(final boolean answer) + { + this.answer = answer; + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/AdvancedMode.java b/EssentialsUpdate/src/net/ess3/update/states/AdvancedMode.java new file mode 100644 index 000000000..8ddf06eeb --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/AdvancedMode.java @@ -0,0 +1,20 @@ +package net.ess3.update.states; + +import org.bukkit.entity.Player; + + +public class AdvancedMode extends AbstractYesNoState +{ + public AdvancedMode(final StateMap states) + { + super(states, EssentialsChat.class); + } + + @Override + public void askQuestion(final Player sender) + { + sender.sendMessage("This installation mode has a lot of options."); + sender.sendMessage("Do you want use the advanced mode to see all questions?"); + sender.sendMessage("Otherwise the default values will be used."); + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/Changelog.java b/EssentialsUpdate/src/net/ess3/update/states/Changelog.java new file mode 100644 index 000000000..42fdc8ca2 --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/Changelog.java @@ -0,0 +1,91 @@ +package net.ess3.update.states; + +import net.ess3.update.UpdateCheck; +import net.ess3.update.VersionInfo; +import java.util.List; +import org.bukkit.entity.Player; + + +public class Changelog extends AbstractState +{ + private static final int CHANGES_PER_PAGE = 5; + private transient int page = 0; + private transient boolean confirmed = false; + private transient final List<String> changes; + private transient final int pages; + + public Changelog(final StateMap stateMap) + { + super(stateMap); + changes = getChanges(); + pages = changes.size() / CHANGES_PER_PAGE + (changes.size() % CHANGES_PER_PAGE > 0 ? 1 : 0); + } + + @Override + public AbstractState getNextState() + { + return confirmed ? getState(EssentialsChat.class) : this; + } + + @Override + public boolean guessAnswer() + { + if (pages == 0) + { + confirmed = true; + } + return confirmed; + } + + private List<String> getChanges() + { + final UpdateCheck updateCheck = getState(UpdateOrInstallation.class).getUpdateCheck(); + final VersionInfo versionInfo = updateCheck.getNewVersionInfo(); + return versionInfo.getChangelog(); + } + + @Override + public void askQuestion(final Player sender) + { + if (pages > 1) + { + sender.sendMessage("Changelog, page " + page + " of " + pages + ":"); + } + else + { + sender.sendMessage("Changelog:"); + } + for (int i = page * CHANGES_PER_PAGE; i < Math.min(page * CHANGES_PER_PAGE + CHANGES_PER_PAGE, changes.size()); i++) + { + sender.sendMessage(changes.get(i)); + } + if (pages > 1) + { + sender.sendMessage("Select a page by typing the numbers 1 to " + pages + " to view all changes and then type confirm or abort."); + } + else + { + sender.sendMessage("Type confirm to update Essentials or abort to cancel the update."); + } + } + + @Override + public boolean reactOnAnswer(final String answer) + { + if (answer.equalsIgnoreCase("confirm")) + { + confirmed = true; + return true; + } + if (answer.matches("[0-9]+")) + { + final int page = Integer.parseInt(answer); + if (page <= pages && page > 0) + { + this.page = page - 1; + return true; + } + } + return false; + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/EssentialsChat.java b/EssentialsUpdate/src/net/ess3/update/states/EssentialsChat.java new file mode 100644 index 000000000..a62735f5e --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/EssentialsChat.java @@ -0,0 +1,47 @@ +package net.ess3.update.states; + +import net.ess3.update.AbstractWorkListener; +import net.ess3.update.tasks.InstallModule; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + + +public class EssentialsChat extends AbstractYesNoState +{ + public EssentialsChat(final StateMap states) + { + super(states, EssentialsChatSettings.class); + } + + @Override + public boolean guessAnswer() + { + final Plugin plugin = Bukkit.getPluginManager().getPlugin("EssentialsChat"); + if (plugin != null) + { + setAnswer(true); + return true; + } + return false; + } + + @Override + public void askQuestion(final Player sender) + { + sender.sendMessage("Do you want to install EssentialsChat? (yes/no)"); + sender.sendMessage("EssentialsChat is a simple chat formatting plugin"); + sender.sendMessage("It allows you to make user prefixes and coloured text."); + } + + @Override + public void doWork(final AbstractWorkListener listener) + { + if (getAnswer()) + { + new InstallModule(listener, "EssentialsChat").start(); + return; + } + listener.onWorkDone(); + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/EssentialsChatSettings.java b/EssentialsUpdate/src/net/ess3/update/states/EssentialsChatSettings.java new file mode 100644 index 000000000..db3202ab3 --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/EssentialsChatSettings.java @@ -0,0 +1,29 @@ +package net.ess3.update.states; + +import org.bukkit.entity.Player; + + +public class EssentialsChatSettings extends AbstractYesNoState +{ + public EssentialsChatSettings(final StateMap states) + { + super(states, null); + } + + @Override + public boolean guessAnswer() + { + if (getState(AdvancedMode.class).getAnswer()) + { + setAnswer(false); + return true; + } + return false; + } + + @Override + public void askQuestion(final Player sender) + { + sender.sendMessage("Would you like to configure EssentialsChat to prefix ingame messages with their group?"); + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/EssentialsGeoIP.java b/EssentialsUpdate/src/net/ess3/update/states/EssentialsGeoIP.java new file mode 100644 index 000000000..cd1865b42 --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/EssentialsGeoIP.java @@ -0,0 +1,48 @@ +package net.ess3.update.states; + +import net.ess3.update.AbstractWorkListener; +import net.ess3.update.tasks.InstallModule; +import net.ess3.update.AbstractWorkListener; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + + +public class EssentialsGeoIP extends AbstractYesNoState +{ + public EssentialsGeoIP(final StateMap states) + { + super(states, null); + } + + @Override + public boolean guessAnswer() + { + final Plugin plugin = Bukkit.getPluginManager().getPlugin("EssentialsGeoIP"); + if (plugin != null) + { + setAnswer(true); + return true; + } + return false; + } + + @Override + public void askQuestion(final Player sender) + { + sender.sendMessage("Do you want to install EssentialsGeoIP? (yes/no)"); + sender.sendMessage("EssentialsGeoIP performs a IP lookup on joining players"); + sender.sendMessage("It allows you get a rough idea of where a player is from."); + } + + @Override + public void doWork(final AbstractWorkListener listener) + { + if (getAnswer()) + { + new InstallModule(listener, "EssentialsGeoIP").start(); + return; + } + listener.onWorkDone(); + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/EssentialsProtect.java b/EssentialsUpdate/src/net/ess3/update/states/EssentialsProtect.java new file mode 100644 index 000000000..bb3a841a7 --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/EssentialsProtect.java @@ -0,0 +1,48 @@ +package net.ess3.update.states; + +import net.ess3.update.AbstractWorkListener; +import net.ess3.update.tasks.InstallModule; +import net.ess3.update.AbstractWorkListener; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + + +public class EssentialsProtect extends AbstractYesNoState +{ + public EssentialsProtect(final StateMap states) + { + super(states, null); + } + + @Override + public boolean guessAnswer() + { + final Plugin plugin = Bukkit.getPluginManager().getPlugin("EssentialsProtect"); + if (plugin != null) + { + setAnswer(true); + return true; + } + return false; + } + + @Override + public void askQuestion(final Player sender) + { + sender.sendMessage("Do you want to install EssentialsProtect? (yes/no)"); + sender.sendMessage("EssentialsProtect is a basic world protection system"); + sender.sendMessage("It allows you to set server wide rules, such as disabling creeper explosions, and preventing fire spread."); + } + + @Override + public void doWork(final AbstractWorkListener listener) + { + if (getAnswer()) + { + new InstallModule(listener, "EssentialsProtect").start(); + return; + } + listener.onWorkDone(); + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/InstallationFinishedEvent.java b/EssentialsUpdate/src/net/ess3/update/states/InstallationFinishedEvent.java new file mode 100644 index 000000000..5c38db7ee --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/InstallationFinishedEvent.java @@ -0,0 +1,21 @@ +package net.ess3.update.states; + +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + + +public class InstallationFinishedEvent extends Event +{ + private static final HandlerList handlers = new HandlerList(); + + @Override + public HandlerList getHandlers() + { + return handlers; + } + + public static HandlerList getHandlerList() + { + return handlers; + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/StateMachine.java b/EssentialsUpdate/src/net/ess3/update/states/StateMachine.java new file mode 100644 index 000000000..b66ca4c58 --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/StateMachine.java @@ -0,0 +1,185 @@ +package net.ess3.update.states; + +import net.ess3.update.AbstractWorkListener; +import net.ess3.update.UpdateCheck; +import java.util.Iterator; + +import net.ess3.update.UpdateCheck; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + + +public class StateMachine extends AbstractWorkListener implements Runnable +{ + public enum MachineResult + { + ABORT, WAIT, DONE, NONE + } + private final transient StateMap states = new StateMap(); + private transient AbstractState current; + private transient Player player; + private transient MachineResult result = MachineResult.NONE; + + public StateMachine(final Plugin plugin, final Player player, final UpdateCheck updateCheck) + { + super(plugin, updateCheck.getNewVersionInfo()); + this.player = player; + states.clear(); + final UpdateOrInstallation state = new UpdateOrInstallation(states, updateCheck); + current = states.put(UpdateOrInstallation.class, state); + } + + public MachineResult askQuestion() + { + try + { + while (current.guessAnswer()) + { + current = current.getNextState(); + if (current == null) + { + result = MachineResult.DONE; + break; + } + } + if (current != null) + { + if (player.isOnline()) + { + current.askQuestion(player); + } + result = MachineResult.WAIT; + } + } + catch (RuntimeException ex) + { + player.sendMessage(ex.getMessage()); + finish(); + result = MachineResult.ABORT; + } + return result; + } + + public MachineResult reactOnMessage(final String message) + { + result = MachineResult.NONE; + final AbstractState next = current.reactOnAnswer(player, message); + if (next == null) + { + if (current.isAbortion()) + { + finish(); + result = MachineResult.ABORT; + } + else + { + result = MachineResult.DONE; + } + } + else + { + current = next; + askQuestion(); + } + return result; + } + private transient Iterator<AbstractState> iterator; + + public void startWork() + { + iterator = states.values().iterator(); + Bukkit.getScheduler().scheduleAsyncDelayedTask(getPlugin(), this); + } + + @Override + public void run() + { + if (!iterator.hasNext()) + { + Bukkit.getScheduler().scheduleSyncDelayedTask(getPlugin(), new Runnable() + { + @Override + public void run() + { + if (StateMachine.this.player.isOnline()) + { + StateMachine.this.player.sendMessage("Installation done. Reloading server."); + } + finish(); + Bukkit.getServer().reload(); + } + }); + return; + } + final AbstractState state = iterator.next(); + state.doWork(this); + } + + @Override + public void onWorkAbort(final String message) + { + finish(); + Bukkit.getScheduler().scheduleSyncDelayedTask(getPlugin(), new Runnable() + { + @Override + public void run() + { + if (message != null && !message.isEmpty() && StateMachine.this.player.isOnline()) + { + StateMachine.this.player.sendMessage(message); + } + } + }); + } + + @Override + public void onWorkDone(final String message) + { + Bukkit.getScheduler().scheduleSyncDelayedTask(getPlugin(), new Runnable() + { + @Override + public void run() + { + if (message != null && !message.isEmpty() && StateMachine.this.player.isOnline()) + { + StateMachine.this.player.sendMessage(message); + } + Bukkit.getScheduler().scheduleAsyncDelayedTask(getPlugin(), StateMachine.this); + } + }); + } + + private void finish() + { + current = null; + iterator = null; + states.clear(); + getPlugin().getServer().getPluginManager().callEvent(new InstallationFinishedEvent()); + } + + public void resumeInstallation(final Player player) + { + this.player = player; + if (result == MachineResult.WAIT) + { + if (current == null) + { + throw new RuntimeException("State is WAIT, but current state is null!"); + } + current.askQuestion(player); + } + if (result == MachineResult.DONE && iterator != null) + { + player.sendMessage("Installation is still running."); + } + if (result == MachineResult.ABORT) + { + throw new RuntimeException("Player should not be able to resume an aborted installation."); + } + if (result == MachineResult.NONE) + { + throw new RuntimeException("State machine in an undefined state."); + } + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/StateMap.java b/EssentialsUpdate/src/net/ess3/update/states/StateMap.java new file mode 100644 index 000000000..397ef7c81 --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/StateMap.java @@ -0,0 +1,12 @@ +package net.ess3.update.states; + +import java.util.LinkedHashMap; + + +public class StateMap extends LinkedHashMap<Class<? extends AbstractState>, AbstractState> +{ + public StateMap() + { + super(50); + } +} diff --git a/EssentialsUpdate/src/net/ess3/update/states/UpdateOrInstallation.java b/EssentialsUpdate/src/net/ess3/update/states/UpdateOrInstallation.java new file mode 100644 index 000000000..c7bd5127a --- /dev/null +++ b/EssentialsUpdate/src/net/ess3/update/states/UpdateOrInstallation.java @@ -0,0 +1,61 @@ +package net.ess3.update.states; + +import net.ess3.update.UpdateCheck; +import net.ess3.update.UpdateCheck; +import org.bukkit.entity.Player; + + +public class UpdateOrInstallation extends AbstractState +{ + private final transient UpdateCheck updateCheck; + private transient boolean update = false; + + public UpdateOrInstallation(final StateMap stateMap, final UpdateCheck updateCheck) + { + super(stateMap); + this.updateCheck = updateCheck; + } + + @Override + public boolean guessAnswer() + { + if (getUpdateCheck().isEssentialsInstalled()) + { + update = true; + } + return update; + } + + @Override + public AbstractState getNextState() + { + return update ? getState(Changelog.class) : getState(EssentialsChat.class); + } + + @Override + public void askQuestion(final Player sender) + { + sender.sendMessage("Thank you for choosing Essentials."); + sender.sendMessage("The following installation wizard will guide you through the installation of Essentials."); + sender.sendMessage("Your answers will be saved for a later update."); + sender.sendMessage("Please answer the messages with yes or no, if not otherwise stated."); + sender.sendMessage("Write bye/exit/quit if you want to exit the wizard at anytime."); + sender.sendMessage("Type ok to continue..."); + } + + @Override + public boolean reactOnAnswer(final String answer) + { + return answer.equalsIgnoreCase("ok") || answer.equalsIgnoreCase("k") || answer.equalsIgnoreCase("continue"); + } + + public UpdateCheck getUpdateCheck() + { + return updateCheck; + } + + public boolean isUpdate() + { + return update; + } +} |