PlayerESP and Breadcrumbs Improvements

Author: cev-api

README.md

@@ -17,7 +17,6 @@
 import java.util.UUID;
 
 import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 import net.wurstclient.Category;
 import net.wurstclient.SearchTags;
@@ -46,19 +45,79 @@ private enum Target
 		BOTH
 	}
 
+	private boolean movedEnough(Vec3d a, Vec3d b, double minDist)
+	{
+		double dx = a.x - b.x;
+		double dy = a.y - b.y;
+		double dz = a.z - b.z;
+		double sq = dx * dx + dy * dy + dz * dz;
+		return sq >= minDist * minDist;
+	}
+	
 	private final EnumSetting<Target> target =
 		new EnumSetting<>("Target", Target.values(), Target.YOU);
 	private final ColorSetting otherColor = new ColorSetting("Other color",
-		"Color for other players' trails.", new Color(64, 160, 255));
+		"Color for other players' trails. Note: PlayerESP overrides Breadcrumbs'\n"
+			+ "colors; if PlayerESP is using a static or unique color for a player,\n"
+			+ "Breadcrumbs will show that color instead.",
+		new Color(64, 160, 255));
 	private final CheckboxSetting keepOthersOnLeave =
-		new CheckboxSetting("Keep other trails when out of view", false);
+		new CheckboxSetting("Keep trails when out of view/logout", false);
 	// If enabled, assign bright random-ish colors to other players.
-	private final CheckboxSetting randomBrightColors =
-		new CheckboxSetting("Random bright colors for others", false);
-	private final SliderSetting maxSections =
-		new SliderSetting("Max sections", 1000, 100, MAX_SECTIONS_INFINITE, 50,
-			net.wurstclient.settings.SliderSetting.ValueDisplay.INTEGER
-				.withLabel(MAX_SECTIONS_INFINITE, "Infinite"));
+	private final CheckboxSetting randomBrightColors = new CheckboxSetting(
+		"Unique colors for others",
+		"Assign bright deterministic colors per-player so other hacks\n"
+			+ "(for example PlayerESP) can share the same color. If you turn\n"
+			+ "this off, Breadcrumbs will remove colors it owns from the\n"
+			+ "shared registry so other features may take over.",
+		false);
+	// Build a piecewise sections map: 0..100 (step 1), 200..1000 (step 100),
+	// 1200..5000 (step 200), 6000..9000 (step 1000), then 9999 and Infinite.
+	private static final int[] SECTIONS_MAP = buildSectionsMap();
+	
+	private static int[] buildSectionsMap()
+	{
+		java.util.ArrayList<Integer> list = new java.util.ArrayList<>();
+		for(int i = 0; i <= 100; i++)
+			list.add(i);
+		for(int v = 200; v <= 1000; v += 100)
+			list.add(v);
+		for(int v = 1200; v <= 5000; v += 200)
+			list.add(v);
+		for(int v = 6000; v <= 9000; v += 1000)
+			list.add(v);
+		list.add(9999);
+		list.add(MAX_SECTIONS_INFINITE);
+		int[] arr = new int[list.size()];
+		for(int i = 0; i < list.size(); i++)
+			arr[i] = list.get(i);
+		return arr;
+	}
+	
+	private static int findIndexFor(int value)
+	{
+		for(int i = 0; i < SECTIONS_MAP.length; i++)
+			if(SECTIONS_MAP[i] == value)
+				return i;
+		return 0;
+	}
+	
+	// Slider indexes into SECTIONS_MAP. Display the mapped value (actual
+	// section count) instead of the raw index so users see values like
+	// 2500 or "Infinite".
+	private final SliderSetting maxSections = new SliderSetting("Max sections",
+		findIndexFor(1000), 0, SECTIONS_MAP.length - 1, 1,
+		new net.wurstclient.settings.SliderSetting.ValueDisplay()
+		{
+			@Override
+			public String getValueString(double v)
+			{
+				int idx = (int)v;
+				int mapped = computeMaxSections(idx);
+				return mapped >= MAX_SECTIONS_INFINITE ? "Infinite"
+					: Integer.toString(mapped);
+			}
+		});
 	private final SliderSetting sectionLen =
 		new SliderSetting("Section length", 0.5, 0.1, 5.0, 0.1,
 			net.wurstclient.settings.SliderSetting.ValueDisplay.DECIMAL);
