caskd
/
kami-blue
forked from RepoMirrors/kami-blue
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

convert render category modules to kotlin

This commit is contained in:
Bella 2020-04-22 12:50:43 -04:00
parent 89c59a51e7
commit cd7d6da17a
No known key found for this signature in database
GPG Key ID: DBD4A6030080C8B3
34 changed files with 1052 additions and 1176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/main/java/me/zeroeightsix/kami/mixin/client/MixinEntityRenderer.java
View File

@ -59,7 +59,7 @@ public class MixinEntityRenderer {
@Inject(method = "setupFog", at = @At(value = "HEAD"), cancellable = true)
public void setupFog(int startCoords, float partialTicks, CallbackInfo callbackInfo) {
if (AntiFog.enabled() && AntiFog.mode.getValue() == AntiFog.VisionMode.NOFOG)
if (AntiFog.enabled() && AntiFog.mode.getValue() == AntiFog.VisionMode.NO_FOG)
callbackInfo.cancel();
}

33
src/main/java/me/zeroeightsix/kami/module/modules/render/AntiFog.java
View File

@ -1,33 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
/**
* Created by 086 on 9/04/2018.
*/
@Module.Info(
name = "AntiFog",
description = "Disables or reduces fog",
category = Module.Category.RENDER
)
public class AntiFog extends Module {
public static Setting<VisionMode> mode = Settings.e("Mode", VisionMode.NOFOG);
private static AntiFog INSTANCE = new AntiFog();
public AntiFog() {
INSTANCE = this;
register(mode);
}
public static boolean enabled() {
return INSTANCE.isEnabled();
}
public enum VisionMode {
NOFOG, AIR
}
}

34
src/main/java/me/zeroeightsix/kami/module/modules/render/AntiFog.kt Normal file
View File

@ -0,0 +1,34 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Setting
import me.zeroeightsix.kami.setting.Settings
/**
* Created by 086 on 9/04/2018.
*/
@Module.Info(
name = "AntiFog",
description = "Disables or reduces fog",
category = Module.Category.RENDER
)
class AntiFog : Module() {
enum class VisionMode {
NO_FOG, AIR
}
companion object {
@JvmField
var mode: Setting<VisionMode> = Settings.e("Mode", VisionMode.NO_FOG)
private var INSTANCE = AntiFog()
@JvmStatic
fun enabled(): Boolean {
return INSTANCE.isEnabled
}
}
init {
INSTANCE = this
register(mode)
}
}

76
src/main/java/me/zeroeightsix/kami/module/modules/render/ArmourHUD.java
View File

@ -1,76 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import me.zeroeightsix.kami.util.ColourHolder;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.RenderItem;
import net.minecraft.item.ItemStack;
import net.minecraft.util.NonNullList;
import net.minecraft.world.GameType;
/**
* Created by 086 on 24/01/2018.
*/
@Module.Info(
name = "ArmourHUD",
category = Module.Category.RENDER,
showOnArray = Module.ShowOnArray.OFF,
description = "Displays your armour and it's durability on screen"
)
public class ArmourHUD extends Module {
private static RenderItem itemRender = Minecraft.getMinecraft().getRenderItem();
private Setting<Boolean> damage = register(Settings.b("Damage", false));
private NonNullList<ItemStack> getArmour() {
if (mc.playerController.getCurrentGameType().equals(GameType.CREATIVE) || mc.playerController.getCurrentGameType().equals(GameType.SPECTATOR)) {
return NonNullList.withSize(4, ItemStack.EMPTY);
}
else {
return mc.player.inventory.armorInventory;
}
}
@Override
public void onRender() {
GlStateManager.enableTexture2D();
ScaledResolution resolution = new ScaledResolution(mc);
int i = resolution.getScaledWidth() / 2;
int iteration = 0;
int y = resolution.getScaledHeight() - 55 - (mc.player.isInWater() ? 10 : 0);
for (ItemStack is : getArmour()) {
iteration++;
if (is.isEmpty()) continue;
int x = i - 90 + (9 - iteration) * 20 + 2;
GlStateManager.enableDepth();
itemRender.zLevel = 200F;
itemRender.renderItemAndEffectIntoGUI(is, x, y);
itemRender.renderItemOverlayIntoGUI(mc.fontRenderer, is, x, y, "");
itemRender.zLevel = 0F;
GlStateManager.enableTexture2D();
GlStateManager.disableLighting();
GlStateManager.disableDepth();
String s = is.getCount() > 1 ? is.getCount() + "" : "";
mc.fontRenderer.drawStringWithShadow(s, x + 19 - 2 - mc.fontRenderer.getStringWidth(s), y + 9, 0xffffff);
if (damage.getValue()) {
float green = ((float) is.getMaxDamage() - (float) is.getItemDamage()) / (float) is.getMaxDamage();
float red = 1 - green;
int dmg = 100 - (int) (red * 100);
mc.fontRenderer.drawStringWithShadow(dmg + "", x + 8 - mc.fontRenderer.getStringWidth(dmg + "") / 2, y - 11, ColourHolder.toHex((int) (red * 255), (int) (green * 255), 0));
}
}
GlStateManager.enableDepth();
GlStateManager.disableLighting();
}
}

65
src/main/java/me/zeroeightsix/kami/module/modules/render/ArmourHUD.kt Normal file
View File

@ -0,0 +1,65 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Settings
import me.zeroeightsix.kami.util.ColourHolder
import net.minecraft.client.Minecraft
import net.minecraft.client.gui.ScaledResolution
import net.minecraft.client.renderer.GlStateManager
import net.minecraft.item.ItemStack
import net.minecraft.util.NonNullList
import net.minecraft.world.GameType
/**
* Created by 086 on 24/01/2018.
*/
@Module.Info(
name = "ArmourHUD",
category = Module.Category.RENDER,
showOnArray = Module.ShowOnArray.OFF,
description = "Displays your armour and it's durability on screen"
)
class ArmourHUD : Module() {
private val damage = register(Settings.b("Damage", false))
private val armour: NonNullList<ItemStack>
get() = if (mc.playerController.getCurrentGameType() == GameType.CREATIVE || mc.playerController.getCurrentGameType() == GameType.SPECTATOR) {
NonNullList.withSize(4, ItemStack.EMPTY)
} else {
mc.player.inventory.armorInventory
}
override fun onRender() {
GlStateManager.enableTexture2D()
val resolution = ScaledResolution(mc)
val i = resolution.scaledWidth / 2
var iteration = 0
val y = resolution.scaledHeight - 55 - if (mc.player.isInWater) 10 else 0
for (`is` in armour) {
iteration++
if (`is`.isEmpty()) continue
val x = i - 90 + (9 - iteration) * 20 + 2
GlStateManager.enableDepth()
itemRender.zLevel = 200f
itemRender.renderItemAndEffectIntoGUI(`is`, x, y)
itemRender.renderItemOverlayIntoGUI(mc.fontRenderer, `is`, x, y, "")
itemRender.zLevel = 0f
GlStateManager.enableTexture2D()
GlStateManager.disableLighting()
GlStateManager.disableDepth()
val s = if (`is`.count > 1) `is`.count.toString() + "" else ""
mc.fontRenderer.drawStringWithShadow(s, x + 19 - 2 - mc.fontRenderer.getStringWidth(s).toFloat(), y + 9.toFloat(), 0xffffff)
if (damage.value) {
val green = (`is`.maxDamage.toFloat() - `is`.getItemDamage().toFloat()) / `is`.maxDamage.toFloat()
val red = 1 - green
val dmg = 100 - (red * 100).toInt()
mc.fontRenderer.drawStringWithShadow(dmg.toString() + "", x + 8 - mc.fontRenderer.getStringWidth(dmg.toString() + "") / 2.toFloat(), y - 11.toFloat(), ColourHolder.toHex((red * 255).toInt(), (green * 255).toInt(), 0))
}
}
GlStateManager.enableDepth()
GlStateManager.disableLighting()
}
companion object {
private val itemRender = Minecraft.getMinecraft().getRenderItem()
}
}

46
src/main/java/me/zeroeightsix/kami/module/modules/render/ArmourHide.java
View File

@ -1,46 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import net.minecraft.inventory.EntityEquipmentSlot;
/**
* Created by TBM on 30/12/2019.
*/
@Module.Info(
name = "ArmourHide",
category = Module.Category.RENDER,
description = "Hides the armour on selected entities",
showOnArray = Module.ShowOnArray.OFF
)
public class ArmourHide extends Module {
public Setting<Boolean> player = register(Settings.b("Players", false));
public Setting<Boolean> armourstand = register(Settings.b("Armour Stands", true));
public Setting<Boolean> mobs = register(Settings.b("Mobs", true));
public Setting<Boolean> helmet = register(Settings.b("Helmet", false));
public Setting<Boolean> chestplate = register(Settings.b("Chestplate", false));
public Setting<Boolean> leggins = register(Settings.b("Leggings", false));
public Setting<Boolean> boots = register(Settings.b("Boots", false));
public static ArmourHide INSTANCE;
public ArmourHide() {
ArmourHide.INSTANCE = this;
}
public static boolean shouldRenderPiece(EntityEquipmentSlot slotIn) {
if (slotIn == EntityEquipmentSlot.HEAD && ArmourHide.INSTANCE.helmet.getValue()) {
return true;
} else if (slotIn == EntityEquipmentSlot.CHEST && ArmourHide.INSTANCE.chestplate.getValue()) {
return true;
} else if (slotIn == EntityEquipmentSlot.LEGS && ArmourHide.INSTANCE.leggins.getValue()) {
return true;
} else if (slotIn == EntityEquipmentSlot.FEET && ArmourHide.INSTANCE.boots.getValue()) {
return true;
} else {
return false;
}
}
}

47
src/main/java/me/zeroeightsix/kami/module/modules/render/ArmourHide.kt Normal file
View File

@ -0,0 +1,47 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Setting
import me.zeroeightsix.kami.setting.Settings
import net.minecraft.inventory.EntityEquipmentSlot
/**
* Created by TBM on 30/12/2019.
*/
@Module.Info(
name = "ArmourHide",
category = Module.Category.RENDER,
description = "Hides the armour on selected entities",
showOnArray = Module.ShowOnArray.OFF
)
class ArmourHide : Module() {
@JvmField
var player: Setting<Boolean> = register(Settings.b("Players", false))
@JvmField
var armourstand: Setting<Boolean> = register(Settings.b("Armour Stands", true))
@JvmField
var mobs: Setting<Boolean> = register(Settings.b("Mobs", true))
var helmet: Setting<Boolean> = register(Settings.b("Helmet", false))
var chestplate: Setting<Boolean> = register(Settings.b("Chestplate", false))
var leggings: Setting<Boolean> = register(Settings.b("Leggings", false))
var boots: Setting<Boolean> = register(Settings.b("Boots", false))
companion object {
@JvmField
var INSTANCE: ArmourHide? = null
@JvmStatic
fun shouldRenderPiece(slotIn: EntityEquipmentSlot): Boolean {
return if (slotIn == EntityEquipmentSlot.HEAD && INSTANCE!!.helmet.value) {
true
} else if (slotIn == EntityEquipmentSlot.CHEST && INSTANCE!!.chestplate.value) {
true
} else if (slotIn == EntityEquipmentSlot.LEGS && INSTANCE!!.leggings.value) {
true
} else slotIn == EntityEquipmentSlot.FEET && INSTANCE!!.boots.value
}
}
init {
INSTANCE = this
}
}

58
src/main/java/me/zeroeightsix/kami/module/modules/render/BoxESP.java
View File

@ -1,58 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.event.events.RenderEvent;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import me.zeroeightsix.kami.util.GeometryMasks;
import me.zeroeightsix.kami.util.KamiTessellator;
import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.item.EntityXPOrb;
import net.minecraft.entity.projectile.EntityArrow;
import net.minecraft.entity.projectile.EntityThrowable;
import org.lwjgl.opengl.GL11;
import java.util.List;
import java.util.stream.Collectors;
import static me.zeroeightsix.kami.util.ColourConverter.rgbToInt;
/**
* @author polymer
* Updated by dominikaaaa on 30/03/20
*/
@Module.Info(
name = "BoxESP",
description = "Draws a box around small entities",
category = Module.Category.RENDER
)
public class BoxESP extends Module {
private Setting<Boolean> experience = register(Settings.b("Experience", true));
private Setting<Boolean> arrows = register(Settings.b("Arrows", true));
private Setting<Boolean> throwable = register(Settings.b("Throwable", true));
private Setting<Boolean> items = register(Settings.b("Items", false));
private Setting<Integer> alpha = register(Settings.integerBuilder("Alpha").withMinimum(1).withMaximum(255).withValue(100).build());
private Setting<Integer> red = register(Settings.integerBuilder("Red").withMinimum(1).withMaximum(255).withValue(155).build());
private Setting<Integer> green = register(Settings.integerBuilder("Green").withMinimum(1).withMaximum(255).withValue(144).build());
private Setting<Integer> blue = register(Settings.integerBuilder("Blue").withMinimum(1).withMaximum(255).withValue(255).build());
@Override
public void onWorldRender(RenderEvent event) {
List<Entity> entities = mc.world.loadedEntityList.stream().filter(this::getEntity).collect(Collectors.toList());
for (Entity e: entities) {
KamiTessellator.prepare(GL11.GL_QUADS);
int colour = rgbToInt(red.getValue(), green.getValue(), blue.getValue(), alpha.getValue());
KamiTessellator.drawBoxSmall((float) e.getPositionVector().x - 0.25f, (float) e.getPositionVector().y, (float) e.getPositionVector().z - 0.25f, colour, GeometryMasks.Quad.ALL);
KamiTessellator.release();
}
}
private boolean getEntity(Entity entity) {
if (entity instanceof EntityXPOrb && experience.getValue()) return true;
else if (entity instanceof EntityArrow && arrows.getValue()) return true;
else if (entity instanceof EntityThrowable && throwable.getValue()) return true;
else return entity instanceof EntityItem && items.getValue();
}
}

48
src/main/java/me/zeroeightsix/kami/module/modules/render/BoxESP.kt Normal file
View File

@ -0,0 +1,48 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.event.events.RenderEvent
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Settings
import me.zeroeightsix.kami.util.ColourConverter
import me.zeroeightsix.kami.util.GeometryMasks
import me.zeroeightsix.kami.util.KamiTessellator
import net.minecraft.entity.Entity
import net.minecraft.entity.item.EntityItem
import net.minecraft.entity.item.EntityXPOrb
import net.minecraft.entity.projectile.EntityArrow
import net.minecraft.entity.projectile.EntityThrowable
import org.lwjgl.opengl.GL11
import java.util.stream.Collectors
/**
* @author polymer
* Updated by dominikaaaa on 30/03/20
*/
@Module.Info(
name = "BoxESP",
description = "Draws a box around small entities",
category = Module.Category.RENDER
)
class BoxESP : Module() {
private val experience = register(Settings.b("Experience", true))
private val arrows = register(Settings.b("Arrows", true))
private val throwable = register(Settings.b("Throwable", true))
private val items = register(Settings.b("Items", false))
private val alpha = register(Settings.integerBuilder("Alpha").withMinimum(1).withMaximum(255).withValue(100).build())
private val red = register(Settings.integerBuilder("Red").withMinimum(1).withMaximum(255).withValue(155).build())
private val green = register(Settings.integerBuilder("Green").withMinimum(1).withMaximum(255).withValue(144).build())
private val blue = register(Settings.integerBuilder("Blue").withMinimum(1).withMaximum(255).withValue(255).build())
override fun onWorldRender(event: RenderEvent) {
val entities = mc.world.loadedEntityList.stream().filter { entity: Entity -> getEntity(entity) }.collect(Collectors.toList())
for (e in entities) {
KamiTessellator.prepare(GL11.GL_QUADS)
val colour = ColourConverter.rgbToInt(red.value, green.value, blue.value, alpha.value)
KamiTessellator.drawBoxSmall(e.positionVector.x.toFloat() - 0.25f, e.positionVector.y.toFloat(), e.positionVector.z.toFloat() - 0.25f, colour, GeometryMasks.Quad.ALL)
KamiTessellator.release()
}
}
private fun getEntity(entity: Entity): Boolean {
return if (entity is EntityXPOrb && experience.value) true else if (entity is EntityArrow && arrows.value) true else if (entity is EntityThrowable && throwable.value) true else entity is EntityItem && items.value
}
}

32
src/main/java/me/zeroeightsix/kami/module/modules/render/Chams.java
View File

@ -1,32 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import me.zeroeightsix.kami.util.EntityUtil;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
/**
* Created by 086 on 12/12/2017.
*/
@Module.Info(
name = "Chams",
category = Module.Category.RENDER,
description = "See entities through walls"
)
public class Chams extends Module {
private static Setting<Boolean> players = Settings.b("Players", true);
private static Setting<Boolean> animals = Settings.b("Animals", false);
private static Setting<Boolean> mobs = Settings.b("Mobs", false);
public Chams() {
registerAll(players, animals, mobs);
}
public static boolean renderChams(Entity entity) {
return (entity instanceof EntityPlayer ? players.getValue() : (EntityUtil.isPassive(entity) ? animals.getValue() : mobs.getValue()));
}
}

31
src/main/java/me/zeroeightsix/kami/module/modules/render/Chams.kt Normal file
View File

@ -0,0 +1,31 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Settings
import me.zeroeightsix.kami.util.EntityUtil
import net.minecraft.entity.Entity
import net.minecraft.entity.player.EntityPlayer
/**
* Created by 086 on 12/12/2017.
*/
@Module.Info(
name = "Chams",
category = Module.Category.RENDER,
description = "See entities through walls"
)
class Chams : Module() {
companion object {
private val players = Settings.b("Players", true)
private val animals = Settings.b("Animals", false)
private val mobs = Settings.b("Mobs", false)
@JvmStatic
fun renderChams(entity: Entity?): Boolean {
return if (entity is EntityPlayer) players.value else if (EntityUtil.isPassive(entity)) animals.value else mobs.value
}
}
init {
registerAll(players, animals, mobs)
}
}

31
src/main/java/me/zeroeightsix/kami/module/modules/render/CleanGUI.java
View File

@ -1,31 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
/**
* @author dominikaaaa
* Updated by dominikaaaa on 27/12/19
*/
@Module.Info(
name = "CleanGUI",
category = Module.Category.RENDER,
showOnArray = Module.ShowOnArray.OFF,
description = "Modifies parts of the GUI to be transparent"
)
public class CleanGUI extends Module {
public Setting<Boolean> inventoryGlobal = register(Settings.b("Inventory", true));
public static Setting<Boolean> chatGlobal = Settings.b("Chat", false);
private static CleanGUI INSTANCE = new CleanGUI();
public CleanGUI() {
INSTANCE = this;
register(chatGlobal);
}
public static boolean enabled() {
return INSTANCE.isEnabled();
}
}

35
src/main/java/me/zeroeightsix/kami/module/modules/render/CleanGUI.kt Normal file
View File

@ -0,0 +1,35 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Setting
import me.zeroeightsix.kami.setting.Settings
/**
* @author dominikaaaa
* Updated by dominikaaaa on 27/12/19
*/
@Module.Info(
name = "CleanGUI",
category = Module.Category.RENDER,
showOnArray = Module.ShowOnArray.OFF,
description = "Modifies parts of the GUI to be transparent"
)
class CleanGUI : Module() {
@JvmField
var inventoryGlobal: Setting<Boolean> = register(Settings.b("Inventory", true))
companion object {
@JvmField
var chatGlobal: Setting<Boolean> = Settings.b("Chat", false)
private var INSTANCE = CleanGUI()
@JvmStatic
fun enabled(): Boolean {
return INSTANCE.isEnabled
}
}
init {
INSTANCE = this
register(chatGlobal)
}
}

24
src/main/java/me/zeroeightsix/kami/module/modules/render/ExtraTab.java
View File

@ -1,24 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
/**
* Created by 086 on 8/04/2018.
*/
@Module.Info(
name = "ExtraTab",
description = "Expands the player tab menu",
category = Module.Category.RENDER
)
public class ExtraTab extends Module {
public Setting<Integer> tabSize = register(Settings.integerBuilder("Players").withMinimum(1).withValue(80).build());
public static ExtraTab INSTANCE;
public ExtraTab() {
ExtraTab.INSTANCE = this;
}
}

27
src/main/java/me/zeroeightsix/kami/module/modules/render/ExtraTab.kt Normal file
View File

@ -0,0 +1,27 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Setting
import me.zeroeightsix.kami.setting.Settings
/**
* Created by 086 on 8/04/2018.
*/
@Module.Info(
name = "ExtraTab",
description = "Expands the player tab menu",
category = Module.Category.RENDER
)
class ExtraTab : Module() {
@JvmField
var tabSize: Setting<Int> = register(Settings.integerBuilder("Players").withMinimum(1).withValue(80).build())
companion object {
@JvmField
var INSTANCE: ExtraTab? = null
}
init {
INSTANCE = this
}
}

171
src/main/java/me/zeroeightsix/kami/module/modules/render/HoleESP.java
View File

@ -1,171 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.event.events.RenderEvent;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.module.modules.combat.CrystalAura;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import me.zeroeightsix.kami.util.GeometryMasks;
import me.zeroeightsix.kami.util.KamiTessellator;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.util.math.BlockPos;
import org.lwjgl.opengl.GL11;
import java.awt.*;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import static me.zeroeightsix.kami.KamiMod.MODULE_MANAGER;
import static me.zeroeightsix.kami.module.modules.combat.CrystalAura.getPlayerPos;
/**
* Created 16 November 2019 by hub
* Updated by dominikaaaa on 15/12/19
*/
@Module.Info(
name = "HoleESP",
category = Module.Category.RENDER,
description = "Show safe holes for crystal pvp"
)
public class HoleESP extends Module {
private final BlockPos[] surroundOffset = {
new BlockPos(0, -1, 0), // down
new BlockPos(0, 0, -1), // north
new BlockPos(1, 0, 0), // east
new BlockPos(0, 0, 1), // south
new BlockPos(-1, 0, 0) // west
};
private Setting<Double> renderDistance = register(Settings.d("Render Distance", 8.0d));
private Setting<Integer> a0 = register(Settings.integerBuilder("Transparency").withMinimum(0).withValue(32).withMaximum(255).build());
private Setting<Integer> r1 = register(Settings.integerBuilder("Red (Obby)").withMinimum(0).withValue(208).withMaximum(255).withVisibility(v-> obbySettings()).build());
private Setting<Integer> g1 = register(Settings.integerBuilder("Green (Obby)").withMinimum(0).withValue(144).withMaximum(255).withVisibility(v-> obbySettings()).build());
private Setting<Integer> b1 = register(Settings.integerBuilder("Blue (Obby)").withMinimum(0).withValue(255).withMaximum(255).withVisibility(v-> obbySettings()).build());
private Setting<Integer> r2 = register(Settings.integerBuilder("Red (Bedrock)").withMinimum(0).withValue(144).withMaximum(255).withVisibility(v-> bedrockSettings()).build()); // 208
private Setting<Integer> g2 = register(Settings.integerBuilder("Green (Bedrock)").withMinimum(0).withValue(144).withMaximum(255).withVisibility(v-> bedrockSettings()).build());
private Setting<Integer> b2 = register(Settings.integerBuilder("Blue (Bedrock)").withMinimum(0).withValue(255).withMaximum(255).withVisibility(v-> bedrockSettings()).build());
private Setting<RenderMode> renderModeSetting = register(Settings.e("Render Mode", RenderMode.BLOCK));
private Setting<RenderBlocks> renderBlocksSetting = register(Settings.e("Render", RenderBlocks.BOTH));
private ConcurrentHashMap<BlockPos, Boolean> safeHoles;
private enum RenderMode {
DOWN, BLOCK
}
private enum RenderBlocks {
OBBY, BEDROCK, BOTH
}
private boolean obbySettings() {
return renderBlocksSetting.getValue().equals(RenderBlocks.OBBY) || renderBlocksSetting.getValue().equals(RenderBlocks.BOTH);
}
private boolean bedrockSettings() {
return renderBlocksSetting.getValue().equals(RenderBlocks.BEDROCK) || renderBlocksSetting.getValue().equals(RenderBlocks.BOTH);
}
@Override
public void onUpdate() {
if (safeHoles == null) {
safeHoles = new ConcurrentHashMap<>();
} else {
safeHoles.clear();
}
int range = (int) Math.ceil(renderDistance.getValue());
CrystalAura crystalAura = MODULE_MANAGER.getModuleT(CrystalAura.class);
List<BlockPos> blockPosList = crystalAura.getSphere(getPlayerPos(), range, range, false, true, 0);
for (BlockPos pos : blockPosList) {
// block gotta be air
if (!mc.world.getBlockState(pos).getBlock().equals(Blocks.AIR)) {
continue;
}
// block 1 above gotta be air
if (!mc.world.getBlockState(pos.add(0, 1, 0)).getBlock().equals(Blocks.AIR)) {
continue;
}
// block 2 above gotta be air
if (!mc.world.getBlockState(pos.add(0, 2, 0)).getBlock().equals(Blocks.AIR)) {
continue;
}
boolean isSafe = true;
boolean isBedrock = true;
for (BlockPos offset : surroundOffset) {
Block block = mc.world.getBlockState(pos.add(offset)).getBlock();
if (block != Blocks.BEDROCK) {
isBedrock = false;
}
if (block != Blocks.BEDROCK && block != Blocks.OBSIDIAN && block != Blocks.ENDER_CHEST && block != Blocks.ANVIL) {
isSafe = false;
break;
}
}
if (isSafe) {
safeHoles.put(pos, isBedrock);
}
}
}
@Override
public void onWorldRender(final RenderEvent event) {
if (mc.player == null || safeHoles == null) {
return;
}
if (safeHoles.isEmpty()) {
return;
}
KamiTessellator.prepare(GL11.GL_QUADS);
safeHoles.forEach((blockPos, isBedrock) -> {
switch (renderBlocksSetting.getValue()) {
case BOTH:
if (isBedrock) {
drawBox(blockPos, r2.getValue(), g2.getValue(), b2.getValue());
}
else {
drawBox(blockPos, r1.getValue(), g1.getValue(), b1.getValue());
}
break;
case OBBY:
if (!isBedrock) {
drawBox(blockPos, r1.getValue(), g1.getValue(), b1.getValue());
}
break;
case BEDROCK:
if (isBedrock) {
drawBox(blockPos, r2.getValue(), g2.getValue(), b2.getValue());
}
break;
}
});
KamiTessellator.release();
}
private void drawBox(BlockPos blockPos, int r, int g, int b) {
Color color = new Color(r, g, b, a0.getValue());
if (renderModeSetting.getValue().equals(RenderMode.DOWN)) {
KamiTessellator.drawBox(blockPos, color.getRGB(), GeometryMasks.Quad.DOWN);
} else if (renderModeSetting.getValue().equals(RenderMode.BLOCK)) {
KamiTessellator.drawBox(blockPos, color.getRGB(), GeometryMasks.Quad.ALL);
}
}
}

139
src/main/java/me/zeroeightsix/kami/module/modules/render/HoleESP.kt Normal file
View File

@ -0,0 +1,139 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.KamiMod
import me.zeroeightsix.kami.event.events.RenderEvent
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.module.modules.combat.CrystalAura
import me.zeroeightsix.kami.setting.Settings
import me.zeroeightsix.kami.util.GeometryMasks
import me.zeroeightsix.kami.util.KamiTessellator
import net.minecraft.init.Blocks
import net.minecraft.util.math.BlockPos
import org.lwjgl.opengl.GL11
import java.awt.Color
import java.util.concurrent.ConcurrentHashMap
import kotlin.math.ceil
/**
* Created 16 November 2019 by hub
* Updated by dominikaaaa on 15/12/19
*/
@Module.Info(
name = "HoleESP",
category = Module.Category.RENDER,
description = "Show safe holes for crystal pvp"
)
class HoleESP : Module() {
private val surroundOffset = arrayOf(
BlockPos(0, -1, 0), // down
BlockPos(0, 0, -1), // north
BlockPos(1, 0, 0), // east
BlockPos(0, 0, 1), // south
BlockPos(-1, 0, 0) // west
)
private val renderDistance = register(Settings.d("Render Distance", 8.0))
private val a0 = register(Settings.integerBuilder("Transparency").withMinimum(0).withValue(32).withMaximum(255).build())
private val r1 = register(Settings.integerBuilder("Red (Obby)").withMinimum(0).withValue(208).withMaximum(255).withVisibility { v: Int? -> obbySettings() }.build())
private val g1 = register(Settings.integerBuilder("Green (Obby)").withMinimum(0).withValue(144).withMaximum(255).withVisibility { v: Int? -> obbySettings() }.build())
private val b1 = register(Settings.integerBuilder("Blue (Obby)").withMinimum(0).withValue(255).withMaximum(255).withVisibility { v: Int? -> obbySettings() }.build())
private val r2 = register(Settings.integerBuilder("Red (Bedrock)").withMinimum(0).withValue(144).withMaximum(255).withVisibility { v: Int? -> bedrockSettings() }.build())
private val g2 = register(Settings.integerBuilder("Green (Bedrock)").withMinimum(0).withValue(144).withMaximum(255).withVisibility { v: Int? -> bedrockSettings() }.build())
private val b2 = register(Settings.integerBuilder("Blue (Bedrock)").withMinimum(0).withValue(255).withMaximum(255).withVisibility { v: Int? -> bedrockSettings() }.build())
private val renderModeSetting = register(Settings.e<RenderMode>("Render Mode", RenderMode.BLOCK))
private val renderBlocksSetting = register(Settings.e<RenderBlocks>("Render", RenderBlocks.BOTH))
private var safeHoles: ConcurrentHashMap<BlockPos, Boolean>? = null
private enum class RenderMode {
DOWN, BLOCK
}
private enum class RenderBlocks {
OBBY, BEDROCK, BOTH
}
private fun obbySettings(): Boolean {
return renderBlocksSetting.value == RenderBlocks.OBBY || renderBlocksSetting.value == RenderBlocks.BOTH
}
private fun bedrockSettings(): Boolean {
return renderBlocksSetting.value == RenderBlocks.BEDROCK || renderBlocksSetting.value == RenderBlocks.BOTH
}
override fun onUpdate() {
if (safeHoles == null) {
safeHoles = ConcurrentHashMap()
} else {
safeHoles!!.clear()
}
val range = ceil(renderDistance.value).toInt()
val crystalAura = KamiMod.MODULE_MANAGER.getModuleT(CrystalAura::class.java)
val blockPosList = crystalAura.getSphere(CrystalAura.getPlayerPos(), range.toFloat(), range, false, true, 0)
for (pos in blockPosList) {
// block gotta be air
if (mc.world.getBlockState(pos).block != Blocks.AIR) {
continue
}
// block 1 above gotta be air
if (mc.world.getBlockState(pos.add(0, 1, 0)).block != Blocks.AIR) {
continue
}
// block 2 above gotta be air
if (mc.world.getBlockState(pos.add(0, 2, 0)).block != Blocks.AIR) {
continue
}
var isSafe = true
var isBedrock = true
for (offset in surroundOffset) {
val block = mc.world.getBlockState(pos.add(offset)).block
if (block !== Blocks.BEDROCK) {
isBedrock = false
}
if (block !== Blocks.BEDROCK && block !== Blocks.OBSIDIAN && block !== Blocks.ENDER_CHEST && block !== Blocks.ANVIL) {
isSafe = false
break
}
}
if (isSafe) {
safeHoles!![pos] = isBedrock
}
}
}
override fun onWorldRender(event: RenderEvent) {
if (mc.player == null || safeHoles == null) {
return
}
if (safeHoles!!.isEmpty()) {
return
}
KamiTessellator.prepare(GL11.GL_QUADS)
safeHoles!!.forEach { (blockPos: BlockPos, isBedrock: Boolean) ->
when (renderBlocksSetting.value) {
RenderBlocks.BOTH -> if (isBedrock) {
drawBox(blockPos, r2.value, g2.value, b2.value)
} else {
drawBox(blockPos, r1.value, g1.value, b1.value)
}
RenderBlocks.OBBY -> if (!isBedrock) {
drawBox(blockPos, r1.value, g1.value, b1.value)
}
RenderBlocks.BEDROCK -> if (isBedrock) {
drawBox(blockPos, r2.value, g2.value, b2.value)
}
}
}
KamiTessellator.release()
}
private fun drawBox(blockPos: BlockPos, r: Int, g: Int, b: Int) {
val color = Color(r, g, b, a0.value)
if (renderModeSetting.value == RenderMode.DOWN) {
KamiTessellator.drawBox(blockPos, color.rgb, GeometryMasks.Quad.DOWN)
} else if (renderModeSetting.value == RenderMode.BLOCK) {
KamiTessellator.drawBox(blockPos, color.rgb, GeometryMasks.Quad.ALL)
}
}
}

21
src/main/java/me/zeroeightsix/kami/module/modules/render/HungerOverlay.java
View File

@ -1,21 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
/**
* Created (partly) by Dewy on the 19th of April, 2020
*
* PLEASE NOTE: Just like xray, the overlay textures will break in a development environment.
*/
@Module.Info(
name = "HungerOverlay",
description = "Displays a helpful overlay over your hunger bar.",
category = Module.Category.PLAYER
)
public class HungerOverlay extends Module {
public Setting<Boolean> saturationOverlay = register(Settings.booleanBuilder("Saturation Overlay").withValue(true));
public Setting<Boolean> foodValueOverlay = register(Settings.booleanBuilder("Food Value Overlay").withValue(true));
public Setting<Boolean> foodExhaustionOverlay = register(Settings.booleanBuilder("Food Exhaustion Overlay").withValue(true));
}

24
src/main/java/me/zeroeightsix/kami/module/modules/render/HungerOverlay.kt Normal file
View File

@ -0,0 +1,24 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Setting
import me.zeroeightsix.kami.setting.Settings
/**
* Created (partly) by Dewy on the 19th of April, 2020
*
* PLEASE NOTE: Just like xray, the overlay textures will break in a development environment.
*/
@Module.Info(
name = "HungerOverlay",
description = "Displays a helpful overlay over your hunger bar.",
category = Module.Category.PLAYER
)
class HungerOverlay : Module() {
@JvmField
var saturationOverlay: Setting<Boolean> = register(Settings.booleanBuilder("Saturation Overlay").withValue(true))
@JvmField
var foodValueOverlay: Setting<Boolean> = register(Settings.booleanBuilder("Food Value Overlay").withValue(true))
@JvmField
var foodExhaustionOverlay: Setting<Boolean> = register(Settings.booleanBuilder("Food Exhaustion Overlay").withValue(true))
}

25
src/main/java/me/zeroeightsix/kami/module/modules/render/NoHurtCam.java
View File

@ -1,25 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
/**
* @author 086
*/
@Module.Info(
name = "NoHurtCam",
category = Module.Category.RENDER,
description = "Disables the 'hurt' camera effect"
)
public class NoHurtCam extends Module {
private static NoHurtCam INSTANCE;
public NoHurtCam() {
INSTANCE = this;
}
public static boolean shouldDisable() {
return INSTANCE != null && INSTANCE.isEnabled();
}
}

26
src/main/java/me/zeroeightsix/kami/module/modules/render/NoHurtCam.kt Normal file
View File

@ -0,0 +1,26 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
/**
* @author 086
*/
@Module.Info(
name = "NoHurtCam",
category = Module.Category.RENDER,
description = "Disables the 'hurt' camera effect"
)
class NoHurtCam : Module() {
companion object {
private var INSTANCE: NoHurtCam? = null
@JvmStatic
fun shouldDisable(): Boolean {
return INSTANCE != null && INSTANCE!!.isEnabled
}
}
init {
INSTANCE = this
}
}

67
src/main/java/me/zeroeightsix/kami/module/modules/render/NoRender.java
View File

@ -1,67 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zero.alpine.listener.EventHandler;
import me.zero.alpine.listener.Listener;
import me.zeroeightsix.kami.event.events.PacketEvent;
import me.zeroeightsix.kami.event.events.WorldCheckLightForEvent;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.*;
import net.minecraft.world.EnumSkyBlock;
import net.minecraftforge.client.event.RenderBlockOverlayEvent;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
/**
* Created by 086 on 4/02/2018.
* Updated by dominikaaaa on 14/04/20
*
* Skylight Updates taken from https://github.com/fr1kin/ForgeHax/blob/1a4f98d/src/main/java/com/matt/forgehax/mods/NoSkylightUpdates.java
*/
@Module.Info(
name = "NoRender",
category = Module.Category.RENDER,
description = "Ignore entity spawn packets"
)
public class NoRender extends Module {
private Setting<Boolean> mob = register(Settings.b("Mob", false));
private Setting<Boolean> sand = register(Settings.b("Sand", false));
private Setting<Boolean> gentity = register(Settings.b("GEntity", false));
private Setting<Boolean> object = register(Settings.b("Object", false));
public Setting<Boolean> items = register(Settings.b("Items", false));
private Setting<Boolean> xp = register(Settings.b("XP", false));
private Setting<Boolean> paint = register(Settings.b("Paintings", false));
private Setting<Boolean> fire = register(Settings.b("Fire", true));
private Setting<Boolean> explosion = register(Settings.b("Explosions", true));
public Setting<Boolean> beacon = register(Settings.b("Beacon Beams", false));
private Setting<Boolean> skylight = register(Settings.b("Skylight Updates", false));
@EventHandler
public Listener<PacketEvent.Receive> receiveListener = new Listener<>(event -> {
Packet packet = event.getPacket();
if ((packet instanceof SPacketSpawnMob && mob.getValue()) ||
(packet instanceof SPacketSpawnGlobalEntity && gentity.getValue()) ||
(packet instanceof SPacketSpawnObject && object.getValue()) ||
(packet instanceof SPacketSpawnExperienceOrb && xp.getValue()) ||
(packet instanceof SPacketSpawnObject && sand.getValue()) ||
(packet instanceof SPacketExplosion && explosion.getValue()) ||
(packet instanceof SPacketSpawnPainting && paint.getValue()))
event.cancel();
});
@EventHandler
public Listener<RenderBlockOverlayEvent> blockOverlayEventListener = new Listener<>(event -> {
if (fire.getValue() && event.getOverlayType() == RenderBlockOverlayEvent.OverlayType.FIRE)
event.setCanceled(true);
});
@SubscribeEvent
public void onLightingUpdate(WorldCheckLightForEvent event) {
if (skylight.getValue() && event.getEnumSkyBlock() == EnumSkyBlock.SKY) {
event.setCanceled(true);
}
}
}

63
src/main/java/me/zeroeightsix/kami/module/modules/render/NoRender.kt Normal file
View File

@ -0,0 +1,63 @@
package me.zeroeightsix.kami.module.modules.render
import me.zero.alpine.listener.EventHandler
import me.zero.alpine.listener.EventHook
import me.zero.alpine.listener.Listener
import me.zeroeightsix.kami.event.events.PacketEvent.Receive
import me.zeroeightsix.kami.event.events.WorldCheckLightForEvent
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Setting
import me.zeroeightsix.kami.setting.Settings
import net.minecraft.network.play.server.*
import net.minecraft.world.EnumSkyBlock
import net.minecraftforge.client.event.RenderBlockOverlayEvent
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
/**
* Created by 086 on 4/02/2018.
* Updated by dominikaaaa on 14/04/20
*
* Skylight Updates taken from https://github.com/fr1kin/ForgeHax/blob/1a4f98d/src/main/java/com/matt/forgehax/mods/NoSkylightUpdates.java
*/
@Module.Info(
name = "NoRender",
category = Module.Category.RENDER,
description = "Ignore entity spawn packets"
)
class NoRender : Module() {
private val mob = register(Settings.b("Mob", false))
private val sand = register(Settings.b("Sand", false))
private val gEntity = register(Settings.b("GEntity", false))
private val `object` = register(Settings.b("Object", false))
@JvmField
var items: Setting<Boolean> = register(Settings.b("Items", false))
private val xp = register(Settings.b("XP", false))
private val paint = register(Settings.b("Paintings", false))
private val fire = register(Settings.b("Fire", true))
private val explosion = register(Settings.b("Explosions", true))
@JvmField
var beacon: Setting<Boolean> = register(Settings.b("Beacon Beams", false))
private val skylight = register(Settings.b("Skylight Updates", false))
@EventHandler
var receiveListener = Listener(EventHook { event: Receive ->
val packet = event.packet
if (packet is SPacketSpawnMob && mob.value ||
packet is SPacketSpawnGlobalEntity && gEntity.value ||
packet is SPacketSpawnObject && `object`.value ||
packet is SPacketSpawnExperienceOrb && xp.value ||
packet is SPacketSpawnObject && sand.value ||
packet is SPacketExplosion && explosion.value ||
packet is SPacketSpawnPainting && paint.value) event.cancel()
})
@EventHandler
var blockOverlayEventListener = Listener(EventHook { event: RenderBlockOverlayEvent -> if (fire.value && event.overlayType == RenderBlockOverlayEvent.OverlayType.FIRE) event.isCanceled = true })
@SubscribeEvent
fun onLightingUpdate(event: WorldCheckLightForEvent) {
if (skylight.value && event.enumSkyBlock == EnumSkyBlock.SKY) {
event.isCanceled = true
}
}
}

7
src/main/java/me/zeroeightsix/kami/module/modules/render/ShulkerPreview.java → src/main/java/me/zeroeightsix/kami/module/modules/render/ShulkerPreview.kt
View File

@ -1,6 +1,6 @@
package me.zeroeightsix.kami.module.modules.render;
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.module.Module
/**
* Created by 086 on 24/12/2017.
@ -12,5 +12,4 @@ import me.zeroeightsix.kami.module.Module;
category = Module.Category.RENDER,
description = "Previews shulkers in the game GUI"
)
public class ShulkerPreview extends Module {
}
class ShulkerPreview : Module()

139
src/main/java/me/zeroeightsix/kami/module/modules/render/StorageESP.java
View File

@ -1,139 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.event.events.RenderEvent;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import me.zeroeightsix.kami.util.ColourUtils;
import me.zeroeightsix.kami.util.GeometryMasks;
import me.zeroeightsix.kami.util.KamiTessellator;
import me.zeroeightsix.kami.util.Wrapper;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityItemFrame;
import net.minecraft.entity.item.EntityMinecartChest;
import net.minecraft.item.ItemShulkerBox;
import net.minecraft.tileentity.*;
import net.minecraft.util.math.BlockPos;
import org.lwjgl.opengl.GL11;
import java.util.ArrayList;
/**
* Created by 086 on 10/12/2017.
* Updated by dominikaaaa on 14/12/19
*/
@Module.Info(
name = "StorageESP",
description = "Draws nice little lines around storage items",
category = Module.Category.RENDER
)
public class StorageESP extends Module {
private Setting<Boolean> chest = register(Settings.b("Chest", true));
private Setting<Boolean> dispenser = register(Settings.b("Dispenser", true));
private Setting<Boolean> shulker = register(Settings.b("Shulker", true));
private Setting<Boolean> echest = register(Settings.b("Ender Chest", true));
private Setting<Boolean> furnace = register(Settings.b("Furnace", true));
private Setting<Boolean> hopper = register(Settings.b("Hopper", true));
private Setting<Boolean> cart = register(Settings.b("Minecart", true));
private Setting<Boolean> frame = register(Settings.b("Item Frame", true));
private int getTileEntityColor(TileEntity tileEntity) {
if (tileEntity instanceof TileEntityChest || tileEntity instanceof TileEntityDispenser)
return ColourUtils.Colors.ORANGE;
else if (tileEntity instanceof TileEntityShulkerBox)
return ColourUtils.Colors.RED;
else if (tileEntity instanceof TileEntityEnderChest)
return ColourUtils.Colors.PURPLE;
else if (tileEntity instanceof TileEntityFurnace)
return ColourUtils.Colors.GRAY;
else if (tileEntity instanceof TileEntityHopper)
return ColourUtils.Colors.DARK_RED;
else
return -1;
}
private int getEntityColor(Entity entity) {
if (entity instanceof EntityMinecartChest)
return ColourUtils.Colors.ORANGE;
else if (entity instanceof EntityItemFrame &&
((EntityItemFrame) entity).getDisplayedItem().getItem() instanceof ItemShulkerBox)
return ColourUtils.Colors.YELLOW;
else if (entity instanceof EntityItemFrame &&
(!(((EntityItemFrame) entity).getDisplayedItem().getItem() instanceof ItemShulkerBox)))
return ColourUtils.Colors.ORANGE;
else
return -1;
}
@Override
public void onWorldRender(RenderEvent event) {
ArrayList<Triplet<BlockPos, Integer, Integer>> a = new ArrayList<>();
GlStateManager.pushMatrix();
for (TileEntity tileEntity : Wrapper.getWorld().loadedTileEntityList) {
BlockPos pos = tileEntity.getPos();
int color = getTileEntityColor(tileEntity);
int side = GeometryMasks.Quad.ALL;
if (tileEntity instanceof TileEntityChest) {
TileEntityChest chest = (TileEntityChest) tileEntity;
// Leave only the colliding face and then flip the bits (~) to have ALL but that face
if (chest.adjacentChestZNeg != null) side = ~(side & GeometryMasks.Quad.NORTH);
if (chest.adjacentChestXPos != null) side = ~(side & GeometryMasks.Quad.EAST);
if (chest.adjacentChestZPos != null) side = ~(side & GeometryMasks.Quad.SOUTH);
if (chest.adjacentChestXNeg != null) side = ~(side & GeometryMasks.Quad.WEST);
}
if ((tileEntity instanceof TileEntityChest && chest.getValue()) || (tileEntity instanceof TileEntityDispenser && dispenser.getValue()) || (tileEntity instanceof TileEntityShulkerBox && shulker.getValue()) || (tileEntity instanceof TileEntityEnderChest && echest.getValue()) || (tileEntity instanceof TileEntityFurnace && furnace.getValue()) || (tileEntity instanceof TileEntityHopper && hopper.getValue()))
if (color != -1)
a.add(new Triplet<>(pos, color, side)); //GeometryTessellator.drawCuboid(event.getBuffer(), pos, GeometryMasks.Line.ALL, color);
}
for (Entity entity : Wrapper.getWorld().loadedEntityList) {
BlockPos pos = entity.getPosition();
int color = getEntityColor(entity);
if ((entity instanceof EntityItemFrame && frame.getValue()) || (entity instanceof EntityMinecartChest && cart.getValue()))
if (color != -1)
a.add(new Triplet<>(entity instanceof EntityItemFrame ? pos.add(0, -1, 0) : pos, color, GeometryMasks.Quad.ALL)); //GeometryTessellator.drawCuboid(event.getBuffer(), entity instanceof EntityItemFrame ? pos.add(0, -1, 0) : pos, GeometryMasks.Line.ALL, color);
}
KamiTessellator.prepare(GL11.GL_QUADS);
for (Triplet<BlockPos, Integer, Integer> pair : a)
KamiTessellator.drawBox(pair.getFirst(), changeAlpha(pair.getSecond(), 100), pair.getThird());
KamiTessellator.release();
GlStateManager.popMatrix();
GlStateManager.enableTexture2D();
}
int changeAlpha(int origColor, int userInputedAlpha) {
origColor = origColor & 0x00ffffff; //drop the previous alpha value
return (userInputedAlpha << 24) | origColor; //add the one the user inputted
}
public class Triplet<T, U, V> {
private final T first;
private final U second;
private final V third;
public Triplet(T first, U second, V third) {
this.first = first;
this.second = second;
this.third = third;
}
public T getFirst() {
return first;
}
public U getSecond() {
return second;
}
public V getThird() {
return third;
}
}
}

83
src/main/java/me/zeroeightsix/kami/module/modules/render/StorageESP.kt Normal file
View File

@ -0,0 +1,83 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.event.events.RenderEvent
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Settings
import me.zeroeightsix.kami.util.ColourUtils
import me.zeroeightsix.kami.util.GeometryMasks
import me.zeroeightsix.kami.util.KamiTessellator
import me.zeroeightsix.kami.util.Wrapper
import net.minecraft.client.renderer.GlStateManager
import net.minecraft.entity.Entity
import net.minecraft.entity.item.EntityItemFrame
import net.minecraft.entity.item.EntityMinecartChest
import net.minecraft.item.ItemShulkerBox
import net.minecraft.tileentity.*
import net.minecraft.util.math.BlockPos
import org.lwjgl.opengl.GL11
import java.util.*
/**
* Created by 086 on 10/12/2017.
* Updated by dominikaaaa on 14/12/19
*/
@Module.Info(
name = "StorageESP",
description = "Draws nice little lines around storage items",
category = Module.Category.RENDER
)
class StorageESP : Module() {
private val chest = register(Settings.b("Chest", true))
private val dispenser = register(Settings.b("Dispenser", true))
private val shulker = register(Settings.b("Shulker", true))
private val enderChest = register(Settings.b("Ender Chest", true))
private val furnace = register(Settings.b("Furnace", true))
private val hopper = register(Settings.b("Hopper", true))
private val cart = register(Settings.b("Minecart", true))
private val frame = register(Settings.b("Item Frame", true))
private fun getTileEntityColor(tileEntity: TileEntity): Int {
return if (tileEntity is TileEntityChest || tileEntity is TileEntityDispenser) ColourUtils.Colors.ORANGE else if (tileEntity is TileEntityShulkerBox) ColourUtils.Colors.RED else if (tileEntity is TileEntityEnderChest) ColourUtils.Colors.PURPLE else if (tileEntity is TileEntityFurnace) ColourUtils.Colors.GRAY else if (tileEntity is TileEntityHopper) ColourUtils.Colors.DARK_RED else -1
}
private fun getEntityColor(entity: Entity): Int {
return if (entity is EntityMinecartChest) ColourUtils.Colors.ORANGE else if (entity is EntityItemFrame &&
entity.displayedItem.getItem() is ItemShulkerBox) ColourUtils.Colors.YELLOW else if (entity is EntityItemFrame &&
entity.displayedItem.getItem() !is ItemShulkerBox) ColourUtils.Colors.ORANGE else -1
}
override fun onWorldRender(event: RenderEvent) {
val a = ArrayList<Triplet<BlockPos, Int, Int>>()
GlStateManager.pushMatrix()
for (tileEntity in Wrapper.getWorld().loadedTileEntityList) {
val pos = tileEntity.pos
val color = getTileEntityColor(tileEntity)
var side = GeometryMasks.Quad.ALL
if (tileEntity is TileEntityChest) {
// Leave only the colliding face and then flip the bits (~) to have ALL but that face
if (tileEntity.adjacentChestZNeg != null) side = (side and GeometryMasks.Quad.NORTH).inv()
if (tileEntity.adjacentChestXPos != null) side = (side and GeometryMasks.Quad.EAST).inv()
if (tileEntity.adjacentChestZPos != null) side = (side and GeometryMasks.Quad.SOUTH).inv()
if (tileEntity.adjacentChestXNeg != null) side = (side and GeometryMasks.Quad.WEST).inv()
}
if (tileEntity is TileEntityChest && chest.value || tileEntity is TileEntityDispenser && dispenser.value || tileEntity is TileEntityShulkerBox && shulker.value || tileEntity is TileEntityEnderChest && enderChest.value || tileEntity is TileEntityFurnace && furnace.value || tileEntity is TileEntityHopper && hopper.value) if (color != -1) a.add(Triplet(pos, color, side)) //GeometryTessellator.drawCuboid(event.getBuffer(), pos, GeometryMasks.Line.ALL, color);
}
for (entity in Wrapper.getWorld().loadedEntityList) {
val pos = entity.position
val color = getEntityColor(entity)
if (entity is EntityItemFrame && frame.value || entity is EntityMinecartChest && cart.value) if (color != -1) a.add(Triplet(if (entity is EntityItemFrame) pos.add(0, -1, 0) else pos, color, GeometryMasks.Quad.ALL)) //GeometryTessellator.drawCuboid(event.getBuffer(), entity instanceof EntityItemFrame ? pos.add(0, -1, 0) : pos, GeometryMasks.Line.ALL, color);
}
KamiTessellator.prepare(GL11.GL_QUADS)
for (pair in a) KamiTessellator.drawBox(pair.first, changeAlpha(pair.second, 100), pair.third)
KamiTessellator.release()
GlStateManager.popMatrix()
GlStateManager.enableTexture2D()
}
private fun changeAlpha(origColor: Int, userInputedAlpha: Int): Int {
var origColor = origColor
origColor = origColor and 0x00ffffff //drop the previous alpha value
return userInputedAlpha shl 24 or origColor //add the one the user inputted
}
inner class Triplet<T, U, V>(val first: T, val second: U, val third: V)
}

28
src/main/java/me/zeroeightsix/kami/module/modules/render/TabFriends.java
View File

@ -1,28 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.KamiMod;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.util.Friends;
import net.minecraft.client.network.NetworkPlayerInfo;
import net.minecraft.scoreboard.ScorePlayerTeam;
@Module.Info(
name = "TabFriends",
description = "Highlights friends in the tab menu",
category = Module.Category.RENDER,
showOnArray = Module.ShowOnArray.OFF
)
public class TabFriends extends Module {
public static TabFriends INSTANCE;
public TabFriends() {
TabFriends.INSTANCE = this;
}
public static String getPlayerName(NetworkPlayerInfo networkPlayerInfoIn) {
String dname = networkPlayerInfoIn.getDisplayName() != null ? networkPlayerInfoIn.getDisplayName().getFormattedText() : ScorePlayerTeam.formatPlayerName(networkPlayerInfoIn.getPlayerTeam(), networkPlayerInfoIn.getGameProfile().getName());
if (Friends.isFriend(dname)) return String.format("%sa%s", KamiMod.colour, dname);
return dname;
}
}

29
src/main/java/me/zeroeightsix/kami/module/modules/render/TabFriends.kt Normal file
View File

@ -0,0 +1,29 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.KamiMod
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.util.Friends
import net.minecraft.client.network.NetworkPlayerInfo
import net.minecraft.scoreboard.ScorePlayerTeam
@Module.Info(
name = "TabFriends",
description = "Highlights friends in the tab menu",
category = Module.Category.RENDER,
showOnArray = Module.ShowOnArray.OFF
)
class TabFriends : Module() {
companion object {
@JvmField
var INSTANCE: TabFriends? = null
@JvmStatic
fun getPlayerName(networkPlayerInfoIn: NetworkPlayerInfo): String {
val dname = if (networkPlayerInfoIn.displayName != null) networkPlayerInfoIn.displayName!!.formattedText else ScorePlayerTeam.formatPlayerName(networkPlayerInfoIn.playerTeam, networkPlayerInfoIn.gameProfile.name)
return if (Friends.isFriend(dname)) String.format("%sa%s", KamiMod.colour, dname) else dname
}
}
init {
INSTANCE = this
}
}

191
src/main/java/me/zeroeightsix/kami/module/modules/render/Tracers.java
View File

@ -1,191 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.event.events.RenderEvent;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import me.zeroeightsix.kami.util.ColourUtils;
import me.zeroeightsix.kami.util.EntityUtil;
import me.zeroeightsix.kami.util.Friends;
import me.zeroeightsix.kami.util.HueCycler;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.math.Vec3d;
import org.lwjgl.opengl.GL11;
import static me.zeroeightsix.kami.util.ColourConverter.rgbToInt;
/**
* Created by 086 on 11/12/2017.
* <p>
* Kurisu Makise is best girl
*/
@Module.Info(
name = "Tracers",
description = "Draws lines to other living entities",
category = Module.Category.RENDER
)
public class Tracers extends Module {
private Setting<Boolean> players = register(Settings.b("Players", true));
private Setting<Boolean> friends = register(Settings.b("Friends", true));
private Setting<Boolean> animals = register(Settings.b("Animals", false));
private Setting<Boolean> mobs = register(Settings.b("Mobs", false));
private Setting<Double> range = register(Settings.d("Range", 200));
private Setting<Boolean> renderInvis = register(Settings.b("Invisible", false));
private Setting<Boolean> customColours = register(Settings.booleanBuilder("Custom Colours").withValue(true).build());
private Setting<Float> opacity = register(Settings.floatBuilder("Opacity").withRange(0f, 1f).withValue(1f).build());
private Setting<Integer> r = register(Settings.integerBuilder("Red").withMinimum(0).withValue(155).withMaximum(255).withVisibility(v -> customColours.getValue()).build());
private Setting<Integer> g = register(Settings.integerBuilder("Green").withMinimum(0).withValue(144).withMaximum(255).withVisibility(v -> customColours.getValue()).build());
private Setting<Integer> b = register(Settings.integerBuilder("Blue").withMinimum(0).withValue(255).withMaximum(255).withVisibility(v -> customColours.getValue()).build());
HueCycler cycler = new HueCycler(3600);
@Override
public void onWorldRender(RenderEvent event) {
GlStateManager.pushMatrix();
Minecraft.getMinecraft().world.loadedEntityList.stream()
.filter(EntityUtil::isLiving)
.filter(entity -> {
if (entity.isInvisible()) {
return renderInvis.getValue();
}
return true;
})
.filter(entity -> !EntityUtil.isFakeLocalPlayer(entity))
.filter(entity -> (entity instanceof EntityPlayer ? players.getValue() && mc.player != entity : (EntityUtil.isPassive(entity) ? animals.getValue() : mobs.getValue())))
.filter(entity -> mc.player.getDistance(entity) < range.getValue())
.forEach(entity -> {
int colour = getColour(entity);
if (colour == ColourUtils.Colors.RAINBOW) {
if (!friends.getValue()) return;
if (customColours.getValue()) {
colour = rgbToInt(r.getValue(), g.getValue(), b.getValue(), (int) (opacity.getValue() * 255f));
} else {
colour = cycler.current();
}
} else {
colour = cycler.current();
}
final float r = ((colour >>> 16) & 0xFF) / 255f;
final float g = ((colour >>> 8) & 0xFF) / 255f;
final float b = (colour & 0xFF) / 255f;
drawLineToEntity(entity, r, g, b, opacity.getValue());
});
GlStateManager.popMatrix();
}
@Override
public void onUpdate() {
cycler.next();
}
private void drawRainbowToEntity(Entity entity, float opacity) {
Vec3d eyes = new Vec3d(0, 0, 1)
.rotatePitch(-(float) Math
.toRadians(Minecraft.getMinecraft().player.rotationPitch))
.rotateYaw(-(float) Math
.toRadians(Minecraft.getMinecraft().player.rotationYaw));
double[] xyz = interpolate(entity);
double posx = xyz[0];
double posy = xyz[1];
double posz = xyz[2];
double posx2 = eyes.x;
double posy2 = eyes.y + mc.player.getEyeHeight();
double posz2 = eyes.z;
GL11.glBlendFunc(770, 771);
GL11.glEnable(GL11.GL_BLEND);
GL11.glLineWidth(1.5f);
GL11.glDisable(GL11.GL_TEXTURE_2D);
GL11.glDisable(GL11.GL_DEPTH_TEST);
GL11.glDepthMask(false);
cycler.reset();
cycler.setNext(opacity);
GlStateManager.disableLighting();
GL11.glLoadIdentity();
mc.entityRenderer.orientCamera(mc.getRenderPartialTicks());
GL11.glBegin(GL11.GL_LINES);
{
GL11.glVertex3d(posx, posy, posz);
GL11.glVertex3d(posx2, posy2, posz2);
cycler.setNext(opacity);
GL11.glVertex3d(posx2, posy2, posz2);
GL11.glVertex3d(posx2, posy2, posz2);
}
GL11.glEnd();
GL11.glEnable(GL11.GL_TEXTURE_2D);
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glDepthMask(true);
GL11.glDisable(GL11.GL_BLEND);
GL11.glColor3d(1d, 1d, 1d);
GlStateManager.enableLighting();
}
private int getColour(Entity entity) {
if (entity instanceof EntityPlayer) {
return Friends.isFriend(entity.getName()) ? ColourUtils.Colors.RAINBOW : ColourUtils.Colors.WHITE;
} else {
if (EntityUtil.isPassive(entity)) return ColourUtils.Colors.GREEN;
else
return ColourUtils.Colors.RED;
}
}
public static double interpolate(double now, double then) {
return then + (now - then) * mc.getRenderPartialTicks();
}
public static double[] interpolate(Entity entity) {
double posX = interpolate(entity.posX, entity.lastTickPosX) - mc.getRenderManager().renderPosX;
double posY = interpolate(entity.posY, entity.lastTickPosY) - mc.getRenderManager().renderPosY;
double posZ = interpolate(entity.posZ, entity.lastTickPosZ) - mc.getRenderManager().renderPosZ;
return new double[]{posX, posY, posZ};
}
public static void drawLineToEntity(Entity e, float red, float green, float blue, float opacity) {
double[] xyz = interpolate(e);
drawLine(xyz[0], xyz[1], xyz[2], e.height, red, green, blue, opacity);
}
public static void drawLine(double posx, double posy, double posz, double up, float red, float green, float blue, float opacity) {
Vec3d eyes = new Vec3d(0, 0, 1)
.rotatePitch(-(float) Math
.toRadians(Minecraft.getMinecraft().player.rotationPitch))
.rotateYaw(-(float) Math
.toRadians(Minecraft.getMinecraft().player.rotationYaw));
drawLineFromPosToPos(eyes.x, eyes.y + mc.player.getEyeHeight(), eyes.z, posx, posy, posz, up, red, green, blue, opacity);
}
public static void drawLineFromPosToPos(double posx, double posy, double posz, double posx2, double posy2, double posz2, double up, float red, float green, float blue, float opacity) {
GL11.glBlendFunc(770, 771);
GL11.glLineWidth(1.5f);
GL11.glDisable(GL11.GL_TEXTURE_2D);
GL11.glDisable(GL11.GL_DEPTH_TEST);
GL11.glDepthMask(false);
GL11.glColor4f(red, green, blue, opacity);
GlStateManager.disableLighting();
GL11.glLoadIdentity();
mc.entityRenderer.orientCamera(mc.getRenderPartialTicks());
GL11.glBegin(GL11.GL_LINES);
{
GL11.glVertex3d(posx, posy, posz);
GL11.glVertex3d(posx2, posy2, posz2);
GL11.glVertex3d(posx2, posy2, posz2);
GL11.glVertex3d(posx2, posy2 + up, posz2);
}
GL11.glEnd();
GL11.glEnable(GL11.GL_TEXTURE_2D);
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glDepthMask(true);
GL11.glColor3d(1d, 1d, 1d);
GlStateManager.enableLighting();
}
}

176
src/main/java/me/zeroeightsix/kami/module/modules/render/Tracers.kt Normal file
View File

@ -0,0 +1,176 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.event.events.RenderEvent
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Settings
import me.zeroeightsix.kami.util.*
import net.minecraft.client.Minecraft
import net.minecraft.client.renderer.GlStateManager
import net.minecraft.entity.Entity
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.util.math.Vec3d
import org.lwjgl.opengl.GL11
/**
* Created by 086 on 11/12/2017.
*
*
* Kurisu Makise is best girl
*/
@Module.Info(
name = "Tracers",
description = "Draws lines to other living entities",
category = Module.Category.RENDER
)
class Tracers : Module() {
private val players = register(Settings.b("Players", true))
private val friends = register(Settings.b("Friends", true))
private val animals = register(Settings.b("Animals", false))
private val mobs = register(Settings.b("Mobs", false))
private val range = register(Settings.d("Range", 200.0))
private val renderInvis = register(Settings.b("Invisible", false))
private val customColours = register(Settings.booleanBuilder("Custom Colours").withValue(true).build())
private val opacity = register(Settings.floatBuilder("Opacity").withRange(0f, 1f).withValue(1f).build())
private val r = register(Settings.integerBuilder("Red").withMinimum(0).withValue(155).withMaximum(255).withVisibility { v: Int? -> customColours.value }.build())
private val g = register(Settings.integerBuilder("Green").withMinimum(0).withValue(144).withMaximum(255).withVisibility { v: Int? -> customColours.value }.build())
private val b = register(Settings.integerBuilder("Blue").withMinimum(0).withValue(255).withMaximum(255).withVisibility { v: Int? -> customColours.value }.build())
private var cycler = HueCycler(3600)
override fun onWorldRender(event: RenderEvent) {
GlStateManager.pushMatrix()
Minecraft.getMinecraft().world.loadedEntityList.stream()
.filter { e: Entity? -> EntityUtil.isLiving(e) }
.filter { entity: Entity ->
if (entity.isInvisible) {
return@filter renderInvis.value
}
true
}
.filter { entity: Entity? -> !EntityUtil.isFakeLocalPlayer(entity) }
.filter { entity: Entity -> if (entity is EntityPlayer) players.value && mc.player !== entity else if (EntityUtil.isPassive(entity)) animals.value else mobs.value }
.filter { entity: Entity? -> mc.player.getDistance(entity) < range.value }
.forEach { entity: Entity ->
var colour = getColour(entity)
colour = if (colour == ColourUtils.Colors.RAINBOW) {
if (!friends.value) return@forEach
if (customColours.value) {
ColourConverter.rgbToInt(r.value, g.value, b.value, (opacity.value * 255f).toInt())
} else {
cycler.current()
}
} else {
cycler.current()
}
val r = (colour ushr 16 and 0xFF) / 255f
val g = (colour ushr 8 and 0xFF) / 255f
val b = (colour and 0xFF) / 255f
drawLineToEntity(entity, r, g, b, opacity.value)
}
GlStateManager.popMatrix()
}
override fun onUpdate() {
cycler.next()
}
private fun drawRainbowToEntity(entity: Entity, opacity: Float) {
val eyes = Vec3d(0.0, 0.0, 1.0)
.rotatePitch((-Math
.toRadians(Minecraft.getMinecraft().player.rotationPitch.toDouble())).toFloat())
.rotateYaw((-Math
.toRadians(Minecraft.getMinecraft().player.rotationYaw.toDouble())).toFloat())
val xyz = interpolate(entity)
val posx = xyz[0]
val posy = xyz[1]
val posz = xyz[2]
val posx2 = eyes.x
val posy2 = eyes.y + mc.player.getEyeHeight()
val posz2 = eyes.z
GL11.glBlendFunc(770, 771)
GL11.glEnable(GL11.GL_BLEND)
GL11.glLineWidth(1.5f)
GL11.glDisable(GL11.GL_TEXTURE_2D)
GL11.glDisable(GL11.GL_DEPTH_TEST)
GL11.glDepthMask(false)
cycler.reset()
cycler.setNext(opacity)
GlStateManager.disableLighting()
GL11.glLoadIdentity()
mc.entityRenderer.orientCamera(mc.renderPartialTicks)
GL11.glBegin(GL11.GL_LINES)
run {
GL11.glVertex3d(posx, posy, posz)
GL11.glVertex3d(posx2, posy2, posz2)
cycler.setNext(opacity)
GL11.glVertex3d(posx2, posy2, posz2)
GL11.glVertex3d(posx2, posy2, posz2)
}
GL11.glEnd()
GL11.glEnable(GL11.GL_TEXTURE_2D)
GL11.glEnable(GL11.GL_DEPTH_TEST)
GL11.glDepthMask(true)
GL11.glDisable(GL11.GL_BLEND)
GL11.glColor3d(1.0, 1.0, 1.0)
GlStateManager.enableLighting()
}
private fun getColour(entity: Entity): Int {
return if (entity is EntityPlayer) {
if (Friends.isFriend(entity.getName())) ColourUtils.Colors.RAINBOW else ColourUtils.Colors.WHITE
} else {
if (EntityUtil.isPassive(entity)) ColourUtils.Colors.GREEN else ColourUtils.Colors.RED
}
}
companion object {
private fun interpolate(now: Double, then: Double): Double {
return then + (now - then) * mc.renderPartialTicks
}
fun interpolate(entity: Entity): DoubleArray {
val posX = interpolate(entity.posX, entity.lastTickPosX) - mc.getRenderManager().renderPosX
val posY = interpolate(entity.posY, entity.lastTickPosY) - mc.getRenderManager().renderPosY
val posZ = interpolate(entity.posZ, entity.lastTickPosZ) - mc.getRenderManager().renderPosZ
return doubleArrayOf(posX, posY, posZ)
}
fun drawLineToEntity(e: Entity, red: Float, green: Float, blue: Float, opacity: Float) {
val xyz = interpolate(e)
drawLine(xyz[0], xyz[1], xyz[2], e.height.toDouble(), red, green, blue, opacity)
}
private fun drawLine(posx: Double, posy: Double, posz: Double, up: Double, red: Float, green: Float, blue: Float, opacity: Float) {
val eyes = Vec3d(0.0, 0.0, 1.0)
.rotatePitch((-Math
.toRadians(Minecraft.getMinecraft().player.rotationPitch.toDouble())).toFloat())
.rotateYaw((-Math
.toRadians(Minecraft.getMinecraft().player.rotationYaw.toDouble())).toFloat())
drawLineFromPosToPos(eyes.x, eyes.y + mc.player.getEyeHeight(), eyes.z, posx, posy, posz, up, red, green, blue, opacity)
}
@JvmStatic
fun drawLineFromPosToPos(posx: Double, posy: Double, posz: Double, posx2: Double, posy2: Double, posz2: Double, up: Double, red: Float, green: Float, blue: Float, opacity: Float) {
GL11.glBlendFunc(770, 771)
GL11.glLineWidth(1.5f)
GL11.glDisable(GL11.GL_TEXTURE_2D)
GL11.glDisable(GL11.GL_DEPTH_TEST)
GL11.glDepthMask(false)
GL11.glColor4f(red, green, blue, opacity)
GlStateManager.disableLighting()
GL11.glLoadIdentity()
mc.entityRenderer.orientCamera(mc.renderPartialTicks)
GL11.glBegin(GL11.GL_LINES)
run {
GL11.glVertex3d(posx, posy, posz)
GL11.glVertex3d(posx2, posy2, posz2)
GL11.glVertex3d(posx2, posy2, posz2)
GL11.glVertex3d(posx2, posy2 + up, posz2)
}
GL11.glEnd()
GL11.glEnable(GL11.GL_TEXTURE_2D)
GL11.glEnable(GL11.GL_DEPTH_TEST)
GL11.glDepthMask(true)
GL11.glColor3d(1.0, 1.0, 1.0)
GlStateManager.enableLighting()
}
}
}

182
src/main/java/me/zeroeightsix/kami/module/modules/render/XRay.java
View File

@ -1,182 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.KamiMod;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.util.BlockRenderLayer;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.event.RegistryEvent;
import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/**
* Created by 20kdc on 15/02/2020.
* Updated by dominikaaaa on 17/02/20
* Note for anybody using this in a development environment: THIS DOES NOT WORK. It will lag and the texture will break
*/
@Module.Info(
name = "XRay",
category = Module.Category.RENDER,
description = "See through common blocks!")
@EventBusSubscriber(modid = KamiMod.MODID
)
public class XRay extends Module {
// A default reasonable configuration for the XRay. Most people will want to use it like this.
private static final String DEFAULT_XRAY_CONFIG = "minecraft:grass,minecraft:dirt,minecraft:netherrack,minecraft:gravel,minecraft:sand,minecraft:stone";
// Split by ',' & each element trimmed (this is a bit weird but it works for now?)
private Setting<String> hiddenBlockNames = register(Settings.stringBuilder("HiddenBlocks").withValue(DEFAULT_XRAY_CONFIG).withConsumer((old, value) -> {
refreshHiddenBlocksSet(value);
if (isEnabled())
mc.renderGlobal.loadRenderers();
}).build());
public Setting<Boolean> invert = register(Settings.booleanBuilder("Invert").withValue(false).withConsumer((old, value) -> {
invertStatic = value;
if (isEnabled())
mc.renderGlobal.loadRenderers();
}).build());
private Setting<Boolean> outlines = register(Settings.booleanBuilder("Outlines").withValue(true).withConsumer((old, value) -> {
outlinesStatic = value;
if (isEnabled())
mc.renderGlobal.loadRenderers();
}).build());
// A static mirror of the state.
private static Set<Block> hiddenBlocks = Collections.synchronizedSet(new HashSet<>());
private static boolean invertStatic, outlinesStatic = true;
// This is the state used for hidden blocks.
private static IBlockState transparentState;
// This is used as part of a mechanism to make the Minecraft renderer play along with the XRay.
// Essentially, the XRay primitive is just a block state transformer.
// Then this implements a custom block that the block state transformer can use for hidden blocks.
public static Block transparentBlock;
public XRay() {
invertStatic = invert.getValue();
outlinesStatic = outlines.getValue();
refreshHiddenBlocksSet(hiddenBlockNames.getValue());
}
// Get hidden block list for command display
public String extGet() {
return extGetInternal(null);
}
// Add entry by arbitrary user-provided string
public void extAdd(String s) {
hiddenBlockNames.setValue(extGetInternal(null) + ", " + s);
}
// Remove entry by arbitrary user-provided string
public void extRemove(String s) {
hiddenBlockNames.setValue(extGetInternal(Block.getBlockFromName(s)));
}
// Clears the list.
public void extClear() {
hiddenBlockNames.setValue("");
}
// Resets the list to default
public void extDefaults() { extClear(); extAdd(DEFAULT_XRAY_CONFIG); }
// Set the list to 1 value
public void extSet(String s) { extClear(); extAdd(s); }
private String extGetInternal(Block filter) {
StringBuilder sb = new StringBuilder();
boolean notFirst = false;
for (Block b : hiddenBlocks) {
if (b == filter)
continue;
if (notFirst)
sb.append(", ");
notFirst = true;
sb.append(Block.REGISTRY.getNameForObject(b));
}
return sb.toString();
}
private void refreshHiddenBlocksSet(String v) {
hiddenBlocks.clear();
for (String s : v.split(",")) {
String s2 = s.trim();
Block block = Block.getBlockFromName(s2);
if (block != null)
hiddenBlocks.add(block);
}
}
@SubscribeEvent
public static void registerBlocks(RegistryEvent.Register<Block> event) {
transparentBlock = new Block(Material.GLASS) {
// did you know this name's new
@Override
public BlockRenderLayer getRenderLayer() {
return BlockRenderLayer.CUTOUT;
}
// Not opaque so other materials (such as, of course, ores) will render
@Override
public boolean isOpaqueCube(IBlockState blah) {
return false;
}
// Essentially, the hidden-block world should be a projected grid-like thing...?
@Override
public boolean shouldSideBeRendered(IBlockState blah, IBlockAccess w, BlockPos pos, EnumFacing side) {
BlockPos adj = pos.offset(side);
IBlockState other = w.getBlockState(adj);
// this directly adj. to this must never be rendered
if (other.getBlock() == this)
return false;
// if it contacts something opaque, don't render as we'll probably accidentally make it harder to see
return !other.isOpaqueCube();
}
};
transparentBlock.setRegistryName("kami_xray_transparent");
transparentState = transparentBlock.getDefaultState();
event.getRegistry().registerAll(transparentBlock);
}
@SubscribeEvent
public static void registerItems(RegistryEvent.Register<Item> event) {
// this runs after transparentBlock is set, right?
event.getRegistry().registerAll(new ItemBlock(transparentBlock).setRegistryName(transparentBlock.getRegistryName()));
}
public static IBlockState transform(IBlockState input) {
Block b = input.getBlock();
boolean hide = hiddenBlocks.contains(b);
if (invertStatic)
hide = !hide;
if (hide) {
IBlockState target = Blocks.AIR.getDefaultState();
if (outlinesStatic && (transparentState != null))
target = transparentState;
return target;
}
return input;
}
@Override
protected void onEnable() {
// This is important because otherwise the changes in ChunkCache behavior won't propagate.
// Also needs to be done if shouldHide effects change.
mc.renderGlobal.loadRenderers();
}
@Override
protected void onDisable() {
// This is important because otherwise the changes in ChunkCache behavior won't propagate.
// Also needs to be done if shouldHide effects change.
mc.renderGlobal.loadRenderers();
}
}

183
src/main/java/me/zeroeightsix/kami/module/modules/render/XRay.kt Normal file
View File

@ -0,0 +1,183 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.KamiMod
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Setting
import me.zeroeightsix.kami.setting.Settings
import net.minecraft.block.Block
import net.minecraft.block.material.Material
import net.minecraft.block.state.IBlockState
import net.minecraft.init.Blocks
import net.minecraft.item.Item
import net.minecraft.item.ItemBlock
import net.minecraft.util.BlockRenderLayer
import net.minecraft.util.EnumFacing
import net.minecraft.util.math.BlockPos
import net.minecraft.world.IBlockAccess
import net.minecraftforge.event.RegistryEvent
import net.minecraftforge.fml.common.Mod.EventBusSubscriber
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent
import java.util.*
/**
* Created by 20kdc on 15/02/2020.
* Updated by dominikaaaa on 17/02/20
* Note for anybody using this in a development environment: THIS DOES NOT WORK. It will lag and the texture will break
*/
@Module.Info(
name = "XRay",
category = Module.Category.RENDER,
description = "See through common blocks!"
)
@EventBusSubscriber(modid = KamiMod.MODID)
class XRay : Module() {
// Split by ',' & each element trimmed (this is a bit weird but it works for now?)
private val hiddenBlockNames = register(Settings.stringBuilder("HiddenBlocks").withValue(DEFAULT_XRAY_CONFIG).withConsumer { old: String?, value: String ->
refreshHiddenBlocksSet(value)
if (isEnabled) mc.renderGlobal.loadRenderers()
}.build())
@JvmField
var invert: Setting<Boolean> = register(Settings.booleanBuilder("Invert").withValue(false).withConsumer { old: Boolean?, value: Boolean ->
invertStatic = value
if (isEnabled) mc.renderGlobal.loadRenderers()
}.build())
private val outlines = register(Settings.booleanBuilder("Outlines").withValue(true).withConsumer { old: Boolean?, value: Boolean ->
outlinesStatic = value
if (isEnabled) mc.renderGlobal.loadRenderers()
}.build())
// Get hidden block list for command display
fun extGet(): String {
return extGetInternal(null)
}
// Add entry by arbitrary user-provided string
fun extAdd(s: String) {
hiddenBlockNames.value = extGetInternal(null) + ", " + s
}
// Remove entry by arbitrary user-provided string
fun extRemove(s: String?) {
hiddenBlockNames.value = extGetInternal(Block.getBlockFromName(s))
}
// Clears the list.
fun extClear() {
hiddenBlockNames.value = ""
}
// Resets the list to default
fun extDefaults() {
extClear()
extAdd(DEFAULT_XRAY_CONFIG)
}
// Set the list to 1 value
fun extSet(s: String) {
extClear()
extAdd(s)
}
private fun extGetInternal(filter: Block?): String {
val sb = StringBuilder()
var notFirst = false
for (b in hiddenBlocks) {
if (b === filter) continue
if (notFirst) sb.append(", ")
notFirst = true
sb.append(Block.REGISTRY.getNameForObject(b))
}
return sb.toString()
}
private fun refreshHiddenBlocksSet(v: String) {
hiddenBlocks.clear()
for (s in v.split(",").toTypedArray()) {
val s2 = s.trim { it <= ' ' }
val block = Block.getBlockFromName(s2)
if (block != null) hiddenBlocks.add(block)
}
}
override fun onEnable() {
// This is important because otherwise the changes in ChunkCache behavior won't propagate.
// Also needs to be done if shouldHide effects change.
mc.renderGlobal.loadRenderers()
}
override fun onDisable() {
// This is important because otherwise the changes in ChunkCache behavior won't propagate.
// Also needs to be done if shouldHide effects change.
mc.renderGlobal.loadRenderers()
}
companion object {
// A default reasonable configuration for the XRay. Most people will want to use it like this.
private const val DEFAULT_XRAY_CONFIG = "minecraft:grass,minecraft:dirt,minecraft:netherrack,minecraft:gravel,minecraft:sand,minecraft:stone"
// A static mirror of the state.
private val hiddenBlocks = Collections.synchronizedSet(HashSet<Block>())
private var invertStatic: Boolean = false
private var outlinesStatic = true
// This is the state used for hidden blocks.
private var transparentState: IBlockState? = null
// This is used as part of a mechanism to make the Minecraft renderer play along with the XRay.
// Essentially, the XRay primitive is just a block state transformer.
// Then this implements a custom block that the block state transformer can use for hidden blocks.
var transparentBlock: Block? = null
@SubscribeEvent
fun registerBlocks(event: RegistryEvent.Register<Block?>) {
transparentBlock = object : Block(Material.GLASS) {
// did you know this name's new
override fun getRenderLayer(): BlockRenderLayer {
return BlockRenderLayer.CUTOUT
}
// Not opaque so other materials (such as, of course, ores) will render
override fun isOpaqueCube(blah: IBlockState): Boolean {
return false
}
// Essentially, the hidden-block world should be a projected grid-like thing...?
override fun shouldSideBeRendered(blah: IBlockState, w: IBlockAccess, pos: BlockPos, side: EnumFacing): Boolean {
val adj = pos.offset(side)
val other = w.getBlockState(adj)
// this directly adj. to this must never be rendered
return if (other.block === this) false else !other.isOpaqueCube
// if it contacts something opaque, don't render as we'll probably accidentally make it harder to see
}
}
(transparentBlock as Block).setRegistryName("kami_xray_transparent")
transparentState = (transparentBlock as Block).defaultState
event.registry.registerAll(transparentBlock)
}
@SubscribeEvent
fun registerItems(event: RegistryEvent.Register<Item?>) {
// this runs after transparentBlock is set, right?
event.registry.registerAll(ItemBlock(transparentBlock).setRegistryName(transparentBlock!!.registryName))
}
@JvmStatic
fun transform(input: IBlockState): IBlockState? {
val b = input.block
var hide = hiddenBlocks.contains(b)
if (invertStatic) hide = !hide
if (hide) {
var target = Blocks.AIR.defaultState
if (outlinesStatic && transparentState != null) target = transparentState
return target
}
return input
}
}
init {
invertStatic = invert.value
outlinesStatic = outlines.value
refreshHiddenBlocksSet(hiddenBlockNames.value)
}
}

47
src/main/java/me/zeroeightsix/kami/module/modules/render/Zoom.java
View File

@ -1,47 +0,0 @@
package me.zeroeightsix.kami.module.modules.render;
import me.zeroeightsix.kami.module.Module;
import me.zeroeightsix.kami.setting.Setting;
import me.zeroeightsix.kami.setting.Settings;
/**
* @author dominikaaaa
* Created by dominikaaaa on 20/12/19
* Updated by dominikaaaa on 22/12/19
*/
@Module.Info(
name = "Zoom",
category = Module.Category.RENDER,
description = "Configures FOV",
showOnArray = Module.ShowOnArray.OFF
)
public class Zoom extends Module {
private float fov = 0;
private float sensi = 0;
private Setting<Integer> fovChange = register(Settings.integerBuilder("FOV").withMinimum(30).withValue(30).withMaximum(150).build());
private Setting<Float> sensChange = register(Settings.floatBuilder("Sensitivity").withMinimum(0.25F).withValue(1.3F).withMaximum(2F).build());
private Setting<Boolean> smoothCamera = register(Settings.b("Cinematic Camera", true));
private Setting<Boolean> sens = register(Settings.b("Sensitivity", true));
public void onEnable() {
if (mc.player == null) return;
fov = mc.gameSettings.fovSetting;
sensi = mc.gameSettings.mouseSensitivity;
if (smoothCamera.getValue()) mc.gameSettings.smoothCamera = true;
}
public void onDisable() {
mc.gameSettings.fovSetting = fov;
mc.gameSettings.mouseSensitivity = sensi;
if (smoothCamera.getValue()) mc.gameSettings.smoothCamera = false;
}
public void onUpdate() {
if (mc.player == null) return;
mc.gameSettings.fovSetting = fovChange.getValue();
mc.gameSettings.smoothCamera = smoothCamera.getValue();
if (sens.getValue()) mc.gameSettings.mouseSensitivity = sensi * sensChange.getValue();
}
}

38
src/main/java/me/zeroeightsix/kami/module/modules/render/Zoom.kt Normal file
View File

@ -0,0 +1,38 @@
package me.zeroeightsix.kami.module.modules.render
import me.zeroeightsix.kami.module.Module
import me.zeroeightsix.kami.setting.Settings
/**
* @author dominikaaaa
* Created by dominikaaaa on 20/12/19
* Updated by dominikaaaa on 22/12/19
*/
@Module.Info(name = "Zoom", category = Module.Category.RENDER, description = "Configures FOV", showOnArray = Module.ShowOnArray.OFF)
class Zoom : Module() {
private var fov = 0f
private var sensi = 0f
private val fovChange = register(Settings.integerBuilder("FOV").withMinimum(30).withValue(30).withMaximum(150).build())
private val sensChange = register(Settings.floatBuilder("Sensitivity").withMinimum(0.25f).withValue(1.3f).withMaximum(2f).build())
private val smoothCamera = register(Settings.b("Cinematic Camera", true))
private val sens = register(Settings.b("Sensitivity", true))
public override fun onEnable() {
if (mc.player == null) return
fov = mc.gameSettings.fovSetting
sensi = mc.gameSettings.mouseSensitivity
if (smoothCamera.value) mc.gameSettings.smoothCamera = true
}
public override fun onDisable() {
mc.gameSettings.fovSetting = fov
mc.gameSettings.mouseSensitivity = sensi
if (smoothCamera.value) mc.gameSettings.smoothCamera = false
}
override fun onUpdate() {
if (mc.player == null) return
mc.gameSettings.fovSetting = fovChange.value.toFloat()
mc.gameSettings.smoothCamera = smoothCamera.value
if (sens.value) mc.gameSettings.mouseSensitivity = sensi * sensChange.value
}
}