Initial commit

src/main/java/eu/mhsl/minenet/minigames/instance/room/Room.java

@@ -0,0 +1,123 @@
+package eu.mhsl.minenet.minigames.instance.room;
+
+import eu.mhsl.minenet.minigames.Resource;
+import eu.mhsl.minenet.minigames.instance.game.Game;
+import eu.mhsl.minenet.minigames.message.Icon;
+import eu.mhsl.minenet.minigames.message.type.ChatMessage;
+import eu.mhsl.minenet.minigames.util.CommonEventHandles;
+import eu.mhsl.minenet.minigames.util.MoveInstance;
+import eu.mhsl.minenet.minigames.instance.Spawnable;
+import eu.mhsl.minenet.minigames.instance.Dimension;
+import eu.mhsl.minenet.minigames.instance.hub.HubInstance;
+import eu.mhsl.minenet.minigames.instance.room.entity.GameSelector;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.player.PlayerBlockBreakEvent;
+import net.minestom.server.event.player.PlayerDisconnectEvent;
+import net.minestom.server.instance.AnvilLoader;
+import net.minestom.server.instance.InstanceContainer;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class Room extends InstanceContainer implements Spawnable {
+    private static final Map<Player, Room> rooms = new WeakHashMap<>();
+
+    public static Room createRoom(Player owner) {
+        System.out.println("Room created by " + owner.getUsername());
+        setRoom(owner, new Room(owner));
+        return getRoom(owner);
+    }
+
+    public static void deleteRoom(Room room) {
+        System.out.println("Room deleted");
+        rooms.values().removeAll(Collections.singleton(room)); // remove(room) would only remove the first one
+        room.getAllMembers().forEach(player -> MoveInstance.move(player, HubInstance.INSTANCE));
+        MoveInstance.forceCloseInstance(room);
+    }
+
+    public static Room getRoom(Player p) {
+        return rooms.get(p);
+    }
+
+    public static void setOwnRoom(Player p) {
+        setRoom(p, getRoom(p));
+    }
+
+    public static void setRoom(Player p, Room room) {
+        p.clearEffects();
+        p.clearTitle();
+        p.getInventory().clear();
+        rooms.put(p, room);
+        MoveInstance.move(p, room);
+    }
+
+    public static void unsetRoom(Player p) {
+        rooms.remove(p);
+    }
+
+    public static Set<Room> getAllRooms() {
+        return new HashSet<>(rooms.values());
+    }
+
+    private Player owner;
+    private Room(Player owner) {
+        super(UUID.randomUUID(), Dimension.THE_END.DIMENSION);
+        MinecraftServer.getInstanceManager().registerInstance(this);
+        setChunkLoader(new AnvilLoader(Resource.LOBBY_MAP.getPath()));
+
+        eventNode().addListener(PlayerBlockBreakEvent.class, CommonEventHandles::cancel);
+
+        setOwner(owner);
+
+        new GameSelector().setInstance(this, new Pos(0.5, 16, 9.5));
+    }
+
+    public Player getOwner() {
+        return owner;
+    }
+
+    private void setOwner(Player newOwner) {
+        this.owner = newOwner;
+
+        this.owner.eventNode().addListener(PlayerDisconnectEvent.class, playerDisconnectEvent -> {
+            System.out.println("Room Leader left room");
+            Player p = playerDisconnectEvent.getPlayer();
+
+            if(p != this.owner) return; // return if the current handling player is really the current owner
+
+            getAllMembers().stream()
+                    .filter(player -> player != p) // exclude the current leaving owner
+                    .findFirst() // find first user meeting the requirement
+                    .ifPresentOrElse(
+                            this::setOwner, // set the new owner
+                            () -> Room.deleteRoom(Room.getRoom(p)) // or else delete the room (no players in the room)
+                    );
+
+            Room.unsetRoom(p); // remove the player itself from the room
+
+            new ChatMessage(Icon.ERROR).appendStatic("The room leader left!").send(getAllMembers());
+            new ChatMessage(Icon.SCIENCE).appendStatic(this.owner.getUsername()).appendStatic(" is the new Leader!").send(getAllMembers().stream().filter(player -> player != this.owner).collect(Collectors.toSet()));
+            new ChatMessage(Icon.SUCCESS).appendStatic("You are now the leader.").send(this.owner);
+        });
+
+    }
+
+    public void moveMembersToGame(Game game) {
+        this.getAllMembers().forEach(player -> {
+            MoveInstance.move(player, game);
+        });
+    }
+
+    public Set<Player> getAllMembers() {
+        return rooms.keySet().stream()
+                .filter(player -> getRoom(player) == this)
+                .collect(Collectors.toSet());
+    }
+
+    @Override
+    public Pos getSpawn() {
+        return new Pos(0.5, 16, 0.5);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/room/entity/GameSelector.java

@@ -0,0 +1,49 @@
+package eu.mhsl.minenet.minigames.instance.room.entity;
+
+import eu.mhsl.minenet.minigames.instance.room.Room;
+import eu.mhsl.minenet.minigames.instance.room.inventory.MinigameTypeSelectInventory;
+import eu.mhsl.minenet.minigames.message.Icon;
+import eu.mhsl.minenet.minigames.message.type.ChatMessage;
+import eu.mhsl.minenet.minigames.shared.entity.InteractableEntity;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.entity.metadata.villager.AbstractVillagerMeta;
+import net.minestom.server.event.entity.EntityAttackEvent;
+import net.minestom.server.event.instance.AddEntityToInstanceEvent;
+import net.minestom.server.event.player.PlayerEntityInteractEvent;
+import org.jetbrains.annotations.NotNull;
+
+public class GameSelector extends InteractableEntity {
+    final AbstractVillagerMeta abstractVillagerMeta;
+    public GameSelector() {
+        super(EntityType.VILLAGER);
+
+        abstractVillagerMeta = (AbstractVillagerMeta) this.getEntityMeta();
+    }
+
+    @Override
+    public void onSpawn(@NotNull AddEntityToInstanceEvent addEntityToInstanceEvent) {
+
+    }
+
+    @Override
+    public void onAttack(@NotNull EntityAttackEvent entityAttackEvent) {
+        super.onAttack(entityAttackEvent);
+    }
+
+    @Override
+    public void onInteract(@NotNull PlayerEntityInteractEvent playerEntityInteractEvent) {
+        Room room = (Room) instance;
+
+        if(playerEntityInteractEvent.getPlayer() != room.getOwner()) {
+            abstractVillagerMeta.setHeadShakeTimer(20);
+
+            new ChatMessage(Icon.ERROR).appendStatic("Only the room leader can start games!").indent(1).newLine()
+                    .appendStatic("current leader: ").appendStatic(room.getOwner().getUsername())
+                    .send(playerEntityInteractEvent.getPlayer());
+
+            return;
+        }
+
+        playerEntityInteractEvent.getPlayer().openInventory(new MinigameTypeSelectInventory());
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/room/inventory/BoardInventory.java

@@ -0,0 +1,11 @@
+package eu.mhsl.minenet.minigames.instance.room.inventory;
+
+import eu.mhsl.minenet.minigames.shared.inventory.InteractableInventory;
+import net.kyori.adventure.text.Component;
+import net.minestom.server.inventory.InventoryType;
+
+public class BoardInventory extends InteractableInventory {
+    public BoardInventory() {
+        super(InventoryType.CHEST_3_ROW, Component.text("Brettspiele"));
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/room/inventory/MinigameTypeSelectInventory.java

@@ -0,0 +1,64 @@
+package eu.mhsl.minenet.minigames.instance.room.inventory;
+
+import eu.mhsl.minenet.minigames.instance.game.minigame.MinigameType;
+import eu.mhsl.minenet.minigames.instance.game.minigame.config.GameConfigurationInventory;
+import eu.mhsl.minenet.minigames.instance.game.minigame.config.GameFactory;
+import eu.mhsl.minenet.minigames.shared.inventory.InteractableInventory;
+import net.kyori.adventure.text.Component;
+import net.minestom.server.inventory.InventoryType;
+import net.minestom.server.item.ItemHideFlag;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+
+public class MinigameTypeSelectInventory extends InteractableInventory {
+    public MinigameTypeSelectInventory() {
+        super(InventoryType.CHEST_3_ROW, Component.text("MineNet Servernetzwerk"));
+
+        int i = 0;
+        for (MinigameType minigameType : MinigameType.values()) {
+            GameFactory gameFactory = minigameType.getFactory();
+
+            setClickableItem(
+                    ItemStack.builder(gameFactory.symbol())
+                            .displayName(gameFactory.name())
+                            .lore(gameFactory.description())
+                            .meta(metaBuilder -> metaBuilder.hideFlag(ItemHideFlag.HIDE_ATTRIBUTES))
+                            .build(),
+                    i,
+                    itemClick -> itemClick.getPlayer().openInventory(new GameConfigurationInventory(gameFactory))
+            );
+            i++;
+        }
+
+//        setClickableItem(
+//                ItemStack
+//                        .builder(Material.IRON_SWORD)
+//                        .displayName(Component.text("PVP Spiele"))
+//                        .lore(Component.text("Player versus Player"))
+//                        .meta(metaBuilder -> metaBuilder.hideFlag(ItemHideFlag.HIDE_ATTRIBUTES))
+//                        .build(),
+//                11,
+//                itemClick -> itemClick.getPlayer().openInventory(new PvpInventory())
+//        );
+//
+//        setClickableItem(
+//                ItemStack
+//                        .builder(Material.ZOMBIE_HEAD)
+//                        .displayName(Component.text("PVE Arenen"))
+//                        .lore(Component.text("Player versus Entity"))
+//                        .build(),
+//                13,
+//                itemClick -> itemClick.getPlayer().openInventory(new PveInventory())
+//        );
+//
+//        setClickableItem(
+//                ItemStack
+//                        .builder(Material.BRICK_SLAB)
+//                        .displayName(Component.text("Brettspiele"))
+//                        .lore(Component.text("Bekannte Brettspieler aller Art"))
+//                        .build(),
+//                15,
+//                itemClick -> itemClick.getPlayer().openInventory(new BoardInventory())
+//        );
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/room/inventory/PveInventory.java

@@ -0,0 +1,41 @@
+package eu.mhsl.minenet.minigames.instance.room.inventory;
+
+import eu.mhsl.minenet.minigames.instance.game.minigame.config.GameConfigurationInventory;
+import eu.mhsl.minenet.minigames.instance.game.minigame.types.minerun.MinerunFactory;
+import eu.mhsl.minenet.minigames.shared.inventory.InteractableInventory;
+import eu.mhsl.minenet.minigames.instance.game.minigame.types.deathcube.DeathcubeFactory;
+import eu.mhsl.minenet.minigames.instance.game.minigame.types.trafficlightrace.TrafficLightRaceFactory;
+import net.kyori.adventure.text.Component;
+import net.minestom.server.inventory.InventoryType;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+
+public class PveInventory extends InteractableInventory {
+    public PveInventory() {
+        super(InventoryType.CHEST_3_ROW, Component.text("PVE"));
+
+        setClickableItem(
+                ItemStack.builder(Material.LIGHT_WEIGHTED_PRESSURE_PLATE).displayName(Component.text("Minerun")).lore(Component.text("Jump between ground mines to the finish")).build(),
+                0,
+                itemClick -> {
+                    itemClick.getPlayer().openInventory(new GameConfigurationInventory(new MinerunFactory()));
+                }
+        );
+
+        setClickableItem(
+                ItemStack.builder(Material.YELLOW_WOOL).displayName(Component.text("Ampelrennen")).build(),
+                1,
+                itemClick -> {
+                    itemClick.getPlayer().openInventory(new GameConfigurationInventory(new TrafficLightRaceFactory()));
+                }
+        );
+
+        setClickableItem(
+                ItemStack.builder(Material.RED_WOOL).displayName(Component.text("Deathcube")).build(),
+                2,
+                itemClick -> {
+                    itemClick.getPlayer().openInventory(new GameConfigurationInventory(new DeathcubeFactory()));
+                }
+        );
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/room/inventory/PvpInventory.java

@@ -0,0 +1,27 @@
+package eu.mhsl.minenet.minigames.instance.room.inventory;
+
+import eu.mhsl.minenet.minigames.instance.game.minigame.config.GameConfigurationInventory;
+import eu.mhsl.minenet.minigames.instance.game.minigame.types.stickfight.StickFightFactory;
+import eu.mhsl.minenet.minigames.shared.inventory.InteractableInventory;
+import net.kyori.adventure.text.Component;
+import net.minestom.server.entity.Player;
+import net.minestom.server.inventory.InventoryType;
+import net.minestom.server.inventory.click.ClickType;
+import net.minestom.server.inventory.condition.InventoryConditionResult;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+
+public class PvpInventory extends InteractableInventory {
+    public PvpInventory() {
+        super(InventoryType.CHEST_6_ROW, Component.text("PVP"));
+
+        setClickableItem(ItemStack.of(Material.GOLD_INGOT), 4, itemClick -> {
+            itemClick.getPlayer().openInventory(new GameConfigurationInventory(new StickFightFactory()));
+        });
+    }
+
+    @Override
+    protected void onClick(Player player, int slot, ClickType clickType, InventoryConditionResult inventoryConditionResult) {
+        super.onClick(player, slot, clickType, inventoryConditionResult);
+    }
+}