@@ -72,8 +131,9 @@ private enum Target
 	private final Map<UUID, Deque<Vec3d>> otherPoints = new HashMap<>();
 	// previous target selection to detect changes
 	private Target prevTarget = null;
-	// per-player assigned colors when randomBrightColors is enabled
-	private final Map<UUID, Color> playerColors = new HashMap<>();
+	// previous random toggle so we can clean up registry on toggle off
+	private boolean prevRandom = false;
+	// per-player colors are managed via PlayerColorRegistry
 
 	public BreadcrumbsHack()
 	{
@@ -102,6 +162,7 @@ protected void onEnable()
 		points.clear();
 		otherPoints.clear();
 		prevTarget = target.getSelected();
+		prevRandom = randomBrightColors.isChecked();
 		EVENTS.add(UpdateListener.class, this);
 		EVENTS.add(RenderListener.class, this);
 	}
@@ -152,7 +213,7 @@ public void onUpdate()
 		if(movedEnough(last, here, sectionLen.getValue()))
 		{
 			points.add(here);
-			int limit = maxSections.getValueI();
+			int limit = computeMaxSections(maxSections.getValueI());
 			boolean infinite = limit >= MAX_SECTIONS_INFINITE;
 			while(!infinite && points.size() > limit)
 				points.pollFirst();
@@ -161,17 +222,24 @@ public void onUpdate()
 		// Track other players if enabled
 		if(sel == Target.OTHERS || sel == Target.BOTH)
 		{
+			int nextIndex = 0;
 			for(var p : MC.world.getPlayers())
 			{
 				if(p == MC.player)
 					continue;
 				UUID id = p.getUuid();
-				// assign a color if needed
-				if(randomBrightColors.isChecked()
-					&& !playerColors.containsKey(id))
+				// assign a color if needed via central registry
+				if(randomBrightColors.isChecked())
 				{
-					playerColors.put(id,
-						generateBrightColor(playerColors.size()));
+					java.awt.Color assigned =
+						net.wurstclient.util.PlayerColorRegistry.get(id);
+					if(assigned == null)
+					{
+						// assign deterministically so all features agree on
+						// the color for this player
+						net.wurstclient.util.PlayerColorRegistry
+							.assignDeterministic(id, "Breadcrumbs");
+					}
 				}
 				Deque<Vec3d> dq =
 					otherPoints.computeIfAbsent(id, k -> new ArrayDeque<>());
@@ -185,7 +253,7 @@ public void onUpdate()
 				if(movedEnough(lastp, pos, sectionLen.getValue()))
 				{
 					dq.add(pos);
-					int limit = maxSections.getValueI();
+					int limit = computeMaxSections(maxSections.getValueI());
 					boolean infinite = limit >= MAX_SECTIONS_INFINITE;
 					while(!infinite && dq.size() > limit)
 						dq.pollFirst();
@@ -194,14 +262,40 @@ public void onUpdate()
 			// Remove trails for players that left, unless user chose to keep
 			if(!keepOthersOnLeave.isChecked())
 			{
-				otherPoints.keySet().removeIf(uuid -> {
-					boolean gone = MC.world.getPlayerByUuid(uuid) == null;
-					if(gone)
-						playerColors.remove(uuid);
-					return gone;
+				otherPoints.keySet()
+					.removeIf(uuid -> MC.world.getPlayerByUuid(uuid) == null);
+				// If not keeping trails we also remove registry entries
+				otherPoints.keySet().forEach(uuid -> {
+					if(MC.world.getPlayerByUuid(uuid) == null)
+						net.wurstclient.util.PlayerColorRegistry.remove(uuid);
 				});
 			}
 		}
+		
+		// If the random toggle was turned off, remove Breadcrumbs-owned
+		// registry
+		// entries so other hacks can take over colors.
+		boolean curRandom = randomBrightColors.isChecked();
+		if(prevRandom && !curRandom)
+		{
+			net.wurstclient.util.PlayerColorRegistry
+				.removeByOwner("Breadcrumbs");
+		}
+		prevRandom = curRandom;
+	}
+	
+	/**
+	 * Map the slider value to an actual max sections value. Values up to
+	 * 1000 are linear; values above 1000 scale up exponentially to allow
+	 * very large values without losing slider precision.
+	 */
+	private int computeMaxSections(int sliderIndex)
+	{
+		if(sliderIndex < 0)
+			return SECTIONS_MAP[0];
+		if(sliderIndex >= SECTIONS_MAP.length)
+			return SECTIONS_MAP[SECTIONS_MAP.length - 1];
+		return SECTIONS_MAP[sliderIndex];
 	}
 
 	@Override
@@ -230,8 +324,10 @@ public void onRender(MatrixStack matrixStack, float partialTicks)
 				int oc;
 				if(randomBrightColors.isChecked())
 				{
-					Color col =
-						playerColors.getOrDefault(id, otherColor.getColor());
+					java.awt.Color col =
+						net.wurstclient.util.PlayerColorRegistry.get(id);
+					if(col == null)
+						col = otherColor.getColor();
 					oc = RenderUtils
 						.toIntColor(
 							new float[]{col.getRed() / 255f,
@@ -281,10 +377,4 @@ private Color generateBrightColor(int index)
 		return new Color(r, g, bl);
 	}
 
-	private boolean movedEnough(Vec3d a, Vec3d b, double min)
-	{
-		return MathHelper.abs((float)(a.x - b.x)) >= min
-			|| MathHelper.abs((float)(a.y - b.y)) >= min
-			|| MathHelper.abs((float)(a.z - b.z)) >= min;
-	}
 }

src/main/java/net/wurstclient/hacks/BreadcrumbsHack.java

@@ -29,6 +29,9 @@
 import net.wurstclient.settings.filterlists.EntityFilterList;
 import net.wurstclient.settings.filters.FilterInvisibleSetting;
 import net.wurstclient.settings.filters.FilterSleepingSetting;
+import net.wurstclient.settings.ColorSetting;
+import java.awt.Color;
+import net.wurstclient.settings.CheckboxSetting;
 import net.wurstclient.util.EntityUtils;
 import net.wurstclient.util.FakePlayerEntity;
 import net.wurstclient.util.RenderUtils;
@@ -51,12 +54,40 @@ public final class PlayerEspHack extends Hack implements UpdateListener,
 		new FilterInvisibleSetting("Won't show invisible players.", false));
 
 	private final ArrayList<PlayerEntity> players = new ArrayList<>();
+	private final CheckboxSetting randomBrightColors = new CheckboxSetting(
+		"Unique colors for players",
+		"When enabled, assigns each player a bright color from a shared\n"
+			+ "palette and forces it into the shared color registry.\n"
+			+ "PlayerESP takes ownership of these colors (overrides Breadcrumbs).",
+		false);
+	private final CheckboxSetting filledBoxes = new CheckboxSetting(
+		"Filled boxes",
+		"When enabled, renders solid filled boxes instead of outlined boxes.",
+		false);
+	private final CheckboxSetting useStaticPlayerColor = new CheckboxSetting(
+		"Use static player color",
+		"When enabled, uses the selected static color for all players and\n"
+			+ "forces it into the shared color registry. PlayerESP owns the\n"
+			+ "assignment while this is enabled (will override Breadcrumbs).",
+		false);
+	private final ColorSetting playerColor = new ColorSetting("Player color",
+		"Static color used when 'Use static player color' is enabled.",
+		new Color(255, 196, 64));
+	private final net.wurstclient.settings.SliderSetting filledAlpha =
+		new net.wurstclient.settings.SliderSetting("Filled box alpha", 35, 0,
+			100, 1,
+			net.wurstclient.settings.SliderSetting.ValueDisplay.INTEGER);
 
 	public PlayerEspHack()
 	{
 		super("PlayerESP");
 		setCategory(Category.RENDER);
 		addSetting(style);
+		addSetting(randomBrightColors);
+		addSetting(filledBoxes);
+		addSetting(filledAlpha);
+		addSetting(useStaticPlayerColor);
+		addSetting(playerColor);
 		addSetting(boxSize);
 		entityFilters.forEach(this::addSetting);
 	}
@@ -113,10 +144,32 @@ public void onRender(MatrixStack matrixStack, float partialTicks)
 			{
 				Box box = EntityUtils.getLerpedBox(e, partialTicks)
 					.offset(0, extraSize, 0).expand(extraSize);
-				boxes.add(new ColoredBox(box, getColor(e)));
+				int col = getColor(e);
+				boxes.add(new ColoredBox(box, col));
 			}
 
-			RenderUtils.drawOutlinedBoxes(matrixStack, boxes, false);
+			if(filledBoxes.isChecked())
+			{
+				// Draw semi-transparent filled boxes, then draw opaque
+				// outlines on top
+				ArrayList<ColoredBox> solid = new ArrayList<>(boxes.size());
+				ArrayList<ColoredBox> outline = new ArrayList<>(boxes.size());
+				for(ColoredBox cb : boxes)
+				{
+					int base = cb.color();
+					int solidAlpha =
+						(int)((filledAlpha.getValue() / 100f) * 255) << 24;
+					int solidColor = (base & 0x00FFFFFF) | solidAlpha;
+					solid.add(new ColoredBox(cb.box(), solidColor));
+					int outlineColor = (base & 0x00FFFFFF) | (0xFF << 24);
+					outline.add(new ColoredBox(cb.box(), outlineColor));
+				}
+				RenderUtils.drawSolidBoxes(matrixStack, solid, false);
+				RenderUtils.drawOutlinedBoxes(matrixStack, outline, false);
+			}else
+			{
+				RenderUtils.drawOutlinedBoxes(matrixStack, boxes, false);
+			}
 		}
 
 		if(style.hasLines())
@@ -137,6 +190,59 @@ private int getColor(PlayerEntity e)
 	{
 		if(WURST.getFriends().contains(e.getName().getString()))
 			return 0x800000FF;
+		// If PlayerESP enforces a static color, force it into the registry so
+		// PlayerESP always overrides Breadcrumbs. Return that color.
+		if(useStaticPlayerColor.isChecked())
+		{
+			java.awt.Color pc = playerColor.getColor();
+			net.wurstclient.util.PlayerColorRegistry.forceAssign(e.getUuid(),
+				pc, "PlayerESP");
+			return RenderUtils.toIntColor(new float[]{pc.getRed() / 255f,
+				pc.getGreen() / 255f, pc.getBlue() / 255f}, 0.85F);
+		}
+		
+		// If PlayerESP requests random bright colors, generate one
+		// deterministically and force-assign it so PlayerESP overrides
+		// Breadcrumbs.
+		if(randomBrightColors.isChecked())
+		{
+			int idx = Math.abs(e.getUuid().hashCode());
+			java.awt.Color gen = net.wurstclient.util.PlayerColorRegistry
+				.generateBrightColor(idx);
+			net.wurstclient.util.PlayerColorRegistry.forceAssign(e.getUuid(),
+				gen, "PlayerESP");
+			return RenderUtils.toIntColor(new float[]{gen.getRed() / 255f,
+				gen.getGreen() / 255f, gen.getBlue() / 255f}, 0.9F);
+		}
+		
+		// If neither static nor random are enabled, remove any PlayerESP-owned
+		// registry entries so other hacks' colors can show. Then fall back to
+		// dynamic distance-based coloring.
+		if(!useStaticPlayerColor.isChecked() && !randomBrightColors.isChecked())
+		{
+			// remove all registry assignments owned by PlayerESP
+			net.wurstclient.util.PlayerColorRegistry.removeByOwner("PlayerESP");
+			// Continue to distance-based dynamic coloring below
+		}
+		
+		// Only consult the shared registry when PlayerESP has explicitly opted
+		// into owning colors. This prevents Breadcrumbs (or other hacks)
+		// changing PlayerESP colors unexpectedly.
+		if(useStaticPlayerColor.isChecked() || randomBrightColors.isChecked())
+		{
+			java.awt.Color reg2 =
+				net.wurstclient.util.PlayerColorRegistry.get(e.getUuid());
+			if(reg2 != null)
+			{
+				return RenderUtils
+					.toIntColor(
+						new float[]{reg2.getRed() / 255f,
+							reg2.getGreen() / 255f, reg2.getBlue() / 255f},
+						0.9F);
+			}
+		}
+		
+		// Otherwise fall back to the dynamic distance-based coloring (default).
 
 		float f = MC.player.distanceTo(e) / 20F;
 		float r = MathHelper.clamp(2 - f, 0, 1);