Add player retention analysis graph (#2917)

Adds a graph to network and server pages that has options to:
- Draw graphs at different time resolutions
- Limit input data by time
- Group players by register date or join address
- Visualize retention in different ways
  - Time since registration date
  - Playtime
  - Date
  - Cumulative player gain
  - Percentage / Player count / Stacked player count

Any and all combinations are allowed which allows extensive analysis of player retention. Help sections attempt to make the data understandable and show examples.

Affects issues:
- Close #2159

Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/RetentionData.java

@@ -0,0 +1,86 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.delivery.domain;
+
+import java.util.Objects;
+import java.util.UUID;
+
+/**
+ * Represents data that can be used to calculate player retention for a specific player.
+ *
+ * @author AuroraLS3
+ */
+public class RetentionData {
+
+    private final UUID playerUUID;
+    private final long registerDate;
+    private final long lastSeenDate;
+    private final long playtime;
+    private final long timeDifference;
+
+    public RetentionData(UUID playerUUID, long registerDate, long lastSeenDate, long playtime) {
+        this.playerUUID = playerUUID;
+        this.registerDate = registerDate;
+        this.lastSeenDate = lastSeenDate;
+        this.playtime = playtime;
+        timeDifference = lastSeenDate - registerDate;
+    }
+
+    public UUID getPlayerUUID() {
+        return playerUUID;
+    }
+
+    public long getRegisterDate() {
+        return registerDate;
+    }
+
+    public long getLastSeenDate() {
+        return lastSeenDate;
+    }
+
+    public long getTimeDifference() {
+        return timeDifference;
+    }
+
+    public long getPlaytime() {
+        return playtime;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        RetentionData that = (RetentionData) o;
+        return getRegisterDate() == that.getRegisterDate() && getLastSeenDate() == that.getLastSeenDate() && getPlaytime() == that.getPlaytime() && getTimeDifference() == that.getTimeDifference() && Objects.equals(getPlayerUUID(), that.getPlayerUUID());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getPlayerUUID(), getRegisterDate(), getLastSeenDate(), getPlaytime(), getTimeDifference());
+    }
+
+    @Override
+    public String toString() {
+        return "RetentionData{" +
+                "playerUUID=" + playerUUID +
+                ", registerDate=" + registerDate +
+                ", lastSeenDate=" + lastSeenDate +
+                ", playtime=" + playtime +
+                ", timeDifference=" + timeDifference +
+                '}';
+    }
+}

Plan/common/src/main/java/com/djrapitops/plan/delivery/export/NetworkPageExporter.java

@@ -126,6 +126,7 @@ public class NetworkPageExporter extends FileExporter {
                 "network/sessions",
                 "network/playerbase",
                 "network/join-addresses",
+                "network/retention",
                 "network/players",
                 "network/geolocations",
                 "network/plugins-overview",
@@ -166,7 +167,9 @@ public class NetworkPageExporter extends FileExporter {
                 "graph?type=uniqueAndNew",
                 "network/pingTable",
                 "sessions",
-                "extensionData?server=" + serverUUID
+                "extensionData?server=" + serverUUID,
+                "retention",
+                "joinAddresses"
         );
     }
 

Plan/common/src/main/java/com/djrapitops/plan/delivery/export/ServerPageExporter.java

@@ -142,6 +142,7 @@ public class ServerPageExporter extends FileExporter {
                 server + serverUUID + "/pvppve",
                 server + serverUUID + "/playerbase",
                 server + serverUUID + "/join-addresses",
+                server + serverUUID + "/retention",
                 server + serverUUID + "/players",
                 server + serverUUID + "/geolocations",
                 server + serverUUID + "/performance",
@@ -190,7 +191,9 @@ public class ServerPageExporter extends FileExporter {
                 "pingTable?server=" + serverUUID,
                 "sessions?server=" + serverUUID,
                 "extensionData?server=" + serverUUID,
-                "serverIdentity?server=" + serverUUID
+                "serverIdentity?server=" + serverUUID,
+                "retention?server=" + serverUUID,
+                "joinAddresses?server=" + serverUUID
         );
     }
 

Plan/common/src/main/java/com/djrapitops/plan/delivery/rendering/json/JSONFactory.java

@@ -17,6 +17,7 @@
 package com.djrapitops.plan.delivery.rendering.json;
 
 import com.djrapitops.plan.delivery.domain.DateObj;
+import com.djrapitops.plan.delivery.domain.RetentionData;
 import com.djrapitops.plan.delivery.domain.datatransfer.ServerDto;
 import com.djrapitops.plan.delivery.domain.mutators.PlayerKillMutator;
 import com.djrapitops.plan.delivery.domain.mutators.SessionsMutator;
@@ -43,6 +44,7 @@ import com.djrapitops.plan.settings.theme.ThemeVal;
 import com.djrapitops.plan.storage.database.DBSystem;
 import com.djrapitops.plan.storage.database.Database;
 import com.djrapitops.plan.storage.database.queries.analysis.PlayerCountQueries;
+import com.djrapitops.plan.storage.database.queries.analysis.PlayerRetentionQueries;
 import com.djrapitops.plan.storage.database.queries.objects.*;
 import com.djrapitops.plan.storage.database.queries.objects.playertable.NetworkTablePlayersQuery;
 import com.djrapitops.plan.storage.database.queries.objects.playertable.ServerTablePlayersQuery;
@@ -128,6 +130,26 @@ public class JSONFactory {
         ).toJSONMap();
     }
 
