Created
September 4, 2013 03:26
-
-
Save Aurenos/6432456 to your computer and use it in GitHub Desktop.
A little Final Fantasy inspired text-based battle I built back in '09.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import random | |
| class User: #The User | |
| # Basic Stats | |
| name = "Spero" | |
| maxhp = random.randint(8000,9999) | |
| hp = maxhp | |
| maxmp = random.randint(380,550) | |
| mp = maxmp | |
| evasion = random.randint(10,20) | |
| strength = random.randint(100,255) | |
| magic = random.randint(100,255) | |
| overdriveTech = "" | |
| # Current Conditions | |
| overdrive = 0 | |
| multcast = False | |
| benefit = [] #This and status are used only for display on the menu | |
| status = [] | |
| defend = 1 | |
| #Possible Status Ailments -each lasts a limited amount of turns | |
| #Each of the follwing variables that have 'ct' at the end | |
| #is a the countdown until that particular status or benefit is removed | |
| #If the ct variable is equal to 0, then the corresponding status or | |
| #benefit should be False. | |
| poison = False | |
| poisonct = 0 | |
| poisoneffect = False | |
| confuse = False | |
| confusect = 0 | |
| paralysis = False | |
| paralysisct = 0 | |
| mute = False | |
| mutect = 0 | |
| berserk = False | |
| berserkct = 0 | |
| berserkBonus = 1.5 | |
| #Items | |
| potion = 3 | |
| ether = 3 | |
| elixir = 1 | |
| remedy = 2 | |
| #Benefits | |
| astra = False | |
| astract = 0 | |
| barrier = 1 | |
| barrierct = 0 | |
| regen = False | |
| regenct = 0 | |
| rheal = False | |
| class Bahamut: #If user chooses "Summon Bahamut" as Overdrive | |
| summoned = False | |
| #Basic Stats | |
| maxhp = random.randint(14000,16250) | |
| hp = maxhp | |
| maxmp = random.randint(400,530) | |
| mp = maxmp | |
| strength = random.randint(180,255) | |
| magic = random.randint(180,255) | |
| evasion = random.randint(15,25) | |
| overdriveTech = "Exa Flare" | |
| #Current Conditions | |
| overdrive = 0 | |
| cooldown = False | |
| defend = 1 | |
| barrier = 1 #This is here only to satisfy the calculation for Abaddon's dmg | |
| class BlackMagic: | |
| def flare(self): | |
| weakBonus = 1 | |
| print "You cast Flare on Abaddon!" | |
| if Abaddon.weakness == "Fire": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.magic*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Ice": | |
| print "Abaddon absorbs your spell!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| Abaddon.hp += dmg | |
| if Abaddon.hp > Abaddon.maxhp: | |
| Abaddon.hp = Abaddon.maxhp | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| else: | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| def blizzard(self): | |
| weakBonus = 1 | |
| print "You cast Blizzard on Abaddon!" | |
| if Abaddon.weakness == "Ice": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.magic*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Fire": | |
| print "Abaddon absorbs your spell!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| Abaddon.hp += dmg | |
| if Abaddon.hp > Abaddon.maxhp: | |
| Abaddon.hp = Abaddon.maxhp | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| else: | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| def bolt(self): | |
| weakBonus = 1 | |
| print "You cast Bolt on Abaddon!" | |
| if Abaddon.weakness == "Lightning": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.magic*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Water": | |
| print "Abaddon absorbs your spell!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| Abaddon.hp += dmg | |
| if Abaddon.hp > Abaddon.maxhp: | |
| Abaddon.hp = Abaddon.maxhp | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| else: | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| def water(self): | |
| weakBonus = 1 | |
| print "You cast Water on Abaddon!" | |
| if Abaddon.weakness == "Water": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.magic*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Lightning": | |
| print "Abaddon absorbs your spell!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| Abaddon.hp += dmg | |
| if Abaddon.hp > Abaddon.maxhp: | |
| Abaddon.hp = Abaddon.maxhp | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| else: | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 30 | |
| return abaddonTurn() | |
| def bio(self): | |
| poison = random.randint(1,100) | |
| dmg = int(random.randint(30,35)*Player.magic) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| print "You cast Bio on Abaddon!" | |
| print "Abaddon takes",dmg,"damage!" | |
| if poison <= 40: | |
| print "Abaddon is poisoned!" | |
| Abaddon.poison = True | |
| Abaddon.poisonct = 10 | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| if not Player.multcast: | |
| Player.mp -= 35 | |
| return abaddonTurn() | |
| def drain(self): | |
| drain = random.randint(1,50) | |
| Player.mp -= 50 | |
| if drain >= 51: | |
| print "Your attempt to Drain Abaddon fails!" | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| dmg = random.randint(5,10)*Player.magic | |
| if dmg > 9999: | |
| dmg = 9999 | |
| print "You cast Drain on Abaddon!" | |
| print "Abaddon takes",dmg,"damage!" | |
| print "You regain",dmg,"HP!" | |
| Player.hp += dmg | |
| if Player.hp > Player.maxhp: | |
| Player.hp = Player.maxhp | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| def mpAbsorb(self): | |
| if Abaddon.mp <= 0: | |
| print "Abaddon has no MP left" | |
| raw_input("") | |
| return abaddonTurn() | |
| dmg = random.randint(5,10)*int(Player.magic/6) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| print "You cast MP Absorb on Abaddon!" | |
| print "Abaddon takes",dmg,"MP damage!" | |
| print "You regain",dmg,"MP!" | |
| Player.mp += dmg | |
| if Player.mp > Player.maxmp: | |
| Player.mp = Player.maxmp | |
| Abaddon.mp -= dmg | |
| if Abaddon.mp < 0: | |
| Abaddon.mp = 0 | |
| raw_input("") | |
| return abaddonTurn() | |
| class WhiteMagic: | |
| def cure(self): | |
| restore = random.randint(20,25)*Player.magic | |
| if restore > 9999: | |
| restore = 9999 | |
| print "You cast Cure!" | |
| print "You regain",restore,"HP!" | |
| Player.hp += restore | |
| if Player.hp > Player.maxhp: | |
| Player.hp = Player.maxhp | |
| Player.mp -= 25 | |
| raw_input("") | |
| return abaddonTurn() | |
| def panacea(self): | |
| print "You cast Panacea!" | |
| Player.mp -= 20 | |
| if Player.poison: | |
| print "You are cured of your poison!" | |
| Player.poisonct = 0 | |
| Player.poison = False | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| print "The spell has no effect." | |
| raw_input("") | |
| return abaddonTurn() | |
| def astra(self): | |
| print "You cast Astra!" | |
| Player.mp -= 35 | |
| if Player.astra: | |
| print "Astra is already in effect." | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| print "You are now protected from receiving to two status ailments!" | |
| Player.astra = True | |
| Player.astract = 2 | |
| Player.benefit.append("Astra") | |
| raw_input("") | |
| return abaddonTurn() | |
| def regen(self): | |
| print "You cast Regen!" | |
| Player.mp -= 40 | |
| if Player.regen: | |
| print "Regen is already in effect." | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| print "You will now temporarily heal HP every turn!" | |
| Player.regen = True | |
| Player.regenct = 10 | |
| Player.benefit.append("Regen") | |
| raw_input("") | |
| return abaddonTurn() | |
| def barrier(self): | |
| print "You cast Barrier!" | |
| Player.mp -= 50 | |
| if Player.barrier != 1: | |
| print "Barrier is already in effect." | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| print "You will temporarily receive less damage!" | |
| Player.barrier = 0.5 | |
| Player.barrierct = 10 | |
| Player.benefit.append("Barrier") | |
| raw_input("") | |
| return abaddonTurn() | |
| class Skills: | |
| def lionHeart(self): | |
| print "You attack with Lion Heart!" | |
| evade = random.randint(1,100) | |
| if evade <= Abaddon.evasion: | |
| print "Abaddon evades your attack" | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| dmg = int(0.25*(random.randint(30,40)*Player.strength)) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| print "Abaddon takes",dmg,"damage!" | |
| print "You regain",dmg,"HP!" | |
| Player.hp += dmg | |
| if Player.hp > Player.maxhp: | |
| Player.hp = Player.maxhp | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| def deathBlow(self): | |
| print "You attack with Death Blow!" | |
| evade = random.randint(1,100) | |
| if evade <= (Abaddon.evasion+40): | |
| print "Abaddon evades your attack" | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| dmg = int(random.randint(30,40)*Player.strength*1.5) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| def minusStrike(self): | |
| dmg = Player.maxhp - Player.hp | |
| print "You attack with Minus Strike!" | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| def steal(self): | |
| success = random.randint(1,120) | |
| if success <= 40: | |
| print "You theft was a failure." | |
| raw_input("") | |
| return abaddonTurn() | |
| if success >= 41 and success <= 70: | |
| print "You stole a Potion!" | |
| Player.potion += 1 | |
| raw_input("") | |
| return abaddonTurn() | |
| if success >= 71 and success <= 90: | |
| print "You stole an Ether!" | |
| Player.ether += 1 | |
| raw_input("") | |
| return abaddonTurn() | |
| if success >= 91 and success <= 100: | |
| print "You stole an Elixir!" | |
| Player.elixir += 1 | |
| raw_input("") | |
| return abaddonTurn() | |
| if success >= 101 and success <= 120: | |
| print "you stole a Remedy!" | |
| Player.remedy += 1 | |
| raw_input("") | |
| return abaddonTurn() | |
| def spellBlade(self): | |
| print "-"*35 | |
| print "1) Fire (30 MP)" | |
| print "2) Ice (30 MP)" | |
| print "3) Bolt (30 MP)" | |
| print "4) Water (30 MP)" | |
| print "0) RETURN" | |
| fusion = raw_input("What element to you want to use? ") | |
| if fusion == "1" and Player.mp < 30: | |
| print "~Insufficient MP~" | |
| raw_input("") | |
| return skills() | |
| elif fusion == "2" and Player.mp < 30: | |
| print "~Insufficient MP~" | |
| raw_input("") | |
| return skills() | |
| elif fusion == "3" and Player.mp < 30: | |
| print "~Insufficient MP~" | |
| raw_input("") | |
| return skills() | |
| elif fusion == "4" and Player.mp < 30: | |
| print "~Insufficient MP~" | |
| raw_input("") | |
| return skills() | |
| else: | |
| if fusion == "0": | |
| return skills() | |
| elif fusion == "1": | |
| Player.mp -= 30 | |
| weakBonus = 1 | |
| print "You attack with Fire Sword!" | |
| if Abaddon.weakness == "Fire": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.strength*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Ice": | |
| print "Abaddon absorbs your attack!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| raw_input("") | |
| return abaddonTurn() | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| elif fusion == "2": | |
| Player.mp -= 30 | |
| weakBonus = 1 | |
| print "You attack with Ice Sword!" | |
| if Abaddon.weakness == "Ice": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.strength*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Fire": | |
| print "Abaddon absorbs your attack!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| raw_input("") | |
| return abaddonTurn() | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| elif fusion == "3": | |
| Player.mp -= 30 | |
| weakBonus = 1 | |
| print "You attack with Bolt Sword!" | |
| if Abaddon.weakness == "Lightning": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.strength*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Water": | |
| print "Abaddon absorbs your attack!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| raw_input("") | |
| return abaddonTurn() | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| elif fusion == "4": | |
| Player.mp -= 30 | |
| weakBonus = 1 | |
| print "You attack with Water Sword!" | |
| if Abaddon.weakness == "Water": | |
| print "You hit Abaddon's weakness!" | |
| weakBonus = 1.5 | |
| dmg = int(random.randint(30,40)*Player.strength*weakBonus) | |
| if dmg > 9999: | |
| dmg = 9999 | |
| if Abaddon.weakness == "Lightning": | |
| print "Abaddon absorbs your attack!" | |
| print "Abaddon recovers",dmg,"HP!" | |
| raw_input("") | |
| return abaddonTurn() | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| return skills() | |
| class Overdrives: | |
| def omnislash(self): | |
| print "You unleash the power of OMNISLASH!!!" | |
| totaldmg = 0 | |
| for i in range(15): | |
| dmg = random.randint(30,40)*Player.strength | |
| if dmg > 9999: | |
| dmg = 9999 | |
| print "You attack and Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| totaldmg += dmg | |
| raw_input("") | |
| print "You deal a total of",totaldmg,"damage!!!" | |
| Player.overdrive = 0 | |
| raw_input("") | |
| return abaddonTurn() | |
| def multiCast(self): | |
| print "-"*35 | |
| print "1) Flare" | |
| print "2) Blizzard" | |
| print "3) Bolt" | |
| print "4) Water" | |
| print "5) Bio" | |
| print "0) RETURN" | |
| cast = raw_input("What will you cast? ") | |
| multiple = random.randint(10,15) | |
| if cast == "0": | |
| return playerMenu() | |
| elif cast == "1": | |
| Player.multcast = True | |
| for i in range(multiple): | |
| BLACK.flare() | |
| Player.multcast = False | |
| Player.overdrive = 0 | |
| return abaddonTurn() | |
| elif cast == "2": | |
| Player.multcast = True | |
| for i in range(multiple): | |
| BLACK.blizzard() | |
| Player.multcast = False | |
| Player.overdrive = 0 | |
| return abaddonTurn() | |
| elif cast == "3": | |
| Player.multcast = True | |
| for i in range(multiple): | |
| BLACK.bolt() | |
| Player.multcast = False | |
| Player.overdrive = 0 | |
| return abaddonTurn() | |
| elif cast == "4": | |
| Player.multcast = True | |
| for i in range(multiple): | |
| BLACK.water() | |
| Player.multcast = False | |
| Player.overdrive = 0 | |
| return abaddonTurn() | |
| elif cast == "5": | |
| Player.multcast = True | |
| for i in range(multiple): | |
| BLACK.bio() | |
| Player.multcast = False | |
| Player.overdrive = 0 | |
| return abaddonTurn() | |
| else: | |
| return skills() | |
| def fullHeal(self): | |
| print "You use Full-Heal!" | |
| print "Your HP and MP are fully restored!" | |
| Player.hp = Player.maxhp | |
| Player.mp = Player.maxmp | |
| Player.overdrive = 0 | |
| raw_input("") | |
| return abaddonTurn() | |
| def ultima(self): | |
| print "You unleash the power of ULTIMA!!!" | |
| totaldmg = 0 | |
| for i in range(15): | |
| dmg = random.randint(30,40)*Player.magic | |
| if dmg > 9999: | |
| dmg = 9999 | |
| print "You attack and Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| totaldmg += dmg | |
| raw_input("") | |
| print "You deal a total of",totaldmg,"damage!!!" | |
| Player.overdrive = 0 | |
| raw_input("") | |
| return abaddonTurn() | |
| def summonBahamut(self): | |
| if Bahamut.hp <= 0: | |
| print "Bahamut cannot be called because he is incapacitated." | |
| raw_input("") | |
| return playerMenu() | |
| else: | |
| print "You search within yourself and call forth Bahamut to fight for you!" | |
| raw_input("") | |
| Abaddon.target = Bahamut | |
| Bahamut.summoned = True | |
| Player.overdrive = 0 | |
| return bahamutMenu() | |
| class Abaddon: #The Enemy | |
| #Basic Stats | |
| maxhp = random.randint(480000,520000) | |
| hp = maxhp | |
| maxmp = random.randint(2500,3000) | |
| mp = maxmp | |
| evasion = random.randint(5,10) | |
| #Current Conditions | |
| overdrivect = 0 | |
| overdriveCharge = False | |
| overdriveCharging = False | |
| overdriveComplete = False | |
| weakness = "None" | |
| target = None | |
| doom = 300 | |
| # Status Ailments | |
| poison = False | |
| poisonct = 0 | |
| poisoneffect = False | |
| class ESkills: #Abaddon's Skills | |
| def demija(self): | |
| if Abaddon.mp < 50: | |
| return abaddonTurn() | |
| else: | |
| dmg = int(Abaddon.target.hp*0.75) | |
| print "Abaddon casts Demija!" | |
| print "Demija does",dmg,"damage!" | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| Abaddon.mp -= 50 | |
| raw_input("") | |
| def doomBlade(self): | |
| print "Abaddon uses Doom Blade!" | |
| print "Doom Blade does",Abaddon.doom,"damage!" | |
| Abaddon.target.hp -= Abaddon.doom | |
| Abaddon.target.overdrive += Abaddon.doom | |
| Abaddon.doom = Abaddon.doom*2 | |
| raw_input("") | |
| def elementShift(self): | |
| print "Abaddon uses Element Shift!" | |
| print "Abaddon has changed his elemental affinity!" | |
| elements = ["None","Fire","Ice","Lightning","Water","None"] | |
| Abaddon.weakness = random.choice(elements) | |
| raw_input("") | |
| def hitoawafukaseru(self): | |
| print "Abaddon uses Hitoawafukaseru!" | |
| print "A bright flash emanates from Abaddon's eyes!" | |
| if Bahamut.summoned: | |
| print "It has no effect on Bahamut." | |
| raw_input("") | |
| else: | |
| if Player.astra: | |
| print "Astra prevents paralysis!" | |
| Player.astract -= 1 | |
| raw_input("") | |
| else: | |
| print "You are now paralyzed!" | |
| Player.paralysis = True | |
| Player.paralysisct = 2 | |
| raw_input("") | |
| def megido(self): | |
| if Abaddon.mp < 75: | |
| return abaddonTurn() | |
| else: | |
| Abaddon.mp -= 75 | |
| dmg = random.randint(2000,2500) | |
| print "Abaddon casts Megido!" | |
| print "Megido does",dmg,"damage!" | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| raw_input("") | |
| def negative(self): | |
| print "Abaddon uses Negative!" | |
| print "HP and MP are switched!" | |
| switch = [Abaddon.target.hp,Abaddon.target.mp] | |
| Abaddon.target.hp = switch[1] | |
| Abaddon.target.mp = switch[0] | |
| if Abaddon.target.mp > Abaddon.target.maxmp: | |
| Abaddon.target.mp = Abaddon.target.maxmp | |
| raw_input("") | |
| def nova(self): | |
| if Abaddon.mp < 30: | |
| return abaddonTurn() | |
| else: | |
| dmg = random.randint(1500,2000) | |
| print "Abaddon casts Nova!" | |
| print "Nova does",dmg,"damage!" | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| Abaddon.mp -= 30 | |
| raw_input("") | |
| def plague(self): | |
| dmg = int(random.randint(500,620)*Abaddon.target.defend*Abaddon.target.barrier) | |
| print "Abaddon uses Plague!" | |
| print "Plague does",dmg,"damage!" | |
| if Bahamut.summoned: | |
| pass | |
| else: | |
| if Player.astra: | |
| print "Astra prevents poison!" | |
| Player.astract -= 1 | |
| else: | |
| print "You are now poisoned!" | |
| Player.poison = True | |
| Player.poisonct = 10 | |
| Player.status.append("Poison") | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| raw_input("") | |
| def roulette(self): | |
| print "Abaddon uses Roulette!" | |
| stat = ["HP","MP","HP1/2","MP1/2"] | |
| stop = random.choice(stat) | |
| raw_input("") | |
| if stop == "HP": | |
| print "Roulette lands on 'HP'!" | |
| print "HP is reduced to 1." | |
| Abaddon.target.hp = 1 | |
| elif stop == "MP": | |
| print "Roulette lands on 'MP'!" | |
| print "MP is reduced to 1." | |
| Abaddon.target.mp = 1 | |
| elif stop == "HP1/2": | |
| print "Roulette lands on 'HP1/2'!" | |
| print "Max HP is cut in half!" | |
| Abaddon.target.maxhp = int(Abaddon.target.maxhp/2) | |
| if Abaddon.target.hp > Abaddon.target.maxhp: | |
| Abaddon.target.hp = Abaddon.target.maxhp | |
| else: | |
| print "Roulette lands on 'MP1/2'!" | |
| print "Max MP is cut in half!" | |
| Abaddon.target.maxmp = int(Abaddon.target.maxmp/2) | |
| if Abaddon.target.mp > Abaddon.target.maxmp: | |
| Abaddon.target.mp = Abaddon.target.maxmp | |
| def sealVoice(self): | |
| print "Abaddon uses Seal Voice!" | |
| if Bahamut.summoned: | |
| print "It has no effect on Bahamut." | |
| raw_input("") | |
| else: | |
| if Player.astra: | |
| print "Astra prevents mute!" | |
| Player.astract -= 1 | |
| raw_input("") | |
| else: | |
| print "You are now Mute!" | |
| Player.mute = True | |
| Player.mutect = 5 | |
| Player.status.append("Mute") | |
| raw_input("") | |
| def supernova(self): | |
| if Abaddon.mp < 100: | |
| return abaddonTurn() | |
| else: | |
| dmg = random.randint(3200,3600) | |
| print "Abaddon casts Super Nova!" | |
| print "Super Nova does",dmg,"damage!" | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| Abaddon.mp -= 100 | |
| raw_input("") | |
| def thanatos(self): # Overdrive | |
| if Abaddon.hp <= int(int(Abaddon.maxhp*0.25)/2.0): | |
| print "-"*35 | |
| print "Abaddon's Overdrive is disrupted!" | |
| Abaddon.overdriveCharge = False | |
| Abaddon.overdriveComplete = True | |
| raw_input("") | |
| return playerMenu() | |
| else: | |
| if Abaddon.overdrivect > 0: | |
| print "-"*35 | |
| print "Abaddon is preparing to use his Overdrive!" | |
| print Abaddon.overdrivect,"turns left until the attack!" | |
| Abaddon.overdrivect -= 1 | |
| raw_input("") | |
| return playerMenu() | |
| else: | |
| print "-"*35 | |
| hpdmg = int(Abaddon.target.hp*0.99) | |
| mpdmg = int(Abaddon.target.mp*0.99) | |
| print "Abaddon has finished preparing his Overdrive!!!" | |
| print "Abaddon unleashes THANATOS!!!" | |
| raw_input("") | |
| print "THANATOS does",hpdmg,"to HP!" | |
| print "THANATOS does",mpdmg,"to MP!" | |
| Abaddon.target.hp -= hpdmg | |
| Abaddon.target.mp -= mpdmg | |
| Abaddon.target.overdrive += hpdmg | |
| Abaddon.overdriveCharge = False | |
| Abaddon.overdriveComplete = True | |
| raw_input("") | |
| return playerMenu() | |
| def urotsukidoji(self): | |
| dmg = int(random.randint(1000,1200)*Abaddon.target.defend*Abaddon.target.barrier) | |
| print "Abaddon uses Urotsukidoji!" | |
| print "Urotsukidoji does",dmg,"damage!" | |
| if Bahamut.summoned: | |
| pass | |
| else: | |
| if Player.astra: | |
| print "Astra prevents confusion!" | |
| Player.astract -= 1 | |
| else: | |
| print "You are now confused!" | |
| Player.confuse = True | |
| Player.confusect = 3 | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| raw_input("") | |
| def wrath(self): | |
| atknum = random.randint(8,14) | |
| print "Abaddon unleashes his Wrath!" | |
| print "Abaddon attacks",atknum,"times at incredible speed!" | |
| for i in range(atknum): | |
| dmg = int(random.randint(400,450)*Abaddon.target.defend*Abaddon.target.barrier) | |
| print "Abaddon's attack does",dmg,"damage!" | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| raw_input("") | |
| if Bahamut.summoned: | |
| pass | |
| else: | |
| if Player.astra: | |
| print "Astra prevents berserk!" | |
| Player.astract -= 1 | |
| raw_input("") | |
| else: | |
| print "You are now berserked!" | |
| Player.berserk = True | |
| Player.berserkct = 4 | |
| raw_input("") | |
| #----------------------------------- | |
| #Instantiation of Player, Bahamut and Magic/Skill Classes | |
| Player = User() | |
| Bahamut = Bahamut() | |
| Abaddon.target = Player #Sets Abaddon's initial target to the Player | |
| BLACK = BlackMagic() | |
| WHITE = WhiteMagic() | |
| SKILL = Skills() | |
| OVERDRIVE = Overdrives() | |
| ESKILL = ESkills() | |
| #----------------------------------- | |
| ## Basic Setup & Menus | |
| def intro(): | |
| print """ | |
| The devil known as Abaddon awaits you in Gehenna. He is plotting to destroy | |
| all life and is building up massive amounts of energy in this wicked place | |
| to send as an attack against the Earth. You've traveled far, and he has | |
| already taken the lives of everyone you hold dear, even those who | |
| accompanied you as you searched for him. You are the only one left | |
| who has a chance of defeating him before he obliterates everything | |
| else. | |
| As you pass through the gates of Gehenna, you slaughter everything that | |
| stands in your way. Abaddon's Gate looms forebodingly in the distance, dark | |
| and monolithic. You quickly slay the gatekeeping demons and force open the gate. | |
| As you approach the devil, Abaddon, he beckon's you forth, a cocky smile on | |
| his face. Can he back up his confidence? Or will he find himself unable | |
| to withstand your fury? | |
| """ | |
| raw_input("") | |
| name = raw_input("Now what is your name (Default: 'Spero')? ") | |
| if name == "": | |
| pass | |
| else: | |
| Player.name = name | |
| print "Prepare yourself",Player.name+", for your final battle is about to commence!" | |
| raw_input("") | |
| return statRoll() | |
| def statRoll(): | |
| print "-"*35 | |
| print "PROFILE" | |
| print "Name:",Player.name | |
| print "HP:",Player.maxhp | |
| print "MP:",Player.maxmp | |
| print "Strength:",Player.strength | |
| print "Magic:",Player.magic | |
| print "Evasion:",Player.evasion | |
| raw_input("") | |
| return overdriveSelection() | |
| def overdriveSelection(): | |
| print "-"*35 | |
| print "OVERDRIVES" | |
| print "1) Omnislash" | |
| print "2) Multi-Cast" | |
| print "3) Full-Heal" | |
| print "4) Ultima" | |
| print "5) Summon Bahamut" | |
| overdrive = raw_input("Choose your Overdrive technique: ") | |
| if overdrive == "1": | |
| Player.overdriveTech = "Omnislash" | |
| elif overdrive == "2": | |
| Player.overdriveTech = "Multi-Cast" | |
| elif overdrive == "3": | |
| Player.overdriveTech = "Full-Heal" | |
| elif overdrive == "4": | |
| Player.overdriveTech = "Ultima" | |
| elif overdrive == "5": | |
| Player.overdriveTech = "Summon Bahamut" | |
| else: | |
| return overdriveSelection() | |
| def playerMenu(): #Player Root Menu | |
| if Bahamut.summoned: | |
| return bahamutMenu() | |
| removeBenefit = 0 | |
| for i in Player.benefit: #Benefit removal if necessary | |
| if Player.benefit[removeBenefit] == "Astra" and Player.astract <= 0: | |
| del Player.benefit[removeBenefit] | |
| Player.astra = False | |
| elif Player.benefit[removeBenefit] == "Barrier" and Player.barrierct <= 0: | |
| del Player.benefit[removeBenefit] | |
| Player.barrier = 1 | |
| elif Player.benefit[removeBenefit] == "Regen" and Player.regenct <= 0: | |
| del Player.benefit[removeBenefit] | |
| Player.regen = False | |
| else: | |
| pass | |
| removeBenefit += 1 | |
| if Player.regen and not Player.rheal: #Regen effects | |
| print "-"*35 | |
| regenEffect = int(Player.maxhp/20) | |
| print "Regen's effect restores",regenEffect,"HP!" | |
| Player.hp += regenEffect | |
| if Player.hp > Player.maxhp: | |
| Player.hp = Player.maxhp | |
| Player.regenct -= 1 | |
| Player.rheal = True | |
| raw_input("") | |
| if Player.barrier != 1: #Barrier countdown | |
| Player.barrierct -= 1 | |
| if Player.poison and not Player.poisoneffect: #Poison damage | |
| poisonDmg = int(Player.maxhp/20) | |
| print "You take",poisonDmg,"damage from poison." | |
| Player.hp -= poisonDmg | |
| Player.poisonct -= 1 | |
| Player.poisoneffect = True | |
| raw_input("") | |
| if Player.mute: #Mute countdown | |
| Player.mutect -= 1 | |
| removeStatus = 0 #Removal of Poison or Mute if necessary | |
| for i in Player.status: | |
| if Player.status[removeStatus] == "Poison" and Player.poisonct <= 0: | |
| del Player.status[removeStatus] | |
| Player.poison = False | |
| raw_input("") | |
| elif Player.status[removeStatus] == "Mute" and Player.mutect <= 0: | |
| del Player.status[removeStatus] | |
| Player.mute = False | |
| raw_input("") | |
| else: | |
| pass | |
| removeStatus += 1 | |
| if Player.paralysis: #Paralysis effect | |
| print "-"*35 | |
| print "You are paralyzed and can take no actions." | |
| if Player.confuse: | |
| Player.confusect -= 1 | |
| if Player.confusect == 0: | |
| print "You are no longer confused!" | |
| Player.confuse = False | |
| if Player.berserk: | |
| Player.berserkct -= 1 | |
| if Player.berserkct == 0: | |
| print "you are no longer berserked!" | |
| Player.berserk = False | |
| Player.paralysisct -= 1 | |
| if Player.paralysisct == 0: | |
| Player.paralysis = False | |
| raw_input("") | |
| return abaddonTurn() | |
| if Player.confuse: #Confusion effects | |
| target = random.randint(1,100) | |
| print "-"*35 | |
| print "You are confused." | |
| if Player.berserk: | |
| print "You are also berserk." | |
| raw_input("") | |
| if target <= 50: | |
| print "You attack Abaddon!" | |
| evade = random.randint(1,100) | |
| if evade <= Abaddon.evasion: | |
| print "Abaddon evades your attack" | |
| raw_input("") | |
| Player.confusect -= 1 | |
| if Player.confusect == 0: | |
| print "You are no longer confused!" | |
| Player.confuse = False | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| crit = random.randint(10,100) | |
| critBonus = 1 | |
| if crit <= 10: | |
| critBonus = 1.5 | |
| print "CRITICAL HIT!" | |
| if Player.berserk: | |
| atkdmg = int(random.randint(30,40)*Player.strength*critBonus*Player.berserkBonus) | |
| else: | |
| atkdmg = int(random.randint(30,40)*Player.strength*critBonus) | |
| if atkdmg > 9999: | |
| atkdmg = 9999 | |
| print "Abaddon takes",atkdmg,"damage!" | |
| Abaddon.hp -= atkdmg | |
| raw_input("") | |
| Player.confusect -= 1 | |
| if Player.confusect == 0: | |
| print "You are no longer confused!" | |
| Player.confuse = False | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| print "You attack yourself!" | |
| critBonus = 1 | |
| crit = random.randint(10,100) | |
| if crit <= 10: | |
| critBonus = 1.5 | |
| print "CRITICAL HIT!" | |
| if Player.berserk: | |
| selfdmg = int(critBonus*Player.berserkBonus*(random.randint(30,40)*Player.strength/5)) | |
| else: | |
| selfdmg = int(critBonus*(random.randint(30,40)*Player.strength/5)) | |
| print "You take",selfdmg,"damage!" | |
| raw_input("") | |
| print "You are no longer confused!" | |
| if Player.berserk: | |
| Player.berserkct -= 1 | |
| if Player.berserkct == 0: | |
| print "You are no longer berserked!" | |
| Player.berserk = False | |
| Player.hp -= selfdmg | |
| Player.confusect = 0 | |
| Player.confuse = False | |
| raw_input("") | |
| return abaddonTurn() | |
| if Player.berserk: #Berserk effects | |
| print "-"*35 | |
| print "You are berserked!" | |
| raw_input("") | |
| print "You attack Abaddon!" | |
| evade = random.randint(1,100) | |
| if evade <= Abaddon.evasion: | |
| print "Abaddon evades your attack" | |
| raw_input("") | |
| Player.berserkct -= 1 | |
| if Player.berserkct == 0: | |
| print "You are no longer berserked!" | |
| Player.berserk = False | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| crit = random.randint(10,100) | |
| critBonus = 1 | |
| if crit <= 10: | |
| critBonus = 1.5 | |
| print "CRITICAL HIT!" | |
| atkdmg = int(random.randint(30,40)*Player.strength*critBonus*Player.berserkBonus) | |
| if atkdmg > 9999: | |
| atkdmg = 9999 | |
| print "Abaddon takes",atkdmg,"damage!" | |
| Abaddon.hp -= atkdmg | |
| raw_input("") | |
| Player.berserkct -= 1 | |
| if Player.berserkct == 0: | |
| print "You are no longer berserked!" | |
| Player.berserk = False | |
| raw_input("") | |
| return abaddonTurn() | |
| if Player.hp <= 0: | |
| print "The battle is lost. Now there is no one to stop Abaddon's attack." | |
| print "GAME OVER" | |
| raw_input("~Press Enter to Close Program~") | |
| return | |
| Player.defend = 1 #Reset defend | |
| #Bahamut recovery | |
| if not Bahamut.hp <= 0: | |
| Bahamut.hp += int(Bahamut.maxhp/60) | |
| if Bahamut.hp > Bahamut.maxhp: | |
| Bahamut.hp = Bahamut.maxhp | |
| Bahamut.mp += int(Bahamut.maxmp/40) | |
| if Bahamut.mp > Bahamut.maxmp: | |
| Bahamut.mp = Bahamut.maxmp | |
| print "-"*35 | |
| print Player.name | |
| print "HP:",str(Player.hp)+"/"+str(Player.maxhp) | |
| print "MP:",str(Player.mp)+"/"+str(Player.maxmp) | |
| print "Benefit:", | |
| for i in Player.benefit: | |
| print i,",", | |
| print "\n" | |
| print "Status:", | |
| for i in Player.status: | |
| print i,",", | |
| print "1) Attack" | |
| if not Player.mute: | |
| print "2) White Magic" | |
| print "3) Black Magic" | |
| print "4) Skills" | |
| print "5) Defend" | |
| print "6) Item" | |
| if Player.overdrive >= int(Player.maxhp*4.4): | |
| print "7) OVERDRIVE:",Player.overdriveTech | |
| action = raw_input("What will you do? ") | |
| if action == "1": #Attack | |
| evade = random.randint(1,100) | |
| if evade <= Abaddon.evasion: | |
| print "Abaddon evades your attack" | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| crit = random.randint(10,100) | |
| critBonus = 1 | |
| if crit <= 10: | |
| critBonus = 1.5 | |
| print "CRITICAL HIT!" | |
| atkdmg = int(random.randint(30,40)*Player.strength*critBonus) | |
| if atkdmg > 9999: | |
| atkdmg = 9999 | |
| print "Abaddon takes",atkdmg,"damage!" | |
| Abaddon.hp -= atkdmg | |
| raw_input("") | |
| return abaddonTurn() | |
| elif action == "2" and Player.mute == False: #Go to White Magic Menu | |
| return wmagic() | |
| elif action == "3" and Player.mute == False: #Go to Black Magic Menu | |
| return bmagic() | |
| elif action == "4": #Go to Skills Menu | |
| return skills() | |
| elif action == "5": #Defend | |
| print "You brace yourself for attack" | |
| raw_input("") | |
| Player.defend = 0.5 | |
| return abaddonTurn() | |
| elif action == "6": #Go to Item Menu | |
| return item() | |
| elif action == "7" and Player.overdrive >= int(Player.maxhp*4.4): #Execute Overdrive | |
| if Player.overdriveTech == "Omnislash": | |
| return OVERDRIVE.omnislash() | |
| if Player.overdriveTech == "Multi-Cast": | |
| return OVERDRIVE.multiCast() | |
| if Player.overdriveTech == "Full-Heal": | |
| return OVERDRIVE.fullHeal() | |
| if Player.overdriveTech == "Ultima": | |
| return OVERDRIVE.ultima() | |
| if Player.overdriveTech == "Summon Bahamut": | |
| return OVERDRIVE.summonBahamut() | |
| else: | |
| return playerMenu() | |
| def bmagic(): #Player's Black Magic Menu | |
| print "-"*35 | |
| print "BLACK MAGIC" | |
| print "1) Flare (30 MP)" | |
| print "2) Blizzard (30 MP)" | |
| print "3) Bolt (30 MP)" | |
| print "4) Water (30 MP)" | |
| print "5) Drain (50 MP)" | |
| print "6) Bio (40 MP)" | |
| print "7) MP Absorb" | |
| print "0) RETURN" | |
| action = raw_input("What will you cast? ") | |
| if action == "1" and Player.mp < 30: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return bmagic() | |
| elif action == "2" and Player.mp < 30: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return bmagic() | |
| elif action == "3" and Player.mp < 30: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return bmagic() | |
| elif action == "4" and Player.mp < 30: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return bmagic() | |
| elif action == "5" and Player.mp < 50: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return bmagic() | |
| elif action == "6" and Player.mp < 40: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return bmagic() | |
| else: | |
| if action == "0": | |
| return playerMenu() | |
| elif action == "1": | |
| return BLACK.flare() | |
| elif action == "2": | |
| return BLACK.blizzard() | |
| elif action == "3": | |
| return BLACK.bolt() | |
| elif action == "4": | |
| return BLACK.water() | |
| elif action == "5": | |
| return BLACK.drain() | |
| elif action == "6": | |
| return BLACK.bio() | |
| elif action == "7": | |
| return BLACK.mpAbsorb() | |
| else: | |
| return bmagic() | |
| def wmagic(): #Player's White Magic Menu | |
| print "-"*35 | |
| print "WHITE MAGIC" | |
| print "1) Cure (25 MP)" | |
| print "2) Panacea (20 MP)" | |
| print "3) Astra (60 MP)" | |
| print "4) Regen (50 MP)" | |
| print "5) Barrier (50 MP)" | |
| print "0) RETURN" | |
| action = raw_input("What will you cast? ") | |
| if action == "1" and Player.mp < 25: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return wmagic() | |
| elif action == "2" and Player.mp < 20: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return wmagic() | |
| elif action == "3" and Player.mp < 60: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return wmagic() | |
| elif action == "4" and Player.mp < 50: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return wmagic() | |
| elif action == "5" and Player.mp < 50: | |
| print "~Insufficent MP~" | |
| raw_input("") | |
| return wmagic() | |
| else: | |
| if action == "0": | |
| return playerMenu() | |
| elif action == "1": | |
| return WHITE.cure() | |
| elif action == "2": | |
| return WHITE.panacea() | |
| elif action == "3": | |
| return WHITE.astra() | |
| elif action == "4": | |
| return WHITE.regen() | |
| elif action == "5": | |
| return WHITE.barrier() | |
| else: | |
| return wmagic() | |
| def skills(): #Player's Skill Menu | |
| print "-"*35 | |
| print "SKILLS" | |
| print "1) Lion Heart" | |
| print "2) Death Blow" | |
| print "3) Minus Strike" | |
| if not Player.mute: | |
| print "4) Spell Blade" | |
| print "5) Steal" | |
| print "0) RETURN" | |
| action = raw_input("What will you do? ") | |
| if action == "0": | |
| return playerMenu() | |
| elif action == "1": | |
| return SKILL.lionHeart() | |
| elif action == "2": | |
| return SKILL.deathBlow() | |
| elif action == "3": | |
| return SKILL.minusStrike() | |
| elif action == "4" and Player.mute == False: | |
| return SKILL.spellBlade() | |
| elif action == "5": | |
| return SKILL.steal() | |
| else: | |
| return skills() | |
| def item(): #Player's Item Menu | |
| print "-"*35 | |
| print "ITEMS" | |
| print "1) Potion x"+str(Player.potion) | |
| print "2) Ether x"+str(Player.ether) | |
| print "3) Elixir x"+str(Player.elixir) | |
| print "4) Remedy x"+str(Player.remedy) | |
| print "0) RETURN" | |
| action = raw_input("What will you use? ") | |
| if action == "1" and Player.potion <= 0: | |
| print "~You have no more of this item~" | |
| raw_input("") | |
| return item() | |
| elif action == "2" and Player.ether <= 0: | |
| print "~You have no more of this item~" | |
| raw_input("") | |
| return item() | |
| elif action == "3" and Player.elixir <= 0: | |
| print "~You have no more of this item~" | |
| raw_input("") | |
| return item() | |
| elif action == "4" and Player.remedy <= 0: | |
| print "~You have no more of this item~" | |
| raw_input("") | |
| return item() | |
| else: | |
| if action == "0": | |
| return playerMenu() | |
| elif action == "1": | |
| restoration = int(Player.maxhp/2) | |
| print "You use a Potion." | |
| print "You recover",restoration,"HP." | |
| Player.hp += restoration | |
| if Player.hp > Player.maxhp: | |
| Player.hp = Player.maxhp | |
| Player.potion -= 1 | |
| raw_input("") | |
| return abaddonTurn() | |
| elif action == "2": | |
| restoration = int(Player.maxmp/2) | |
| print "You use an Ether." | |
| print "You recover",restoration,"MP." | |
| Player.mp += restoration | |
| if Player.mp > Player.maxmp: | |
| Player.mp = Player.maxmp | |
| raw_input("") | |
| Player.ether -= 1 | |
| return abaddonTurn() | |
| elif action == "3": | |
| print "You use an Elixir." | |
| print "Your HP and MP are fully healed." | |
| Player.hp = Player.maxhp | |
| Player.mp = Player.maxmp | |
| Player.elixir -= 1 | |
| raw_input("") | |
| return abaddonTurn() | |
| elif action == "4": | |
| print "You use a Remedy." | |
| print "All status ailments are removed." | |
| Player.remedy -= 1 | |
| Player.poisonct = 0 | |
| Player.poison = False | |
| Player.mutect = 0 | |
| Player.mute = False | |
| for i in Player.status: | |
| del Player.status[0] | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| return item() | |
| def bahamutMenu(): #Root menu and actions for Bahamut | |
| Bahamut.defend = 1 | |
| if Bahamut.hp <= 0: | |
| print "Bahamut has become unable to fight because of injury and disappears." | |
| Bahamut.summoned = False | |
| Abaddon.target = Player | |
| raw_input("") | |
| return playerMenu() | |
| if Bahamut.cooldown: | |
| print "-"*35 | |
| print "Bahamut is recovering from using Exa Flare" | |
| Bahamut.cooldown = False | |
| raw_input("") | |
| return abaddonTurn() | |
| print "-"*35 | |
| print "Bahamut" | |
| print "HP:",str(Bahamut.hp)+"/"+str(Bahamut.maxhp) | |
| print "MP:",str(Bahamut.mp)+"/"+str(Bahamut.maxmp) | |
| print "1) Attack" | |
| print "2) Restore (30 MP)" | |
| print "3) Abarekuru (50 MP)" | |
| print "4) Defend" | |
| if Bahamut.overdrive >= int(Bahamut.maxhp*.75): | |
| print "5) OVERDRIVE: Exa Flare" | |
| print "0) Dismiss" | |
| action = raw_input("What will you do? ") | |
| if action == "2" and Bahamut.mp < 30: | |
| print "~Insufficient MP~" | |
| raw_input("") | |
| return bahamutMenu() | |
| elif action == "3" and Bahamut.mp < 50: | |
| print "~Insufficient MP~" | |
| raw_input("") | |
| return bahamutMenu() | |
| else: | |
| if action == "0": #Dismiss | |
| print "You thank Bahamut for his aid, and send him away for now." | |
| Bahamut.summoned = False | |
| Abaddon.target = Player | |
| raw_input("") | |
| return playerMenu() | |
| elif action == "1": #Attack | |
| evade = random.randint(1,100) | |
| if evade <= Abaddon.evasion: | |
| print "Abaddon evades Bahamut's attack" | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| crit = random.randint(10,100) | |
| critBonus = 1 | |
| if crit <= 10: | |
| critBonus = 1.5 | |
| print "CRITICAL HIT!" | |
| atkdmg = int(random.randint(35,45)*Bahamut.strength*critBonus) | |
| print "Abaddon takes",atkdmg,"damage!" | |
| Abaddon.hp -= atkdmg | |
| raw_input("") | |
| return abaddonTurn() | |
| elif action == "2": #Restore | |
| restore = int(Bahamut.maxhp/3) | |
| print "Bahamut uses Restore." | |
| print "Bahamut regains",restore,"HP." | |
| Bahamut.mp -= 30 | |
| Bahamut.hp += restore | |
| if Bahamut.hp > Bahamut.maxhp: | |
| Bahamut.hp = Bahamut.maxhp | |
| raw_input("") | |
| return abaddonTurn() | |
| elif action == "3": #Abarekuru | |
| evade = random.randint(1,100) | |
| Bahamut.mp -= 50 | |
| if evade <= Abaddon.evasion+40: | |
| print "Abaddon evades Bahamut's attack" | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| dmg = int(random.randint(35,45)*Bahamut.strength*1.5) | |
| print "Abaddon takes",dmg,"damage!" | |
| Abaddon.hp -= dmg | |
| raw_input("") | |
| return abaddonTurn() | |
| elif action == "4": #Defend | |
| print "Bahamut takes a defensive stance." | |
| Bahamut.defend = 0.5 | |
| raw_input("") | |
| return abaddonTurn() | |
| elif action == "5" and Bahamut.overdrive >= int(Bahamut.maxhp*.75): | |
| if Bahamut.strength > Bahamut.magic: | |
| exaFlare = random.randint(75,80)*Bahamut.strength | |
| else: | |
| exaFlare = random.randint(75,80)*Bahamut.magic | |
| print "Bahamut unleashes the power of Exa Flare!!!" | |
| print "Abaddon suffers",exaFlare,"damage!" | |
| Abaddon.hp -= exaFlare | |
| Bahamut.overdrive = 0 | |
| Bahamut.cooldown = True | |
| raw_input("") | |
| return abaddonTurn() | |
| else: | |
| return bahamutMenu() | |
| def abaddonTurn(): #Abaddon's action randomly selected | |
| if Abaddon.poison and not Abaddon.poisoneffect: #Abaddon is poisoned | |
| poisonDmg = int(Abaddon.maxhp/500) | |
| print "-"*35 | |
| print "Abaddon takes",poisonDmg,"damage from poison!" | |
| Abaddon.poisonct -= 1 | |
| Abaddon.poisoneffect = True | |
| if Abaddon.poisonct <= 0: | |
| Abaddon.poison = False | |
| Abaddon.poisonct = 0 | |
| raw_input("") | |
| if Abaddon.hp <= 0: | |
| print """ | |
| Abaddon falls to the floor in death. Finally, the the long and | |
| arduous battle, and your journey, has come to an end. You have | |
| successfully prevented Abaddon's attack against the Earth. | |
| With a smile on your face, you leave Gehenna and go back home, | |
| glad that your friends' sacrifices were not in vain. | |
| """ | |
| raw_input("") | |
| return | |
| if Abaddon.hp <= int(Abaddon.maxhp*0.25): | |
| if not Abaddon.overdriveCharging and not Abaddon.overdriveComplete: | |
| Abaddon.overdriveCharge = True | |
| Abaddon.overdriveCharging = True | |
| Abaddon.overdrivect = 4 | |
| if Abaddon.overdriveCharge: | |
| return ESKILL.thanatos() | |
| else: | |
| print "-"*35 | |
| print "Abaddon HP:",str(Abaddon.hp)+"/"+str(Abaddon.maxhp) | |
| action = random.randint(1,100) | |
| if action <= 39: # Attack | |
| evade = random.randint(1,100) | |
| print "Abaddon attacks!" | |
| if evade <= Abaddon.target.evasion: | |
| print "Abaddon's attack missed!" | |
| raw_input("") | |
| else: | |
| dmg = int(random.randint(960,1160)*Abaddon.target.defend*Abaddon.target.barrier) | |
| print "The attack does",dmg,"damage!" | |
| Abaddon.target.hp -= dmg | |
| Abaddon.target.overdrive += dmg | |
| raw_input("") | |
| elif action >= 40 and action <= 47: # Element Shift | |
| ESKILL.elementShift() | |
| elif action >= 48 and action <= 52: # Nova | |
| ESKILL.nova() | |
| elif action >= 53 and action <= 54: # Negative | |
| ESKILL.negative() | |
| elif action >= 55 and action <= 59: # Wrath | |
| ESKILL.wrath() | |
| elif action >= 60 and action <= 64: # Plague | |
| ESKILL.plague() | |
| elif action >= 65 and action <= 68: # Demija | |
| ESKILL.demija() | |
| elif action >= 69 and action <= 72: # Urotsukidoji | |
| ESKILL.urotsukidoji() | |
| elif action >= 73 and action <= 75: # Roulette | |
| ESKILL.roulette() | |
| elif action >= 76 and action <= 79: # Hitoawafukaseru | |
| ESKILL.hitoawafukaseru() | |
| elif action >= 80 and action <= 86: # Doom Blade | |
| ESKILL.doomBlade() | |
| elif action >= 87 and action <= 92: # Megido | |
| ESKILL.megido() | |
| elif action >= 93 or action <= 97: # Super Nova | |
| ESKILL.supernova() | |
| elif action >= 98: # Seal Voice | |
| ESKILL.sealVoice() | |
| else: | |
| pass | |
| # Go to Player's turn | |
| Player.rheal = False | |
| Player.poisoneffect = False | |
| Abaddon.poisoneffect = False | |
| return playerMenu() | |
| intro() | |
| print "-"*35 | |
| print "Let the battle begin!" | |
| raw_input("") | |
| playerMenu() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment