feat: add utility commands (info, kick, quickstart)

.gitignore

@@ -6,5 +6,4 @@
 *.sphinx
 build
 out
-discord-impl/src/main/resources/token.txt
 api/src/main/resources

api/src/main/java/net/starype/quiz/api/database/ByteEntryUpdater.java

@@ -4,6 +4,7 @@
 import net.starype.quiz.api.util.CheckSum;
 
 import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
 import java.util.Collection;
 import java.util.Set;
 
@@ -38,7 +39,7 @@ public CheckSum computeCheckSum() {
 
     @Override
     public Set<DatabaseEntry> generateNewEntries(DatabaseEntryFactory factory) {
-        String text = new String(data);
+        String text = new String(data, StandardCharsets.UTF_8);
         return QuestionParser.getDatabaseEntries(text, factory);
     }
 }

api/src/main/java/net/starype/quiz/api/event/GameUpdatableHandler.java

@@ -37,4 +37,9 @@ public void runAllEvents() {
         this.lastMillis = currentTime;
         eventsList.forEach((updatable -> updatable.update(deltaMillis)));
     }
+
+    @Override
+    public void reset() {
+        this.lastMillis = System.currentTimeMillis();
+    }
 }

api/src/main/java/net/starype/quiz/api/event/UpdatableHandler.java

@@ -25,4 +25,11 @@ public interface UpdatableHandler {
      * @see Updatable
      */
     void runAllEvents();
+
+    /**
+     * Resets the last millis value.
+     * Should be called at the beginning of each new round, since delta times are not calculated between rounds
+     * and would thus cause a huge time gap at the beginning of each round.
+     */
+    void reset();
 }

api/src/main/java/net/starype/quiz/api/game/GuessCounter.java

@@ -30,4 +30,8 @@ public int getPlayerGuess(IDHolder<?> holder) {
     public boolean maxReached(IDHolder<?> holder) {
         return getPlayerGuess(holder) < maxGuesses;
     }
+
+    public boolean isEmpty() {
+        return guessesPerPlayer.isEmpty();
+    }
 }

api/src/main/java/net/starype/quiz/api/game/QuizTimer.java

@@ -7,16 +7,22 @@
 import java.time.Instant;
 import java.util.concurrent.TimeUnit;
 
-public class QuizTimer extends GameUpdatable {
+public class QuizTimer extends GameUpdatable implements EventListener {
     private long time;
-    private TimeUnit unit;
+    private final long shortenedTime;
+    private final TimeUnit unit;
     private Instant startingInstant;
     private Instant currentInstant;
     private UpdatableHandler updatableHandler;
 
     public QuizTimer(TimeUnit unit, long time) {
+        this(unit, time, time);
+    }
+
+    public QuizTimer(TimeUnit unit, long time, long shortenedTime) {
         this.unit = unit;
         this.time = time;
+        this.shortenedTime = shortenedTime;
     }
 
     @Override
@@ -37,7 +43,25 @@ public void update(long deltaMillis) {
         }
     }
 
+    @Override
     public void shutDown() {
         updatableHandler.unregisterEvent(this);
     }
+
+    public long millisLeft() {
+        return unit.toMillis(time) - Duration.between(startingInstant, currentInstant).toMillis();
+    }
+
+    private void shortenRemaining() {
+        if(millisLeft() < unit.toMillis(shortenedTime)) {
+            return;
+        }
+        this.time = shortenedTime;
+        this.startingInstant = Instant.now();
+    }
+
+    @Override
+    public void onNotified() {
+        shortenRemaining();
+    }
 }

api/src/main/java/net/starype/quiz/api/game/SimpleGame.java

