CSCI 204 – Project 3 - Galaxy Conflict by Alex Fuchsberger
Introduction
In a galaxy far far away...
The galaxy is in turmoil. Thousands of star systems have declared their independence. Everywhere new weapon facilities
and shipyards are pushing out tools of mass destruction. It is only a matter of time until our beloved homeworld will be
eradicated from existence. We are a nation of peace and prosperity and not prepared for an all out war with our rebelling
colonies. Our government has entrusted you to prepare and design a fleet that will ensure the survival of our species and
continued dominance in the cluster…
In this project we are going to implement a complex space
battle simulation in multiple phases. Two opposing fleets will
clash and fight for survival. Only one will prevail, who is it
going to be? You will have to create Spaceships and equip
them with modules such that they are effective in bringing
down your opponents before they can bring down yours. In
the final stage we will let each commander (yes, that is you)
test out their fleet composition in a fair battle against each
other and see who really has the skills to become grand
admiral of our starfleet! A grand prize awaits the most capable
commander and his or her designs will ensure the safety of
future generations to come!
This project consists of multiple phases:
1. Create several Ship and Weapon classes and build a fleet.
2. Create a Battle Simulator that will schedule the firing of weapon systems and handle basic combat
3. Improve your Battle simulator by adding a sophisticated Targeting-Computer that will allow your weapon systems
to do maximum damage to an enemy with known capabilities
Timeline Due Points
Phase 1: “Imminent Doomstacks” Fr, 4/8 11pm 36
Phase 2: “Advanced Battle Simulator” Mo, 4/18 11pm 29
Phase 3: “Autonomous Target System” We, 4/27 11pm 35
Extra Credit: Doomsday Showdown We, 4/29 in class (5)
Important: All phases are submitted via Gradescope but must be implemented in replit. Phases 1 and 2 will also be
auto-graded via Gradescope. You have the choice of submitting each phase (and not altering your submissions afterwards)
by the phase deadline for 100% of the score or submit it until the final phase deadline for 80% of the score.
CSCI 204 Project 3 - Galaxy Conflict 1
Overview
On this page we list the TODOS for the three phases and what to submit. For all three phases you will work in the same replit.
Before getting started with the project you should study all given files to get an overview of the project.
For phase 1 you need to deliver the following files via gradescope:
● specs/ships.py (contains your Ship, Fighter, Destroyer, Cruiser, Battleship classes)
● specs/weapons.py (contains your Weapon, Torpedo, Laser, Railgun classes)
● specs/fleet.py (create your read_fleet_file method)
For phase 2 you need to redeliver the following files via gradescope:
● specs/weapons.py (resubmit with updated fire method)
● specs/fleets.py (updated Fleet class with more methods for GUI output)
For phase 3 you need to deliver the following files via gradescope:
● computers/student.py (contains your target computer)
● fleets/student.txt (contains your fleet composition)
● README.md (feedback and explanations)
Weapon Properties/Attributes Ship Properties/Attributes Fleet Properties
self.ship (phase 1)
self.damage (phase 1)
self.accuracy (phase 1)
self.target (phase 1)
class properties:
hull_modifier (phase 1)
armor_modifier (phase 1)
shield_modifier (phase 1)
cooldown (phase 1)
self.fleet (phase 1)
self.weapons (phase 1)
self.max_hull (phase 1)
self.max_armor (phase 1)
self.max_shields (phase 1)
self.pd (phase 1)
self.evasion (phase 1)
self.hull (phase 1)
self.armor (phase 1)
self.shields (phase 1)
class properties:
cost (phase 1)
self.name
self.ships
Weapon Methods (you need to impl.) Ship Methods (you need to implement) Fleet Methods (you need to implement)
fire (phase 2) __init__(self) (phase 1)
__str__(self) (phase 1)
read_fleet_file() (phase 1)
get_stats() (phase 2)
get_weapons() (phase 2)
__str__() (phase 2)
Table 1: Class Attributes
student.py (phase 3) only contains a single function set_targets(attackFleet, targetFleet) that you need to complete.
Good luck to you and good fortune to us all… May we survive the battles to come…
CSCI 204 Project 3 - Galaxy Conflict 2
Phase 1 - “Imminent Doomstacks”
Our shipyard has delivered us clear specifications of ship types they can produce. Types vary in size and purpose and can hold a
number of modules. Every ship has a hull, armor and shields. An attacker needs to first overcome the ship’s shield barriers. Once the
shields are down, the armor can be damaged. A ship without any armor remaining is vulnerable to hull damage. Should the hull
integrity fail the ship is destroyed. Every ship also has some maneuverability in the form of evasion - the ability to dodge an attack.
This is a percentage to avoid damage altogether.
1.1 Ship Types & Defense Modules
Fighter (F) The smallest ship in our armada can be produced cheap and fast. Because it is so fast it's really hard to target, thus most
normal weapons will miss. Unfortunately a direct hit usually means the end of it.
Destroyer (D) This small but capable attack ship can house two weapon slots and a defense slot. It is stronger and slower than a
Fighter but still maneuverable.
Cruisers (C) are offering great firepower and defense capabilities but lack the maneuverability of smaller ship types. They offer a
good combat strength for its cost.
Battleships (B) are massive warships that offer supreme firepower and are really hard to take down. They also cost a lot though
limiting their deployment in combat. Overcharging their weapons however takes time, thus aiming accuracy is decreased.
Here is an overview and comparison of ship specifications that you should implement:
Overview Fighter Destroyer Cruiser Battleship
Cost / Command Points 1 2 4 8
Weapon Slots 1 2 3 4
Defense Slots 0 1 2 3
Base Hull / Armor / Shields 100 300 600 1000
Evasion 80% 40% 20% 10%
Damage Multiplier 100% 100% 120% 150%
Accuracy (Lasers and Railguns) 100% 100% 90% 80%
Fire Priority First Second Third Last
Defense modules can increase armor or shields of a ship, boost its maneuverability, or provide a means to defend against torpedoes.
Here is an overview of the available defense modules.
Defense Modules Description
Shield Generator (S) adds 50% of base Shield to the shield value of the ship
Tritanium Armor (A) adds 50% of base Armor to the armor value of the ship
Ion Thrusters (E) doubles the evasion level of the ship (only one of these per ship allowed)
Point Defense (P) adds a 1/3 chance to shoot down incoming torpedoes
A ship is created via the following prototype:
class Ship:
def __init__(self, modules, base, dmg_modifier):
It is probably easiest to directly modify the ships base values based on the characters you receive in the module string.
CSCI 204 Project 3 - Galaxy Conflict 3
In the end all ship objects must contain the attributes as outlined in Table 1. I strongly suggest creating these attributes in the base
class (ship) not in the child classes (Fighter,...). Further make sure that the child classes (Fighter,...) properly inherit from the ship
class.
Notice that some attributes are labeled as class attributes. Whenever your objects have a property that is always the same for all
objects of that type it is better to not create it with each object but rather in the class itself. This also works with inheritance:
As you can see the cost (command point requirement) does not change
between ships of the same type. Thus this is an ideal candidate for a
class attribute.
The only thing to keep in mind is that changing such a class attribute
will change it for all objects.
self.fleet is a reference to the owner's fleet thus given a ship we can get
the matching fleet.
max_* attributes represent hull, armor and shields of that ship at the
beginning of combat and should not change over the course of battle.
That's what self.hull, self.armor and self.shields are for.
Set self.pd and self.evasion as fractions (e.g. 1/3 or 0.8).
TODO and Hint Summary:
● Create all Ship classes and set defense attributes correctly based on the module string.
● Use inheritance whenever possible and useful. Do not recreate the same mechanics for each ship, rather inherit.
● For self.weapons you can for now just create an empty python list [] and worry about weapons modules in 1.1.
1.2 Weapon Types
Weapon slots can be equipped with Lasers, Railguns or Torpedos:
Railguns (R) are effective against shields and have a high rate of fire. They are ineffective against armor.
Lasers (L) cut through hull and armor at ease but are ineffective against shields.
Torpedos (T) ignore shields altogether. They always hit and cannot be evaded. Ships can defend themselves against torpedoes using
Point Defense modules. Torpedo bays also need a long time to reload and have a lower DPS for compensation.
Weapon Modules Railgun Laser Torpedo
Base Damage 10 60 120
Cool Down 1 5 15
Damage to Hull 90% 100% 120%
Damage to Armor 40% 120% 100%
Damage to Shields 120% 40% -
Specials 100% accuracy regardless of ship size
ignores enemy evasion
ignores enemy shields
Weapons need to be implemented a little bit differently than Defense modules: Instead of modifying the ship's stats weapons are added
under self.weapons which is a python list. Make sure:
CSCI 204 Project 3 - Galaxy Conflict 4
● Weapon base damage and accuracy is modified correctly according to the ship's specifications
● You create class attributes for hull_modifier, armor_modifier, shields_modifier, and max_cooldown
● You set the actual cooldown of the weapon to 0 so it can be shot in the first round. Please check the charge method to see how
the firing works. Basically every round we charge the weapons and if ready, shoot. A max_cooldown of 0 therefore means
this weapon can shoot every round.
● Don't worry about the special features of Torpedoes yet, except for the accuracy which should be always at 100%. (phase 2).
● You do not need to touch the fire method at this point (phase 2).
● You do not need to worry about the fire priority at this point (phase 2).
1.3 Reading and Describing Ships and Fleets
1.3.1 Reading Fleet Files
How are fleets actually created? Take a look at the fleet file. fleets/student.txt could look like:
B RRLLSSA
B TTTTPSA
B TTTTESA
B TTTTPPP
C TLRSA
C TLRAA
C TLRSS
D LRE
D LRE
D LRP
D LRS
F R
F R
F R
F R
F R
F L
F L
F L
F L
F L
Every line consists of two words and describes a ship configuration:
1. The first word is a single letter indicating the ship type
2. The second letter is a list of modules to build into that ship
Your job is to complete the read_fleet_file(self) function that reads the fleet specification from a file rather than hard code them.
1.3.2 Error handling
We want to ensure valid ships are being created. To do this you will need to raise custom exceptions when attempting to create invalid
ships. Think about logical places where to do this. You need to account for the following constraints:
● If a ship contains more than the maximum allowed number of weapon / defense slots raise an InvalidModuleException.
● If a ship has an unknown module (letter other than R,L,T,S,A,P,E) raise a InvalidModuleException
● If a ship contains more than one Ion Thruster Module raise an InvalidModuleException
● If you try to build a ship other than F,D,C,B raise an InvalidCastException
● If your fleet contains ships worth more than 100 command points raise an InvalidFleetException
CSCI 204 Project 3 - Galaxy Conflict 5
1.3.3 Describing ships
Your next objective is to implement a __str__(self) method in the Ships that is used inside Fleet.list_ships(self) to show
an overview over all ships:
T | Modules | H | A | S | PD | E | DPS |
==|=========|======|======|======|======|=====|=====|
B | RRLLSSA | 1000 | 1500 | 2000 | 0% | 10% | 30 |
...more ships here...
This summary of your fleet is visible if launching your simulation without GUI or after exiting the GUI.
Make sure that:
● Output exactly matches the format above
● Right align all values with spaces left and right
● Round Point Defense and DPS to the nearest full percentage
● Round DPS to the nearest integer.
DPS stands for Damage per Second and can be calculated for an individual ship as well as the whole fleet. For the str method of the
ship you will want to compute it for the ship. Simply calculate (total_weapon_damage)/(total_cooldown). Round your DPS
to an integer.
1.4 Grading Rubric
Grading Rubric for Phase 1 File Points
1.1 Created all ship classes and handled defense modules correctly ships.py 12
1.2 Created all weapon classes and set properties correctly weapons.py 6
1.3.1 Completed read_fleet_file() method correctly fleets.py 6
1.3.2 All custom Exceptions raise correctly when attempting to create invalid fleets ships.py / fleets.py 6
1.3.3 Created the Ship.__str__(self) correctly ships.py 6
You didn't comment and structure your code well. up to -5
For all phases keep your project in repl or make sure it is in there on due date.
You must work only in replit on your project so we can verify your progress and clarify possible instances of plagiarism.
Once you are confident your weapons.py and ships.py are complete please do upload them on Gradescope, the same platform we used
for the midterm. You do not need to hit the submit button in replit. Only your submission in Gradescope counts. This provides the
following advantages:
● You get automated feedback and your estimated grade on your code before submission deadline
● You can submit as many times as you like until you get it fully right or the deadline has passed.
There are two deadlines for phase 1:
● Fr, 4/8 11pm If you submit phase 1 by then you earn 100% of your score
● We, 4/27 11pm If your latest submission was after 4/8 but before 4/27 then you earn 80% of your autograder score.
● Afterwards If you submit after 4/27 you earn 0% of your gradescope score.
And the saga will continue...
CSCI 204 Project 3 - Galaxy Conflict 6
Phase 2 - Advanced Battle Simulator
“We are running out of time. Grave news reached us today from Trappist Prime, one of our first and most successful colonies. What
appears to be nuclear fire covering the entire populated surface area has left 85% of the area uninhabitable for generations to come.
It is believed that all 20.8 million colonists have perished in the assault. Experts are now investigating what went wrong. At this point
the most likely scenario is a sophisticated cyber hack into the nuclear defense protocol of the Planetary Defense Grid. While shock
and disbelief grips us we think of these brave souls on Trappist. Anger and calls for justice are getting louder. Who would do such a
thing? Are we safe? Could this tragedy have been avoided? Why does an agricultural colony need a nuclear defense grid? How will
our government respond? This is Kate Lansel from Alliance Star News.”
As appointed Commander it falls on you to conduct the next phase of our starfleet overhaul. We are tasked to develop an unhackable
battle computer. It must be capable of simulating the clash of two fleets and predict the most likely outcome. This will allow us to
choose the battles we can win and avoid the ones we cannot.
As Sun Tsu (544 - 496 BC) put it: “He will win who knows when to fight and when not to fight.”
In this step we are making the combat simulation work, thus ships being able to damage other ships:
CSCI 204 Project 3 - Galaxy Conflict 7
We do recommend running your simulation via shell (python main.py). Otherwise you may end up with visual bugs.
Ships are displayed in the middle area. Their color indicates how long they are likely going to last. Green ships have never taken a
single hit. Blue ships have shields weakened. Yellow Ships have their armor penetrated. Red ships no longer have their structural
integrity (hull) intact. Destroyed ships are painted in black, thus becoming invisible on the console.
The bottom are is an info display that shows useful statistics about your fleet. You don't have to mess with the Curses GUI in
simulation.py but you need to revise the combat_stats() method in order for the info display to show appropriate values.
The empty bottom box is where you display your combat statistics (Task 3). Here is where you want to display information such as
how many ships each side has left. You are free to use the remaining space as you like but do not increase the size of the info area. The
goal is to populate this limited space with as much (useful) information as possible. If you cannot think of what to display here, get
inspiration of the __str__(self) function in the Fleet class.
In this phase we have three main objectives:
1. program the Weapon method fire(self) function that will properly damage the target ship.
2. program all info methods in fleet.py that will allow useful combat statistics in the GUI to display in the info_box(self,
win) method in simulation.py
2.1 Armament
Before we do anything else, let's study the combat_round() method in simulation.py. It describes that both battle participants shoot
their available weapons at the same time each combat round. This could lead to a scenario where ships destroy each other at the same
time leading to a potential draw.
Also notice that the Simulation keeps a property self.round. This number will be incremented after each combat round. We abort the
combat once we reach combat round 1000 because at this point in time it is most likely that you ended up in a situation where no
further damage can be made (e.g. both sides have only Torpedoes left but have ships that are immune to Torpedos).
The way combat works in our simulation is the following:
● All Weapons on ships that still have hull left first select a target on which they shoot. (This is going to be phase 3)
● Weapons from one ship do not need to all fire on the same ship.
● Ships shoot in order according to their ship sizes. Smaller ships will shoot before larger ships:
○ All Fighters from both sides Shoot at the same time and apply damage
○ All surviving Destroyers from both sides shoot at the same time and apply damage
○ All surviving Cruisers from both sides shoot at the same time and apply damage
○ All surviving Battleships from both sides shoot at the same time and apply damage
● Targeting happens at the beginning of the combat round for all ship classes and remains locked. Bigger ships can therefore
not change their targets after casualties are taken from smaller ships.
Complete the Fleet method get_weapons(self, priority) that should return a list of all weapons of ships that belong to that
category and have not yet been destroyed. Priority is expressed as the class name Fighter or Destroyer,... Thus a valid function call
would be:
fleet1.get_weapons(Fighter)
2.2 Fire in the hole
Now we want to complete the fire(self) method that will calculate if it hits the target and if so, apply the damage to the opposing
ship. There are a few rules:
● If a weapon is still on cooldown it cannot fire.
Hint: see if you can use self.round and weapon.cooldown as well as modulo to your advantage)
● If a weapon is a torpedo you need to check whether it passed point defense.
CSCI 204 Project 3 - Galaxy Conflict 8
Hint: use random.random() to create a random number between 0 and 1 and compare it with point defense value of target.
● If a weapon is a torpedo and the ship still has shields left ignore the shield and damage armor or hull instead
● If a weapon is not a torpedo check whether the enemy ship managed to evade it
● Weapons first damage shields (if remaining and not a torpedo), then armor (if remaining), then hull (if remaining)
● Properly modify the weapon damage by the type of defense that is being targeted (hull/armor/shields).
● If a weapon would deal more damage then current shields / armor / hull value of the ship the remaining damage is voided.
Example: A ship has 100 shields left. Your weapon made 150 damage. Instead of disabling the shields and doing 50 damage
to the armor of the target it will only disable the shield. This will guarantee that each ship, even Fighters, can always tank at
least two hits. The next weapon hit will damage armor. Also make sure hull, armor and shields only go down to 0, not
become negative values.
2.3 Fleet Stats
Now its time to focus on the info display. You will want to complete the get_stats method that will return a dictionary with the
following key/value pairs:
● ships (counts ships alive)
● ships_total (total number of ships)
● cost (cost in command points of ships alive)
● cost_total (cost in command points, should normally be 100)
● hull (current hull of the whole fleet)
● hull_total (total hull of the whole fleet)
● armor (current armor of the whole fleet)
● armor_total (total armor of the whole fleet)
● shields (current shields of the whole fleet)
● shields_total ( total shields of the whole fleet)
● damage_taken ( accumulated hull/armor/shield damage the fleet has taken)
This method is used in simulation.py to produce the info display. All values should be returned as integers.
2.4 Fleet Report
You should also create a fleet Summary that will be displayed in non-GUI simulations or after leaving a GUI simulation. This should
be implemented in the __str__(self) method. I highly recommend to call the get_stats() method first and then just put together the
string accordingly:
Fleet students
=========================================================
Ships: 21/21, Command Points: 62/62
Hull: 8000/8000, Armor: 10400/10400, Shields: 11050/11050
Grading Rubric for Phase 2 File Points
2.1 Created the get_weapons() method correctly fleets.py 6
2.2 Created the fire() method correctly weapons.py 12
2.3 Created get_stats() method correctly fleets.py 8
2.4 Created __str__() method correctly fleets.py 3
You didn't comment and structure your code well. up to -4
Once you are confident your weapons.py and fleet.py are complete please do upload them on Gradescope, the same platform we used
for the midterm. You do not need to hit the submit button in replit. Only your submission in Gradescope counts.
There are two deadlines for phase 2:
● Fr, 4/18 11pm If you submit phase 2 by then you earn 100% of your score
● We, 4/27 11pm If your last submission was after 4/18 but before 4/27 then you earn 80% of your autograder score.
● Afterwards If you submit after 4/27 you earn 0% of your gradescope score.
CSCI 204 Project 3 - Galaxy Conflict 9
Phase 3 - Autonomous Target System
… Hope. It's there. We are so close… The new simulations are getting more and more promising. Let's just hope we are not too late.
Our engineers have managed to develop a precognitive interface that can sense optimal decisions instantly using a combination of
quantum computing and biological reasoning. Would we not be at war, this milestone achievement would certainly mark a new area of
human civilization. Think of all the possibilities. Optimal decisions for resource allocation so no one would ever need to starve again.
Expandable, autonomous drones taking over the difficult jobs minimizing the risk to our species. Cell Treatment and consciousness
transfer for potentially infinite life... We cannot fail now…
In this phase you are going to develop the smart technology that will improve your chances of winning a space battle significantly.
This is the most open-ended stage of the project, thus ensure to read carefully how I will grade this section at the end of this phase. In
this phase you will need to utilize advanced ADTs that you have learned throughout the semester.
You are going to work exclusively in computers/student.py and your fleet file fleets/student.txt
Now we are ready to start working on improving our target system. Your job is to improve the set_targets(myFleet,
enemyFleet) function in your computer in a way such that your fleet is making more damage than just randomly targeting enemy
ships. By now you know the different ships and weapons and the "rock-paper-scissor" approach that governs the success of one fleet
over another.
Your task is to create a target system (and accompanying fleet) that can win with minimal losses against your fellow peer's
target systems. There are no limits to how complex this can go but good computers will account for the current situation and target
accordingly. In the final showdown we will let each participant fight against another. The student with the best submission (that
wins most often with least casualties) will gain a real trophy which can currently be admired in the trophy display before
April's office in DANA!
As set_targets() takes both your fleet and the enemy fleet you will have full access to all information of the battle. What this function
should actually achieve is to set self.target for each weapon that can still fire (ship is not destroyed) to some enemy ship (that is not yet
destroyed). See the random target computer implementation for inspiration.
There are few rules:
● You must use at least one ADT we have learned in this class. Some recommendations:
○ Sort ships by their health to finish weaker ships first using heapsort
○ Handle your weapons in a bounded priority queue by type. This way you can anticipate how much damage you can
do to hull/armor/shields and decide how many weapons should target the same ship.
● Create all ADTs and helpers in the files you submit, do not create any extra files. This is paramount!
● You can add additional properties to the fleets/ships/weapons via this method but you should not change existing properties.
● Your function must not do anything affecting the battle beyond setting the target, such as damaging enemy ships directly.
Here are a couple of suggestions for you to take into consideration when writing your target computer. This list is by far not complete
and it is up to you into how much detail you go and how smart your computer will end up being.
● Avoid firing Torpedoes on ships with high Point Defense
● Torpedos are great to target small ships with high evasion but be careful to “dose” them correctly as firing too many
Torpedoes on the same target may be a waste of firepower. To dose weapons on a specific target note that you can at any
time add new properties to objects that already exists. For example the first time you target a ship with a torpedo you could
set target.shots_torpedo = 1. Depending on the ship size you could now decide how many more more torpedoes you need to
fire on the ship until it is destroyed. (For a fighter, a maximum of three torpedos should do the trick).
● Prioritize your Lasers to ships that no longer have shields
● Prioritize your Railguns to ships with shields
● Railguns are also very efficient in finishing of ships with very little hull left (as they fire so rapidly)
CSCI 204 Project 3 - Galaxy Conflict 10
● As smaller ships shoot first, consider using their weapons to "Finish off" low health targets will your battle ships do the heavy
lifting.
● Design your computer alongside your fleet. A mixed fleet may be viable but so may be a fleet consisting only of ships of one
type. You design a computer for your fleet, not a general purpose computer (although you can totally do that instead).
● You can use different ship classes to prioritize different ships. Note that weapons of Fighters and Destroyers are more
accurate while Cruisers and Battleships make more damage. It may be a good strategy for ships to target ships in their size
first
● Using the own_fleet argument you can count your own available weapon systems for each category and develop a better
“macro” strategy - a strategy that takes your overall firepower in consideration and then optimizes your combat as a whole
not just based on the specific weapon.
Again once done please submit via gradescope to verify your computer works for the showdown event in class. I will pull your files
and compile them together into a special replit so we can participate in class. If you do not have a working computer/fleet file I will
automatically default to the random computer and a random fleet. You are still eligible for participation for the extra credit opportunity
but you will likely win no trophy as the random computer is really bad.
Although submitted via gradescope, phase 3 will be manually graded:
Grading Rubric for Phase 3 Points
Your target computer uses at least one ADT effectively. 8
Your target system has improved behavior for torpedoes 4
Your target system has improved behavior for bringing down shields / armor 6
Your target system takes your own fleet composition into consideration. 3
Your target system takes the enemy fleet composition into consideration. 3
You have implemented and clearly indicated one strategy not suggested above 3
You have a total of at least 7 different target strategies 4
README completed for all three phases and general feedback. 4
You didn't comment and structure your code well. up to -5
Extra credit: Participated in the showdown battle (5)
Your target_ship() function is cheating and directly damaging enemy ships disqualification
from extra credit
Don't forget to submit your README file with the project.
Scoring for the showdown battle:
● 50 points for participating in a battle (regardless of win/loose/draw)
● 1 point for each surviving command point (cost) in a battle. (this does not apply for draws)
Rules of participation
● You can combat the same opponent not more than once
● You can combat as many other students as you like, your 5 best scores will be used to calculate your max score.
● To be eligible for the extra credit you need to reach at least 250 points. (or in other words, battle 5 opponents).
● You must accept more challenges from other students even if you have already participated in 5 battles.
There is only one deadline for phase 1:
● We, 4/27 11pm If you submit phase 3 by then you earn 100% of your score
● Afterwards If you submit after 4/27 you earn 0% of your gradescope score.
Have fun!