feat: completed DoE implementation

Author: GioeleBucci

CHANGELOG.md

@@ -1,5 +1,16 @@
 ## v1.1
 
-- Fix a bug with inconsistent projectile speed
-- Fix broken spicy pepper test
-- Remove executable jar from tracked files (it can be accessed via the releases page)
+### New features
+- Added a new boss: Duke of Eyes!
+
+### Tweaks and changes
+- Increased invincibility duration after being hit by an attack to .5 seconds
+
+### Bugfixes
+- Fixed a bug with inconsistent projectile speed
+
+### Dev notes 
+- Added a new `Attack` class that features different attack patterns that can be used by any generic entity.
+- Removed executable jar from tracked files (it can be accessed via the releases page)
+- Fixed broken spicy pepper test
+- Refactored enemy projectile spawn in the decorators to use the generic methods provided by the `Attack` class

src/main/java/tbooop/model/boss/attacks/Attack.java

@@ -26,14 +26,14 @@ public static void vomit(Entity source, Point2d target,
         double scatterAngle = r.nextDouble(-maxScatterAngle, maxScatterAngle);
         Vector2d vec = new Vector2dImpl(target
                 .subtract(source.getPosition()).toV2d()).normalize();
-        double speed = r.nextDouble(maxprojSpeed - (projSpeedVariation * maxprojSpeed), maxprojSpeed);
+        double speed = r.nextDouble(maxprojSpeed - (projSpeedVariation / 100 * maxprojSpeed), maxprojSpeed);
         EnemyProjectile proj = new EnemyProjectile(vec.rotate(scatterAngle), source.getPosition(), speed);
         source.addProjectile(proj);
     }
 
     /** Returns the next direction */
     public static Vector2d spiral(Entity source, double projSpeed, Vector2d direction, double angle) {
-        Vector2d newDir = direction.rotate(angle);
+        Vector2d newDir = direction.rotate(angle).normalize();
         EnemyProjectile proj = new EnemyProjectile(newDir, source.getPosition(), projSpeed);
         source.addProjectile(proj);
         return newDir;
@@ -59,7 +59,7 @@ public static void radiusWithGap(Entity source, double projSpeed, int projectile
             angles.add(i * angle);
         }
         removeUpToNElements(angles, gapSize).forEach(a -> source.addProjectile(
-                new EnemyProjectile(Direction.RIGHT.toP2d().toV2d().rotate(a),
+                new EnemyProjectile(Direction.RIGHT.toP2d().toV2d().rotate(a).normalize(),
                         source.getPosition(), projSpeed)));
     }
 

src/main/java/tbooop/model/boss/impl/DukeOfEyes/DoEAngered.java

@@ -1,26 +1,107 @@
 package tbooop.model.boss.impl.DukeOfEyes;
 
+import tbooop.commons.api.Vector2d;
+import tbooop.commons.api.Vector2dUtils;
+import tbooop.model.boss.attacks.Attack;
 import tbooop.model.boss.impl.DukeOfEyes.DoESM.State;
 import tbooop.model.boss.stateMachine.api.AbstractState;
 import tbooop.model.enemy.api.ai.MovementAi;
 import tbooop.model.enemy.impl.ai.ChasingAi;
 import tbooop.model.player.api.Player;
+import java.util.Random;
 
 public class DoEAngered extends AbstractState<DoESM.State> {
 
+    private static final double VELOCITY_MULTIPLIER = 1.6;
+    private static final long TIME_BETWEEN_ATTACKS = 3000;
+    private static final long ATK_DURATION = 1000;
+    private static final long ATK_FREQUENCY = 20;
+    private static final double PROJECTILE_SPEED = 0.16;
     private DukeOfEyes doe;
+    private Player p;
     private MovementAi ai;
+    private double velocity;
+    private long timeSinceLastAttack;
+    private boolean isAttacking;
+    private AttackType attackType;
+    Random rand = new Random();
 
     public DoEAngered(DukeOfEyes doe, Player p) {
         super(doe);
         this.doe = doe;
+        this.p = p;
         ai = new ChasingAi(p);
+        velocity = doe.getVelocity() * VELOCITY_MULTIPLIER;
     }
 
+    @Override
+    public void onStateEnter() {
+        timeSinceLastAttack = TIME_BETWEEN_ATTACKS - 1;
+    }
+
+    private long atkWindowTime;
+    private long atkFreqTime;
+
     @Override
     public void updateState(long deltaTime) {
-        var nextPos = ai.newPosition(doe.getPosition(), deltaTime, doe.getVelocity());
-        doe.setPosition(nextPos);
+        if (!(isAttacking && attackType == AttackType.SPIRAL)) {
+            var nextPos = ai.newPosition(doe.getPosition(), deltaTime, velocity);
+            doe.setPosition(nextPos);
+        }
+        this.timeSinceLastAttack += deltaTime;
+        if (isAttacking) {
+            attack(deltaTime);
+        }
+        if (this.timeSinceLastAttack >= TIME_BETWEEN_ATTACKS) {
+            this.timeSinceLastAttack = 0;
+            setAttackMode(true);
+        }
+    }
+
+    private void attack(long deltaTime) {
+        atkWindowTime += deltaTime;
+        atkFreqTime += deltaTime;
+        if (atkWindowTime >= ATK_DURATION) {
+            setAttackMode(false);
+            return;
+        }
+        if (atkFreqTime >= ATK_FREQUENCY) {
+            atkFreqTime = 0;
+            performAttack();
+        }
+    }
+
+    private Vector2d dir = Vector2dUtils.randomNorm();
+
+    private void performAttack() {
+        switch (attackType) {
+            case SPIRAL:
+                dir = Attack.spiral(doe, PROJECTILE_SPEED / 2, dir, 35);
+                break;
+            case VOMIT:
+                Attack.vomit(doe, p.getPosition(), 10, PROJECTILE_SPEED, 30);
+                break;
+        }
+    }
+
+    private enum AttackType {
+        VOMIT,
+        SPIRAL;
+    }
+
+    private void setAttackMode(boolean isAttacking) {
+        this.isAttacking = isAttacking;
+        atkWindowTime = 0;
+        atkFreqTime = 0;
+        if (isAttacking) {
+            setRandomAttackType();
+        }
+    }
+
+    private void setRandomAttackType() {
+        AttackType[] attackTypes = AttackType.values();
+        int index = rand.nextInt(attackTypes.length);
+        attackType = attackTypes[index];
     }
 
     @Override

src/main/java/tbooop/model/boss/impl/DukeOfEyes/DoERoam.java

@@ -1,22 +1,23 @@
 package tbooop.model.boss.impl.DukeOfEyes;
 
-import tbooop.commons.api.Vector2d;
 import tbooop.commons.api.Vector2dUtils;
 import tbooop.model.boss.attacks.Attack;
 import tbooop.model.boss.impl.DukeOfEyes.DoESM.State;
 import tbooop.model.boss.stateMachine.api.AbstractState;
 import tbooop.model.enemy.api.ai.MovementAi;
 import tbooop.model.enemy.impl.ai.BouncingAi;
 import tbooop.model.player.api.Player;
+import java.util.Random;
 
 public class DoERoam extends AbstractState<DoESM.State> {
 
-    private MovementAi ai;
+    private static final long TIME_BETWEEN_ATTACKS = 3000;
+    private static final double PROJECTILE_SPEED = 0.08;
     private DukeOfEyes doe;
     private Player p;
-    private static final long TIME_BETWEEN_ATTACKS = 200;
-    private static final double PROJECTILE_SPEED = 0.08;
-    private long timeSinceLastShoot;
+    private MovementAi ai;
+    private long timeSinceLastAttack;
+    Random rand = new Random();
 
     public DoERoam(DukeOfEyes doe, Player p) {
         super(doe);
@@ -25,23 +26,32 @@ public DoERoam(DukeOfEyes doe, Player p) {
         ai = new BouncingAi(Vector2dUtils.randomNorm().toP2d(), doe.getCollider().getRadius());
     }
 
-    private Vector2d dir = Vector2dUtils.randomNorm();
-
     @Override
     public void updateState(long deltaTime) {
         var nextPos = ai.newPosition(doe.getPosition(), deltaTime, doe.getVelocity());
-        // doe.setPosition(nextPos); TODO uncomment
-        this.timeSinceLastShoot += deltaTime;
-        if (this.timeSinceLastShoot >= TIME_BETWEEN_ATTACKS) {
-            this.timeSinceLastShoot = 0;
-            dir = Attack.multiSpiral(doe, PROJECTILE_SPEED, dir, 20, 4);
-            // Attack.snipe(doe, p.getPosition(), PROJECTILE_SPEED);
+        doe.setPosition(nextPos);
+        this.timeSinceLastAttack += deltaTime;
+        if (this.timeSinceLastAttack >= TIME_BETWEEN_ATTACKS) {
+            this.timeSinceLastAttack = 0;
+            performRandomAttack();
         }
+    }
 
+    private void performRandomAttack() {
+        switch (rand.nextInt(2)) {
+            case 0:
+                Attack.radiusWithGap(doe, PROJECTILE_SPEED, 20, 4);
+                break;
+            default:
+                Attack.snipe(doe, p.getPosition(), PROJECTILE_SPEED * 2);
+        }
     }
 
     @Override
     public State getNextStateKey() {
+        if (doe.getHealth() <= doe.getMaxHealth() / 2) {
+            return State.ANGERED;
+        }
         return State.ROAMING;
     }
 

src/main/java/tbooop/model/boss/impl/DukeOfEyes/DukeOfEyes.java

@@ -7,7 +7,7 @@
 public class DukeOfEyes extends AbstractBoss<DoESM.State> {
 
     public DukeOfEyes(Player p) {
-        super(new HealthImpl(20), 0.035, 30);
+        super(new HealthImpl(30), 0.035, 14);
         setStateMachine(new DoESM(this, p));
     }
 }