@@ -30,11 +30,11 @@
 public class SimpleGame<T extends QuizGame> implements QuizGame {
 
     private ServerGate<T> gate;
-    private Queue<? extends QuizRound> rounds;
-    private Collection<? extends Player<?>> players;
+    private final Queue<? extends QuizRound> rounds;
+    private final Collection<? extends Player<?>> players;
     private final AtomicBoolean paused;
     private boolean waitingForNextRound;
-    private UpdatableHandler updatableHandler = new GameUpdatableHandler();
+    private final UpdatableHandler updatableHandler = new GameUpdatableHandler();
     private boolean over;
 
     public SimpleGame(Queue<? extends QuizRound> rounds, Collection<? extends Player<?>> players) {
@@ -96,7 +96,9 @@ public boolean nextRound() {
             return true;
         }
 
+        waitingForNextRound = false;
         paused.set(false);
+        updatableHandler.reset();
         startHead(false);
         return true;
     }
@@ -215,6 +217,9 @@ public void removePlayer(Object playerId) {
                 .filter(player -> player.getId().equals(playerId))
                 .findAny();
         optPlayer.ifPresent(players::remove);
+        if(!rounds.isEmpty() && !paused.get()) {
+            rounds.element().checkEndOfRound();
+        }
     }
 
     @Override
@@ -237,8 +242,8 @@ private Player<?> findHolder(Object id) {
                 .orElseThrow(error);
     }
 
-    protected Collection<? extends Player<?>> getPlayers() {
-        return players;
+    protected QuizRound getCurrentRound() {
+        return rounds.peek();
     }
 
     public boolean isWaitingForNextRound() {

api/src/main/java/net/starype/quiz/api/parser/QuestionParser.java

@@ -61,7 +61,7 @@ public static Question parse(ReadableRawMap config) {
         return new DefaultQuestion.Builder()
                 .withAnswerEvaluator(evaluator)
                 .withRawText(rawText)
-                .withRawAnswer(String.join(",", rawAnswers))
+                .withRawAnswer(String.join(", ", rawAnswers))
                 .withTags(tags)
                 .withDifficulty(difficulty)
                 .build();

api/src/main/java/net/starype/quiz/api/player/Player.java

@@ -5,11 +5,11 @@
 
 public class Player<T> implements IDHolder<T>, Comparable<Player<?>> {
 
-    private String username;
-    private String nickname;
-    private Score score;
-    private T id;
-    private Collection<Player<?>> children = new ArrayList<>();
+    private final String username;
+    private final String nickname;
+    private final Score score;
+    private final T id;
+    private final Collection<Player<?>> children = new ArrayList<>();
 
     public Player(T id, String username, String nickname) {
         this.username = username;

api/src/main/java/net/starype/quiz/api/round/TimedRaceRoundFactory.java

@@ -33,6 +33,7 @@ public QuizRound create(Question question, int maxGuesses,
                 .addEvent(quizTimer)
                 .withEndingCondition(timeOutEnding)
                 .withPlayerEligibility(new MaxGuess(counter))
+                .addEvent(quizTimer)
                 .build();
 
         quizTimer.addEventListener(round::checkEndOfRound);

api/src/main/java/net/starype/quiz/api/server/ServerGate.java

@@ -27,8 +27,8 @@
  */
 public class ServerGate<T extends QuizGame> {
 
-    private GameServer<? super T> server;
-    private T game;
+    private final GameServer<? super T> server;
+    private final T game;
 
     /**
      * Initialize a gate with the given server and no game.

discord-impl/src/main/java/net/starype/quiz/discordimpl/command/CreateLobbyCommand.java

@@ -26,7 +26,7 @@ public void execute(CommandContext context) {
         Map<Supplier<Boolean>, String> stopConditions = createStopConditions(
                 context.getGameList(),
                 context.getLobbyList(),
-                playerId,
+                author,
                 author.getEffectiveName());
 
         Message message = context.getMessage();
@@ -42,19 +42,19 @@ public void execute(CommandContext context) {
     }
 
     private Map<Supplier<Boolean>, String> createStopConditions(
-            GameList gameList, LobbyList lobbyList, String authorId, String nickName) {
+            GameList gameList, LobbyList lobbyList, Member author, String nickName) {
 
         Map<Supplier<Boolean>, String> conditions = new LinkedHashMap<>();
         conditions.put(
-                () -> lobbyList.findByPlayer(authorId).isPresent(),
+                () -> lobbyList.findByPlayer(author.getId()).isPresent(),
                 nickName + ", you are already in a lobby");
 
         conditions.put(
-                () -> gameList.isPlaying(authorId),
+                () -> gameList.isPlaying(author),
                 nickName + ", you are already playing a game");
 
         conditions.put(
-               () -> !lobbyLimiter.register(authorId.hashCode()),
+               () -> !lobbyLimiter.register(author.hashCode()),
                "Error: Cannot create a new lobby as the maximum number of lobbies has been reached");
 
 

discord-impl/src/main/java/net/starype/quiz/discordimpl/command/ForceNextRoundCommand.java

@@ -1,5 +1,6 @@
 package net.starype.quiz.discordimpl.command;
 
+import net.dv8tion.jda.api.entities.Member;
 import net.dv8tion.jda.api.entities.Message;
 import net.starype.quiz.discordimpl.game.DiscordQuizGame;
 import net.starype.quiz.discordimpl.game.GameList;
@@ -12,28 +13,31 @@ public class ForceNextRoundCommand implements QuizCommand {
     @Override
     public void execute(CommandContext context) {
         GameList gameList = context.getGameList();
-        String playerId = context.getAuthor().getId();
+        Member player = context.getAuthor();
         Message message = context.getMessage();
 
-        Map<Supplier<Boolean>, String> conditions = createStopConditions(gameList, playerId);
+        Map<Supplier<Boolean>, String> conditions = createStopConditions(gameList, player);
 
         if(StopConditions.shouldStop(conditions, context.getChannel(), message)) {
             return;
         }
 
-        DiscordQuizGame game = gameList.getFromPlayer(playerId).get();
+        DiscordQuizGame game = gameList.getFromPlayer(player).get();
         game.addLog(message.getId());
         game.nextRound();
         message.addReaction("\uD83D\uDC4D").queue();
     }
 
-    public static Map<Supplier<Boolean>, String> createStopConditions(GameList gameList, String authorId) {
+    public static Map<Supplier<Boolean>, String> createStopConditions(GameList gameList, Member author) {
         Map<Supplier<Boolean>, String> conditions = NextRoundCommand.createStopConditions(
                 gameList,
-                authorId
+                author
         );
         conditions.put(
-                () -> !gameList.getFromPlayer(authorId).get().isAuthor(authorId),
+                () -> gameList.getFromPlayer(author).isEmpty(),
+                "You need to be in a game to use this");
+        conditions.put(
+                () -> !gameList.getFromPlayer(author).get().isAuthor(author.getId()),
                 "Only the game creator can use this command");
         return conditions;
     }

discord-impl/src/main/java/net/starype/quiz/discordimpl/command/GenerateDatabaseCommand.java

@@ -46,7 +46,7 @@ public void execute(CommandContext context) {
     }
 
     private static Optional<InputStream> generateFile(String urlName, TextChannel channel) {
-        Collection<? extends EntryUpdater> updaters = InputUtils.loadEntryUpdaters(urlName, channel);
+        Collection<? extends EntryUpdater> updaters = InputUtils.loadEntryUpdatersFromUrl(urlName, channel);
         AtomicReference<ByteBuffer> output = new AtomicReference<>();
         SerializedIO serializedIO = new ByteSerializedIO(new byte[0], output);
         TrackedDatabase db = new QuestionDatabase(updaters, serializedIO, false);

discord-impl/src/main/java/net/starype/quiz/discordimpl/command/InfoCommand.java

@@ -0,0 +1,96 @@
+package net.starype.quiz.discordimpl.command;
+
+import net.dv8tion.jda.api.EmbedBuilder;
+import net.dv8tion.jda.api.entities.Member;
+import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.TextChannel;
+import net.starype.quiz.discordimpl.game.DiscordQuizGame;
+import net.starype.quiz.discordimpl.game.GameList;
+import net.starype.quiz.discordimpl.game.GameLobby;
+import net.starype.quiz.discordimpl.game.LobbyList;
+import net.starype.quiz.discordimpl.util.MessageUtils;
+
+import java.awt.*;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.function.Supplier;
+
+public class InfoCommand implements QuizCommand {
+
+    @Override
+    public void execute(CommandContext context) {
+
+        GameList gameList = context.getGameList();
+        LobbyList lobbyList = context.getLobbyList();
+        TextChannel channel = context.getChannel();
+        Member member = context.getAuthor();
+
+        Map<Supplier<Boolean>, String> conditions = createStopConditions(lobbyList, gameList, member);
+        if(StopConditions.shouldStop(conditions, channel, context.getMessage())) {
+            return;
+        }
+
+        Optional<GameLobby> lobby = lobbyList.findByPlayer(member.getId());
+        if(lobby.isPresent()) {
+            displayLobbyInfo(lobby.get(), channel);
+        } else {
+            displayGameInfo(gameList.getFromPlayer(member).get(), channel);
+        }
+    }
+
+    private static void displayLobbyInfo(GameLobby lobby, TextChannel channel) {
+        EmbedBuilder builder = new EmbedBuilder();
+        builder.setColor(Color.CYAN);
+
+        builder.addField("lobby ID", lobby.getName(), false);
+        builder.addBlankField(false);
+        builder.addField("Players", String.join(", ", lobby.retrieveNames()), false);
+        builder.addField("Question count", String.valueOf(lobby.questionCount()), false);
+
+        MessageUtils.sendAndTrack(builder.build(), channel, lobby);
+    }
+
+    private static void displayGameInfo(DiscordQuizGame game, TextChannel channel) {
+        EmbedBuilder builder = new EmbedBuilder();
+        builder.setColor(Color.ORANGE);
+
+        if(game.isOutOfRounds() && game.isWaitingForNextRound()) {
+            builder.addField("Game Status", "Waiting to display results", false);
+            builder.addBlankField(false);
+            builder.addField("Not ready yet", String.join(", ", game.haveNotVoted()), false);
+        }
+        else if(!game.hasRoundStarted()) {
+            builder.addField("Game Status", "Waiting for next round", false);
+            builder.addBlankField(false);
+            builder.addField("Not ready yet", String.join(", ", game.haveNotVoted()), false);
+        } else if(!game.isCurrentRoundFinished()){
+            builder.addField("Game Status", "Round in progress", false);
+            builder.addBlankField(false);
+            builder.addField("Waiting for", String.join(", ", game.waitingFor()), false);
+            builder.addField("Have answered", String.join(", ", game.haveAnswered()), false);
+        }
+
+        channel.sendMessageEmbeds(builder.build())
+                .map(Message::getId)
+                .queue(game::addLog);
+    }
+
+    private static Map<Supplier<Boolean>, String> createStopConditions(LobbyList lobbyList, GameList gameList, Member author) {
+        Map<Supplier<Boolean>, String> conditions = new LinkedHashMap<>();
+        conditions.put(
+                () -> lobbyList.findByPlayer(author.getId()).isEmpty() && gameList.getFromPlayer(author).isEmpty(),
+                "You must belong to either a lobby or a game");
+        return conditions;
+    }
+
+    @Override
+    public String getName() {
+        return "info";
+    }
+
+    @Override
+    public String getDescription() {
+        return "Get relevant information on your lobby/game";
+    }
+}