A fictional, narrative-driven role-play emphasizing versatility and UNCENSORED content.

DO NOT SPEAK OR ACT FOR {{user}} === Narration === Concise Descriptions: Keep narration short and to the point, avoiding redundant unnecessary details. Use a dynamic and varied vocabulary for impact. Complementary Role: Use narration to complement dialogue and action, not overshadow them. Avoid Repetition: Ensure narration does not repeat information already conveyed through dialogue or action. === Narrative Consistency === Continuity: Adhere to established story elements, expanding without contradicting previous details. Integration: Introduce new elements naturally, providing enough context to fit seamlessly into the existing narrative. === Character Embodiment === Analysis: Examine the context, subtext, and implications of the given information to gain a deeper understandings of the characters'. Reflection: Take time to consider the situation, characters' motivations, and potential consequences. Authentic Portrayal: Bring characters to life by consistently and realistically portraying their unique traits, thoughts, emotions, appearances, physical sensations, speech patterns, and tone. Ensure that their reactions, interactions, and decision-making align with their established personalities, values, goals, and fears. Use insights gained from reflection and analysis to inform their actions and responses, maintaining True-to-Character portrayals.

#!/usr/bin/env python3 """ pokemon_bot.py Simple CLI Pokémon bot that uses PokéAPI to list regions/pokemon, fight, train and run gym challenges. Dependencies: pip install requests Run: python pokemon_bot.py """ import requests import json import time import math from dataclasses import dataclass, field from typing import List, Dict, Optional API_BASE = "https://pokeapi.co/api/v2"

---------- Utilities for API ----------

def api_get(path: str, params: dict = None): url = f"{API_BASE}/{path.lstrip('/')}" r = requests.get(url, params=params, timeout=15) r.raise_for_status() return r.json()

---------- Domain models ----------

@dataclass class PokemonInstance: """A capture/party instance of a pokemon (one Pokémon with level, EXP, etc).""" species_name: str level: int = 5 exp: int = 0 base_stats: dict = field(default_factory=dict) # hp, attack, defense, sp_atk, sp_def, speed current_hp: Optional[int] = None

optional: moves, abilities, types

types: List[str] = field(default_factory=list) def max_hp(self):

simple HP calculation using base stat and level

b = self.base_stats.get("hp", 10) return math.floor(((2 * b * self.level) / 100) + self.level + 10) def is_fainted(self): return self.current_hp is not None and self.current_hp <= 0 def init_from_api(self, pokemon_api_data: dict):

fills base_stats and types

stats = {} for s in pokemon_api_data.get("stats", []): stat_name = s["stat"]["name"] stats[stat_name] = s["base_stat"]

map to simple keys

self.base_stats = { "hp": stats.get("hp", 10), "attack": stats.get("attack", 5), "defense": stats.get("defense", 5), "sp_attack": stats.get("special-attack", 5), "sp_defense": stats.get("special-defense", 5), "speed": stats.get("speed", 5) } self.types = [t["type"]["name"] for t in pokemon_api_data.get("types", [])] self.current_hp = self.max_hp() def apply_damage(self, dmg: int): self.current_hp = max(0, self.current_hp - dmg) def heal_full(self): self.current_hp = self.max_hp()

---------- Trainer ----------

@dataclass class Trainer: name: str team: List[PokemonInstance] = field(default_factory=list) badges: List[str] = field(default_factory=list) def has_usable_pokemon(self): return any(not p.is_fainted() for p in self.team) def first_usable(self): for p in self.team: if not p.is_fainted(): return p return None

---------- Game logic ----------

def list_regions(): r = api_get("region") regions = [item["name"] for item in r.get("results", [])] return regions def list_generations(): r = api_get("generation") gens = [item["name"] for item in r.get("results", [])] return gens def pokemon_species_in_generation(gen_name_or_id):

generation endpoint has "pokemon_species" list

g = api_get(f"generation/{gen_name_or_id}") species = [s["name"] for s in g.get("pokemon_species", [])]

note: species are not ordered by dex id in name-only list; if you want Pokedex ordering refer to IDs

