From 04511f25d63cea757c874faa6c2382f6c3668dec Mon Sep 17 00:00:00 2001
From: Felix <tony.199975@gmail.com>
Date: Fri, 13 Oct 2023 17:19:20 +0200
Subject: [PATCH 1/2] Dooooooooone

---
 vikingsClasses.py | 90 +++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 84 insertions(+), 6 deletions(-)

diff --git a/vikingsClasses.py b/vikingsClasses.py
index b51cd5f..014061c 100644
--- a/vikingsClasses.py
+++ b/vikingsClasses.py
@@ -1,24 +1,102 @@
 
+import random as rd
+
+
 # Soldier
 
 
 class Soldier:
-    pass
+    
+    def __init__(self, health, strength):
+        
+        self.health = health
+        self.strength = strength
+        
+    def attack(self):
+        return self.strength
+    
+    def receiveDamage(self, damage):
+        self.health -= damage
+        
 
 # Viking
 
 
-class Viking:
-    pass
+class Viking(Soldier):
+    
+    def __init__(self, name, health, strength):
+        super().__init__(health, strength)
+        self.name = name
+        
+    def receiveDamage(self, damage):
+        self.health -= damage
+        if self.health > 0:
+            return f"{self.name} has received {damage} points of damage"
+        else:
+            return f"{self.name} has died in act of combat"
+        
+    def battleCry(self):
+        return "Odin Owns You All!"
+        
+        
 
 # Saxon
 
 
-class Saxon:
-    pass
+class Saxon(Soldier):
+    
+    def receiveDamage(self, damage):
+        self.health -= damage
+        if self.health > 0:
+            return f"A Saxon has received {damage} points of damage"
+        else:
+            return f"A Saxon has died in combat"
+            
 
 # War
 
 
 class War:
-    pass
+    
+    def __init__(self):
+        self.vikingArmy = []
+        self.saxonArmy = []
+            
+    def addViking(self, Viking_obj):
+        self.vikingArmy += [Viking_obj]
+        
+    def addSaxon(self, Saxon_obj):
+        self.saxonArmy += [Saxon_obj]
+        
+    def vikingAttack(self):
+        saxon_rand = self.saxonArmy[rd.randint(0,len(self.saxonArmy)-1)]
+        viking_rand = self.vikingArmy[rd.randint(0,len(self.vikingArmy)-1)]
+        
+
+        
+        if saxon_rand.health <= viking_rand.attack():
+            self.saxonArmy.remove(saxon_rand)
+            
+        return  saxon_rand.receiveDamage(viking_rand.attack())
+    
+    
+    
+    def saxonAttack(self):
+        viking_rand = self.vikingArmy[rd.randint(0,len(self.vikingArmy)-1)]
+        saxon_rand = self.saxonArmy[rd.randint(0,len(self.saxonArmy)-1)]
+                  
+        if viking_rand.health <= saxon_rand.attack():
+            self.vikingArmy.remove(viking_rand)
+            
+        return viking_rand.receiveDamage(saxon_rand.attack()) 
+    
+    def showStatus(self):
+        
+        if not self.saxonArmy:
+            return "Vikings have won the war of the century!"
+        
+        elif not self.vikingArmy:
+            return "Saxons have fought for their lives and survive another day..."
+        
+        else:
+            return "Vikings and Saxons are still in the thick of battle."  

From 5c0b3db625ba709feb8904173be0496d89425f99 Mon Sep 17 00:00:00 2001
From: Felix <tony.199975@gmail.com>
Date: Sun, 15 Oct 2023 12:29:21 +0200
Subject: [PATCH 2/2] game ghostbuster created

---
 GhostBuster/1-testsSoldier.py                 |  48 +++++++
 GhostBuster/2-testsHunters.py                 |  67 ++++++++++
 GhostBuster/3-testsGhosts.py                  |  67 ++++++++++
 GhostBuster/4-testsGhostBusters.py            |  54 ++++++++
 GhostBuster/GhostBuster.py                    | 118 ++++++++++++++++++
 .../__pycache__/GhostBuster.cpython-311.pyc   | Bin 0 -> 5768 bytes
 __pycache__/GhostBuster.cpython-311.pyc       | Bin 0 -> 5100 bytes
 __pycache__/file.cpython-311.pyc              | Bin 0 -> 4859 bytes
 __pycache__/vikingsClasses.cpython-311.pyc    | Bin 0 -> 5235 bytes
 9 files changed, 354 insertions(+)
 create mode 100644 GhostBuster/1-testsSoldier.py
 create mode 100644 GhostBuster/2-testsHunters.py
 create mode 100644 GhostBuster/3-testsGhosts.py
 create mode 100644 GhostBuster/4-testsGhostBusters.py
 create mode 100644 GhostBuster/GhostBuster.py
 create mode 100644 GhostBuster/__pycache__/GhostBuster.cpython-311.pyc
 create mode 100644 __pycache__/GhostBuster.cpython-311.pyc
 create mode 100644 __pycache__/file.cpython-311.pyc
 create mode 100644 __pycache__/vikingsClasses.cpython-311.pyc

