Come implementare l'ereditarietà negli oggetti Screeps?

Question

Ho giocato con Screeps per un po 'e ieri sera ho deciso di elaborare alcuni dei miei comportamenti in una gerarchia di classi derivando due classi, Miner e Transporter da una classe principale Creep. Tuttavia, ogni volta che faccio

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

ottengo la stessa identica lista delle funzioni, come quando faccio

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

Qualcuno potrebbe dirmi se sto facendo qualcosa di sbagliato o se sto effettivamente in esecuzione in un limitazione dell'ambiente in cui viene eseguito il mio codice? Questo è il mio codice:

//////////////////////////// 
// 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

Con questa formazione ...

Miner.prototype = Creep.prototype; 

... dici JS che entrambi i prototipi sono in realtà lo stesso oggetto . Quindi qualsiasi aggiornamento per Miner.prototype interesserà anche Creep.prototype.

Un possibile approccio utilizza Object.create quando si stabilisce il collegamento tra i prototipi. Ecco un esempio semplificato:

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, ... }