A lot of things :)

Author: Restioson

README.md

@@ -1,5 +1,5 @@
 # Loop-de-loop
 
-A small game where you try to fly through all the hoops. First to do it wins!
+Soar amongst the clouds in this game of graceful flight. The first fly through all the hoops wins!
 
 ![A screenshot of the game](screenshot.png)

build.gradle

@@ -26,7 +26,7 @@ dependencies {
 
     implementation 'com.google.code.findbugs:jsr305:3.0.1'
 
-    modImplementation 'xyz.nucleoid:plasmid:0.1.0+build.57'
+    modImplementation 'xyz.nucleoid:plasmid:0.1.0+build.68'
 
      modRuntime("com.github.SuperCoder7979:databreaker:0.2.6") {
          exclude module: "fabric-loader"

gradle.properties

@@ -5,7 +5,7 @@ minecraft_version=1.16.2
 yarn_mappings=1.16.2+build.6
 loader_version=0.9.1+build.205
 # Mod Properties
-mod_version=1.0.4
+mod_version=1.1.0
 maven_group=io.github.restioson
 archives_base_name=loopdeloop
 # Dependencies

src/main/java/io/github/restioson/loopdeloop/LoopDeLoop.java

@@ -3,10 +3,10 @@
 import io.github.restioson.loopdeloop.game.LoopDeLoopConfig;
 import io.github.restioson.loopdeloop.game.LoopDeLoopWaiting;
 import net.fabricmc.api.ModInitializer;
-import xyz.nucleoid.plasmid.game.GameType;
 import net.minecraft.util.Identifier;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import xyz.nucleoid.plasmid.game.GameType;
 
 public final class LoopDeLoop implements ModInitializer {
     public static final String ID = "loopdeloop";

src/main/java/io/github/restioson/loopdeloop/game/LoopDeLoopActive.java

@@ -23,31 +23,23 @@
 import net.minecraft.sound.SoundEvents;
 import net.minecraft.text.LiteralText;
 import net.minecraft.text.Text;
+import net.minecraft.util.ActionResult;
 import net.minecraft.util.Formatting;
+import net.minecraft.util.Pair;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.GameMode;
 import xyz.nucleoid.plasmid.game.GameWorld;
-import xyz.nucleoid.plasmid.game.event.GameCloseListener;
-import xyz.nucleoid.plasmid.game.event.GameOpenListener;
-import xyz.nucleoid.plasmid.game.event.GameTickListener;
-import xyz.nucleoid.plasmid.game.event.OfferPlayerListener;
-import xyz.nucleoid.plasmid.game.event.PlayerAddListener;
-import xyz.nucleoid.plasmid.game.event.PlayerDamageListener;
-import xyz.nucleoid.plasmid.game.event.PlayerDeathListener;
-import xyz.nucleoid.plasmid.game.event.PlayerRemoveListener;
+import xyz.nucleoid.plasmid.game.event.*;
 import xyz.nucleoid.plasmid.game.player.JoinResult;
 import xyz.nucleoid.plasmid.game.rule.GameRule;
 import xyz.nucleoid.plasmid.game.rule.RuleResult;
 import xyz.nucleoid.plasmid.util.ItemStackBuilder;
 
 import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
+
 
 public final class LoopDeLoopActive {
     private final GameWorld gameWorld;
@@ -56,10 +48,12 @@ public final class LoopDeLoopActive {
     private final List<LoopDeLoopWinner> finished;
     private final LoopDeLoopSpawnLogic spawnLogic;
     private final LoopDeLoopTimerBar timerBar = new LoopDeLoopTimerBar();
+    private LoopDeLoopScoreboard scoreboard;
     // Only stores flying players, i.e non-completed players
     private final Object2ObjectMap<ServerPlayerEntity, LoopDeLoopPlayer> player_states;
     @Nullable
     private ServerPlayerEntity lastCompleter;
+    private final List<Pair<ServerPlayerEntity, LoopDeLoopPlayer>> topPlayers;
     @Nullable
     Team team;
     private long closeTime = -1;
@@ -73,6 +67,7 @@ private LoopDeLoopActive(GameWorld gameWorld, LoopDeLoopMap map, LoopDeLoopConfi
         this.finished = new ArrayList<>();
         this.spawnLogic = new LoopDeLoopSpawnLogic(gameWorld, map);
         this.player_states = new Object2ObjectOpenHashMap<>();
+        this.topPlayers = new ArrayList<>();
 
         for (ServerPlayerEntity player : participants) {
             this.player_states.put(player, new LoopDeLoopPlayer());
@@ -125,11 +120,17 @@ private void onOpen() {
         long time = world.getTime();
         this.startTime = time - (time % 20) + (4 * 20) + 19;
         this.finishTime = this.startTime + (this.config.timeLimit * 20);
+        this.scoreboard = new LoopDeLoopScoreboard(
+                this.gameWorld.getWorld().getScoreboard(),
+                this.config.loops
+        );
+        this.scoreboard.render(this.topPlayers);
     }
 
     private void onClose() {
         this.gameWorld.getWorld().getScoreboard().removeTeam(this.team);
         this.timerBar.close();
+        this.scoreboard.close();
     }
 
     private void addPlayer(ServerPlayerEntity player) {
@@ -247,47 +248,65 @@ private void tickPlayers(long time) {
 
             LoopDeLoopHoop hoop = this.map.hoops.get(nextHoop);
 
-            int lastHoopZ;
-            int lastHoopX;
+            double lastHoopZ;
+            double lastHoopX;
+            int lastHoopRadius;
             if (state.lastHoop == -1) {
                 lastHoopZ = -5;
                 lastHoopX = 0;
+                lastHoopRadius = 10;
             } else {
-                BlockPos last = this.map.hoops.get(state.lastHoop).centre;
-                lastHoopZ = last.getZ();
-                lastHoopX = last.getX();
+                LoopDeLoopHoop last = this.map.hoops.get(state.lastHoop);
+                lastHoopZ = Vec3d.ofCenter(last.centre).getZ();
+                lastHoopX = Vec3d.ofCenter(last.centre).getX();
+                lastHoopRadius = last.radius;
             }
 
             BlockPos centre = hoop.centre;
 
-            double yMax = ((double) this.config.maxYVariation / 2) + 30;
+            double yMax = ((double) this.config.yVarMax / 2) + 30;
             boolean outOfBounds = Math.floor(player.getZ()) > centre.getZ() ||
                     player.getZ() < lastHoopZ - 10 ||
-                    player.getY() < 75 - yMax ||
-                    player.getY() > 75 + yMax ||
+                    player.getY() < 128 - yMax ||
+                    player.getY() > 128 + yMax ||
                     player.getY() < 0 ||
-                    player.getX() > Math.max(centre.getX(), lastHoopX) + 30 ||
-                    player.getX() < Math.min(centre.getX(), lastHoopX) - 30;
+                    player.getX() > Math.max(centre.getX() + hoop.radius, lastHoopX + lastHoopRadius) + 30 ||
+                    player.getX() < Math.min(centre.getX() + hoop.radius, lastHoopX + lastHoopRadius) - 30;
 
             if (hoop.intersectsSegment(state.lastPos, player.getPos())) {
                 player.playSound(SoundEvents.ENTITY_EXPERIENCE_ORB_PICKUP, SoundCategory.PLAYERS, 1.0F, 1.0F);
                 giveRocket(player, 1);
                 state.lastHoop += 1;
+                state.previousFails = 0;
+                state.lastFailOrSuccess = time;
+
+                if (this.topPlayers.stream().noneMatch(i -> i.getLeft().getUuid() == player.getUuid())) {
+                    this.topPlayers.add(new Pair<>(player, state));
+                }
+
+                this.topPlayers.sort(Comparator.comparing(i -> i.getRight().lastHoop));
+
+                if (this.topPlayers.size() > 5) {
+                    this.topPlayers.remove(5);
+                }
+
+                this.scoreboard.render(this.topPlayers);
             } else if (outOfBounds) {
-               this.failHoop(player, state, time);
+                this.failHoop(player, state, time);
             }
 
             state.lastPos = player.getPos();
         }
     }
 
     private void failHoop(ServerPlayerEntity player, LoopDeLoopPlayer state, long time) {
-        if (time - state.lastFailTp < 20) {
+        if (time - state.lastFailOrSuccess < 10) {
             return;
         }
 
-        state.lastFailTp = time;
-        giveRocket(player, 1);
+        state.previousFails += 1;
+        state.lastFailOrSuccess = time;
+        giveRocket(player, Math.min(state.previousFails, 3));
 
         ServerWorld world = this.gameWorld.getWorld();
         List<FireworkRocketEntity> rockets = world.getEntitiesByType(
@@ -321,7 +340,7 @@ private void broadcastWin() {
             StringBuilder message_builder = new StringBuilder();
             message_builder.append("The game has ended!\n");
 
-            for (int i = 0; i < 3 && i < this.finished.size(); i++) {
+            for (int i = 0; i < 5 && i < this.finished.size(); i++) {
                 LoopDeLoopWinner player = this.finished.get(i);
                 message_builder.append(String.format(
                         "    %s place - %s in %.2fs\n",
@@ -345,10 +364,10 @@ private boolean onPlayerDamage(ServerPlayerEntity player, DamageSource source, f
         return true;
     }
 
-    private boolean onPlayerDeath(ServerPlayerEntity player, DamageSource source) {
+    private ActionResult onPlayerDeath(ServerPlayerEntity player, DamageSource source) {
         long time = this.gameWorld.getWorld().getTime();
         this.failHoop(player, this.player_states.get(player), time);
-        return true;
+        return ActionResult.FAIL;
     }
 
     private void spawnParticipant(ServerPlayerEntity player) {
@@ -382,7 +401,7 @@ private void broadcastMessage(Text message) {
 
     private void broadcastTitle(Text message) {
         for (ServerPlayerEntity player : this.gameWorld.getPlayers()) {
-            TitleS2CPacket packet = new TitleS2CPacket(TitleS2CPacket.Action.TITLE, message, 1, 5,  3);
+            TitleS2CPacket packet = new TitleS2CPacket(TitleS2CPacket.Action.TITLE, message, 1, 5, 3);
             player.networkHandler.sendPacket(packet);
         }
     }

src/main/java/io/github/restioson/loopdeloop/game/LoopDeLoopConfig.java

@@ -6,24 +6,59 @@
 
 public final class LoopDeLoopConfig {
     public static final Codec<LoopDeLoopConfig> CODEC = RecordCodecBuilder.create(instance -> instance.group(
-            PlayerConfig.CODEC.fieldOf("players").forGetter(config -> config.players),
+            PlayerConfig.CODEC.fieldOf("players").orElse(new PlayerConfig(1, 100)).forGetter(config -> config.players),
             Codec.INT.fieldOf("time_limit_secs").forGetter(config -> config.timeLimit),
             Codec.INT.fieldOf("loops").forGetter(config -> config.loops),
+            Codec.INT.fieldOf("loop_radius").orElse(5).forGetter(config -> config.loopRadius),
             Codec.INT.fieldOf("start_rockets").forGetter(config -> config.startRockets),
-            Codec.INT.fieldOf("max_y_variation").forGetter(config -> config.maxYVariation)
+            Codec.INT.fieldOf("y_var_max").forGetter(config -> config.yVarMax),
+            ZVariation.CODEC.fieldOf("z_var_max").forGetter(config -> config.zVarMax),
+            ZVariation.CODEC.fieldOf("z_var_min").forGetter(config -> config.zVarMin)
     ).apply(instance, LoopDeLoopConfig::new));
 
     public final PlayerConfig players;
     public final int timeLimit;
     public final int loops;
+    public final int loopRadius;
     public final int startRockets;
-    public final int maxYVariation;
+    public final int yVarMax;
+    public final ZVariation zVarMax;
+    public final ZVariation zVarMin;
 
-    public LoopDeLoopConfig(PlayerConfig players, int timeLimit, int loops, int startRockets, int maxYVariation) {
+    public LoopDeLoopConfig(
+            PlayerConfig players,
+            int timeLimit,
+            int loops,
+            int loopRadius,
+            int startRockets,
+            int yVarMax,
+            ZVariation zVarMax,
+            ZVariation zVarMin
+    ) {
         this.players = players;
         this.timeLimit = timeLimit;
         this.loops = loops;
+        this.loopRadius = loopRadius;
         this.startRockets = startRockets;
-        this.maxYVariation = maxYVariation;
+        this.yVarMax = yVarMax;
+        this.zVarMax = zVarMax;
+        this.zVarMin = zVarMin;
+
+        System.out.println(String.format("HERE loops: %s; radius: %s", loops, loopRadius));
+    }
+
+    public static class ZVariation {
+        public static final Codec<ZVariation> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                Codec.INT.fieldOf("start").forGetter(config -> config.start),
+                Codec.INT.fieldOf("end").forGetter(config -> config.end)
+        ).apply(instance, ZVariation::new));
+
+        public final int start;
+        public final int end;
+
+        public ZVariation(int start, int end) {
+            this.start = start;
+            this.end = end;
+        }
     }
 }

src/main/java/io/github/restioson/loopdeloop/game/LoopDeLoopPlayer.java

@@ -5,5 +5,6 @@
 public class LoopDeLoopPlayer {
     public int lastHoop = -1;
     public Vec3d lastPos;
-    public long lastFailTp = -1;
+    public long lastFailOrSuccess = -1;
+    public int previousFails = -1;
 }

src/main/java/io/github/restioson/loopdeloop/game/LoopDeLoopScoreboard.java

@@ -0,0 +1,82 @@
+package io.github.restioson.loopdeloop.game;
+
+
+import net.minecraft.scoreboard.ScoreboardCriterion;
+import net.minecraft.scoreboard.ScoreboardObjective;
+import net.minecraft.scoreboard.ScoreboardPlayerScore;
+import net.minecraft.scoreboard.ServerScoreboard;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.LiteralText;
+import net.minecraft.util.Formatting;
+import net.minecraft.util.Pair;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+public class LoopDeLoopScoreboard {
+
+    ServerScoreboard scoreboard;
+    ScoreboardObjective hoops;
+    int totalHoops;
+
+    public LoopDeLoopScoreboard(ServerScoreboard scoreboard, int totalHoops) {
+        ScoreboardObjective scoreboardObjective = new ScoreboardObjective(
+                scoreboard,
+                "loopdeloop_hoops",
+                ScoreboardCriterion.DUMMY,
+                new LiteralText("Loop-de-loop").formatted(Formatting.BLUE, Formatting.BOLD),
+                ScoreboardCriterion.RenderType.INTEGER
+        );
+        scoreboard.addScoreboardObjective(scoreboardObjective);
+        scoreboard.setObjectiveSlot(1, scoreboardObjective);
+        this.hoops = scoreboardObjective;
+        this.scoreboard = scoreboard;
+        this.totalHoops = totalHoops;
+    }
+
+    public void render(List<Pair<ServerPlayerEntity, LoopDeLoopPlayer>> topPlayers) {
+        String top = String.format(
+                "%sTotal hoops:%s %s",
+                Formatting.AQUA + Formatting.BOLD.toString(),
+                Formatting.RESET,
+                this.totalHoops
+        );
+
+        List<String> lines = new ArrayList<>();
+        lines.add(top);
+
+        for (Pair<ServerPlayerEntity, LoopDeLoopPlayer> pair : topPlayers) {
+            String line = String.format(
+                    "%s%s:%s %d hoops",
+                    Formatting.AQUA,
+                    pair.getLeft().getEntityName(),
+                    Formatting.RESET,
+                    pair.getRight().lastHoop + 1
+            );
+            lines.add(line);
+        }
+
+        this.renderObjective(this.hoops, lines);
+    }
+
+    private void renderObjective(ScoreboardObjective objective, List<String> lines) {
+        System.out.println(lines);
+        this.clear(objective);
+        for (int i = 0; i < lines.size(); i++) {
+            String line = lines.get(i);
+            scoreboard.getPlayerScore(line, objective).setScore(lines.size() - i);
+        }
+    }
+
+    private void clear(ScoreboardObjective objective) {
+        Collection<ScoreboardPlayerScore> existing = this.scoreboard.getAllPlayerScores(objective);
+        for (ScoreboardPlayerScore score : existing) {
+            this.scoreboard.resetPlayerScore(score.getPlayerName(), objective);
+        }
+    }
+
+    public void close() {
+        scoreboard.removeObjective(this.hoops);
+    }
+}

src/main/java/io/github/restioson/loopdeloop/game/LoopDeLoopSpawnLogic.java

@@ -2,14 +2,14 @@
 
 import io.github.restioson.loopdeloop.LoopDeLoop;
 import io.github.restioson.loopdeloop.game.map.LoopDeLoopMap;
-import xyz.nucleoid.plasmid.game.GameWorld;
 import net.minecraft.entity.effect.StatusEffectInstance;
 import net.minecraft.entity.effect.StatusEffects;
 import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.world.GameMode;
+import xyz.nucleoid.plasmid.game.GameWorld;
 
 public final class LoopDeLoopSpawnLogic {
     private final GameWorld gameWorld;