refactor, cleanup, integrated tagless into lumiscope

src/main/java/com/lumijiez/lumiscope/Lumiscope.java

@@ -1,10 +1,15 @@
 package com.lumijiez.lumiscope;
 
-import com.lumijiez.lumiscope.handlers.RadarPacketHandler;
+import com.lumijiez.lumiscope.handlers.radar.LongRadarPacketHandler;
-import com.lumijiez.lumiscope.render.ShortRadarRenderer;
+import com.lumijiez.lumiscope.handlers.radar.ShortRadarPacketHandler;
+import com.lumijiez.lumiscope.render.radar.LongRadarRenderer;
+import com.lumijiez.lumiscope.render.radar.ShortRadarRenderer;
 import com.lumijiez.lumiscope.proxy.CommonProxy;
 import com.lumijiez.lumiscope.util.Ref;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraftforge.client.event.RenderLivingEvent;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.fml.common.FMLCommonHandler;
 import net.minecraftforge.fml.common.Mod;
@@ -16,6 +21,7 @@ import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
 
 import static com.lumijiez.lumiscope.util.Ref.logger;
 
@@ -24,11 +30,18 @@ public class Lumiscope {
     @SidedProxy(clientSide = Ref.CLIENT_PROXY_CLASS, serverSide = Ref.COMMON_PROXY_CLASS)
     public static CommonProxy proxy;
 
+    @SideOnly(Side.CLIENT)
+    @SubscribeEvent
+    public void onRenderNameTag(RenderLivingEvent.Specials.Pre<EntityLivingBase> event) {
+        if (event.getEntity() instanceof EntityPlayer) event.setCanceled(true);
+    }
+
     @EventHandler
     public void preInit(FMLPreInitializationEvent event)
     {
         MinecraftForge.EVENT_BUS.register(this);
-        RadarPacketHandler.registerMessages();
+        ShortRadarPacketHandler.registerMessages();
+        LongRadarPacketHandler.registerMessages();
     }
 
     @EventHandler
@@ -36,6 +49,7 @@ public class Lumiscope {
     {
         if (event.getSide() == Side.CLIENT) {
             MinecraftForge.EVENT_BUS.register(ShortRadarRenderer.getInstance());
+            MinecraftForge.EVENT_BUS.register(LongRadarRenderer.getInstance());
         }
     }
 
@@ -49,7 +63,8 @@ public class Lumiscope {
     public void onServerTick(TickEvent.ServerTickEvent event) {
         if (event.phase == TickEvent.Phase.END) {
             for (EntityPlayerMP player : FMLCommonHandler.instance().getMinecraftServerInstance().getPlayerList().getPlayers()) {
-                RadarPacketHandler.sendRadarUpdate(player);
+                ShortRadarPacketHandler.sendRadarUpdate(player);
+                LongRadarPacketHandler.sendRadarUpdate(player);
             }
         }
     }

src/main/java/com/lumijiez/lumiscope/handlers/RadarPacketHandler.java

@@ -1,45 +0,0 @@
-package com.lumijiez.lumiscope.handlers;
-
-import com.lumijiez.lumiscope.items.radars.ShortRadar;
-import com.lumijiez.lumiscope.network.RadarPacket;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.util.math.MathHelper;
-import net.minecraftforge.fml.common.network.NetworkRegistry;
-import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
-import net.minecraftforge.fml.relauncher.Side;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class RadarPacketHandler {
-    public static final SimpleNetworkWrapper INSTANCE = NetworkRegistry.INSTANCE.newSimpleChannel("lumiscope");
-
-    public static void registerMessages() {
-        INSTANCE.registerMessage(RadarPacket.Handler.class, RadarPacket.class, 0, Side.CLIENT);
-    }
-
-    public static void sendRadarUpdate(EntityPlayerMP player) {
-        if (!(player.getHeldItemMainhand().getItem() instanceof ShortRadar)) {
-            return;
-        }
-        List<RadarPacket.PlayerInfo> playerInfos = new ArrayList<>();
-        for (EntityPlayerMP otherPlayer : player.getServerWorld().getMinecraftServer().getPlayerList().getPlayers()) {
-            if (!otherPlayer.equals(player) && player.getDistance(otherPlayer) <= 100) {
-                double direction = getPlayerDirection(player, otherPlayer);
-                playerInfos.add(new RadarPacket.PlayerInfo(otherPlayer.getName(), direction, player.getDistance(otherPlayer)));
-            }
-        }
-        INSTANCE.sendTo(new RadarPacket(playerInfos), player);
-    }
-
-    private static double getPlayerDirection(EntityPlayerMP player, EntityPlayerMP otherPlayer) {
-        double deltaX = otherPlayer.posX - player.posX;
-        double deltaZ = otherPlayer.posZ - player.posZ;
-
-        double angle = MathHelper.atan2(deltaZ, deltaX) * (180 / Math.PI) - 90;
-        if (angle < 0) angle += 360;
-
-        angle = (angle + 180) % 360;
-        return Math.toRadians(angle);
-    }
-}

src/main/java/com/lumijiez/lumiscope/handlers/radar/LongRadarPacketHandler.java

@@ -0,0 +1,48 @@
+package com.lumijiez.lumiscope.handlers.radar;
+
+import com.lumijiez.lumiscope.items.radars.LongRadar;
+import com.lumijiez.lumiscope.network.LongRadarPacket;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraftforge.fml.common.network.NetworkRegistry;
+import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
+import net.minecraftforge.fml.relauncher.Side;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static com.lumijiez.lumiscope.util.CustomMath.getPlayerDirectionLong;
+
+public class LongRadarPacketHandler {
+    private static final SimpleNetworkWrapper NETWORK_CHANNEL = NetworkRegistry.INSTANCE.newSimpleChannel("long_radar");
+
+    public static void registerMessages() {
+        NETWORK_CHANNEL.registerMessage(LongRadarPacket.Handler.class, LongRadarPacket.class, 0, Side.CLIENT);
+    }
+
+    public static void sendRadarUpdate(EntityPlayerMP player) {
+        if (isHoldingLongRadar(player)) {
+            List<LongRadarPacket.PlayerInfo> playerInfos = getNearbyPlayersInfo(player);
+            NETWORK_CHANNEL.sendTo(new LongRadarPacket(playerInfos), player);
+        }
+    }
+
+    private static boolean isHoldingLongRadar(EntityPlayerMP player) {
+        return player.getHeldItemMainhand().getItem() instanceof LongRadar;
+    }
+
+    private static List<LongRadarPacket.PlayerInfo> getNearbyPlayersInfo(EntityPlayerMP player) {
+        return Objects.requireNonNull(player.getServerWorld().getMinecraftServer()).getPlayerList().getPlayers().stream()
+                .filter(otherPlayer -> shouldIncludePlayer(player, otherPlayer))
+                .map(otherPlayer -> new LongRadarPacket.PlayerInfo(
+                        otherPlayer.getName(),
+                        getPlayerDirectionLong(player, otherPlayer),
+                        player.getDistance(otherPlayer)
+                ))
+                .collect(Collectors.toList());
+    }
+
+    private static boolean shouldIncludePlayer(EntityPlayerMP player, EntityPlayerMP otherPlayer) {
+        return !otherPlayer.equals(player) && player.getDistance(otherPlayer) >= 300;
+    }
+}

src/main/java/com/lumijiez/lumiscope/handlers/radar/ShortRadarPacketHandler.java

@@ -0,0 +1,51 @@
+package com.lumijiez.lumiscope.handlers.radar;
+
+import com.lumijiez.lumiscope.items.radars.ShortRadar;
+import com.lumijiez.lumiscope.network.ShortRadarPacket;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.MobEffects;
+import net.minecraftforge.fml.common.network.NetworkRegistry;
+import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
+import net.minecraftforge.fml.relauncher.Side;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static com.lumijiez.lumiscope.util.CustomMath.getPlayerDirectionShort;
+
+public class ShortRadarPacketHandler {
+    private static final SimpleNetworkWrapper NETWORK_CHANNEL = NetworkRegistry.INSTANCE.newSimpleChannel("short_radar");
+
+    public static void registerMessages() {
+        NETWORK_CHANNEL.registerMessage(ShortRadarPacket.Handler.class, ShortRadarPacket.class, 0, Side.CLIENT);
+    }
+
+    public static void sendRadarUpdate(EntityPlayerMP player) {
+        if (isHoldingShortRadar(player)) {
+            List<ShortRadarPacket.PlayerInfo> playerInfos = getNearbyPlayersInfo(player);
+            NETWORK_CHANNEL.sendTo(new ShortRadarPacket(playerInfos), player);
+        }
+    }
+
+    private static boolean isHoldingShortRadar(EntityPlayerMP player) {
+        return player.getHeldItemMainhand().getItem() instanceof ShortRadar;
+    }
+
+    private static List<ShortRadarPacket.PlayerInfo> getNearbyPlayersInfo(EntityPlayerMP player) {
+        return Objects.requireNonNull(player.getServerWorld().getMinecraftServer()).getPlayerList().getPlayers().stream()
+                .filter(otherPlayer -> shouldIncludePlayer(player, otherPlayer))
+                .map(otherPlayer -> new ShortRadarPacket.PlayerInfo(
+                        otherPlayer.getName(),
+                        getPlayerDirectionShort(player, otherPlayer),
+                        player.getDistance(otherPlayer)
+                ))
+                .collect(Collectors.toList());
+    }
+
+    private static boolean shouldIncludePlayer(EntityPlayerMP player, EntityPlayerMP otherPlayer) {
+        return !otherPlayer.equals(player) &&
+                player.getDistance(otherPlayer) <= 100 &&
+                !player.isPotionActive(MobEffects.INVISIBILITY);
+    }
+}

src/main/java/com/lumijiez/lumiscope/items/radars/LongRadar.java

@@ -2,12 +2,7 @@ package com.lumijiez.lumiscope.items.radars;
 
 import com.lumijiez.lumiscope.items.ItemBase;
 import net.minecraft.client.util.ITooltipFlag;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.init.MobEffects;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.EnumActionResult;
-import net.minecraft.util.EnumHand;
 import net.minecraft.util.text.ITextComponent;
 import net.minecraft.util.text.Style;
 import net.minecraft.util.text.TextComponentString;
@@ -15,11 +10,10 @@ import net.minecraft.util.text.TextFormatting;
 import net.minecraft.world.World;
 
 import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
 import java.util.List;
-import java.util.Random;
 
 public class LongRadar extends ItemBase {
-    private static final Random RANDOM = new Random();
 
     public LongRadar() {
         super("long_radar");
@@ -27,6 +21,7 @@ public class LongRadar extends ItemBase {
     }
 
     @Override
+    @ParametersAreNonnullByDefault
     public void addInformation(ItemStack stack, @Nullable World worldIn, List<String> tooltip, ITooltipFlag flagIn) {
         ITextComponent info = new TextComponentString("Checks for faraway players.")
                 .setStyle(new Style().setColor(TextFormatting.AQUA));
@@ -42,67 +37,4 @@ public class LongRadar extends ItemBase {
 
         super.addInformation(stack, worldIn, tooltip, flagIn);
     }
-
-    @Override
-    public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) {
-        if (!world.isRemote) {
-            player.getHeldItem(hand).damageItem(1, player);
-
-            ITextComponent warningMessage = new TextComponentString("WARNING: Cannot detect players less than 300 meters from you!")
-                    .setStyle(new Style().setColor(TextFormatting.RED));
-            player.sendMessage(warningMessage);
-
-            boolean playerNearby = false;
-
-            for (EntityPlayer otherPlayer : world.playerEntities) {
-                if (!otherPlayer.equals(player)
-                    && otherPlayer.getActivePotionEffects().stream()
-                        .noneMatch(potionEffect -> potionEffect.getPotion() == MobEffects.INVISIBILITY)) {
-
-                    double deltaX = otherPlayer.posX - player.posX;
-                    double deltaZ = otherPlayer.posZ - player.posZ;
-                    double distance = Math.sqrt(deltaX * deltaX + deltaZ * deltaZ);
-
-                    if (distance <= 300) continue;
-
-                    double angle = Math.atan2(deltaZ, deltaX);
-                    double angleDegrees = Math.toDegrees(angle) - 90;
-                    angleDegrees = (angleDegrees + 360) % 360;
-
-                    angleDegrees = (angleDegrees > 180) ? angleDegrees - 360 : angleDegrees;
-
-                    double margin = RANDOM.nextDouble() * 20;
-                    double halfMargin = margin / 2;
-
-                    double startAngle = (angleDegrees - halfMargin + 360) % 360;
-                    startAngle = (startAngle > 180) ? startAngle - 360 : startAngle;
-
-                    double endAngle = (angleDegrees + halfMargin + 360) % 360;
-                    endAngle = (endAngle > 180) ? endAngle - 360 : endAngle;
-
-                    String distanceMessage = distance > 500000 ? " (extremely far)" :
-                            distance > 50000 ? " (very far)" :
-                                    distance > 5000 ? " (far)" : "";
-
-
-                    ITextComponent intervalMessage;
-
-                    intervalMessage = new TextComponentString(String.format("Look in the interval of %.1f - %.1f degrees%s", startAngle, endAngle, distanceMessage))
-                            .setStyle(new Style().setColor(TextFormatting.GREEN));
-
-                    player.sendMessage(intervalMessage);
-                    playerNearby = true;
-                }
-            }
-
-            if (!playerNearby) {
-                ITextComponent noPlayersMessage = new TextComponentString("No players found.")
-                        .setStyle(new Style().setColor(TextFormatting.GRAY));
-                player.sendMessage(noPlayersMessage);
-            }
-
-            player.getCooldownTracker().setCooldown(this, 3600);
-        }
-        return new ActionResult<>(EnumActionResult.SUCCESS, player.getHeldItem(hand));
-    }
 }

src/main/java/com/lumijiez/lumiscope/items/radars/ShortRadar.java

@@ -2,17 +2,14 @@ package com.lumijiez.lumiscope.items.radars;
 
 import com.lumijiez.lumiscope.items.ItemBase;
 import net.minecraft.client.util.ITooltipFlag;
-import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.ItemStack;
-import net.minecraft.util.ActionResult;
-import net.minecraft.util.EnumActionResult;
-import net.minecraft.util.EnumHand;
 import net.minecraft.util.text.Style;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraft.world.World;
 
 import javax.annotation.Nullable;
+import javax.annotation.ParametersAreNonnullByDefault;
 import java.util.List;
 
 public class ShortRadar extends ItemBase {
@@ -22,12 +19,13 @@ public class ShortRadar extends ItemBase {
     }
 
     @Override
+    @ParametersAreNonnullByDefault
     public void addInformation(ItemStack stack, @Nullable World worldIn, List<String> tooltip, ITooltipFlag flagIn) {
         tooltip.add(new TextComponentString("Checks for nearby players.")
                 .setStyle(new Style().setColor(TextFormatting.AQUA)).getFormattedText());
 
-        tooltip.add(new TextComponentString("Does not detect invisible players!")
+        tooltip.add(new TextComponentString("Does detect invisible players!")
-                .setStyle(new Style().setColor(TextFormatting.DARK_RED).setBold(true).setItalic(true)).getFormattedText());
+                .setStyle(new Style().setColor(TextFormatting.GREEN).setBold(true).setItalic(true)).getFormattedText());
 
         super.addInformation(stack, worldIn, tooltip, flagIn);
     }

src/main/java/com/lumijiez/lumiscope/network/LongRadarPacket.java

@@ -0,0 +1,73 @@
+package com.lumijiez.lumiscope.network;
+
+import com.lumijiez.lumiscope.render.radar.LongRadarRenderer;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.client.Minecraft;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LongRadarPacket implements IMessage {
+    public static class PlayerInfo {
+        public String name;
+        public double direction;
+        public double distance;
+
+        public PlayerInfo(String name, double direction, double distance) {
+            this.name = "none";
+            this.direction = direction;
+            this.distance = 0;
+        }
+    }
+
+    private List<PlayerInfo> playerInfos;
+
+    public LongRadarPacket() {
+        this.playerInfos = new ArrayList<>();
+    }
+
+    public LongRadarPacket(List<PlayerInfo> playerInfos) {
+        this.playerInfos = playerInfos;
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(playerInfos.size());
+        for (PlayerInfo info : playerInfos) {
+            byte[] nameBytes = info.name.getBytes();
+            buf.writeInt(nameBytes.length);
+            buf.writeBytes(nameBytes);
+            buf.writeDouble(info.direction);
+            buf.writeDouble(info.distance);
+        }
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        int size = buf.readInt();
+        playerInfos = new ArrayList<>(size);
+        for (int i = 0; i < size; i++) {
+            int nameLength = buf.readInt();
+            byte[] nameBytes = new byte[nameLength];
+            buf.readBytes(nameBytes);
+            String name = new String(nameBytes);
+            double direction = buf.readDouble();
+            double distance = buf.readDouble();
+            playerInfos.add(new PlayerInfo(name, direction, distance));
+        }
+    }
+
+    public static class Handler implements IMessageHandler<LongRadarPacket, IMessage> {
+        @Override
+        public IMessage onMessage(LongRadarPacket message, MessageContext ctx) {
+            Minecraft.getMinecraft().addScheduledTask(() -> {
+                LongRadarRenderer renderer = LongRadarRenderer.getInstance();
+                renderer.updatePlayerInfos(message.playerInfos);
+            });
+            return null;
+        }
+    }
+}

src/main/java/com/lumijiez/lumiscope/network/ShortRadarPacket.java

@@ -1,6 +1,6 @@
 package com.lumijiez.lumiscope.network;
 
-import com.lumijiez.lumiscope.render.ShortRadarRenderer;
+import com.lumijiez.lumiscope.render.radar.ShortRadarRenderer;
 import io.netty.buffer.ByteBuf;
 import net.minecraft.client.Minecraft;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
@@ -10,7 +10,7 @@ import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import java.util.ArrayList;
 import java.util.List;
 
-public class RadarPacket implements IMessage {
+public class ShortRadarPacket implements IMessage {
     public static class PlayerInfo {
         public String name;
         public double direction;
@@ -25,11 +25,11 @@ public class RadarPacket implements IMessage {
 
     private List<PlayerInfo> playerInfos;
 
-    public RadarPacket() {
+    public ShortRadarPacket() {
         this.playerInfos = new ArrayList<>();
     }
 
-    public RadarPacket(List<PlayerInfo> playerInfos) {
+    public ShortRadarPacket(List<PlayerInfo> playerInfos) {
         this.playerInfos = playerInfos;
     }
 
@@ -60,9 +60,9 @@ public class RadarPacket implements IMessage {
         }
     }
 
-    public static class Handler implements IMessageHandler<RadarPacket, IMessage> {
+    public static class Handler implements IMessageHandler<ShortRadarPacket, IMessage> {
         @Override
-        public IMessage onMessage(RadarPacket message, MessageContext ctx) {
+        public IMessage onMessage(ShortRadarPacket message, MessageContext ctx) {
             Minecraft.getMinecraft().addScheduledTask(() -> {
                 ShortRadarRenderer renderer = ShortRadarRenderer.getInstance();
                 renderer.updatePlayerInfos(message.playerInfos);

src/main/java/com/lumijiez/lumiscope/render/ShortRadarRenderer.java

@@ -1,177 +0,0 @@
-package com.lumijiez.lumiscope.render;
-
-import com.lumijiez.lumiscope.items.radars.ShortRadar;
-import com.lumijiez.lumiscope.network.RadarPacket;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.GlStateManager;
-import net.minecraft.client.renderer.RenderHelper;
-import net.minecraft.util.ResourceLocation;
-import net.minecraftforge.client.event.RenderHandEvent;
-import net.minecraftforge.client.event.RenderWorldLastEvent;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-import net.minecraftforge.items.wrapper.PlayerOffhandInvWrapper;
-import org.lwjgl.opengl.GL11;
-
-import java.awt.*;
-import java.util.List;
-
-@SideOnly(Side.CLIENT)
-public class ShortRadarRenderer {
-    private static final Minecraft mc = Minecraft.getMinecraft();
-    private static final ShortRadarRenderer INSTANCE = new ShortRadarRenderer();
-    private final ResourceLocation radarTexture = new ResourceLocation("lumiscope", "textures/gui/radar.png");
-    private final ResourceLocation radarArrowTexture = new ResourceLocation("lumiscope", "textures/gui/radar_arrow.png");
-    private List<RadarPacket.PlayerInfo> playerInfos;
-
-    private ShortRadarRenderer() {}
-
-    public static ShortRadarRenderer getInstance() {
-        return INSTANCE;
-    }
-
-    public void updatePlayerInfos(List<RadarPacket.PlayerInfo> playerInfos) {
-        this.playerInfos = playerInfos;
-    }
-
-    @SubscribeEvent
-    public void onRenderWorldLast(RenderWorldLastEvent event) {
-        if (shouldRenderRadar()) {
-            if (playerInfos != null && !playerInfos.isEmpty()) {
-                renderRadar(event.getPartialTicks());
-            }
-        }
-    }
-
-    @SubscribeEvent
-    public void onRenderPlayerHand(RenderHandEvent event) {
-        if (mc.player.getHeldItemMainhand().getItem() instanceof ShortRadar) {
-            event.setCanceled(true);
-        }
-    }
-
-    private boolean shouldRenderRadar() {
-        return mc.player.getHeldItemMainhand().getItem() instanceof ShortRadar ||
-                mc.player.getHeldItemOffhand().getItem() instanceof ShortRadar;
-    }
-
-    private void renderRadar(float partialTicks) {
-        GlStateManager.pushMatrix();
-        GlStateManager.translate(0, 0.01, 0);
-
-        mc.getTextureManager().bindTexture(radarTexture);
-
-        GlStateManager.disableDepth();
-        GlStateManager.disableLighting();
-        GlStateManager.disableCull();
-
-        GlStateManager.enableBlend();
-        GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GlStateManager.color(1.0f, 1.0f, 1.0f, 0.5f);
-
-        drawTexturedCircle(1.4f);
-
-        for (RadarPacket.PlayerInfo info : playerInfos) {
-            double angle = info.direction - Math.toRadians(90);
-            drawTexturedLine(1.4f, angle);
-        }
-        GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f);
-        GlStateManager.disableBlend();
-
-        RenderHelper.disableStandardItemLighting();
-        GlStateManager.enableTexture2D();
-        GlStateManager.enableCull();
-        for (RadarPacket.PlayerInfo info : playerInfos) {
-            double angle = info.direction - Math.toRadians(90);
-            GlStateManager.pushMatrix();
-            GlStateManager.translate((float) (Math.cos(angle) * 1.2), 0.001, (float) (Math.sin(angle) * 1.2));
-            GlStateManager.rotate(90f, 1, 0, 0);
-
-            GlStateManager.rotate((float) Math.toDegrees(angle), 0, 0, 1);
-            GlStateManager.scale(0.01, 0.01, 0.01);
-
-            mc.fontRenderer.drawStringWithShadow(info.name, -mc.fontRenderer.getStringWidth(info.name) - 50 , -4, 0x808080);
-            mc.fontRenderer.drawStringWithShadow("(" + (int) info.distance +"m)", -mc.fontRenderer.getStringWidth(info.name) + 5 , -4, interpolateColor(100, 0, (int) info.distance));
-
-            GlStateManager.popMatrix();
-        }
-        GlStateManager.disableCull();
-        GlStateManager.disableTexture2D();
-        RenderHelper.enableStandardItemLighting();
-
-        GlStateManager.enableDepth();
-        GlStateManager.enableLighting();
-        GlStateManager.enableCull();
-        GlStateManager.disableBlend();
-        GlStateManager.popMatrix();
-    }
-
-    private void drawTexturedCircle(float radius) {
-        mc.getTextureManager().bindTexture(radarTexture);
-
-        GlStateManager.enableTexture2D();
-
-        GlStateManager.glBegin(GL11.GL_TRIANGLE_FAN);
-
-        GlStateManager.glTexCoord2f(0.5f, 0.5f);
-        GlStateManager.glVertex3f(0, 0, 0);
-
-        for (int i = 0; i <= 360; i++) {
-            double rad = Math.toRadians(i);
-            float x = (float) (Math.cos(rad) * radius);
-            float y = (float) (Math.sin(rad) * radius);
-
-            float u = (x / radius + 1.0f) / 2.0f;
-            float v = (y / radius + 1.0f) / 2.0f;
-
-            GlStateManager.glTexCoord2f(u, v);
-            GlStateManager.glVertex3f(x, 0, y);
-        }
-
-        GlStateManager.glEnd();
-
-        GlStateManager.disableTexture2D();
-    }
-
-    private void drawTexturedLine(float length, double angle) {
-        mc.getTextureManager().bindTexture(radarArrowTexture);
-
-        GlStateManager.enableTexture2D();
-
-        GlStateManager.pushMatrix();
-        GlStateManager.translate((float) (Math.cos(angle) * length / 2), 0, (float) (Math.sin(angle) * length / 2));
-        GlStateManager.rotate(90f, 1, 0, 0);
-        GlStateManager.rotate((float) Math.toDegrees(angle) + 90, 0, 0, 1);
-        GlStateManager.scale(0.2, length, 1);
-
-        GlStateManager.glBegin(GL11.GL_QUADS);
-
-        GlStateManager.glTexCoord2f(0, 0);
-        GlStateManager.glVertex3f(-0.5f, -0.5f, 0);
-        GlStateManager.glTexCoord2f(1, 0);
-        GlStateManager.glVertex3f(0.5f, -0.5f, 0);
-        GlStateManager.glTexCoord2f(1, 1);
-        GlStateManager.glVertex3f(0.5f, 0.5f, 0);
-        GlStateManager.glTexCoord2f(0, 1);
-        GlStateManager.glVertex3f(-0.5f, 0.5f, 0);
-
-        GlStateManager.glEnd();
-
-        GlStateManager.popMatrix();
-
-        GlStateManager.disableTexture2D();
-    }
-
-    private int interpolateColor(int maxDistance, int minDistance, int currentDistance) {
-        int clampedDistance = Math.max(minDistance, Math.min(maxDistance, currentDistance));
-        float ratio = (float) (maxDistance - clampedDistance) / (maxDistance - minDistance);
-
-        int r = (int) (ratio * 255);
-        int g = (int) ((1 - ratio) * 255);
-        int b = 0;
-
-        return new Color(r, g, b).getRGB();
-    }
-}

src/main/java/com/lumijiez/lumiscope/render/radar/BaseRadarRenderer.java

@@ -0,0 +1,103 @@
+package com.lumijiez.lumiscope.render.radar;
+
+import com.lumijiez.lumiscope.util.GLHelper;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.util.ResourceLocation;
+import org.lwjgl.opengl.GL11;
+
+import java.util.List;
+
+public abstract class BaseRadarRenderer<T> {
+
+    protected static final Minecraft mc = Minecraft.getMinecraft();
+    protected final ResourceLocation radarTexture = new ResourceLocation("lumiscope", "textures/gui/radar.png");
+    protected final ResourceLocation radarArrowTexture = new ResourceLocation("lumiscope", "textures/gui/radar_arrow.png");
+    protected List<T> playerInfos;
+
+    protected abstract void drawTexturedCircle(float radius);
+
+    protected abstract void drawTexturedLine(float length, double angle);
+
+    protected abstract double getDirection(T info);
+
+    protected abstract boolean shouldRenderRadar();
+
+    public void updatePlayerInfos(List<T> playerInfos) {
+        this.playerInfos = playerInfos;
+    }
+
+    protected void renderRadar(float partialTicks) {
+        GlStateManager.pushMatrix();
+        GlStateManager.translate(0, 0.01, 0);
+
+        mc.getTextureManager().bindTexture(radarTexture);
+
+        GLHelper.setupForRadarRendering();
+        drawTexturedCircle(1.4f);
+
+        for (T info : playerInfos) {
+            double angle = getDirection(info) - Math.toRadians(90);
+            drawTexturedLine(1.4f, angle);
+        }
+
+        GLHelper.cleanupAfterRadarRendering();
+        GlStateManager.popMatrix();
+    }
+
+    protected void drawTexturedCircleBase(float radius) {
+        mc.getTextureManager().bindTexture(radarTexture);
+
+        GlStateManager.enableTexture2D();
+
+        GlStateManager.glBegin(GL11.GL_TRIANGLE_FAN);
+
+        GlStateManager.glTexCoord2f(0.5f, 0.5f);
+        GlStateManager.glVertex3f(0, 0, 0);
+
+        for (int i = 0; i <= 360; i++) {
+            double rad = Math.toRadians(i);
+            float x = (float) (Math.cos(rad) * radius);
+            float y = (float) (Math.sin(rad) * radius);
+
+            float u = (x / radius + 1.0f) / 2.0f;
+            float v = (y / radius + 1.0f) / 2.0f;
+
+            GlStateManager.glTexCoord2f(u, v);
+            GlStateManager.glVertex3f(x, 0, y);
+        }
+
+        GlStateManager.glEnd();
+
+        GlStateManager.disableTexture2D();
+    }
+
+    protected void drawTexturedLineBase(float length, double angle) {
+        mc.getTextureManager().bindTexture(radarArrowTexture);
+
+        GlStateManager.enableTexture2D();
+
+        GlStateManager.pushMatrix();
+        GlStateManager.translate((float) (Math.cos(angle) * length / 2), 0, (float) (Math.sin(angle) * length / 2));
+        GlStateManager.rotate(90f, 1, 0, 0);
+        GlStateManager.rotate((float) Math.toDegrees(angle) + 90, 0, 0, 1);
+        GlStateManager.scale(0.2, length, 1);
+
+        GlStateManager.glBegin(GL11.GL_QUADS);
+
+        GlStateManager.glTexCoord2f(0, 0);
+        GlStateManager.glVertex3f(-0.5f, -0.5f, 0);
+        GlStateManager.glTexCoord2f(1, 0);
+        GlStateManager.glVertex3f(0.5f, -0.5f, 0);
+        GlStateManager.glTexCoord2f(1, 1);
+        GlStateManager.glVertex3f(0.5f, 0.5f, 0);
+        GlStateManager.glTexCoord2f(0, 1);
+        GlStateManager.glVertex3f(-0.5f, 0.5f, 0);
+
+        GlStateManager.glEnd();
+
+        GlStateManager.popMatrix();
+
+        GlStateManager.disableTexture2D();
+    }
+}

src/main/java/com/lumijiez/lumiscope/render/radar/LongRadarRenderer.java

@@ -0,0 +1,57 @@
+package com.lumijiez.lumiscope.render.radar;
+
+import com.lumijiez.lumiscope.items.radars.LongRadar;
+import com.lumijiez.lumiscope.network.LongRadarPacket;
+import net.minecraftforge.client.event.RenderHandEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class LongRadarRenderer extends BaseRadarRenderer<LongRadarPacket.PlayerInfo> {
+    private static final LongRadarRenderer INSTANCE = new LongRadarRenderer();
+
+    private LongRadarRenderer() {}
+
+    public static LongRadarRenderer getInstance() {
+        return INSTANCE;
+    }
+
+    @SubscribeEvent
+    public void onRenderWorldLast(RenderWorldLastEvent event) {
+        if (shouldRenderRadar()) {
+            if (playerInfos != null && !playerInfos.isEmpty()) {
+                renderRadar(event.getPartialTicks());
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void onRenderPlayerHand(RenderHandEvent event) {
+        if (mc.player.getHeldItemMainhand().getItem() instanceof LongRadar) {
+            event.setCanceled(true);
+        }
+    }
+
+    @Override
+    protected boolean shouldRenderRadar() {
+        return mc.player.getHeldItemMainhand().getItem() instanceof LongRadar ||
+                mc.player.getHeldItemOffhand().getItem() instanceof LongRadar;
+    }
+
+    @Override
+    protected void drawTexturedCircle(float radius) {
+        drawTexturedCircleBase(radius);
+    }
+
+    @Override
+    protected void drawTexturedLine(float length, double angle) {
+        drawTexturedLineBase(length, angle);
+    }
+
+    @Override
+    protected double getDirection(LongRadarPacket.PlayerInfo info) {
+        return info.direction;
+    }
+}

src/main/java/com/lumijiez/lumiscope/render/radar/ShortRadarRenderer.java

@@ -0,0 +1,97 @@
+package com.lumijiez.lumiscope.render.radar;
+
+import com.lumijiez.lumiscope.items.radars.ShortRadar;
+import com.lumijiez.lumiscope.network.ShortRadarPacket;
+import com.lumijiez.lumiscope.util.CustomMath;
+import com.lumijiez.lumiscope.util.GLHelper;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraftforge.client.event.RenderHandEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+@SideOnly(Side.CLIENT)
+public class ShortRadarRenderer extends BaseRadarRenderer<ShortRadarPacket.PlayerInfo> {
+    private static final ShortRadarRenderer INSTANCE = new ShortRadarRenderer();
+
+    private ShortRadarRenderer() {}
+
+    public static ShortRadarRenderer getInstance() {
+        return INSTANCE;
+    }
+
+    @SubscribeEvent
+    public void onRenderWorldLast(RenderWorldLastEvent event) {
+        if (shouldRenderRadar()) {
+            if (playerInfos != null && !playerInfos.isEmpty()) {
+                renderRadar(event.getPartialTicks());
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public void onRenderPlayerHand(RenderHandEvent event) {
+        if (mc.player.getHeldItemMainhand().getItem() instanceof ShortRadar) {
+            event.setCanceled(true);
+        }
+    }
+
+    @Override
+    protected void renderRadar(float partialTicks) {
+        GlStateManager.pushMatrix();
+        GlStateManager.translate(0, 0.01, 0);
+
+        mc.getTextureManager().bindTexture(radarTexture);
+
+        GLHelper.setupForRadarRendering();
+        drawTexturedCircle(1.4f);
+
+        for (ShortRadarPacket.PlayerInfo info : playerInfos) {
+            double angle = getDirection(info) - Math.toRadians(90);
+            drawTexturedLine(1.4f, angle);
+        }
+
+        GLHelper.setupForTextRendering();
+
+        for (ShortRadarPacket.PlayerInfo info : playerInfos) {
+            double angle = info.direction - Math.toRadians(90);
+            GlStateManager.pushMatrix();
+            GlStateManager.translate((float) (Math.cos(angle) * 1.2), 0.001, (float) (Math.sin(angle) * 1.2));
+            GlStateManager.rotate(90f, 1, 0, 0);
+
+            GlStateManager.rotate((float) Math.toDegrees(angle), 0, 0, 1);
+            GlStateManager.scale(0.01, 0.01, 0.01);
+
+            mc.fontRenderer.drawStringWithShadow(info.name, -mc.fontRenderer.getStringWidth(info.name) - 50 , -4, 0x808080);
+            mc.fontRenderer.drawStringWithShadow("(" + (int) info.distance +"m)", -mc.fontRenderer.getStringWidth(info.name) + 5 , -4, CustomMath.interpolateColor(100, 0, (int) info.distance));
+
+            GlStateManager.popMatrix();
+        }
+
+        GLHelper.cleanupAfterTextRendering();
+        GLHelper.cleanupAfterRadarRendering();
+        GlStateManager.popMatrix();
+    }
+
+    @Override
+    protected boolean shouldRenderRadar() {
+        return mc.player.getHeldItemMainhand().getItem() instanceof ShortRadar ||
+                mc.player.getHeldItemOffhand().getItem() instanceof ShortRadar;
+    }
+
+    @Override
+    protected void drawTexturedCircle(float radius) {
+        drawTexturedCircleBase(radius);
+    }
+
+    @Override
+    protected void drawTexturedLine(float length, double angle) {
+        drawTexturedLineBase(length, angle);
+    }
+
+    @Override
+    protected double getDirection(ShortRadarPacket.PlayerInfo info) {
+        return info.direction;
+    }
+}

src/main/java/com/lumijiez/lumiscope/util/CustomMath.java

@@ -0,0 +1,73 @@
+package com.lumijiez.lumiscope.util;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.math.MathHelper;
+
+import java.awt.*;
+import java.util.Random;
+
+public class CustomMath {
+
+    private static final Random RANDOM = new Random();
+
+    public static double getPlayerDirectionShort(EntityPlayerMP player, EntityPlayerMP otherPlayer) {
+        double angle = calculateRawAngle(player, otherPlayer);
+        return Math.toRadians(normalizeAngle(angle));
+    }
+
+    public static double getPlayerDirectionLong(EntityPlayerMP player, EntityPlayerMP otherPlayer) {
+        double angle = calculateRawAngle(player, otherPlayer);
+        double errorAngle = applyDoublePerlinNoise(angle, 0.15);
+        return Math.toRadians(normalizeAngle(errorAngle));
+    }
+
+    private static double calculateRawAngle(EntityPlayerMP player, EntityPlayerMP otherPlayer) {
+        double deltaX = otherPlayer.posX - player.posX;
+        double deltaZ = otherPlayer.posZ - player.posZ;
+
+        double angle = MathHelper.atan2(deltaZ, deltaX) * (180 / Math.PI) - 90;
+        if (angle < 0) angle += 360;
+
+        return (angle + 180) % 360;
+    }
+
+    private static double normalizeAngle(double angle) {
+        return (angle + 360) % 360;
+    }
+
+    private static double applyRandomError(double angle) {
+        double errorPercentage = 1 + RANDOM.nextDouble() * 9;
+        double error = angle * (errorPercentage / 100.0);
+        double errorSign = RANDOM.nextBoolean() ? 1 : -1;
+        return angle + errorSign * error;
+    }
+
+    private static double applyPerlinNoiseError(double baseValue, double scale) {
+        double time = System.currentTimeMillis() / 1000.0;
+        double noiseValue = PerlinNoise.noise(time);
+        double error = baseValue * scale * noiseValue;
+        return baseValue + error;
+    }
+
+    private static double applyDoublePerlinNoise(double baseValue, double scale) {
+        double time = System.currentTimeMillis() / 1000.0;
+        double firstNoise = PerlinNoise.noise(time);
+        double noiseInput = baseValue + scale * firstNoise;
+
+        double secondNoise = PerlinNoise.noise(noiseInput);
+        double error = baseValue * scale * secondNoise;
+
+        return baseValue + error;
+    }
+
+    public static int interpolateColor(int maxDistance, int minDistance, int currentDistance) {
+        int clampedDistance = Math.max(minDistance, Math.min(maxDistance, currentDistance));
+        float ratio = (float) (maxDistance - clampedDistance) / (maxDistance - minDistance);
+
+        int r = (int) (ratio * 255);
+        int g = (int) ((1 - ratio) * 255);
+        int b = 0;
+
+        return new Color(r, g, b).getRGB();
+    }
+}

src/main/java/com/lumijiez/lumiscope/util/GLHelper.java

@@ -0,0 +1,41 @@
+package com.lumijiez.lumiscope.util;
+
+import net.minecraft.client.renderer.GlStateManager;
+import org.lwjgl.opengl.GL11;
+
+public class GLHelper {
+
+    public static void setupForRadarRendering() {
+        GlStateManager.disableDepth();
+        GlStateManager.disableLighting();
+        GlStateManager.disableCull();
+        GlStateManager.enableBlend();
+        GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+    }
+
+    public static void cleanupAfterRadarRendering() {
+        GlStateManager.disableBlend();
+        GlStateManager.enableDepth();
+        GlStateManager.enableLighting();
+        GlStateManager.enableCull();
+    }
+
+    public static void setupForTextRendering() {
+        GlStateManager.disableDepth();
+        GlStateManager.disableLighting();
+        GlStateManager.disableCull();
+        GlStateManager.enableBlend();
+        GlStateManager.enableTexture2D();
+        GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        GlStateManager.color(1.0f, 1.0f, 1.0f, 0.5f);
+    }
+
+    public static void cleanupAfterTextRendering() {
+        GlStateManager.color(1.0f, 1.0f, 1.0f, 1.0f);
+        GlStateManager.disableBlend();
+        GlStateManager.enableDepth();
+        GlStateManager.enableLighting();
+        GlStateManager.enableCull();
+        GlStateManager.disableTexture2D();
+    }
+}

src/main/java/com/lumijiez/lumiscope/util/PerlinNoise.java

@@ -0,0 +1,45 @@
+package com.lumijiez.lumiscope.util;
+
+public class PerlinNoise {
+    private static final int PERMUTATION_SIZE = 256;
+    private static final int[] PERMUTATION = new int[PERMUTATION_SIZE * 2];
+    private static final int[] P = new int[PERMUTATION_SIZE];
+
+    static {
+        for (int i = 0; i < PERMUTATION_SIZE; i++) {
+            P[i] = i;
+        }
+
+        for (int i = 0; i < PERMUTATION_SIZE; i++) {
+            int swap = (int) (Math.random() * PERMUTATION_SIZE);
+            int temp = P[i];
+            P[i] = P[swap];
+            P[swap] = temp;
+        }
+
+        System.arraycopy(P, 0, PERMUTATION, 0, PERMUTATION_SIZE);
+        System.arraycopy(P, 0, PERMUTATION, PERMUTATION_SIZE, PERMUTATION_SIZE);
+    }
+
+    private static double fade(double t) {
+        return t * t * t * (t * (t * 6 - 15) + 10);
+    }
+
+    private static double lerp(double t, double a, double b) {
+        return a + t * (b - a);
+    }
+
+    private static double grad(int hash, double x) {
+        int h = hash & 15;
+        double grad = 1 + (h & 7);
+        return (h & 8) == 0 ? grad * x : -grad * x;
+    }
+
+    public static double noise(double x) {
+        int xi = (int) Math.floor(x) & 255;
+        double xf = x - Math.floor(x);
+        double u = fade(xf);
+
+        return lerp(u, grad(PERMUTATION[xi], xf), grad(PERMUTATION[xi + 1], xf - 1));
+    }
+}