WinDanesz
214 lines
9.5 KiB
Java
214 lines
9.5 KiB
Java
package electroblob.wizardry.spell;
|
|
|
|
import electroblob.wizardry.Wizardry;
|
|
import electroblob.wizardry.item.SpellActions;
|
|
import electroblob.wizardry.registry.WizardryItems;
|
|
import electroblob.wizardry.util.ParticleBuilder;
|
|
import electroblob.wizardry.util.ParticleBuilder.Type;
|
|
import electroblob.wizardry.util.SpellModifiers;
|
|
import net.minecraft.entity.EntityLiving;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.potion.Potion;
|
|
import net.minecraft.potion.PotionEffect;
|
|
import net.minecraft.tileentity.TileEntityDispenser;
|
|
import net.minecraft.util.EnumFacing;
|
|
import net.minecraft.util.EnumHand;
|
|
import net.minecraft.util.math.AxisAlignedBB;
|
|
import net.minecraft.util.math.BlockPos;
|
|
import net.minecraft.world.World;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.function.Supplier;
|
|
import java.util.stream.Collectors;
|
|
|
|
/**
|
|
* Generic superclass for all spells which buff their caster.
|
|
* This allows all the relevant code to be centralised, since these spells all work in the same way. Usually, a simple
|
|
* instantiation of this class is sufficient to create a buff spell; if something extra needs to be done, such as
|
|
* applying a non-potion buff, then methods can be overridden (perhaps using an anonymous class) to add the required
|
|
* functionality.
|
|
* <p></p>
|
|
* Properties added by this type of spell: {@link SpellBuff#getDurationKey(Potion)}, {@link SpellBuff#getStrengthKey(Potion)}
|
|
* <p></p>
|
|
* By default, this type of spell can be cast by NPCs. {@link Spell#canBeCastBy(EntityLiving, boolean)}
|
|
* <p></p>
|
|
* By default, this type of spell can be cast by dispensers. {@link Spell#canBeCastBy(TileEntityDispenser)}
|
|
* <p></p>
|
|
* By default, this type of spell requires a packet to be sent. {@link Spell#requiresPacket()}
|
|
*
|
|
* @author Electroblob
|
|
* @since Wizardry 4.2
|
|
*/
|
|
public class SpellBuff extends Spell {
|
|
|
|
/** An array of factories for the status effects that this spell applies to its caster. The effect factory
|
|
* avoids the issue of the potions being registered after the spell. */
|
|
protected final Supplier<Potion>[] effects;
|
|
/** A set of all the different potions (status effects) that this spell applies to its caster. Loaded during
|
|
* init(). */
|
|
protected Set<Potion> potionSet;
|
|
/** The RGB colour values of the particles spawned when this spell is cast. */
|
|
protected final float r, g, b;
|
|
|
|
/** The number of sparkle particles spawned when this spell is cast. Defaults to 10. */
|
|
protected float particleCount = 10;
|
|
|
|
@SafeVarargs
|
|
public SpellBuff(String name, float r, float g, float b, Supplier<Potion>... effects){
|
|
this(Wizardry.MODID, name, r, g, b, effects);
|
|
}
|
|
|
|
@SafeVarargs
|
|
public SpellBuff(String modID, String name, float r, float g, float b, Supplier<Potion>... effects){
|
|
super(modID, name, SpellActions.POINT_UP, false);
|
|
this.effects = effects;
|
|
this.r = r;
|
|
this.g = g;
|
|
this.b = b;
|
|
this.npcSelector((e, o) -> true);
|
|
}
|
|
|
|
@Override
|
|
public void init(){
|
|
// Loads the potion set
|
|
this.potionSet = Arrays.stream(effects).map(Supplier::get).collect(Collectors.toSet());
|
|
|
|
for(Potion potion : potionSet){
|
|
// I don't like having this for all buff spells when some potions aren't affected by amplifiers
|
|
// TODO: Find a way of only adding the strength key if the potion is affected by amplifiers (dynamically if possible)
|
|
// BrewingRecipeRegistry#getOutput might be a good place to start
|
|
addProperties(getStrengthKey(potion));
|
|
if(!potion.isInstant()) addProperties(getDurationKey(potion));
|
|
}
|
|
}
|
|
|
|
/** Returns an unmodifiable view of the set of {@link Potion} objects that this spell applies to its caster. */
|
|
public Set<Potion> getPotionSet(){
|
|
return Collections.unmodifiableSet(potionSet);
|
|
}
|
|
|
|
// Potion-specific equivalent to defining the identifiers as constants
|
|
|
|
protected static String getDurationKey(Potion potion){
|
|
return potion.getRegistryName().getPath() + "_duration";
|
|
}
|
|
|
|
protected static String getStrengthKey(Potion potion){
|
|
return potion.getRegistryName().getPath() + "_strength";
|
|
}
|
|
|
|
/**
|
|
* Sets the number of sparkle particles spawned when this spell is cast.
|
|
* @param particleCount The number of particles.
|
|
* @return The spell instance, allowing this method to be chained onto the constructor.
|
|
*/
|
|
public SpellBuff particleCount(int particleCount){
|
|
this.particleCount = particleCount;
|
|
return this;
|
|
}
|
|
|
|
@Override public boolean canBeCastBy(TileEntityDispenser dispenser) { return true; }
|
|
|
|
@Override
|
|
public boolean cast(World world, EntityPlayer caster, EnumHand hand, int ticksInUse, SpellModifiers modifiers){
|
|
// Only return on the server side or the client probably won't spawn particles
|
|
if(!this.applyEffects(caster, modifiers) && !world.isRemote) return false;
|
|
if(world.isRemote) this.spawnParticles(world, caster, modifiers);
|
|
this.playSound(world, caster, ticksInUse, -1, modifiers);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean cast(World world, EntityLiving caster, EnumHand hand, int ticksInUse, EntityLivingBase target, SpellModifiers modifiers){
|
|
// Wizards can only cast a buff spell if they don't already have its effects.
|
|
// Some buff spells doesn't add any potion effects, those are ignored by this check
|
|
if(!potionSet.isEmpty() && caster.getActivePotionMap().keySet().containsAll(potionSet)) return false;
|
|
// Only return on the server side or the client probably won't spawn particles
|
|
if(!this.applyEffects(caster, modifiers) && !world.isRemote) return false;
|
|
if(world.isRemote) this.spawnParticles(world, caster, modifiers);
|
|
this.playSound(world, caster, ticksInUse, -1, modifiers);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean cast(World world, double x, double y, double z, EnumFacing direction, int ticksInUse, int duration, SpellModifiers modifiers){
|
|
// Gets a 1x1x1 bounding box corresponding to the block in front of the dispenser
|
|
AxisAlignedBB boundingBox = new AxisAlignedBB(new BlockPos(x, y, z));
|
|
List<EntityLivingBase> entities = world.getEntitiesWithinAABB(EntityLivingBase.class, boundingBox);
|
|
|
|
float distance = -1;
|
|
EntityLivingBase nearestEntity = null;
|
|
// Finds the nearest entity within the bounding box
|
|
for(EntityLivingBase entity : entities){
|
|
float newDistance = (float)entity.getDistance(x, y, z);
|
|
if(distance == -1 || newDistance < distance){
|
|
distance = newDistance;
|
|
nearestEntity = entity;
|
|
}
|
|
}
|
|
|
|
if(nearestEntity == null) return false;
|
|
|
|
// Only return on the server side or the client probably won't spawn particles
|
|
if(!this.applyEffects(nearestEntity, modifiers) && !world.isRemote) return false;
|
|
if(world.isRemote) this.spawnParticles(world, nearestEntity, modifiers);
|
|
// This MUST be the coordinates of the actual dispenser, so we need to offset it
|
|
this.playSound(world, x - direction.getXOffset(), y - direction.getYOffset(), z - direction.getZOffset(), ticksInUse, duration, modifiers);
|
|
|
|
return true;
|
|
}
|
|
|
|
/** Actually applies the status effects to the caster. By default, this iterates through the array of effects and
|
|
* applies each in turn, multiplying the duration and amplifier by the appropriate modifiers. Particles are always
|
|
* hidden and isAmbient is always set to false. Override to do something special, like apply a non-potion buff.
|
|
* Returns a boolean to allow subclasses to cause the spell to fail if for some reason the effect cannot be applied
|
|
* (for example, {@link Heal} fails if the caster is on full health). */
|
|
protected boolean applyEffects(EntityLivingBase caster, SpellModifiers modifiers){
|
|
// This will generate 0 for novice and apprentice, and 1 for advanced and master
|
|
// TODO: Once we've found a way of detecting if amplifiers actually affect the potion type, implement it here.
|
|
int bonusAmplifier = getBonusAmplifier(modifiers.get(SpellModifiers.POTENCY));
|
|
|
|
for(Potion potion : potionSet){
|
|
caster.addPotionEffect(new PotionEffect(potion, potion.isInstant() ? 1 :
|
|
(int)(getProperty(getDurationKey(potion)).floatValue() * modifiers.get(WizardryItems.duration_upgrade)),
|
|
(int)getProperty(getStrengthKey(potion)).floatValue() + bonusAmplifier,
|
|
false, true));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/** Returns the number to be added to the potion amplifier(s) based on the given potency modifier. Override
|
|
* to define custom modifier handling. Delegates to {@link SpellBuff#getStandardBonusAmplifier(float)} by
|
|
* default. */
|
|
protected int getBonusAmplifier(float potencyModifier){
|
|
return getStandardBonusAmplifier(potencyModifier);
|
|
}
|
|
|
|
/** Returns a number to be added to potion amplifiers based on the given potency modifier. This method uses
|
|
* a standard calculation which results in zero extra levels for novice and apprentice wands and one extra
|
|
* level for advanced and master wands (this generally seems to give about the right weight to potency
|
|
* modifiers). This is public static because it is useful in a variety of places. */
|
|
public static int getStandardBonusAmplifier(float potencyModifier){
|
|
return (int)((potencyModifier - 1) / 0.4);
|
|
}
|
|
|
|
/** Spawns buff particles around the caster. Override to add a custom particle effect. Only called client-side. */
|
|
protected void spawnParticles(World world, EntityLivingBase caster, SpellModifiers modifiers){
|
|
|
|
for(int i = 0; i < particleCount; i++){
|
|
double x = caster.posX + world.rand.nextDouble() * 2 - 1;
|
|
double y = caster.posY + caster.getEyeHeight() - 0.5 + world.rand.nextDouble();
|
|
double z = caster.posZ + world.rand.nextDouble() * 2 - 1;
|
|
ParticleBuilder.create(Type.SPARKLE).pos(x, y, z).vel(0, 0.1, 0).clr(r, g, b).spawn(world);
|
|
}
|
|
|
|
ParticleBuilder.create(Type.BUFF).entity(caster).clr(r, g, b).spawn(world);
|
|
}
|
|
|
|
}
|