3f5178dd6a
Slowly getting rid of these BlockStack references. Slowly moving towards a proper "API" in our internals.
385 lines
14 KiB
Java
385 lines
14 KiB
Java
package WayofTime.bloodmagic.ritual;
|
|
|
|
import WayofTime.bloodmagic.soul.DemonWillHolder;
|
|
import WayofTime.bloodmagic.soul.EnumDemonWillType;
|
|
import WayofTime.bloodmagic.demonAura.WorldDemonWillHandler;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.util.math.BlockPos;
|
|
import net.minecraft.util.text.ITextComponent;
|
|
import net.minecraft.util.text.TextComponentTranslation;
|
|
import net.minecraft.world.World;
|
|
import org.apache.commons.lang3.builder.ToStringBuilder;
|
|
|
|
import java.util.*;
|
|
import java.util.Map.Entry;
|
|
|
|
/**
|
|
* Abstract class for creating new rituals. Rituals need be registered with
|
|
* {@link RitualRegistry#registerRitual(Ritual, String)}
|
|
*/
|
|
public abstract class Ritual {
|
|
|
|
protected final Map<String, AreaDescriptor> modableRangeMap = new HashMap<>();
|
|
protected final Map<String, Integer> volumeRangeMap = new HashMap<>();
|
|
protected final Map<String, Integer> horizontalRangeMap = new HashMap<>();
|
|
protected final Map<String, Integer> verticalRangeMap = new HashMap<>();
|
|
private final String name;
|
|
private final int crystalLevel;
|
|
private final int activationCost;
|
|
private final RitualRenderer renderer;
|
|
private final String unlocalizedName;
|
|
|
|
public Ritual(String name, int crystalLevel, int activationCost, RitualRenderer renderer, String unlocalizedName) {
|
|
this.name = name;
|
|
this.crystalLevel = crystalLevel;
|
|
this.activationCost = activationCost;
|
|
this.renderer = renderer;
|
|
this.unlocalizedName = unlocalizedName;
|
|
}
|
|
|
|
/**
|
|
* @param name - The name of the ritual
|
|
* @param crystalLevel - Required Activation Crystal tier
|
|
* @param activationCost - Base LP cost for activating the ritual
|
|
*/
|
|
public Ritual(String name, int crystalLevel, int activationCost, String unlocalizedName) {
|
|
this(name, crystalLevel, activationCost, null, unlocalizedName);
|
|
}
|
|
|
|
public void readFromNBT(NBTTagCompound tag) {
|
|
NBTTagList tags = tag.getTagList("areas", 10);
|
|
if (tags.hasNoTags()) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < tags.tagCount(); i++) {
|
|
NBTTagCompound newTag = tags.getCompoundTagAt(i);
|
|
String rangeKey = newTag.getString("key");
|
|
|
|
NBTTagCompound storedTag = newTag.getCompoundTag("area");
|
|
AreaDescriptor desc = this.getBlockRange(rangeKey);
|
|
if (desc != null) {
|
|
desc.readFromNBT(storedTag);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void writeToNBT(NBTTagCompound tag) {
|
|
NBTTagList tags = new NBTTagList();
|
|
|
|
for (Entry<String, AreaDescriptor> entry : modableRangeMap.entrySet()) {
|
|
NBTTagCompound newTag = new NBTTagCompound();
|
|
newTag.setString("key", entry.getKey());
|
|
NBTTagCompound storedTag = new NBTTagCompound();
|
|
|
|
entry.getValue().writeToNBT(storedTag);
|
|
|
|
newTag.setTag("area", storedTag);
|
|
|
|
tags.appendTag(newTag);
|
|
}
|
|
|
|
tag.setTag("areas", tags);
|
|
}
|
|
|
|
/**
|
|
* Called when the player attempts to activate the ritual.
|
|
* <p>
|
|
* {@link WayofTime.bloodmagic.tile.TileMasterRitualStone#activateRitual(ItemStack, EntityPlayer, Ritual)}
|
|
*
|
|
* @param masterRitualStone - The {@link IMasterRitualStone} that the ritual is bound to
|
|
* @param player - The activating player
|
|
* @param owner - Owner of the crystal activating this ritual, or the current
|
|
* owner of the ritual if being reactivated.
|
|
* @return - Whether activation was successful
|
|
*/
|
|
public boolean activateRitual(IMasterRitualStone masterRitualStone, EntityPlayer player, UUID owner) {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Called every {@link #getRefreshTime()} ticks while active.
|
|
* <p>
|
|
* {@link WayofTime.bloodmagic.tile.TileMasterRitualStone#performRitual(World, BlockPos)}
|
|
*
|
|
* @param masterRitualStone - The {@link IMasterRitualStone} that the ritual is bound to
|
|
*/
|
|
public abstract void performRitual(IMasterRitualStone masterRitualStone);
|
|
|
|
/**
|
|
* Called when the ritual is stopped for a given {@link Ritual.BreakType}.
|
|
* <p>
|
|
* {@link WayofTime.bloodmagic.tile.TileMasterRitualStone#stopRitual(Ritual.BreakType)}
|
|
*
|
|
* @param masterRitualStone - The {@link IMasterRitualStone} that the ritual is bound to
|
|
* @param breakType - The type of break that caused the stoppage.
|
|
*/
|
|
public void stopRitual(IMasterRitualStone masterRitualStone, BreakType breakType) {
|
|
|
|
}
|
|
|
|
/**
|
|
* Used to set the amount of LP drained every {@link #getRefreshTime()}
|
|
* ticks.
|
|
*
|
|
* @return - The amount of LP drained per refresh
|
|
*/
|
|
public abstract int getRefreshCost();
|
|
|
|
/**
|
|
* Used to set the refresh rate of the ritual. (How often
|
|
* {@link #performRitual(IMasterRitualStone)} is called.
|
|
*
|
|
* @return - How often to perform the effect in ticks.
|
|
*/
|
|
public int getRefreshTime() {
|
|
return 20;
|
|
}
|
|
|
|
public void addBlockRange(String range, AreaDescriptor defaultRange) {
|
|
modableRangeMap.put(range, defaultRange);
|
|
}
|
|
|
|
/**
|
|
* Used to grab the range of a ritual for a given effect.
|
|
*
|
|
* @param range - Range that needs to be pulled.
|
|
* @return -
|
|
*/
|
|
public AreaDescriptor getBlockRange(String range) {
|
|
if (modableRangeMap.containsKey(range)) {
|
|
return modableRangeMap.get(range);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public List<String> getListOfRanges() {
|
|
return new ArrayList<>(modableRangeMap.keySet());
|
|
}
|
|
|
|
public String getNextBlockRange(String range) {
|
|
List<String> rangeList = getListOfRanges();
|
|
|
|
if (rangeList.isEmpty()) {
|
|
return "";
|
|
}
|
|
|
|
if (!rangeList.contains(range)) {
|
|
return rangeList.get(0);
|
|
}
|
|
|
|
boolean hasMatch = false;
|
|
|
|
for (String rangeCheck : rangeList) {
|
|
if (hasMatch) {
|
|
return rangeCheck;
|
|
} else if (rangeCheck.equals(range)) {
|
|
hasMatch = true;
|
|
}
|
|
}
|
|
|
|
return rangeList.get(0);
|
|
}
|
|
|
|
public boolean setBlockRangeByBounds(String range, IMasterRitualStone master, BlockPos offset1, BlockPos offset2) {
|
|
AreaDescriptor descriptor = this.getBlockRange(range);
|
|
World world = master.getWorldObj();
|
|
BlockPos masterPos = master.getBlockPos();
|
|
DemonWillHolder holder = WorldDemonWillHandler.getWillHolder(world, masterPos);
|
|
if (canBlockRangeBeModified(range, descriptor, master, offset1, offset2, holder)) {
|
|
descriptor.modifyAreaByBlockPositions(offset1, offset2);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected boolean canBlockRangeBeModified(String range, AreaDescriptor descriptor, IMasterRitualStone master, BlockPos offset1, BlockPos offset2, DemonWillHolder holder) {
|
|
List<EnumDemonWillType> willConfig = master.getActiveWillConfig();
|
|
int maxVolume = getMaxVolumeForRange(range, willConfig, holder);
|
|
int maxVertical = getMaxVerticalRadiusForRange(range, willConfig, holder);
|
|
int maxHorizontal = getMaxHorizontalRadiusForRange(range, willConfig, holder);
|
|
|
|
return (maxVolume <= 0 || descriptor.getVolumeForOffsets(offset1, offset2) <= maxVolume) && descriptor.isWithinRange(offset1, offset2, maxVertical, maxHorizontal);
|
|
}
|
|
|
|
protected void setMaximumVolumeAndDistanceOfRange(String range, int volume, int horizontalRadius, int verticalRadius) {
|
|
volumeRangeMap.put(range, volume);
|
|
horizontalRangeMap.put(range, horizontalRadius);
|
|
verticalRangeMap.put(range, verticalRadius);
|
|
}
|
|
|
|
protected boolean checkDescriptorIsWithinRange(AreaDescriptor descriptor, int maxVolume, int maxHorizontal, int maxVertical) {
|
|
return descriptor.getVolume() <= maxVolume && descriptor.isWithinRange(maxVertical, maxHorizontal);
|
|
}
|
|
|
|
public int getMaxVolumeForRange(String range, List<EnumDemonWillType> activeTypes, DemonWillHolder holder) {
|
|
return volumeRangeMap.get(range);
|
|
}
|
|
|
|
public int getMaxVerticalRadiusForRange(String range, List<EnumDemonWillType> activeTypes, DemonWillHolder holder) {
|
|
return verticalRangeMap.get(range);
|
|
}
|
|
|
|
public int getMaxHorizontalRadiusForRange(String range, List<EnumDemonWillType> activeTypes, DemonWillHolder holder) {
|
|
return horizontalRangeMap.get(range);
|
|
}
|
|
|
|
public ITextComponent getErrorForBlockRangeOnFail(EntityPlayer player, String range, IMasterRitualStone master, BlockPos offset1, BlockPos offset2) {
|
|
AreaDescriptor descriptor = this.getBlockRange(range);
|
|
if (descriptor == null) {
|
|
return new TextComponentTranslation("ritual.bloodmagic.blockRange.tooBig", "?");
|
|
}
|
|
|
|
List<EnumDemonWillType> willConfig = master.getActiveWillConfig();
|
|
DemonWillHolder holder = WorldDemonWillHandler.getWillHolder(master.getWorldObj(), master.getBlockPos());
|
|
|
|
int maxVolume = this.getMaxVolumeForRange(range, willConfig, holder);
|
|
int maxVertical = this.getMaxVerticalRadiusForRange(range, willConfig, holder);
|
|
int maxHorizontal = this.getMaxHorizontalRadiusForRange(range, willConfig, holder);
|
|
|
|
if (maxVolume > 0 && descriptor.getVolumeForOffsets(offset1, offset2) > maxVolume) {
|
|
return new TextComponentTranslation("ritual.bloodmagic.blockRange.tooBig", maxVolume);
|
|
} else {
|
|
return new TextComponentTranslation("ritual.bloodmagic.blockRange.tooFar", maxVertical, maxHorizontal);
|
|
}
|
|
}
|
|
|
|
public ITextComponent[] provideInformationOfRitualToPlayer(EntityPlayer player) {
|
|
return new ITextComponent[]{new TextComponentTranslation(this.getUnlocalizedName() + ".info")};
|
|
}
|
|
|
|
public ITextComponent provideInformationOfRangeToPlayer(EntityPlayer player, String range) {
|
|
if (getListOfRanges().contains(range)) {
|
|
return new TextComponentTranslation(this.getUnlocalizedName() + "." + range + ".info");
|
|
} else {
|
|
return new TextComponentTranslation("ritual.bloodmagic.blockRange.noRange");
|
|
}
|
|
}
|
|
|
|
public abstract void gatherComponents(List<RitualComponent> components);
|
|
|
|
protected final void addRune(List<RitualComponent> components, int offset1, int y, int offset2, EnumRuneType rune) {
|
|
components.add(new RitualComponent(new BlockPos(offset1, y, offset2), rune));
|
|
}
|
|
|
|
protected final void addOffsetRunes(List<RitualComponent> components, int offset1, int offset2, int y, EnumRuneType rune) {
|
|
addRune(components, offset1, y, offset2, rune);
|
|
addRune(components, offset2, y, offset1, rune);
|
|
addRune(components, offset1, y, -offset2, rune);
|
|
addRune(components, -offset2, y, offset1, rune);
|
|
addRune(components, -offset1, y, offset2, rune);
|
|
addRune(components, offset2, y, -offset1, rune);
|
|
addRune(components, -offset1, y, -offset2, rune);
|
|
addRune(components, -offset2, y, -offset1, rune);
|
|
}
|
|
|
|
protected final void addCornerRunes(List<RitualComponent> components, int offset, int y, EnumRuneType rune) {
|
|
addRune(components, offset, y, offset, rune);
|
|
addRune(components, offset, y, -offset, rune);
|
|
addRune(components, -offset, y, -offset, rune);
|
|
addRune(components, -offset, y, offset, rune);
|
|
}
|
|
|
|
protected final void addParallelRunes(List<RitualComponent> components, int offset, int y, EnumRuneType rune) {
|
|
addRune(components, offset, y, 0, rune);
|
|
addRune(components, -offset, y, 0, rune);
|
|
addRune(components, 0, y, -offset, rune);
|
|
addRune(components, 0, y, offset, rune);
|
|
}
|
|
|
|
public double getWillRespectingConfig(World world, BlockPos pos, EnumDemonWillType type, List<EnumDemonWillType> willConfig) {
|
|
return willConfig.contains(type) ? WorldDemonWillHandler.getCurrentWill(world, pos, type) : 0;
|
|
}
|
|
|
|
public abstract Ritual getNewCopy();
|
|
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
public int getCrystalLevel() {
|
|
return crystalLevel;
|
|
}
|
|
|
|
public int getActivationCost() {
|
|
return activationCost;
|
|
}
|
|
|
|
public RitualRenderer getRenderer() {
|
|
return renderer;
|
|
}
|
|
|
|
public String getUnlocalizedName() {
|
|
return unlocalizedName;
|
|
}
|
|
|
|
public Map<String, AreaDescriptor> getModableRangeMap() {
|
|
return modableRangeMap;
|
|
}
|
|
|
|
public Map<String, Integer> getVolumeRangeMap() {
|
|
return volumeRangeMap;
|
|
}
|
|
|
|
public Map<String, Integer> getHorizontalRangeMap() {
|
|
return horizontalRangeMap;
|
|
}
|
|
|
|
public Map<String, Integer> getVerticalRangeMap() {
|
|
return verticalRangeMap;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return new ToStringBuilder(this)
|
|
.append("name", name)
|
|
.append("crystalLevel", crystalLevel)
|
|
.append("activationCost", activationCost)
|
|
.append("renderer", renderer)
|
|
.append("unlocalizedName", unlocalizedName)
|
|
.append("modableRangeMap", modableRangeMap)
|
|
.append("volumeRangeMap", volumeRangeMap)
|
|
.append("horizontalRangeMap", horizontalRangeMap)
|
|
.append("verticalRangeMap", verticalRangeMap)
|
|
.append("refreshTime", getRefreshTime())
|
|
.append("listOfRanges", getListOfRanges())
|
|
.toString();
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object o) {
|
|
if (this == o) return true;
|
|
if (!(o instanceof Ritual)) return false;
|
|
|
|
Ritual ritual = (Ritual) o;
|
|
|
|
if (crystalLevel != ritual.crystalLevel) return false;
|
|
if (activationCost != ritual.activationCost) return false;
|
|
if (name != null ? !name.equals(ritual.name) : ritual.name != null) return false;
|
|
return unlocalizedName != null ? unlocalizedName.equals(ritual.unlocalizedName) : ritual.unlocalizedName == null;
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
int result = name != null ? name.hashCode() : 0;
|
|
result = 31 * result + crystalLevel;
|
|
result = 31 * result + activationCost;
|
|
result = 31 * result + (unlocalizedName != null ? unlocalizedName.hashCode() : 0);
|
|
return result;
|
|
}
|
|
|
|
public enum BreakType {
|
|
REDSTONE,
|
|
BREAK_MRS,
|
|
BREAK_STONE,
|
|
ACTIVATE,
|
|
DEACTIVATE,
|
|
EXPLOSION,
|
|
}
|
|
}
|