Repository files navigation

We have learned Object-oriented programming and howclass and inheritance work in JavaScript. Now let's work with our Viking friends, applying the concepts we have just learned.

• Fork this repo.
• Clone this repo.

• Upon completion, run the following commands:

git add.git commit -m"Solved lab"git push origin master

• Create a Pull Request so that your TAs can check your work.

This LAB is equipped with unit tests to provide automated feedback on your lab progress. In case you want to check the tests, they are in thetests/viking.spec.js file.

To run the tests and your JavaScript code, open theSpecRunner.html file using theLive Server VSCode extension.

To see the outputs of theconsole.log in your JavaScript code, open theConsole in the Developer Tools.

You will work on thesrc/viking.js file.

Your task is to write the correct code in thesrc/viking.js file to make the tests pass. In this file, you will find the following starter code:

// SoldierclassSoldier{}// VikingclassViking{}// SaxonclassSaxon{}// WarclassWar{}

Let's have a look at the first test case together to get you started.

The first test case says that "Soldier class >> should receive 2 arguments (health & strength)", so we have to write the correct code to pass this test. Let's make theSoldier class receive two arguments:

// SoldierclassSoldier{constructor(health,strength){}}// VikingclassViking{}// SaxonclassSaxon{}// WarclassWar{}

Modify theSoldier class and add 2 methods to it:attack(), andreceiveDamage().

• should receive2 arguments (health & strength)
• should receive thehealth property as its1st argument
• should receive thestrength property as its2nd argument

• should be a function
• should receive0 arguments
• should returnthestrength property of theSoldier

• should be a function
• should receive1 argument (the damage)
• should remove the received damage from thehealth property
• shouldn't return anything

AViking is aSoldier with an additional property, theirname. They also have a differentreceiveDamage() method and a new method,battleCry().

Modify theViking class, have it inherit fromSoldier, re-implement thereceiveDamage() method forViking, and add a newbattleCry() method.

• Viking shouldextendSoldier

• should receive3 arguments (name, health & strength)
• should receive thename property as its1st argument
• should receive thehealth property as its2nd argument
• should receive thestrength property as its3rd argument

(This method should beinherited fromSoldier, no need to re-implement it.)

• should be a function
• should receive0 arguments
• should returnthestrength property of theViking

This method needs to bere-implemented forViking because theViking version needs to have different return values.

• should be a function
• should receive1 argument (the damage)
• should remove the received damage from thehealth property
• if theViking is still alive, it should return"NAME has received DAMAGE points of damage"
• if theViking dies, it should return"NAME has died in act of combat"

Learn more about battle cries.

• should be a function
• should receive0 arguments
• should return"Odin Owns You All!"

ASaxon is a weaker kind ofSoldier. Unlike aViking, aSaxon has no name. TheirreceiveDamage() method will also be different than the originalSoldier version.

Modify theSaxon, constructor function, have it inherit fromSoldier and re-implement thereceiveDamage() method forSaxon.

• Saxon should extendSoldier

• You don't have to include a constructor method since this class will inherit perfectly from the parents class, both the health and the strength (itextends Soldier class 😉 )

This method should beinherited fromSoldier, no need to re-implement it.

• should be a function
• should receive0 arguments
• should returnthestrength property of theSaxon

This method needs to bere-implemented forSaxon because theSaxon version needs to have different return values.

• should be a function
• should receive1 argument (the damage)
• should remove the received damage from thehealth property
• if the Saxon is still alive, it should return"A Saxon has received DAMAGE points of damage"
• if the Saxon dies, it should return"A Saxon has died in combat"

Now we get to the good stuff: WAR! OurWar class will allow us to have aViking army and aSaxon army that battle each other.

Modify theWar class and add 5 methods to itsclass:

• addViking()
• addSaxon()
• vikingAttack()
• saxonAttack()
• showStatus()

When we first create aWar, the armies should be empty. We will add soldiers to the armies later.

• should receive0 arguments
• should assign an empty array to thevikingArmy property
• should assign an empty array to thesaxonArmy property

Adds 1Viking to thevikingArmy. If you want a 10Viking army, you need to call this 10 times.

• should be a function
• should receive1 argument (aViking object)
• should add the receivedViking to the army
• shouldn't return anything

TheSaxon version ofaddViking().

• should be a function
• should receive1 argument (aSaxon object)
• should add the receivedSaxon to the army
• shouldn't return anything

ASaxon (chosen at random) has theirreceiveDamage() method called with the damage equal to thestrength of aViking (also chosen at random). This should only perform a single attack and theSaxon doesn't get to attack back.

• should be a function
• should receive0 arguments
• should make aSaxonreceiveDamage() equal to thestrength of aViking
• should remove dead Saxons from the army
• should returnresult of callingreceiveDamage() of aSaxon with thestrength of aViking

TheSaxon version ofvikingAttack(). AViking receives damage equal to thestrength of aSaxon.

• should be a function
• should receive0 arguments
• should make aVikingreceiveDamage() equal to thestrength of aSaxon
• should remove dead Vikings from the army
• should returnresult of callingreceiveDamage() of aViking with thestrength of aSaxon

Since there is a lot of repetitive code in the previous two iterations, methodsvikingAttack() andsaxonAttack(), try to create onegeneric method and call it in the case ofvikingAttack and in the case ofsaxonAttack instead of using almost the same code for both methods. (This iteration doesn't have the test, so ask your TAs and your instructor to give you feedback on the quality of your code after the refactor.)

Returns the current status of theWar based on the size of the armies.

• should be a function
• should receive0 arguments
• if theSaxon array is empty, should return"Vikings have won the war of the century!"
• if theViking array is empty, should return"Saxons have fought for their lives and survived another day..."
• if there are at least 1Viking and 1Saxon, should return"Vikings and Saxons are still in the thick of battle."

Happy Coding! ❤️

array.forEach(function(element){// code to be executed for each element});

constfruits=['apple','banana','cherry'];fruits.forEach(function(element,index){console.log(`${index}:${element}`);});

fruits.forEach((element,index)=>{console.log(`${index}:${element}`);});

array.splice(start,deleteCount,item1,item2, ...)

letnumbers=["a","b","c","d","e"];// Remove 1 element starting at index 2 (removes "c")letremoved=numbers.splice(2,1);console.log(numbers);// Output: ["a", "b", "d", "e"]console.log(removed);// Output: ["c"]

classDog{constructor(name){this.name=name;}bark(){console.log(`${this.name} is barking.`);}}classLabradoodleextendsDog{constructor(name,color){super(name);this.color=color;}}constdog1=newLabradoodle("Daisy","white");dog1.bark();// Output: "Daisy is barking."