Initial commit

2018-01-19 20:33:04 +00:00
commit da6b007a3a
945 changed files with 60616 additions and 0 deletions
@@ -0,0 +1,153 @@
+package electroblob.wizardry.entity.construct;
+
+import java.lang.ref.WeakReference;
+import java.util.UUID;
+
+import electroblob.wizardry.util.WizardryUtilities;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.common.registry.IEntityAdditionalSpawnData;
+
+/**
+ * This class is for all inanimate magical constructs which are not projectiles. It was made from scratch
+ * to provide a unifying superclass for black hole, blizzard, tornado and a few others which all share some
+ * characteristics. The EntityPlayer instance of the caster, the lifetime and the damage multiplier are stored
+ * and synced here.
+ * <p>
+ * When extending this class, override both constructors. Generally speaking, subclasses of this class are areas
+ * of effect which deal damage or apply effects over time.
+ * @since Wizardry 1.0
+ */
+public abstract class EntityMagicConstruct extends Entity implements IEntityAdditionalSpawnData {
+	
+	/** The entity that created this construct */
+	private WeakReference<EntityLivingBase> caster;
+	
+	/** The UUID of the caster. Note that this is only for loading purposes; during normal updates
+	 * the actual entity instance is stored (so that getEntityByUUID is not called constantly),
+	 * so this will not always be synced (this is why it is private). */
+	private UUID casterUUID;
+	
+	/** The time in ticks this magical construct lasts for; defaults to 600 (30 seconds). If this is -1 the construct
+	 * doesn't despawn. */
+	public int lifetime = 600;
+	
+	/** The damage multiplier for this construct, determined by the wand with which it was cast. */
+	public float damageMultiplier = 1.0f;
+	
+	public EntityMagicConstruct(World par1World) {
+		super(par1World);
+		this.height = 1.0f;
+		this.width = 1.0f;
+		this.noClip = true;
+	}
+	
+	public EntityMagicConstruct(World world, double x, double y, double z, EntityLivingBase caster, int lifetime, float damageMultiplier) {
+		super(world);
+		this.height = 1.0f;
+		this.width = 1.0f;
+		this.setPosition(x, y, z);
+		this.caster = new WeakReference<EntityLivingBase>(caster);
+		this.noClip = true;
+		this.lifetime = lifetime;
+		this.damageMultiplier = damageMultiplier;
+	}
+	
+	// Overrides the original to stop the entity moving when it intersects stuff. The default arrow does this to allow
+    // it to stick in blocks.
+	@Override
+	public void setPositionAndRotationDirect(double x, double y, double z, float yaw, float pitch, int posRotationIncrements, boolean teleport)
+    {
+        this.setPosition(x, y, z);
+        this.setRotation(yaw, pitch);
+    }
+	
+	public void onUpdate(){
+		
+		if(this.getCaster() == null && this.casterUUID != null){
+			Entity entity = WizardryUtilities.getEntityByUUID(worldObj, casterUUID);
+			if(entity instanceof EntityLivingBase){
+				this.caster = new WeakReference<EntityLivingBase>((EntityLivingBase)entity);
+			}
+		}
+		
+		if(this.ticksExisted > lifetime && lifetime != -1){
+			this.despawn();
+		}
+		
+		super.onUpdate();
+		
+	}
+	
+	/**
+	 * Defaults to just setDead() in EntityMagicConstruct, but is provided to allow subclasses to override this
+	 * e.g. bubble uses it to dismount the entity inside it and play the 'pop' sound before calling super(). You
+	 * should always call super() when overriding this method, in case it changes. There is no need, therefore, to
+	 * call setDead() when overriding.
+	 */
+	public void despawn(){
+		this.setDead();
+	}
+
+	@Override
+	protected void entityInit() {
+		
+	}
+
+	@Override
+	protected void readEntityFromNBT(NBTTagCompound nbttagcompound){
+		casterUUID = nbttagcompound.getUniqueId("casterUUID");
+        lifetime = nbttagcompound.getInteger("lifetime");
+        damageMultiplier = nbttagcompound.getFloat("damageMultiplier");
+	}
+
+	@Override
+	protected void writeEntityToNBT(NBTTagCompound nbttagcompound){
+		if(this.getCaster() != null){
+        	nbttagcompound.setUniqueId("casterUUID", this.getCaster().getUniqueID());
+        }
+		nbttagcompound.setInteger("lifetime", lifetime);
+		nbttagcompound.setFloat("damageMultiplier", damageMultiplier);
+	}
+	
+	@Override
+	public void writeSpawnData(ByteBuf data){
+		data.writeInt(lifetime);
+	}
+
+	@Override
+	public void readSpawnData(ByteBuf data){
+		lifetime = data.readInt();
+	}
+
+	/**
+	 * Returns the EntityLivingBase that created this construct, 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 construct simply had no caster in the first place.
+	 */
+	public EntityLivingBase getCaster() {
+		return caster == null ? null : caster.get();
+	}
+	
+	/**
+	 * Shorthand for {@link WizardryUtilities#isValidTarget(Entity, Entity)}, with the owner of this construct as the
+	 * attacker. Also allows subclasses to override it if they wish to do so.
+	 */
+	public boolean isValidTarget(Entity target){
+		return WizardryUtilities.isValidTarget(this.getCaster(), target);
+	}
+	
+	@Override
+    public boolean canRenderOnFire()
+    {
+        return false;
+    }
+	
+	@Override
+	public boolean isPushedByWater() {
+		return false;
+	}
+}