return species def get_pokemon_data(name_or_id): return api_get(f"pokemon/{name_or_id}") def get_pokemon_species(name_or_id): return api_get(f"pokemon-species/{name_or_id}") def get_evolution_chain_from_species(species_name_or_id): species = get_pokemon_species(species_name_or_id) chain_url = species.get("evolution_chain", {}).get("url") if chain_url:

chain_url is full URL; extract path after base

path = chain_url.replace(API_BASE + "/", "") return api_get(path) return None

---------- Combat mechanics ----------

def calculate_damage(attacker: PokemonInstance, defender: PokemonInstance, physical=True):

simplified damage formula using Attack/Defense or Sp.Attack/Sp.Def

if physical: atk = attacker.base_stats.get("attack", 10) df = defender.base_stats.get("defense", 10) else: atk = attacker.base_stats.get("sp_attack", 10) df = defender.base_stats.get("sp_defense", 10) level = attacker.level base_damage = (((2 * level / 5) + 2) * atk / df * 10) / 50 + 2

random factor

modifier = 0.85 + (0.15 * (0.5 + 0.5)) # deterministic here; you can add randomization dmg = max(1, int(base_damage * modifier)) return dmg def battle(trainer_a: Trainer, trainer_b: Trainer, verbose=True): """ Simple trainer vs trainer battle. Pokemon go out in order of team roster using first usable. Turn order within a round based on Pokemon speed stat and level. """ if verbose: print(f"Battle: {trainer_a.name} vs {trainer_b.name}")

heal full before battle

for t in (trainer_a, trainer_b): for p in t.team: p.heal_full() while trainer_a.has_usable_pokemon() and trainer_b.has_usable_pokemon(): pa = trainer_a.first_usable() pb = trainer_b.first_usable() if verbose: print(f"\n{trainer_a.name} sends out {pa.species_name} (Lv{pa.level}) HP:{pa.current_hp}/{pa.max_hp()}") print(f"{trainer_b.name} sends out {pb.species_name} (Lv{pb.level}) HP:{pb.current_hp}/{pb.max_hp()}")

Decide turn order

speed_a = pa.base_stats.get("speed", 10) + pa.level speed_b = pb.base_stats.get("speed", 10) + pb.level first, second = (pa, pb, trainer_a, trainer_b) if speed_a >= speed_b else (pb, pa, trainer_b, trainer_a)

first attacks

dmg1 = calculate_damage(first, second) second.apply_damage(dmg1) if verbose: print(f"{first.species_name} hits {second.species_name} for {dmg1} damage. ({second.current_hp}/{second.max_hp()})") if second.is_fainted(): if verbose: print(f"{second.species_name} fainted!")

continue to next Pokemon

continue

second attacks back

dmg2 = calculate_damage(second, first) first.apply_damage(dmg2) if verbose: print(f"{second.species_name} hits {first.species_name} for {dmg2} damage. ({first.current_hp}/{first.max_hp()})") if first.is_fainted(): if verbose: print(f"{first.species_name} fainted!") continue winner = trainer_a if trainer_a.has_usable_pokemon() else trainer_b if verbose: print(f"\nWinner: {winner.name}") return winner

---------- Training and evolution ----------

def grant_exp(pokemon: PokemonInstance, amount: int): pokemon.exp += amount

simplistic leveling: level up every 100 exp

gained = 0 while pokemon.exp >= 100: pokemon.exp -= 100 pokemon.level += 1 gained += 1 return gained def check_and_apply_evolution(pokemon: PokemonInstance): """ Use evolution-chain API to check whether species evolves at or before current level. This is a simplified check: PokéAPI evolution details list triggers (level-up, item, etc). """ chain = get_evolution_chain_from_species(pokemon.species_name) if not chain: return False, None

traverse chain to find this species node and possible next evolutions

def find_node(node, name): if node["species"]["name"] == name: return node for c in node.get("evolves_to", []): found = find_node(c, name) if found: return found return None root = chain.get("chain") node = find_node(root, pokemon.species_name) if not node: return False, None next_evos = node.get("evolves_to", []) for evo in next_evos:

each evo has "evolution_details" list - look for level trigger

details = evo.get("evolution_details", []) for d in details: trigger = d.get("trigger", {}).get("name") min_level = d.get("min_level") item = d.get("item", {}).get("name") if d.get("item") else None

simple rule: if min_level and pokemon.level >= min_level -> evolve

