def __init__(self, dex=None, pid=None):
if dex is not None:
self.dex = dex
else:
self.dex = DexLoader().pokedex
self.pokemon = self.dex.get(str(pid))
self.name = self.pokemon.get("name")
self.types = [Type(DexLoader().typedex, type) for type in self.pokemon.get("types")]
self.weight = self.pokemon.get("weight") / 10
self.stats = {
"base": self.pokemon.get("stats"),
"stage": {
"attack": 0,
"defense": 0,
"spattack": 0,
"spdefense": 0,
"speed": 0
}
}
self.maxHp = 141 + 2 * self.pokemon.get("stats").get("hp")
self.hp = self.maxHp
self.conditions = {}
self.ailment = None
self.faintObservers = []
self.strategy = Strategy(self)
self.move = None
self.moves = self.strategy.chooseBuild([Move(mid=move) for move in self.pokemon.get("moves")])
self.trainer = None
self.score = 0
def __init__(self, dex=None, tid=None):
if dex is not None:
self.dex = dex
else:
self.dex = DexLoader().typedex
self.all = list(self.dex.keys())
if tid is not None:
self.type = self.dex.get(str(tid))
self.id = self.type.get("id")
self.name = self.type.get("name")
self.offense = self.type.get("offense")
self.defense = self.type.get("defense")
class Type(object):
def __init__(self, dex=None, tid=None):
if dex is not None:
self.dex = dex
else:
self.dex = DexLoader().typedex
self.all = list(self.dex.keys())
if tid is not None:
self.type = self.dex.get(str(tid))
self.id = self.type.get("id")
self.name = self.type.get("name")
self.offense = self.type.get("offense")
self.defense = self.type.get("defense")
def __str__(self):
return self.name
@staticmethod
def all():
return [Type(tid=typeid) for typeid in DexLoader().typedex.keys()]
def effectivenessAgainst(self, types):
if not type(types) == list:
types = [types]
base = 1
for t in types:
base *= self.offense.get(str(t.id))
return base
def effectiveAgainst(self, types):
return self.effectivenessAgainst(types) > 1
def weeknesses(self):
return [
Type(self.dex, type_id)
for (type_id, effectiveness) in self.defense.items()
if effectiveness > 1
]
def strengths(self):
return [
Type(self.dex, type_id)
for (type_id, effectiveness) in self.offense.items()
if effectiveness > 1
]
def __init__(self, dex=None, mid=None):
if dex is not None:
self.dex = dex
else:
self.dex = DexLoader().movedex
self.move = self.dex.get(str(mid))
self.id = self.move.get("id")
self.name = self.move.get("name")
self.basePower = self.move.get("power")
self.type = Type(DexLoader().typedex, self.move.get("type"))
self.effect = Effect.make(id=self.move.get("effect"),
chance=self.move.get("effect_chance"))
self.accuracy = self.move.get(
"accuracy") if self.move.get("accuracy") > 0 else 100
self.priority = self.move.get("priority")
self.damageClass = self.move.get("damage_class")
class Move(object):
def __init__(self, dex=None, mid=None):
if dex is not None:
self.dex = dex
else:
self.dex = DexLoader().movedex
self.move = self.dex.get(str(mid))
self.id = self.move.get("id")
self.name = self.move.get("name")
self.basePower = self.move.get("power")
self.type = Type(DexLoader().typedex, self.move.get("type"))
self.effect = Effect.make(id=self.move.get("effect"),
chance=self.move.get("effect_chance"))
self.accuracy = self.move.get(
"accuracy") if self.move.get("accuracy") > 0 else 100
self.priority = self.move.get("priority")
self.damageClass = self.move.get("damage_class")
def __str__(self):
return self.name + "(" + self.type.name + " - " + (
'X' if self.basePower == 1 else str(self.basePower)
) + " power - " + str(self.accuracy) + " accuracy)"
def banned(self):
return (self.damageClass
== DAMAGE_NONE) or (self.effect.banned()) or (self.power() < 2)
def attackStat(self):
return "attack" if self.damageClass == DAMAGE_PHYSICAL else "spattack"
def defenseStat(self):
return "defense" if self.damageClass == DAMAGE_PHYSICAL else "spdefense"
def buildMultiplier(self, attacker):
base = self.effect.buildMultiplier(attacker)
return base * 1.33 if self.priority > 0 else base * 0.9
def battleMultiplier(self, attacker, defender, damage):
lethal = damage >= defender.hp
base = self.accuracy / 100
if self.priority > 0 and lethal:
base *= 5
base *= self.effect.battleMultiplier(attacker, defender, damage,
lethal)
return base
def effectiveness(self, attacker, defender):
effectiveness = self.type.effectivenessAgainst(defender.types)
return self.effect.effectiveness(attacker, defender, effectiveness)
def power(self, attacker=None, defender=None):
return self.effect.power(base=self.basePower)
def hits(self):
return self.effect.hits()
def criticalRateStage(self):
return self.effect.criticalRateStage()
def afterDamage(self, attacker, defender, damage):
self.effect.afterDamage(attacker, defender, damage)
def afterMiss(self, attacker, defender):
self.effect.afterMiss(attacker, defender)
if self.priority > 0 and lethal:
base *= 5
base *= self.effect.battleMultiplier(attacker, defender, damage,
lethal)
return base
def effectiveness(self, attacker, defender):
effectiveness = self.type.effectivenessAgainst(defender.types)
return self.effect.effectiveness(attacker, defender, effectiveness)
def power(self, attacker=None, defender=None):
return self.effect.power(base=self.basePower)
def hits(self):
return self.effect.hits()
def criticalRateStage(self):
return self.effect.criticalRateStage()
def afterDamage(self, attacker, defender, damage):
self.effect.afterDamage(attacker, defender, damage)
def afterMiss(self, attacker, defender):
self.effect.afterMiss(attacker, defender)
struggle = Move(DexLoader().movedex, 165)
if __name__ == "__main__":
pass
def all():
return [Type(tid=typeid) for typeid in DexLoader().typedex.keys()]
if not type(types) == list:
types = [types]
base = 1
for t in types:
base *= self.offense.get(str(t.id))
return base
def effectiveAgainst(self, types):
return self.effectivenessAgainst(types) > 1
def weeknesses(self):
return [
Type(self.dex, type_id)
for (type_id, effectiveness) in self.defense.items()
if effectiveness > 1
]
def strengths(self):
return [
Type(self.dex, type_id)
for (type_id, effectiveness) in self.offense.items()
if effectiveness > 1
]
if __name__ == "__main__":
dl = DexLoader().typedex
mv = Type(dl, 12)
mv.effectiveAgainst([Type(dl, 10), Type(dl, 7)])
import random
from main.dexLoader import DexLoader
from pokemon import Pokemon
from trainer import Trainer
from battle import Battle
dl = DexLoader()
def pokemon_lookup(name):
name = name.lower()
if name == "nidoran f":
return 29
elif name == "nidoran m":
return 32
else:
pkdex = dl.pokedex
return [v.get("id") for k, v in pkdex.items() if v.get("name").lower() == name][0]
def pokemon_battle(team1, team2):
team1 = {"trainer": None, "pokemon": team1}
team2 = {"trainer": "The foe", "pokemon": team2}
trainer1 = Trainer(team1.get("trainer"))
for pkm in team1.get("pokemon"):
trainer1.addPokemon(Pokemon(pid=pkm))
trainer2 = Trainer(team2.get("trainer"))
for pkm in team2.get("pokemon"):
trainer2.addPokemon(Pokemon(pid=pkm))
class Pokemon(object):
def __init__(self, dex=None, pid=None):
if dex is not None:
self.dex = dex
else:
self.dex = DexLoader().pokedex
self.pokemon = self.dex.get(str(pid))
self.name = self.pokemon.get("name")
self.types = [Type(DexLoader().typedex, type) for type in self.pokemon.get("types")]
self.weight = self.pokemon.get("weight") / 10
self.stats = {
"base": self.pokemon.get("stats"),
"stage": {
"attack": 0,
"defense": 0,
"spattack": 0,
"spdefense": 0,
"speed": 0
}
}
self.maxHp = 141 + 2 * self.pokemon.get("stats").get("hp")
self.hp = self.maxHp
self.conditions = {}
self.ailment = None
self.faintObservers = []
self.strategy = Strategy(self)
self.move = None
self.moves = self.strategy.chooseBuild([Move(mid=move) for move in self.pokemon.get("moves")])
self.trainer = None
self.score = 0
def __str__(self):
return self.name
def trainerAndName(self):
if self.trainer.name is None:
return "Your " + self.name
else:
return self.trainer.name + "'s " + self.name
def stat(self, stat, options=None):
if options is None:
options = {}
if not options.get("ignorePositive"):
options["ignorePositive"] = False
if not options.get("ignoreNegative"):
options["ignoreNegative"] = False
stageMultiplier = self.statStageMultiplier(self.stats.get("stage").get(stat))
if (stageMultiplier > 1 and options.get("ingorePositive")) or (
stageMultiplier < 1 and options.get("ingoreNegative")):
stageMultiplier = 1
ailmentMultiplier = 1
if self.ailment is not None:
ailmentMultiplier = self.ailment.statMultiplier(stat)
return 36 + 2 * self.stats.get("base").get(stat) * stageMultiplier * ailmentMultiplier
def statStageMultiplier(self, stage):
if stage == 0:
return 1
elif stage > 0:
return (stage + 2) / 2
else:
return 2 / (abs(stage) + 2)
def attack(self):
return self.stat("attack")
def defense(self):
return self.stat("defense")
def spattack(self):
return self.stat("spattack")
def spdefense(self):
return self.stat("spdefense")
def speed(self):
return self.stat("speed")
def isAlive(self):
return self.hp > 0
def chooseMove(self, defender):
self.move = self.strategy.chooseMove(defender)
def takeDamage(self, damage, message):
if damage > self.hp:
damage = self.hp
self.hp -= damage
print(message)
if not self.isAlive():
for observer in self.faintObservers:
observer.notifyFaint(self)
return damage
def subscribeToFaint(self, observer):
self.faintObservers.append(observer)
def statName(self, stat):
namedict = {"attack": "Attack", "defense": "Defense", "spattack": "Special Attack",
"spdefense": "Special Defense", "speed": "Speed"}
return namedict.get(stat)
def modifyStatStage(self, stat, change):
statName = self.statName(stat)
if self.stats.get("stage").get(stat) == 6 and change > 0:
print(self.trainerAndName() + "'s" + statName + " cannot rise any higher.")
if self.stats.get("stage").get(stat) == -6 and change < 0:
print(self.trainerAndName() + "'s" + statName + " cannot fall any lower.")
else:
change = 6 - self.stats.get("stage").get(stat) if self.stats.get("stage").get(stat) + change > 6 else change
change = -6 - self.stats.get("stage").get(stat) if self.stats.get("stage").get(
stat) + change < -6 else change
self.stats.get("stage")[stat] += change
if change == 1:
print(self.trainerAndName() + "'s " + statName + " rose")
if change == 2:
print(self.trainerAndName() + "'s " + statName + " sharply rose")
if change == 3:
print(self.trainerAndName() + "'s " + statName + " drastically rose")
if change == -1:
print(self.trainerAndName() + "'s " + statName + " fell")
if change == -2:
print(self.trainerAndName() + "'s " + statName + " harshly fell")
if change == -3:
print(self.trainerAndName() + "'s " + statName + " severely fell")
def typeAdvantageAgainst(self, pokemon):
type_list = [type for type in self.types if type.effectiveAgainst(pokemon.types)]
return len(type_list) > 0
def canAttack(self):
if self.ailment is not None and not self.ailment.canAttack(self):
return False
conditions = copy.deepcopy(self.conditions)
for x, condition in conditions.items():
if not condition.canAttack(self):
return False
return True
def whenSwitchedOut(self):
self.move = None
if self.ailment is not None:
self.ailment.whenSwitchedOut(self)
self.conditions = {}
def endTurn(self):
if self.ailment is not None:
self.ailment.endTurn(self)
conditions = copy.deepcopy(self.conditions)
for x, condition in conditions.items():
condition.endTurn(self)
del conditions