enemy projectile

assets/Scripts/Game/Collision/PlayerCollisionSystem.ts

@@ -7,6 +7,7 @@ import { Gold } from "../Items/Gold/Gold";
 import { HealthPotion } from "../Items/HealthPotion/HealthPotion";
 import { ItemManager } from "../Items/ItemManager";
 import { XP } from "../Items/XP/XP";
+import { Projectile } from "../Projectile/Projectile";
 import { Enemy } from "../Unit/Enemy/Enemy";
 import { Player } from "../Unit/Player/Player";
 
@@ -27,6 +28,7 @@ export class PlayerCollisionSystem {
         this.collisionTimer = new GameTimer(collisionDelay);
 
         this.groupToResolver.set(GroupType.ENEMY, this.resolveEnemyContact.bind(this));
+        this.groupToResolver.set(GroupType.ENEMY_PROJECTILE, this.resolveEnemyProjectileContact.bind(this));
         this.groupToResolver.set(GroupType.XP, this.resolveXpContact.bind(this));
         this.groupToResolver.set(GroupType.GOLD, this.resolveGoldContact.bind(this));
         this.groupToResolver.set(GroupType.HEALTH_POTION, this.resolveHealthPotionContact.bind(this));
@@ -75,6 +77,15 @@ export class PlayerCollisionSystem {
         this.player.Health.damage(damage);
     }
 
+    private resolveEnemyProjectileContact(enemyCollider: Collider2D): void {
+        const projectile = enemyCollider.node.getComponent(Projectile);
+        const damage: number = projectile.Damage;
+        projectile.pierce();
+        console.log("Collided with enemy projectile: Damage: " + damage);
+
+        this.player.Health.damage(damage);
+    }
+
     private resolveXpContact(xpCollider: Collider2D): void {
         console.log("Collided with XP");
         this.itemManager.pickupXP(xpCollider.node.getComponent(XP));

assets/Scripts/Game/Data/GameSettings.ts

@@ -1,3 +1,5 @@
+import { EnemyProjectileLauncher } from "../Unit/Enemy/ProjectileLauncher.cs/EnemyProjectileLauncher";
+
 export class GameSettings {
     public player: PlayerSettings = new PlayerSettings();
     public upgrades: UpgradeSettings = new UpgradeSettings();
@@ -34,6 +36,14 @@ export class HaloLauncherSettings {
     public launcher = new ProjectileLauncherSettings();
 }
 
+export class EnemyLauncherSettings {
+    public enemyIds: string[] = [];
+    public projectileLifetime = 0;
+    public projectileSpeed = 0;
+    public projectileDamage = 0;
+    public cooldown = 0;
+}
+
 export class ProjectileLauncherSettings {
     public projectileLifetime = 0;
     public projectileSpeed = 0;
@@ -66,6 +76,7 @@ export class MetaUpgradeSettings {
 }
 
 export class EnemyManagerSettings {
+    public projectileLauncher1 = new EnemyLauncherSettings();
     public enemies: EnemySettings[] = [new EnemySettings()];
     public periodicFollowMovers: PeriodicFollowMoverSettings[] = [new PeriodicFollowMoverSettings()];
     public individualEnemySpawners: IndividualEnemySpawnerSettings[] = [new IndividualEnemySpawnerSettings()];

assets/Scripts/Game/Game.ts

@@ -26,6 +26,7 @@ import { ProjectileData } from "./Unit/Player/ProjectileLauncher/ProjectileData"
 import { WaveProjectileLauncher } from "./Unit/Player/ProjectileLauncher/WaveProjectileLauncher";
 import { Upgrader } from "./Upgrades/Upgrader";
 import { MetaUpgradeType } from "./Upgrades/UpgradeType";
+import { EnemyProjectileLauncher } from "./Unit/Enemy/ProjectileLauncher.cs/EnemyProjectileLauncher";
 
 const { ccclass, property } = _decorator;
 
@@ -36,6 +37,7 @@ export class Game extends Component {
     @property(ProjectileLauncher) private haloProjectileLauncherComponent: ProjectileLauncher;
     @property(ProjectileLauncher) private horizontalProjectileLauncherComponent: ProjectileLauncher;
     @property(ProjectileLauncher) private diagonalProjectileLauncherComponent: ProjectileLauncher;
+    @property(ProjectileLauncher) private enemyProjectileLauncherComponent: ProjectileLauncher;
     @property(EnemyManager) private enemyManager: EnemyManager;
     @property(ItemManager) private itemManager: ItemManager;
     @property(Camera) private camera: Camera;
@@ -49,6 +51,8 @@ export class Game extends Component {
     private horizontalProjectileLauncher: WaveProjectileLauncher;
     private diagonalProjectileLauncher: WaveProjectileLauncher;
 
+    private enemyProjectileLauncher: EnemyProjectileLauncher;
+
     private gamePauser: Pauser = new Pauser();
 
     private static instance: Game;
@@ -112,6 +116,13 @@ export class Game extends Component {
             projectileData
         );
 
+        this.enemyProjectileLauncher = new EnemyProjectileLauncher(
+            this.enemyProjectileLauncherComponent,
+            this.player.node,
+            this.enemyManager,
+            settings.enemyManager.projectileLauncher1
+        );
+
         new PlayerProjectileCollisionSystem([this.haloProjectileLauncher, this.horizontalProjectileLauncher, this.diagonalProjectileLauncher]);
 
         const upgrader = new Upgrader(
@@ -150,6 +161,7 @@ export class Game extends Component {
         this.haloProjectileLauncher.gameTick(deltaTime);
         this.horizontalProjectileLauncher.gameTick(deltaTime);
         this.diagonalProjectileLauncher.gameTick(deltaTime);
+        this.enemyProjectileLauncher.gameTick(deltaTime);
         this.background.gameTick();
 
         this.timeAlive += deltaTime;

assets/Scripts/Game/Unit/Enemy/ProjectileLauncher.cs/EnemyProjectileLauncher.ts

@@ -1,30 +1,54 @@
 import { Vec3, Node, Vec2 } from "cc";
 import { GameTimer } from "../../../../Services/GameTimer";
+import { EnemyLauncherSettings } from "../../../Data/GameSettings";
 import { ProjectileLauncher } from "../../Player/ProjectileLauncher/ProjectileLauncher";
 import { Enemy } from "../Enemy";
 import { EnemyManager } from "../EnemyManager";
 
 export class EnemyProjectileLauncher {
-    private enemies: Enemy[] = [];
-    private shootTimer: GameTimer = new GameTimer(3);
+    private enemyToTimer = new Map<Enemy, GameTimer>();
+    private cooldown: number;
+    private enemyIds: string[];
 
-    public constructor(private playerNode: Node, private projectileLauncher: ProjectileLauncher, enemyManager: EnemyManager) {
+    public constructor(
+        private projectileLauncher: ProjectileLauncher,
+        private playerNode: Node,
+        enemyManager: EnemyManager,
+        settings: EnemyLauncherSettings
+    ) {
         enemyManager.EnemyAddedEvent.on(this.tryAddEnemy, this);
         enemyManager.EnemyRemovedEvent.on(this.tryRemoveEnemy, this);
+
+        this.cooldown = settings.cooldown;
+        this.enemyIds = settings.enemyIds;
+        projectileLauncher.init(settings.projectileLifetime, settings.projectileSpeed, settings.projectileDamage, 1);
     }
 
     private tryAddEnemy(enemy: Enemy): void {
-        if (enemy.Id == "BasicEnemy") {
-            this.enemies.push();
+        if (this.enemyIds.includes(enemy.Id)) {
+            this.enemyToTimer.set(enemy, new GameTimer(this.cooldown));
         }
     }
 
     private tryRemoveEnemy(enemy: Enemy): void {
-        if (enemy.Id == "BasicEnemy") {
-            const index = this.enemies.indexOf(enemy);
-            this.enemies.splice(index, 1);
-        }
+        if (!this.enemyToTimer.has(enemy)) return;
+
+        this.enemyToTimer.delete(enemy);
     }
 
-    public gameTick(deltaTime: number): void {}
+    public gameTick(deltaTime: number): void {
+        this.projectileLauncher.gameTick(deltaTime);
+
+        for (const enemyAndTimerPair of this.enemyToTimer) {
+            const enemyWorldPosition: Vec3 = enemyAndTimerPair[0].node.worldPosition;
+            const shootTimer: GameTimer = enemyAndTimerPair[1];
+
+            shootTimer.gameTick(deltaTime);
+            if (shootTimer.tryFinishPeriod()) {
+                let direction: Vec3 = new Vec3();
+                direction = Vec3.subtract(direction, this.playerNode.worldPosition, enemyWorldPosition);
+                this.projectileLauncher.fireProjectiles(enemyWorldPosition, [new Vec2(direction.x, direction.y)]);
+            }
+        }
+    }
 }

assets/Scripts/Game/Unit/Player/ProjectileLauncher/ProjectileLauncher.ts

@@ -51,6 +51,7 @@ export class ProjectileLauncher extends Component implements IProjectileCollisio
     }
 
     private fireProjectile(startPosition: Vec3, direction: Vec2): void {
+        direction = direction.normalize();
         const projectile: Projectile = this.projectilePool.borrow();
         projectile.init(this.projectileDamage, this.projectilePierces, getDegreeAngleFromDirection(direction.x, direction.y));
         projectile.node.setWorldPosition(startPosition);