feat: TU19 (Dec 2014) Features & Content (#155)

* try to resolve merge conflict

* feat: TU19 (Dec 2014) Features & Content (#32)

* December 2014 files

* Working release build

* Fix compilation issues

* Add sound to Windows64Media

* Add DLC content and force Tutorial DLC

* Revert "Add DLC content and force Tutorial DLC"

This reverts commit 97a43994725008e35fceb984d5549df9c8cea470.

* Disable broken light packing

* Disable breakpoint during DLC texture map load

Allows DLC loading but the DLC textures are still broken

* Fix post build not working

* ...

* fix vs2022 build

* fix cmake build

---------

Co-authored-by: Loki <lokirautio@gmail.com>

1 files changed, 247 insertions, 0 deletions

diff --git a/Minecraft.World/PlayerSelector.h b/Minecraft.World/PlayerSelector.h
new file mode 100644
index 00000000..7c63d667
--- /dev/null
+++ b/Minecraft.World/PlayerSelector.h
@@ -0,0 +1,247 @@
+/*
+package net.minecraft.commands;
+
+import net.minecraft.Pos;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelSettings;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class PlayerSelector {
+    private static final Pattern PATTERN_TARGETS = Pattern.compile("^@([parf])(?:\\[([\\w=,!-]*)\\])?$");
+    private static final Pattern PATTERN_SHORT_ARGUMENT = Pattern.compile("\\G([-!]?[\\w-]*)(?:$|,)");
+    private static final Pattern PATTERN_LONG_ARGUMENT = Pattern.compile("\\G(\\w+)=([-!]?[\\w-]*)(?:$|,)");
+
+    private static final int TARGETS_GROUP_TYPE = 1;
+    private static final int TARGETS_GROUP_ARGS = 2; // Null if not specified
+
+    private static final String TARGET_NEAREST = "p";
+    private static final String TARGET_ALL = "a";
+    private static final String TARGET_RANDOM = "r";
+
+    private static final String ARGUMENT_RANGE_MAX = "r";
+    private static final String ARGUMENT_RANGE_MIN = "rm";
+    private static final String ARGUMENT_LEVEL_MAX = "l";
+    private static final String ARGUMENT_LEVEL_MIN = "lm";
+    private static final String ARGUMENT_COORDINATE_X = "x";
+    private static final String ARGUMENT_COORDINATE_Y = "y";
+    private static final String ARGUMENT_COORDINATE_Z = "z";
+    private static final String ARGUMENT_COUNT = "c";
+    private static final String ARGUMENT_MODE = "m";
+    private static final String ARGUMENT_SCORE_PREFIX = "score_";
+    private static final String ARGUMENT_TEAM_NAME = "team";
+    private static final String ARGUMENT_PLAYER_NAME = "name";
+
+    public static ServerPlayer getPlayer(CommandSender source, String input) {
+        ServerPlayer[] result = getPlayers(source, input);
+
+        if (result == null || result.length != 1) return null;
+
+        return result[0];
+    }
+
+    public static String getPlayerNames(CommandSender source, String input) {
+        ServerPlayer[] result = getPlayers(source, input);
+        if (result == null || result.length == 0) return null;
+        String[] names = new String[result.length];
+
+        for (int i = 0; i < names.length; i++) {
+            names[i] = result[i].getDisplayName();
+        }
+
+        return BaseCommand.joinStrings(names);
+    }
+
+    public static ServerPlayer[] getPlayers(CommandSender source, String input) {
+        Matcher matcher = PATTERN_TARGETS.matcher(input);
+
+        if (matcher.matches()) {
+            Map<String, String> args = getArguments(matcher.group(TARGETS_GROUP_ARGS));
+            String type = matcher.group(TARGETS_GROUP_TYPE);
+            int rangeMin = getDefaultRangeMin(type);
+            int rangeMax = getDefaultRangeMax(type);
+            int levelMin = getDefaultLevelMin(type);
+            int levelMax = getDefaultLevelMax(type);
+            int count = getDefaultCount(type);
+            int mode = LevelSettings.GameType.NOT_SET.getId();
+            Pos pos = source.getCommandSenderWorldPosition();
+            Map<String, Integer> scores = getScores(args);
+            String name = null;
+            String team = null;
+            boolean requireLevel = false;
+
+            if (args.containsKey(ARGUMENT_RANGE_MIN)) {
+                rangeMin = Mth.getInt(args.get(ARGUMENT_RANGE_MIN), rangeMin);
+                requireLevel = true;
+            }
+            if (args.containsKey(ARGUMENT_RANGE_MAX)) {
+                rangeMax = Mth.getInt(args.get(ARGUMENT_RANGE_MAX), rangeMax);
+                requireLevel = true;
+            }
+            if (args.containsKey(ARGUMENT_LEVEL_MIN)) {
+                levelMin = Mth.getInt(args.get(ARGUMENT_LEVEL_MIN), levelMin);
+            }
+            if (args.containsKey(ARGUMENT_LEVEL_MAX)) {
+                levelMax = Mth.getInt(args.get(ARGUMENT_LEVEL_MAX), levelMax);
+            }
+            if (args.containsKey(ARGUMENT_COORDINATE_X)) {
+                pos.x = Mth.getInt(args.get(ARGUMENT_COORDINATE_X), pos.x);
+                requireLevel = true;
+            }
+            if (args.containsKey(ARGUMENT_COORDINATE_Y)) {
+                pos.y = Mth.getInt(args.get(ARGUMENT_COORDINATE_Y), pos.y);
+                requireLevel = true;
+            }
+            if (args.containsKey(ARGUMENT_COORDINATE_Z)) {
+                pos.z = Mth.getInt(args.get(ARGUMENT_COORDINATE_Z), pos.z);
+                requireLevel = true;
+            }
+            if (args.containsKey(ARGUMENT_MODE)) {
+                mode = Mth.getInt(args.get(ARGUMENT_MODE), mode);
+            }
+            if (args.containsKey(ARGUMENT_COUNT)) {
+                count = Mth.getInt(args.get(ARGUMENT_COUNT), count);
+            }
+            if (args.containsKey(ARGUMENT_TEAM_NAME)) {
+                team = args.get(ARGUMENT_TEAM_NAME);
+            }
+            if (args.containsKey(ARGUMENT_PLAYER_NAME)) {
+                name = args.get(ARGUMENT_PLAYER_NAME);
+            }
+
+            Level level = requireLevel ? source.getCommandSenderWorld() : null;
+
+            if (type.equals(TARGET_NEAREST) || type.equals(TARGET_ALL)) {
+                List<ServerPlayer> players = MinecraftServer.getInstance().getPlayers().getPlayers(pos, rangeMin, rangeMax, count, mode, levelMin, levelMax, scores, name, team, level);
+                return players == null || players.isEmpty() ? new ServerPlayer[0] : players.toArray(new ServerPlayer[0]);
+            } else if (type.equals(TARGET_RANDOM)) {
+                List<ServerPlayer> players = MinecraftServer.getInstance().getPlayers().getPlayers(pos, rangeMin, rangeMax, 0, mode, levelMin, levelMax, scores, name, team, level);
+                Collections.shuffle(players);
+                players = players.subList(0, Math.min(count, players.size()));
+                return players == null || players.isEmpty() ? new ServerPlayer[0] : players.toArray(new ServerPlayer[0]);
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    public static Map<String, Integer> getScores(Map<String, String> input) {
+        Map<String, Integer> result = new HashMap<String, Integer>();
+
+        for (String key : input.keySet()) {
+            if (key.startsWith(ARGUMENT_SCORE_PREFIX) && key.length() > ARGUMENT_SCORE_PREFIX.length()) {
+                String name = key.substring(ARGUMENT_SCORE_PREFIX.length());
+                result.put(name, Mth.getInt(input.get(key), 1));
+            }
+        }
+
+        return result;
+    }
+
+    public static boolean isList(String input) {
+        Matcher matcher = PATTERN_TARGETS.matcher(input);
+
+        if (matcher.matches()) {
+            Map<String, String> args = getArguments(matcher.group(TARGETS_GROUP_ARGS));
+            String type = matcher.group(TARGETS_GROUP_TYPE);
+            int count = getDefaultCount(type);
+            if (args.containsKey(ARGUMENT_COUNT)) count = Mth.getInt(args.get(ARGUMENT_COUNT), count);
+            return count != 1;
+        }
+
+        return false;
+    }
+
+    public static boolean isPattern(String input, String onlyType) {
+        Matcher matcher = PATTERN_TARGETS.matcher(input);
+
+        if (matcher.matches()) {
+            String type = matcher.group(TARGETS_GROUP_TYPE);
+            if (onlyType != null && !onlyType.equals(type)) return false;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public static boolean isPattern(String input) {
+        return isPattern(input, null);
+    }
+
+    private static final int getDefaultRangeMin(String type) {
+        return 0;
+    }
+
+    private static final int getDefaultRangeMax(String type) {
+        return 0;
+    }
+
+    private static final int getDefaultLevelMax(String type) {
+        return Integer.MAX_VALUE;
+    }
+
+    private static final int getDefaultLevelMin(String type) {
+        return 0;
+    }
+
+    private static final int getDefaultCount(String type) {
+        if (type.equals(TARGET_ALL)) {
+            return 0;
+        } else {
+            return 1;
+        }
+    }
+
+    private static Map<String, String> getArguments(String input) {
+        HashMap<String, String> result = new HashMap<String, String>();
+        if (input == null) return result;
+        Matcher matcher = PATTERN_SHORT_ARGUMENT.matcher(input);
+        int count = 0;
+        int last = -1;
+
+        while (matcher.find()) {
+            String name = null;
+
+            switch (count++) {
+                case 0:
+                    name = ARGUMENT_COORDINATE_X;
+                    break;
+                case 1:
+                    name = ARGUMENT_COORDINATE_Y;
+                    break;
+                case 2:
+                    name = ARGUMENT_COORDINATE_Z;
+                    break;
+                case 3:
+                    name = ARGUMENT_RANGE_MAX;
+                    break;
+            }
+
+            if (name != null && matcher.group(1).length() > 0) result.put(name, matcher.group(1));
+            last = matcher.end();
+        }
+
+        if (last < input.length()) {
+            matcher = PATTERN_LONG_ARGUMENT.matcher(last == -1 ? input : input.substring(last));
+
+            while (matcher.find()) {
+                result.put(matcher.group(1), matcher.group(2));
+            }
+        }
+
+        return result;
+    }
+}
+
+*/
\ No newline at end of file