Team 4 Levels - General Levels Updates

source/core/src/main/com/csse3200/game/areas/ForestGameArea.java

@@ -166,14 +166,17 @@ public class ForestGameArea extends GameArea {
           "sounds/engineers/firing_auto.mp3",
           "sounds/engineers/firing_single.mp3",
           "sounds/projectiles/on_collision.mp3",
-          "sounds/projectiles/explosion.mp3"
+          "sounds/projectiles/explosion.mp3",
+          "sounds/waves/wave-start/Wave_Start_Alarm.ogg",
+          "sounds/waves/wave-end/Wave_Over_01.ogg"
   };
   private static final String backgroundMusic = "sounds/background/Sci-Fi1.ogg";
   private static final String[] forestMusic = {backgroundMusic};
 
   private final TerrainFactory terrainFactory;
 
   private Entity player;
+  private Entity waves;
 
   // Variables to be used with spawn projectile methods. This is the variable
   // that should occupy the direction param.
@@ -192,7 +195,9 @@ public ForestGameArea(TerrainFactory terrainFactory) {
     this.terrainFactory = terrainFactory;
   }
 
-  // Add this method to start the wave spawning timer when the game starts.
+  /**
+   * Add this method to start the wave spawning timer when the game starts.
+   */
   private void startWaveTimer() {
     waveTimer = new Timer();
     waveTimer.scheduleAtFixedRate(new TimerTask() {
@@ -203,14 +208,19 @@ public void run() {
     }, 0, 10000); // 10000 milliseconds = 10 seconds
   }
 
-  // Add this method to stop the wave timer when the game ends or as needed.
+  /**
+   * Add this method to stop the wave timer when the game ends or as needed.
+   */
   private void stopWaveTimer() {
     if (waveTimer != null) {
       waveTimer.cancel();
       waveTimer = null;
     }
   }
 
+  /**
+   * Cases to spawn a wave
+   */
   private void spawnWave() {
     wave++;
     switch (wave) {
@@ -255,13 +265,17 @@ public void create() {
 
     // Set up infrastructure for end game tracking
     player = spawnPlayer();
-    player.getEvents().addListener("spawnWave", this::spawnWave);
+
+    waves = WaveFactory.createWaves();
+    spawnEntity(waves);
+    waves.getEvents().addListener("spawnWave", this::spawnMob);
+
     playMusic();
-    spawnXenoGrunts();
-    startWaveTimer();
+    //spawnXenoGrunts();
+    //startWaveTimer();
     spawnScrap();
-    spawnDeflectXenoGrunt(15, 5);
-    spawnSplittingXenoGrunt(15, 4);
+    //spawnDeflectXenoGrunt(15, 5);
+    //spawnSplittingXenoGrunt(15, 4);
     spawnScrap();
     spawnTNTTower();
     spawnWeaponTower();
@@ -469,17 +483,33 @@ private void spawnProjectile(Vector2 position, short targetLayer, int space, int
     Entity Projectile = ProjectileFactory.createFireBall(targetLayer, new Vector2(direction, position.y + space), speed);
     Projectile.setPosition(position);
     spawnEntity(Projectile);
-  }  
-
-  private void spawnXenoGrunts() {
-    int[] pickedLanes = random.ints(1, 7)
-            .distinct().limit(5).toArray();
-    for (int i = 0; i < NUM_GRUNTS; i++) {
-      GridPoint2 randomPos = new GridPoint2(19, pickedLanes[i]);
-      Entity xenoGrunt = NPCFactory.createXenoGrunt();
-      xenoGrunt.setScale(1.5f, 1.5f);
-      spawnEntityAt(xenoGrunt, randomPos, true, false);
+  }
+
+  /**
+   * Spawn an entity on the map. Is called during a wave. Add cases here for each mob type
+   * @param entity mob to be spawned
+   * @param randomPos position to be spawned at
+   */
+  public void spawnMob(String entity, GridPoint2 randomPos) {
+    Entity mob;
+    switch (entity) {
+      case "Xeno":
+        mob = NPCFactory.createXenoGrunt();
+        break;
+      case "SplittingXeno":
+        mob = NPCFactory.createSplittingXenoGrunt();
+        break;
+      case "DodgingDragon":
+        mob = NPCFactory.createDodgingDragonKnight();
+        break;
+      case "DeflectXeno":
+        mob = NPCFactory.createDeflectXenoGrunt();
+        break;
+      default:
+        mob = NPCFactory.createBaseNPC();
     }
+    mob.setScale(1.5f, 1.5f);
+    spawnEntityAt(mob, randomPos, true, false);
   }
 
   // * TEMPORARY FOR TESTING

source/core/src/main/com/csse3200/game/components/TouchAttackComponent.java

@@ -151,8 +151,17 @@ private void onCollisionEnd(Fixture me, Fixture other) {
     }
   }
 
+  /**
+   * Choose the weapon to use against the given fixture.
+   *
+   * If the fixture has been removed (died) return null, else return the weapon to use.
+   * */
   public Weapon chooseWeapon(Fixture other) {
-    Entity target = ((BodyUserData) other.getBody().getUserData()).entity;
+    BodyUserData data = ((BodyUserData) other.getBody().getUserData());
+    if (data == null) {
+      return null;
+    }
+    Entity target = data.entity;
     Weapon weapon = null;
     if (target.getComponent(CombatStatsComponent.class) != null) {
       weapon = combatStats.getWeapon(target);

source/core/src/main/com/csse3200/game/components/tasks/MobWanderTask.java

@@ -65,29 +65,27 @@ public void start() {
   @Override
   public void update() {
 
-    //Update the position of the mob
+    // Update the position of the mob
     mobPosition = owner.getEntity().getPosition();
 
     // If the mob is at zero health, kill the mob,
     // play the death animation and stop the task
-    // This method is the idea of Ahmad who very kindly helped
-    // with section, massive props to him for his help!
+    // This method is the idea of Ahmad who very kindly helped with section, massive props to him for his help!
     if (!isDead && owner.getEntity().getComponent(CombatStatsComponent.class).isDead()) {
       this.owner.getEntity().getEvents().trigger("dieStart");
       currentTask.stop();
       isDead = true;
+      ServiceLocator.getWaveService().updateEnemyCount();
     }
 
     // Check if the mob has finished death animation
     else if (isDead && owner.getEntity().getComponent(AnimationRenderComponent.class).isFinished()) {
-
-      // Drop scrap at the mobs location for player
-      // to collect.
+      // Drop scrap at the mobs location
       Entity scrap = DropFactory.createScrapDrop();
       scrap.setPosition(mobPosition.x,mobPosition.y);
       ServiceLocator.getEntityService().register(scrap);
 
-      // Delete the mob.
+      // Delete the mob and update count for number of mobs remaining in the wave
       owner.getEntity().setFlagForDelete(true);
 
     }

source/core/src/main/com/csse3200/game/components/tasks/NewMobWanderTask.java

@@ -89,6 +89,7 @@ else if (isDead && owner.getEntity().getComponent(AnimationRenderComponent.class
       Entity scrap = DropFactory.createScrapDrop();
       scrap.setPosition(mobPosition.x,mobPosition.y);
       ServiceLocator.getEntityService().register(scrap);
+      ServiceLocator.getWaveService().updateEnemyCount();
 
       // Delete the mob.
       owner.getEntity().setFlagForDelete(true);

source/core/src/main/com/csse3200/game/components/tasks/waves/LevelWaves.java

@@ -0,0 +1,124 @@
+package com.csse3200.game.components.tasks.waves;
+
+import com.badlogic.gdx.math.GridPoint2;
+import com.csse3200.game.entities.Entity;
+import com.csse3200.game.services.GameTime;
+import com.csse3200.game.services.ServiceLocator;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Random;
+
+public class LevelWaves extends Entity {
+    List<WaveClass> waves = new ArrayList<>();
+    private float spawnDelay;
+    private GameTime gameTime;
+    private long startTime;
+    private Random rand = new Random();
+    private int currentRandom = 0;
+    private int previousRandom = 0;
+    private int mobIndex;
+    private int waveIndex;
+    private int numWaves;
+
+    /**
+     * Constructor for the LevelWaves class
+     * @param spawnDelay time to elapse between each wave
+     */
+    public LevelWaves(int spawnDelay) {
+        this.spawnDelay = spawnDelay;
+        this.gameTime = ServiceLocator.getTimeSource();
+        this.startTime = this.gameTime.getTime();
+        this.mobIndex = 0;
+        this.waveIndex = 0;
+        this.numWaves = 0;
+
+        long currentTime = ServiceLocator.getTimeSource().getTime();
+        // Setting the timestamp for when the next mobs will spawn.
+        // Currently, the delay of mobs spawning after wave start
+        // is hardcoded but will fix in the next push.
+        ServiceLocator.getWaveService().setNextWaveTime(currentTime + 10000);
+    }
+
+    /**
+     * Add a wave to the level and increment the total number of waves
+     * @param wave to be added
+     */
+    public void addWave(WaveClass wave) {
+        this.numWaves++;
+        this.waves.add(wave);
+    }
+
+    /**
+     * Retrieve a wave at an index in the list
+     * @param index wave number to be retireved
+     * @return instance of a wave class
+     */
+    public WaveClass getWave(int index) {
+        return this.waves.get(index);
+    }
+
+    /**
+     * Spawn the wave and all the associated mobs for that wave
+     */
+    public void spawnWave() {
+        if (gameTime.getTime() >= startTime + spawnDelay * 1000) {
+            do {
+                currentRandom = rand.nextInt(1, 7);
+            } while (currentRandom == previousRandom);
+            ServiceLocator.getWaveService().setNextLane(currentRandom);
+            GridPoint2 randomPos = new GridPoint2(19, currentRandom);
+            this.getEvents().trigger("spawnWave", waves.get(waveIndex)
+                    .getMobs().get(mobIndex), randomPos);
+            startTime = gameTime.getTime();
+            mobIndex++;
+            previousRandom = currentRandom;
+        } else if (mobIndex == waves.get(waveIndex).getSize()) {
+            this.getEvents().trigger("waveFinishedSpawning");
+            mobIndex = 0;
+        }
+    }
+
+    /**
+     * Set the wave index
+     * @param index
+     */
+    public void setWaveIndex(int index) {
+        this.waveIndex = index;
+    }
+
+    /**
+     * Get the total number of waves in this level
+     * @return number of waves in the level
+     */
+    public int getNumWaves() {
+        return this.numWaves;
+    }
+
+    public float getSpawnDelay() {
+        return this.spawnDelay;
+    }
+
+    public long getStartTime() {
+        return this.startTime;
+    }
+
+    /**
+     * Get the current mob index
+     * @return mob index
+     */
+    public int getMobIndex() {
+        return this.mobIndex;
+    }
+
+    /**
+     * Get the current wave index
+     * @return wave index
+     */
+    public int getWaveIndex() {
+        return this.waveIndex;
+    }
+
+}
+

source/core/src/main/com/csse3200/game/components/tasks/waves/WaveClass.java

@@ -0,0 +1,60 @@
+package com.csse3200.game.components.tasks.waves;
+
+import com.badlogic.gdx.math.GridPoint2;
+import com.csse3200.game.entities.Entity;
+import com.csse3200.game.services.GameTime;
+import com.csse3200.game.services.ServiceLocator;
+
+import java.util.*;
+
+
+public class WaveClass {
+  private HashMap<String, Integer> entities;
+  private GameTime gameTime;
+  private long startTime;
+  private List<String> wave;
+  private Random rand = new Random();
+  private int mobIndex;
+
+  /**
+   * Constructor for the WaveClass
+   * @param entities: HashMap of entities and the quantity of them to be spawned in this wave
+   */
+  public WaveClass(HashMap<String, Integer> entities) {
+    this.entities = entities;
+    this.wave = entitiesToWave();
+    this.mobIndex = 0;
+  }
+
+  /**
+   * Get the entities that are part of this wave and randomise the order they are spawned
+   * @return mobs for the wave
+   */
+  private List<String> entitiesToWave() {
+    List<String> enemies = new ArrayList<>();
+    for (Map.Entry<String, Integer> set : entities.entrySet()) {
+      for (int i = 0; i < set.getValue(); i++) {
+        enemies.add(set.getKey());
+      }
+    }
+    Collections.shuffle(enemies);
+    return enemies;
+  }
+
+  /**
+   * Gets the current number of entities spawned in the wave
+   * @return size of the current wave (number of entities)
+   */
+  public int getSize() {
+    return this.wave.size();
+  }
+
+  /**
+   * Gets the current entities that have spawned in the wave
+   * @return list of mobs in the current wave
+   */
+  public List<String> getMobs() {
+    return this.wave;
+  }
+
+}