mirror of
https://github.com/GTNewHorizons/EnderIO.git
synced 2026-11-22 05:02:25 +00:00
512 lines
19 KiB
Java
512 lines
19 KiB
Java
package crazypants.enderio.item.darksteel;
|
|
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.entity.EntityClientPlayerMP;
|
|
import net.minecraft.entity.SharedMonsterAttributes;
|
|
import net.minecraft.entity.ai.attributes.AttributeModifier;
|
|
import net.minecraft.entity.ai.attributes.IAttributeInstance;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.potion.Potion;
|
|
import net.minecraft.potion.PotionEffect;
|
|
import net.minecraft.util.MathHelper;
|
|
import net.minecraft.util.MovementInput;
|
|
import net.minecraftforge.client.event.RenderPlayerEvent;
|
|
import net.minecraftforge.event.entity.player.PlayerEvent;
|
|
|
|
import org.lwjgl.opengl.GL11;
|
|
|
|
import cofh.api.energy.IEnergyContainerItem;
|
|
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
|
|
import cpw.mods.fml.common.gameevent.TickEvent;
|
|
import cpw.mods.fml.common.gameevent.TickEvent.Phase;
|
|
import cpw.mods.fml.relauncher.Side;
|
|
import cpw.mods.fml.relauncher.SideOnly;
|
|
import crazypants.enderio.EnderIO;
|
|
import crazypants.enderio.config.Config;
|
|
import crazypants.enderio.item.darksteel.PacketUpgradeState.Type;
|
|
import crazypants.enderio.item.darksteel.upgrade.EnergyUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.GliderUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.IDarkSteelUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.IRenderUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.JumpUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.NightVisionUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.SolarUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.SpeedUpgrade;
|
|
import crazypants.enderio.item.darksteel.upgrade.SwimUpgrade;
|
|
import crazypants.enderio.machine.solar.TileEntitySolarPanel;
|
|
import crazypants.enderio.network.PacketHandler;
|
|
import crazypants.util.Util;
|
|
import crazypants.vecmath.VecmathUtil;
|
|
import crazypants.vecmath.Vector3d;
|
|
import crazypants.vecmath.Vector4d;
|
|
|
|
public class DarkSteelController {
|
|
|
|
public static final DarkSteelController instance = new DarkSteelController();
|
|
|
|
private final AttributeModifier[] walkModifiers = new AttributeModifier[] {
|
|
new AttributeModifier(new UUID(12879874982l, 320981923), "generic.movementSpeed", SpeedUpgrade.WALK_MULTIPLIERS[0], 1),
|
|
new AttributeModifier(new UUID(12879874982l, 320981923), "generic.movementSpeed", SpeedUpgrade.WALK_MULTIPLIERS[1], 1),
|
|
new AttributeModifier(new UUID(12879874982l, 320981923), "generic.movementSpeed", SpeedUpgrade.WALK_MULTIPLIERS[2], 1),
|
|
};
|
|
|
|
private final AttributeModifier[] sprintModifiers = new AttributeModifier[] {
|
|
new AttributeModifier(new UUID(12879874982l, 320981923), "generic.movementSpeed", SpeedUpgrade.SPRINT_MULTIPLIERS[0], 1),
|
|
new AttributeModifier(new UUID(12879874982l, 320981923), "generic.movementSpeed", SpeedUpgrade.SPRINT_MULTIPLIERS[1], 1),
|
|
new AttributeModifier(new UUID(12879874982l, 320981923), "generic.movementSpeed", SpeedUpgrade.SPRINT_MULTIPLIERS[2], 1),
|
|
};
|
|
|
|
private final AttributeModifier swordDamageModifierPowered = new AttributeModifier(new UUID(63242325, 320981923), "Weapon modifier",
|
|
2, 0);
|
|
|
|
private boolean wasJumping;
|
|
private int jumpCount;
|
|
private int ticksSinceLastJump;
|
|
|
|
private final Map<UUID, Boolean> glideActiveMap = new HashMap<UUID, Boolean>();
|
|
private final Map<UUID, Boolean> speedActiveMap = new HashMap<UUID, Boolean>();
|
|
private final Map<UUID, Boolean> stepAssistActiveMap = new HashMap<UUID, Boolean>();
|
|
|
|
private boolean nightVisionActive = false;
|
|
private boolean removeNightvision = false;
|
|
|
|
private DarkSteelController() {
|
|
PacketHandler.INSTANCE.registerMessage(PacketDarkSteelPowerPacket.class, PacketDarkSteelPowerPacket.class, PacketHandler.nextID(), Side.SERVER);
|
|
PacketHandler.INSTANCE.registerMessage(PacketUpgradeState.class, PacketUpgradeState.class, PacketHandler.nextID(), Side.SERVER);
|
|
PacketHandler.INSTANCE.registerMessage(PacketUpgradeState.class, PacketUpgradeState.class, PacketHandler.nextID(), Side.CLIENT);
|
|
}
|
|
|
|
public boolean isActive(EntityPlayer player, Type type) {
|
|
switch(type) {
|
|
case GLIDE:
|
|
return isGlideActive(player);
|
|
case SPEED:
|
|
return isSpeedActive(player);
|
|
case STEP_ASSIST:
|
|
return isStepAssistActive(player);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void setGlideActive(EntityPlayer player, boolean isGlideActive) {
|
|
if(player.getGameProfile().getId() != null) {
|
|
glideActiveMap.put(player.getGameProfile().getId(), isGlideActive);
|
|
}
|
|
}
|
|
|
|
public boolean isGlideActive(EntityPlayer player) {
|
|
Boolean isActive = glideActiveMap.get(player.getGameProfile().getId());
|
|
if(isActive == null) {
|
|
return false;
|
|
}
|
|
return isActive.booleanValue();
|
|
}
|
|
|
|
public void setSpeedActive(EntityPlayer player, boolean isSpeedActive) {
|
|
if(player.getGameProfile().getId() != null) {
|
|
speedActiveMap.put(player.getGameProfile().getId(), isSpeedActive);
|
|
}
|
|
}
|
|
|
|
public boolean isSpeedActive(EntityPlayer player) {
|
|
Boolean isActive = speedActiveMap.get(player.getGameProfile().getId());
|
|
if(isActive == null) {
|
|
return true;
|
|
}
|
|
return isActive.booleanValue();
|
|
}
|
|
|
|
public void setStepAssistActive(EntityPlayer player, boolean isActive) {
|
|
if(player.getGameProfile().getId() != null) {
|
|
stepAssistActiveMap.put(player.getGameProfile().getId(), isActive);
|
|
}
|
|
}
|
|
|
|
public boolean isStepAssistActive(EntityPlayer player) {
|
|
Boolean isActive = stepAssistActiveMap.get(player.getGameProfile().getId());
|
|
if(isActive == null) {
|
|
return true;
|
|
}
|
|
return isActive.booleanValue();
|
|
}
|
|
|
|
@SubscribeEvent
|
|
public void onPlayerTick(TickEvent.PlayerTickEvent event) {
|
|
EntityPlayer player = event.player;
|
|
|
|
if(event.phase == Phase.START) {
|
|
//boots
|
|
updateStepHeightAndFallDistance(player);
|
|
|
|
//leggings
|
|
updateSpeed(player);
|
|
|
|
//sword
|
|
updateSword(player);
|
|
|
|
updateGlide(player);
|
|
|
|
updateSwim(player);
|
|
|
|
updateSolar(player);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private void updateSolar(EntityPlayer player) {
|
|
// no processing on client
|
|
if (player.worldObj.isRemote) {
|
|
return;
|
|
}
|
|
|
|
ItemStack helm = player.getEquipmentInSlot(4);
|
|
SolarUpgrade upgrade = SolarUpgrade.loadFromItem(helm);
|
|
if(upgrade == null) {
|
|
return;
|
|
}
|
|
|
|
int RFperSecond = Math.round((float) upgrade.getRFPerSec() * TileEntitySolarPanel.calculateLightRatio(player.worldObj, MathHelper.floor_double(player.posX), MathHelper.floor_double(player.posY + 1), MathHelper.floor_double(player.posZ)));
|
|
|
|
int leftover = RFperSecond % 20;
|
|
boolean addExtraRF = player.worldObj.getTotalWorldTime() % 20 < leftover;
|
|
|
|
int toAdd = (RFperSecond / 20) + (addExtraRF ? 1 : 0);
|
|
|
|
if(toAdd != 0) {
|
|
|
|
int nextIndex = player.getEntityData().getInteger("dsarmor:solar") % 4;
|
|
|
|
for (int i = 0; i < 4 && toAdd > 0; i++) {
|
|
ItemStack stack = player.inventory.armorInventory[nextIndex];
|
|
if(stack != null && (EnergyUpgrade.loadFromItem(stack) != null || (Config.darkSteelSolarChargeOthers && stack.getItem() instanceof IEnergyContainerItem))) {
|
|
toAdd -= ((IEnergyContainerItem) stack.getItem()).receiveEnergy(stack, toAdd, false);
|
|
}
|
|
nextIndex = (nextIndex + 1) % 4;
|
|
}
|
|
|
|
player.getEntityData().setInteger("dsarmor:solar", nextIndex);
|
|
}
|
|
}
|
|
|
|
private void updateSwim(EntityPlayer player) {
|
|
ItemStack boots = player.getEquipmentInSlot(1);
|
|
SwimUpgrade upgrade = SwimUpgrade.loadFromItem(boots);
|
|
if(upgrade == null) {
|
|
return;
|
|
}
|
|
if(player.isInWater()) {
|
|
player.motionX *= 1.1;
|
|
player.motionZ *= 1.1;
|
|
}
|
|
}
|
|
|
|
private void updateGlide(EntityPlayer player) {
|
|
if(!isGlideActive(player) || !isGliderUpgradeEquipped(player)) {
|
|
return;
|
|
}
|
|
|
|
if(!player.onGround && player.motionY < 0 && !player.isSneaking() && !player.isInWater()) {
|
|
|
|
double horizontalSpeed = Config.darkSteelGliderHorizontalSpeed;
|
|
double verticalSpeed = Config.darkSteelGliderVerticalSpeed;
|
|
if(player.isSprinting()) {
|
|
verticalSpeed = Config.darkSteelGliderVerticalSpeedSprinting;
|
|
}
|
|
|
|
Vector3d look = Util.getLookVecEio(player);
|
|
Vector3d side = new Vector3d();
|
|
side.cross(new Vector3d(0, 1, 0), look);
|
|
Vector3d playerPos = new Vector3d(player.prevPosX, player.prevPosY, player.prevPosZ);
|
|
Vector3d b = new Vector3d(playerPos);
|
|
b.y += 1;
|
|
Vector3d c = new Vector3d(playerPos);
|
|
c.add(side);
|
|
Vector4d plane = new Vector4d();
|
|
VecmathUtil.computePlaneEquation(playerPos, b, c, plane);
|
|
double dist = Math.abs(VecmathUtil.distanceFromPointToPlane(plane, new Vector3d(player.posX, player.posY, player.posZ)));
|
|
double minDist = 0.15;
|
|
if(dist < minDist) {
|
|
double dropRate = (minDist * 10) - (dist * 10);
|
|
verticalSpeed = verticalSpeed + (verticalSpeed * dropRate * 8);
|
|
horizontalSpeed -= (0.02 * dropRate);
|
|
}
|
|
|
|
double x = Math.cos(Math.toRadians(player.rotationYawHead + 90))
|
|
* horizontalSpeed;
|
|
double z = Math.sin(Math.toRadians(player.rotationYawHead + 90))
|
|
* horizontalSpeed;
|
|
|
|
player.motionX += x;
|
|
player.motionZ += z;
|
|
|
|
player.motionY = verticalSpeed;
|
|
player.fallDistance = 0f;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
public boolean isGliderUpgradeEquipped(EntityPlayer player) {
|
|
ItemStack chestPlate = player.getEquipmentInSlot(3);
|
|
GliderUpgrade glideUpgrade = GliderUpgrade.loadFromItem(chestPlate);
|
|
if(glideUpgrade == null) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void updateSword(EntityPlayer player) {
|
|
if(ItemDarkSteelSword.isEquipped(player)) {
|
|
IAttributeInstance attackInst = player.getAttributeMap().getAttributeInstance(SharedMonsterAttributes.attackDamage);
|
|
attackInst.removeModifier(swordDamageModifierPowered);
|
|
|
|
ItemStack sword = player.getCurrentEquippedItem();
|
|
if(Config.darkSteelSwordPowerUsePerHit <= 0 || EnergyUpgrade.getEnergyStored(sword) >= Config.darkSteelSwordPowerUsePerHit) {
|
|
attackInst.applyModifier(swordDamageModifierPowered);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateSpeed(EntityPlayer player) {
|
|
if(player.worldObj.isRemote || !player.onGround) {
|
|
return;
|
|
}
|
|
|
|
IAttributeInstance moveInst = player.getAttributeMap().getAttributeInstance(SharedMonsterAttributes.movementSpeed);
|
|
if(moveInst.getModifier(walkModifiers[0].getID()) != null) {
|
|
moveInst.removeModifier(walkModifiers[0]); //any will so as they all have the same UID
|
|
} else if(moveInst.getModifier(sprintModifiers[0].getID()) != null) {
|
|
moveInst.removeModifier(sprintModifiers[0]);
|
|
}
|
|
|
|
ItemStack leggings = player.getEquipmentInSlot(2);
|
|
SpeedUpgrade speedUpgrade = SpeedUpgrade.loadFromItem(leggings);
|
|
if(leggings != null && leggings.getItem() == DarkSteelItems.itemDarkSteelLeggings && speedUpgrade != null && isSpeedActive(player)) {
|
|
|
|
double horzMovement = Math.abs(player.distanceWalkedModified - player.prevDistanceWalkedModified);
|
|
double costModifier = player.isSprinting() ? Config.darkSteelSprintPowerCost : Config.darkSteelWalkPowerCost;
|
|
costModifier = costModifier + (costModifier * speedUpgrade.getWalkMultiplier());
|
|
int cost = (int) (horzMovement * costModifier);
|
|
int totalEnergy = getPlayerEnergy(player, DarkSteelItems.itemDarkSteelLeggings);
|
|
|
|
if(totalEnergy > 0) {
|
|
usePlayerEnergy(player, DarkSteelItems.itemDarkSteelLeggings, cost);
|
|
if(player.isSprinting()) {
|
|
moveInst.applyModifier(sprintModifiers[speedUpgrade.getLevel() - 1]);
|
|
} else {
|
|
moveInst.applyModifier(walkModifiers[speedUpgrade.getLevel() - 1]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void updateStepHeightAndFallDistance(EntityPlayer player) {
|
|
ItemStack boots = player.getEquipmentInSlot(1);
|
|
|
|
if(boots != null && boots.getItem() == DarkSteelItems.itemDarkSteelBoots && !player.capabilities.allowFlying) {
|
|
int costedDistance = (int) player.fallDistance;
|
|
if(costedDistance > 0) {
|
|
int energyCost = costedDistance * Config.darkSteelFallDistanceCost;
|
|
int totalEnergy = getPlayerEnergy(player, DarkSteelItems.itemDarkSteelBoots);
|
|
if(totalEnergy > 0 && totalEnergy >= energyCost) {
|
|
usePlayerEnergy(player, DarkSteelItems.itemDarkSteelBoots, energyCost);
|
|
player.fallDistance -= costedDistance;
|
|
}
|
|
}
|
|
}
|
|
|
|
JumpUpgrade jumpUpgrade = JumpUpgrade.loadFromItem(boots);
|
|
if(jumpUpgrade != null && boots != null && boots.getItem() == DarkSteelItems.itemDarkSteelBoots && isStepAssistActive(player)) {
|
|
player.stepHeight = 1.0023F;
|
|
} else if(player.stepHeight == 1.0023F) {
|
|
player.stepHeight = 0.5001F;
|
|
}
|
|
}
|
|
|
|
void usePlayerEnergy(EntityPlayer player, ItemDarkSteelArmor armor, int cost) {
|
|
if(cost == 0) {
|
|
return;
|
|
}
|
|
boolean extracted = false;
|
|
int remaining = cost;
|
|
if(Config.darkSteelDrainPowerFromInventory) {
|
|
for (ItemStack stack : player.inventory.mainInventory) {
|
|
if(stack != null && stack.getItem() instanceof IEnergyContainerItem) {
|
|
IEnergyContainerItem cont = (IEnergyContainerItem) stack.getItem();
|
|
int used = cont.extractEnergy(stack, remaining, false);
|
|
remaining -= used;
|
|
extracted |= used > 0;
|
|
if(remaining <= 0) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(armor != null && remaining > 0) {
|
|
ItemStack stack = player.inventory.armorInventory[3 - armor.armorType];
|
|
if(stack != null) {
|
|
int used = armor.extractEnergy(stack, remaining, false);
|
|
extracted |= used > 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
private int getPlayerEnergy(EntityPlayer player, ItemDarkSteelArmor armor) {
|
|
int res = 0;
|
|
|
|
if(Config.darkSteelDrainPowerFromInventory) {
|
|
for (ItemStack stack : player.inventory.mainInventory) {
|
|
if(stack != null && stack.getItem() instanceof IEnergyContainerItem) {
|
|
IEnergyContainerItem cont = (IEnergyContainerItem) stack.getItem();
|
|
res += cont.extractEnergy(stack, Integer.MAX_VALUE, true);
|
|
}
|
|
}
|
|
}
|
|
if(armor != null) {
|
|
ItemStack stack = player.inventory.armorInventory[3 - armor.armorType];
|
|
res = armor.getEnergyStored(stack);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
@SubscribeEvent
|
|
public void onStartTracking(PlayerEvent.StartTracking event) {
|
|
if (event.target instanceof EntityPlayerMP) {
|
|
for (PacketUpgradeState.Type type : PacketUpgradeState.Type.values()) {
|
|
PacketHandler.sendTo(new PacketUpgradeState(type, isActive((EntityPlayer) event.target, type), event.target.getEntityId()), (EntityPlayerMP) event.entityPlayer);
|
|
}
|
|
}
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
@SubscribeEvent
|
|
public void onClientTick(TickEvent.ClientTickEvent event) {
|
|
if(event.phase == TickEvent.Phase.END) {
|
|
EntityClientPlayerMP player = Minecraft.getMinecraft().thePlayer;
|
|
if(player == null) {
|
|
return;
|
|
}
|
|
MovementInput input = player.movementInput;
|
|
if(input.jump && !wasJumping) {
|
|
doJump(player);
|
|
} else if(input.jump && jumpCount < 3 && ticksSinceLastJump > 5) {
|
|
doJump(player);
|
|
}
|
|
|
|
wasJumping = !player.onGround;
|
|
if(!wasJumping) {
|
|
jumpCount = 0;
|
|
}
|
|
ticksSinceLastJump++;
|
|
|
|
updateNightvision(player);
|
|
}
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
@SubscribeEvent
|
|
public void onPlayerRender(RenderPlayerEvent.Specials.Post event) {
|
|
if (event.entityLiving.getActivePotionEffect(Potion.invisibility) != null) {
|
|
return;
|
|
}
|
|
|
|
EntityPlayer player = event.entityPlayer;
|
|
ItemStack[] armors = player.inventory.armorInventory;
|
|
|
|
dispatchRenders(armors, event, false);
|
|
|
|
float yaw = player.prevRotationYawHead + (player.rotationYawHead - player.prevRotationYawHead) * event.partialRenderTick;
|
|
float yawOffset = player.prevRenderYawOffset + (player.renderYawOffset - player.prevRenderYawOffset) * event.partialRenderTick;
|
|
float pitch = player.prevRotationPitch + (player.rotationPitch - player.prevRotationPitch) * event.partialRenderTick;
|
|
|
|
GL11.glPushMatrix();
|
|
GL11.glRotatef(yawOffset, 0, -1, 0);
|
|
GL11.glRotatef(yaw - 270, 0, 1, 0);
|
|
GL11.glRotatef(pitch, 0, 0, 1);
|
|
dispatchRenders(armors, event, true);
|
|
GL11.glPopMatrix();
|
|
}
|
|
|
|
private void dispatchRenders(ItemStack[] armors, RenderPlayerEvent event, boolean head) {
|
|
for (int i = 0; i < armors.length; i++) {
|
|
ItemStack stack = armors[i];
|
|
if (stack != null) {
|
|
Item item = stack.getItem();
|
|
|
|
if (item instanceof IDarkSteelItem) {
|
|
for (IDarkSteelUpgrade upg : DarkSteelRecipeManager.instance.getUpgrades()) {
|
|
if (upg.hasUpgrade(stack)) {
|
|
GL11.glPushMatrix();
|
|
GL11.glColor4f(1F, 1F, 1F, 1F);
|
|
IRenderUpgrade render = upg.getRender();
|
|
if (render != null) {
|
|
upg.getRender().render(event, stack, head);
|
|
}
|
|
GL11.glPopMatrix();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
private void doJump(EntityClientPlayerMP player) {
|
|
|
|
ItemStack boots = player.getEquipmentInSlot(1);
|
|
JumpUpgrade jumpUpgrade = JumpUpgrade.loadFromItem(boots);
|
|
|
|
if(jumpUpgrade == null || boots == null || boots.getItem() != DarkSteelItems.itemDarkSteelBoots) {
|
|
return;
|
|
}
|
|
|
|
int requiredPower = Config.darkSteelBootsJumpPowerCost * (int) Math.pow(jumpCount + 1, 2.5);
|
|
int availablePower = getPlayerEnergy(player, DarkSteelItems.itemDarkSteelBoots);
|
|
if(availablePower > 0 && requiredPower <= availablePower && jumpCount < jumpUpgrade.getLevel()) {
|
|
jumpCount++;
|
|
player.motionY += 0.15 * Config.darkSteelBootsJumpModifier * jumpCount;
|
|
ticksSinceLastJump = 0;
|
|
usePlayerEnergy(player, DarkSteelItems.itemDarkSteelBoots, requiredPower);
|
|
player.worldObj.playSound(player.posX, player.posY, player.posZ, EnderIO.MODID + ":ds.jump", 1.0f, player.worldObj.rand.nextFloat() * 0.5f + 0.75f, false);
|
|
PacketHandler.INSTANCE.sendToServer(new PacketDarkSteelPowerPacket(requiredPower, DarkSteelItems.itemDarkSteelBoots.armorType));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
private void updateNightvision(EntityPlayer player) {
|
|
if(isNightVisionUpgradeEquipped(player) && nightVisionActive) {
|
|
player.addPotionEffect(new PotionEffect(Potion.nightVision.getId(), 210, 0, true));
|
|
}
|
|
if(!isNightVisionUpgradeEquipped(player) && nightVisionActive) {
|
|
nightVisionActive = false;
|
|
removeNightvision = true;
|
|
}
|
|
if(removeNightvision) {
|
|
player.removePotionEffect(Potion.nightVision.getId());
|
|
removeNightvision = false;
|
|
}
|
|
}
|
|
|
|
public boolean isNightVisionUpgradeEquipped(EntityPlayer player) {
|
|
ItemStack helmet = player.getEquipmentInSlot(4);
|
|
return NightVisionUpgrade.loadFromItem(helmet) != null;
|
|
}
|
|
|
|
public void setNightVisionActive(boolean isNightVisionActive) {
|
|
if(nightVisionActive && !isNightVisionActive) {
|
|
removeNightvision = true;
|
|
}
|
|
this.nightVisionActive = isNightVisionActive;
|
|
}
|
|
|
|
}
|