是否可以从另一个类内部调用一个类（没有扩展）？

Question

I'm working on different components for a basic game.

Right now my structure is I have a file of race classes that get exported to another file where I have a class that extends off of the Human race and makes a Player. Giving the Player both the attributes of a Human and a Player.

However, this means that if I wanted to make a Player that wasn't Human I would have to make a new class of Player that extends off of a different race. That seems like poor practice and I want to find a way to refactor it all to make it flow better.

---

Here is my Human class:

export class Human {
constructor() {
    this.type = 'Human';
    this.health = 10;
    this.baseAttack = 2;
    this.baseDefense = 1;
}

And here is my player Player class:

export class Player extends Human {
constructor(name, level){
    super();
    var inventory = {};
    this.name = name;
    this.level = level;
    this.inventory = inventory;
    this.currentCapacity = 0;
    this.maxCapacity = 50;
}

There's other functions in the Player class related to the inventory however those don't seem relevant to my problem.

---

My intended results are that I have a group of races that when I make a Player or a Character I can select from that group and then that Player or Character will inherit attributes that are static to that race (Eg health, baseAttack, and baseDefense).

Answer 1

As the smart kids say, prefer composition to inheritance. You could do something like this without deviating too far from your current approach:

class Orc {
  constructor() {
    this.mortal = true
  }
}

class Player {
constructor(race, name, level){
    var inventory = {};
    this.race = race;
    this.name = name;
    this.level = level;
    this.inventory = inventory;
    this.currentCapacity = 0;
    this.maxCapacity = 50;
    }
}

const orc = new Player(new Orc(), 'Baz', 1 )
console.log(orc.race)

There are a lot of other ways to skin this cat, including having Human descend from Player. In fact, that would be the usual way to model those entities using classical inheritance (Player is general case and Humans and Orcs are more specific).

class PlayerClassic {
constructor(name, level){
    var inventory = {};
    this.name = name;
    this.level = level;
    this.inventory = inventory;
    this.currentCapacity = 0;
    this.maxCapacity = 50;
    }
}


class Human extends PlayerClassic {
  constructor(name, level) {
    super(name, level)
    this.mortal = true
  }
}

const human = new Human('Johnny', 2)
console.log(human)

I find inheritance hierarchies seldom buy much advantage. And in both of the above cases you have to use typeof to determine what sort of creature you're dealing with.

If it was my code, I'd probably skip the classes entirely. I might do something like the following to build up a data structure that represented a constructed player:

const raceTemplates = {
  human: {mortal:true}, 
  elf: { mortal:true}}

const playerMaker = template => (race, name, level)=> {
  return {
    name,
    level,
    race,
    inventory: {},
    currentCapacity:0,
    maxCapacity:50,
    ...template[race]
  }
}  

const player = playerMaker(raceTemplates)('elf', 'sammy', 2)
console.log(player) 

Here's a link to a repl.it for anyone who is interested:

https://repl.it/@rmoskal/RealisticWholeParameter

Answer 2

To answer your question in the title:

Can a class contain another class?

Yes, it can.

Otherwise, for your scenarios, I see race as an attribute (similarly player can have qualities too, that may require setting). Therefore I would suggest injecting values through a factory method. Just a simple highlight provided, but you can work a more structured factory method on your own.

function raceFactory(raceName) {
    if (raceName == 'raceA') {
        let res = new Human();
        res.health = 30;
        return res;
    }
}

and in the main app:

let humanRaceA = new factory.RaceFactory('raceA');

Answer 3

Here's another solution

function Player(name, level){
    var inventory = {};
    this.name = name;
    this.level = level;
    this.inventory = inventory;
    this.currentCapacity = 0;
    this.maxCapacity = 50;
}

module.exports.Player = function(race, name, level){
  var newPlayer = Object.create(Object.assign(race.prototype, Player.prototype))//override  
  race.call(newPlayer);
  Player.call(newPlayer, name, level);
  return newPlayer;
}

And in client code you can do something like:

var { Player } = require(/* your module */)
var newPlayer = Player(Human, 'Bob', 23);
console.log(newPlayer);
/*
{ type: 'Human',
  health: 10,
  baseAttack: 2,
  baseDefense: 1,
  name: 'Bob',
  level: 23,
  inventory: {},
  currentCapacity: 0,
  maxCapacity: 50 }
*/