Here's a revision of your code structure. In order to ensure that the minimum and maximum health values for a certain type of enemy are not tied to each instance, I have organized them under an independent mapping called enemyConfigs. The base constructor of the Enemy class now handles the randomization of stats for each enemy upon instantiation. An interesting aspect is that the configurations for each specific enemy class are only partial; any undefined values are inherited from the default enemy configuration.
(Sadly, there seems to be no TypeScript-friendly way to override statics in a hierarchical inheritance system; otherwise, I would have chosen that approach instead of creating individual mappings per enemy type.)
Moreover, the process of spawning enemies based on a list of classes functions seamlessly . . .
type MinMax = [number, number];
interface EnemyConfig {
gold: MinMax;
health: MinMax;
attackSpeed: MinMax;
damage: MinMax;
}
const baseEnemyConfig: EnemyConfig = {
gold: [0, 0],
health: [1, 1],
attackSpeed: [0, 0],
damage: [0, 0],
};
function initializeNumber([min, max]: MinMax): number {
return min + Math.floor(Math.random() * (max - min));
}
class Enemy {
public gold: number;
public health: number;
public maxHealth: number;
public attackSpeed: number;
public damage: number;
constructor(config?: Partial<EnemyConfig>) {
const fullConfig = { ...baseEnemyConfig, ...config };
this.gold = initializeNumber(fullConfig.gold);
this.health = this.maxHealth = initializeNumber(fullConfig.health);
this.attackSpeed = initializeNumber(fullConfig.attackSpeed);
this.damage = initializeNumber(fullConfig.damage);
}
public makeNoise(): string {
return "...";
}
}
const enemyConfigs: Record<string, Partial<EnemyConfig>> = {
Goblin: {
gold: [1, 3],
health: [3, 6],
// ... etc
},
Titan: {
gold: [200, 300],
health: [100, 300],
},
};
class Goblin extends Enemy {
constructor() {
super(enemyConfigs.Goblin);
}
public makeNoise() {
return "Gob!";
}
}
class Titan extends Enemy {
constructor() {
super(enemyConfigs.Titan);
}
public makeNoise() {
return "Titan toot!";
}
}
const enemyClasses = [Goblin, Titan];
function spawnEnemies(n: number): Array<Enemy> {
const enemies = [];
for (let i = 0; i < n; i++) {
const cls =
enemyClasses[Math.floor(Math.random() * enemyClasses.length)];
const enemy = new cls();
enemies.push(enemy);
}
return enemies;
}
const enemies = spawnEnemies(10);
enemies.forEach((enemy) => {
console.log(enemy.makeNoise(), enemy.health, enemy.gold);
});
The output will look similar to:
[LOG]: "Gob!", 3, 2
[LOG]: "Titan toot!", 208, 246
[LOG]: "Gob!", 5, 1
[LOG]: "Titan toot!", 206, 254
[LOG]: "Gob!", 3, 1
[LOG]: "Titan toot!", 210, 262
[LOG]: "Titan toot!", 168, 229
[LOG]: "Gob!", 5, 2
[LOG]: "Gob!", 5, 2
[LOG]: "Titan toot!", 207, 236
You can experiment with this code on the TypeScript playground.