Electroblob
383 lines
17 KiB
Java
383 lines
17 KiB
Java
package electroblob.wizardry.entity.living;
|
|
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.Arrays;
|
|
import java.util.UUID;
|
|
|
|
import javax.annotation.Nullable;
|
|
|
|
import com.google.common.base.Predicate;
|
|
|
|
import electroblob.wizardry.WizardData;
|
|
import electroblob.wizardry.Wizardry;
|
|
import electroblob.wizardry.item.ItemWand;
|
|
import electroblob.wizardry.util.IElementalDamage;
|
|
import electroblob.wizardry.util.IndirectMinionDamage;
|
|
import electroblob.wizardry.util.MagicDamage.DamageType;
|
|
import electroblob.wizardry.util.MinionDamage;
|
|
import electroblob.wizardry.util.WizardryParticleType;
|
|
import electroblob.wizardry.util.WizardryUtilities;
|
|
import io.netty.buffer.ByteBuf;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityList;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.monster.IMob;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.util.DamageSource;
|
|
import net.minecraft.util.EntityDamageSource;
|
|
import net.minecraft.util.EntityDamageSourceIndirect;
|
|
import net.minecraft.util.EnumHand;
|
|
import net.minecraftforge.event.entity.living.LivingAttackEvent;
|
|
import net.minecraftforge.fml.common.Mod;
|
|
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
|
|
import net.minecraftforge.fml.common.registry.IEntityAdditionalSpawnData;
|
|
|
|
/**
|
|
* Interface for all summoned creatures. The code for summoned creatures has been overhauled in Wizardry 2.1, and this
|
|
* interface allows summoned creatures to extend vanilla (or indeed modded) entity classes, so
|
|
* <code>EntitySummonedZombie</code> now extends <code>EntityZombie</code>, for example. This change has two major
|
|
* benefits:
|
|
* <p>
|
|
* - There is no longer any need for separate render classes, because summoned creatures are now instances of vanilla
|
|
* types. <i>You don't even need to assign a render class</i> because the supertype should already be assigned the
|
|
* correct one.<br>
|
|
* - Summoned creature classes are now much more robust when it comes to changes between Minecraft versions, since none
|
|
* of the vanilla code needs to be copied.
|
|
* <p>
|
|
* <b>Summoned creatures that do not emulate vanilla entities do not directly implement this interface</b>. Instead,
|
|
* they should extend the abstract base implementation, {@link EntitySummonedCreature}.
|
|
* <p>
|
|
* All damage dealt by ISummonedCreature instances is redirected via
|
|
* {@link ISummonedCreature#onLivingAttackEvent(net.minecraftforge.event.entity.living.LivingAttackEvent)
|
|
* ISummonedCreature.onLivingAttackEvent(LivingAttackEvent)} and replaced by an instance of
|
|
* {@link electroblob.wizardry.util.IElementalDamage IElementalDamage} with the summoner of that creature as the source
|
|
* rather than the creature itself. This means that kills by summoned creatures register as kills for their owner,
|
|
* dropping xp and rare loot if that owner is a player.
|
|
* <p>
|
|
* Though this system is a lot better than the previous system, <i>it is not a perfect solution</i>. The old
|
|
* EntitySummonedCreature class overrode some methods from Entity in order to add shared functionality, but this cannot
|
|
* be done with an interface. To get around this problem, this interface contains 5 delegate methods that do the same
|
|
* things, with the aim of centralising as much code as possible, even though it is not automatically applied.
|
|
* <b>Implementing classes must override the corresponding methods from Entity, and within them, call the appropriate
|
|
* delegate method in this interface.</b> It is impossible to enforce this condition, but the summoned creature will not
|
|
* work properly unless it is adhered to. <i>The position of the delegate method call is unimportant, but by convention
|
|
* it is usually at the start of the calling method, which avoids it being unintentionally skipped by a return
|
|
* statement (except for methods where the result of the delegate method should itself be returned).</i>
|
|
* <p>
|
|
* It is recommended that when implementing this interface, you begin by copying {@link EntitySummonedCreature} to
|
|
* ensure all the relevant methods are duplicated. You can then change the superclass, override any additional methods
|
|
* and add functionality to any that are already overridden. You will always want to override the AI methods at the very
|
|
* least.
|
|
* <p>
|
|
* Due to the limitations of interfaces, some methods that really ought to be protected are public. These are clearly
|
|
* marked as 'Internal, DO NOT CALL'. <b>Don't call them, only implement them.</b>
|
|
*
|
|
* @since Wizardry 2.1
|
|
* @author Electroblob
|
|
*/
|
|
/* Quite honestly, this is not what default methods are really for. However, this is modding, and in modding some
|
|
* sacrifices have to be made when it comes to Java style - because adding on to a pre-existing program is not a good
|
|
* way of doing this sort of thing anyway, but we have no choice about that! */
|
|
@Mod.EventBusSubscriber
|
|
public interface ISummonedCreature extends IEntityAdditionalSpawnData {
|
|
|
|
// Remember that ALL fields are static and final in interfaces, even if they don't explicitly state that.
|
|
String NAMEPLATE_TRANSLATION_KEY = "entity." + Wizardry.MODID + ":summonedcreature.nameplate";
|
|
|
|
// Setters and getters. The subclass fields that these access should be private.
|
|
|
|
/** Sets the lifetime of the summoned creature in ticks. */
|
|
void setLifetime(int ticks);
|
|
|
|
/**
|
|
* Returns the lifetime of the summoned creature in ticks. Allows primarily for duration multiplier support, but
|
|
* also for example the skeleton legion spell which lasts for 60 seconds instead of the usual 30. Syncing and saving
|
|
* is done automatically. As of Wizardry 2.1, despawning is handled in ISummonedCreature; see
|
|
* {@link ISummonedCreature#onDespawn()} for details.
|
|
*/
|
|
int getLifetime();
|
|
|
|
/**
|
|
* Sets the WeakReference object which refers to the owner of this summoned creature. Internal, don't call unless
|
|
* you know what you are doing.
|
|
*/
|
|
void setCasterReference(WeakReference<EntityLivingBase> reference);
|
|
|
|
/**
|
|
* Returns a WeakReference object which refers to the owner of this summoned creature. Subclasses should store this
|
|
* as a private field. This may be null; as such it is preferable to use {@link ISummonedCreature#getCaster()} to
|
|
* get the caster object itself.
|
|
*/
|
|
@Nullable
|
|
WeakReference<EntityLivingBase> getCasterReference();
|
|
|
|
/** Internal, DO NOT CALL. */
|
|
void setCasterUUID(UUID uuid);
|
|
|
|
/** Internal, DO NOT CALL. This is for loading purposes only and is not usually synchronised. */
|
|
UUID getCasterUUID();
|
|
|
|
/**
|
|
* Returns the EntityLivingBase that summoned this creature, or null if it no longer exists. Cases where the entity
|
|
* may no longer exist are: entity died or was deleted, mob despawned, player logged out, entity teleported to
|
|
* another dimension, or this creature simply had no caster in the first place. <i>This is the correct method to use
|
|
* to get the owner of this summoned creature.
|
|
*/
|
|
@Nullable
|
|
default EntityLivingBase getCaster(){
|
|
return getCasterReference() == null ? null : getCasterReference().get();
|
|
}
|
|
|
|
// Miscellaneous
|
|
|
|
/**
|
|
* Called by the server when constructing the spawn packet. Data should be added to the provided stream.
|
|
* <b>Implementors must call super when overriding.</b>
|
|
*
|
|
* @param buffer The packet data stream
|
|
*/
|
|
@Override
|
|
default void writeSpawnData(ByteBuf buffer){
|
|
buffer.writeInt(getCaster() != null ? getCaster().getEntityId() : -1);
|
|
buffer.writeInt(getLifetime());
|
|
}
|
|
|
|
/**
|
|
* Called by the client when it receives a Entity spawn packet. Data should be read out of the stream in the same
|
|
* way as it was written. <b>Implementors must call super when overriding.</b>
|
|
*
|
|
* @param additionalData The packet data stream
|
|
*/
|
|
@Override
|
|
default void readSpawnData(ByteBuf buffer){
|
|
int id = buffer.readInt();
|
|
// We're on the client side here, so we can safely use Minecraft.getMinecraft().world via proxies.
|
|
if(id > -1) setCasterReference(
|
|
new WeakReference<EntityLivingBase>((EntityLivingBase)Wizardry.proxy.getTheWorld().getEntityByID(id)));
|
|
setLifetime(buffer.readInt());
|
|
}
|
|
|
|
/**
|
|
* Shorthand for {@link WizardryUtilities#isValidTarget(Entity, Entity)}, with the owner of this creature as the
|
|
* attacker. Also allows implementors to override it if they wish to do so.
|
|
*/
|
|
default boolean isValidTarget(Entity target){
|
|
return WizardryUtilities.isValidTarget(this.getCaster(), target);
|
|
}
|
|
|
|
/**
|
|
* Returns a entity selector to be passed into AI methods. Normally, this should not be overridden, but it is
|
|
* possible for implementors to override this in order to do something special when selecting a target.
|
|
*/
|
|
default Predicate<Entity> getTargetSelector(){
|
|
|
|
return new Predicate<Entity>(){
|
|
|
|
public boolean apply(Entity entity){
|
|
// TODO: Backport invisibility check (also in wizards)
|
|
// If the target is valid and not invisible...
|
|
if(!entity.isInvisible() && isValidTarget(entity)){
|
|
|
|
// ... and is a player, they can be attacked, since players can't be in the whitelist or the
|
|
// blacklist.
|
|
if(entity instanceof EntityPlayer) return true;
|
|
|
|
// ... and is a mob, a summoned creature, a wizard ...
|
|
if((entity instanceof IMob || entity instanceof ISummonedCreature
|
|
|| (entity instanceof EntityWizard && !(getCaster() instanceof EntityWizard))
|
|
// ... or in the whitelist ...
|
|
|| Arrays.asList(Wizardry.settings.summonedCreatureTargetsWhitelist)
|
|
.contains(EntityList.getKey(entity.getClass())))
|
|
// ... and isn't in the blacklist ...
|
|
&& !Arrays.asList(Wizardry.settings.summonedCreatureTargetsBlacklist)
|
|
.contains(EntityList.getKey(entity.getClass()))){
|
|
// ... it can be attacked.
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Called when this creature has existed for 1 tick, effectively when it has just been spawned. Normally used to add
|
|
* particles, sounds, etc.
|
|
*/
|
|
void onSpawn();
|
|
|
|
/**
|
|
* Called when this summoned creature vanishes. Normally used to add particles, sounds, etc.
|
|
*/
|
|
void onDespawn();
|
|
|
|
/** Whether this creature should spawn a subtle black swirl particle effect while alive. */
|
|
boolean hasParticleEffect();
|
|
|
|
/**
|
|
* Called from the event handler after the damage change is applied. Does nothing by default, but can be overridden
|
|
* to do something when a successful attack is made. This was added because the event-based damage source system can
|
|
* cause parts of attackEntityAsMob not to fire, since attackEntityFrom is intercepted and canceled.
|
|
* <p>
|
|
* Usage examples: {@link EntitySliverfishMinion} uses this to summon more silverfish if the target is killed,
|
|
* {@link EntitySkeletonMinion} and {@link EntitySpiderMinion} use this to add potion effects to the target.
|
|
*/
|
|
default void onSuccessfulAttack(EntityLivingBase target){
|
|
};
|
|
|
|
// Delegates
|
|
|
|
/**
|
|
* Implementors should call this from writeEntityToNBT. Can be overridden as long as super is called, but there's
|
|
* very little point in doing that since anything extra could just be added to writeEntityToNBT anyway.
|
|
*/
|
|
default void writeNBTDelegate(NBTTagCompound tagcompound){
|
|
if(this.getCaster() != null){
|
|
tagcompound.setUniqueId("casterUUID", this.getCaster().getUniqueID());
|
|
}
|
|
tagcompound.setInteger("lifetime", getLifetime());
|
|
}
|
|
|
|
/**
|
|
* Implementors should call this from readEntityFromNBT. Can be overridden as long as super is called, but there's
|
|
* very little point in doing that since anything extra could just be added to readEntityFromNBT anyway.
|
|
*/
|
|
default void readNBTDelegate(NBTTagCompound tagcompound){
|
|
this.setCasterUUID(tagcompound.getUniqueId("casterUUID"));
|
|
this.setLifetime(tagcompound.getInteger("lifetime"));
|
|
}
|
|
|
|
/**
|
|
* Implementors should call this from setRevengeTarget, and call super.setRevengeTarget if and only if this method
|
|
* returns <b>true</b>.
|
|
*/
|
|
default boolean shouldRevengeTarget(EntityLivingBase entity){
|
|
// Allows the config to prevent minions from revenge-targeting their owners.
|
|
return entity != this.getCaster() || Wizardry.settings.minionRevengeTargeting;
|
|
}
|
|
|
|
/**
|
|
* Implementors should call this from onUpdate. Can be overridden as long as super is called, but there's very
|
|
* little point in doing that since anything extra could just be added to onUpdate anyway.
|
|
*/
|
|
default void updateDelegate(){
|
|
|
|
if(!(this instanceof Entity))
|
|
throw new ClassCastException("Implementations of ISummonedCreature must extend Entity!");
|
|
|
|
Entity thisEntity = ((Entity)this);
|
|
|
|
if(this.getCaster() == null && this.getCasterUUID() != null){
|
|
Entity entity = WizardryUtilities.getEntityByUUID(thisEntity.world, getCasterUUID());
|
|
if(entity instanceof EntityLivingBase){
|
|
this.setCasterReference(new WeakReference<EntityLivingBase>((EntityLivingBase)entity));
|
|
}
|
|
}
|
|
|
|
if(thisEntity.ticksExisted == 1){
|
|
this.onSpawn();
|
|
}
|
|
|
|
if(thisEntity.ticksExisted > this.getLifetime() && this.getLifetime() != -1){
|
|
this.onDespawn();
|
|
thisEntity.setDead();
|
|
}
|
|
|
|
if(this.hasParticleEffect() && thisEntity.world.isRemote && thisEntity.world.rand.nextInt(8) == 0)
|
|
Wizardry.proxy.spawnParticle(WizardryParticleType.DARK_MAGIC, thisEntity.world, thisEntity.posX,
|
|
thisEntity.posY + thisEntity.world.rand.nextDouble() * 1.5, thisEntity.posZ, 0.0d, 0.0d, 0.0d, 0,
|
|
0.1f, 0.0f, 0.0f);
|
|
|
|
}
|
|
|
|
/**
|
|
* Implementors should call this from processInteract, and call super.processInteract if and only if this method
|
|
* returns <b>false</b>.
|
|
*/
|
|
default boolean interactDelegate(EntityPlayer player, EnumHand hand){
|
|
|
|
ItemStack stack = player.getHeldItem(hand);
|
|
|
|
WizardData properties = WizardData.get(player);
|
|
// Selects one of the player's minions.
|
|
if(player.isSneaking() && stack.getItem() instanceof ItemWand){
|
|
|
|
if(!player.world.isRemote && properties != null && this.getCaster() == player){
|
|
|
|
if(properties.selectedMinion != null && properties.selectedMinion.get() == this){
|
|
// Deselects the selected minion if right-clicked again
|
|
properties.selectedMinion = null;
|
|
}else{
|
|
// Selects this minion
|
|
properties.selectedMinion = new WeakReference<ISummonedCreature>(this);
|
|
}
|
|
properties.sync();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Damage system
|
|
|
|
@SubscribeEvent
|
|
public static void onLivingAttackEvent(LivingAttackEvent event){
|
|
|
|
// Rather than bother overriding entire attack methods in ISummonedCreature implementations, it's easier (and
|
|
// more robust) to use LivingAttackEvent to modify the damage source.
|
|
if(event.getSource().getTrueSource() instanceof ISummonedCreature){
|
|
|
|
EntityLivingBase summoner = ((ISummonedCreature)event.getSource().getTrueSource()).getCaster();
|
|
|
|
if(summoner != null){
|
|
|
|
event.setCanceled(true);
|
|
DamageSource newSource = event.getSource();
|
|
// Copies over the original DamageType if appropriate.
|
|
DamageType type = event.getSource() instanceof IElementalDamage
|
|
? ((IElementalDamage)event.getSource()).getType()
|
|
: DamageType.MAGIC;
|
|
// Copies over the original isRetaliatory flag if appropriate.
|
|
boolean isRetaliatory = event.getSource() instanceof IElementalDamage
|
|
&& ((IElementalDamage)event.getSource()).isRetaliatory();
|
|
|
|
// All summoned creatures are classified as magic, so it makes sense to do it this way.
|
|
if(event.getSource() instanceof EntityDamageSourceIndirect){
|
|
newSource = new IndirectMinionDamage(event.getSource().damageType,
|
|
event.getSource().getImmediateSource(), event.getSource().getTrueSource(), summoner, type,
|
|
isRetaliatory);
|
|
}else if(event.getSource() instanceof EntityDamageSource){
|
|
// Name is copied over so it uses the appropriate vanilla death message
|
|
newSource = new MinionDamage(event.getSource().damageType, event.getSource().getTrueSource(), summoner,
|
|
type, isRetaliatory);
|
|
}
|
|
|
|
// Copy over any relevant 'attributes' the original DamageSource might have had.
|
|
if(event.getSource().isExplosion()) newSource.setExplosion();
|
|
if(event.getSource().isFireDamage()) newSource.setFireDamage();
|
|
if(event.getSource().isProjectile()) newSource.setProjectile();
|
|
|
|
// For some reason Minecraft calculates knockback relative to DamageSource#getTrueSource. In vanilla this
|
|
// is unnoticeable, but it looks a bit weird with summoned creatures involved - so this fixes that.
|
|
if(WizardryUtilities.attackEntityWithoutKnockback(event.getEntity(), newSource, event.getAmount())){
|
|
// Using event.getSource().getTrueSource() as this means the target is knocked back from the minion
|
|
WizardryUtilities.applyStandardKnockback(event.getSource().getTrueSource(), event.getEntityLiving());
|
|
((ISummonedCreature)event.getSource().getTrueSource()).onSuccessfulAttack(event.getEntityLiving());
|
|
// If the target revenge-targeted the summoner, make it revenge-target the minion instead
|
|
// (if it didn't revenge-target, do nothing)
|
|
if(event.getEntityLiving().getRevengeTarget() == summoner
|
|
&& event.getSource().getTrueSource() instanceof EntityLivingBase){
|
|
event.getEntityLiving().setRevengeTarget((EntityLivingBase)event.getSource().getTrueSource());
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|