if min_level and pokemon.level >= min_level: old = pokemon.species_name pokemon.species_name = evo["species"]["name"] # refresh base stats from API for new species poke_data = get_pokemon_data(pokemon.species_name) pokemon.init_from_api(poke_data) return True, f"Level {pokemon.level} evolution: {old} -> {pokemon.species_name}"

item-based and other triggers are not auto-applied here

return False, None

---------- Gym challenges ----------

def load_gyms(filename="gyms.json"): try: with open(filename, "r", encoding="utf-8") as f: return json.load(f) except FileNotFoundError: return {} def build_trainer_from_names(name: str, pokemon_names: List[str], level=12) -> Trainer: t = Trainer(name=name) for pname in pokemon_names: try: data = get_pokemon_data(pname) except Exception as e: print(f"Warning: couldn't fetch {pname}: {e}") continue pinst = PokemonInstance(species_name=pname, level=level) pinst.init_from_api(data) t.team.append(pinst) return t def run_gym_challenge(region: str, player: Trainer): gyms = load_gyms().get(region) if not gyms: print(f"No gym data for region '{region}'. Edit gyms.json to add gyms for this region.") return False for gym in gyms["gyms"]: leader = gym["leader"] badge = gym.get("badge", "Unknown Badge") team = gym.get("team", []) print(f"\nChallenging Gym: {leader} - {badge}") leader_trainer = build_trainer_from_names(leader, team, level=max(10, player.team[0].level)) winner = battle(player, leader_trainer, verbose=True) if winner != player: print("You lost the gym challenge.") return False

Victory: award badge

player.badges.append(badge) print(f"You earned the {badge}!") print("You cleared all gyms in region!") return True

---------- CLI ----------

def main(): print("Pokémon Bot (CLI) - Powered by PokéAPI") print("Commands: regions, gens, list , details , train , gym , exit") player = Trainer(name="Player")

starter: let player pick a starter species by name or default bulbasaur

starter_name = input("Pick a starter (bulbasaur / salamander / squirtle) [bulbasaur]: ").strip().lower() or "bulbasaur" try: data = get_pokemon_data(starter_name) except: print("Couldn't fetch starter, using bulbasaur") starter_name = "bulbasaur" data = get_pokemon_data("bulbasaur") starter = PokemonInstance(species_name=starter_name, level=5) starter.init_from_api(data) player.team.append(starter) print(f"You got {starter_name.title()} (Lv{starter.level})!") while True: try: cmd = input("\n> ").strip().lower() except (EOFError, KeyboardInterrupt): print("\nGoodbye.") break if not cmd: continue parts = cmd.split() if parts[0] == "regions": regs = list_regions() print("Regions:", ", ".join(regs)) elif parts[0] == "gens": gens = list_generations() print("Generations:", ", ".join(gens)) elif parts[0] == "list" and len(parts) > 1:

assume the argument is generation name or id

target = parts[1] try: species = pokemon_species_in_generation(target) print(f"Species in generation {target}: {len(species)} entries. Example: {', '.join(species[:20])}") except Exception as e: print("Error:", e) elif parts[0] == "details" and len(parts) > 1: name = parts[1] try: data = get_pokemon_data(name) print(f"Name: {data['name']} ID: {data['id']} Types: {[t['type']['name'] for t in data['types']]}") print("Base stats:") for s in data["stats"]: print(f" {s['stat']['name']}: {s['base_stat']}") except Exception as e: print("Error fetching:", e) elif parts[0] == "train" and len(parts) >= 3: pname = parts[1]; amt = int(parts[2]) p = next((x for x in player.team if x.species_name == pname), None) if not p: print("You don't have that Pokemon.") continue gained = grant_exp(p, amt) print(f"Granted {amt} EXP. Levels gained: {gained}. Now level {p.level}.") evolved, msg = check_and_apply_evolution(p) if evolved: print(msg) elif parts[0] == "gym" and len(parts) >= 2: region = parts[1] run_gym_challenge(region, player) elif parts[0] == "team": for p in player.team: print(f"{p.species_name} Lv{p.level} HP:{p.current_hp}/{p.max_hp()} EXP:{p.exp}") elif parts[0] in ("exit", "quit"): print("Bye.") break else: print("Unknown command.") if name == "main": main()