Wie wird die Vererbung in Screeps-Objekten implementiert?

Question

Ich habe schon eine Weile mit Screeps herumgespielt und letzte Nacht habe ich beschlossen, einige meiner Verhaltensweisen in eine Klassenhierarchie einzuordnen, indem ich zwei Klassen, Miner und Transporter, von einer Creep Hauptklasse herleite. Jedes Mal, wenn ich

console.log(_.functions(minerInstance)); 

ich genau die gleiche Funktionsliste erhalten, wie wenn ich

console.log(_.functions(transporterInstance)); 

Könnte mir jemand sagen, ob ich etwas falsch bin, oder wenn ich renne tatsächlich in eine Einschränkung der Umgebung, in der mein Code läuft? Dies ist mein Code:

//////////////////////////// 
// Creep.js 
var Creep = function(creep, room) { 
    this.creep = creep; 
    this.room = room; 
    this.name = creep.name; 
    this.id = creep.id; 
}; 

module.exports = Creep; 

Creep.prototype = { 
    tick: function() { 
     console.log("Base class implementation of tick(), should never happen."); 
    }, 

    getRole: function() { 
     return this.creep.memory.role; 
    } 
}; 

//////////////////////////// 
// Miner.js 
var Creep = require("Creep"); 

var Miner = function(creep, room) { 
    this.base = Creep; 
    this.base(creep, room); 
    //Creep.call(this, creep, room); 
}; 

module.exports = Miner; 

Miner.prototype = Creep.prototype; 

Miner.prototype.tick = function() { 
    var creep = this.creep; 

    if (creep.memory.activity === undefined || creep.memory.activity === "") { 
     var target = creep.pos.findNearest(Game.SOURCES_ACTIVE); 
     this.mine(creep, target); 
    } 

    var act = creep.memory.activity; 
    if (act == "mine") { 
     var target = this.getTarget(creep); 
     if (target !== undefined) { 
      if (creep.energy < creep.energyCapacity) { 
       creep.moveTo(target); 
       creep.harvest(target); 
      } else { 
       console.log("Write dump to truck code"); 
       /*var trucks = find.transporterInRange(creep, 1); 
       if (trucks.length) { 
        creep.moveTo(trucks[0]); 
        var amount = trucks[0].energyCapacity - trucks[0].energy; 
        creep.transferEnergy(trucks[0], amount); 
       }*/ 
      } 
     } 
    } 
}; 

Miner.prototype.mine = function(creep, target) { 
    creep.memory.target = target.id; 
    creep.memory.activity = "mine";   
}; 

Miner.prototype.getTarget = function(creep) { 
    return Game.getObjectById(creep.memory.target); 
}; 

//////////////////////////// 
// Transporter.js 
var Creep = require("Creep"); 

var Transporter = function(creep, room) { 
    Creep.call(this, creep, room); 
}; 

module.exports = Transporter; 

Transporter.prototype = Creep.prototype; 

Transporter.prototype.tick = function() { 
    var creep = this.creep; 
    if (creep.energy < creep.energyCapacity) { 
     var miner = this.room.findByRole(creep, "miner"); 
     console.log(miner); 
     if (miner !== null) { 
      //console.log(miner[0].name); 
      //creep.moveTo(miner); 

     } else 
      console.log("no miners found"); 
    } else { 
     console.log("moving to drop"); 
     //var drop = find.nearestEnergyDropOff(creep); 
     //creep.moveTo(drop); 
     //creep.transferEnergy(drop); 
    } 
}; 

Answer 1

Mit dieser Linie ...

Miner.prototype = Creep.prototype; 

... Sie JS sagen, dass beide Prototypen tatsächlich das gleiche Objekt sind. Daher wirkt sich jedes Update für Miner.prototype auch auf Creep.prototype aus.

Ein möglicher Ansatz ist die Verwendung Object.create beim Herstellen der Verbindung zwischen Prototypen. Hier ein vereinfachtes Beispiel:

function Foo(a) { 
    this.a = a; 
} 

Foo.prototype.tick = function() { console.log('Foo ticks'); }; 
Foo.prototype.tock = function() { console.log('Foo tocks'); }; 

function Bar(a, b) { 
    this.base = Foo; 
    this.base(a); 
    this.b = b; 
} 

Bar.prototype = Object.create(Foo.prototype); 
// as you inherit all the properties, you'll have to reassign a constructor 
Bar.prototype.constructor = Bar; 
Bar.prototype.tick = function() { console.log('Bar ticks'); }; 

var f = new Foo(1); 
f.tick(); // Foo ticks 
f.tock(); // Foo tocks 
console.log(f); // Foo { a=1, ... } 

var b = new Bar(1, 2); 
b.tick(); // Bar ticks 
b.tock(); // Foo tocks 
console.log(b); // Bar { a=1, b=2, ... }