diff --git a/GhostBuster/1-testsSoldier.py b/GhostBuster/1-testsSoldier.py
new file mode 100644
index 0000000..b47f89f
--- /dev/null
+++ b/GhostBuster/1-testsSoldier.py
@@ -0,0 +1,48 @@
+import unittest
+from GhostBuster import Soldier
+from inspect import signature
+
+
+class TestSoldier(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        cls.strength = 150
+        cls.health = 300
+        cls.soldier = Soldier(cls.health, cls.strength)
+
+    def testConstructorSignature(self):
+        self.assertEqual(len(signature(Soldier).parameters), 2)
+
+    def testHealth(self):
+        self.assertEqual(self.soldier.health, self.health)
+
+    def testStrength(self):
+        self.assertEqual(self.soldier.strength, self.strength)
+
+    def testAttackShouldBeFunction(self):
+        self.assertEqual(callable(self.soldier.attack), True)
+
+    def testAttackHasNoParams(self):
+        self.assertEqual(len(signature(self.soldier.attack).parameters), 0)
+
+    def testAttackRetunsStrength(self):
+        self.assertEqual(self.soldier.attack(), self.strength)
+
+    def testReceivesDamage(self):
+        self.assertEqual(callable(self.soldier.receiveDamage), True)
+
+    def testReceivesDamageHasParams(self):
+        self.assertEqual(
+            len(signature(self.soldier.receiveDamage).parameters), 1)
+
+    def testReceiveDamageReturnNone(self):
+        self.assertEqual(self.soldier.receiveDamage(50), None)
+
+    def testCanReceiveDamage(self):
+        self.soldier.receiveDamage(50)
+        self.assertEqual(self.soldier.health, self.health - 50)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/GhostBuster/2-testsHunters.py b/GhostBuster/2-testsHunters.py
new file mode 100644
index 0000000..ae8cce3
--- /dev/null
+++ b/GhostBuster/2-testsHunters.py
@@ -0,0 +1,67 @@
+import unittest
+from GhostBuster import Hunters
+from inspect import signature
+
+
+class TestHunters(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        cls.name = 'Fernando'
+        cls.strength = 150
+        cls.health = 300
+        cls.hunters = Hunters(cls.name, cls.health, cls.strength)
+
+    def testShouldReciveThreeParams(self):
+        self.assertEqual(len(signature(Hunters).parameters), 3)
+
+    def testName(self):
+        self.assertEqual(self.hunters.name_team1, self.name)
+
+    def testHealth(self):
+        self.assertEqual(self.hunters.health, self.health)
+
+    def testStrenght(self):
+        self.assertEqual(self.hunters.strength, self.strength)
+
+    def testAttackShouldBeFunction(self):
+        self.assertEqual(callable(self.hunters.attack), True)
+
+    def testAttackReciveNoParameters(self):
+        self.assertEqual(len(signature(self.hunters.attack).parameters), 0)
+
+    def testAttackShouldReturnStrength(self):
+        self.assertEqual(self.hunters.attack(), self.strength)
+
+    def testReceiveDamageIsFunction(self):
+        self.assertEqual(callable(self.hunters.receiveDamage), True)
+
+    def testReceiveDamageReciveOneParam(self):
+        self.assertEqual(
+            len(signature(self.hunters.receiveDamage).parameters), 1)
+
+    def testReciveDamageShouldRestHealth(self):
+        self.hunters.receiveDamage(50)
+        self.assertEqual(self.hunters.health, self.health - 50)
+
+    def testReciveDamageShouldReturnString50(self):
+        self.assertEqual(self.hunters.receiveDamage(50), self.name +
+                         ' has received 50 points of damage')
+
+    def testReciveDamageShouldReturnString70(self):
+        self.assertEqual(self.hunters.receiveDamage(70), self.name +
+                         ' has received 70 points of damage')
+
+    def testReceiveDamageShouldReturnStringDeath(self):
+        self.assertEqual(self.hunters.receiveDamage(self.health),
+                         self.name + ' has died in act of combat')
+
+    def testBattleCry(self):
+        self.assertEqual(callable(self.hunters.battleCry), True)
+
+    def testBattleCryReturnString(self):
+        self.assertEqual(self.hunters.battleCry(), 'For Glory and Victory!')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/GhostBuster/3-testsGhosts.py b/GhostBuster/3-testsGhosts.py
new file mode 100644
index 0000000..3e4533b
--- /dev/null
+++ b/GhostBuster/3-testsGhosts.py
@@ -0,0 +1,67 @@
+import unittest
+from GhostBuster import Ghosts
+from inspect import signature
+
+
+class TestGhosts(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        cls.name = 'Bego'
+        cls.health = 250
+        cls.strength = 100
+        cls.ghosts = Ghosts(cls.name, cls.health, cls.strength)
+
+    def testShouldReciveThreeParams(self):
+        self.assertEqual(len(signature(Ghosts).parameters), 3)
+
+    def testName(self):
+        self.assertEqual(self.ghosts.name_team2, self.name)
+        
+    def testHealth(self):
+        self.assertEqual(self.ghosts.health, self.health)
+
+    def testStrength(self):
+        self.assertEqual(self.ghosts.strength, self.strength)
+
+    def testAttack(self):
+        self.assertEqual(callable(self.ghosts.attack), True)
+
+    def testAttackShouldReceiveNoParams(self):
+        self.assertEqual(len(signature(self.ghosts.attack).parameters), 0)
+
+    def testAttackREturnStrength(self):
+        self.assertEqual(self.ghosts.attack(), self.strength)
+
+    def testReceiveDamageIsFunction(self):
+        self.assertEqual(callable(self.ghosts.receiveDamage), True)
+
+    def testReceiveDamageShouldReceiveOneParam(self):
+        self.assertEqual(
+            len(signature(self.ghosts.receiveDamage).parameters), 1)
+
+    def testReceiveDamage(self):
+        self.ghosts.receiveDamage(1)
+        self.assertEqual(self.ghosts.health, self.health - 1)
+
+    def testReceiveDamageString45(self):
+        self.assertEqual(self.ghosts.receiveDamage(
+            45), self.name + ' has received 45 points of damage')
+
+    def testReceiveDamageString10(self):
+        self.assertEqual(self.ghosts.receiveDamage(
+            10), self.name + ' has received 10 points of damage')
+
+    def testReceiveDamageStringDied(self):
+        self.assertEqual(self.ghosts.receiveDamage(self.health), 
+                         self.name + ' has died in combat')
+
+    def testBattleCry(self):
+        self.assertEqual(callable(self.ghosts.battleCry), True)
+
+    def testBattleCryReturnString(self):
+        self.assertEqual(self.ghosts.battleCry(), 'No Mercy, No Regrets!')
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/GhostBuster/4-testsGhostBusters.py b/GhostBuster/4-testsGhostBusters.py
new file mode 100644
index 0000000..a668ff3
--- /dev/null
+++ b/GhostBuster/4-testsGhostBusters.py
@@ -0,0 +1,54 @@
+import unittest
+from GhostBuster import GhostBusters, Hunters, Ghosts
+
+
+class TestGhostBusters(unittest.TestCase):
+    def testHunterAttack(self):
+        ghostbusters = GhostBusters([], [])
+        result = ghostbusters.hunterAttack()
+        self.assertEqual(result, "There are no ghosts left to attack.")
+
+    def testGhostAttack(self):
+        ghostbusters = GhostBusters([], [])
+        result = ghostbusters.ghostAttack()
+        self.assertEqual(result, "There are no hunters left to possess.")
+
+    def testShowStatusHuntersWin(self):
+        ghostbusters = GhostBusters(["Ghost1", "Ghost2"], [])
+        result = ghostbusters.showStatus()
+        self.assertEqual(result, "Hunters have won the hunting of the century")
+
+    def testShowStatusGhostsWin(self):
+        ghostbusters = GhostBusters([], ["Hunter1", "Hunter2"])
+        result = ghostbusters.showStatus()
+        self.assertEqual(result, "Ghosts have possessed the bodies of hunters")
+
+    def testShowStatusStillFighting(self):
+        ghostbusters = GhostBusters(["Hunter1", "Hunter2"], ["Ghost1", "Ghost2"])
+        result = ghostbusters.showStatus()
+        self.assertEqual(result, "Hunters and Ghosts are still in the thick of battle!!")
+
+class TestHunters(unittest.TestCase):
+    def testReceiveDamage(self):
+        hunter = Hunters("Hunter1", 100, 50)
+        result = hunter.receiveDamage(30)
+        self.assertEqual(result, "Hunter1 has received 30 points of damage")
+
+    def testBattleCry(self):
+        hunter = Hunters("Hunter1", 100, 50)
+        result = hunter.battleCry()
+        self.assertEqual(result, "For Glory and Victory!")
+
+class TestGhosts(unittest.TestCase):
+    def testReceiveDamage(self):
+        ghost = Ghosts("Ghost1", 100, 50)
+        result = ghost.receiveDamage(30)
+        self.assertEqual(result, "Ghost1 has received 30 points of damage")
+
+    def testBattleCry(self):
+        ghost = Ghosts("Ghost1", 100, 50)
+        result = ghost.battleCry()
+        self.assertEqual(result, "No Mercy, No Regrets!")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/GhostBuster/GhostBuster.py b/GhostBuster/GhostBuster.py
new file mode 100644
index 0000000..9c30822
--- /dev/null
+++ b/GhostBuster/GhostBuster.py
@@ -0,0 +1,118 @@
+# %%
+import random as rd
+
+names = ["aída", "Amir", "ana","bego","claudia","Edward", "Emma", "Esther", "Leon", "Junior", "Lucia", "Maira", "Marc", "Marco", "Marta", "Miquel", "Noemi", "Patricia", "Pati", "Ricardo", "Sara", "Uri", "Victor", "Xavier"]
+
+rd.shuffle(names)
+
+division_team = int(len(names) / 2)
+
+team_hunter = names[:division_team]
+
+team_ghost = names[division_team:]
+
+
+class Soldier:
+    
+    def __init__(self, health, strength):
+        
+        self.health = health
+        self.strength = strength
+        
+    def attack(self):
+        return self.strength
+    
+    def receiveDamage(self, damage):
+        self.health -= damage
+        
+
+ ## TEAM 1 ##
+
+class Hunters(Soldier):
+    
+    def __init__(self, name_team1, health, strength):
+        
+        super().__init__(health, strength)
+        self.name_team1 = name_team1
+        
+    def receiveDamage(self, damage):
+        self.health -= damage
+        if self.health > 0:
+            return "{} has received {} points of damage".format(self.name_team1, damage)
+        else: 
+            return "{} has died in act of combat".format(self.name_team1)
+        
+    def battleCry(self):
+        return "For Glory and Victory!"
+    
+    
+class Ghosts(Soldier):
+    
+    def __init__(self, name_team2, health, strength):
+        
+        super().__init__(health, strength)
+        self.name_team2 = name_team2
+    
+    def receiveDamage(self, damage):
+        self.health -= damage
+        if self.health > 0:
+            return "{} has received {} points of damage".format(self.name_team2, damage)
+        else:
+            return "{} has died in combat".format(self.name_team2)
+    
+    def battleCry(self):
+        return "No Mercy, No Regrets!"
+    
+    
+        
+class GhostBusters(Soldier):
+    
+    def __init__(self, team_hunter, team_ghost):
+        self.hunting_squad = team_hunter
+        self.ghost_squad = team_ghost
+
+    def hunterAttack(self):
+        if not self.ghost_squad:
+            return "There are no ghosts left to attack."
+        
+        random_hunter = rd.choice(self.hunting_squad)
+        random_ghost = rd.choice(self.ghost_squad)
+        
+        damage = random_hunter.attack()
+        result = random_ghost.receiveDamage(damage)
+        
+        if random_ghost.health <= 0:
+            self.ghost_squad.remove(random_ghost)
+        
+        return result
+
+    def ghostAttack(self):
+        if not self.hunting_squad:
+            return "There are no hunters left to possess."
+        
+        random_ghost = rd.choice(self.ghost_squad)
+        random_hunter = rd.choice(self.hunting_squad)
+        
+        damage = random_ghost.attack()
+        result = random_hunter.receiveDamage(damage)
+        
+        if random_hunter.health <= 0:
+            self.hunting_squad.remove(random_hunter)
+        
+        return result
+
+    def showStatus(self):
+        
+        if not self.ghost_squad:
+            return "Hunters have won the hunting of the century"
+        
+        elif not self.hunting_squad:
+            return "Ghosts have possessed the bodies of hunters"
+        
+        else:
+            return "Hunters and Ghosts are still in the thick of battle!!"
+
+        
+
+
+
diff --git a/GhostBuster/__pycache__/GhostBuster.cpython-311.pyc b/GhostBuster/__pycache__/GhostBuster.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2c4ea15dd3679957281720d853f5a4711aba2f8
GIT binary patch
literal 5768
zcmeGgO>Y#*wYq1fJ)RHjPGdZ<VA}YL!NAI35*9Xm7?uwMlU*DZVmX;K-EF&JW}2<;
zG3$wud|<Vch=W(!2o5<|9LORRDTf?#h@wcz516q=venW`mLe4GZIC%cobq1vbbH2Q
zXM^?-MN0Mbo2q(Muc}_X&;D&Z9wAU7e;(BT5hLX9*ziiIR#|%kmB&OQ8kZsC+!WFH
zr`$Nt6P>#g@CNJrGmelK@VbQ~fDghO+KABtg(xA7qsIlE*En7HjNj=IAmc4MuL~O2
z&==;(MWO{C5-s$MhxOof%Xllp2!LtPTc5$cUif<(k1$*qaIH<aD8oen7j44DG;WL}
zW8dHssbnIL98v!IJ56zdXR`)%0!j|5xAiI0X;CvuUNaO&_&~d_P|XQ`kj-MtvZr<G
z1h495&JjlQIm4t*=xSbtp`mMvL4m+Eg{s(~s>%Lrn0L+iB(G<jP|DP^h7<l!v8jP`
zf>1M@mg|NJi<nMuOaTgk8`N-wj}6rZ;=(Ou#?a|E$Ql)Q?iKHD)@0~;Omw(Qjf?}|
zACmEa#sds$0e~Sb2&WD?En{Xz14^pTNSKFIvAwpB5t-xWNE&Kxnd715Edv5GMxJx2
zB<~2*x{|S{ov>w7JvU`fCj(B<(le8EFHEE|01JuAvi#<fdSc>+rBiF-f}Sxxoj7l*
z`K+F^t%(uSv{fa0Zz7}IJ~U(8HF8td#KmdTvPbfkt<(DY;d`@AIGr|fhMi6q+G{5{
z?DdGa;&uS@WOc{xV(?LPB_YFKya>-4^b^%T1~jnF4&4rw$7GJ&fq%D*5!wZ{B*#wi
zoTJ^)vT%Y-kwuQ6*tVkHEo}4l;I?<*Fx0(yveG6!dQb}QroGTqk-=WUHQBoTP{DOS
z<<?i8;|iTPex3cuaBnxr*ylXkjU#AER+-W*BrVsr6{otY8#DTOhAMP;yKCr1Wwdao
zu*q<&7=097m??+%V5JBT+i)r=Ag6OmR!^s$NIIQ0wR{Hav2^;AypnM-v<Jx00R)2p
zo)b2iv54-*UIcCMT4w>w`%g6(2z6J94<cM>PnGyU;6h#4+z4FiNK=K^FCKH(4nWuE
zbxKeqlN=~QxKR;`!0>Salp*M}T*~J_#w<1H6C(uc?0&|f@@wufvGL+-<r)0H@ET;X
z4&!$cP?$iY9pea7DQ}}piQGF4I3X*4Pp6ENPK2@5)|Ko~GQ_T#4g=kFg>qWcX|PF_
zl}=k|w?Mb#d6(aK6@~WNfqb3lhTgUP0RA~oUWVhpY<bkO98N5S6Hj(5Cd%OhmGFU5
z_`u4pUeJ@aB0SCV>ht3%kok6bt=A)syURFB-_iIjct!5`T$$q<xi&_$z_-t8^f`E~
zDT*ZD^!(z1Jgr!AP53n#+V@NYjE-zh%C7blcGm`hNz`N`Co8IrSk=tlR_tVeao!Oo
zO_~K;&F&%zwCk0QNq(WjV|;_Ep@v&m0W_=HO0@0K$tU8kP8UzFNXM6@(@WCnzXbo*
zR{H2>S-Mq`Zk1xUR;8h3>G+a#{EyrJw6`o>u1J?lvCHla)k_}MnZycE0iTZkjZYPJ
zTrjD8F=NtMS;=X#>q%z2>ANtBvaR97n(1hT^V%8x9GxwQ-dX&vLom(?13<erP-+`s
zdwAYL4<aeV(!&T)1{pu-NvJvTny{*RCX-Hs89fHQ%#5CKWp)V1BS6Du{R9ArsrR6f
z=tCpX1R|l(C|4zQa2prej}~KV;MxvcONG}jp76cB?GTug`fr*JdK8Ya(Qq8`495r}
zeNXJNelwHN=AOg17>wxmadIz!2G13Q4kl+$q4K|D3FvXyZlPm?rZ=cKeGi6E#<I=z
zdwY#b4eE__zms|&SeAyCq@myU{^8xSG*Xd9O0kjuSiL(^rhE+ox!Hp<)UNAORJX0o
zwVSD9p}lqnU#(B${ynwsFSYf%O7cGP;uPZ0KGan840a+w6?!XGJ;zklhoGthsH$57
zcNe%;gQ|KKZw*b?zmIew-W9YESV6&wu|vDDr1f2bUe{mqPJ9|-28dGA7Q{iC6P?0X
z)op;k=!U&HQS{(x90y54gf-YG3zY{vcAdlSsNbHigBM_&l>h+tcF+D|uoB+2@=hQA
zCra$sEF?&p>1G1>)ELcLkPVCx8?m)g=X1$=w%6!MA8=dF@W^b)_a5+b+#=eDrt%DW
z)}y8efjNHB%R?K+LfizqU(Yum1n2lWf;U9t?=l&nyXs?%#TE}=|3BB1xz1t!6G#<$
zehjIbE-UcnOxe8`IipY7vTe$47=M@r5XmsT3?v;M@;*VGHVsv$m!M-k-mOIkRL`0-
zdd==SaSG1X^shfwYqEtXMyQTJbt|8-{Q$1!fn%<~oOLscoehFfj~WFU)@K0F8B3M6
zy`W94??Dhzl8(Pj?D|dXVsB;Na5-_Tk~mh3f8DwB%h|>4mF}T(=aEY1kz#CB>{=H4
zmc+iYI8YG>io%MxXIUIv5(mG!P!^9?#G^%FHQHH;b}e=<MSDuoo|Ra8CANDx*0U7r
zS-e_~4OL=8rP$DFTSqbee@TR!aLe0DVqb$Kx>s!ZqIl1=EZwqvS!AMj4OXHl1Spyt
zB$56I`aJjl5#m2YfHFs~1K22VuIZ}DTcSbUn6$bWjLPc84e~aw_2i0lq9mPo*(6+F
zHwoY>N>}fa*jpC+D`G#28_3_mCGp@_AD6}9ia3nomZ(JcE)Fe4drQ$?CT?BJvA(5P
z-(t2L8?MBLOR?cC#0^aXGkkc?%?uwH3uZO|O~4fLm{zbfp)h#KP5&TGn9=3?W=@9B
zIx=1a*mq0=u&KgliabQcgN#9zJGOQ?kTc+r+a{zBEUTzpV&Rxa83XUyM6@`TZDcZ-
zXW%q@+EDM}GOk1J?oRUVwX&;5FUK5k%{)Y`Y4iS=t=M_1(AjWV>xgNbgW)}V0jZgW
zmewoWigczVommw-Dq>HS1pS_>K(=4uO42A(;#6|;czz7%(HjVEB4F7=FV^-UKv%`U
zd8k-8Y~FvWK|a)9B|ZqpLp!R(2VH)R^>wv|u0W`;Ido$JTr3#}1IkP+MQw0Gm@`{W
zi#45}oXqG>05Uu$kkNBaTr*}2%P@0kbiowuCcT0HzaX%*g9SA15gL#6Cj7qp#p4wH
z84O1GvGxP31~`seB~r=zRfDAU=Yc9&hx4IT5}D^8MvBMEM63|8M8ws0X(6z1ZsFXM
z&=;d$jxLH{q{{6*mG++b`06%kA+_++g;Zr*&wO+>{=J1CE}U98Rf+GLk5q*y2j4)N
z!7J>0y^fIEILLgOL2>F8_P$<6^|o;kcr}CKO&mFZBWw8nLmXbm=5XN$uNda_7I=1D
F{{nY=zbOC!

literal 0
HcmV?d00001

diff --git a/__pycache__/GhostBuster.cpython-311.pyc b/__pycache__/GhostBuster.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3d18fe0967d055e717b6c17edf06e763b0d7bf8
GIT binary patch
literal 5100
zcmeHK&2JmW6`x%$KO~Zt)@xa`6Wc3MAEsqHkS#Zko%l=slx?<&>cnMLu<PBGv^L3g
zW|wlr%76|w!WKR#KnnZN1L1=k!zj>04?W~ip#1|#VgU&Y1RzlOkfH|$%AxS7@6D1F
zY1wUq7AOjIq<x&3_vX#V`@J`BejSZ=6Daq;9Mk_2Cgji9Xcm8?vi?`7JR};?xD3g1
zDUQQBpW#!!IimR<b18u*y6<LFp6J38j*w^Yd4(gu55O0EnWG5>n6*<n719Nb*F*RD
z9Zdx!)uju1NaH*Dx_NSeX#RUd3+UVvAIu1!S5jfd3j!~+i5FqKF5q=<;zc!nnk2$s
zqnZTg2B*!8X6Q7Th~;s6${&BDDXwrjYf#sx<e+*(pEKQ{no;tap}2u_+8u>zu5d1!
z#g=8y>(mvl=w{9hOyzTiNnQVyyb7ZJtBOHE!BvH-*r2M(ery<b)%ZBCXIy{M)U$>g
z`hj9o1IGwZGu+?@h6<CIt}v~D2H!PmxPcE1)duB(>&gPG_iG*&tKue_1v{{;?*sBF
zm{TVyP9rJ4NM<>WyBA9NH2xk*37QY6zeqmeQUN#$!3|!_=WLx?s=yR@1nYR(>nR|=
z<Q@{cWo@u0^gV;mE2TD0vyYG^e#!R)7WJ&TFv5`~Zi%E@ZH-Kmr(81ObNyESHXLIp
zoi=iYold*mIVG#7ZC%NZC;YBp>6uwN2)f<Cysl*Ic{gO)RL{*ptt*`d<5*TYZJ_~W
zD9bP2RgcYFvtUm%=k<*7$;??(&1dzTZOxo9O<Ps6w`VfSjROnDEh9H)&0Lr_E&EK~
zf>Stndyx)+o<eWqR1P*5wGDdL_X7FbGI<_~{yg{~xEhL8L$OEOOR-95pA*_w4((gp
zIaCxL^c3N59b}2x+AcI&hx!;A56KeP;3f*OvcwhoQ9j-50R9G7<8CqY&^I*xH3v>^
zw&q&mI*)!D-1wi5>U2}YMv|h+7xACnmFE>prn;&d3%Vvl`?hJodCKOjtSMP#PA|OK
z5CV77WFsdls*POL%-&G!gpUq^CO0r^(k!5T5E@T;8fSf;0t=^-Wjcy|(Z*C~J>7jx
zV{~+5_^_@3Ste_tNHP2%ys}UU?ZV1hxaYy~N8&F|7Ei88M^~kjRq5m(gg^C^-~Xs0
zU3aAG<;eA#G`=bwtx89KzwOIC73q>AT`ET|(F7<|+aZm0<_ZC*K$zs<WcXxZ`+1Yf
z7cwSYl$D$&d;YmN@Dwo3_GRI?#&){k2<(hLNf!%Zb1SVb8RV=G5ZFe~Xt`&UE#YYp
z{ek%b_(M9KHMM+32j7UK(;w%RjK^VErEkGtdKicsZFqyKXENzDtYie0<4R7kgQdGr
z6v<X({0IoZx%pQYeE#7&c?IeA`=_`%X`@>>|K2+JM}%#I&GjD&Q~~Cv|CKmJ_rOU3
zh-LU;XWkZ~4ki4|;PgFYBFyP95_a^hnB*P*05A$Y-acB91qCTa77u$ZFNPigK8C%=
zQ2F197<3GlTj+Z!B6NfTx*tTmBRc@KcJF6+E^KR@Qisc<-ha#G_pM6fRcZXUL%(~g
zBAs!hGv&ycf7#{xlBRrBr|RN<8EPNsb5ysj0XmL5IfN_QaCzpAh2F*<TE5Ptn!Y|#
z?iul%WCAt3)6~##)#KQS1R?dETy>JUYKwxaj-so+o_MRkxjI}Gw}WLJ5xS94KsG@-
zvk6Uro`B|u$QW=VY}4L#YN?3cW<g{#G!H@r(2VIolZOcdNjGPN1az8sPRF~^c}P&;
zqE1^7_%t^>hu5{&0GEt|1~-hkLK@{DkLYF%CS~DtkP@_cUtjz3T0Y1QKL)}Ogm>*N
z3QlO}+8e|88!NN_%^*S5Y&S7jHTvepZEf**OW4S5l(xH>+-&uC-ne(U*N$kac`22?
z%P(;yj1im46X@AU(eC<|_!5SqO$CxPSp7ySe^*%IZw8uT8h?vfgzjwLT`Ab)xBo8j
zothxs695msWFh`TNRo9~fiGvuo?YaOK5NUiDZ|C6sJ9NXL?aQRXF;XQLxvqt=S@S^
z=_GapJSp#@Lw9fkRL`0VdL#5gz5sWy*+M|1(PVScgN*@JK4Z6%#Kz4W@i23mt)j4_
z0~_rujP2HaAb3ejPR|~2sIGS)w<t?TpT~Cos;e~Q3{F&HN1WJ^V)U#29iK0jwmAdi
zmHtCc|Dj@}ChlGphpXanMI3d+(PCgt+_fr>RmHI{&R4|4j(E5jsD=BT@b1z;H5@O8
z<7<&#C-UZMBwmfgOIIq9aVIifj*QoO`ijy2gApv@mG271;SMl*Cbn8=ylq;RZdolj
zBKqh>B$tpNI_VS=mU1By>180z4B#quU`EO?N0U%{8E{_oYTzx_fj5R$kAphe;WmJ9
zJH93zD@(_oZvxj>n*dltbPZL-p^7--h$9F$z~BC=xc`d}E8>JBP9WT3PIymgyc!-V
zhld#4cCSW;tC8VSwi20eA`|7v#B1P&Q30bEdu_fd_CdU0kppDlZpTNr=3_64!q`Rc
zxd|_d1zo;l=45z7%V-D)@%UoErV5X>JY>sb?0_s!wqYE2UZBVg6J8qZ0n#vH;Yd?6
z=Hrcl7<4S#$Yk(Ig2U{2L%oI5cz5!^K!W$o%1r&zE$(((^X8ptTe0(2p})ge8;l?0
z77-82q}B)x!LG~PnsllxovMj_ju@{Kq196lkZqT_vNXk<IGG62BQTbJ56Rm|29SIo
z$@@sAk+2j4Unbr~b{cC)aDa6U$a3qiF7W=5I%$zm)W5w>T4Z;t#`<=5`7cAZ@M`L%
z1vpP)i@T-qTAsw$wr){0KZIcxcbSX0eteTyZqS;~&(3Ca*9R{|*O$?AZd5ZC49hTc
z>`hP4!BBc0344yPM2BsubDJ+h?|QGE6BN&wgU{LuwC>|Lu0{sSo&Pl=m7D){fpq=U
zS0@{E*<T~w%ly6W;*kmw9U_*ASnHKmd@GYHlaKtLO?^I95<g2;dgD%Sd^uX%BCRA>
zezKBuw#1jiwdmHB_f}4<oN%Ip%iZ-*4+n3b&7?T@4fcM!!5Zq}AnV#piXWlmC`vZ?
WBL_G%#H;Db+utzGx3A$dL;W2TTUOHm

literal 0
HcmV?d00001

diff --git a/__pycache__/file.cpython-311.pyc b/__pycache__/file.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..036e165155779e26e7552729f898fa0e4e072662
GIT binary patch
literal 4859
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
G+3fG?(F{=l

literal 0
HcmV?d00001

diff --git a/__pycache__/vikingsClasses.cpython-311.pyc b/__pycache__/vikingsClasses.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66506b9edfc4046004a9295e3d7153fdb2761d97
GIT binary patch
literal 5235
zcmeHLO>7&-6`m!z<WgLTlxe9lZ6zx?akVleTR%-3>#vH1$WZ|qjnV`a)DUa#N}@!O
z&g@FI7D}r_fU<=SMd3mMiU35Bs4{%<A-U(6-bjIfgarx+=qWcE@}cml@6G;@6y?SR
zdg!6E<lC9|W@p~K`QDqi``6~?CIV%m(yMhs?H|~13-44;O{nY=m8e{X%yT|6O;q1!
zMD_3c2zdg3yUhETBmfd#^X>aV27gE9XR;v3LJhJ2lL;UTpBa%?xj7;?eTRe0rkt_Z
zjdL2O5>$4H270Mv-luY(k$FFAHy=>_KzTI)Bk)#eE|*c$8clgB!E>lOwokj+AY0rP
zNkYvoTRv#H)4<~A$YX9+_F2JYP01L`mY^F{%Ptwqvfm2mT4s@k;6W+?(Q!~ol3q;Q
zzP0cRU8DNKyILmwaA7K!T3^$$hQ9DlE@z~awfhSh<zC-LdNrM0(ifcj?Tn)9n%;kZ
z(-M-&bT(}ylV;3WK)=huebX-j*(N9LSMq_K$Z>}Rx8^)tr@$vEPkU%!ovk$nm0hw$
zR^V=zIYNU_lR2jRV~&QQrQ-t<#aXPNVi-zl)ogKfu-j4Wh8?!aaWua3X;HXBMQElx
zNI(PUWb<Bw3eNkGtIoW|nLoh(RjZ?&nKqyX+VioGX=4RdWldSqbR1f8)M}<$N=t8O
zQ%q#Gx!TpSFTewOI}lJ(5c83p$R9RJLMK-8a505v<se!*tE_3sq}7y6uI1GA4A#YD
z@{@HXV@qfRhM~A>igtfY*u%_3G=N+rZ2u>rvh7`!fS>QG5RWu*d}oDtB*^ivVe>4p
zN5?T!@b`*q+|yoQ{k8`Cd9ug>{)Kw{=fU9fLGXcq75tFlEQLe51?y~k=ArT@ZkHG}
zpxFoB6SpTR)JQxg0XI1l2ROnU$<>p&jtwxs#p~<$HOdTW1<<N8&-Ryg!iZG|vckz^
z3cVni)G-QyFG<_Bp>Yq)sJ#-;7cK)+?*a19ZSr@a`FEk6(2>w_D0J+#7dlEpZ&~Oq
z3cbe{JHS7}dAJ&J>KS4YhWUP+*7}ditum9+X5e~8`ZEN{Ee@#va|l6aB!SO;7?x%!
zTFGpYmK9xcV5>?mTBZBBG(-t0w<y`THxsN2L@-rKXC)<Npe&VJyQdhk&o&%0A%lC3
zlQ5*37ae=mdB*E#v}quXo^c$B?u_iU{(d4qaonDGlrF~a!0%wgz9SXyoY;bqVx0ZN
z5!<HT`e9(KGjL&efdd4Cxo_6Ia94#j+<lPMrC;XOrO8aDi*`T{+5)6D?u21=Mn=0$
zH_e!{0*`~?L`P@C;B&PYy~?JSL$nP?LWidiT8Qnl=&rOIh}G->E2U*J$s~ll*MQ6B
z{Hcwv1a?Jo2?ZYl0Zh49CE(*PRmeF+;Q7%C@kk5Dzkxpea$<WoPE_aJuK7+;<;HUj
z3<yp%r##GM&yTWq*kj)pWzR)#(8H^Lj@ZYhgU_}}iA`A#Q!2q+W};T+;?o8uZG{f>
zd_>0Cfc<rVyb0a)VIcn=knyR5w~Fy8=O<2`#BUbGo6MfGa^UR#v#n?7!lTLF<2SK}
zq#yqJRUqyLZ<9)Z=Lc{n&k}pX@Tv1RY!D=k8&;c$Ks~7PKtn1dLi2(eg6$M6|3?a~
zJF3xrncE;@cgYe2kLm%*S}sazVyn+;+F;>*lCEu9VI3iY)w52;9KsY~PA__n!8A@L
zah$+RB6@u3GTd77aIs~dk2MUqjgfMRGn-#>rh~iTp#=d8GYqTA_UUBq-b&rM9#&M<
z7Mabcr`McBMR6}}fJAqqdoz2ZCE<s8sOI7NFDrY!M%gd}Y=f=>D90qWN!`{|y{0WY
zEqib8T`vi5=Al|OtGAEP9kU&_>wg4peS&5n-zh7I4pvmoz-OFN>(cu$!V_<7)n`JI
zR-aj8aI?#&ko2wu+}113<n{lLW`g5z1y6HUwtNLV6&lJuaH=`SDq96j)UK{jv+C;O
zTU@;^n1vMZd}t`IHgo-Gko^1YVE7$sB!?+t!}3wp3Q;8s=b2&oGg_A6+dhslPqczm
zTgz=|>=c&$4(yq4Ch;*VV*4y>xNi+CMp>fc&35J;LqDkH;JK~;1qir8+oeYzfBDWA
zGY6l19e?`4S09%Krpg0T-~7BZ@NVgi=`#G<?&O>BAkTey?~9eEtzQp4HNN^yX=u7U
zH2p1C8hWpEZKe#r_Mhb=6@iHD<;ayn<VYGklm<)Ea9J8Yj0_he!^dK5XZA?!IuyGK
zy(O`)EcO+}zLQwuDAscr>p8f5B##`*BPDsPERU69<K@_RQ5d(K(t{)D{C}u}5x^zk
z|Gx-zIs}RV#4%RWA0c@Q$&ZmB?5p^uKfxv*u@1QDEo8h6q#n%?`#iG297QnKFh0QU
z1t5UsR|DxQLjEKINbW2oj=Ba9y9P^L!{x3TB;P#}yAQ?g!bnNHQ5J6$#TzHl#8I^8
zFxqpFIFfH2%C}1LXjvXDMaRm~v7#{6h-5@H3)*O_`k<}D$B6p8A2^WptB_sEfmyT1
zKH_vpsx~y~K`tv9%WzjHX7*T3!H0r%y4hupu>;2GxR_gCS~jG`9K}v)DrMjeSeGD}
zNcuY6fCkiaAfoW<u-V_=Zw|W?VIOBGg=&&+q%#?Oo50D8<#cKlXSNgUemJAqRx=Eo
z&C8qg<=lfgLowEMvxRM@*ZvjQLGNRGc>>=AeqAA<@C<hxA1lVkPFmX@y<Q;!#(2LN
zf4>qW7iYL){5@vaS%BPm$vY-#bO6Z+63kZU1d=mZ9i}4`33k(UAlu%BiTf2y+#Mot
zd=KX54uMzjYuI#1Fw9R>h({73ejL`}k_%yehC}grl&yqm0pApY7~^wmwhskRJ@$6N
z(od#s{R&<PqxOe~aXJZ|5nKA-fK>b($DNRP(fw7#2nSya8p$){J+BJ7TR3<FX(aiN
no+0;nRn!~eAmME!`RQlKeO?tMu5-BX^XW6jfBq6FGtR#NCXWh-

literal 0
HcmV?d00001