package com.irtimaled.bbor.client.commands;
+import com.irtimaled.bbor.client.config.HexColor;
import com.irtimaled.bbor.common.models.Coords;
import com.irtimaled.bbor.common.models.Point;
-import com.mojang.brigadier.arguments.BoolArgumentType;
-import com.mojang.brigadier.arguments.DoubleArgumentType;
-import com.mojang.brigadier.arguments.IntegerArgumentType;
-import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.arguments.*;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.minecraft.command.CommandSource;
return BoolArgumentType.bool();
}
+ public static ArgumentType<HexColor> hexColor() {
+ return new HexColorArgument();
+ }
+
public static Coords getCoords(CommandContext<CommandSource> context, String name) throws CommandSyntaxException {
return new Coords(getArgumentValueOrDefault(context, name, Vec3Argument::getVec3, () -> context.getSource().getPos()));
}
package com.irtimaled.bbor.client.commands;
import com.irtimaled.bbor.client.config.ConfigManager;
+import com.irtimaled.bbor.client.config.HexColor;
import com.irtimaled.bbor.client.config.Setting;
import com.irtimaled.bbor.client.gui.SettingsScreen;
import com.mojang.brigadier.Command;
case 'S':
buildSetSettingCommand(command, (Setting<String>) setting, Arguments.string(), String.class);
break;
+ case 'H':
+ buildSetSettingCommand(command, (Setting<HexColor>) setting, Arguments.hexColor(), HexColor.class);
+ break;
}
return command;
}
--- /dev/null
+package com.irtimaled.bbor.client.commands;
+
+import com.irtimaled.bbor.client.config.HexColor;
+import com.mojang.brigadier.LiteralMessage;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public class HexColorArgument implements ArgumentType<HexColor> {
+ private static final List<String> EXAMPLES = Arrays.asList("#000000", "#ffffff");
+ public static final DynamicCommandExceptionType INVALID_HEX_COLOR = new DynamicCommandExceptionType(v -> new LiteralMessage("Invalid hex color, expected six digit hex color starting with # but found '" + v + "'"));
+ public static final SimpleCommandExceptionType EXPECTED_HEX_COLOR = new SimpleCommandExceptionType(new LiteralMessage("Expected hex color"));
+
+ @Override
+ public <S> HexColor parse(StringReader reader) throws CommandSyntaxException {
+ String value = reader.getRemaining().split(" ")[0].toLowerCase();
+ if (value.isEmpty()) {
+ throw EXPECTED_HEX_COLOR.createWithContext(reader);
+ }
+
+ HexColor color = HexColor.from(value);
+ if(color != null) {
+ reader.setCursor(reader.getCursor() + 7);
+ return color;
+ }
+
+ throw INVALID_HEX_COLOR.createWithContext(reader, value);
+ }
+
+ @Override
+ public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+ if (builder.getRemaining().length() == 0) builder.suggest("#");
+ return builder.buildFuture();
+ }
+
+ @Override
+ public Collection<String> getExamples() {
+ return EXAMPLES;
+ }
+}
import com.irtimaled.bbor.common.BoundingBoxType;
+import java.awt.*;
import java.util.HashMap;
import java.util.Map;
public class BoundingBoxTypeHelper {
- private static final Map<String, Setting<Boolean>> structureTypeMap = new HashMap<>();
+ private static final Map<String, BoundingBoxTypeSettings> structureTypeMap = new HashMap<>();
- private static void registerType(BoundingBoxType type, Setting<Boolean> shouldRenderSetting) {
- structureTypeMap.put(type.getName(), shouldRenderSetting);
+ private static void registerType(BoundingBoxType type, Setting<Boolean> shouldRender, Setting<HexColor> color) {
+ structureTypeMap.put(type.getName(), new BoundingBoxTypeSettings(shouldRender, color));
}
static {
- registerType(BoundingBoxType.WorldSpawn, ConfigManager.drawWorldSpawn);
- registerType(BoundingBoxType.SpawnChunks, ConfigManager.drawWorldSpawn);
- registerType(BoundingBoxType.LazySpawnChunks, ConfigManager.drawLazySpawnChunks);
- registerType(BoundingBoxType.MobSpawner, ConfigManager.drawMobSpawners);
- registerType(BoundingBoxType.SlimeChunks, ConfigManager.drawSlimeChunks);
- registerType(BoundingBoxType.AFKSphere, ConfigManager.drawAFKSpheres);
- registerType(BoundingBoxType.BiomeBorder, ConfigManager.drawBiomeBorders);
- registerType(BoundingBoxType.Beacon, ConfigManager.drawBeacons);
- registerType(BoundingBoxType.Conduit, ConfigManager.drawConduits);
- registerType(BoundingBoxType.SpawnableBlocks, ConfigManager.drawSpawnableBlocks);
-
- registerType(BoundingBoxType.JungleTemple, ConfigManager.drawJungleTemples);
- registerType(BoundingBoxType.DesertTemple, ConfigManager.drawDesertTemples);
- registerType(BoundingBoxType.WitchHut, ConfigManager.drawWitchHuts);
- registerType(BoundingBoxType.OceanMonument, ConfigManager.drawOceanMonuments);
- registerType(BoundingBoxType.Shipwreck, ConfigManager.drawShipwrecks);
- registerType(BoundingBoxType.OceanRuin, ConfigManager.drawOceanRuins);
- registerType(BoundingBoxType.BuriedTreasure, ConfigManager.drawBuriedTreasure);
- registerType(BoundingBoxType.Stronghold, ConfigManager.drawStrongholds);
- registerType(BoundingBoxType.MineShaft, ConfigManager.drawMineShafts);
- registerType(BoundingBoxType.NetherFortress, ConfigManager.drawNetherFortresses);
- registerType(BoundingBoxType.EndCity, ConfigManager.drawEndCities);
- registerType(BoundingBoxType.Mansion, ConfigManager.drawMansions);
- registerType(BoundingBoxType.Igloo, ConfigManager.drawIgloos);
- registerType(BoundingBoxType.PillagerOutpost, ConfigManager.drawPillagerOutposts);
- registerType(BoundingBoxType.Village, ConfigManager.drawVillages);
- registerType(BoundingBoxType.VillageSpheres, ConfigManager.drawVillageSpheres);
- registerType(BoundingBoxType.NetherFossil, ConfigManager.drawNetherFossils);
- registerType(BoundingBoxType.BastionRemnant, ConfigManager.drawBastionRemnants);
- registerType(BoundingBoxType.RuinedPortal, ConfigManager.drawRuinedPortals);
+ registerType(BoundingBoxType.WorldSpawn, ConfigManager.drawWorldSpawn, ConfigManager.colorWorldSpawn);
+ registerType(BoundingBoxType.SpawnChunks, ConfigManager.drawWorldSpawn, ConfigManager.colorWorldSpawn);
+ registerType(BoundingBoxType.LazySpawnChunks, ConfigManager.drawLazySpawnChunks, ConfigManager.colorLazySpawnChunks);
+ registerType(BoundingBoxType.MobSpawner, ConfigManager.drawMobSpawners, ConfigManager.colorMobSpawners);
+ registerType(BoundingBoxType.SlimeChunks, ConfigManager.drawSlimeChunks, ConfigManager.colorSlimeChunks);
+ registerType(BoundingBoxType.AFKSphere, ConfigManager.drawAFKSpheres, ConfigManager.colorAFKSpheres);
+ registerType(BoundingBoxType.BiomeBorder, ConfigManager.drawBiomeBorders, ConfigManager.colorBiomeBorders);
+ registerType(BoundingBoxType.Beacon, ConfigManager.drawBeacons, ConfigManager.colorBeacons);
+ registerType(BoundingBoxType.Custom, ConfigManager.drawConduits, ConfigManager.colorCustom);
+ registerType(BoundingBoxType.Conduit, ConfigManager.drawConduits, ConfigManager.colorConduits);
+ registerType(BoundingBoxType.SpawnableBlocks, ConfigManager.drawSpawnableBlocks, ConfigManager.colorSpawnableBlocks);
+
+ registerType(BoundingBoxType.JungleTemple, ConfigManager.drawJungleTemples, ConfigManager.colorJungleTemples);
+ registerType(BoundingBoxType.DesertTemple, ConfigManager.drawDesertTemples, ConfigManager.colorDesertTemples);
+ registerType(BoundingBoxType.WitchHut, ConfigManager.drawWitchHuts, ConfigManager.colorWitchHuts);
+ registerType(BoundingBoxType.OceanMonument, ConfigManager.drawOceanMonuments, ConfigManager.colorOceanMonuments);
+ registerType(BoundingBoxType.Shipwreck, ConfigManager.drawShipwrecks, ConfigManager.colorShipwrecks);
+ registerType(BoundingBoxType.OceanRuin, ConfigManager.drawOceanRuins, ConfigManager.colorOceanRuins);
+ registerType(BoundingBoxType.BuriedTreasure, ConfigManager.drawBuriedTreasure, ConfigManager.colorBuriedTreasure);
+ registerType(BoundingBoxType.Stronghold, ConfigManager.drawStrongholds, ConfigManager.colorStrongholds);
+ registerType(BoundingBoxType.MineShaft, ConfigManager.drawMineShafts, ConfigManager.colorMineShafts);
+ registerType(BoundingBoxType.NetherFortress, ConfigManager.drawNetherFortresses, ConfigManager.colorNetherFortresses);
+ registerType(BoundingBoxType.EndCity, ConfigManager.drawEndCities, ConfigManager.colorEndCities);
+ registerType(BoundingBoxType.Mansion, ConfigManager.drawMansions, ConfigManager.colorMansions);
+ registerType(BoundingBoxType.Igloo, ConfigManager.drawIgloos, ConfigManager.colorIgloos);
+ registerType(BoundingBoxType.PillagerOutpost, ConfigManager.drawPillagerOutposts, ConfigManager.colorPillagerOutposts);
+ registerType(BoundingBoxType.Village, ConfigManager.drawVillages, ConfigManager.colorVillages);
+ registerType(BoundingBoxType.VillageSpheres, ConfigManager.drawVillageSpheres, ConfigManager.colorVillages);
+ registerType(BoundingBoxType.NetherFossil, ConfigManager.drawNetherFossils, ConfigManager.colorNetherFossils);
+ registerType(BoundingBoxType.BastionRemnant, ConfigManager.drawBastionRemnants, ConfigManager.colorBastionRemnants);
+ registerType(BoundingBoxType.RuinedPortal, ConfigManager.drawRuinedPortals, ConfigManager.colorRuinedPortals);
}
public static Setting<Boolean> renderSetting(BoundingBoxType type) {
- return structureTypeMap.get(type.getName());
+ return structureTypeMap.get(type.getName()).shouldRender;
}
public static boolean shouldRender(BoundingBoxType type) {
- Setting<Boolean> setting = structureTypeMap.get(type.getName());
- return setting != null ? setting.get() : false;
+ BoundingBoxTypeSettings settings = structureTypeMap.get(type.getName());
+ return settings != null ? settings.shouldRender.get() : false;
+ }
+
+ public static Color getColor(BoundingBoxType type) {
+ BoundingBoxTypeSettings settings = structureTypeMap.get(type.getName());
+ return settings != null ? ColorHelper.getColor(settings.color) : Color.WHITE;
+ }
+
+ private static class BoundingBoxTypeSettings {
+ private final Setting<Boolean> shouldRender;
+ private final Setting<HexColor> color;
+
+ public BoundingBoxTypeSettings(Setting<Boolean> shouldRender, Setting<HexColor> color) {
+ this.shouldRender = shouldRender;
+ this.color = color;
+ }
}
}
--- /dev/null
+package com.irtimaled.bbor.client.config;
+
+import java.awt.*;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ColorHelper {
+ private static final Map<HexColor, Color> colorMap = new HashMap<>();
+
+ private static Color getColor(HexColor value) {
+ return colorMap.computeIfAbsent(value, ColorHelper::decodeColor);
+ }
+
+ private static Color decodeColor(HexColor hexColor) {
+ try {
+ int color = Integer.decode(hexColor.getValue());
+
+ int alpha = (color >> 24) & 0xFF;
+ return new Color(color, hexColor.hasAlpha());
+ }
+ catch (Exception ignored) {
+ return null;
+ }
+ }
+
+ public static Color getColor(Setting<HexColor> value) {
+ if(value == null) return Color.WHITE;
+
+ Color color = getColor(value.get());
+ return color != null ? color : getColor(value.defaultValue);
+ }
+}
public static Setting<Boolean> invertBoxColorPlayerInside;
public static Setting<Boolean> renderSphereAsDots;
+ public static Setting<HexColor> colorWorldSpawn;
+ public static Setting<HexColor> colorLazySpawnChunks;
+ public static Setting<HexColor> colorMobSpawners;
+ public static Setting<HexColor> colorMobSpawnersLineFarAway;
+ public static Setting<HexColor> colorMobSpawnersLineNearby;
+ public static Setting<HexColor> colorMobSpawnersLineActive;
+ public static Setting<HexColor> colorSlimeChunks;
+ public static Setting<HexColor> colorAFKSpheres;
+ public static Setting<HexColor> colorAFKSpheresSafeArea;
+ public static Setting<HexColor> colorBiomeBorders;
+ public static Setting<HexColor> colorBeacons;
+ public static Setting<HexColor> colorCustom;
+ public static Setting<HexColor> colorConduits;
+ public static Setting<HexColor> colorConduitMobHarmArea;
+ public static Setting<HexColor> colorSpawnableBlocks;
+ public static Setting<HexColor> colorJungleTemples;
+ public static Setting<HexColor> colorDesertTemples;
+ public static Setting<HexColor> colorWitchHuts;
+ public static Setting<HexColor> colorOceanMonuments;
+ public static Setting<HexColor> colorShipwrecks;
+ public static Setting<HexColor> colorOceanRuins;
+ public static Setting<HexColor> colorBuriedTreasure;
+ public static Setting<HexColor> colorStrongholds;
+ public static Setting<HexColor> colorMineShafts;
+ public static Setting<HexColor> colorNetherFortresses;
+ public static Setting<HexColor> colorEndCities;
+ public static Setting<HexColor> colorMansions;
+ public static Setting<HexColor> colorIgloos;
+ public static Setting<HexColor> colorPillagerOutposts;
+ public static Setting<HexColor> colorVillages;
+ public static Setting<HexColor> colorNetherFossils;
+ public static Setting<HexColor> colorBastionRemnants;
+ public static Setting<HexColor> colorRuinedPortals;
+
+ public static Setting<HexColor> buttonOnOverlay;
+
public static void loadConfig() {
configDir = new File(".", "config");
configDir.mkdirs();
keepCacheBetweenSessions = setup(config, "general", "keepCacheBetweenSessions", false, "If set to true bounding box caches will be kept between sessions.");
invertBoxColorPlayerInside = setup(config, "general", "invertBoxColorPlayerInside", false, "If set to true the color of any bounding box the player is inside will be inverted.");
renderSphereAsDots = setup(config, "general", "renderSphereAsDots", false, "If set to true spheres will be rendered as dots.");
+ buttonOnOverlay = setup(config, "general", "buttonEnabledOverlay", HexColor.from("#3000ff00"), "The color and alpha of the button overlay when a button is on.");
drawBeacons = setup(config, "beacons", "drawBeacons", true, "If set to true beacon bounding boxes will be drawn.");
spawnableBlocksRenderWidth = setup(config, "spawnableBlocks", "spawnableBlocksRenderWidth", 2, "The distance from the player where spawnable blocks will be drawn in X and Z axis.");
spawnableBlocksRenderHeight = setup(config, "spawnableBlocks", "spawnableBlocksRenderHeight", 1, "The distance from the player where spawnable blocks will be drawn in Y axis.");
+ colorWorldSpawn = setup(config, "colors", "colorWorldSpawn", HexColor.from("#ff0000"), "Color of world spawn and spawn chunks bounding boxes.");
+ colorLazySpawnChunks = setup(config, "colors", "colorLazySpawnChunks", HexColor.from("#ff0000"), "Color of lazy spawn chunks bounding boxes.");
+ colorMobSpawners = setup(config, "colors", "colorMobSpawners", HexColor.from("#00ff00"), "Color of mob spawners.");
+ colorMobSpawnersLineFarAway = setup(config, "colors", "colorMobSpawnersLineFarAway", HexColor.from("#ff0000"), "Color of mob spawner activation line if spawner far away.");
+ colorMobSpawnersLineNearby = setup(config, "colors", "colorMobSpawnersLineNearby", HexColor.from("#ff7f00"), "Color of mob spawners activation line if spawner nearby.");
+ colorMobSpawnersLineActive = setup(config, "colors", "colorMobSpawnersLineActive", HexColor.from("#00ff00"), "Color of mob spawners activation line if spawner active.");
+ colorSlimeChunks = setup(config, "colors", "colorSlimeChunks", HexColor.from("#006000"), "Color of slime chunks bounding boxes.");
+ colorAFKSpheres = setup(config, "colors", "colorAFKSpheres", HexColor.from("#ff0000"), "Color of afk spot spheres.");
+ colorAFKSpheresSafeArea = setup(config, "colors", "colorAFKSpheresSafeArea", HexColor.from("#00ff00"), "Color of afk spot safe area spheres.");
+ colorBiomeBorders = setup(config, "colors", "colorBiomeBorders", HexColor.from("#00ff00"), "Color of biome borders.");
+ colorBeacons = setup(config, "colors", "colorBeacons", HexColor.from("#ffffff"), "Color of beacon bounding boxes.");
+ colorCustom = setup(config, "colors", "colorCustom", HexColor.from("#ffffff"), "Color of all types of custom boxes.");
+ colorConduits = setup(config, "colors", "colorConduits", HexColor.from("#00ffff"), "Color of conduit bounding spheres.");
+ colorConduitMobHarmArea = setup(config, "colors", "colorConduitMobHarmArea", HexColor.from("#ff7f00"), "Color of conduit mob harm bounding boxes.");
+ colorSpawnableBlocks = setup(config, "colors", "colorSpawnableBlocks", HexColor.from("#ff0000"), "Color of spawnable blocks.");
+ colorJungleTemples = setup(config, "colors", "colorJungleTemples", HexColor.from("#006000"), "Color of jungle temple bounding boxes.");
+ colorDesertTemples = setup(config, "colors", "colorDesertTemples", HexColor.from("#ffc800"), "Color of desert temple bounding boxes.");
+ colorWitchHuts = setup(config, "colors", "colorWitchHuts", HexColor.from("#0000ff"), "Color of witch hut bounding boxes.");
+ colorOceanMonuments = setup(config, "colors", "colorOceanMonuments", HexColor.from("#00ffff"), "Color of ocean monument bounding boxes.");
+ colorShipwrecks = setup(config, "colors", "colorShipwrecks", HexColor.from("#00ffff"), "Color of ship wrecks.");
+ colorOceanRuins = setup(config, "colors", "colorOceanRuins", HexColor.from("#00ffff"), "Color of ocean ruins.");
+ colorBuriedTreasure = setup(config, "colors", "colorBuriedTreasure", HexColor.from("#00ffff"), "Color of buried treasure.");
+ colorStrongholds = setup(config, "colors", "colorStrongholds", HexColor.from("#ffff00"), "Color of stronghold bounding boxes.");
+ colorMineShafts = setup(config, "colors", "colorMineShafts", HexColor.from("#c0c0c0"), "Color of mineshaft bounding boxes.");
+ colorNetherFortresses = setup(config, "colors", "colorNetherFortresses", HexColor.from("#ff0000"), "Color of nether fortress bounding boxes.");
+ colorEndCities = setup(config, "colors", "colorEndCities", HexColor.from("#ff00ff"), "Color of end cities.");
+ colorMansions = setup(config, "colors", "colorMansions", HexColor.from("#8b4513"), "Color of woodland mansions.");
+ colorIgloos = setup(config, "colors", "colorIgloos", HexColor.from("#ffffff"), "Color of igloos.");
+ colorPillagerOutposts = setup(config, "colors", "colorPillagerOutposts", HexColor.from("#404040"), "Color of pillager outposts.");
+ colorVillages = setup(config, "colors", "colorVillages", HexColor.from("#800080"), "Color of village bounding boxes.");
+ colorNetherFossils = setup(config, "colors", "colorNetherFossils", HexColor.from("#ffffff"), "Color of nether fossils.");
+ colorBastionRemnants = setup(config, "colors", "colorBastionRemnants", HexColor.from("#c0c0c0"), "Color of bastion remnants.");
+ colorRuinedPortals = setup(config, "colors", "colorRuinedPortals", HexColor.from("#c800ff"), "Color of ruined portals.");
+
config.save();
}
return new Setting<>(type, Integer.parseInt(value));
case 'B':
return new Setting<>(type, value.equals("1") || value.toLowerCase().equals("true"));
+ case 'H':
+ return new Setting<>(type, HexColor.from(value));
}
return new Setting<>(type, value);
}
--- /dev/null
+package com.irtimaled.bbor.client.config;
+
+public class HexColor {
+ private final String value;
+ private final boolean hasAlpha;
+
+ private HexColor(String value, boolean hasAlpha) {
+ this.value = value;
+ this.hasAlpha = hasAlpha;
+ }
+
+ public static HexColor from(String value) {
+ String lowerValue = value.toLowerCase();
+ if (lowerValue.length() == 7 &&
+ lowerValue.matches("#[0-9a-f]{6}")) return new HexColor(lowerValue, false);
+ if (lowerValue.length() == 9 &&
+ lowerValue.matches("#[0-9a-f]{8}")) return new HexColor(lowerValue, true);
+
+ return null;
+ }
+
+ public String getValue() {
+ return value;
+ }
+
+ public boolean hasAlpha() {
+ return hasAlpha;
+ }
+
+ @Override
+ public String toString() {
+ return getValue();
+ }
+
+ @Override
+ public int hashCode() {
+ return value.hashCode();
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+ if (obj == null || getClass() != obj.getClass()) return false;
+ HexColor hexColor = (HexColor) obj;
+ return value.equals(hexColor.value);
+ }
+}
package com.irtimaled.bbor.client.gui;
-import java.awt.*;
+import com.irtimaled.bbor.client.config.ColorHelper;
+import com.irtimaled.bbor.client.config.ConfigManager;
public abstract class BoolButton extends AbstractButton {
- private static final Color OVERLAY_COLOR = new Color(0, 255, 0, 48);
-
private boolean value;
BoolButton(int width, String label, boolean enabled) {
int right = left + this.width - 2;
int bottom = top + this.height - 2;
if (this.getValue()) {
- drawRectangle(left, top, right, bottom, OVERLAY_COLOR);
+ drawRectangle(left, top, right, bottom, ColorHelper.getColor(ConfigManager.buttonOnOverlay));
}
}
}
import java.awt.*;
public class BoundingBoxTypeButton extends BoolSettingButton {
- private final Color color;
+ private final BoundingBoxType type;
BoundingBoxTypeButton(int width, String label, BoundingBoxType type) {
super(width, label, BoundingBoxTypeHelper.renderSetting(type));
- color = type.getColor();
+ this.type = type;
}
@Override
int right = left + width - 2;
int bottom = top + height - 2;
+ Color color = BoundingBoxTypeHelper.getColor(type);
+
// top & left
drawRectangle(left, top, right, top + 1, color);
drawRectangle(left, top, left + 1, bottom, color);
private final Coords coords;
private final int level;
- private BoundingBoxBeacon(Coords coords, Coords minCoords, Coords maxCoords, int level) {
- super(minCoords, maxCoords, BoundingBoxType.Beacon);
+ private BoundingBoxBeacon(Coords coords, Coords minCoords, Coords maxCoords, int level, BoundingBoxType beacon) {
+ super(minCoords, maxCoords, beacon);
this.coords = coords;
this.level = level;
}
public static BoundingBoxBeacon from(Coords coords, int level) {
+ BoundingBoxType type = BoundingBoxType.Beacon;
+ return from(coords, level, type);
+ }
+
+ public static BoundingBoxBeacon from(Coords coords, int level, BoundingBoxType type) {
int range = 10 + (10 * level);
Coords minCoords = new Coords(coords.getX() - range, coords.getY() - range, coords.getZ() - range);
Coords maxCoords = new Coords(coords.getX() + range, 324 + range, coords.getZ() + range);
- return new BoundingBoxBeacon(coords, minCoords, maxCoords, level);
+ return new BoundingBoxBeacon(coords, minCoords, maxCoords, level, type);
}
@Override
import com.irtimaled.bbor.client.Player;
import com.irtimaled.bbor.client.models.BoundingBoxBeacon;
+import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.models.Coords;
import java.util.HashMap;
public static void add(Coords coords, int level) {
int dimensionId = Player.getDimensionId();
- BoundingBoxBeacon beacon = BoundingBoxBeacon.from(coords, level);
+ BoundingBoxBeacon beacon = BoundingBoxBeacon.from(coords, level, BoundingBoxType.Custom);
getCache(dimensionId).put(coords, beacon);
}
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.client.models.BoundingBoxBeacon;
import com.irtimaled.bbor.common.models.Coords;
@Override
public void render(BoundingBoxBeacon boundingBox) {
Coords coords = boundingBox.getCoords();
- Color color = boundingBox.getColor();
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
renderCuboid(new OffsetBox(coords, coords), color);
if (boundingBox.getLevel() != 0) {
renderCuboid(new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords()), color);
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.models.BoundingBoxBiomeBorder;
import com.irtimaled.bbor.common.models.Coords;
OffsetPoint northEast = northWest.offset(1, 0, 0);
OffsetPoint southWest = northWest.offset(0, 0, 1);
- Color color = Color.GREEN;
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
if (boundingBox.renderNorth()) {
render(northWest, northEast, color);
}
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
+import com.irtimaled.bbor.client.config.ColorHelper;
import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.models.BoundingBoxConduit;
-import com.irtimaled.bbor.common.models.Colors;
import com.irtimaled.bbor.common.models.Point;
import java.awt.*;
@Override
public void render(BoundingBoxConduit boundingBox) {
int level = boundingBox.getLevel();
- Color color = boundingBox.getColor();
Point point = boundingBox.getPoint();
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
OffsetPoint center = new OffsetPoint(point);
OffsetBox centerBox = new OffsetBox(center, center).grow(0.5, 0.5, 0.5);
renderCuboid(centerBox, color);
if (level == 6 && ConfigManager.renderConduitMobHarmArea.get()) {
- renderCuboid(centerBox.grow(8, 8, 8), Colors.DARK_ORANGE);
+ renderCuboid(centerBox.grow(8, 8, 8),
+ ColorHelper.getColor(ConfigManager.colorConduitMobHarmArea));
}
if (level != 0) {
renderSphere(point, boundingBox.getRadius() + 0.5, color, 5, 5);
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.common.models.BoundingBoxCuboid;
public class CuboidRenderer extends AbstractRenderer<BoundingBoxCuboid> {
@Override
public void render(BoundingBoxCuboid boundingBox) {
OffsetBox bb = new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
- renderCuboid(bb, boundingBox.getColor());
+ renderCuboid(bb, BoundingBoxTypeHelper.getColor(boundingBox.getType()));
}
}
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.models.BoundingBoxLine;
import org.lwjgl.opengl.GL11;
public class LineRenderer extends AbstractRenderer<BoundingBoxLine> {
@Override
public void render(BoundingBoxLine boundingBox) {
- Color color = boundingBox.getColor();
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
if (boundingBox.getWidth() == 0) {
OffsetPoint startPoint = new OffsetPoint(boundingBox.getMinPoint()).offset(0, 0.001f, 0);
package com.irtimaled.bbor.client.renderers;
import com.irtimaled.bbor.client.Player;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
+import com.irtimaled.bbor.client.config.ColorHelper;
import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.models.BoundingBoxMobSpawner;
-import com.irtimaled.bbor.common.models.Colors;
import com.irtimaled.bbor.common.models.Coords;
import java.awt.*;
@Override
public void render(BoundingBoxMobSpawner boundingBox) {
Coords coords = boundingBox.getCoords();
- Color color = boundingBox.getColor();
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
renderCuboid(new OffsetBox(coords, coords), color);
OffsetPoint playerPos = new OffsetPoint(Player.getPoint());
double distance = centerPoint.getDistance(playerPos);
if (distance <= 20) {
- Color color = distance > 18 ? Color.RED : distance > 16 ? Colors.DARK_ORANGE : Color.GREEN;
OffsetPoint playerPoint = playerPos.offset(0, 0.1, 0);
- renderLine(centerPoint, playerPoint, color);
+ renderLine(centerPoint, playerPoint, getColor(distance));
}
}
+
+ private Color getColor(double distance) {
+ if (distance > 18) return ColorHelper.getColor(ConfigManager.colorMobSpawnersLineFarAway);
+ if (distance > 16) return ColorHelper.getColor(ConfigManager.colorMobSpawnersLineNearby);
+ return ColorHelper.getColor(ConfigManager.colorMobSpawnersLineActive);
+ }
}
package com.irtimaled.bbor.client.renderers;
import com.irtimaled.bbor.client.Player;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.models.BoundingBoxSlimeChunk;
@Override
public void render(BoundingBoxSlimeChunk boundingBox) {
OffsetBox bb = new OffsetBox(boundingBox.getMinCoords(), boundingBox.getMaxCoords());
- Color color = boundingBox.getColor();
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
renderCuboid(bb, color);
double maxY = Player.getMaxY(ConfigManager.slimeChunkMaxY.get());
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.client.models.BoundingBoxSpawnableBlocks;
+import java.awt.*;
+
public class SpawnableBlocksRenderer extends AbstractRenderer<BoundingBoxSpawnableBlocks> {
@Override
public void render(BoundingBoxSpawnableBlocks boundingBox) {
- boundingBox.getBlocks().forEach(c -> {
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
+ boundingBox.getBlocks().forEach(c -> {
int x = c.getX();
int y = c.getY();
int z = c.getZ();
OffsetBox offsetBox = new OffsetBox(x, y, z, x + 1, y, z + 1);
- renderCuboid(offsetBox, boundingBox.getColor());
+ renderCuboid(offsetBox, color);
});
}
}
package com.irtimaled.bbor.client.renderers;
import com.irtimaled.bbor.client.Player;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
+import com.irtimaled.bbor.client.config.ColorHelper;
import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.models.BoundingBoxSpawningSphere;
+import com.irtimaled.bbor.common.BoundingBoxType;
import com.irtimaled.bbor.common.models.Point;
import net.minecraft.client.resources.I18n;
OffsetPoint sphereCenter = new OffsetPoint(point);
OffsetBox offsetBox = new OffsetBox(sphereCenter, sphereCenter).grow(0.5, 0, 0.5);
- renderCuboid(offsetBox, Color.GREEN);
+ Color safeAreaColor = ColorHelper.getColor(ConfigManager.colorAFKSpheresSafeArea);
+ renderCuboid(offsetBox, safeAreaColor);
Integer spawnableSpacesCount = boundingBox.getSpawnableSpacesCount();
if (spawnableSpacesCount != null) {
String.format("%,d", spawnableSpacesCount));
}
- renderSphere(point, BoundingBoxSpawningSphere.SAFE_RADIUS, Color.GREEN, 5, 5);
- renderSphere(point, BoundingBoxSpawningSphere.SPAWN_RADIUS, Color.RED, 5, 5);
+ renderSphere(point, BoundingBoxSpawningSphere.SAFE_RADIUS, safeAreaColor, 5, 5);
+
+ renderOuterSphere(boundingBox, point);
if (ConfigManager.renderAFKSpawnableBlocks.get() && boundingBox.isWithinSphere(Player.getPoint())) {
renderSpawnableSpaces(boundingBox);
}
}
+ private void renderOuterSphere(BoundingBoxSpawningSphere boundingBox, Point point) {
+ Color color = BoundingBoxTypeHelper.getColor(boundingBox.getType());
+ renderSphere(point, BoundingBoxSpawningSphere.SPAWN_RADIUS, color, 5, 5);
+ }
+
private void renderSpawnableSpaces(BoundingBoxSpawningSphere boundingBox) {
+ Color color = BoundingBoxTypeHelper.getColor(BoundingBoxType.SpawnableBlocks);
boundingBox.getBlocks().forEach(c -> {
int x = c.getX();
int y = c.getY();
int z = c.getZ();
OffsetBox offsetBox = new OffsetBox(x, y, z, x + 1, y, z + 1);
- renderCuboid(offsetBox, boundingBox.getColor());
+ renderCuboid(offsetBox, color);
});
}
}
package com.irtimaled.bbor.client.renderers;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.common.models.BoundingBoxSphere;
import com.irtimaled.bbor.common.models.Point;
public void render(BoundingBoxSphere boundingBox) {
Point point = boundingBox.getPoint();
double radius = boundingBox.getRadius();
- renderSphere(point, radius, boundingBox.getColor(), 5, 5);
+ renderSphere(point, radius, BoundingBoxTypeHelper.getColor(boundingBox.getType()), 5, 5);
}
}
package com.irtimaled.bbor.client.renderers;
import com.irtimaled.bbor.client.Player;
+import com.irtimaled.bbor.client.config.BoundingBoxTypeHelper;
import com.irtimaled.bbor.client.config.ConfigManager;
import com.irtimaled.bbor.client.models.BoundingBoxWorldSpawn;
import com.irtimaled.bbor.common.models.Coords;
-import java.awt.*;
-
public class WorldSpawnRenderer extends AbstractRenderer<BoundingBoxWorldSpawn> {
@Override
public void render(BoundingBoxWorldSpawn boundingBox) {
- Color color = boundingBox.getColor();
Coords minCoords = boundingBox.getMinCoords();
Coords maxCoords = boundingBox.getMaxCoords();
double y = Player.getMaxY(ConfigManager.worldSpawnMaxY.get());
OffsetBox offsetBox = new OffsetBox(minCoords.getX(), y, minCoords.getZ(), maxCoords.getX(), y, maxCoords.getZ());
- renderOutlinedCuboid(offsetBox.nudge(), color);
+ renderOutlinedCuboid(offsetBox.nudge(), BoundingBoxTypeHelper.getColor(boundingBox.getType()));
}
}
package com.irtimaled.bbor.common;
-import com.irtimaled.bbor.common.models.Colors;
-
-import java.awt.*;
import java.util.HashMap;
import java.util.Map;
public class BoundingBoxType {
private static final Map<Integer, BoundingBoxType> structureTypeMap = new HashMap<>();
- public static final BoundingBoxType WorldSpawn = register(Color.RED, "World_Spawn");
- public static final BoundingBoxType SpawnChunks = register(Color.RED, "Spawn_Chunks");
- public static final BoundingBoxType LazySpawnChunks = register(Color.RED, "Lazy_Chunks");
- public static final BoundingBoxType MobSpawner = register(Color.GREEN, "Mob_Spawner");
- public static final BoundingBoxType SlimeChunks = register(Colors.DARK_GREEN, "Slime_Chunks");
- public static final BoundingBoxType AFKSphere = register(Color.RED, "AFK Sphere");
- public static final BoundingBoxType BiomeBorder = register(Color.GREEN, "Biome Border");
- public static final BoundingBoxType Custom = register(Color.WHITE, "Custom");
- public static final BoundingBoxType Beacon = register(Color.WHITE, "Beacon");
- public static final BoundingBoxType Conduit = register(Color.CYAN, "Conduit");
- public static final BoundingBoxType SpawnableBlocks = register(Color.RED, "Spawnable Blocks");
+ public static final BoundingBoxType WorldSpawn = register("World_Spawn");
+ public static final BoundingBoxType SpawnChunks = register("Spawn_Chunks");
+ public static final BoundingBoxType LazySpawnChunks = register("Lazy_Chunks");
+ public static final BoundingBoxType MobSpawner = register("Mob_Spawner");
+ public static final BoundingBoxType SlimeChunks = register("Slime_Chunks");
+ public static final BoundingBoxType AFKSphere = register("AFK Sphere");
+ public static final BoundingBoxType BiomeBorder = register("Biome Border");
+ public static final BoundingBoxType Custom = register("Custom");
+ public static final BoundingBoxType Beacon = register("Beacon");
+ public static final BoundingBoxType Conduit = register("Conduit");
+ public static final BoundingBoxType SpawnableBlocks = register("Spawnable Blocks");
- public static final BoundingBoxType JungleTemple = register(Colors.DARK_GREEN, "Jungle_Pyramid");
- public static final BoundingBoxType DesertTemple = register(Color.ORANGE, "Desert_Pyramid");
- public static final BoundingBoxType WitchHut = register(Color.BLUE, "Swamp_Hut");
- public static final BoundingBoxType OceanMonument = register(Color.CYAN, "Monument");
- public static final BoundingBoxType Shipwreck = register(Color.CYAN, "Shipwreck");
- public static final BoundingBoxType OceanRuin = register(Color.CYAN, "Ocean_Ruin");
- public static final BoundingBoxType BuriedTreasure = register(Color.CYAN, "Buried_Treasure");
- public static final BoundingBoxType Stronghold = register(Color.YELLOW, "Stronghold");
- public static final BoundingBoxType MineShaft = register(Color.LIGHT_GRAY, "Mineshaft");
- public static final BoundingBoxType NetherFortress = register(Color.RED, "Fortress");
- public static final BoundingBoxType EndCity = register(Color.MAGENTA, "EndCity");
- public static final BoundingBoxType Mansion = register(Colors.BROWN, "Mansion");
- public static final BoundingBoxType Igloo = register(Color.WHITE, "Igloo");
- public static final BoundingBoxType PillagerOutpost = register(Color.DARK_GRAY, "Pillager_Outpost");
- public static final BoundingBoxType Village = register(Colors.PURPLE, "Village");
- public static final BoundingBoxType VillageSpheres = register(null, "Village Sphere");
- public static final BoundingBoxType NetherFossil = register(Color.WHITE, "Nether_Fossil");
- public static final BoundingBoxType BastionRemnant = register(Color.LIGHT_GRAY, "Bastion_Remnant");
- public static final BoundingBoxType RuinedPortal = register(Colors.COOL_PURPLE, "Ruined_Portal");
+ public static final BoundingBoxType JungleTemple = register("Jungle_Pyramid");
+ public static final BoundingBoxType DesertTemple = register("Desert_Pyramid");
+ public static final BoundingBoxType WitchHut = register("Swamp_Hut");
+ public static final BoundingBoxType OceanMonument = register("Monument");
+ public static final BoundingBoxType Shipwreck = register("Shipwreck");
+ public static final BoundingBoxType OceanRuin = register("Ocean_Ruin");
+ public static final BoundingBoxType BuriedTreasure = register("Buried_Treasure");
+ public static final BoundingBoxType Stronghold = register("Stronghold");
+ public static final BoundingBoxType MineShaft = register("Mineshaft");
+ public static final BoundingBoxType NetherFortress = register("Fortress");
+ public static final BoundingBoxType EndCity = register("EndCity");
+ public static final BoundingBoxType Mansion = register("Mansion");
+ public static final BoundingBoxType Igloo = register("Igloo");
+ public static final BoundingBoxType PillagerOutpost = register("Pillager_Outpost");
+ public static final BoundingBoxType Village = register("Village");
+ public static final BoundingBoxType VillageSpheres = register("Village Sphere");
+ public static final BoundingBoxType NetherFossil = register("Nether_Fossil");
+ public static final BoundingBoxType BastionRemnant = register("Bastion_Remnant");
+ public static final BoundingBoxType RuinedPortal = register("Ruined_Portal");
- private static BoundingBoxType register(Color color, String name) {
- BoundingBoxType type = structureTypeMap.computeIfAbsent(name.hashCode(), k -> new BoundingBoxType(color, name));
+ private static BoundingBoxType register(String name) {
+ BoundingBoxType type = structureTypeMap.computeIfAbsent(name.hashCode(), k -> new BoundingBoxType(name));
StructureProcessor.registerSupportedStructure(type);
return type;
}
return structureTypeMap.get(nameHash);
}
- private final Color color;
private final String name;
- private BoundingBoxType(Color color, String name) {
- this.color = color;
+ private BoundingBoxType(String name) {
this.name = name;
}
- public Color getColor() {
- return color;
- }
-
public String getName() {
return name;
}
import com.irtimaled.bbor.common.BoundingBoxType;
-import java.awt.*;
-
public abstract class AbstractBoundingBox {
private final BoundingBoxType type;
this.type = type;
}
- public Color getColor() {
- return type.getColor();
- }
-
public abstract Boolean intersectsBounds(int minX, int minZ, int maxX, int maxZ);
public BoundingBoxType getType() {
+++ /dev/null
-package com.irtimaled.bbor.common.models;
-
-import java.awt.*;
-
-public class Colors {
- public static final Color DARK_ORANGE = new Color(255, 127, 0);
- public static final Color DARK_GREEN = new Color(0, 96, 0);
- public static final Color BROWN = new Color(139, 69, 19);
- public static final Color PURPLE = new Color(128, 0, 128);
- public static final Color COOL_PURPLE = new Color(200, 0, 255);
-}
projects / BoundingBoxOutlineReloaded.git / commitdiff