Autism-Development/Autism-Client
Autism-Development/Autism-Client
2
0
Fork 0
mirror of https://github.com/AutismDevelopment/Autism-Client.git synced 2026-10-28 19:39:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Refactor: extract MacroPacketWait from MacroExecutor (upstream #4)

Browse source 
Move 9 packet match/wait methods (normalizePacketKey,
packetKeyMatches, packetNameMatches, ParsedPacketTarget,
parsedPacketTarget, matchesPacketTarget, awaitPacket, awaitChat,
awaitCaptureValueChat, captureSelectionState) verbatim into
MacroPacketWait. Shared MacroExecutor members referenced as
MacroExecutor.xxx (mechanical qualification only); same-package
captureSelectionState kept as delegate. All bodies verified
identical against HEAD modulo that qualification.
This commit is contained in:
sectersion 2026-10-11 16:01:35 +01:00
parent 518bc78faa
commit 026800738b
2 changed files with 229 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

197
src/main/java/autismclient/util/macro/MacroPacketWait.java Normal file
View file

@ -0,0 +1,197 @@
package autismclient.util.macro;
import autismclient.util.AutismPacketNamer;
import autismclient.util.AutismPacketRegistry;
import net.minecraft.client.Minecraft;
import net.minecraft.network.protocol.Packet;
import java.util.concurrent.CompletableFuture;
final class MacroPacketWait {
private MacroPacketWait() {
}
private static String normalizePacketKey(String value) {
return AutismPacketNamer.normalizePacketKey(value);
}
private static boolean packetKeyMatches(String normalizedExpected, String candidate) {
if (normalizedExpected.isEmpty() || candidate == null || candidate.isEmpty()) return false;
String normalizedCandidate = normalizePacketKey(candidate);
if (normalizedCandidate.isEmpty()) return false;
if (normalizedExpected.equals(normalizedCandidate)) return true;
if (normalizedCandidate.endsWith("packet")) {
String strippedCandidate = normalizedCandidate.substring(0, normalizedCandidate.length() - "packet".length());
if (normalizedExpected.equals(strippedCandidate)) return true;
}
return normalizedExpected.endsWith(normalizedCandidate) || normalizedCandidate.endsWith(normalizedExpected);
}
private static boolean packetNameMatches(String expected, String candidate) {
if (expected == null || expected.isEmpty()) return false;
return packetKeyMatches(normalizePacketKey(expected), candidate);
}
private record ParsedPacketTarget(String direction, String expectedName, String normalizedExpected) {}
private static final java.util.concurrent.ConcurrentHashMap<String, ParsedPacketTarget> PARSED_TARGET_CACHE =
new java.util.concurrent.ConcurrentHashMap<>();
private static final ParsedPacketTarget EMPTY_PACKET_TARGET = new ParsedPacketTarget("", "", "");
private static ParsedPacketTarget parsedPacketTarget(String target) {
if (target == null) return EMPTY_PACKET_TARGET;
if (PARSED_TARGET_CACHE.size() > 256) PARSED_TARGET_CACHE.clear();
return PARSED_TARGET_CACHE.computeIfAbsent(target, t -> {
String expectedName = WaitForPacketAction.getPacketName(t);
return new ParsedPacketTarget(WaitForPacketAction.getDirection(t), expectedName, normalizePacketKey(expectedName));
});
}
public static boolean matchesPacketTarget(String target, Packet<?> packet, String direction) {
if (packet == null) return false;
ParsedPacketTarget parsed = parsedPacketTarget(target);
if (!parsed.direction().isEmpty() && !parsed.direction().equalsIgnoreCase(direction)) return false;
if (parsed.expectedName().isEmpty()) return true;
String normalizedExpected = parsed.normalizedExpected();
if (packetKeyMatches(normalizedExpected, AutismPacketNamer.getFriendlyName(packet, direction))) return true;
if (packetKeyMatches(normalizedExpected, AutismPacketNamer.getFriendlyName(packet))) return true;
if (packetKeyMatches(normalizedExpected, packet.getClass().getSimpleName())) return true;
@SuppressWarnings("unchecked")
String fullName = AutismPacketRegistry.getName((Class<? extends Packet<?>>) packet.getClass());
return packetKeyMatches(normalizedExpected, fullName);
}
public static void awaitPacket(String target) {
MacroExecutor.RunState run = MacroExecutor.CURRENT_RUN.get();
if (run != null) {
CompletableFuture<Void> future = new CompletableFuture<>();
String normalizedTarget = WaitForPacketAction.normalizeTarget(target);
synchronized (run.packetWaitLock) {
run.waitingPacketName.set(normalizedTarget);
run.packetFuture = future;
run.waitingForPacket.set(true);
}
try {
MacroExecutor.setCurrentStatus(normalizedTarget.isEmpty()
? "Waiting for packet: Any"
: "Waiting for packet: " + WaitForPacketAction.getDisplayLabel(normalizedTarget));
MacroExecutor.waitForCondition(future);
} finally {
synchronized (run.packetWaitLock) {
if (run.packetFuture == future) {
run.waitingForPacket.set(false);
run.waitingPacketName.set("");
run.packetFuture = null;
}
}
}
return;
}
CompletableFuture<Void> future = new CompletableFuture<>();
String normalizedTarget = WaitForPacketAction.normalizeTarget(target);
synchronized (MacroExecutor.packetWaitLock) {
MacroExecutor.waitingPacketName.set(normalizedTarget);
MacroExecutor.lastReceivedPacket.set("");
MacroExecutor.activePacketFuture = future;
MacroExecutor.isWaitingForPacket.set(true);
}
try {
MacroExecutor.setCurrentStatus(normalizedTarget.isEmpty()
? "Waiting for packet: Any"
: "Waiting for packet: " + WaitForPacketAction.getDisplayLabel(normalizedTarget));
MacroExecutor.waitForCondition(future);
} finally {
synchronized (MacroExecutor.packetWaitLock) {
if (MacroExecutor.activePacketFuture == future) {
MacroExecutor.isWaitingForPacket.set(false);
MacroExecutor.waitingPacketName.set("");
MacroExecutor.activePacketFuture = null;
}
}
}
}
public static void awaitChat(WaitForChatAction wca) {
MacroExecutor.RunState run = MacroExecutor.CURRENT_RUN.get();
if (run != null) {
MacroExecutor.clearCaptureOutputs(wca);
CompletableFuture<Void> future = new CompletableFuture<>();
run.chatFuture = future;
run.waitingChatAction = wca;
run.waitingForChat.set(true);
try {
if (wca.timeoutMs > 0) future.completeOnTimeout(null, wca.timeoutMs, java.util.concurrent.TimeUnit.MILLISECONDS);
MacroExecutor.waitForCondition(future);
MacroExecutor.commitStagedCapture(wca);
} finally {
if (run.chatFuture == future) {
run.waitingForChat.set(false);
run.waitingChatAction = null;
run.chatFuture = null;
}
}
return;
}
CompletableFuture<Void> future = new CompletableFuture<>();
MacroExecutor.activeChatFuture = future;
MacroExecutor.isWaitingForChat.set(true);
MacroExecutor.waitingChatPattern.set(MacroChatText.normalizeManualText(wca.pattern));
MacroExecutor.waitingChatPatternJson.set(wca.patternJson == null ? "" : wca.patternJson);
MacroExecutor.waitingChatIsRegex.set(wca.useRegex);
MacroExecutor.waitingChatFuzzyPercent.set(WaitForChatAction.clampFuzzyPercent(wca.fuzzyPercent));
MacroExecutor.lastMatchedChat.set("");
try {
if (wca.timeoutMs > 0) future.completeOnTimeout(null, wca.timeoutMs, java.util.concurrent.TimeUnit.MILLISECONDS);
MacroExecutor.waitForCondition(future);
} finally {
MacroExecutor.isWaitingForChat.set(false);
MacroExecutor.waitingChatPattern.set("");
MacroExecutor.waitingChatPatternJson.set("");
MacroExecutor.waitingChatIsRegex.set(false);
MacroExecutor.waitingChatFuzzyPercent.set(100);
MacroExecutor.activeChatFuture = null;
}
}
public static void awaitCaptureValueChat(CaptureValueAction action) {
if (action == null) return;
MacroExecutor.RunState run = MacroExecutor.CURRENT_RUN.get();
MacroExecutor.clearCaptureOutputs(action);
MacroExecutor.OneShotPacketListener listener = MacroExecutor.awaitReceive(packet -> {
MacroExecutor.ChatCapture capture = MacroChatObserve.extractIncomingChat(packet);
if (capture == null) return false;
MacroExecutor.RecentChatMessage message = new MacroExecutor.RecentChatMessage(
capture.sender() == null ? "" : capture.sender(),
capture.message() == null ? "" : capture.message(),
capture.displayText() == null ? "" : capture.displayText(),
capture.displayComponent(),
capture.source(),
System.currentTimeMillis()
);
CaptureValueAction.Preview preview = action.previewChat(message);
if (!preview.success()) return false;
if (run != null) run.stagedCaptures.put(action, preview.values());
else MacroVariables.setAll(preview.values());
return true;
});
try {
if (MacroExecutor.waitForFutureDone(listener.future, 0) && run != null) MacroExecutor.commitStagedCapture(action);
} finally {
listener.cancel();
}
}
static CaptureListSelector.State captureSelectionState(MacroAction action) {
MacroExecutor.RunState run = MacroExecutor.CURRENT_RUN.get();
if (run == null || action == null) return null;
synchronized (run.captureSelection) {
return run.captureSelection.computeIfAbsent(action, a -> new CaptureListSelector.State());
}
}
}