ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1/*
2package net.minecraft.commands;
3
4import net.minecraft.Pos;
5import net.minecraft.server.MinecraftServer;
6import net.minecraft.server.level.ServerPlayer;
7import net.minecraft.util.Mth;
8import net.minecraft.world.level.Level;
9import net.minecraft.world.level.LevelSettings;
10
11import java.util.Collections;
12import java.util.HashMap;
13import java.util.List;
14import java.util.Map;
15import java.util.regex.Matcher;
16import java.util.regex.Pattern;
17
18public class PlayerSelector {
19 private static final Pattern PATTERN_TARGETS = Pattern.compile("^@([parf])(?:\\[([\\w=,!-]*)\\])?$");
20 private static final Pattern PATTERN_SHORT_ARGUMENT = Pattern.compile("\\G([-!]?[\\w-]*)(?:$|,)");
21 private static final Pattern PATTERN_LONG_ARGUMENT = Pattern.compile("\\G(\\w+)=([-!]?[\\w-]*)(?:$|,)");
22
23 private static final int TARGETS_GROUP_TYPE = 1;
24 private static final int TARGETS_GROUP_ARGS = 2; // Null if not specified
25
26 private static final String TARGET_NEAREST = "p";
27 private static final String TARGET_ALL = "a";
28 private static final String TARGET_RANDOM = "r";
29
30 private static final String ARGUMENT_RANGE_MAX = "r";
31 private static final String ARGUMENT_RANGE_MIN = "rm";
32 private static final String ARGUMENT_LEVEL_MAX = "l";
33 private static final String ARGUMENT_LEVEL_MIN = "lm";
34 private static final String ARGUMENT_COORDINATE_X = "x";
35 private static final String ARGUMENT_COORDINATE_Y = "y";
36 private static final String ARGUMENT_COORDINATE_Z = "z";
37 private static final String ARGUMENT_COUNT = "c";
38 private static final String ARGUMENT_MODE = "m";
39 private static final String ARGUMENT_SCORE_PREFIX = "score_";
40 private static final String ARGUMENT_TEAM_NAME = "team";
41 private static final String ARGUMENT_PLAYER_NAME = "name";
42
43 public static ServerPlayer getPlayer(CommandSender source, String input) {
44 ServerPlayer[] result = getPlayers(source, input);
45
46 if (result == null || result.length != 1) return null;
47
48 return result[0];
49 }
50
51 public static String getPlayerNames(CommandSender source, String input) {
52 ServerPlayer[] result = getPlayers(source, input);
53 if (result == null || result.length == 0) return null;
54 String[] names = new String[result.length];
55
56 for (int i = 0; i < names.length; i++) {
57 names[i] = result[i].getDisplayName();
58 }
59
60 return BaseCommand.joinStrings(names);
61 }
62
63 public static ServerPlayer[] getPlayers(CommandSender source, String input) {
64 Matcher matcher = PATTERN_TARGETS.matcher(input);
65
66 if (matcher.matches()) {
67 Map<String, String> args = getArguments(matcher.group(TARGETS_GROUP_ARGS));
68 String type = matcher.group(TARGETS_GROUP_TYPE);
69 int rangeMin = getDefaultRangeMin(type);
70 int rangeMax = getDefaultRangeMax(type);
71 int levelMin = getDefaultLevelMin(type);
72 int levelMax = getDefaultLevelMax(type);
73 int count = getDefaultCount(type);
74 int mode = LevelSettings.GameType.NOT_SET.getId();
75 Pos pos = source.getCommandSenderWorldPosition();
76 Map<String, Integer> scores = getScores(args);
77 String name = null;
78 String team = null;
79 boolean requireLevel = false;
80
81 if (args.containsKey(ARGUMENT_RANGE_MIN)) {
82 rangeMin = Mth.getInt(args.get(ARGUMENT_RANGE_MIN), rangeMin);
83 requireLevel = true;
84 }
85 if (args.containsKey(ARGUMENT_RANGE_MAX)) {
86 rangeMax = Mth.getInt(args.get(ARGUMENT_RANGE_MAX), rangeMax);
87 requireLevel = true;
88 }
89 if (args.containsKey(ARGUMENT_LEVEL_MIN)) {
90 levelMin = Mth.getInt(args.get(ARGUMENT_LEVEL_MIN), levelMin);
91 }
92 if (args.containsKey(ARGUMENT_LEVEL_MAX)) {
93 levelMax = Mth.getInt(args.get(ARGUMENT_LEVEL_MAX), levelMax);
94 }
95 if (args.containsKey(ARGUMENT_COORDINATE_X)) {
96 pos.x = Mth.getInt(args.get(ARGUMENT_COORDINATE_X), pos.x);
97 requireLevel = true;
98 }
99 if (args.containsKey(ARGUMENT_COORDINATE_Y)) {
100 pos.y = Mth.getInt(args.get(ARGUMENT_COORDINATE_Y), pos.y);
101 requireLevel = true;
102 }
103 if (args.containsKey(ARGUMENT_COORDINATE_Z)) {
104 pos.z = Mth.getInt(args.get(ARGUMENT_COORDINATE_Z), pos.z);
105 requireLevel = true;
106 }
107 if (args.containsKey(ARGUMENT_MODE)) {
108 mode = Mth.getInt(args.get(ARGUMENT_MODE), mode);
109 }
110 if (args.containsKey(ARGUMENT_COUNT)) {
111 count = Mth.getInt(args.get(ARGUMENT_COUNT), count);
112 }
113 if (args.containsKey(ARGUMENT_TEAM_NAME)) {
114 team = args.get(ARGUMENT_TEAM_NAME);
115 }
116 if (args.containsKey(ARGUMENT_PLAYER_NAME)) {
117 name = args.get(ARGUMENT_PLAYER_NAME);
118 }
119
120 Level level = requireLevel ? source.getCommandSenderWorld() : null;
121
122 if (type.equals(TARGET_NEAREST) || type.equals(TARGET_ALL)) {
123 List<ServerPlayer> players = MinecraftServer.getInstance().getPlayers().getPlayers(pos, rangeMin, rangeMax, count, mode, levelMin, levelMax, scores, name, team, level);
124 return players == null || players.isEmpty() ? new ServerPlayer[0] : players.toArray(new ServerPlayer[0]);
125 } else if (type.equals(TARGET_RANDOM)) {
126 List<ServerPlayer> players = MinecraftServer.getInstance().getPlayers().getPlayers(pos, rangeMin, rangeMax, 0, mode, levelMin, levelMax, scores, name, team, level);
127 Collections.shuffle(players);
128 players = players.subList(0, Math.min(count, players.size()));
129 return players == null || players.isEmpty() ? new ServerPlayer[0] : players.toArray(new ServerPlayer[0]);
130 } else {
131 return null;
132 }
133 } else {
134 return null;
135 }
136 }
137
138 public static Map<String, Integer> getScores(Map<String, String> input) {
139 Map<String, Integer> result = new HashMap<String, Integer>();
140
141 for (String key : input.keySet()) {
142 if (key.startsWith(ARGUMENT_SCORE_PREFIX) && key.length() > ARGUMENT_SCORE_PREFIX.length()) {
143 String name = key.substring(ARGUMENT_SCORE_PREFIX.length());
144 result.put(name, Mth.getInt(input.get(key), 1));
145 }
146 }
147
148 return result;
149 }
150
151 public static boolean isList(String input) {
152 Matcher matcher = PATTERN_TARGETS.matcher(input);
153
154 if (matcher.matches()) {
155 Map<String, String> args = getArguments(matcher.group(TARGETS_GROUP_ARGS));
156 String type = matcher.group(TARGETS_GROUP_TYPE);
157 int count = getDefaultCount(type);
158 if (args.containsKey(ARGUMENT_COUNT)) count = Mth.getInt(args.get(ARGUMENT_COUNT), count);
159 return count != 1;
160 }
161
162 return false;
163 }
164
165 public static boolean isPattern(String input, String onlyType) {
166 Matcher matcher = PATTERN_TARGETS.matcher(input);
167
168 if (matcher.matches()) {
169 String type = matcher.group(TARGETS_GROUP_TYPE);
170 if (onlyType != null && !onlyType.equals(type)) return false;
171
172 return true;
173 }
174
175 return false;
176 }
177
178 public static boolean isPattern(String input) {
179 return isPattern(input, null);
180 }
181
182 private static final int getDefaultRangeMin(String type) {
183 return 0;
184 }
185
186 private static final int getDefaultRangeMax(String type) {
187 return 0;
188 }
189
190 private static final int getDefaultLevelMax(String type) {
191 return Integer.MAX_VALUE;
192 }
193
194 private static final int getDefaultLevelMin(String type) {
195 return 0;
196 }
197
198 private static final int getDefaultCount(String type) {
199 if (type.equals(TARGET_ALL)) {
200 return 0;
201 } else {
202 return 1;
203 }
204 }
205
206 private static Map<String, String> getArguments(String input) {
207 HashMap<String, String> result = new HashMap<String, String>();
208 if (input == null) return result;
209 Matcher matcher = PATTERN_SHORT_ARGUMENT.matcher(input);
210 int count = 0;
211 int last = -1;
212
213 while (matcher.find()) {
214 String name = null;
215
216 switch (count++) {
217 case 0:
218 name = ARGUMENT_COORDINATE_X;
219 break;
220 case 1:
221 name = ARGUMENT_COORDINATE_Y;
222 break;
223 case 2:
224 name = ARGUMENT_COORDINATE_Z;
225 break;
226 case 3:
227 name = ARGUMENT_RANGE_MAX;
228 break;
229 }
230
231 if (name != null && matcher.group(1).length() > 0) result.put(name, matcher.group(1));
232 last = matcher.end();
233 }
234
235 if (last < input.length()) {
236 matcher = PATTERN_LONG_ARGUMENT.matcher(last == -1 ? input : input.substring(last));
237
238 while (matcher.find()) {
239 result.put(matcher.group(1), matcher.group(2));
240 }
241 }
242
243 return result;
244 }
245}
246
247*/