Adding an animation action that can spawn projectiles (#155)

* Fixing cases where monsters with custom projectiles could shoot themselves

* Adding an animation action that can spawn projectiles

* Disconnecting the ranged and melee attack timers

* Spell cast animations stop monster movement as well

* Monsters tossing potions will set them off

Author: Interrupt

Dungeoneer/src/com/interrupt/dungeoneer/entities/Monster.java

@@ -1,5 +1,6 @@
 package com.interrupt.dungeoneer.entities;
 
+import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.graphics.Color;
 import com.badlogic.gdx.math.Vector3;
 import com.badlogic.gdx.utils.Array;
@@ -70,6 +71,10 @@ public class Monster extends Actor implements Directional {
 	@EditorProperty
 	private float attackTime = 60;
 
+	/** Time to wait before starting to move again after an attack. */
+	@EditorProperty
+	private float postAttackMoveWaitTime = 0.01f;
+
 	/** Time interval between monster projectile attacks. */
 	@EditorProperty
 	private float projectileAttackTime = 100;
@@ -87,9 +92,11 @@ public class Monster extends Actor implements Directional {
 	public float projectileOffset = 0f;
 
 	private float attacktimer = 0;
+	private float rangedAttackTimer = 0;
 	private float regenManaTimer = 0;
 
 	private float stuntime = 0;
+	private float postAttackMoveWaitTimer = 0;
 
 	/** Is monster alerted to player's presence? */
 	public boolean alerted = false;
@@ -200,6 +207,9 @@ public class Monster extends Actor implements Directional {
 	/** Monster attack animation. */
 	private SpriteAnimation attackAnimation = null;
 
+	/** Monster ranged attack animation. */
+	private SpriteAnimation rangedAttackAnimation = null;
+
 	/** Monster cast animation. */
 	private SpriteAnimation castAnimation = null;
 
@@ -279,6 +289,7 @@ public Monster() {
 		stepHeight = 0.4f;
 
 		attacktimer = 30;
+		rangedAttackTimer = 30;
 
 		mass = 2f;
 
@@ -379,6 +390,7 @@ public int takeDamage(int damage, DamageType damageType, Entity instigator) {
 		int tookDamage = super.takeDamage(damage, damageType, instigator);
 		if(doPainRoll(tookDamage)) {
 			if (attackAnimation != null) attackAnimation.playing = false;
+			if (rangedAttackAnimation != null) rangedAttackAnimation.playing = false;
 			if (hurtAnimation != null) hurtAnimation.play();
 		}
 		return tookDamage;
@@ -437,6 +449,7 @@ public void tick(Level level, float delta)
 
 		// tick some timers (TODO: MAKE A TIMER HELPER)
 		if(attacktimer > 0) attacktimer -= delta;
+		if(rangedAttackTimer > 0) rangedAttackTimer -= delta;
 		regenManaTimer += delta;
 
 		if(regenManaTimer > 60) {
@@ -473,7 +486,9 @@ public void tick(Level level, float delta)
 		if(hostile) {
 			canSeePlayer = level.canSeeIncludingDoors(x, y, player.x, player.y, 17);
 
+			// Reset attack timers if we lose track of the player
 			if(!canSeePlayer && attacktimer < 30) attacktimer = 30;
+			if(!canSeePlayer && rangedAttackTimer < 30) rangedAttackTimer = 30;
 
 			pxdir = player.x - x;
 			pydir = player.y - y;
@@ -506,6 +521,7 @@ else if(playerdist > 0.75f) {
 				Audio.playPositionedSound(alertSound, new Vector3(x, y, z), soundVolume, 1f, 12f);
 
 				attacktimer = 40 + Game.rand.nextInt(20);
+				rangedAttackTimer = 40 + Game.rand.nextInt(20);
 			}
 		}
 
@@ -663,15 +679,34 @@ else if(tryAt == 4)
 			txa = 0;
 			tza = 0;
 		}
+
+		// stop moving after an attack
+		if(postAttackMoveWaitTimer > 0) {
+			boolean isPlayingAttackAnimation = false;
+
+			if(attackAnimation != null)
+				isPlayingAttackAnimation |= attackAnimation.playing;
+			if(rangedAttackAnimation != null)
+				isPlayingAttackAnimation |= rangedAttackAnimation.playing;
+			if(castAnimation != null)
+				isPlayingAttackAnimation |= castAnimation.playing;
+
+			if(!isPlayingAttackAnimation)
+				postAttackMoveWaitTimer -= delta;
+
+			txa = 0;
+			tza = 0;
+		}
 
-		if(hostile && (playerdist < collision.x + reach || playerdist < collision.x + attackStartDistance))
-		{
-		    float zDiff = Math.abs((player.z + 0.3f) - (z + 0.3f));
-            if(zDiff < reach || zDiff < attackStartDistance) {
-                attack(player);
-                txa = 0;
-                tza = 0;
-            }
+		if(hostile) {
+			if((playerdist < collision.x + reach || playerdist < collision.x + attackStartDistance)) {
+				float zDiff = Math.abs((player.z + 0.3f) - (z + 0.3f));
+				if (zDiff < reach || zDiff < attackStartDistance) {
+					attack(player);
+				}
+			} else if(playerdist > projectileAttackMinDistance && playerdist < projectileAttackMaxDistance && (projectile != null || rangedAttackAnimation != null)) {
+				rangedAttack(player);
+			}
 		}
 
 		if(walkSound != null) {
@@ -762,62 +797,8 @@ else if(tryAt == 4)
 					}
 				}
 			}
-		}
-
-		if(projectile != null && attacktimer <= 0 && stuntime <= 0 && canSeePlayer && hostile && !isParalyzed()
-				&& playerdist < projectileAttackMaxDistance && playerdist > projectileAttackMinDistance)
-		{
-			// face fire direction!
-			setDirectionTowards(player);
-
-			attacktimer = projectileAttackTime;
-			if(attackAnimation != null) {
-				attackAnimation.play();
-			}
 
-			try {
-				Entity pCopy = null;
-				if(projectile instanceof Prefab) {
-					Prefab p = (Prefab)projectile;
-					pCopy = EntityManager.instance.getEntity(p.category, p.name);
-				}
-				else {
-					pCopy = (Entity) KryoSerializer.copyObject(projectile);
-				}
-
-				if(pCopy != null) {
-					pCopy.owner = this;
-					pCopy.ignorePlayerCollision = false;
-
-					// spawns from this entity
-					pCopy.x = x;
-					pCopy.y = y;
-					pCopy.z = projectileOffset + z + (collision.z * 0.6f);
-
-					Vector3 dirToPlayer = new Vector3(player.x, player.y, player.z + (player.collision.z * 0.5f));
-					if (!pCopy.floating) {
-						// Go ballistics
-						dirToPlayer.z += (playerdist * playerdist) * projectileBallisticsMod;
-					}
-
-					dirToPlayer.sub(pCopy.x, pCopy.y, pCopy.z).nor();
-
-					// offset out of collision
-					pCopy.x += dirToPlayer.x * collision.x * 0.5f;
-					pCopy.y += dirToPlayer.y * collision.x * 0.5f;
-					pCopy.z += dirToPlayer.z * collision.x * 0.5f;
-
-					// initial speed
-					dirToPlayer.scl(projectileSpeed);
-
-					pCopy.xa = dirToPlayer.x;
-					pCopy.ya = dirToPlayer.y;
-					pCopy.za = dirToPlayer.z;
-
-					level.SpawnEntity(pCopy);
-				}
-			}
-			catch(Exception ex) { }
+			postAttackMoveWaitTimer = postAttackMoveWaitTime;
 		}
 
 		// idle sounds!
@@ -836,10 +817,11 @@ else if(tryAt == 4)
 		if(hurtAnimation != null && hurtAnimation.playing) hurtAnimation.animate(delta, this);
 		else if(castAnimation != null && castAnimation.playing) castAnimation.animate(delta, this);
 		else if(attackAnimation != null && attackAnimation.playing) attackAnimation.animate(delta, this);
+		else if(rangedAttackAnimation != null && rangedAttackAnimation.playing) rangedAttackAnimation.animate(delta, this);
 		else if(dodgeAnimation != null && dodgeAnimation.playing) dodgeAnimation.animate(delta, this);
 		else if(walkAnimation != null) walkAnimation.animate(delta, this);
 	}
-	
+
 	private float getSpeed() {
 		float baseSpeed = speed;
 
@@ -1142,36 +1124,128 @@ public void attack(Entity target)
 		if(!hostile) return;
 		if(stuntime > 0) return;
 		if(isParalyzed()) return;
-		if(!alerted) alerted = true;
+		alerted = true;
 
-		if(attacktimer <= 0)
-		{
-			if(dodgeAnimation != null) {
-				dodgeAnimation.play();
-				attacktimer = attackTime * 2;
-				return;
+		if(attacktimer > 0)
+			return;
+
+		if(dodgeAnimation != null) {
+			dodgeAnimation.play();
+			attacktimer = attackTime * 2;
+			return;
+		}
+
+		attackTarget = target;
+		attacktimer = attackTime + Game.rand.nextInt(10);
+		Audio.playPositionedSound(attackSwingSound, new Vector3(x, y, z), 0.75f, 1f, 12f);
+
+		setDirectionTowards(attackTarget);
+
+		if(Game.rand.nextFloat() > 0.7f) Audio.playPositionedSound(attackSound, new Vector3(x, y, z), soundVolume, 1f, 12f);
+
+		if(attackAnimation != null) {
+			attackAnimation.play();
+
+			// if no actions are set, just do the damage hit now
+			// otherwise assume that there's a set damage frame
+			if(attackAnimation.actions == null) {
+				tryDamageHit(attackTarget, 0f, 0.05f);
 			}
+		}
+		else {
+			tryDamageHit(attackTarget, 0f, 0.05f);
+		}
 
-			attackTarget = target;
-			attacktimer = attackTime + Game.rand.nextInt(10);
-			Audio.playPositionedSound(attackSwingSound, new Vector3(x, y, z), 0.75f, 1f, 12f);
+		postAttackMoveWaitTimer = postAttackMoveWaitTime;
+	}
+
+	private void rangedAttack(Entity target) {
+		if(target == null || !target.isActive) return;
+		if(!hostile) return;
+		if(stuntime > 0) return;
+		if(isParalyzed()) return;
+		alerted = true;
 
-			setDirectionTowards(attackTarget);
+		if(rangedAttackTimer > 0)
+			return;
 
-			if(Game.rand.nextFloat() > 0.7f) Audio.playPositionedSound(attackSound, new Vector3(x, y, z), soundVolume, 1f, 12f);
+		attackTarget = target;
+		rangedAttackTimer = projectileAttackTime + Game.rand.nextInt(15);
+		setDirectionTowards(attackTarget);
 
-			if(attackAnimation != null) {
-				attackAnimation.play();
+		if(rangedAttackAnimation != null) {
+			rangedAttackAnimation.play();
 
-				// if no actions are set, just do the damage hit now
-				// otherwise assume that there's a set damage frame
-				if(attackAnimation.actions == null) {
-					tryDamageHit(attackTarget, 0f, 0.05f);
-				}
+			// If no actions are set, try to spawn the basic projectile.
+			// Otherwise, assume there is a ProjectileAttackAction in there.
+			if(rangedAttackAnimation.actions == null) {
+				spawnBasicProjectile(target);
+			}
+		}
+		else {
+			spawnBasicProjectile(target);
+		}
+
+		postAttackMoveWaitTimer = postAttackMoveWaitTime;
+	}
+
+	private void spawnBasicProjectile(Entity target) {
+		// face fire direction!
+		setDirectionTowards(target);
+
+		rangedAttackTimer = projectileAttackTime;
+		if(attackAnimation != null) {
+			attackAnimation.play();
+		}
+
+		try {
+			Entity pCopy = null;
+			if(projectile instanceof Prefab) {
+				Prefab p = (Prefab)projectile;
+				pCopy = EntityManager.instance.getEntity(p.category, p.name);
 			}
 			else {
-				tryDamageHit(attackTarget, 0f, 0.05f);
+				pCopy = (Entity) KryoSerializer.copyObject(projectile);
 			}
+
+			if(pCopy != null) {
+				pCopy.owner = this;
+				pCopy.ignorePlayerCollision = false;
+
+				// spawns from this entity
+				pCopy.x = x;
+				pCopy.y = y;
+				pCopy.z = projectileOffset + z + (collision.z * 0.6f);
+
+				Vector3 dirToTarget = new Vector3(target.x, target.y, target.z + (target.collision.z * 0.5f));
+				if (!pCopy.floating) {
+					// Go ballistics
+					dirToTarget.z += (playerdist * playerdist) * projectileBallisticsMod;
+				}
+
+				dirToTarget.sub(pCopy.x, pCopy.y, pCopy.z).nor();
+
+				// offset out of collision
+				pCopy.x += dirToTarget.x * collision.x * 0.5f;
+				pCopy.y += dirToTarget.y * collision.x * 0.5f;
+				pCopy.z += dirToTarget.z * collision.x * 0.5f;
+
+				// initial speed
+				dirToTarget.scl(projectileSpeed);
+
+				pCopy.xa = dirToTarget.x;
+				pCopy.ya = dirToTarget.y;
+				pCopy.za = dirToTarget.z;
+
+				// Some items trigger effects when thrown
+				if(pCopy instanceof Item)
+					((Item)pCopy).tossItem(Game.instance.level, 1.0f);
+
+				Game.instance.level.SpawnEntity(pCopy);
+			}
+		}
+		catch(Exception ex) {
+			Gdx.app.log("DelverGame", "Error spawning projectile: " + ex.getMessage());
 		}
 	}