+    public List<RetentionData> playerRetentionAsJSONMap(ServerUUID serverUUID) {
+        Database db = dbSystem.getDatabase();
+        return db.query(PlayerRetentionQueries.fetchRetentionData(serverUUID));
+    }
+
+    public List<RetentionData> networkPlayerRetentionAsJSONMap() {
+        Database db = dbSystem.getDatabase();
+        return db.query(PlayerRetentionQueries.fetchRetentionData());
+    }
+
+    public Map<UUID, String> playerJoinAddresses(ServerUUID serverUUID) {
+        Database db = dbSystem.getDatabase();
+        return db.query(JoinAddressQueries.latestJoinAddressesOfPlayers(serverUUID));
+    }
+
+    public Map<UUID, String> playerJoinAddresses() {
+        Database db = dbSystem.getDatabase();
+        return db.query(JoinAddressQueries.latestJoinAddressesOfPlayers());
+    }
+
     public List<Map<String, Object>> serverSessionsAsJSONMap(ServerUUID serverUUID) {
         Database db = dbSystem.getDatabase();
 

Plan/common/src/main/java/com/djrapitops/plan/delivery/webserver/cache/DataID.java

@@ -52,7 +52,10 @@ public enum DataID {
     EXTENSION_TABS,
     EXTENSION_JSON,
     LIST_SERVERS,
-    JOIN_ADDRESSES_BY_DAY;
+    JOIN_ADDRESSES_BY_DAY,
+    PLAYER_RETENTION,
+    PLAYER_JOIN_ADDRESSES,
+    ;
 
     public String of(ServerUUID serverUUID) {
         if (serverUUID == null) return name();

Plan/common/src/main/java/com/djrapitops/plan/delivery/webserver/resolver/json/PlayerJoinAddressJSONResolver.java

@@ -0,0 +1,111 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.delivery.webserver.resolver.json;
+
+import com.djrapitops.plan.delivery.formatting.Formatter;
+import com.djrapitops.plan.delivery.rendering.json.JSONFactory;
+import com.djrapitops.plan.delivery.web.resolver.MimeType;
+import com.djrapitops.plan.delivery.web.resolver.Response;
+import com.djrapitops.plan.delivery.web.resolver.request.Request;
+import com.djrapitops.plan.delivery.web.resolver.request.WebUser;
+import com.djrapitops.plan.delivery.webserver.cache.AsyncJSONResolverService;
+import com.djrapitops.plan.delivery.webserver.cache.DataID;
+import com.djrapitops.plan.delivery.webserver.cache.JSONStorage;
+import com.djrapitops.plan.identification.Identifiers;
+import com.djrapitops.plan.identification.ServerUUID;
+import com.djrapitops.plan.utilities.dev.Untrusted;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.parameters.RequestBody;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import org.jetbrains.annotations.Nullable;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.Collections;
+import java.util.Optional;
+
+/**
+ * @author AuroraLS3
+ */
+@Singleton
+@Path("/v1/joinAddresses")
+public class PlayerJoinAddressJSONResolver extends JSONResolver {
+
+    private final Identifiers identifiers;
+    private final AsyncJSONResolverService jsonResolverService;
+    private final JSONFactory jsonFactory;
+
+    @Inject
+    public PlayerJoinAddressJSONResolver(Identifiers identifiers, AsyncJSONResolverService jsonResolverService, JSONFactory jsonFactory) {
+        this.identifiers = identifiers;
+        this.jsonResolverService = jsonResolverService;
+        this.jsonFactory = jsonFactory;
+    }
+
+    @Override
+    public Formatter<Long> getHttpLastModifiedFormatter() {return jsonResolverService.getHttpLastModifiedFormatter();}
+
+    @Override
+    public boolean canAccess(@Untrusted Request request) {
+        return request.getUser().orElse(new WebUser("")).hasPermission("page.server");
+    }
+
+    @GET
+    @Operation(
+            description = "Get join address information of players for server or network",
+            responses = {
+                    @ApiResponse(responseCode = "200", content = @Content(mediaType = MimeType.JSON)),
+                    @ApiResponse(responseCode = "400", description = "If 'server' parameter is not an existing server")
+            },
+            parameters = @Parameter(in = ParameterIn.QUERY, name = "server", description = "Server identifier to get data for (optional)", examples = {
+                    @ExampleObject("Server 1"),
+                    @ExampleObject("1"),
+                    @ExampleObject("1fb39d2a-eb82-4868-b245-1fad17d823b3"),
+            }),
+            requestBody = @RequestBody(content = @Content(examples = @ExampleObject()))
+    )
+    @Override
+    public Optional<Response> resolve(@Untrusted Request request) {
+        return Optional.of(getResponse(request));
+    }
+
+    private Response getResponse(@Untrusted Request request) {
+        JSONStorage.StoredJSON result = getStoredJSON(request);
+        return getCachedOrNewResponse(request, result);
+    }
+
+    @Nullable
+    private JSONStorage.StoredJSON getStoredJSON(Request request) {
+        Optional<Long> timestamp = Identifiers.getTimestamp(request);
+        if (request.getQuery().get("server").isPresent()) {
+            ServerUUID serverUUID = identifiers.getServerUUID(request);
+            return jsonResolverService.resolve(timestamp, DataID.PLAYER_JOIN_ADDRESSES, serverUUID,
+                    theUUID -> Collections.singletonMap("join_address_by_player", jsonFactory.playerJoinAddresses(theUUID))
+            );
+        }
+        // Assume network
+        return jsonResolverService.resolve(timestamp, DataID.PLAYER_JOIN_ADDRESSES,
+                () -> Collections.singletonMap("join_address_by_player", jsonFactory.playerJoinAddresses())
+        );
+    }
+}

Plan/common/src/main/java/com/djrapitops/plan/delivery/webserver/resolver/json/RetentionJSONResolver.java

@@ -0,0 +1,111 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.delivery.webserver.resolver.json;
+
+import com.djrapitops.plan.delivery.formatting.Formatter;
+import com.djrapitops.plan.delivery.rendering.json.JSONFactory;
+import com.djrapitops.plan.delivery.web.resolver.MimeType;
+import com.djrapitops.plan.delivery.web.resolver.Response;
+import com.djrapitops.plan.delivery.web.resolver.request.Request;
+import com.djrapitops.plan.delivery.web.resolver.request.WebUser;
+import com.djrapitops.plan.delivery.webserver.cache.AsyncJSONResolverService;
+import com.djrapitops.plan.delivery.webserver.cache.DataID;
+import com.djrapitops.plan.delivery.webserver.cache.JSONStorage;
+import com.djrapitops.plan.identification.Identifiers;
+import com.djrapitops.plan.identification.ServerUUID;
+import com.djrapitops.plan.utilities.dev.Untrusted;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.ExampleObject;
+import io.swagger.v3.oas.annotations.parameters.RequestBody;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import org.jetbrains.annotations.Nullable;
+
+import javax.inject.Inject;
+import javax.inject.Singleton;
+import java.util.Collections;
+import java.util.Optional;
+
+/**
+ * @author AuroraLS3
+ */
+@Singleton
+@Path("/v1/retention")
+public class RetentionJSONResolver extends JSONResolver {
+
+    private final Identifiers identifiers;
+    private final AsyncJSONResolverService jsonResolverService;
+    private final JSONFactory jsonFactory;
+
+    @Inject
+    public RetentionJSONResolver(Identifiers identifiers, AsyncJSONResolverService jsonResolverService, JSONFactory jsonFactory) {
+        this.identifiers = identifiers;
+        this.jsonResolverService = jsonResolverService;
+        this.jsonFactory = jsonFactory;
+    }
+
+    @Override
+    public Formatter<Long> getHttpLastModifiedFormatter() {return jsonResolverService.getHttpLastModifiedFormatter();}
+
+    @Override
+    public boolean canAccess(@Untrusted Request request) {
+        return request.getUser().orElse(new WebUser("")).hasPermission("page.server");
+    }
+
+    @GET
+    @Operation(
+            description = "Get retention data for server or the network",
+            responses = {
+                    @ApiResponse(responseCode = "200", content = @Content(mediaType = MimeType.JSON)),
+                    @ApiResponse(responseCode = "400", description = "If 'server' parameter is not an existing server")
+            },
+            parameters = @Parameter(in = ParameterIn.QUERY, name = "server", description = "Server identifier to get data for (optional)", examples = {
+                    @ExampleObject("Server 1"),
+                    @ExampleObject("1"),
+                    @ExampleObject("1fb39d2a-eb82-4868-b245-1fad17d823b3"),
+            }),
+            requestBody = @RequestBody(content = @Content(examples = @ExampleObject()))
+    )
+    @Override
+    public Optional<Response> resolve(@Untrusted Request request) {
+        return Optional.of(getResponse(request));
+    }
+
+    private Response getResponse(@Untrusted Request request) {
+        JSONStorage.StoredJSON result = getStoredJSON(request);
+        return getCachedOrNewResponse(request, result);
+    }
+
+    @Nullable
+    private JSONStorage.StoredJSON getStoredJSON(Request request) {
+        Optional<Long> timestamp = Identifiers.getTimestamp(request);
+        if (request.getQuery().get("server").isPresent()) {
+            ServerUUID serverUUID = identifiers.getServerUUID(request);
+            return jsonResolverService.resolve(timestamp, DataID.PLAYER_RETENTION, serverUUID,
+                    theUUID -> Collections.singletonMap("player_retention", jsonFactory.playerRetentionAsJSONMap(theUUID))
+            );
+        }
+        // Assume network
+        return jsonResolverService.resolve(timestamp, DataID.PLAYER_RETENTION,
+                () -> Collections.singletonMap("player_retention", jsonFactory.networkPlayerRetentionAsJSONMap())
+        );
+    }
+}

Plan/common/src/main/java/com/djrapitops/plan/delivery/webserver/resolver/json/RootJSONResolver.java

@@ -65,7 +65,9 @@ public class RootJSONResolver {
             NetworkMetadataJSONResolver networkMetadataJSONResolver,
             WhoAmIJSONResolver whoAmIJSONResolver,
             ServerIdentityJSONResolver serverIdentityJSONResolver,
-            ExtensionJSONResolver extensionJSONResolver
+            ExtensionJSONResolver extensionJSONResolver,
+            RetentionJSONResolver retentionJSONResolver,
+            PlayerJoinAddressJSONResolver playerJoinAddressJSONResolver
     ) {
         this.identifiers = identifiers;
         this.asyncJSONResolverService = asyncJSONResolverService;
@@ -94,6 +96,8 @@ public class RootJSONResolver {
                 .add("serverIdentity", serverIdentityJSONResolver)
                 .add("whoami", whoAmIJSONResolver)
                 .add("extensionData", extensionJSONResolver)
+                .add("retention", retentionJSONResolver)
+                .add("joinAddresses", playerJoinAddressJSONResolver)
                 .build();
     }
 

Plan/common/src/main/java/com/djrapitops/plan/settings/locale/lang/HtmlLang.java

@@ -306,6 +306,7 @@ public enum HtmlLang implements Lang {
 
     HELP_TEST_RESULT("html.label.help.testResult", "Test result"),
     HELP_TEST_IT_OUT("html.label.help.testPrompt", "Test it out:"),
+    HELP_TIPS("html.label.help.tips", "Tips"),
     HELP_RETENTION("html.label.help.retentionBasis", "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."),
     HELP_ACTIVITY_INDEX("html.label.help.activityIndexBasis", "Activity index is based on non-AFK playtime in the past 3 weeks (21 days). Each week is considered separately."),
     HELP_ACTIVITY_INDEX_THRESHOLD("html.label.help.threshold", "Threshold"),
@@ -317,6 +318,59 @@ public enum HtmlLang implements Lang {
     HELP_ACTIVITY_INDEX_EXAMPLE_3("html.label.help.activityIndexExample3", "The index approaches 5 indefinitely."),
     HELP_ACTIVITY_INDEX_VISUALIZATION("html.label.help.activityIndexVisual", "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."),
 
+    HELP_GRAPH_ZOOM("html.label.help.graph.zoom", "You can Zoom in by click + dragging on the graph."),
+    HELP_GRAPH_TITLE("html.label.help.graph.title", "Graph"),
+    HELP_GRAPH_LABEL("html.label.help.graph.labels", "You can hide/show a group by clicking on the label at the bottom."),
+    HELP_RETENTION_USING_GRAPH("html.label.help.usingTheGraph", "Using the Graph"),
+    HELP_RETENTION_SELECT_OPTIONS("html.label.help.retention.options", "Select the options to analyze different aspects of Player Retention."),
+    HELP_RETENTION_COMPARE_MONTHS("html.label.help.retention.compareMonths", "You can compare different months by changing the '<0>' option to '<1>'"),
+    HELP_RETENTION_COMPARE_JOIN_ADDRESS("html.label.help.retention.compareJoinAddress", "Grouping by join address allows measuring advertising campaigns on different sites."),
+    RETENTION_CALCULATED("html.label.help.retention.howIsItCalculated", "How it is calculated"),
+    RETENTION_CALCULATED_FROM("html.label.help.retention.howIsItCalculatedData", "The graph is generated from player data:"),
+    RETENTION_CALCULATION_STEP1("html.label.help.retention.calculationStep1", "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."),
+    RETENTION_CALCULATION_STEP2("html.label.help.retention.calculationStep2", "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"),
+    RETENTION_CALCULATION_STEP3("html.label.help.retention.calculationStep3", "Then the '<0>' and '<1>' options select which visualization to render."),
+    RETENTION_CALCULATION_STEP4("html.label.help.retention.calculationStep4", "'<>' controls how many points the graph has, eg. 'Days' has one point per day."),
+    RETENTION_CALCULATION_STEP5("html.label.help.retention.calculationStep5", "On each calculated point all players are checked for the condition."),
+    RETENTION_CALCULATION_STEP6("html.label.help.retention.calculationStep6", "Select X Axis below to see conditions."),
+    RETENTION_CALCULATION_STEP_TIME("html.label.help.retention.calculationStepTime", "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."),
+    RETENTION_CALCULATION_STEP_PLAYTIME("html.label.help.retention.calculationStepPlaytime", "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."),
+    RETENTION_CALCULATION_STEP_DATE("html.label.help.retention.calculationStepDate", "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."),
+    RETENTION_CALCULATION_STEP_DELTAS("html.label.help.retention.calculationStepDeltas", "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."),
+    RETENTION_EXAMPLE("html.label.help.examples", "Examples"),
+    RETENTION_EXAMPLE_PLAYTIME("html.label.help.retention.examples.playtime", "Playtime tells how long the gameplay loop keeps players engaged on your server."),
+    RETENTION_EXAMPLE_DELTAS("html.label.help.retention.examples.deltas", "<> shows net gain of players."),
+    RETENTION_EXAMPLE_PATTERN("html.label.help.retention.examples.pattern", "A general pattern emerges when all players start leaving the server at the same time"),
+    RETENTION_EXAMPLE_PLATEAU("html.label.help.retention.examples.plateau", "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."),
+    RETENTION_EXAMPLE_AD_CAMPAIGN("html.label.help.retention.examples.adCampaign", "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"),
+    RETENTION_EXAMPLE_STACK("html.label.help.retention.examples.stack", "Cumulative player gain can be checked with stacked player count as Y axis"),
+
+    RETENTION_TIME_STEP("html.label.retention.timeStep", "Time step"),
+    RETENTION_PLAYERS_WHO_REGISTERED("html.label.retention.playersRegisteredInTime", "Players who registered"),
+    RETENTION_GROUP_REGISTER_BY("html.label.retention.groupByTime", "Group registered by"),
+    RETENTION_GROUP_REGISTER_BY_NONE("html.label.retention.groupByNone", "No grouping"),
+    RETENTION_PLAYER_PERCENTAGE("html.label.retention.retainedPlayersPercentage", "Retained Players %"),
+    RETENTION_LAST_7_DAYS("html.label.retention.inLast7d", "in the last 7 days"),
+    RETENTION_LAST_30_DAYS("html.label.retention.inLast30d", "in the last 30 days"),
+    RETENTION_LAST_90_DAYS("html.label.retention.inLast90d", "in the last 3 months"),
+    RETENTION_LAST_180_DAYS("html.label.retention.inLast180d", "in the last 6 months"),
+    RETENTION_LAST_365_DAYS("html.label.retention.inLast365d", "in the last 12 months"),
+    RETENTION_LAST_730_DAYS("html.label.retention.inLast730d", "in the last 24 months"),
+    RETENTION_ANY_TIME("html.label.retention.inAnytime", "any time"),
+    TIME_SINCE_REGISTERED("html.label.retention.timeSinceRegistered", "Time since register date"),
+    DATE("html.label.time.date", "Date"),
+    DAY("html.label.time.day", "Day"),
+    WEEK("html.label.time.week", "Week"),
+    MONTH("html.label.time.month", "Month"),
+    YEAR("html.label.time.year", "Year"),
+    HOURS("html.label.time.hours", "Hours"),
+    DAYS("html.label.time.days", "Days"),
+    WEEKS("html.label.time.weeks", "Weeks"),
+    MONTHS("html.label.time.months", "Months"),
+    X_AXIS("html.label.xAxis", "X Axis"),
+    Y_AXIS("html.label.yAxis", "Y Axis"),
+    PERCENTAGE("html.label.unit.percentage", "Percentage"),
+    PLAYER_COUNT("html.label.unit.playerCount", "Player Count"),
 
     WARNING_NO_GAME_SERVERS("html.description.noGameServers", "Some data requires Plan to be installed on game servers."),
     WARNING_NO_GEOLOCATIONS("html.description.noGeolocations", "Geolocation gathering needs to be enabled in the config (Accept GeoLite2 EULA)."),

Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/PlayerRetentionQueries.java

@@ -0,0 +1,83 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.storage.database.queries.analysis;
+
+import com.djrapitops.plan.delivery.domain.RetentionData;
+import com.djrapitops.plan.identification.ServerUUID;
+import com.djrapitops.plan.storage.database.queries.Query;
+import com.djrapitops.plan.storage.database.sql.tables.ServerTable;
+import com.djrapitops.plan.storage.database.sql.tables.SessionsTable;
+import com.djrapitops.plan.storage.database.sql.tables.UserInfoTable;
+import com.djrapitops.plan.storage.database.sql.tables.UsersTable;
+
+import java.util.List;
+import java.util.UUID;
+
+import static com.djrapitops.plan.storage.database.sql.building.Sql.*;
+
+/**
+ * Contains queries related to player retention data.
+ *
+ * @author AuroraLS3
+ */
+public class PlayerRetentionQueries {
+
+    private PlayerRetentionQueries() {
+        /* Static method class */
+    }
+
+    public static Query<List<RetentionData>> fetchRetentionData(ServerUUID serverUUID) {
+        String sql = SELECT +
+                UsersTable.USER_UUID + ',' +
+                "ui." + UserInfoTable.REGISTERED + ',' +
+                "MAX(" + SessionsTable.SESSION_END + ") as last_seen," +
+                "SUM(" + SessionsTable.SESSION_END + "-" + SessionsTable.SESSION_START + ") as playtime" +
+                FROM + UsersTable.TABLE_NAME + " u" +
+                INNER_JOIN + UserInfoTable.TABLE_NAME + " ui ON ui." + UserInfoTable.USER_ID + "=u." + UsersTable.ID +
+                INNER_JOIN + SessionsTable.TABLE_NAME + " s ON s." + SessionsTable.USER_ID + "=u." + UsersTable.ID +
+                AND + "s." + SessionsTable.SERVER_ID + "=ui." + UserInfoTable.SERVER_ID +
+                WHERE + "s." + UserInfoTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
+                GROUP_BY + UsersTable.USER_UUID + ",ui." + UserInfoTable.REGISTERED;
+
+        return db -> db.queryList(sql, set -> {
+            UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID));
+            long registerDate = set.getLong(UserInfoTable.REGISTERED);
+            long lastSeenDate = set.getLong("last_seen");
+            long playtime = set.getLong("playtime");
+            return new RetentionData(playerUUID, registerDate, lastSeenDate, playtime);
+        }, serverUUID);
+    }
+
+    public static Query<List<RetentionData>> fetchRetentionData() {
+        String sql = SELECT +
+                UsersTable.USER_UUID + ',' +
+                UsersTable.REGISTERED + ',' +
+                "MAX(" + SessionsTable.SESSION_END + ") as last_seen," +
+                "SUM(" + SessionsTable.SESSION_END + "-" + SessionsTable.SESSION_START + ") as playtime" +
+                FROM + UsersTable.TABLE_NAME + " u" +
+                INNER_JOIN + SessionsTable.TABLE_NAME + " s ON s." + SessionsTable.USER_ID + "=u." + UsersTable.ID +
+                GROUP_BY + UsersTable.USER_UUID + ',' + UserInfoTable.REGISTERED;
+
+        return db -> db.queryList(sql, set -> {
+            UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID));
+            long registerDate = set.getLong(UsersTable.REGISTERED);
+            long lastSeenDate = set.getLong("last_seen");
+            long playtime = set.getLong("playtime");
+            return new RetentionData(playerUUID, registerDate, lastSeenDate, playtime);
+        });
+    }
+}

Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/JoinAddressQueries.java

@@ -26,6 +26,7 @@ import com.djrapitops.plan.storage.database.sql.building.Sql;
 import com.djrapitops.plan.storage.database.sql.tables.JoinAddressTable;
 import com.djrapitops.plan.storage.database.sql.tables.ServerTable;
 import com.djrapitops.plan.storage.database.sql.tables.SessionsTable;
+import com.djrapitops.plan.storage.database.sql.tables.UsersTable;
 import com.djrapitops.plan.utilities.dev.Untrusted;
 
 import java.sql.PreparedStatement;
@@ -61,6 +62,10 @@ public class JoinAddressQueries {
         joinAddresses.put(set.getString(JoinAddressTable.JOIN_ADDRESS), set.getInt("total"));
     }
 
+    private static void extractJoinAddress(ResultSet set, Map<UUID, String> joinAddresses) throws SQLException {
+        joinAddresses.put(UUID.fromString(set.getString(UsersTable.USER_UUID)), set.getString(JoinAddressTable.JOIN_ADDRESS));
+    }
+
     public static Query<Map<String, Integer>> latestJoinAddresses(ServerUUID serverUUID) {
         String selectLatestSessionStarts = SELECT + SessionsTable.USER_ID + ",MAX(" + SessionsTable.SESSION_START + ") as max_start" +
                 FROM + SessionsTable.TABLE_NAME + " max_s" +
@@ -82,6 +87,45 @@ public class JoinAddressQueries {
         return db -> db.queryMap(selectJoinAddressCounts, JoinAddressQueries::extractJoinAddressCounts, TreeMap::new, serverUUID);
     }
 
+    public static Query<Map<UUID, String>> latestJoinAddressesOfPlayers() {
+        String selectLatestSessionStarts = SELECT + SessionsTable.USER_ID + ",MAX(" + SessionsTable.SESSION_START + ") as max_start" +
+                FROM + SessionsTable.TABLE_NAME + " max_s" +
+                GROUP_BY + SessionsTable.USER_ID;
+        String selectLatestJoinAddressIds = SELECT + SessionsTable.JOIN_ADDRESS_ID + ",s." + SessionsTable.USER_ID +
+                FROM + SessionsTable.TABLE_NAME + " s" +
+                INNER_JOIN + "(" + selectLatestSessionStarts + ") q1 on q1." + SessionsTable.USER_ID + "=s." + SessionsTable.USER_ID +
+                AND + "q1.max_start=s." + SessionsTable.SESSION_START;
+
+        String selectJoinAddress = SELECT +
+                UsersTable.USER_UUID + ',' +
+                JoinAddressTable.JOIN_ADDRESS +
+                FROM + "(" + selectLatestJoinAddressIds + ") a" +
+                INNER_JOIN + UsersTable.TABLE_NAME + " u on u." + UsersTable.ID + "=a." + SessionsTable.USER_ID +
+                INNER_JOIN + JoinAddressTable.TABLE_NAME + " j on j." + JoinAddressTable.ID + "=a." + SessionsTable.JOIN_ADDRESS_ID;
+
+        return db -> db.queryMap(selectJoinAddress, JoinAddressQueries::extractJoinAddress, HashMap::new);
+    }
+
+    public static Query<Map<UUID, String>> latestJoinAddressesOfPlayers(ServerUUID serverUUID) {
+        String selectLatestSessionStarts = SELECT + SessionsTable.USER_ID + ",MAX(" + SessionsTable.SESSION_START + ") as max_start" +
+                FROM + SessionsTable.TABLE_NAME + " max_s" +
+                WHERE + "max_s." + SessionsTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
+                GROUP_BY + SessionsTable.USER_ID;
+        String selectLatestJoinAddressIds = SELECT + SessionsTable.JOIN_ADDRESS_ID + ",s." + SessionsTable.USER_ID +
+                FROM + SessionsTable.TABLE_NAME + " s" +
+                INNER_JOIN + "(" + selectLatestSessionStarts + ") q1 on q1." + SessionsTable.USER_ID + "=s." + SessionsTable.USER_ID +
+                AND + "q1.max_start=s." + SessionsTable.SESSION_START;
+
+        String selectJoinAddress = SELECT +
+                UsersTable.USER_UUID + ',' +
+                JoinAddressTable.JOIN_ADDRESS +
+                FROM + "(" + selectLatestJoinAddressIds + ") a" +
+                INNER_JOIN + UsersTable.TABLE_NAME + " u on u." + UsersTable.ID + "=a." + SessionsTable.USER_ID +
+                INNER_JOIN + JoinAddressTable.TABLE_NAME + " j on j." + JoinAddressTable.ID + "=a." + SessionsTable.JOIN_ADDRESS_ID;
+
+        return db -> db.queryMap(selectJoinAddress, JoinAddressQueries::extractJoinAddress, HashMap::new, serverUUID);
+    }
+
     public static QueryStatement<List<String>> allJoinAddresses() {
         String sql = SELECT + JoinAddressTable.JOIN_ADDRESS +
                 FROM + JoinAddressTable.TABLE_NAME +

Plan/common/src/main/resources/assets/plan/locale/locale_CN.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "该指数无限趋近于5。"
             activityIndexVisual: "这里是y = 活跃指数，x = 每周游戏时间 / 阈值的曲线可视化。"
             activityIndexWeek: "第{}周"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "小时"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "新玩家留坑率根据会话数据计算。如果注册玩家在时间跨度的后半段内有游戏记录，则被视为已留坑。"
             testPrompt: "试一下："
             testResult: "测试结果"
             threshold: "阈值"
             thresholdUnit: "小时/周"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "按小时查看"
         inactive: "不活跃"
         indexInactive: "不活跃"
@@ -439,6 +469,20 @@ html:
         regular: "普通"
         regularPlayers: "普通玩家"
         relativeJoinActivity: "最近加入活动"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "第二致命的 PVP 武器"
         seenNicknames: "用过的昵称"
         server: "服务器"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "第三致命的 PVP 武器"
         thirtyDays: "30 天"
         thirtyDaysAgo: "30 天前"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "被踢出次数"
         toMainPage: "回到主页面"
         total: "总计"
@@ -480,12 +534,17 @@ html:
         trends30days: "30 天趋势"
         uniquePlayers: "独立玩家"
         uniquePlayers7days: "独立玩家（7天）"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "非常活跃"
         weekComparison: "每周对比"
         weekdays: "'星期一', '星期二', '星期三', '星期四', '星期五', '星期六', '星期日'"
         world: "世界加载"
         worldPlaytime: "世界游玩时间"
         worstPing: "最高延迟"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "登录失败："
         forgotPassword: "忘记密码？"

Plan/common/src/main/resources/assets/plan/locale/locale_CS.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hodina po hodině"
         inactive: "Neaktivní"
         indexInactive: "Neaktivní"
@@ -439,6 +469,20 @@ html:
         regular: "Pravidelný"
         regularPlayers: "Pravidelní hráči"
         relativeJoinActivity: "Relativní aktivita připojení"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2. PvP Zbraň"
         seenNicknames: "Viděné přezdívky"
         server: "Server"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3. PvP Zbraň"
         thirtyDays: "30 dní"
         thirtyDaysAgo: "před 30 dny"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Počet vykopnutí"
         toMainPage: "Zpět na hlavní stránku"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Trendy za 30 dní"
         uniquePlayers: "Unikátní hráči"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Velmi aktivní"
         weekComparison: "Týdenní srovnání"
         weekdays: "'Pondělí', 'Úterý', 'Středa', 'Čtvrtek', 'Pátek', 'Sobota', 'Neděle'"
         world: "Načtení světa"
         worldPlaytime: "Herní čas světa"
         worstPing: "Nejhorší ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Přihlašování selhalo: "
         forgotPassword: "Zapomněl jste heslo?"

Plan/common/src/main/resources/assets/plan/locale/locale_DE.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hour by Hour"
         inactive: "Inaktiv"
         indexInactive: "Inaktiv"
@@ -439,6 +469,20 @@ html:
         regular: "Regulär"
         regularPlayers: "Reguläre Spieler"
         relativeJoinActivity: "Relative Join Activity"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2. PvP Waffe"
         seenNicknames: "Registrierte Nicknames"
         server: "Server"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3. PvP Waffe"
         thirtyDays: "30 Tage"
         thirtyDaysAgo: "30 Tage vorher"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Mal gekickt"
         toMainPage: "zur Hauptseite"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Trends für 30 Tage"
         uniquePlayers: "Einzigartige Spieler"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Sehr aktiv"
         weekComparison: "Wochenvergleich"
         weekdays: "'Montag', 'Dienstag', 'Mittwoch', 'Donnerstag', 'Freitag', 'Samstag', 'Sonntag'"
         world: "World Load"
         worldPlaytime: "Spielzeit in der Welt"
         worstPing: "Schlechtester Ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Login failed: "
         forgotPassword: "Passwort vergessen?"

Plan/common/src/main/resources/assets/plan/locale/locale_EN.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hour by Hour"
         inactive: "Inactive"
         indexInactive: "Inactive"
@@ -439,6 +469,20 @@ html:
         regular: "Regular"
         regularPlayers: "Regular Players"
         relativeJoinActivity: "Relative Join Activity"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2nd PvP Weapon"
         seenNicknames: "Seen Nicknames"
         server: "Server"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3rd PvP Weapon"
         thirtyDays: "30 days"
         thirtyDaysAgo: "30 days ago"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Times Kicked"
         toMainPage: "to main page"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Trends for 30 days"
         uniquePlayers: "Unique Players"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Very Active"
         weekComparison: "Week Comparison"
         weekdays: "'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'"
         world: "World Load"
         worldPlaytime: "World Playtime"
         worstPing: "Worst Ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Login failed: "
         forgotPassword: "Forgot Password?"

Plan/common/src/main/resources/assets/plan/locale/locale_ES.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hora a Hora"
         inactive: "Inactivo"
         indexInactive: "Inactivo"
@@ -439,6 +469,20 @@ html:
         regular: "Normal"
         regularPlayers: "Jugadores normal"
         relativeJoinActivity: "Actividad de unión relativa"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2ª arma PvP"
         seenNicknames: "Nombres de usuarios vistos"
         server: "Servidor"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3ª arma PvP"
         thirtyDays: "30 días"
         thirtyDaysAgo: "Hace 30 días"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Veces kickeado"
         toMainPage: "hasta la página principal"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Tendencias de 30 días"
         uniquePlayers: "Jugadores únicos"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Muy activo"
         weekComparison: "Comparación semanal"
         weekdays: "'Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes', 'Sábado', 'Domingo'"
         world: "Carga de mundo"
         worldPlaytime: "Jugabilidad de mundo"
         worstPing: "Peor ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Ingreso fallido: "
         forgotPassword: "Contraseña Olvidada?"

Plan/common/src/main/resources/assets/plan/locale/locale_FI.yml

@@ -115,7 +115,7 @@ command:
         network: "> §2Verkoston Sivu"
         players: "> §2Pelaajat"
         search: "> §2${0} Tulosta haulle §f${1}§2:"
-        serverList: "id::nimi::uuid::version"
+        serverList: "id::nimi::uuid::versio"
         servers: "> §2Palvelimet"
         webUserList: "käyttäjänimi::linkitetty pelaajaan::lupa taso"
         webUsers: "> §2${0} Verkkokäyttäjät"
@@ -332,18 +332,48 @@ html:
             ortographic: "Ortografinen"
         geolocations: "Sijainnit"
         help:
-            activityIndexBasis: "Activity index is based on non-AFK playtime in the past 3 weeks (21 days). Each week is considered separately."
-            activityIndexExample1: "If someone plays as much as threshold every week, they are given activity index ~3."
-            activityIndexExample2: "Very active is ~2x the threshold (y ≥ 3.75)."
-            activityIndexExample3: "The index approaches 5 indefinitely."
-            activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
-            activityIndexWeek: "Week {}"
-            playtimeUnit: "hours"
-            retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
-            testPrompt: "Test it out:"
-            testResult: "Test result"
-            threshold: "Threshold"
-            thresholdUnit: "hours / week"
+            activityIndexBasis: "Aktiivisuus indeksi perustuu ei-AFK peliaikaan viimeiseltä kolmelta viikolta (21 päivää). Jokaista viikkoa katsotaan erikseen"
+            activityIndexExample1: "Jos joku pelaa kynnyksen määrän joka viikko, on aktiivisuus indeksi noin ~3."
+            activityIndexExample2: "Hyvin aktiivinen pelaa ~2x kynnysarvon verran (y ≥ 3.75)."
+            activityIndexExample3: "Indeksi lähestyy arvoa 5 äärettömyyteen asti"
+            activityIndexVisual: "Alapuolelta löytyy esimerkki käyrästä, missä y = aktiivisuus indeksi, and x = peliaika viikossa / kynnys."
+            activityIndexWeek: "Viikko {}"
+            examples: "Esimerkkejä"
+            graph:
+                labels: "Voit piilottaa/näyttää ryhmän klikkaamalla nimeä käyrän alapuolella"
+                title: "Käyrä"
+                zoom: "Voit katsoa tietoja tarkemmin klikkaamalla ja vetämällä käyrän päällä"
+            playtimeUnit: "tuntia"
+            retention:
+                calculationStep1: "Ensin tiedot rajataan käyttämällä '<>' valintaa. Pelaajat joiden 'registerDate' osuu aikarajauksen ulkopuolelle eivät tule mukaan laskuihin"
+                calculationStep2: "Tämän jälkeen tiedot ryhmitellään käyttämällä '<0>' valintaa, esim. '<1>' valittuna: Kaikki pelaajat jotka rekisteröityivät tammikuussa 2023, helmikuussa 2023, jne"
+                calculationStep3: "Sitten '<0>' ja '<1>' valitsevat mitä esitystä näytetään."
+                calculationStep4: "'<>' ohjaa montako pistettä käyrällä on, esim. 'Päivät' laittaa yhden pisteen per päivä."
+                calculationStep5: "Jokaiselle lasketulle pisteelle tarkistetaan, vastaavatko pelaajat ehtoa."
+                calculationStep6: "Valitse X Akseli alapuolella nähdäksesi ehdot."
+                calculationStepDate: "Tämä esitysmuoto näyttää eri ryhmät jotka vielä pelaavat palvelimella. Esitys käyttää lastSeen päivämäärää. Jos x < lastSeenDate, pelaaja näkyy käyrällä."
+                calculationStepDeltas: "Tämä esitysmuoto on tehokkaampi jos käytetään Pelaajamäärää Y akselina. Esitys näyttää pelaajien lisääntymisen kokonaismääärän (Montako pelaajaa rekisteröityi - pelaajat jotka lopettivat pelaamisen). Esitys käyttää registered ja lastSeen päiviä. Jos registerDate < x < lastSeenDate, pelaaja näkyy käyrällä."
+                calculationStepPlaytime: "Tämä esitysmuoto kertoo miten pitkään pelisykli pitää pelaajat kiinnostuneita palvelimesta. Esitys käyttää peliaikaa. Jos x < playtime, pelaaja näkyy käyrällä."
+                calculationStepTime: "Tämä esitysmuoto kertoo miten kauan pelaajat jatkavat palvelimelle takaisin liittymistä rekisteröitymisen jälkeen. Kuvaus käyttää aikojen erotusta. Jos x < timeDifference, pelaaja näkyy käyrällä."
+                compareJoinAddress: "Liittymisosoitteen avulla ryhmittely mahdollistaa eri mainoskampanjoiden tehokkuuden tarkkailun."
+                compareMonths: "Voit verrata eri kuukausia vaihtamalla '<0>' kohtaan '<1>'"
+                examples:
+                    adCampaign: "Eri mainoskampanjoiden tehokkuuden mittaus eri liittymäosotteiden avulla (anonymisoitu)"
+                    deltas: "<> näyttää pelaajien lisääntymismäärän."
+                    pattern: "Käyrästä paljastuu yleisempi kuvio, kun kaikki pelaajat lopettavat palvelimella pelaamisen kokonaan samaan aikaan."
+                    plateau: "Tässä verrataan pelaajien lisääntymismäärää eri kuukausilta. Tasanteet viittaavat siihen, että on pelaajia joista Plan ei tiedä. Tässä esimerkissä Plan asennettiin tammikuussa 2022."
+                    playtime: "Peliaika kertoo kuinka kauan pelisykli pitää pelaajat kiinnostuneina palvelimesta."
+                    stack: "Kumulatiivisen pelaajien lisääntymismäärän voi tarkistaa päälekkäisillä pelaajamäärillä Y akselina"
+                howIsItCalculated: "Miten se lasketaan"
+                howIsItCalculatedData: "Käyrä generoidaan pelaajien tiedoista:"
+                options: "Eri valinnoilla voi analysoida pelaajien pysyvyyden eri puolia."
+            retentionBasis: "Uusien pelaajien pysyvyys perustuu istuntoihin. Jos rekisteröitynyt pelaaja on pelannut ajanjakson viimeisellä puoliskolla, ajatellaan heidän pysyneen palvelimella"
+            testPrompt: "Kokeile käytännössä:"
+            testResult: "Kokeilun tulos"
+            threshold: "kynnys"
+            thresholdUnit: "tuntia / viikko"
+            tips: "Neuvoja"
+            usingTheGraph: "Käyrän käyttö"
         hourByHour: "Tunnittainen katsaus"
         inactive: "Inaktiivinen"
         indexInactive: "Inaktiivinen"
@@ -411,7 +441,7 @@ html:
         playerList: "Pelaajalista"
         playerOverview: "Yhteenveto Pelaajasta"
         playerPage: "Pelaajan sivu"
-        playerRetention: "Pelaajien säilyvyys"
+        playerRetention: "Pelaajien pysyvyys"
         playerbase: "Pelaajakunta"
         playerbaseDevelopment: "Pelaajakunnan kehitys"
         playerbaseOverview: "Yhteenveto Pelaajakunnasta"
@@ -439,6 +469,20 @@ html:
         regular: "Kantapelaaja"
         regularPlayers: "Kantapelaajia"
         relativeJoinActivity: "Verrannollinen liittymis aktiivisuus"
+        retention:
+            groupByNone: "Ei ryhmittelyä"
+            groupByTime: "Ryhmittele rekisteröityneet"
+            inAnytime: "koska vain"
+            inLast180d: "viimeisen 6 kuukauden aikana"
+            inLast30d: "viimeisen 30 päivän aikana"
+            inLast365d: "viimeisen 12 kuukauden aikana"
+            inLast730d: "viimeisen 24 kuukauden aikana"
+            inLast7d: "viimeisen 7 päivän aikana"
+            inLast90d: "viimeisen 3 kuukauden aikana"
+            playersRegisteredInTime: "Pelaajat jotka rekisteröityivät"
+            retainedPlayersPercentage: "Pelaajien pysyvyys %"
+            timeSinceRegistered: "Aika rekisteröitymispäivästä"
+            timeStep: "Aika askel"
         secondDeadliestWeapon: "2. PvP Ase"
         seenNicknames: "Nähdyt Lempinimet"
         server: "Palvelin"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3. PvP Ase"
         thirtyDays: "30 päivää"
         thirtyDaysAgo: "30 päivää sitten"
+        time:
+            date: "Päivämäärä"
+            day: "Päivä"
+            days: "Päivää"
+            hours: "Tuntia"
+            month: "Kuukausi"
+            months: "Kuukautta"
+            week: "Viikko"
+            weeks: "Viikkoa"
+            year: "Vuosi"
         timesKicked: "Heitetty pihalle"
         toMainPage: "pääsivu"
         total: "Yhteensä"
@@ -480,12 +534,17 @@ html:
         trends30days: "Suunnat 30 päivälle"
         uniquePlayers: "Uniikkeja pelaajia"
         uniquePlayers7days: "Uniikkeja pelaajia (7 päivää)"
+        unit:
+            percentage: "Prosentti"
+            playerCount: "Pelaajamäärä"
         veryActive: "Todella Aktiivinen"
         weekComparison: "Viikkojen vertaus"
         weekdays: "'Maanantai', 'Tiistai', 'Keskiviikko', 'Torstai', 'Perjantai', 'Lauantai', 'Sunnuntai'"
         world: "Maailmojen Resurssit"
         worldPlaytime: "Maailmakohtainen Peliaika"
         worstPing: "Huonoin Vasteaika"
+        xAxis: "X akseli"
+        yAxis: "Y akseli"
     login:
         failed: "Kirjautuminen epäonnistui:"
         forgotPassword: "Unohtuiko salasana?"
@@ -504,7 +563,7 @@ html:
             contributors:
                 bugreporters: "& Bugien ilmoittajat!"
                 code: "koodin tuottaja"
-                donate: "Suuret kiitokset rahallisesti tukeneille henkilöille."
+                donate: "Suuret kiitokset projektia rahallisesti tukeneille henkilöille."
                 text: 'Myös seuraavat <span class="col-plan">mahtavat ihmiset</span> ovat tukeneet kehitystä:'
                 translator: "kääntäjä"
             developer: "on kehittänyt"

Plan/common/src/main/resources/assets/plan/locale/locale_FR.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Heure par Heure"
         inactive: "Inactif(ve)"
         indexInactive: "Inactif"
@@ -439,6 +469,20 @@ html:
         regular: "Régulier(ère)"
         regularPlayers: "Joueurs Réguliers"
         relativeJoinActivity: "Activité de Connexion relative"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2ᵉ Arme de Combat"
         seenNicknames: "Surnoms vus"
         server: "Serveur"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3ᵉ Arme de Combat"
         thirtyDays: "30 jours"
         thirtyDaysAgo: "Il y a 30 jours"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Nombre d'Éjections"
         toMainPage: "Retour à la page principale"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Tendances sur 30 Jours"
         uniquePlayers: "Joueurs Uniques"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Très Actif"
         weekComparison: "Comparaison Hebdomadaire"
         weekdays: "'Lundi', 'Mardi', 'Mercredi', 'Jeudi', 'Vendredi', 'Samedi', 'Dimanche'"
         world: "Charge du Monde"
         worldPlaytime: "Temps de Jeu par Monde"
         worstPing: "Pire Latence"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Connexion échouée : "
         forgotPassword: "Mot de Passe oublié ?"

Plan/common/src/main/resources/assets/plan/locale/locale_IT.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hour by Hour"
         inactive: "Inattivo"
         indexInactive: "Inattivo"
@@ -439,6 +469,20 @@ html:
         regular: "Regolari"
         regularPlayers: "Giocatori Regolari"
         relativeJoinActivity: "Attività Entrate Relative"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2° Arma PvP Preferita"
         seenNicknames: "Nick Usati"
         server: "Server"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3° Arma PvP Preferita"
         thirtyDays: "30 giorni"
         thirtyDaysAgo: "30 giorni fa"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Cacciato"
         toMainPage: "Ritorna alla pagina principale"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Tendenza per 30 giorni"
         uniquePlayers: "Giocatori unici"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Molto Attivo"
         weekComparison: "Confronto settimanale"
         weekdays: "'Lunedì', 'Martedì', 'Mercoledì', 'Giovedì', 'Venerdì', 'Sabato', 'Domenica'"
         world: "Caricamento Mondo"
         worldPlaytime: "Tempo di gioco Mondo"
         worstPing: "Ping Peggiore"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Login failed: "
         forgotPassword: "Forgot Password?"

Plan/common/src/main/resources/assets/plan/locale/locale_JA.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hour by Hour"
         inactive: "休止中"
         indexInactive: "休止中"
@@ -439,6 +469,20 @@ html:
         regular: "よくオンラインのプレイヤー"
         regularPlayers: "よくオンラインのプレイヤー"
         relativeJoinActivity: "オンラインと活動との関係性"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2番目にPvPで使用されている武器"
         seenNicknames: "ニックネーム一覧"
         server: "サーバー"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3番目にPvPで使用されている武器"
         thirtyDays: "1ヶ月"
         thirtyDaysAgo: "1ヶ月前"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "キック回数"
         toMainPage: "メインページに戻る"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "1ヶ月間の増減"
         uniquePlayers: "接続したプレイヤーの総数"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "とてもログインしている"
         weekComparison: "直近1周間での比較"
         weekdays: "'月曜日', '火曜日', '水曜日', '木曜日', '金曜日', '土曜日', '日曜日'"
         world: "ワールドのロード数"
         worldPlaytime: "ワールドごとのプレイ時間"
         worstPing: "最低Ping値"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Login failed: "
         forgotPassword: "Forgot Password?"

Plan/common/src/main/resources/assets/plan/locale/locale_KO.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hour by Hour"
         inactive: "비활성"
         indexInactive: "비활성"
@@ -439,6 +469,20 @@ html:
         regular: "신규"
         regularPlayers: "신규 플레이어"
         relativeJoinActivity: "상대 조인 활동"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2nd PvP 무기"
         seenNicknames: "본 별명"
         server: "서버"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3rd PvP 무기"
         thirtyDays: "30일"
         thirtyDaysAgo: "30일 전"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "접속종료한 시간"
         toMainPage: "메인 페이지로"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "30일 동안의 트렌드"
         uniquePlayers: "기존 플레이어"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "매우 활성화된"
         weekComparison: "주 비교"
         weekdays: "'월요일', '화요일', '수요일', '목요일', '금요일', '토요일', '일요일'"
         world: "월드 로드"
         worldPlaytime: "맵 플레이 타임"
         worstPing: "Worst Ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Login failed: "
         forgotPassword: "Forgot Password?"

Plan/common/src/main/resources/assets/plan/locale/locale_NL.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Uur voor uur"
         inactive: "Inactief"
         indexInactive: "Inactief"
@@ -439,6 +469,20 @@ html:
         regular: "Regulier"
         regularPlayers: "Reguliere speler"
         relativeJoinActivity: "Relatieve deelname aan activiteit"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2e PvP-wapen"
         seenNicknames: "Bijnamen gezien"
         server: "Server"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3e PvP-wapen"
         thirtyDays: "30 dagen"
         thirtyDaysAgo: "30 dagen geleden"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Aantal keer afgetapt"
         toMainPage: "naar hoofdpagina"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Trends voor 30 dagen"
         uniquePlayers: "Unieke spelers"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Heel Actief"
         weekComparison: "Weekvergelijking"
         weekdays: "'Maandag', 'Dinsdag', 'Woensdag', 'Donderdag', 'Vrijdag', 'Zaterdag', 'Zondag'"
         world: "Wereldbelasting"
         worldPlaytime: "Wereld speeltijd"
         worstPing: "Slechtste ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Login niet gelukt: "
         forgotPassword: "Wachtwoord Vergeten?"

Plan/common/src/main/resources/assets/plan/locale/locale_PT_BR.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Hour by Hour"
         inactive: "Inactive"
         indexInactive: "Inativo"
@@ -439,6 +469,20 @@ html:
         regular: "Regular"
         regularPlayers: "Regular Players"
         relativeJoinActivity: "Relative Join Activity"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2nd PvP Weapon"
         seenNicknames: "Nicks Vistos"
         server: "Servidor"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3rd PvP Weapon"
         thirtyDays: "30 days"
         thirtyDaysAgo: "30 days ago"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Vezes Kickado"
         toMainPage: "to main page"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "Trends for 30 days"
         uniquePlayers: "Jogadores Únicos"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Muito Ativo"
         weekComparison: "Week Comparison"
         weekdays: "'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'"
         world: "World Load"
         worldPlaytime: "Tempo de Jogo por Mundo"
         worstPing: "Worst Ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Login failed: "
         forgotPassword: "Forgot Password?"

Plan/common/src/main/resources/assets/plan/locale/locale_RU.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Статистика по часам"
         inactive: "Неактивный"
         indexInactive: "Неактивный"
@@ -439,6 +469,20 @@ html:
         regular: "Постоянный"
         regularPlayers: "Постоянные игроки"
         relativeJoinActivity: "Сравнительная активность присоединения"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2-е PvP оружие"
         seenNicknames: "Увиденные никнеймы"
         server: "Сервер"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3-е PvP оружие"
         thirtyDays: "30 дней"
         thirtyDaysAgo: "30 дней назад"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Кол-во киков"
         toMainPage: "На главную страницу"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "тенденция за 30 дней"
         uniquePlayers: "Уникальные игроки"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Очень активный"
         weekComparison: "Сравнение за неделю"
         weekdays: "'Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье'"
         world: "Загрузка мира"
         worldPlaytime: "Время игры в мире"
         worstPing: "Наихудший пинг"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Логин неудачен: "
         forgotPassword: "Забыли пароль?"

Plan/common/src/main/resources/assets/plan/locale/locale_TR.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "Saat saat"
         inactive: "Etkin değil"
         indexInactive: "Etkisiz"
@@ -439,6 +469,20 @@ html:
         regular: "Düzenli"
         regularPlayers: "Normal Oyuncular"
         relativeJoinActivity: "Göreli Birleştirme Etkinliği"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "2. PvP Silahı"
         seenNicknames: "Görülen takma adlar"
         server: "Sunucu"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "3. PvP Silahı"
         thirtyDays: "30 gün"
         thirtyDaysAgo: "30 gün önce"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "Kere Atılmış"
         toMainPage: "Ana Sayfaya"
         total: "Total"
@@ -480,12 +534,17 @@ html:
         trends30days: "30 günlük trendler"
         uniquePlayers: "Sunucuya İlk Defa Girenler"
         uniquePlayers7days: "Unique Players (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "Çok Aktif"
         weekComparison: "Hafta Karşılaştırması"
         weekdays: "'Pazartesi', 'Salı', 'Çarşamba', 'Perşembe', 'Cuma', 'Cumartesi', 'Pazar'"
         world: "Dünya Yükle"
         worldPlaytime: "Dünya Oyun Süresi"
         worstPing: "En kötü Ping"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "Giriş başarısız:"
         forgotPassword: "Parolanızı mı unuttunuz?"

Plan/common/src/main/resources/assets/plan/locale/locale_ZH_TW.yml

@@ -338,12 +338,42 @@ html:
             activityIndexExample3: "The index approaches 5 indefinitely."
             activityIndexVisual: "Here is a visualization of the curve where y = activity index, and x = playtime per week / threshold."
             activityIndexWeek: "Week {}"
+            examples: "Examples"
+            graph:
+                labels: "You can hide/show a group by clicking on the label at the bottom."
+                title: "Graph"
+                zoom: "You can Zoom in by click + dragging on the graph."
             playtimeUnit: "hours"
+            retention:
+                calculationStep1: "First the data is filtered using '<>' option. Any players with 'registerDate' outside the time range are ignored."
+                calculationStep2: "Then it is grouped into groups of players using '<0>' option, eg. With '<1>': All players who registered in January 2023, February 2023, etc"
+                calculationStep3: "Then the '<0>' and '<1>' options select which visualization to render."
+                calculationStep4: "'<>' controls how many points the graph has, eg. 'Days' has one point per day."
+                calculationStep5: "On each calculated point all players are checked for the condition."
+                calculationStep6: "Select X Axis below to see conditions."
+                calculationStepDate: "This visualization shows the different groups of players that are still playing on your server. The visualization uses lastSeen date. If x < lastSeenDate, the player is visible on the graph."
+                calculationStepDeltas: "This visualization is most effective using Player Count as the Y Axis. The visualization shows net gain of players (How many players joined minus players who stopped playing). The visualization uses both registered and lastSeen dates. If registerDate < x < lastSeenDate, the player is visible on the graph."
+                calculationStepPlaytime: "This visualization tells how long the gameplay loop keeps players engaged on your server. The visualization uses playtime. If x < playtime, the player is visible on the graph."
+                calculationStepTime: "This visualization tells how long people keep coming back to play on the server after they join the first time. The visualization uses timeDifference. If x < timeDifference, the player is visible on the graph."
+                compareJoinAddress: "Grouping by join address allows measuring advertising campaigns on different sites."
+                compareMonths: "You can compare different months by changing the '<0>' option to '<1>'"
+                examples:
+                    adCampaign: "Comparing player gain of different ad campaigns using different Join Addresses (anonymized)"
+                    deltas: "<> shows net gain of players."
+                    pattern: "A general pattern emerges when all players start leaving the server at the same time"
+                    plateau: "Comparing player gain of different months. Plateaus suggest there were players Plan doesn't know about. In this example Plan was installed in January 2022."
+                    playtime: "Playtime tells how long the gameplay loop keeps players engaged on your server."
+                    stack: "Cumulative player gain can be checked with stacked player count as Y axis"
+                howIsItCalculated: "How it is calculated"
+                howIsItCalculatedData: "The graph is generated from player data:"
+                options: "Select the options to analyze different aspects of Player Retention."
             retentionBasis: "New player retention is calculated based on session data. If a registered player has played within latter half of the timespan, they are considered retained."
             testPrompt: "Test it out:"
             testResult: "Test result"
             threshold: "Threshold"
             thresholdUnit: "hours / week"
+            tips: "Tips"
+            usingTheGraph: "Using the Graph"
         hourByHour: "按小時查看"
         inactive: "不活躍"
         indexInactive: "不活躍"
@@ -439,6 +469,20 @@ html:
         regular: "普通"
         regularPlayers: "普通玩家"
         relativeJoinActivity: "最近加入活動"
+        retention:
+            groupByNone: "No grouping"
+            groupByTime: "Group registered by"
+            inAnytime: "any time"
+            inLast180d: "in the last 6 months"
+            inLast30d: "in the last 30 days"
+            inLast365d: "in the last 12 months"
+            inLast730d: "in the last 24 months"
+            inLast7d: "in the last 7 days"
+            inLast90d: "in the last 3 months"
+            playersRegisteredInTime: "Players who registered"
+            retainedPlayersPercentage: "Retained Players %"
+            timeSinceRegistered: "Time since register date"
+            timeStep: "Time step"
         secondDeadliestWeapon: "第二致命的 PvP 武器"
         seenNicknames: "使用過的暱稱"
         server: "伺服器"
@@ -466,6 +510,16 @@ html:
         thirdDeadliestWeapon: "第三致命的 PvP 武器"
         thirtyDays: "30 天"
         thirtyDaysAgo: "30 天前"
+        time:
+            date: "Date"
+            day: "Day"
+            days: "Days"
+            hours: "Hours"
+            month: "Month"
+            months: "Months"
+            week: "Week"
+            weeks: "Weeks"
+            year: "Year"
         timesKicked: "被踢出次數"
         toMainPage: "回到主頁面"
         total: "總計"
@@ -480,12 +534,17 @@ html:
         trends30days: "30 天趨勢"
         uniquePlayers: "獨立玩家"
         uniquePlayers7days: "獨立玩家 (7 days)"
+        unit:
+            percentage: "Percentage"
+            playerCount: "Player Count"
         veryActive: "非常活躍"
         weekComparison: "每週對比"
         weekdays: "'星期一', '星期二', '星期三', '星期四', '星期五', '星期六', '星期日'"
         world: "世界載入"
         worldPlaytime: "世界遊玩時間"
         worstPing: "最高延遲"
+        xAxis: "X Axis"
+        yAxis: "Y Axis"
     login:
         failed: "登入失敗："
         forgotPassword: "忘記密碼？"

Plan/common/src/test/java/com/djrapitops/plan/delivery/webserver/AccessControlTest.java

@@ -180,6 +180,8 @@ class AccessControlTest {
             "/v1/kills?server=" + TestConstants.SERVER_UUID_STRING + ",200",
             "/v1/pingTable?server=" + TestConstants.SERVER_UUID_STRING + ",200",
             "/v1/sessions?server=" + TestConstants.SERVER_UUID_STRING + ",200",
+            "/v1/retention?server=" + TestConstants.SERVER_UUID_STRING + ",200",
+            "/v1/joinAddresses?server=" + TestConstants.SERVER_UUID_STRING + ",200",
             "/network,302",
             "/v1/network/overview,200",
             "/v1/network/servers,200",
@@ -256,6 +258,8 @@ class AccessControlTest {
             "/v1/kills?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/v1/pingTable?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/v1/sessions?server=" + TestConstants.SERVER_UUID_STRING + ",403",
+            "/v1/retention?server=" + TestConstants.SERVER_UUID_STRING + ",403",
+            "/v1/joinAddresses?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/v1/graph?type=joinAddressByDay&server=" + TestConstants.SERVER_UUID_STRING + "&after=0&before=" + 123456L + ",403",
             "/network,403",
             "/v1/network/overview,403",
@@ -334,6 +338,8 @@ class AccessControlTest {
             "/v1/kills?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/v1/pingTable?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/v1/sessions?server=" + TestConstants.SERVER_UUID_STRING + ",403",
+            "/v1/retention?server=" + TestConstants.SERVER_UUID_STRING + ",403",
+            "/v1/joinAddresses?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/network,403",
             "/v1/network/overview,403",
             "/v1/network/servers,403",
@@ -411,6 +417,8 @@ class AccessControlTest {
             "/v1/kills?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/v1/pingTable?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/v1/sessions?server=" + TestConstants.SERVER_UUID_STRING + ",403",
+            "/v1/retention?server=" + TestConstants.SERVER_UUID_STRING + ",403",
+            "/v1/joinAddresses?server=" + TestConstants.SERVER_UUID_STRING + ",403",
             "/network,403",
             "/v1/network/overview,403",
             "/v1/network/servers,403",

Plan/common/src/test/java/com/djrapitops/plan/storage/database/DatabaseTestAggregate.java

@@ -18,6 +18,7 @@ package com.djrapitops.plan.storage.database;
 
 import com.djrapitops.plan.extension.implementation.storage.queries.ExtensionQueryResultTableDataQueryTest;
 import com.djrapitops.plan.storage.database.queries.*;
+import com.djrapitops.plan.storage.database.queries.analysis.PlayerRetentionQueriesTest;
 import com.djrapitops.plan.storage.database.queries.analysis.TopListQueriesTest;
 import com.djrapitops.plan.storage.database.transactions.commands.ChangeUserUUIDTransactionTest;
 import com.djrapitops.plan.storage.database.transactions.commands.CombineUserTransactionTest;
@@ -43,6 +44,7 @@ public interface DatabaseTestAggregate extends
         CombineUserTransactionTest,
         ExtensionQueryResultTableDataQueryTest,
         BadJoinAddressDataCorrectionPatchTest,
-        AfterBadJoinAddressDataCorrectionPatchTest {
+        AfterBadJoinAddressDataCorrectionPatchTest,
+        PlayerRetentionQueriesTest {
     /* Collects all query tests together so its easier to implement database tests */
 }

Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/JoinAddressQueriesTest.java

@@ -22,6 +22,7 @@ import com.djrapitops.plan.settings.config.paths.DataGatheringSettings;
 import com.djrapitops.plan.storage.database.DatabaseTestPreparer;
 import com.djrapitops.plan.storage.database.queries.objects.BaseUserQueries;
 import com.djrapitops.plan.storage.database.queries.objects.JoinAddressQueries;
+import com.djrapitops.plan.storage.database.queries.objects.SessionQueries;
 import com.djrapitops.plan.storage.database.sql.tables.JoinAddressTable;
 import com.djrapitops.plan.storage.database.transactions.commands.RemoveEverythingTransaction;
 import com.djrapitops.plan.storage.database.transactions.events.*;
@@ -85,7 +86,10 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer {
     default void latestJoinAddressIsUpdatedUponSecondSession() {
         joinAddressCanBeUnknown();
 
-        FinishedSession session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
+        Long after = db().query(SessionQueries.lastSeen(playerUUID, serverUUID()));
+
+        FinishedSession session = RandomData.randomSession(serverUUID(), worlds, after, playerUUID, player2UUID);
+
         String expectedAddress = TestConstants.GET_PLAYER_HOSTNAME.get();
         session.getExtraData().put(JoinAddress.class, new JoinAddress(expectedAddress));
         db().executeTransaction(new StoreSessionTransaction(session));
@@ -274,4 +278,22 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer {
         );
         assertEquals(expected, result);
     }
+
+    @Test
+    default void playerSpecificJoinAddressCanBeFetched() {
+        latestJoinAddressIsUpdatedUponSecondSession();
+
+        Map<UUID, String> expected = Map.of(playerUUID, TestConstants.GET_PLAYER_HOSTNAME.get());
+        Map<UUID, String> result = db().query(JoinAddressQueries.latestJoinAddressesOfPlayers());
+        assertEquals(expected, result);
+    }
+
+    @Test
+    default void playerSpecificJoinAddressCanBeFetchedForServer() {
+        joinAddressUpdateIsUniquePerServer();
+
+        Map<UUID, String> expected = Map.of(playerUUID, TestConstants.GET_PLAYER_HOSTNAME.get());
+        Map<UUID, String> result = db().query(JoinAddressQueries.latestJoinAddressesOfPlayers(TestConstants.SERVER_TWO_UUID));
+        assertEquals(expected, result);
+    }
 }

Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/analysis/PlayerRetentionQueriesTest.java

@@ -0,0 +1,77 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package com.djrapitops.plan.storage.database.queries.analysis;
+
+import com.djrapitops.plan.delivery.domain.RetentionData;
+import com.djrapitops.plan.gathering.domain.FinishedSession;
+import com.djrapitops.plan.storage.database.DatabaseTestPreparer;
+import com.djrapitops.plan.storage.database.transactions.events.StoreServerPlayerTransaction;
+import com.djrapitops.plan.storage.database.transactions.events.StoreSessionTransaction;
+import com.djrapitops.plan.storage.database.transactions.events.StoreWorldNameTransaction;
+import org.junit.jupiter.api.Test;
+import utilities.RandomData;
+import utilities.TestConstants;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * @author AuroraLS3
+ */
+public interface PlayerRetentionQueriesTest extends DatabaseTestPreparer {
+
+    @Test
+    default void networkBasedRetentionDataIsFetched() {
+        FinishedSession session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
+        long registerTime = session.getStart();
+
+        db().executeTransaction(new StoreWorldNameTransaction(serverUUID(), worlds[0]));
+        db().executeTransaction(new StoreWorldNameTransaction(serverUUID(), worlds[1]));
+        db().executeTransaction(new StoreServerPlayerTransaction(playerUUID, () -> registerTime,
+                TestConstants.PLAYER_ONE_NAME, serverUUID(), TestConstants.GET_PLAYER_HOSTNAME));
+        db().executeTransaction(new StoreServerPlayerTransaction(player2UUID, () -> registerTime,
+                TestConstants.PLAYER_TWO_NAME, serverUUID(), TestConstants.GET_PLAYER_HOSTNAME));
+
+
+        db().executeTransaction(new StoreSessionTransaction(session));
+
+        List<RetentionData> expected = List.of(new RetentionData(playerUUID, registerTime, session.getEnd(), session.getLength()));
+        List<RetentionData> result = db().query(PlayerRetentionQueries.fetchRetentionData());
+        assertEquals(expected, result);
+    }
+
+    @Test
+    default void serverBasedRetentionDataIsFetched() {
+        FinishedSession session = RandomData.randomSession(serverUUID(), worlds, playerUUID, player2UUID);
+        long registerTime = session.getStart();
+
+        db().executeTransaction(new StoreWorldNameTransaction(serverUUID(), worlds[0]));
+        db().executeTransaction(new StoreWorldNameTransaction(serverUUID(), worlds[1]));
+        db().executeTransaction(new StoreServerPlayerTransaction(playerUUID, () -> registerTime,
+                TestConstants.PLAYER_ONE_NAME, serverUUID(), TestConstants.GET_PLAYER_HOSTNAME));
+        db().executeTransaction(new StoreServerPlayerTransaction(player2UUID, () -> registerTime,
+                TestConstants.PLAYER_TWO_NAME, serverUUID(), TestConstants.GET_PLAYER_HOSTNAME));
+
+        db().executeTransaction(new StoreSessionTransaction(session));
+
+        List<RetentionData> expected = List.of(new RetentionData(playerUUID, registerTime, session.getEnd(), session.getLength()));
+        List<RetentionData> result = db().query(PlayerRetentionQueries.fetchRetentionData(serverUUID()));
+        assertEquals(expected, result);
+    }
+
+}

Plan/common/src/test/java/extension/FullSystemExtension.java

@@ -93,7 +93,7 @@ public class FullSystemExtension implements ParameterResolver, BeforeAllCallback
 
     @Override
     public void afterAll(ExtensionContext context) throws Exception {
-        deleteDirectory(tempDir);
+        if (tempDir != null) deleteDirectory(tempDir);
     }
 
     private void deleteDirectory(Path directory) throws IOException {

Plan/common/src/test/java/extension/SeleniumExtension.java

@@ -72,6 +72,7 @@ public class SeleniumExtension implements ParameterResolver, BeforeAllCallback,
     private ChromeDriver getChromeWebDriver() {
         ChromeOptions chromeOptions = new ChromeOptions();
         chromeOptions.addArguments("--enable-javascript");
+        chromeOptions.addArguments("--remote-allow-origins=*");
         chromeOptions.setCapability(ChromeOptions.LOGGING_PREFS, getLoggingPreferences());
 
         // Using environment variable assumes linux

Plan/common/src/test/java/utilities/TableContentsQuery.java

@@ -0,0 +1,56 @@
+/*
+ *  This file is part of Player Analytics (Plan).
+ *
+ *  Plan is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License v3 as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  Plan is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with Plan. If not, see <https://www.gnu.org/licenses/>.
+ */
+package utilities;
+
+import com.djrapitops.plan.storage.database.queries.QueryAllStatement;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Utility for quick lookups of table contents during testing.
+ *
+ * @author AuroraLS3
+ */
+public class TableContentsQuery extends QueryAllStatement<List<List<Object>>> {
+
+    public TableContentsQuery(String tableName) {
+        super("SELECT * FROM " + tableName);
+    }
+
+    @Override
+    public List<List<Object>> processResults(ResultSet set) throws SQLException {
+        List<List<Object>> rows = new ArrayList<>();
+        int colCount = set.getMetaData().getColumnCount();
+
+        List<Object> firstRow = new ArrayList<>();
+        for (int i = 1; i <= colCount; i++) {
+            firstRow.add(set.getMetaData().getColumnLabel(i));
+        }
+        rows.add(firstRow);
+        while (set.next()) {
+            List<Object> row = new ArrayList<>();
+            for (int i = 1; i <= colCount; i++) {
+                row.add(set.getObject(i));
+            }
+            rows.add(row);
+        }
+        return rows;
+    }
+}

Plan/react/dashboard/src/App.js

@@ -37,12 +37,14 @@ const ServerPerformance = React.lazy(() => import("./views/server/ServerPerforma
 const ServerPluginData = React.lazy(() => import("./views/server/ServerPluginData"));
 const ServerWidePluginData = React.lazy(() => import("./views/server/ServerWidePluginData"));
 const ServerJoinAddresses = React.lazy(() => import("./views/server/ServerJoinAddresses"));
+const ServerPlayerRetention = React.lazy(() => import("./views/server/ServerPlayerRetention"));
 
 const NetworkPage = React.lazy(() => import("./views/layout/NetworkPage"));
 const NetworkOverview = React.lazy(() => import("./views/network/NetworkOverview"));
 const NetworkServers = React.lazy(() => import("./views/network/NetworkServers"));
 const NetworkSessions = React.lazy(() => import("./views/network/NetworkSessions"));
 const NetworkJoinAddresses = React.lazy(() => import("./views/network/NetworkJoinAddresses"));
+const NetworkPlayerRetention = React.lazy(() => import("./views/network/NetworkPlayerRetention"));
 const NetworkGeolocations = React.lazy(() => import("./views/network/NetworkGeolocations"));
 const NetworkPlayerbaseOverview = React.lazy(() => import("./views/network/NetworkPlayerbaseOverview"));
 const NetworkPerformance = React.lazy(() => import("./views/network/NetworkPerformance"));
@@ -145,7 +147,7 @@ function App() {
                                 <Route path="pvppve" element={<Lazy><ServerPvpPve/></Lazy>}/>
                                 <Route path="playerbase" element={<Lazy><PlayerbaseOverview/></Lazy>}/>
                                 <Route path="join-addresses" element={<Lazy><ServerJoinAddresses/></Lazy>}/>
-                                <Route path="retention" element={<></>}/>
+                                <Route path="retention" element={<Lazy><ServerPlayerRetention/></Lazy>}/>
                                 <Route path="players" element={<Lazy><ServerPlayers/></Lazy>}/>
                                 <Route path="geolocations" element={<Lazy><ServerGeolocations/></Lazy>}/>
                                 <Route path="performance" element={<Lazy><ServerPerformance/></Lazy>}/>
@@ -165,6 +167,7 @@ function App() {
                                 {!staticSite &&
                                     <Route path="performance" element={<Lazy><NetworkPerformance/></Lazy>}/>}
                                 <Route path="playerbase" element={<Lazy><NetworkPlayerbaseOverview/></Lazy>}/>
+                                <Route path="retention" element={<Lazy><NetworkPlayerRetention/></Lazy>}/>
                                 <Route path="join-addresses" element={<Lazy><NetworkJoinAddresses/></Lazy>}/>
                                 <Route path="players" element={<Lazy><AllPlayers/></Lazy>}/>
                                 <Route path="geolocations" element={<Lazy><NetworkGeolocations/></Lazy>}/>

Plan/react/dashboard/src/components/CardTabs.js

@@ -17,9 +17,9 @@ const TabButton = ({name, href, icon, color, active}) => {
 const TabButtons = ({tabs, selectedTab}) => {
     return (
         <ul className="nav nav-tabs" role="tablist">
-            {tabs.map((tab, i) => (
+            {tabs.map(tab => (
                 <TabButton
-                    key={i}
+                    key={tab.href}
                     name={tab.name}
                     href={tab.href}
                     icon={tab.icon}
@@ -37,10 +37,10 @@ const CardTabs = ({tabs}) => {
     const [selectedTab, setSelectedTab] = useState(firstTab);
 
     useEffect(() => {
-        setSelectedTab(hash && tabs ? tabs.find(t => t.href === hash.substring(1)).href : firstTab)
+        setSelectedTab(hash && tabs ? tabs.find(t => t.href === hash.substring(1))?.href : firstTab)
     }, [hash, tabs, firstTab])
 
-    const tabContent = tabs.find(t => t.href === selectedTab).element;
+    const tabContent = tabs.find(t => t.href === selectedTab)?.element;
     return (
         <>
             <TabButtons tabs={tabs} selectedTab={selectedTab}/>

Plan/react/dashboard/src/components/cards/CardHeader.js

@@ -3,13 +3,14 @@ import {FontAwesomeIcon as Fa} from "@fortawesome/react-fontawesome";
 import {Card} from "react-bootstrap";
 import {useTranslation} from "react-i18next";
 
-const CardHeader = ({icon, color, label}) => {
+const CardHeader = ({icon, color, label, children}) => {
     const {t} = useTranslation();
 
     return (
         <Card.Header>
-            <h6 className="col-black">
+            <h6 className="col-black" style={{width: "100%"}}>
                 <Fa icon={icon} className={"col-" + color}/> {t(label)}
+                {children}
             </h6>
         </Card.Header>
     )

Plan/react/dashboard/src/components/cards/common/PlayerRetentionGraphCard.js

@@ -0,0 +1,322 @@
+import React, {useCallback, useEffect, useMemo, useState} from 'react';
+import {Card, Col, Row} from "react-bootstrap";
+import CardHeader from "../CardHeader";
+import {faUsersViewfinder} from "@fortawesome/free-solid-svg-icons";
+import {useTranslation} from "react-i18next";
+import ExtendableCardBody from "../../layout/extension/ExtendableCardBody";
+import {BasicDropdown} from "../../input/BasicDropdown";
+import {useDataRequest} from "../../../hooks/dataFetchHook";
+import {fetchPlayerJoinAddresses, fetchRetentionData} from "../../../service/serverService";
+import {ErrorViewCard} from "../../../views/ErrorView";
+import {CardLoader} from "../../navigation/Loader";
+import {tooltip} from "../../../util/graphs";
+import {hsvToRgb, randomHSVColor, rgbToHexString, withReducedSaturation} from "../../../util/colors";
+import LineGraph from "../../graphs/LineGraph";
+import FunctionPlotGraph from "../../graphs/FunctionPlotGraph";
+import {useTheme} from "../../../hooks/themeHook";
+import {useNavigation} from "../../../hooks/navigationHook";
+import {FontAwesomeIcon as Fa} from "@fortawesome/react-fontawesome";
+import {faQuestionCircle} from "@fortawesome/free-regular-svg-icons";
+
+const dayMs = 24 * 3600000;
+const getWeek = (date) => {
+    const onejan = new Date(date.getFullYear(), 0, 1);
+    const today = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const dayOfYear = ((today - onejan + 86400000) / 86400000);
+    return Math.ceil(dayOfYear / 7)
+};
+
+const PlayerRetentionGraphCard = ({identifier}) => {
+    const {t} = useTranslation();
+    const {nightModeEnabled} = useTheme();
+    const {setHelpModalTopic} = useNavigation();
+    const openHelp = useCallback(() => setHelpModalTopic('player-retention-graph'), [setHelpModalTopic]);
+
+    const time = useMemo(() => new Date().getTime(), []);
+
+    const {data, loadingError} = useDataRequest(fetchRetentionData, [identifier]);
+    const {
+        data: joinAddressData,
+        loadingError: joinAddressLoadingError
+    } = useDataRequest(fetchPlayerJoinAddresses, [identifier]);
+
+    const [selectedWindow, setSelectedWindow] = useState('days');
+    const windowOptions = useMemo(() => [
+        {name: 'hours', displayName: t('html.label.time.hours'), increment: 3600000},
+        {name: 'days', displayName: t('html.label.time.days'), increment: dayMs},
+        {name: 'weeks', displayName: t('html.label.time.weeks'), increment: 7 * dayMs},
+        {name: 'months', displayName: t('html.label.time.months'), increment: 30 * dayMs},
+    ], [t]);
+    const [selectedGroup, setSelectedGroup] = useState('registered-7d');
+    const groupOptions = useMemo(() => [
+        {name: 'registered-7d', displayName: t('html.label.retention.inLast7d'), start: time - 7 * dayMs},
+        {name: 'registered-30d', displayName: t('html.label.retention.inLast30d'), start: time - 30 * dayMs},
+        {name: 'registered-3m', displayName: t('html.label.retention.inLast90d'), start: time - 3 * 30 * dayMs},
+        {name: 'registered-6m', displayName: t('html.label.retention.inLast180d'), start: time - 6 * 30 * dayMs},
+        {name: 'registered-1y', displayName: t('html.label.retention.inLast365d'), start: time - 365 * dayMs},
+        {name: 'registered-2y', displayName: t('html.label.retention.inLast730d'), start: time - 2 * 365 * dayMs},
+        {name: 'registered-ever', displayName: t('html.label.retention.inAnytime'), start: 0},
+    ], [t, time]);
+    const [selectedGroupBy, setSelectedGroupBy] = useState('none');
+    const groupByOptions = useMemo(() => [
+        {name: 'none', displayName: t('html.label.retention.groupByNone')},
+        {name: 'days', displayName: t('html.label.time.day')},
+        {name: 'weeks', displayName: t('html.label.time.week')},
+        {name: 'months', displayName: t('html.label.time.month')},
+        {name: 'years', displayName: t('html.label.time.year')},
+        {name: 'joinAddress', displayName: t('html.label.joinAddress')},
+    ], [t]);
+    const [selectedYAxis, setSelectedYAxis] = useState('percentage');
+    const yAxisOptions = useMemo(() => [
+        {name: 'percentage', displayName: t('html.label.unit.percentage')},
+        {name: 'count', displayName: t('html.label.unit.playerCount')},
+        {name: 'count-stacked', displayName: t('html.label.unit.playerCount') + ' (' + t('html.label.stacked') + ')'},
+    ], [t]);
+    const [selectedAxis, setSelectedAxis] = useState('time');
+    const axisOptions = useMemo(() => [
+        {name: 'time', displayName: t('html.label.retention.timeSinceRegistered')},
+        {name: 'playtime', displayName: t('html.label.playtime')},
+        {name: 'date', displayName: t('html.label.time.date')},
+        {name: 'deltas', displayName: t('html.label.time.date') + ' > ' + t('html.label.registered')},
+    ], [t]);
+
+    const [series, setSeries] = useState([]);
+    const [graphOptions, setGraphOptions] = useState({title: {text: ''},});
+
+    const mapToData = useCallback(async (dataToMap, start) => {
+        const total = dataToMap.length;
+        let seriesData;
+        const increment = windowOptions.find(option => option.name === selectedWindow).increment;
+        const xAxis = axisOptions.find(option => option.name === selectedAxis).name;
+        switch (xAxis) {
+            case 'deltas':
+                const retainedBasedOnDeltas = [];
+                const firstRegisterDeltasStart = dataToMap[0].registerDate - dataToMap[0].registerDate % increment;
+                let previousRetained = -1;
+                for (let date = firstRegisterDeltasStart; date < time; date += increment) {
+                    const filter = player => player.registerDate <= date && player.lastSeenDate >= date;
+                    const retainedSince = dataToMap.filter(filter).length;
+                    retainedBasedOnDeltas.push([date, selectedYAxis === 'percentage' ? retainedSince * 100.0 / total : retainedSince]);
+                    if (previousRetained === retainedSince && retainedSince <= 0.5) break;
+                    if (previousRetained !== -1 || retainedSince > 0) previousRetained = retainedSince;
+                }
+                seriesData = retainedBasedOnDeltas;
+                break;
+            case 'date':
+                const retainedBasedOnDate = [];
+                const firstRegisterDateStart = dataToMap[0].registerDate - dataToMap[0].registerDate % increment;
+                for (let date = firstRegisterDateStart; date < time; date += increment) {
+                    const filter = player => player.lastSeenDate >= date;
+                    const retainedSince = dataToMap.filter(filter).length;
+                    retainedBasedOnDate.push([date, selectedYAxis === 'percentage' ? retainedSince * 100.0 / total : retainedSince]);
+                    if (retainedSince < 0.5) break;
+                }
+                seriesData = retainedBasedOnDate;
+                break;
+            case 'time':
+                const retainedBasedOnTime = [];
+                for (let i = 0; i < time; i += increment) {
+                    const retainedSince = dataToMap.filter(point => point.timeDifference > i).length;
+                    retainedBasedOnTime.push([(i) / increment, selectedYAxis === 'percentage' ? retainedSince * 100.0 / total : retainedSince]);
+                    if (retainedSince < 0.5) break;
+                }
+                seriesData = retainedBasedOnTime;
+                break;
+            case 'playtime':
+            default:
+                const retainedBasedOnPlaytime = [];
+                for (let i = start; i < time; i += increment) {
+                    const retainedSince = dataToMap.filter(point => point.playtime > i - start).length;
+                    retainedBasedOnPlaytime.push([(i - start) / increment, selectedYAxis === 'percentage' ? retainedSince * 100.0 / total : retainedSince]);
+                    if (retainedSince < 0.5) break;
+                }
+                seriesData = retainedBasedOnPlaytime;
+                break;
+        }
+        return seriesData;
+    }, [selectedWindow, windowOptions, selectedAxis, axisOptions, selectedYAxis, time])
+
+    const group = useCallback(async (filtered, joinAddressData) => {
+        const grouped = {};
+        const groupBy = groupByOptions.find(option => option.name === selectedGroupBy).name;
+        for (const point of filtered) {
+            const date = new Date();
+            date.setTime(point.registerDate);
+            switch (groupBy) {
+                case 'days':
+                    const day = date.toISOString().substring(0, 10);
+                    if (!grouped[day]) grouped[day] = [];
+                    grouped[day].push(point);
+                    break;
+                case 'weeks':
+                    const week = date.getUTCFullYear() + '-week-' + getWeek(date);
+                    if (!grouped[week]) grouped[week] = [];
+                    grouped[week].push(point);
+                    break;
+                case 'months':
+                    const month = date.toISOString().substring(0, 7);
+                    if (!grouped[month]) grouped[month] = [];
+                    grouped[month].push(point);
+                    break;
+                case 'years':
+                    const year = date.getUTCFullYear();
+                    if (!grouped[year]) grouped[year] = [];
+                    grouped[year].push(point);
+                    break;
+                case 'joinAddress':
+                    const joinAddress = joinAddressData[point.playerUUID];
+                    if (!grouped[joinAddress]) grouped[joinAddress] = [];
+                    grouped[joinAddress].push(point);
+                    break;
+                case 'none':
+                default:
+                    grouped['all'] = filtered;
+                    break;
+            }
+        }
+        return grouped;
+    }, [groupByOptions, selectedGroupBy]);
+
+    const createSeries = useCallback(async (retentionData, joinAddressData) => {
+
+        const start = groupOptions.find(option => option.name === selectedGroup).start;
+        const filtered = retentionData.filter(point => point.registerDate > start)
+            .sort((a, b) => a.registerDate - b.registerDate);
+
+        const grouped = await group(filtered, joinAddressData);
+
+        let colorIndex = 1;
+        return Promise.all(Object.entries(grouped).map(async group => {
+            const name = group[0];
+            const groupData = group[1];
+            const color = rgbToHexString(hsvToRgb(randomHSVColor(colorIndex)));
+            colorIndex++;
+            const mapped = await mapToData(groupData, start);
+            if (mapped.filter(point => point[1] === 0).length === mapped.length) {
+                // Don't include all zeros series
+                return [];
+            }
+            return [{
+                name: name,
+                type: selectedYAxis === 'count-stacked' ? 'areaspline' : 'spline',
+                tooltip: tooltip.twoDecimals,
+                data: mapped,
+                color: nightModeEnabled ? withReducedSaturation(color) : color
+            }];
+        }));
+    }, [nightModeEnabled, mapToData, groupOptions, selectedGroup, selectedYAxis, group]);
+
+    useEffect(() => {
+        if (!data || !joinAddressData) return;
+
+        createSeries(data.player_retention, joinAddressData.join_address_by_player).then(series => setSeries(series.flat()));
+    }, [data, joinAddressData, createSeries, setSeries]);
+
+    useEffect(() => {
+        const windowName = windowOptions.find(option => option.name === selectedWindow).displayName;
+        const unitLabel = selectedYAxis === 'percentage' ? t('html.label.retention.retainedPlayersPercentage') : t('html.label.players');
+        const axisName = axisOptions.find(option => option.name === selectedAxis).displayName;
+        setGraphOptions({
+            title: {text: ''},
+            rangeSelector: selectedAxis === 'date' ? {
+                selected: 2,
+                buttons: [{
+                    type: 'day',
+                    count: 7,
+                    text: '7d'
+                }, {
+                    type: 'month',
+                    count: 1,
+                    text: '30d'
+                }, {
+                    type: 'all',
+                    text: 'All'
+                }]
+            } : undefined,
+            chart: {
+                zooming: {
+                    type: 'xy'
+                }
+            },
+            plotOptions: {
+                areaspline: {
+                    fillOpacity: nightModeEnabled ? 0.2 : 0.4,
+                    stacking: 'normal'
+                }
+            },
+            legend: {
+                enabled: selectedGroupBy !== 'none',
+            },
+            xAxis: {
+                zoomEnabled: true,
+                title: {
+                    text: selectedAxis === 'date' || selectedAxis === 'deltas' ? t('html.label.time.date') : axisName + ' (' + windowName + ')'
+                }
+            },
+            yAxis: {
+                zoomEnabled: true,
+                title: {text: unitLabel},
+                max: selectedYAxis === 'percentage' ? 100 : undefined,
+                min: 0
+            },
+            tooltip: selectedAxis === 'date' || selectedAxis === 'deltas' ? {
+                enabled: true,
+                valueDecimals: 2,
+                pointFormat: (selectedGroupBy !== 'none' ? '{series.name} - ' : '') + '<b>{point.y} ' + (selectedYAxis === 'percentage' ? '%' : t('html.label.players')) + '</b>'
+            } : {
+                enabled: true,
+                valueDecimals: 2,
+                headerFormat: '{point.x} ' + windowName + '<br>',
+                pointFormat: (selectedGroupBy !== 'none' ? '{series.name} - ' : '') + '<b>{point.y} ' + (selectedYAxis === 'percentage' ? '%' : t('html.label.players')) + '</b>'
+            },
+            series: series
+        })
+    }, [t, nightModeEnabled, series, selectedGroupBy, axisOptions, selectedAxis, windowOptions, selectedWindow, selectedYAxis]);
+
+    if (loadingError) return <ErrorViewCard error={loadingError}/>
+    if (joinAddressLoadingError) return <ErrorViewCard error={joinAddressLoadingError}/>
+    if (!data || !joinAddressData) return <CardLoader/>;
+
+    return (
+        <Card>
+            <CardHeader icon={faUsersViewfinder} color={'indigo'} label={t('html.label.playerRetention')}>
+                <button className={"float-end"} onClick={openHelp}>
+                    <Fa className={"col-blue"}
+                        icon={faQuestionCircle}/>
+                </button>
+            </CardHeader>
+            <ExtendableCardBody id={'card-body-' + (identifier ? 'server-' : 'network-') + 'player-retention'}>
+                <Row>
+                    <Col>
+                        <label>{t('html.label.retention.timeStep')}</label>
+                        <BasicDropdown selected={selectedWindow} options={windowOptions} onChange={setSelectedWindow}/>
+                    </Col>
+                    <Col>
+                        <label>{t('html.label.retention.playersRegisteredInTime')}</label>
+                        <BasicDropdown selected={selectedGroup} options={groupOptions} onChange={setSelectedGroup}/>
+                    </Col>
+                    <Col>
+                        <label>{t('html.label.retention.groupByTime')}</label>
+                        <BasicDropdown selected={selectedGroupBy} options={groupByOptions}
+                                       onChange={setSelectedGroupBy}/>
+                    </Col>
+                    <Col>
+                        <label>{t('html.label.xAxis')}</label>
+                        <BasicDropdown selected={selectedAxis} options={axisOptions} onChange={setSelectedAxis}/>
+                    </Col>
+                    <Col>
+                        <label>{t('html.label.yAxis')}</label>
+                        <BasicDropdown selected={selectedYAxis} options={yAxisOptions} onChange={setSelectedYAxis}/>
+                    </Col>
+                </Row>
+                <hr/>
+                {(selectedAxis !== 'date' && selectedAxis !== 'deltas') &&
+                    <FunctionPlotGraph id={'retention-graph'} options={graphOptions} tall/>}
+                {(selectedAxis === 'date' || selectedAxis === 'deltas') &&
+                    <LineGraph id={'retention-graph'} options={graphOptions} tall/>}
+            </ExtendableCardBody>
+        </Card>
+    )
+};
+
+export default PlayerRetentionGraphCard

Plan/react/dashboard/src/components/graphs/FunctionPlotGraph.js

@@ -14,6 +14,7 @@ const FunctionPlotGraph = ({
                                yPlotBands,
                                xPlotLines,
                                xPlotBands,
+                               options
                            }) => {
     const {t} = useTranslation()
     const {graphTheming, nightModeEnabled} = useTheme();
@@ -23,7 +24,7 @@ const FunctionPlotGraph = ({
         Accessibility(Highcharts);
         Highcharts.setOptions({lang: {noData: t('html.label.noDataToDisplay')}})
         Highcharts.setOptions(graphTheming);
-        Highcharts.chart(id, {
+        Highcharts.chart(id, options ? options : {
             yAxis: {
                 plotLines: yPlotLines,
                 plotBands: yPlotBands
@@ -44,7 +45,7 @@ const FunctionPlotGraph = ({
             },
             series: series
         });
-    }, [series, id, t, graphTheming, nightModeEnabled, legendEnabled,
+    }, [options, series, id, t, graphTheming, nightModeEnabled, legendEnabled,
         yPlotLines, yPlotBands, xPlotLines, xPlotBands]);
 
     const style = tall ? {height: "450px"} : undefined;

Plan/react/dashboard/src/components/graphs/LineGraph.js

@@ -16,7 +16,9 @@ const LineGraph = ({
                        selectedRange,
                        extremes,
                        onSetExtremes,
-                       alreadyOffsetTimezone
+                       alreadyOffsetTimezone,
+                       options,
+                       extraModules
                    }) => {
     const {t} = useTranslation()
     const {graphTheming, nightModeEnabled} = useTheme();
@@ -26,9 +28,14 @@ const LineGraph = ({
     useEffect(() => {
         NoDataDisplay(Highcharts);
         Accessibility(Highcharts);
+        if (extraModules) {
+            for (const extraModule of extraModules) {
+                extraModule(Highcharts);
+            }
+        }
         Highcharts.setOptions({lang: {noData: t('html.label.noDataToDisplay')}})
         Highcharts.setOptions(graphTheming);
-        setGraph(Highcharts.stockChart(id, {
+        setGraph(Highcharts.stockChart(id, options ? options : {
             rangeSelector: {
                 selected: selectedRange !== undefined ? selectedRange : 2,
                 buttons: linegraphButtons
@@ -58,7 +65,7 @@ const LineGraph = ({
             },
             series: series
         }));
-    }, [series, id, t,
+    }, [options, extraModules, series, id, t,
         graphTheming, nightModeEnabled, alreadyOffsetTimezone, timeZoneOffsetMinutes,
         legendEnabled, yAxis,
         onSetExtremes, setGraph, selectedRange]);

Plan/react/dashboard/src/components/input/BasicDropdown.js

@@ -1,28 +1,16 @@
-import React from 'react';
-import DropdownToggle from "react-bootstrap/lib/esm/DropdownToggle";
-import {FontAwesomeIcon as Fa} from "@fortawesome/react-fontawesome";
-import DropdownMenu from "react-bootstrap/lib/esm/DropdownMenu";
-import DropdownItem from "react-bootstrap/lib/esm/DropdownItem";
-import {useTranslation} from "react-i18next";
-import {Dropdown} from "react-bootstrap";
+import React, {useCallback} from 'react';
 
-export const DropDownWithOptions = ({selected, optionList, onChange, optionLabelMapper, icon, title}) => {
-    const {t} = useTranslation();
+export const BasicDropdown = ({selected, onChange, options}) => {
+    const onSelect = useCallback(({target}) => {
+        onChange(target.value);
+    }, [onChange]);
 
     return (
-        <Dropdown className="float-end" style={{position: "absolute", right: "0.5rem"}} title={t(title)}>
-            <DropdownToggle variant=''>
-                <Fa icon={icon}/> {t(optionLabelMapper ? optionLabelMapper(selected) : selected)}
-            </DropdownToggle>
-
-            <DropdownMenu>
-                <h6 className="dropdown-header">{t(title)}</h6>
-                {optionList.map((option, i) => (
-                    <DropdownItem key={i} onClick={() => onChange(option)}>
-                        {t(optionLabelMapper ? optionLabelMapper(option) : option)}
-                    </DropdownItem>
-                ))}
-            </DropdownMenu>
-        </Dropdown>
+        <select onChange={onSelect}
+                className="form-select form-select-sm"
+                defaultValue={selected}>
+            {options.map((option, i) =>
+                <option key={option.name} value={option.name} disabled={option.disabled}>{option.displayName}</option>)}
+        </select>
     )
 };

Plan/react/dashboard/src/components/modal/HelpModal.js

@@ -6,6 +6,7 @@ import {useTranslation} from "react-i18next";
 import ActivityIndexHelp from "./help/ActivityIndexHelp";
 import {faQuestionCircle} from "@fortawesome/free-regular-svg-icons";
 import NewPlayerRetentionHelp from "./help/NewPlayerRetentionHelp";
+import PlayerRetentionGraphHelp from "./help/PlayerRetentionGraphHelp";
 
 const HelpModal = () => {
     const {t} = useTranslation();
@@ -20,6 +21,10 @@ const HelpModal = () => {
         "new-player-retention": {
             title: t('html.label.newPlayerRetention'),
             body: <NewPlayerRetentionHelp/>
+        },
+        "player-retention-graph": {
+            title: t('html.label.playerRetention'),
+            body: <PlayerRetentionGraphHelp/>
         }
     }
 

Plan/react/dashboard/src/components/modal/help/ActivityIndexHelp.js

@@ -14,11 +14,11 @@ const inverseIndex = y => {
     return -2 * y / (Math.PI * (y - 5));
 }
 
-const activityIndexPlot = () => {
+const activityIndexPlot = (maxValue) => {
     const data = []
     let x;
 
-    for (x = 0; x <= 3.5; x += 0.01) {
+    for (x = 0; x <= Math.max(3.5, maxValue); x += 0.01) {
         data.push([x, indexValue(x)]);
     }
     return data;
@@ -67,7 +67,8 @@ const ActivityIndexHelp = () => {
     const [result, setResult] = useState(0);
 
     const series = useMemo(() => {
-        const data = activityIndexPlot();
+        const inverse = inverseIndex(result);
+        const data = activityIndexPlot(inverse);
         return [{
             name: t('html.label.activityIndex') + ' y=5-5/(πx/2)+1',
             data: data,
@@ -77,7 +78,7 @@ const ActivityIndexHelp = () => {
         }, {
             name: t('html.label.help.testResult'),
             type: 'scatter',
-            data: [{x: inverseIndex(result), y: result, marker: {radius: 10}}],
+            data: [{x: inverse, y: result, marker: {radius: 10}}],
             pointPlacement: 0,
             width: 5,
             tooltip: tooltip.twoDecimals,

Plan/react/dashboard/src/components/modal/help/PlayerRetentionGraphHelp.js

@@ -0,0 +1,273 @@
+import React, {useCallback, useEffect, useMemo, useState} from 'react';
+import {useTranslation} from "react-i18next";
+import {faChartArea, faGears} from "@fortawesome/free-solid-svg-icons";
+import CardTabs from "../../CardTabs"
+import {BasicDropdown} from "../../input/BasicDropdown";
+import RangeSlider from "react-bootstrap-range-slider";
+import {tooltip} from "../../../util/graphs";
+import {hsvToRgb, randomHSVColor, rgbToHexString} from "../../../util/colors";
+import FunctionPlotGraph from "../../graphs/FunctionPlotGraph";
+import LineGraph from "../../graphs/LineGraph";
+
+const PlayerRetentionGraphHelp = () => {
+    const {t} = useTranslation();
+
+    const [selectedAxis, setSelectedAxis] = useState('time');
+    const axisOptions = useMemo(() => [
+        {name: 'time', displayName: t('html.label.retention.timeSinceRegistered')},
+        {name: 'playtime', displayName: t('html.label.playtime')},
+        {name: 'date', displayName: t('html.label.time.date')},
+        {name: 'deltas', displayName: t('html.label.time.date') + ' > ' + t('html.label.registered')},
+    ], [t]);
+
+    const [x, setX] = useState(0);
+    const updateX = useCallback(event => setX(event.target.value), [setX]);
+    useEffect(() => {
+        setX(0);
+    }, [selectedAxis, setX]);
+
+    const data = useMemo(() => [
+        {x: 1},
+        {x: 2},
+        {x: 9},
+        {x: 24},
+    ], []);
+    const [series, setSeries] = useState([]);
+    const [graphOptions, setGraphOptions] = useState({title: {text: ''},});
+    useEffect(() => {
+        const d = []
+        for (let i = 0; i < x; i++) {
+            d.push([i, data.filter(item => item.x > i).length * 100.0 / data.length]);
+        }
+        for (let i = x; i < 30; i++) {
+            d.push([i, null]);
+        }
+        const color = rgbToHexString(hsvToRgb(randomHSVColor(1)));
+        setSeries([{
+            name: 'name',
+            type: 'spline',
+            tooltip: tooltip.twoDecimals,
+            data: d,
+            color
+        }]);
+    }, [x, data, setSeries]);
+    useEffect(() => {
+        const unitLabel = t('html.label.retention.retainedPlayersPercentage');
+        const windowName = t('html.label.time.hours');
+        const axisName = axisOptions.find(option => option.name === selectedAxis).displayName;
+        setGraphOptions({
+            title: {text: ''},
+            rangeSelector: selectedAxis === 'date' ? {
+                selected: 2,
+                buttons: [{
+                    type: 'day',
+                    count: 7,
+                    text: '7d'
+                }, {
+                    type: 'month',
+                    count: 1,
+                    text: '30d'
+                }, {
+                    type: 'all',
+                    text: 'All'
+                }]
+            } : undefined,
+            legend: {
+                enabled: false,
+            },
+            plotOptions: {
+                series: {animation: false}
+            },
+            xAxis: {
+                zoomEnabled: true,
+                title: {
+                    text: selectedAxis === 'date' || selectedAxis === 'deltas' ? t('html.label.time.date') : axisName + ' (' + windowName + ')'
+                }
+            },
+            yAxis: {
+                zoomEnabled: true,
+                title: {text: unitLabel},
+                max: 100,
+                min: 0
+            },
+            tooltip: selectedAxis === 'date' || selectedAxis === 'deltas' ? {
+                enabled: true,
+                valueDecimals: 2,
+                pointFormat: '<b>{point.y} %</b>'
+            } : {
+                enabled: true,
+                valueDecimals: 2,
+                headerFormat: '{point.x} ' + windowName + '<br>',
+                pointFormat: '<b>{point.y} %</b>'
+            },
+            series: series
+        })
+    }, [t, series, axisOptions, selectedAxis]);
+
+
+    const disabledColor = 'rgba(0, 0, 0, 0.05)';
+    return (
+        <>
+            <CardTabs tabs={[
+                {
+                    name: t('html.label.help.usingTheGraph'), icon: faGears, color: 'indigo', href: 'data-explanation',
+                    element: <div className={'mt-2'}>
+                        <p>{t('html.label.help.retention.options')}</p>
+                        <h4>{t('html.label.help.tips')}</h4>
+                        <ul>
+                            <li>{t('html.label.help.retention.compareMonths')
+                                .replace('<0>', t('html.label.retention.groupByTime'))
+                                .replace('<1>', t('html.label.time.month'))}
+                            </li>
+                            <li>{t('html.label.help.retention.compareJoinAddress')}</li>
+                            <li>{t('html.label.help.graph.zoom')}</li>
+                            <li>{t('html.label.help.graph.labels')}</li>
+                        </ul>
+                        <hr/>
+                        <h3>{t('html.label.help.retention.howIsItCalculated')}</h3>
+                        <p>{t('html.label.help.retention.howIsItCalculatedData')}</p>
+                        <pre>
+                            {'{\n    playerUUID,\n    registerDate,\n    lastSeenDate,\n    timeDifference = lastSeenDate - registerDate,\n    playtime\n    joinAddress\n}'}
+                        </pre>
+                        <ol>
+                            <li>{t('html.label.help.retention.calculationStep1')
+                                .replace('<>', t('html.label.retention.timeSinceRegistered'))}
+                            </li>
+                            <li>{t('html.label.help.retention.calculationStep2')
+                                .replace('<0>', t('html.label.retention.groupByTime'))
+                                .replace('<1>', t('html.label.time.month'))}
+                            </li>
+                            <li>{t('html.label.help.retention.calculationStep3')
+                                .replace('<0>', t('html.label.xAxis'))
+                                .replace('<1>', t('html.label.yAxis'))}
+                            </li>
+                            <li>{t('html.label.help.retention.calculationStep4')
+                                .replace('<>', t('html.label.retention.timeStep'))}
+                            </li>
+                            <li>
+                                <p className={'m-0'}>{t('html.label.help.retention.calculationStep5')}
+                                    {t('html.label.help.retention.calculationStep6')}</p>
+                                <label>{t('html.label.xAxis')}</label>
+                                <BasicDropdown selected={selectedAxis} options={axisOptions}
+                                               onChange={setSelectedAxis}/>
+                                <div className={'mt-2'}>
+                                    <p>
+                                        {selectedAxis === 'time' && <>
+                                            {t('html.label.help.retention.calculationStepTime')}
+                                        </>}
+                                        {selectedAxis === 'playtime' && <>
+                                            {t('html.label.help.retention.calculationStepPlaytime')}
+                                        </>}
+                                        {selectedAxis === 'date' && <>
+                                            {t('html.label.help.retention.calculationStepDate')}
+                                        </>}
+                                        {selectedAxis === 'deltas' && <>
+                                            {t('html.label.help.retention.calculationStepDeltas')}
+                                        </>}</p>
+                                    {selectedAxis !== 'date' && selectedAxis !== 'deltas' && <>
+                                        <h4>{t('html.label.help.testPrompt')}</h4>
+                                        <table className={"table"}>
+                                            <thead>
+                                            <tr>
+                                                <th>{t('html.label.player')}</th>
+                                                <th>{axisOptions.find(option => option.name === selectedAxis).displayName}</th>
+                                                <th>{t('html.label.playerRetention')}</th>
+                                            </tr>
+                                            </thead>
+                                            <tbody>
+                                            <tr style={x <= 24 ? {} : {backgroundColor: disabledColor}}>
+                                                <td>Pooh</td>
+                                                <td>1d 53s</td>
+                                                <th>{x <= 24 ? t('plugin.generic.yes') : t('plugin.generic.no')}</th>
+                                            </tr>
+                                            <tr style={x <= 9 ? {} : {backgroundColor: disabledColor}}>
+                                                <td>Piglet</td>
+                                                <td>9h 12min</td>
+                                                <th>{x <= 9 ? t('plugin.generic.yes') : t('plugin.generic.no')}</th>
+                                            </tr>
+                                            <tr style={x <= 2 ? {} : {backgroundColor: disabledColor}}>
+                                                <td>Rabbit</td>
+                                                <td>2h</td>
+                                                <th>{x <= 2 ? t('plugin.generic.yes') : t('plugin.generic.no')}</th>
+                                            </tr>
+                                            <tr style={x <= 1 ? {} : {backgroundColor: disabledColor}}>
+                                                <td>Tigger</td>
+                                                <td>1h 59min 59s</td>
+                                                <th>{x <= 1 ? t('plugin.generic.yes') : t('plugin.generic.no')}</th>
+                                            </tr>
+                                            </tbody>
+                                            <tfoot>
+                                            <tr>
+                                                <th>Retention</th>
+                                                <th></th>
+                                                {x <= 1 && <td>100%</td>}
+                                                {1 < x && x <= 2 && <td>75%</td>}
+                                                {2 < x && x <= 9 && <td>50%</td>}
+                                                {9 < x && x <= 24 && <td>25%</td>}
+                                                {x > 24 && <td>0%</td>}
+                                            </tr>
+                                            </tfoot>
+                                        </table>
+                                        <label>x = {x} {t('html.label.time.hours')}</label>
+                                        <RangeSlider
+                                            value={x}
+                                            onChange={updateX}
+                                            min={0}
+                                            max={25}
+                                            tooltip={'off'}/>
+                                        {(selectedAxis !== 'date' && selectedAxis !== 'deltas') &&
+                                            <FunctionPlotGraph id={'retention-help-graph'} options={graphOptions}/>}
+                                        {(selectedAxis === 'date' || selectedAxis === 'deltas') &&
+                                            <LineGraph id={'retention-help-graph'} options={graphOptions}/>}
+                                    </>}
+                                </div>
+                            </li>
+                        </ol>
+
+                    </div>
+                }, {
+                    name: t('html.label.help.examples'),
+                    icon: faChartArea,
+                    color: 'indigo',
+                    href: 'interesting-combinations',
+                    element: <div className={'mt-2'}>
+                        <label>{t('html.label.retention.timeSinceRegistered')}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225086629-69e70c66-69d5-4a08-afbc-c63b218ec9bc.png'}/>
+                        <hr/>
+                        <label>{t('html.label.help.retention.examples.playtime')}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225086773-ae5646e5-0d9e-4016-9f1d-c392d3d25c07.png'}/>
+                        <hr/>
+                        <label>{t('html.label.time.date')}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225086880-c6e88e9a-125d-4513-b86a-ca61b4d752b2.png'}/>
+                        <hr/>
+                        <label>{t('html.label.help.retention.examples.deltas')
+                            .replace('<>', t('html.label.time.date') + ' > ' + t('html.label.registered'))}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225087066-0cacc7e4-aacc-48ff-97d7-ba2cf6a368ff.png'}/>
+                        <hr/>
+                        <label>{t('html.label.help.retention.examples.pattern')}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225087273-04331324-6bc3-4efb-8864-166b5b3d4a89.png'}/>
+                        <hr/>
+                        <label>{t('html.label.help.retention.examples.plateau')}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225087828-8db2da1a-578d-43fc-abc5-2aa09e97935e.png'}/>
+                        <hr/>
+                        <label>{t('html.label.help.retention.examples.adCampaign')}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225088901-2e30caf6-f141-4998-91de-2034fda5b7e9.png'}/>
+                        <hr/>
+                        <label>{t('html.label.help.retention.examples.stack')}</label>
+                        <img className={'w-100'} alt={t('html.label.help.graph.title')} loading={'lazy'}
+                             src={'https://raw.githubusercontent.com/plan-player-analytics/drawio-diagrams-storage/master/image/screenshot/225722723-cde69a1a-09fd-4e19-a8fe-993d60435652.png'}/>
+                    </div>
+                }
+            ]}/>
+        </>
+    )
+};
+
+export default PlayerRetentionGraphHelp

Plan/react/dashboard/src/service/serverService.js

@@ -268,3 +268,43 @@ const fetchJoinAddressByDayNetwork = async (timestamp) => {
     if (staticSite) url = `/data/graph-joinAddressByDay.json`;
     return doGetRequest(url, timestamp);
 }
+
+export const fetchRetentionData = async (timestamp, identifier) => {
+    if (identifier) {
+        return await fetchServerRetentionData(timestamp, identifier);
+    } else {
+        return await fetchNetworkRetentionData(timestamp);
+    }
+}
+
+const fetchServerRetentionData = async (timestamp, identifier) => {
+    let url = `/v1/retention?server=${identifier}`;
+    if (staticSite) url = `/data/retention-${identifier}.json`;
+    return doGetRequest(url, timestamp);
+}
+
+const fetchNetworkRetentionData = async (timestamp) => {
+    let url = `/v1/retention`;
+    if (staticSite) url = `/data/retention.json`;
+    return doGetRequest(url, timestamp);
+}
+
+export const fetchPlayerJoinAddresses = async (timestamp, identifier) => {
+    if (identifier) {
+        return await fetchServerPlayerJoinAddresses(timestamp, identifier);
+    } else {
+        return await fetchNetworkPlayerJoinAddresses(timestamp);
+    }
+}
+
+const fetchServerPlayerJoinAddresses = async (timestamp, identifier) => {
+    let url = `/v1/joinAddresses?server=${identifier}`;
+    if (staticSite) url = `/data/joinAddresses-${identifier}.json`;
+    return doGetRequest(url, timestamp);
+}
+
+const fetchNetworkPlayerJoinAddresses = async (timestamp) => {
+    let url = `/v1/joinAddresses`;
+    if (staticSite) url = `/data/joinAddresses.json`;
+    return doGetRequest(url, timestamp);
+}

Plan/react/dashboard/src/util/colors.js

@@ -123,6 +123,69 @@ export const colorClassToBgClass = colorClass => {
     return "bg-" + colorClassToColorName(colorClass);
 }
 
+export const hsvToRgb = ([h, s, v]) => {
+    let r, g, b;
+
+    const i = Math.floor(h * 6);
+    const f = h * 6 - i;
+    const p = v * (1 - s);
+    const q = v * (1 - f * s);
+    const t = v * (1 - (1 - f) * s);
+
+    switch (i % 6) {
+        case 0:
+            r = v;
+            g = t;
+            b = p;
+            break;
+        case 1:
+            r = q;
+            g = v;
+            b = p;
+            break;
+        case 2:
+            r = p;
+            g = v;
+            b = t;
+            break;
+        case 3:
+            r = p;
+            g = q;
+            b = v;
+            break;
+        case 4:
+            r = t;
+            g = p;
+            b = v;
+            break;
+        case 5:
+            r = v;
+            g = p;
+            b = q;
+            break;
+        default:
+            break;
+    }
+
+    return [r * 255, g * 255, b * 255];
+}
+
+export const randomHSVColor = (i) => {
+    const goldenRatioConjugate = 0.618033988749895;
+    const hue = i * goldenRatioConjugate % 1;
+    const saturation = 0.7;
+    const value = 0.7 + (Math.random() / 10);
+    return [hue, saturation, value]
+}
+
+export const rgbToHexString = ([r, g, b]) => {
+    return '#' + rgbToHex(r) + rgbToHex(g) + rgbToHex(b);
+}
+
+const rgbToHex = (component) => {
+    return Math.floor(component).toString(16).padStart(2, '0');
+}
+
 // From https://stackoverflow.com/a/3732187
 export const withReducedSaturation = hex => {
     const saturationReduction = 0.70;

Plan/react/dashboard/src/views/layout/NetworkPage.js

@@ -13,7 +13,8 @@ import {
     faSearch,
     faServer,
     faUserGroup,
-    faUsers
+    faUsers,
+    faUsersViewfinder
 } from "@fortawesome/free-solid-svg-icons";
 import {useAuth} from "../../hooks/authenticationHook";
 import Sidebar from "../../components/navigation/Sidebar";
@@ -77,7 +78,7 @@ const NetworkSidebar = () => {
                         href: "playerbase"
                     },
                     {name: 'html.label.joinAddresses', icon: faLocationArrow, href: "join-addresses"},
-                    // {name: 'html.label.playerRetention', icon: faUsersViewfinder, href: "retention"},
+                    {name: 'html.label.playerRetention', icon: faUsersViewfinder, href: "retention"},
                     {name: 'html.label.playerList', icon: faUserGroup, href: "players"},
                     {name: 'html.label.geolocations', icon: faGlobe, href: "geolocations"},
                 ]
@@ -87,7 +88,7 @@ const NetworkSidebar = () => {
             {name: 'html.label.pluginsOverview', icon: faCubes, href: "plugins-overview"}
         ]
 
-        if (extensionData) {
+        if (extensionData?.extensions) {
             extensionData.extensions.filter(extension => extension.wide)
                 .map(extension => extension.extensionInformation)
                 .map(info => {

Plan/react/dashboard/src/views/layout/ServerPage.js

@@ -13,7 +13,8 @@ import {
     faLocationArrow,
     faSearch,
     faUserGroup,
-    faUsers
+    faUsers,
+    faUsersViewfinder
 } from "@fortawesome/free-solid-svg-icons";
 import {useAuth} from "../../hooks/authenticationHook";
 import Sidebar from "../../components/navigation/Sidebar";
@@ -67,7 +68,7 @@ const ServerSidebar = () => {
                         href: "playerbase"
                     },
                     {name: 'html.label.joinAddresses', icon: faLocationArrow, href: "join-addresses"},
-                    // {name: 'html.label.playerRetention', icon: faUsersViewfinder, href: "retention"},
+                    {name: 'html.label.playerRetention', icon: faUsersViewfinder, href: "retention"},
                     {name: 'html.label.playerList', icon: faUserGroup, href: "players"},
                     {name: 'html.label.geolocations', icon: faGlobe, href: "geolocations"},
                 ]
@@ -78,7 +79,7 @@ const ServerSidebar = () => {
             {name: 'html.label.pluginsOverview', icon: faCubes, href: "plugins-overview"}
         ]
 
-        if (extensionData) {
+        if (extensionData?.extensions) {
             extensionData.extensions.filter(extension => extension.wide)
                 .map(extension => extension.extensionInformation)
                 .map(info => {

Plan/react/dashboard/src/views/network/NetworkPlayerRetention.js

@@ -0,0 +1,21 @@
+import React from 'react';
+import ExtendableRow from "../../components/layout/extension/ExtendableRow";
+import {Col} from "react-bootstrap";
+import LoadIn from "../../components/animation/LoadIn";
+import PlayerRetentionGraphCard from "../../components/cards/common/PlayerRetentionGraphCard";
+
+const NetworkPlayerRetention = () => {
+    return (
+        <LoadIn>
+            <section className="network-retention">
+                <ExtendableRow id={'row-network-retention-0'}>
+                    <Col lg={12}>
+                        <PlayerRetentionGraphCard identifier={null}/>
+                    </Col>
+                </ExtendableRow>
+            </section>
+        </LoadIn>
+    )
+};
+
+export default NetworkPlayerRetention

Plan/react/dashboard/src/views/player/PlayerPluginData.js

@@ -10,7 +10,7 @@ const PlayerPluginData = () => {
     const {player} = usePlayer();
     const {serverName} = useParams();
 
-    const extensions = player.extensions.find(extension => extension.serverName === serverName)
+    const extensions = player.extensions ? player.extensions.find(extension => extension.serverName === serverName) : {};
 
     useEffect(() => {
         const masonryRow = document.getElementById('extension-masonry-row');
@@ -48,7 +48,7 @@ const PlayerPluginData = () => {
                 <Row id="extension-masonry-row"
                      data-masonry='{"percentPosition": true, "itemSelector": ".extension-wrapper"}'
                      style={{overflowY: 'hidden'}}>
-                    {extensions.extensionData.map((extension, i) =>
+                    {extensions?.extensionData?.map((extension, i) =>
                         <ExtensionCardWrapper key={'ext-' + i} extension={extension}>
                             <ExtensionCard extension={extension}/>
                         </ExtensionCardWrapper>

Plan/react/dashboard/src/views/server/ServerPlayerRetention.js

@@ -0,0 +1,23 @@
+import React from 'react';
+import ExtendableRow from "../../components/layout/extension/ExtendableRow";
+import {Col} from "react-bootstrap";
+import LoadIn from "../../components/animation/LoadIn";
+import PlayerRetentionGraphCard from "../../components/cards/common/PlayerRetentionGraphCard";
+import {useParams} from "react-router-dom";
+
+const ServerPlayerRetention = () => {
+    const {identifier} = useParams();
+    return (
+        <LoadIn>
+            <section className="server-retention">
+                <ExtendableRow id={'row-server-retention-0'}>
+                    <Col lg={12}>
+                        <PlayerRetentionGraphCard identifier={identifier}/>
+                    </Col>
+                </ExtendableRow>
+            </section>
+        </LoadIn>
+    )
+};
+
+export default ServerPlayerRetention

Plan/react/dashboard/src/views/server/ServerPluginData.js

@@ -11,7 +11,7 @@ import ErrorView from "../ErrorView";
 const ServerPluginData = () => {
     const {t} = useTranslation();
     const {extensionData, extensionDataLoadingError} = useServerExtensionContext();
-    const extensions = useMemo(() => extensionData ? extensionData.extensions.filter(extension => !extension.wide) : [], [extensionData]);
+    const extensions = useMemo(() => extensionData?.extensions ? extensionData.extensions.filter(extension => !extension.wide) : [], [extensionData]);
 
     useEffect(() => {
         const masonryRow = document.getElementById('extension-masonry-row');