Implement core RPG components: Campaign, Character, Combat, Inventory, NPC, Quest, and Spell Managers

Author: PtiCalin

engine/rpg/campaign_manager.py

@@ -0,0 +1,40 @@
+"""
+Campaign Manager for DnD-style RPG
+"""
+class Campaign:
+    def __init__(self, title, description, scenes=None, npcs=None, quests=None):
+        self.title = title
+        self.description = description
+        self.scenes = scenes or []
+        self.npcs = npcs or []
+        self.quests = quests or []
+
+    def add_scene(self, scene):
+        self.scenes.append(scene)
+
+    def add_npc(self, npc):
+        self.npcs.append(npc)
+
+    def add_quest(self, quest):
+        self.quests.append(quest)
+
+    def __repr__(self):
+        return f"<Campaign {self.title} ({len(self.scenes)} scenes)>"
+
+class CampaignManager:
+    def __init__(self):
+        self.campaigns = []
+
+    def create_campaign(self, title, description, **kwargs):
+        campaign = Campaign(title, description, **kwargs)
+        self.campaigns.append(campaign)
+        return campaign
+
+    def get_campaign(self, title):
+        for campaign in self.campaigns:
+            if campaign.title == title:
+                return campaign
+        return None
+
+    def list_campaigns(self):
+        return self.campaigns

engine/rpg/character_manager.py

@@ -0,0 +1,51 @@
+"""
+DnD-style Character Manager for PtiCalin Game Engine
+"""
+
+class Character:
+    def __init__(self, name, race, char_class, level=1, stats=None, inventory=None, spells=None, quests=None):
+        self.name = name
+        self.race = race
+        self.char_class = char_class
+        self.level = level
+        self.stats = stats or {
+            'STR': 10, 'DEX': 10, 'CON': 10, 'INT': 10, 'WIS': 10, 'CHA': 10
+        }
+        self.inventory = inventory or []
+        self.spells = spells or []
+        self.quests = quests or []
+        self.hp = self.max_hp()
+
+    def max_hp(self):
+        # Example: 10 + CON modifier per level
+        return 10 + (self.stats['CON'] - 10) // 2 * self.level
+
+    def add_item(self, item):
+        self.inventory.append(item)
+
+    def add_spell(self, spell):
+        self.spells.append(spell)
+
+    def add_quest(self, quest):
+        self.quests.append(quest)
+
+    def __repr__(self):
+        return f"<Character {self.name} ({self.char_class} Lv{self.level})>"
+
+class CharacterManager:
+    def __init__(self):
+        self.characters = []
+
+    def create_character(self, name, race, char_class, **kwargs):
+        char = Character(name, race, char_class, **kwargs)
+        self.characters.append(char)
+        return char
+
+    def get_character(self, name):
+        for char in self.characters:
+            if char.name == name:
+                return char
+        return None
+
+    def list_characters(self):
+        return self.characters

engine/rpg/combat_engine.py

@@ -0,0 +1,28 @@
+"""
+Simple DnD-style Combat Engine
+"""
+from .character_manager import Character
+from .dice_roller import roll_dice
+
+class CombatEngine:
+    def __init__(self, party, enemies):
+        self.party = party  # list of Character
+        self.enemies = enemies  # list of Character
+        self.turn_order = self.determine_initiative()
+
+    def determine_initiative(self):
+        # Sort by DEX stat, descending
+        all_combatants = self.party + self.enemies
+        return sorted(all_combatants, key=lambda c: c.stats['DEX'], reverse=True)
+
+    def attack(self, attacker, defender):
+        # Roll d20 + STR for melee, DEX for ranged
+        attack_roll, _, _ = roll_dice('1d20')
+        attack_mod = attacker.stats['STR'] if attacker.char_class in ['Fighter', 'Barbarian'] else attacker.stats['DEX']
+        total_attack = attack_roll + (attack_mod - 10) // 2
+        # Simple AC check
+        if total_attack >= defender.stats.get('AC', 10):
+            damage, _, _ = roll_dice('1d8')
+            defender.hp -= damage
+            return True, damage
+        return False, 0

engine/rpg/dice_roller.py

