Completed Javascript-II however, prototype file has a couple checks not passed by the test. This is because it says that the children objects are not inheriting the GameObjects destroy funcion. This is probably caused because since the linter would not let me just have return string as a class method, i had to refer to at least one this. If you look at the code you will see what I mean. The this file was causing a lot of headaches in terms of linting and i couldnt figure it out. I had to comment the whole page out just to test the class and prototype files.

odax · odax · commit d44ff3693a25 · 2018-03-23T10:49:29.000-04:00
diff --git a/src/class.js b/src/class.js
@@ -13,22 +13,22 @@ class User {
     this.email = options.email;
     this.password = options.password;
   }
-  comparePasswords (potentialPassword) {
+  comparePasswords(potentialPassword) {
     if (potentialPassword === this.password) {
       return true;
     }
     return false;
   }
 }
 
-const account1 = new User ({
-  email: `tacoman@gmail.com`,
-  password: `llamallama1122`
+const account1 = new User({
+  email: 'tacoman@gmail.com',
+  password: 'llamallama1122',
 });
 
-//to test I would probably do:
-//console.log(account1.comparePasswords(potentialPasswordInput));
-
+// to test I would probably do:
+// console.log(account1.comparePasswords(potentialPasswordInput));
+//
 // Part 2
 // Create a class called `Animal` and a class called `Cat` using ES6 classes.
 // `Cat` should extend the `Animal` class.
@@ -45,16 +45,18 @@ class Animal {
   constructor(options) {
     this.age = options.age;
   }
-  growOlder () {
+  growOlder() {
     return ++this.age;
+  }
 }
 
 class Cat extends Animal {
   constructor(options) {
+    super(options);
     this.name = options.name;
   }
-  meow () {
-    return `${this.name} meowed!`
+  meow() {
+    return `${this.name} meowed!`;
   }
 }
 /* eslint-disable no-undef */
diff --git a/src/prototype.js b/src/prototype.js
@@ -13,11 +13,12 @@ class GameObject {
   constructor(gameObjectParameters) {
     this.createdAt = gameObjectParameters.createdAt;
     this.dimensions = gameObjectParameters.dimensions;
+    this.phrase = 'Game object was removed from the game';
   }
   destroy() {
-    return `Game object was removed from the game`
-  }
-}
+    return this.phrase;
+  } // reason why i created this.phrase to be used in destroy is that the linter wont let me run the test without having a this keyword inside of the method here..
+}   // I've tried return 'Game object was removed from the game'; but it doesn't accept that.. this is why the children are not properly inheriting it.
 
 /*
   NPC
@@ -34,7 +35,7 @@ class NPC extends GameObject {
     this.name = NPCParameters.name;
   }
   takeDamage() {
-    return `${this.name} took damage.`
+    return `${this.name} took damage.`;
   }
 }
 
@@ -48,15 +49,15 @@ class NPC extends GameObject {
     // should inherit takeDamage() from NPC
 */
 
-class Humanoid extends GameObject {
+class Humanoid extends NPC {
   constructor(humanoidParameters) {
     super(humanoidParameters);
     this.faction = humanoidParameters.faction;
     this.weapons = humanoidParameters.weapons;
     this.language = humanoidParameters.language;
   }
   greet() {
-    return `${this.name} offers a greeting in ${this.language}.`
+    return `${this.name} offers a greeting in ${this.language}.`;
   }
 }
 
diff --git a/src/this.js b/src/this.js
@@ -5,29 +5,30 @@
 /* part 1 */
 
 class User {
-  constructor(un,pw) {
+  constructor(user, pass) {
     // set a username and password property on the user object that is created
-    this.username = un;
-    this.password = pw;
+    this.username = user;
+    this.password = pass;
     this.checkPassword = function(inputPass) {
       if (inputPass === this.password) {
         return true;
       }
       return false;
     }
   }
+}
   // create a method on the User class called `checkPassword`
   // this method should take in a string and compare it to the object's password property
   // return `true` if they match, otherwise return `false`
-}
+
 
 const me = new User('LambdaSchool', 'correcthorsebatterystaple');
 
 const result = me.checkPassword('correcthorsebatterystaple'); // should return `true`
 
 // node this.js says that me.checkPassword is not a function so it throws an error.. hmmmmm
 
-console.log(result);
+return result();
 
 /* part 2 */
 

Original file line number	Diff line number	Diff line change
`@@ -13,22 +13,22 @@ class User {`
`13`	`13`	`this.email = options.email;`
`14`	`14`	`this.password = options.password;`
`15`	`15`	`}`
`16`		`- comparePasswords (potentialPassword) {`
	`16`	`+ comparePasswords(potentialPassword) {`
`17`	`17`	`if (potentialPassword === this.password) {`
`18`	`18`	`return true;`
`19`	`19`	`}`
`20`	`20`	`return false;`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
`24`		`-const account1 = new User ({`
`25`		- email: `[email protected]`,
`26`		- password: `llamallama1122`
	`24`	`+const account1 = new User({`
	`25`	`+ email: '[email protected]',`
	`26`	`+ password: 'llamallama1122',`
`27`	`27`	`});`
`28`	`28`
`29`		`-//to test I would probably do:`
`30`		`-//console.log(account1.comparePasswords(potentialPasswordInput));`
`31`		`-`
	`29`	`+// to test I would probably do:`
	`30`	`+// console.log(account1.comparePasswords(potentialPasswordInput));`
	`31`	`+//`
`32`	`32`	`// Part 2`
`33`	`33`	// Create a class called `Animal` and a class called `Cat` using ES6 classes.
`34`	`34`	// `Cat` should extend the `Animal` class.
`@@ -45,16 +45,18 @@ class Animal {`
`45`	`45`	`constructor(options) {`
`46`	`46`	`this.age = options.age;`
`47`	`47`	`}`
`48`		`- growOlder () {`
	`48`	`+ growOlder() {`
`49`	`49`	`return ++this.age;`
	`50`	`+ }`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`class Cat extends Animal {`
`53`	`54`	`constructor(options) {`
	`55`	`+ super(options);`
`54`	`56`	`this.name = options.name;`
`55`	`57`	`}`
`56`		`- meow () {`
`57`		- return `${this.name} meowed!`
	`58`	`+ meow() {`
	`59`	+ return `${this.name} meowed!`;
`58`	`60`	`}`
`59`	`61`	`}`
`60`	`62`	`/* eslint-disable no-undef */`
Original file line number	Diff line number	Diff line change
`@@ -13,11 +13,12 @@ class GameObject {`
`13`	`13`	`constructor(gameObjectParameters) {`
`14`	`14`	`this.createdAt = gameObjectParameters.createdAt;`
`15`	`15`	`this.dimensions = gameObjectParameters.dimensions;`
	`16`	`+ this.phrase = 'Game object was removed from the game';`
`16`	`17`	`}`
`17`	`18`	`destroy() {`
`18`		- return `Game object was removed from the game`
`19`		`- }`
`20`		`-}`
	`19`	`+ return this.phrase;`
	`20`	`+ } // reason why i created this.phrase to be used in destroy is that the linter wont let me run the test without having a this keyword inside of the method here..`
	`21`	`+} // I've tried return 'Game object was removed from the game'; but it doesn't accept that.. this is why the children are not properly inheriting it.`
`21`	`22`
`22`	`23`	`/*`
`23`	`24`	`NPC`
`@@ -34,7 +35,7 @@ class NPC extends GameObject {`
`34`	`35`	`this.name = NPCParameters.name;`
`35`	`36`	`}`
`36`	`37`	`takeDamage() {`
`37`		- return `${this.name} took damage.`
	`38`	+ return `${this.name} took damage.`;
`38`	`39`	`}`
`39`	`40`	`}`
`40`	`41`
`@@ -48,15 +49,15 @@ class NPC extends GameObject {`
`48`	`49`	`// should inherit takeDamage() from NPC`
`49`	`50`	`*/`
`50`	`51`
`51`		`-class Humanoid extends GameObject {`
	`52`	`+class Humanoid extends NPC {`
`52`	`53`	`constructor(humanoidParameters) {`
`53`	`54`	`super(humanoidParameters);`
`54`	`55`	`this.faction = humanoidParameters.faction;`
`55`	`56`	`this.weapons = humanoidParameters.weapons;`
`56`	`57`	`this.language = humanoidParameters.language;`
`57`	`58`	`}`
`58`	`59`	`greet() {`
`59`		- return `${this.name} offers a greeting in ${this.language}.`
	`60`	+ return `${this.name} offers a greeting in ${this.language}.`;
`60`	`61`	`}`
`61`	`62`	`}`
`62`	`63`