Spaces:
Sleeping
Sleeping
| """ | |
| Character Creator Agent - D&D character generation for D'n'D Campaign Manager | |
| """ | |
| import uuid | |
| from typing import Optional, Dict, Any | |
| from datetime import datetime | |
| from src.models.character import ( | |
| Character, CharacterStats, CharacterBackground, | |
| DnDRace, DnDClass, Alignment, HIT_DICE_BY_CLASS | |
| ) | |
| from src.utils.ai_client import get_ai_client | |
| from src.utils.dice import DiceRoller | |
| from src.utils.database import get_database | |
| from src.utils.validators import validate_character | |
| from src.utils.image_generator import get_image_generator | |
| class CharacterAgent: | |
| """Agent for creating D&D characters""" | |
| def __init__(self): | |
| self.ai_client = get_ai_client() | |
| self.dice_roller = DiceRoller() | |
| self.database = get_database() | |
| try: | |
| self.image_generator = get_image_generator() | |
| except Exception as e: | |
| print(f"Warning: Image generator not available: {e}") | |
| self.image_generator = None | |
| def create_character( | |
| self, | |
| name: Optional[str] = None, | |
| race: Optional[DnDRace] = None, | |
| character_class: Optional[DnDClass] = None, | |
| level: int = 1, | |
| background_type: Optional[str] = None, | |
| personality_prompt: Optional[str] = None, | |
| stats_method: str = "standard_array", # "roll", "standard_array", "point_buy" | |
| custom_stats: Optional[Dict[str, int]] = None, | |
| ) -> Character: | |
| """ | |
| Create a complete D&D character | |
| Args: | |
| name: Character name (auto-generated if None) | |
| race: Character race (random if None) | |
| character_class: Character class (random if None) | |
| level: Starting level (1-20) | |
| background_type: Background type | |
| personality_prompt: Prompt to generate personality | |
| stats_method: How to generate ability scores | |
| custom_stats: Pre-set ability scores | |
| Returns: | |
| Complete Character object | |
| """ | |
| # Generate character ID | |
| character_id = str(uuid.uuid4()) | |
| # Generate name if not provided | |
| if not name: | |
| name = self._generate_name(race, character_class) | |
| # Select race and class if not provided | |
| if not race: | |
| race = self._select_random_race() | |
| if not character_class: | |
| character_class = self._select_random_class() | |
| # Generate ability scores | |
| if custom_stats: | |
| stats = CharacterStats(**custom_stats) | |
| else: | |
| stats = self._generate_stats(stats_method) | |
| # Apply racial ability score bonuses (D&D 5e rule) | |
| stats = self._apply_racial_bonuses(stats, race) | |
| # Calculate HP | |
| max_hp = self._calculate_starting_hp(character_class, stats.constitution_modifier, level) | |
| # Generate background and personality | |
| background = self._generate_background( | |
| name, race, character_class, background_type, personality_prompt | |
| ) | |
| # Generate alignment based on personality | |
| alignment = self._determine_alignment(background) | |
| # Get starting equipment | |
| equipment = self._get_starting_equipment(character_class) | |
| # Get class features | |
| features = self._get_class_features(character_class, level) | |
| # Get proficiencies | |
| proficiencies = self._get_proficiencies(character_class, background.background_type) | |
| # Calculate AC (base 10 + dex modifier) | |
| armor_class = 10 + stats.dexterity_modifier | |
| # Create character | |
| character = Character( | |
| id=character_id, | |
| name=name, | |
| race=race, | |
| character_class=character_class, | |
| level=level, | |
| alignment=alignment, | |
| stats=stats, | |
| max_hit_points=max_hp, | |
| current_hit_points=max_hp, | |
| armor_class=armor_class, | |
| background=background, | |
| equipment=equipment, | |
| features=features, | |
| proficiencies=proficiencies, | |
| ) | |
| # Validate character | |
| is_valid, errors = validate_character(character) | |
| if not is_valid: | |
| raise ValueError(f"Character validation failed: {', '.join(errors)}") | |
| # Save to database | |
| self.save_character(character) | |
| return character | |
| def generate_name( | |
| self, | |
| race: Optional[DnDRace] = None, | |
| character_class: Optional[DnDClass] = None, | |
| gender: Optional[str] = None | |
| ) -> str: | |
| """ | |
| PUBLIC method to generate character name using AI | |
| Can be called independently of character creation | |
| Args: | |
| race: Character race (optional) | |
| character_class: Character class (optional) | |
| gender: Character gender (optional) | |
| Returns: | |
| Generated character name | |
| """ | |
| gender_text = f"\nGender: {gender}" if gender and gender != "Not specified" else "" | |
| prompt = f"""Generate a single fantasy character name for a D&D character. | |
| Race: {race.value if race else 'any race'} | |
| Class: {character_class.value if character_class else 'any class'}{gender_text} | |
| Requirements: | |
| - Just the name, nothing else | |
| - Make it sound appropriate for the race{' and gender' if gender_text else ''} | |
| - Make it memorable and fitting for an adventurer | |
| - 2-3 words maximum | |
| Example formats: | |
| - "Thorin Ironforge" (Male Dwarf) | |
| - "Elara Moonwhisper" (Female Elf) | |
| - "Grunk Bonecrusher" (Male Orc) | |
| - "Pip Thornberry" (Any Halfling) | |
| Generate only the name:""" | |
| try: | |
| name = self.ai_client.generate_creative(prompt).strip() | |
| # Clean up any extra text | |
| name = name.split('\n')[0].strip('"\'') | |
| return name | |
| except Exception as e: | |
| # Fallback to simple name generation | |
| import random | |
| prefixes = ["Brave", "Bold", "Swift", "Wise", "Dark", "Bright"] | |
| suffixes = ["blade", "heart", "forge", "walker", "runner", "seeker"] | |
| return f"{random.choice(prefixes)}{random.choice(suffixes)}" | |
| def _generate_name(self, race: Optional[DnDRace], character_class: Optional[DnDClass]) -> str: | |
| """ | |
| PRIVATE method - calls public generate_name | |
| Kept for backward compatibility | |
| """ | |
| return self.generate_name(race, character_class) | |
| def _select_random_race(self) -> DnDRace: | |
| """Select random race""" | |
| import random | |
| return random.choice(list(DnDRace)) | |
| def _select_random_class(self) -> DnDClass: | |
| """Select random class""" | |
| import random | |
| return random.choice(list(DnDClass)) | |
| def _generate_stats(self, method: str) -> CharacterStats: | |
| """Generate ability scores""" | |
| if method == "roll": | |
| # Roll 4d6 drop lowest | |
| stats_dict = self.dice_roller.roll_stats() | |
| return CharacterStats(**stats_dict) | |
| elif method == "standard_array": | |
| # Standard array: 15, 14, 13, 12, 10, 8 | |
| import random | |
| array = [15, 14, 13, 12, 10, 8] | |
| random.shuffle(array) | |
| return CharacterStats( | |
| strength=array[0], | |
| dexterity=array[1], | |
| constitution=array[2], | |
| intelligence=array[3], | |
| wisdom=array[4], | |
| charisma=array[5] | |
| ) | |
| elif method == "point_buy": | |
| # Balanced point buy (27 points) | |
| return CharacterStats( | |
| strength=13, | |
| dexterity=14, | |
| constitution=13, | |
| intelligence=12, | |
| wisdom=10, | |
| charisma=10 | |
| ) | |
| else: | |
| # Default to standard array | |
| return CharacterStats() | |
| def _apply_racial_bonuses(self, stats: CharacterStats, race: DnDRace) -> CharacterStats: | |
| """Apply racial ability score increases per D&D 5e PHB""" | |
| racial_bonuses = { | |
| DnDRace.HUMAN: {"strength": 1, "dexterity": 1, "constitution": 1, | |
| "intelligence": 1, "wisdom": 1, "charisma": 1}, | |
| DnDRace.ELF: {"dexterity": 2}, | |
| DnDRace.DWARF: {"constitution": 2}, | |
| DnDRace.HALFLING: {"dexterity": 2}, | |
| DnDRace.DRAGONBORN: {"strength": 2, "charisma": 1}, | |
| DnDRace.GNOME: {"intelligence": 2}, | |
| DnDRace.HALF_ELF: {"charisma": 2}, # +1 to two highest (auto-assigned) | |
| DnDRace.HALF_ORC: {"strength": 2, "constitution": 1}, | |
| DnDRace.TIEFLING: {"charisma": 2, "intelligence": 1}, | |
| DnDRace.DROW: {"dexterity": 2, "charisma": 1}, | |
| } | |
| bonuses = racial_bonuses.get(race, {}) | |
| stats_dict = stats.model_dump() | |
| # Apply bonuses, capping at 20 per D&D 5e standard rules | |
| for ability, bonus in bonuses.items(): | |
| stats_dict[ability] = min(20, stats_dict[ability] + bonus) | |
| # Half-Elf special case: +1 to two highest abilities after CHA | |
| if race == DnDRace.HALF_ELF: | |
| # Find two highest abilities (excluding charisma which already got +2) | |
| abilities_except_cha = [(k, v) for k, v in stats_dict.items() if k != "charisma"] | |
| abilities_except_cha.sort(key=lambda x: x[1], reverse=True) | |
| # Apply +1 to top two (capped at 20) | |
| for i in range(min(2, len(abilities_except_cha))): | |
| ability_name = abilities_except_cha[i][0] | |
| stats_dict[ability_name] = min(20, stats_dict[ability_name] + 1) | |
| return CharacterStats(**stats_dict) | |
| def _calculate_starting_hp(self, character_class: DnDClass, con_modifier: int, level: int) -> int: | |
| """Calculate starting hit points (D&D 5e rules)""" | |
| hit_die = HIT_DICE_BY_CLASS.get(character_class, 8) | |
| # First level: max hit die + con mod | |
| # Subsequent levels: average of hit die + con mod | |
| first_level_hp = hit_die + con_modifier | |
| subsequent_hp = ((hit_die // 2) + 1 + con_modifier) * (level - 1) | |
| return max(1, first_level_hp + subsequent_hp) | |
| def _generate_background( | |
| self, | |
| name: str, | |
| race: DnDRace, | |
| character_class: DnDClass, | |
| background_type: Optional[str], | |
| personality_prompt: Optional[str] | |
| ) -> CharacterBackground: | |
| """Generate character background and personality using AI""" | |
| system_prompt = """You are a D&D character background generator. | |
| Create compelling, detailed character backgrounds that feel authentic and provide hooks for roleplay. | |
| Be creative but grounded in D&D lore.""" | |
| prompt = f"""Generate a complete character background for: | |
| Name: {name} | |
| Race: {race.value} | |
| Class: {character_class.value} | |
| Background Type: {background_type or 'Adventurer'} | |
| {f'Additional guidance: {personality_prompt}' if personality_prompt else ''} | |
| Generate in this EXACT format: | |
| PERSONALITY TRAITS: | |
| - [trait 1] | |
| - [trait 2] | |
| IDEALS: | |
| [One core ideal that drives them] | |
| BONDS: | |
| [What/who they care about most] | |
| FLAWS: | |
| [A meaningful character flaw] | |
| BACKSTORY: | |
| [2-3 paragraphs of compelling backstory that explains how they became an adventurer] | |
| GOALS: | |
| - [goal 1] | |
| - [goal 2] | |
| Keep it concise but evocative. Focus on what makes this character interesting to play.""" | |
| response = self.ai_client.generate_creative(prompt, system_prompt=system_prompt) | |
| # Parse response | |
| background = self._parse_background_response(response, background_type or "Adventurer") | |
| return background | |
| def _parse_background_response(self, response: str, background_type: str) -> CharacterBackground: | |
| """Parse AI response into CharacterBackground""" | |
| lines = response.strip().split('\n') | |
| traits = [] | |
| ideals = "" | |
| bonds = "" | |
| flaws = "" | |
| backstory = "" | |
| goals = [] | |
| current_section = None | |
| backstory_lines = [] | |
| for line in lines: | |
| line = line.strip() | |
| if not line: | |
| continue | |
| if line.startswith('PERSONALITY TRAITS:'): | |
| current_section = 'traits' | |
| elif line.startswith('IDEALS:'): | |
| current_section = 'ideals' | |
| elif line.startswith('BONDS:'): | |
| current_section = 'bonds' | |
| elif line.startswith('FLAWS:'): | |
| current_section = 'flaws' | |
| elif line.startswith('BACKSTORY:'): | |
| current_section = 'backstory' | |
| elif line.startswith('GOALS:'): | |
| current_section = 'goals' | |
| elif line.startswith('-'): | |
| content = line[1:].strip() | |
| if current_section == 'traits': | |
| traits.append(content) | |
| elif current_section == 'goals': | |
| goals.append(content) | |
| else: | |
| if current_section == 'ideals': | |
| ideals += line + " " | |
| elif current_section == 'bonds': | |
| bonds += line + " " | |
| elif current_section == 'flaws': | |
| flaws += line + " " | |
| elif current_section == 'backstory': | |
| backstory_lines.append(line) | |
| backstory = '\n'.join(backstory_lines).strip() | |
| return CharacterBackground( | |
| background_type=background_type, | |
| personality_traits=traits[:3], # Max 3 traits | |
| ideals=ideals.strip(), | |
| bonds=bonds.strip(), | |
| flaws=flaws.strip(), | |
| backstory=backstory, | |
| goals=goals | |
| ) | |
| def _determine_alignment(self, background: CharacterBackground) -> Alignment: | |
| """Determine alignment based on personality""" | |
| # Simple heuristic based on ideals and traits | |
| ideals_lower = background.ideals.lower() | |
| if 'law' in ideals_lower or 'order' in ideals_lower or 'honor' in ideals_lower: | |
| if 'help' in ideals_lower or 'good' in ideals_lower or 'kind' in ideals_lower: | |
| return Alignment.LAWFUL_GOOD | |
| elif 'evil' in ideals_lower or 'power' in ideals_lower: | |
| return Alignment.LAWFUL_EVIL | |
| else: | |
| return Alignment.LAWFUL_NEUTRAL | |
| elif 'chaos' in ideals_lower or 'freedom' in ideals_lower: | |
| if 'help' in ideals_lower or 'good' in ideals_lower: | |
| return Alignment.CHAOTIC_GOOD | |
| elif 'evil' in ideals_lower or 'selfish' in ideals_lower: | |
| return Alignment.CHAOTIC_EVIL | |
| else: | |
| return Alignment.CHAOTIC_NEUTRAL | |
| else: | |
| if 'help' in ideals_lower or 'good' in ideals_lower: | |
| return Alignment.NEUTRAL_GOOD | |
| elif 'evil' in ideals_lower: | |
| return Alignment.NEUTRAL_EVIL | |
| else: | |
| return Alignment.TRUE_NEUTRAL | |
| def _get_starting_equipment(self, character_class: DnDClass) -> list: | |
| """Get starting equipment for class""" | |
| equipment_by_class = { | |
| DnDClass.FIGHTER: ["Longsword", "Shield", "Chain Mail", "Explorer's Pack"], | |
| DnDClass.WIZARD: ["Spellbook", "Quarterstaff", "Component Pouch", "Scholar's Pack"], | |
| DnDClass.ROGUE: ["Shortbow", "Arrows (20)", "Leather Armor", "Thieves' Tools", "Burglar's Pack"], | |
| DnDClass.CLERIC: ["Mace", "Scale Mail", "Holy Symbol", "Priest's Pack"], | |
| DnDClass.RANGER: ["Longbow", "Arrows (20)", "Leather Armor", "Explorer's Pack"], | |
| DnDClass.PALADIN: ["Longsword", "Shield", "Chain Mail", "Holy Symbol", "Priest's Pack"], | |
| DnDClass.BARD: ["Rapier", "Lute", "Leather Armor", "Entertainer's Pack"], | |
| DnDClass.BARBARIAN: ["Greataxe", "Javelin (4)", "Explorer's Pack"], | |
| DnDClass.DRUID: ["Quarterstaff", "Leather Armor", "Druidic Focus", "Explorer's Pack"], | |
| DnDClass.MONK: ["Shortsword", "Dart (10)", "Explorer's Pack"], | |
| DnDClass.SORCERER: ["Dagger (2)", "Component Pouch", "Dungeoneer's Pack"], | |
| DnDClass.WARLOCK: ["Crossbow", "Bolts (20)", "Leather Armor", "Component Pouch", "Scholar's Pack"], | |
| } | |
| return equipment_by_class.get(character_class, ["Basic Equipment"]) | |
| def _get_class_features(self, character_class: DnDClass, level: int) -> list: | |
| """Get class features for level (D&D 5e PHB)""" | |
| # Features by class and level | |
| features_by_level = { | |
| DnDClass.FIGHTER: { | |
| 1: ["Fighting Style", "Second Wind"], | |
| 2: ["Action Surge (1 use)"], | |
| 3: ["Martial Archetype"], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Extra Attack (1)"], | |
| 6: ["Ability Score Improvement"], | |
| 7: ["Martial Archetype Feature"], | |
| 8: ["Ability Score Improvement"], | |
| 9: ["Indomitable (1 use)"], | |
| 10: ["Martial Archetype Feature"], | |
| 11: ["Extra Attack (2)"], | |
| 12: ["Ability Score Improvement"], | |
| 13: ["Indomitable (2 uses)"], | |
| 14: ["Ability Score Improvement"], | |
| 15: ["Martial Archetype Feature"], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Action Surge (2 uses)", "Indomitable (3 uses)"], | |
| 18: ["Martial Archetype Feature"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Extra Attack (3)"], | |
| }, | |
| DnDClass.WIZARD: { | |
| 1: ["Spellcasting", "Arcane Recovery"], | |
| 2: ["Arcane Tradition"], | |
| 3: [], | |
| 4: ["Ability Score Improvement"], | |
| 5: [], | |
| 6: ["Arcane Tradition Feature"], | |
| 7: [], | |
| 8: ["Ability Score Improvement"], | |
| 9: [], | |
| 10: ["Arcane Tradition Feature"], | |
| 11: [], | |
| 12: ["Ability Score Improvement"], | |
| 13: [], | |
| 14: ["Arcane Tradition Feature"], | |
| 15: [], | |
| 16: ["Ability Score Improvement"], | |
| 17: [], | |
| 18: ["Spell Mastery"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Signature Spells"], | |
| }, | |
| DnDClass.ROGUE: { | |
| 1: ["Expertise", "Sneak Attack (1d6)", "Thieves' Cant"], | |
| 2: ["Cunning Action"], | |
| 3: ["Sneak Attack (2d6)", "Roguish Archetype"], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Sneak Attack (3d6)", "Uncanny Dodge"], | |
| 6: ["Expertise"], | |
| 7: ["Sneak Attack (4d6)", "Evasion"], | |
| 8: ["Ability Score Improvement"], | |
| 9: ["Sneak Attack (5d6)", "Roguish Archetype Feature"], | |
| 10: ["Ability Score Improvement"], | |
| 11: ["Sneak Attack (6d6)", "Reliable Talent"], | |
| 12: ["Ability Score Improvement"], | |
| 13: ["Sneak Attack (7d6)", "Roguish Archetype Feature"], | |
| 14: ["Blindsense"], | |
| 15: ["Sneak Attack (8d6)", "Slippery Mind"], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Sneak Attack (9d6)", "Roguish Archetype Feature"], | |
| 18: ["Elusive"], | |
| 19: ["Sneak Attack (10d6)", "Ability Score Improvement"], | |
| 20: ["Stroke of Luck"], | |
| }, | |
| DnDClass.CLERIC: { | |
| 1: ["Spellcasting", "Divine Domain"], | |
| 2: ["Channel Divinity (1/rest)", "Divine Domain Feature"], | |
| 3: [], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Destroy Undead (CR 1/2)"], | |
| 6: ["Channel Divinity (2/rest)", "Divine Domain Feature"], | |
| 7: [], | |
| 8: ["Ability Score Improvement", "Destroy Undead (CR 1)", "Divine Domain Feature"], | |
| 9: [], | |
| 10: ["Divine Intervention"], | |
| 11: ["Destroy Undead (CR 2)"], | |
| 12: ["Ability Score Improvement"], | |
| 13: [], | |
| 14: ["Destroy Undead (CR 3)"], | |
| 15: [], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Destroy Undead (CR 4)", "Divine Domain Feature"], | |
| 18: ["Channel Divinity (3/rest)"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Divine Intervention Improvement"], | |
| }, | |
| DnDClass.RANGER: { | |
| 1: ["Favored Enemy", "Natural Explorer"], | |
| 2: ["Fighting Style", "Spellcasting"], | |
| 3: ["Ranger Archetype", "Primeval Awareness"], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Extra Attack"], | |
| 6: ["Favored Enemy Improvement", "Natural Explorer Improvement"], | |
| 7: ["Ranger Archetype Feature"], | |
| 8: ["Ability Score Improvement", "Land's Stride"], | |
| 9: [], | |
| 10: ["Natural Explorer Improvement", "Hide in Plain Sight"], | |
| 11: ["Ranger Archetype Feature"], | |
| 12: ["Ability Score Improvement"], | |
| 13: [], | |
| 14: ["Favored Enemy Improvement", "Vanish"], | |
| 15: ["Ranger Archetype Feature"], | |
| 16: ["Ability Score Improvement"], | |
| 17: [], | |
| 18: ["Feral Senses"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Foe Slayer"], | |
| }, | |
| DnDClass.PALADIN: { | |
| 1: ["Divine Sense", "Lay on Hands"], | |
| 2: ["Fighting Style", "Spellcasting", "Divine Smite"], | |
| 3: ["Divine Health", "Sacred Oath"], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Extra Attack"], | |
| 6: ["Aura of Protection"], | |
| 7: ["Sacred Oath Feature"], | |
| 8: ["Ability Score Improvement"], | |
| 9: [], | |
| 10: ["Aura of Courage"], | |
| 11: ["Improved Divine Smite"], | |
| 12: ["Ability Score Improvement"], | |
| 13: [], | |
| 14: ["Cleansing Touch"], | |
| 15: ["Sacred Oath Feature"], | |
| 16: ["Ability Score Improvement"], | |
| 17: [], | |
| 18: ["Aura Improvements"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Sacred Oath Feature"], | |
| }, | |
| DnDClass.BARD: { | |
| 1: ["Spellcasting", "Bardic Inspiration (d6)"], | |
| 2: ["Jack of All Trades", "Song of Rest (d6)"], | |
| 3: ["Bard College", "Expertise"], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Bardic Inspiration (d8)", "Font of Inspiration"], | |
| 6: ["Countercharm", "Bard College Feature"], | |
| 7: [], | |
| 8: ["Ability Score Improvement"], | |
| 9: ["Song of Rest (d8)"], | |
| 10: ["Bardic Inspiration (d10)", "Expertise", "Magical Secrets"], | |
| 11: [], | |
| 12: ["Ability Score Improvement"], | |
| 13: ["Song of Rest (d10)"], | |
| 14: ["Magical Secrets", "Bard College Feature"], | |
| 15: ["Bardic Inspiration (d12)"], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Song of Rest (d12)"], | |
| 18: ["Magical Secrets"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Superior Inspiration"], | |
| }, | |
| DnDClass.BARBARIAN: { | |
| 1: ["Rage (2/day)", "Unarmored Defense"], | |
| 2: ["Reckless Attack", "Danger Sense"], | |
| 3: ["Primal Path", "Rage (3/day)"], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Extra Attack", "Fast Movement"], | |
| 6: ["Path Feature", "Rage (4/day)"], | |
| 7: ["Feral Instinct"], | |
| 8: ["Ability Score Improvement"], | |
| 9: ["Brutal Critical (1 die)"], | |
| 10: ["Path Feature", "Rage (5/day)"], | |
| 11: ["Relentless Rage"], | |
| 12: ["Ability Score Improvement", "Rage (6/day)"], | |
| 13: ["Brutal Critical (2 dice)"], | |
| 14: ["Path Feature"], | |
| 15: ["Persistent Rage"], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Brutal Critical (3 dice)", "Rage (Unlimited)"], | |
| 18: ["Indomitable Might"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Primal Champion"], | |
| }, | |
| DnDClass.DRUID: { | |
| 1: ["Druidic", "Spellcasting"], | |
| 2: ["Wild Shape", "Druid Circle"], | |
| 3: [], | |
| 4: ["Wild Shape Improvement", "Ability Score Improvement"], | |
| 5: [], | |
| 6: ["Druid Circle Feature"], | |
| 7: [], | |
| 8: ["Wild Shape Improvement", "Ability Score Improvement"], | |
| 9: [], | |
| 10: ["Druid Circle Feature"], | |
| 11: [], | |
| 12: ["Ability Score Improvement"], | |
| 13: [], | |
| 14: ["Druid Circle Feature"], | |
| 15: [], | |
| 16: ["Ability Score Improvement"], | |
| 17: [], | |
| 18: ["Timeless Body", "Beast Spells"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Archdruid"], | |
| }, | |
| DnDClass.MONK: { | |
| 1: ["Unarmored Defense", "Martial Arts (1d4)"], | |
| 2: ["Ki", "Unarmored Movement"], | |
| 3: ["Monastic Tradition", "Deflect Missiles"], | |
| 4: ["Ability Score Improvement", "Slow Fall"], | |
| 5: ["Extra Attack", "Stunning Strike", "Martial Arts (1d6)"], | |
| 6: ["Ki-Empowered Strikes", "Monastic Tradition Feature"], | |
| 7: ["Evasion", "Stillness of Mind"], | |
| 8: ["Ability Score Improvement"], | |
| 9: ["Unarmored Movement Improvement"], | |
| 10: ["Purity of Body"], | |
| 11: ["Monastic Tradition Feature", "Martial Arts (1d8)"], | |
| 12: ["Ability Score Improvement"], | |
| 13: ["Tongue of the Sun and Moon"], | |
| 14: ["Diamond Soul"], | |
| 15: ["Timeless Body"], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Monastic Tradition Feature", "Martial Arts (1d10)"], | |
| 18: ["Empty Body"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Perfect Self"], | |
| }, | |
| DnDClass.SORCERER: { | |
| 1: ["Spellcasting", "Sorcerous Origin"], | |
| 2: ["Font of Magic"], | |
| 3: ["Metamagic (2 options)"], | |
| 4: ["Ability Score Improvement"], | |
| 5: [], | |
| 6: ["Sorcerous Origin Feature"], | |
| 7: [], | |
| 8: ["Ability Score Improvement"], | |
| 9: [], | |
| 10: ["Metamagic (3 options)"], | |
| 11: [], | |
| 12: ["Ability Score Improvement"], | |
| 13: [], | |
| 14: ["Sorcerous Origin Feature"], | |
| 15: [], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Metamagic (4 options)"], | |
| 18: ["Sorcerous Origin Feature"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Sorcerous Restoration"], | |
| }, | |
| DnDClass.WARLOCK: { | |
| 1: ["Otherworldly Patron", "Pact Magic"], | |
| 2: ["Eldritch Invocations (2)"], | |
| 3: ["Pact Boon"], | |
| 4: ["Ability Score Improvement"], | |
| 5: ["Eldritch Invocations (3)"], | |
| 6: ["Otherworldly Patron Feature"], | |
| 7: ["Eldritch Invocations (4)"], | |
| 8: ["Ability Score Improvement"], | |
| 9: ["Eldritch Invocations (5)"], | |
| 10: ["Otherworldly Patron Feature"], | |
| 11: ["Mystic Arcanum (6th level)"], | |
| 12: ["Ability Score Improvement", "Eldritch Invocations (6)"], | |
| 13: ["Mystic Arcanum (7th level)"], | |
| 14: ["Otherworldly Patron Feature"], | |
| 15: ["Mystic Arcanum (8th level)", "Eldritch Invocations (7)"], | |
| 16: ["Ability Score Improvement"], | |
| 17: ["Mystic Arcanum (9th level)"], | |
| 18: ["Eldritch Invocations (8)"], | |
| 19: ["Ability Score Improvement"], | |
| 20: ["Eldritch Master"], | |
| }, | |
| } | |
| # Get features for this class up to the current level | |
| class_features_by_level = features_by_level.get(character_class, {}) | |
| all_features = [] | |
| for lvl in range(1, min(level + 1, 21)): | |
| all_features.extend(class_features_by_level.get(lvl, [])) | |
| return all_features if all_features else ["Class Features"] | |
| def _get_proficiencies(self, character_class: DnDClass, background: str) -> list: | |
| """ | |
| Get proficiencies - includes fixed proficiencies and notes about choices | |
| Players need to make skill choices in D&D 5e | |
| """ | |
| # Saving throw proficiencies (FIXED - no choice) | |
| saves = { | |
| DnDClass.FIGHTER: ["Saving Throws: Strength, Constitution"], | |
| DnDClass.WIZARD: ["Saving Throws: Intelligence, Wisdom"], | |
| DnDClass.ROGUE: ["Saving Throws: Dexterity, Intelligence"], | |
| DnDClass.CLERIC: ["Saving Throws: Wisdom, Charisma"], | |
| DnDClass.RANGER: ["Saving Throws: Strength, Dexterity"], | |
| DnDClass.PALADIN: ["Saving Throws: Wisdom, Charisma"], | |
| DnDClass.BARD: ["Saving Throws: Dexterity, Charisma"], | |
| DnDClass.BARBARIAN: ["Saving Throws: Strength, Constitution"], | |
| DnDClass.DRUID: ["Saving Throws: Intelligence, Wisdom"], | |
| DnDClass.MONK: ["Saving Throws: Strength, Dexterity"], | |
| DnDClass.SORCERER: ["Saving Throws: Constitution, Charisma"], | |
| DnDClass.WARLOCK: ["Saving Throws: Wisdom, Charisma"], | |
| } | |
| # Armor and weapon proficiencies (FIXED - no choice) | |
| armor_weapons = { | |
| DnDClass.FIGHTER: ["All armor", "All shields", "Simple weapons", "Martial weapons"], | |
| DnDClass.WIZARD: ["Weapons: Daggers, Darts, Slings, Quarterstaffs, Light crossbows"], | |
| DnDClass.ROGUE: ["Light armor", "Weapons: Simple weapons, Hand crossbows, Longswords, Rapiers, Shortswords", "Tools: Thieves' tools"], | |
| DnDClass.CLERIC: ["Light armor", "Medium armor", "Shields", "Simple weapons"], | |
| DnDClass.RANGER: ["Light armor", "Medium armor", "Shields", "Simple weapons", "Martial weapons"], | |
| DnDClass.PALADIN: ["All armor", "All shields", "Simple weapons", "Martial weapons"], | |
| DnDClass.BARD: ["Light armor", "Weapons: Simple weapons, Hand crossbows, Longswords, Rapiers, Shortswords", "Tools: Three musical instruments of your choice"], | |
| DnDClass.BARBARIAN: ["Light armor", "Medium armor", "Shields", "Simple weapons", "Martial weapons"], | |
| DnDClass.DRUID: ["Light armor (nonmetal)", "Medium armor (nonmetal)", "Shields (nonmetal)", "Weapons: Clubs, Daggers, Darts, Javelins, Maces, Quarterstaffs, Scimitars, Sickles, Slings, Spears", "Tools: Herbalism kit"], | |
| DnDClass.MONK: ["Weapons: Simple weapons, Shortswords", "Tools: Choose one artisan's tool or musical instrument"], | |
| DnDClass.SORCERER: ["Weapons: Daggers, Darts, Slings, Quarterstaffs, Light crossbows"], | |
| DnDClass.WARLOCK: ["Light armor", "Simple weapons"], | |
| } | |
| # Skill choices (PLAYER MUST CHOOSE - provide guidance) | |
| skill_choices = { | |
| DnDClass.FIGHTER: ["Choose 2 skills from: Acrobatics, Animal Handling, Athletics, History, Insight, Intimidation, Perception, Survival"], | |
| DnDClass.WIZARD: ["Choose 2 skills from: Arcana, History, Insight, Investigation, Medicine, Religion"], | |
| DnDClass.ROGUE: ["Choose 4 skills from: Acrobatics, Athletics, Deception, Insight, Intimidation, Investigation, Perception, Performance, Persuasion, Sleight of Hand, Stealth"], | |
| DnDClass.CLERIC: ["Choose 2 skills from: History, Insight, Medicine, Persuasion, Religion"], | |
| DnDClass.RANGER: ["Choose 3 skills from: Animal Handling, Athletics, Insight, Investigation, Nature, Perception, Stealth, Survival"], | |
| DnDClass.PALADIN: ["Choose 2 skills from: Athletics, Insight, Intimidation, Medicine, Persuasion, Religion"], | |
| DnDClass.BARD: ["Choose any 3 skills"], | |
| DnDClass.BARBARIAN: ["Choose 2 skills from: Animal Handling, Athletics, Intimidation, Nature, Perception, Survival"], | |
| DnDClass.DRUID: ["Choose 2 skills from: Arcana, Animal Handling, Insight, Medicine, Nature, Perception, Religion, Survival"], | |
| DnDClass.MONK: ["Choose 2 skills from: Acrobatics, Athletics, History, Insight, Religion, Stealth"], | |
| DnDClass.SORCERER: ["Choose 2 skills from: Arcana, Deception, Insight, Intimidation, Persuasion, Religion"], | |
| DnDClass.WARLOCK: ["Choose 2 skills from: Arcana, Deception, History, Intimidation, Investigation, Nature, Religion"], | |
| } | |
| # Background provides 2 additional skills (VARIES - typical examples provided) | |
| background_note = f"Background ({background}): Grants 2 additional skill proficiencies (varies by background)" | |
| # Combine all proficiencies | |
| proficiencies = [] | |
| proficiencies.extend(saves.get(character_class, [])) | |
| proficiencies.extend(armor_weapons.get(character_class, [])) | |
| proficiencies.extend(skill_choices.get(character_class, [])) | |
| proficiencies.append(background_note) | |
| return proficiencies | |
| def save_character(self, character: Character): | |
| """Save character to database""" | |
| self.database.save( | |
| entity_id=character.id, | |
| entity_type="character", | |
| data=character.to_dict() | |
| ) | |
| def load_character(self, character_id: str) -> Optional[Character]: | |
| """Load character from database""" | |
| data = self.database.load(character_id, "character") | |
| if data: | |
| return Character(**data) | |
| return None | |
| def list_characters(self) -> list[Character]: | |
| """List all saved characters""" | |
| characters_data = self.database.load_all("character") | |
| return [Character(**data) for data in characters_data] | |
| def delete_character(self, character_id: str): | |
| """Delete character from database""" | |
| self.database.delete(character_id) | |
| def generate_portrait( | |
| self, | |
| character: Character, | |
| style: str = "fantasy art", | |
| quality: str = "standard", | |
| provider: str = "auto" | |
| ) -> tuple[Optional[str], Optional[str]]: | |
| """ | |
| Generate character portrait using DALL-E 3 or HuggingFace | |
| Args: | |
| character: Character to generate portrait for | |
| style: Art style (e.g., "fantasy art", "digital painting", "anime") | |
| quality: Image quality ("standard" or "hd") - OpenAI only | |
| provider: "openai", "huggingface", or "auto" | |
| Returns: | |
| Tuple of (file_path, status_message) | |
| """ | |
| if not self.image_generator: | |
| return None, "❌ Image generation not available (API key required)" | |
| try: | |
| file_path, image_bytes = self.image_generator.generate_character_portrait( | |
| character=character, | |
| style=style, | |
| quality=quality, | |
| provider=provider | |
| ) | |
| if file_path: | |
| return file_path, f"✅ Portrait generated successfully!\nSaved to: {file_path}" | |
| else: | |
| return None, "❌ Failed to generate portrait" | |
| except Exception as e: | |
| return None, f"❌ Error generating portrait: {str(e)}" | |
| def get_portrait_path(self, character_id: str) -> Optional[str]: | |
| """Get saved portrait path for character""" | |
| if not self.image_generator: | |
| return None | |
| return self.image_generator.get_portrait_path(character_id) | |