@@ -0,0 +1,20 @@
+"""
+Dice Roller for DnD-style RPG
+"""
+import random
+
+def roll_dice(dice_str):
+    """
+    Roll dice in NdM format, e.g. '2d6+1'
+    Returns total and breakdown.
+    """
+    import re
+    match = re.match(r"(\d+)d(\d+)([+-]\d+)?", dice_str)
+    if not match:
+        raise ValueError("Invalid dice format")
+    n, m, mod = match.groups()
+    n, m = int(n), int(m)
+    mod = int(mod) if mod else 0
+    rolls = [random.randint(1, m) for _ in range(n)]
+    total = sum(rolls) + mod
+    return total, rolls, mod

engine/rpg/inventory_helper.py

@@ -0,0 +1,32 @@
+"""
+Inventory Helper for DnD-style RPG
+"""
+class Item:
+    def __init__(self, name, item_type, description, properties=None):
+        self.name = name
+        self.item_type = item_type  # e.g. weapon, armor, potion
+        self.description = description
+        self.properties = properties or {}
+
+    def __repr__(self):
+        return f"<Item {self.name} ({self.item_type})>"
+
+class InventoryHelper:
+    def __init__(self):
+        self.items = []
+
+    def add_item(self, name, item_type, description, properties=None):
+        item = Item(name, item_type, description, properties)
+        self.items.append(item)
+        return item
+
+    def get_item(self, name):
+        for item in self.items:
+            if item.name == name:
+                return item
+        return None
+
+    def list_items(self, item_type=None):
+        if item_type:
+            return [i for i in self.items if i.item_type == item_type]
+        return self.items

engine/rpg/npc_helper.py

@@ -0,0 +1,33 @@
+"""
+NPC Helper for DnD-style RPG
+"""
+class NPC:
+    def __init__(self, name, traits=None, personality=None, dialogue=None):
+        self.name = name
+        self.traits = traits or {}
+        self.personality = personality or "Neutral"
+        self.dialogue = dialogue or []
+
+    def add_dialogue(self, line):
+        self.dialogue.append(line)
+
+    def __repr__(self):
+        return f"<NPC {self.name} ({self.personality})>"
+
+class NPCHelper:
+    def __init__(self):
+        self.npcs = []
+
+    def add_npc(self, name, traits=None, personality=None, dialogue=None):
+        npc = NPC(name, traits, personality, dialogue)
+        self.npcs.append(npc)
+        return npc
+
+    def get_npc(self, name):
+        for npc in self.npcs:
+            if npc.name == name:
+                return npc
+        return None
+
+    def list_npcs(self):
+        return self.npcs

engine/rpg/quest_manager.py

@@ -0,0 +1,38 @@
+"""
+Quest Manager for DnD-style RPG
+"""
+class Quest:
+    def __init__(self, title, description, status='active', rewards=None):
+        self.title = title
+        self.description = description
+        self.status = status  # active, completed, failed
+        self.rewards = rewards or []
+
+    def complete(self):
+        self.status = 'completed'
+
+    def fail(self):
+        self.status = 'failed'
+
+    def __repr__(self):
+        return f"<Quest {self.title} ({self.status})>"
+
+class QuestManager:
+    def __init__(self):
+        self.quests = []
+
+    def add_quest(self, title, description, **kwargs):
+        quest = Quest(title, description, **kwargs)
+        self.quests.append(quest)
+        return quest
+
+    def get_quest(self, title):
+        for quest in self.quests:
+            if quest.title == title:
+                return quest
+        return None
+
+    def list_quests(self, status=None):
+        if status:
+            return [q for q in self.quests if q.status == status]
+        return self.quests

engine/rpg/spell_manager.py

@@ -0,0 +1,36 @@
+"""
+Spell Manager for DnD-style RPG
+"""
+class Spell:
+    def __init__(self, name, level, school, description, effect=None):
+        self.name = name
+        self.level = level
+        self.school = school
+        self.description = description
+        self.effect = effect or {}
+
+    def __repr__(self):
+        return f"<Spell {self.name} (Lv{self.level}, {self.school})>"
+
+class SpellManager:
+    def __init__(self):
+        self.spells = []
+
+    def add_spell(self, name, level, school, description, effect=None):
+        spell = Spell(name, level, school, description, effect)
+        self.spells.append(spell)
+        return spell
+
+    def get_spell(self, name):
+        for spell in self.spells:
+            if spell.name == name:
+                return spell
+        return None
+
+    def list_spells(self, school=None, level=None):
+        result = self.spells
+        if school:
+            result = [s for s in result if s.school == school]
+        if level:
+            result = [s for s in result if s.level == level]
+        return result