Big refactor: Rename "Map" to "Arena" for clarity.

- Minor updates to Quake match state logic.

src/main/java/com/bytemaniak/mcquake3/blocks/weapon/WeaponPickup.java

@@ -27,7 +27,7 @@ public void onEntityCollision(BlockState state, World world, BlockPos pos, Entit
             PickupEntity weaponPickup = (PickupEntity) world.getBlockEntity(pos);
             if (entity instanceof ServerPlayerEntity player && weaponPickup.use()) {
                 if (!player.getInventory().containsAny(t -> t.isOf(weapon))) {
-                    if (((QuakePlayer) player).playingQuakeMap()) {
+                    if (((QuakePlayer) player).inQuakeArena()) {
                         player.getInventory().insertStack(weapon.slot, new ItemStack(weapon));
 
                         PacketByteBuf buf = PacketByteBufs.create();

src/main/java/com/bytemaniak/mcquake3/data/QuakeArenasParameters.java

@@ -0,0 +1,138 @@
+package com.bytemaniak.mcquake3.data;
+
+import com.bytemaniak.mcquake3.MCQuake3;
+import com.bytemaniak.mcquake3.registry.Blocks;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtElement;
+import net.minecraft.nbt.NbtList;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.PersistentState;
+import net.minecraft.world.PersistentStateManager;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ThreadLocalRandom;
+
+public class QuakeArenasParameters extends PersistentState {
+    public static class ArenaData {
+        public static class Spawnpoint {
+            public Vec3d position;
+            public float yaw;
+
+            public Spawnpoint(Vec3d position, float yaw) {
+                this.position = position;
+                this.yaw = yaw;
+            }
+        }
+
+        public String arenaName;
+        public List<Spawnpoint> spawnpoints = new ArrayList<>();
+    }
+
+    public List<ArenaData> arenas = new ArrayList<>();
+    public int activeArena = 0;
+
+    @Override
+    public NbtCompound writeNbt(NbtCompound nbt) {
+        NbtList arenasNbt = new NbtList();
+
+        for (ArenaData arena : arenas) {
+            NbtCompound arenaNbt = new NbtCompound();
+            NbtList spawnpoints = new NbtList();
+
+            arenaNbt.putString("Arena_name", arena.arenaName);
+
+            for (ArenaData.Spawnpoint i : arena.spawnpoints) {
+                NbtCompound spawnpoint = new NbtCompound();
+                spawnpoint.putDouble("x", i.position.x);
+                spawnpoint.putDouble("y", i.position.y);
+                spawnpoint.putDouble("z", i.position.z);
+                spawnpoint.putFloat("yaw", i.yaw);
+                spawnpoints.add(spawnpoint);
+            }
+            arenaNbt.put("spawnpoints", spawnpoints);
+
+            arenasNbt.add(arenaNbt);
+        }
+
+        nbt.put("q3Arenas_data", arenasNbt);
+        nbt.putInt("active_Arena", activeArena);
+        return nbt;
+    }
+
+    private static QuakeArenasParameters readNbt(NbtCompound nbt) {
+        QuakeArenasParameters state = new QuakeArenasParameters();
+
+        NbtList arenasData = nbt.getList("q3Arenas_data", NbtElement.COMPOUND_TYPE);
+        for (int i = 0; i < arenasData.size(); i++) {
+            ArenaData arenaData = new ArenaData();
+            NbtCompound arenaDataNbt = arenasData.getCompound(i);
+
+            arenaData.arenaName = arenaDataNbt.getString("Arena_name");
+
+            NbtList spawnpoints = arenaDataNbt.getList("spawnpoints", NbtElement.COMPOUND_TYPE);
+            for (int j = 0; j < spawnpoints.size(); j++) {
+                NbtCompound spawnpointNbt = spawnpoints.getCompound(j);
+                Vec3d position = new Vec3d(spawnpointNbt.getDouble("x"), spawnpointNbt.getDouble("y"), spawnpointNbt.getDouble("z"));
+                float yaw = spawnpointNbt.getFloat("yaw");
+
+                arenaData.spawnpoints.add(new ArenaData.Spawnpoint(position, yaw));
+            }
+
+            state.arenas.add(arenaData);
+        }
+
+        state.activeArena = nbt.getInt("active_Arena");
+
+        return state;
+    }
+
+    public static QuakeArenasParameters getServerState(MinecraftServer server) {
+        PersistentStateManager persistentStateManager = server.getWorld(Blocks.Q3_DIMENSION).getPersistentStateManager();
+        return persistentStateManager.getOrCreate(QuakeArenasParameters::readNbt, QuakeArenasParameters::new, "mcquake3_Arenas");
+    }
+
+    public void createInitialArenaData(String arenaName) {
+        if (getArena(arenaName) == null) {
+            ArenaData arenaData = new ArenaData();
+            arenaData.arenaName = arenaName;
+
+            arenas.add(arenaData);
+            markDirty();
+            logUpdates();
+        }
+    }
+
+    public ArenaData getArena(String arenaName) {
+        return arenas.stream().filter(e -> Objects.equals(e.arenaName, arenaName)).findFirst().orElse(null);
+    }
+
+    public ArenaData getRandomArena() {
+        if (arenas.isEmpty()) return null;
+
+        return arenas.get(ThreadLocalRandom.current().nextInt(arenas.size()));
+    }
+
+    public void addSpawnpoint(String arenaName, Vec3d spawnpoint, float yaw) {
+        ArenaData arena = getArena(arenaName);
+        arena.spawnpoints.add(new ArenaData.Spawnpoint(spawnpoint, yaw));
+        markDirty();
+        logUpdates();
+    }
+
+    public void deleteArena(String arenaName) {
+        arenas.removeIf(arena -> arena.arenaName.equals(arenaName));
+        markDirty();
+        logUpdates();
+    }
+
+    private void logUpdates() {
+        for (QuakeArenasParameters.ArenaData data : arenas) {
+            MCQuake3.LOGGER.info(data.arenaName +":");
+            for (ArenaData.Spawnpoint spawnpoint : data.spawnpoints)
+                MCQuake3.LOGGER.info("\t"+spawnpoint.position+" "+spawnpoint.yaw);
+        }
+    }
+}

src/main/java/com/bytemaniak/mcquake3/gui/MCQuake3GuiRenderer.java

@@ -40,7 +40,7 @@ public void onHudRender(MatrixStack matrixStack, float tickDelta) {
             }
         }
 
-        if (player.playingQuakeMap()) {
+        if (player.inQuakeArena()) {
             int playerHealth = (int)(plr.getHealth()*5);
             int healthColor = (playerHealth < 100) ?
                     (((int)(0xFF * (100-playerHealth)/100.f)  << 16) + ((int)(0xFF * playerHealth/100.f) << 8)) :

src/main/java/com/bytemaniak/mcquake3/items/MapTool.java → src/main/java/com/bytemaniak/mcquake3/items/ArenaTool.java

@@ -1,8 +1,8 @@
 package com.bytemaniak.mcquake3.items;
 
-import com.bytemaniak.mcquake3.data.QuakeMapsParameters;
+import com.bytemaniak.mcquake3.data.QuakeArenasParameters;
 import com.bytemaniak.mcquake3.registry.Blocks;
-import com.bytemaniak.mcquake3.screen.MapBrowserScreen;
+import com.bytemaniak.mcquake3.screen.ArenaBrowserScreen;
 import com.bytemaniak.mcquake3.util.QuakePlayer;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.item.TooltipContext;
@@ -22,24 +22,22 @@
 
 import java.util.List;
 
-public class MapTool extends Item {
-    public MapTool() {
-        super(new Settings().maxCount(1));
-    }
+public class ArenaTool extends Item {
+    public ArenaTool() { super(new Settings().maxCount(1)); }
 
     @Override
     public void appendTooltip(ItemStack stack, @Nullable World world, List<Text> tooltip, TooltipContext context) {
-        tooltip.add(Text.of("Used to describe properties of Quake3 maps such as"));
-        tooltip.add(Text.of("the name of the map, and the spawnpoints located"));
-        tooltip.add(Text.of("within this map."));
+        tooltip.add(Text.of("Used to describe properties of Quake3 arenas such as"));
+        tooltip.add(Text.of("the name of the arena, and the spawnpoints located"));
+        tooltip.add(Text.of("within this arena."));
         tooltip.add(Text.of("This tool will only function inside the Quake3 dimension."));
     }
 
     @Override
     public TypedActionResult<ItemStack> use(World world, PlayerEntity user, Hand hand) {
         ItemStack stack = user.getStackInHand(hand);
         if (world.isClient && !user.isSneaking()) {
-            MinecraftClient.getInstance().setScreen(new MapBrowserScreen(Text.of("Map browser")));
+            MinecraftClient.getInstance().setScreen(new ArenaBrowserScreen(Text.of("Arena browser")));
             return TypedActionResult.success(stack);
         }
 
@@ -48,27 +46,27 @@ public TypedActionResult<ItemStack> use(World world, PlayerEntity user, Hand han
             ServerWorld quakeDimension = player.server.getWorld(Blocks.Q3_DIMENSION);
             player.teleport(quakeDimension, 0, 64, 0, 0, 0);
             player.changeGameMode(GameMode.CREATIVE);
-            player.sendMessage(Text.of("Moved to Quake3 dimension. Have fun building maps!"), true);
+            player.sendMessage(Text.of("Moved to Quake3 dimension. Have fun building arenas!"), true);
 
             return TypedActionResult.success(stack);
         }
 
         QuakePlayer player = (QuakePlayer)user;
-        String mapName = player.getCurrentlyEditingMap();
+        String arenaName = player.getCurrentlyEditingArena();
 
         if (user.isSneaking()) {
-            if (mapName.isEmpty()) {
-                user.sendMessage(Text.of("No map chosen yet"), true);
+            if (arenaName.isEmpty()) {
+                user.sendMessage(Text.of("No arena chosen yet"), true);
                 return TypedActionResult.pass(stack);
             }
 
-            QuakeMapsParameters state = QuakeMapsParameters.getServerState(((ServerWorld) world).getServer());
-            if (state.getMap(mapName) == null) state.createInitialMapData(mapName);
+            QuakeArenasParameters state = QuakeArenasParameters.getServerState(((ServerWorld) world).getServer());
+            if (state.getArena(arenaName) == null) state.createInitialArenaData(arenaName);
 
             BlockPos spawnpoint = user.getBlockPos();
             float yaw = Direction.fromRotation(user.getYaw()).asRotation();
-            state.addSpawnpoint(mapName, spawnpoint.toCenterPos(), yaw);
-            user.sendMessage(Text.of("Added spawnpoint "+spawnpoint.toShortString()+", "+yaw+" to map "+mapName), true);
+            state.addSpawnpoint(arenaName, spawnpoint.toCenterPos(), yaw);
+            user.sendMessage(Text.of("Added spawnpoint "+spawnpoint.toShortString()+", "+yaw+" to arena "+arenaName), true);
 
             return TypedActionResult.success(stack);
         }