ActuallyAdditions/src/main/java/de/ellpeck/actuallyadditions/mod/tile/TileEntityXPSolidifier.java

235 lines
8.9 KiB
Java
Raw Normal View History

2015-08-29 14:33:25 +02:00
/*
2016-05-16 22:52:27 +02:00
* This file ("TileEntityXPSolidifier.java") is part of the Actually Additions mod for Minecraft.
2015-08-29 14:33:25 +02:00
* It is created and owned by Ellpeck and distributed
* under the Actually Additions License to be found at
2016-05-16 22:52:27 +02:00
* http://ellpeck.de/actaddlicense
2015-08-29 14:33:25 +02:00
* View the source code at https://github.com/Ellpeck/ActuallyAdditions
*
2017-01-01 16:23:26 +01:00
* © 2015-2017 Ellpeck
2015-08-29 14:33:25 +02:00
*/
2016-01-05 04:47:35 +01:00
package de.ellpeck.actuallyadditions.mod.tile;
2015-07-13 23:44:33 +02:00
2018-05-10 11:38:58 +02:00
import de.ellpeck.actuallyadditions.mod.ActuallyAdditions;
2021-08-30 22:51:41 +02:00
import de.ellpeck.actuallyadditions.mod.blocks.ActuallyBlocks;
import de.ellpeck.actuallyadditions.mod.inventory.ContainerXPSolidifier;
import de.ellpeck.actuallyadditions.mod.items.ActuallyItems;
2016-01-05 04:47:35 +01:00
import de.ellpeck.actuallyadditions.mod.items.ItemSolidifiedExperience;
import de.ellpeck.actuallyadditions.mod.network.gui.IButtonReactor;
2018-08-10 05:04:07 +02:00
import de.ellpeck.actuallyadditions.mod.util.ItemStackHandlerAA.IAcceptor;
import de.ellpeck.actuallyadditions.mod.util.StackUtil;
2024-03-02 21:23:08 +01:00
import net.minecraft.core.BlockPos;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.util.Mth;
import net.minecraft.world.MenuProvider;
import net.minecraft.world.entity.ExperienceOrb;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import net.minecraft.world.phys.AABB;
import javax.annotation.Nullable;
2021-02-26 22:15:48 +01:00
import java.util.List;
2024-03-02 21:23:08 +01:00
public class TileEntityXPSolidifier extends TileEntityInventoryBase implements IButtonReactor, MenuProvider {
private static final int[] XP_MAP = new int[256];
2016-06-17 23:50:38 +02:00
static {
for (int i = 0; i < XP_MAP.length; i++) {
2016-06-17 23:50:38 +02:00
XP_MAP[i] = getExperienceForLevelImpl(i);
}
}
2021-02-26 22:15:48 +01:00
private final int[] buttonAmounts = new int[]{1, 5, 10, 20, 30, 40, 50, 64, -999};
public int amount;
private int lastAmount;
private int singlePointAmount;
2015-07-13 23:44:33 +02:00
2024-03-02 21:23:08 +01:00
public TileEntityXPSolidifier(BlockPos pos, BlockState state) {
super(ActuallyBlocks.XP_SOLIDIFIER.getTileEntityType(), pos, state, 2);
2015-07-13 23:44:33 +02:00
}
/*
* The below methods were excerpted from EnderIO by SleepyTrousers with permission, thanks!
*/
public static int getExperienceForLevel(int level) {
2021-02-26 22:15:48 +01:00
if (level >= 0 && level < XP_MAP.length) {
return XP_MAP[level];
}
if (level >= 21863) {
return Integer.MAX_VALUE;
}
2016-06-17 23:50:38 +02:00
return getExperienceForLevelImpl(level);
}
private static int getExperienceForLevelImpl(int level) {
2016-06-17 23:50:38 +02:00
int res = 0;
for (int i = 0; i < level; i++) {
2016-06-17 23:50:38 +02:00
res += getXpBarCapacity(i);
2021-02-26 22:15:48 +01:00
if (res < 0) {
return Integer.MAX_VALUE;
}
2016-06-17 23:50:38 +02:00
}
return res;
}
public static int getXpBarCapacity(int level) {
if (level >= 30) {
return 112 + (level - 30) * 9;
2021-02-26 22:15:48 +01:00
} else if (level >= 15) {
return 37 + (level - 15) * 5;
}
return 7 + level * 2;
2016-06-17 23:50:38 +02:00
}
public static int getLevelForExperience(int experience) {
for (int i = 0; i < XP_MAP.length; i++) {
2021-02-26 22:15:48 +01:00
if (XP_MAP[i] > experience) {
return i - 1;
}
2016-06-17 23:50:38 +02:00
}
int i = XP_MAP.length;
while (getExperienceForLevel(i) <= experience) {
2016-06-17 23:50:38 +02:00
i++;
}
return i - 1;
2016-06-17 23:50:38 +02:00
}
2024-03-02 21:23:08 +01:00
public static int getPlayerXP(Player player) {
return (int) (getExperienceForLevel(player.experienceLevel) + player.experienceProgress * player.getXpNeededForNextLevel());
2016-06-17 23:50:38 +02:00
}
2024-03-02 21:23:08 +01:00
public static void addPlayerXP(Player player, int amount) {
int experience = Math.max(0, getPlayerXP(player) + amount);
player.totalExperience = experience;
2016-06-17 23:50:38 +02:00
player.experienceLevel = getLevelForExperience(experience);
int expForLevel = getExperienceForLevel(player.experienceLevel);
player.experienceProgress = (float) (experience - expForLevel) / (float) player.getXpNeededForNextLevel();
2016-06-17 23:50:38 +02:00
}
@Override
2024-03-02 21:23:08 +01:00
public void writeSyncableNBT(CompoundTag compound, NBTType type) {
super.writeSyncableNBT(compound, type);
2021-02-27 16:33:00 +01:00
compound.putInt("Amount", this.amount);
compound.putInt("SinglePointAmount", this.singlePointAmount);
}
@Override
2024-03-02 21:23:08 +01:00
public void readSyncableNBT(CompoundTag compound, NBTType type) {
super.readSyncableNBT(compound, type);
2021-02-27 16:33:00 +01:00
this.amount = compound.getInt("Amount");
this.singlePointAmount = compound.getInt("SinglePointAmount");
}
2024-03-02 21:23:08 +01:00
public static <T extends BlockEntity> void clientTick(Level level, BlockPos pos, BlockState state, T t) {
if (t instanceof TileEntityXPSolidifier tile) {
tile.clientTick();
}
}
public static <T extends BlockEntity> void serverTick(Level level, BlockPos pos, BlockState state, T t) {
if (t instanceof TileEntityXPSolidifier tile) {
tile.serverTick();
if (tile.amount > 0) {
ItemStack stack = tile.inv.getStackInSlot(0);
if (stack.isEmpty()) {
2024-03-02 21:23:08 +01:00
int toSet = Math.min(tile.amount, 64);
tile.inv.setStackInSlot(0, new ItemStack(ActuallyItems.SOLIDIFIED_EXPERIENCE.get(), toSet));
tile.amount -= toSet;
tile.setChanged();
} else if (stack.getCount() < 64) {
int needed = 64 - stack.getCount();
2024-03-02 21:23:08 +01:00
int toAdd = Math.min(needed, tile.amount);
stack.grow(toAdd);
2024-03-02 21:23:08 +01:00
tile.amount -= toAdd;
tile.setChanged();
}
}
2024-03-02 21:23:08 +01:00
if (!tile.isRedstonePowered) {
int range = 5;
2024-03-02 21:23:08 +01:00
List<ExperienceOrb> orbs = level.getEntitiesOfClass(ExperienceOrb.class, new AABB(pos.getX() - range, pos.getY() - range, pos.getZ() - range, pos.getX() + 1 + range, pos.getY() + 1 + range, pos.getZ() + 1 + range));
if (orbs != null && !orbs.isEmpty()) {
2024-03-02 21:23:08 +01:00
for (ExperienceOrb orb : orbs) {
2021-02-27 16:33:00 +01:00
// TODO: [port] validate the getPersistentData is correct
if (orb != null && orb.isAlive() && !orb.getPersistentData().getBoolean(ActuallyAdditions.MODID + "FromSolidified")) {
2024-03-02 21:23:08 +01:00
tile.singlePointAmount += orb.getValue();
orb.discard();
2024-03-02 21:23:08 +01:00
if (tile.singlePointAmount >= ItemSolidifiedExperience.SOLID_XP_AMOUNT) {
tile.amount += tile.singlePointAmount / ItemSolidifiedExperience.SOLID_XP_AMOUNT;
tile.singlePointAmount = 0;
tile.setChanged();
}
}
}
}
}
2016-09-12 20:45:29 +02:00
2024-03-02 21:23:08 +01:00
ItemStack stack = tile.inv.getStackInSlot(1);
if (StackUtil.isValid(stack) && stack.getItem() instanceof ItemSolidifiedExperience) {
2024-03-02 21:23:08 +01:00
int remainingSpace = Mth.clamp(Integer.MAX_VALUE - tile.amount, 0, stack.getCount());
if (stack.getCount() >= remainingSpace && remainingSpace != 0) {
2024-03-02 21:23:08 +01:00
tile.amount += remainingSpace;
stack.shrink(remainingSpace);
2024-03-02 21:23:08 +01:00
tile.setChanged();
2017-07-30 02:53:30 +02:00
}
}
2024-03-02 21:23:08 +01:00
if (tile.lastAmount != tile.amount && tile.sendUpdateWithInterval()) {
tile.lastAmount = tile.amount;
}
}
}
2024-03-02 21:23:08 +01:00
2015-07-13 23:44:33 +02:00
@Override
2018-08-10 05:04:07 +02:00
public IAcceptor getAcceptor() {
2021-05-02 18:10:21 +02:00
return (slot, stack, automation) -> slot == 1 && stack.getItem() == ActuallyItems.SOLIDIFIED_EXPERIENCE.get();
2015-07-13 23:44:33 +02:00
}
2017-07-30 02:53:30 +02:00
@Override
public void setChanged() {
2021-02-26 22:15:48 +01:00
if (this.amount < 0) {
this.amount = Integer.MAX_VALUE; //don't u go negative on me weird number
}
super.setChanged();
2017-07-30 02:53:30 +02:00
}
2015-07-13 23:44:33 +02:00
@Override
2024-03-02 21:23:08 +01:00
public void onButtonPressed(int buttonID, Player player) {
if (buttonID < this.buttonAmounts.length) {
int playerXP = getPlayerXP(player);
if (playerXP > 0) {
2021-02-26 22:15:48 +01:00
int xp = this.buttonAmounts[buttonID] == -999
? playerXP / ItemSolidifiedExperience.SOLID_XP_AMOUNT
: this.buttonAmounts[buttonID];
if (this.amount < Integer.MAX_VALUE - xp && playerXP >= ItemSolidifiedExperience.SOLID_XP_AMOUNT * xp) {
addPlayerXP(player, -(ItemSolidifiedExperience.SOLID_XP_AMOUNT * xp));
if (!this.level.isClientSide) {
2015-10-03 10:16:18 +02:00
this.amount += xp;
}
2015-07-15 01:53:04 +02:00
}
}
2015-07-13 23:44:33 +02:00
}
}
@Override
2024-03-02 21:23:08 +01:00
public Component getDisplayName() {
2024-03-03 01:20:53 +01:00
return Component.empty();
}
@Nullable
@Override
2024-03-02 21:23:08 +01:00
public AbstractContainerMenu createMenu(int windowId, Inventory playerInventory, Player player) {
return new ContainerXPSolidifier(windowId, playerInventory, this);
}
2015-07-13 23:44:33 +02:00
}