root/trunk/RBPrivate/WheelOfTime/WheelOfTime.py

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Imports 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import bisect

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Definitions 
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Traits(object):
    PhysicalTraitsTable = [
        'agile', 'athletic', 'brawny', 'broadshouldered', 'energetic',
        'fierce', 'healthy', 'high-pain-threshold', 'lithe', 'nimble', 'quick',
        'robust', 'targeteer', 'tough', 'wiry',
    ]
    MentalTraitsTable = [
        'alert', 'analytical', 'astute', 'creative', 'discerning',
        'empathetic', 'experienced', 'insightful', 'inventive', 'knowlegeable',
        'mechanically-inclined', 'precise', 'recall', 'searcher',
        'supernumerate',
    ]
    SocialTraitsTable = [
        'adaptive', 'alluring', 'commanding', 'charismatic', 'elegant',
        'eloquent', 'enigmatic', 'entertaining', 'expressive', 'handsome',
        'persuasive', 'presence', 'sly', 'strong-willed', 'witty'
    ]

    Table = {}
    Table.update(dict([(x, 'physical') for x in PhysicalTraitsTable]))
    Table.update(dict([(x, 'mental') for x in MentalTraitsTable]))
    Table.update(dict([(x, 'social') for x in SocialTraitsTable]))

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Skills
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Stat(object):
    TraitDependencyTable = {
        'compelling-defense':('strong-willed', 'iron-willed'),
        'initiative':('agile', 'alert', 'quick'),
        'soak':('energetic', 'high-pain-threshold', 'tough'),
        'social-defense':('commanding', 'presence', 'strong-willed'),

        #TODO:
        # 'mental-defense' stat == 'sense-deception' skill
        # 'passive-defense' stat == 0.5 * weapon skill in use
        }

    def __init__(self, statkey):
        self.statkey = statkey.replace(' ', '-').lower()
        self.getTraits()

    def getEffectiveLevel(self, traits):
        return self.getLevel()

    def getLevel(self):
        return sum(filter(None, map(traits.get, self.getTraits())))

    def getTraits(self):
        return self.TraitDependencyTable[self.statkey]

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Skill(object):
    TraitDependencyTable = {
        # Dreamwalker Skills
        'control-self':('discerning', 'precise', 'strong-willed'),
        'dream-travel':('alert', 'insightful', 'searcher'),
        'enter-dreams':('alert', 'discerning', 'insightful'),
        'enter-tel\'aran\'rhoid':('healthy', 'tough', 'strong-willed'),
        'interpret-prophetic-dreams':('discerning', 'insightful', 'analytical'),
        'manipulate-environment':('alert', 'discerning', 'strong-willed'),

        # Aiel Skills
        'tactics':('analytical', 'insightful', 'knowlegeable'),

        # Athletic Skills
        'jump':('athletic', 'energetic', 'fierce'),
        'run':('athletic', 'energetic', 'quick'),
        'swim':('athletic', 'energetic', 'quick'),
        'throw-object':('broadshouldered', 'fierce', 'targeteer'),
        'acrobatics':('broadshouldered', 'fierce', 'targeteer'),

        # Noble
        'gaming':('analytical', 'discerning', 'experienced'),
        'nobel-lore': ('elegant', 'experienced', 'recall'),
        'hawking':('alert', 'commanding', 'discerning'),
        'history':('insightful', 'knowlegeable', 'recall'),
        'daes-dae\'mar':('enigmatic', 'insightful', 'sly'),
        'heraldry':('discerning', 'knowlegeable', 'recall'),

        # Rural
        'animal-lore':('experienced', 'knowlegable', 'recall'),
        'bargain':('astute', 'empathetic', 'stron-willed'),
        'fishing':('alert', 'agile', 'searcher'),
        'gambling':('alert', 'experienced', 'supernumerate'),
        'hunting':('alert', 'discerning', 'insightful'),
        'lifting':('athletic', 'broadshouldered', 'energetic'),
        'ride-animal':('agile', 'athletic', 'experienced'),
        'rural-stealth':('athletic', 'discerning', 'lithe'),
        'survival':('alert', 'healthy', 'searcher'),
        'agriculture':('alert', 'energetic', 'experienced'),
        'animal-handling':('commanding', 'empathetic', 'experienced'),
        'cooking':('creative', 'insightful', 'precise'),
        'healing':('discerning', 'experienced', 'recall'),
        'tracking':('analytical', 'discerning', 'searcher'),
        'trapping':('experienced', 'mechanically-inclined', 'searcher'),
        'herbalism':('discerning', 'experienced', 'searcher'),

        # Social
        'carouse':('energetic', 'entertaining', 'witty'),
        'con':('energetic', 'persuasive', 'sly'),
        'consume-alcohol':('healthy', 'robust', 'strong-willed'),
        'first-impression':('alluring', 'elegant', 'handsome', 'presence'),
        'gossip':('adaptive', 'enigmatic', 'persuasive', 'sly'),
        'grovel':('adaptive', 'enigmatic', 'sly'),
        'interrogate':('commanding', 'empathetic', 'strong-willed'),
        'intimidate':('commanding', 'fierce', 'strong-willed'),
        'leadership':('charismatic', 'commanding', 'eloquent'),
        'oratory':('charismatic', 'eloquent', 'empathetic'),
        'persuade':('charismatic', 'empathetic', 'persuasive'),
        'read-emotions':('empathetic', 'enigmatic', 'experienced'),
        'seduce':('alluring', 'handsome', 'presence'),
        'taunt':('eloquent', 'empathetic', 'witty'),
        'etiquette':('adaptive', 'elegant', 'recall'),
        'languages':('expressive', 'knowlegable', 'recall'),

        # Unarmed Combat
        'dodge':('alert', 'lithe', 'targeteer'),
        'kick':('athletic', 'fierce', 'wiry'),
        'punch':('agile', 'brawny', 'fierce'),
        'throw':('agile', 'targeteer', 'wiry'),
        'wrestle':('athletic', 'high-pain-threshold', 'wiry'),
        'aiel-martial-arts':('athletic', 'lithe', 'wiry'),

        # Vigilance
        'hear-noise':('alert', 'analytical', 'discerning'),
        'notice':('alert', 'discerning', 'insightful'),
        'pierce-disguise':('alert', 'discerning', 'enigmatic'),
        'read-emotions':('empathetic', 'enigmatic', 'experienced'),
        'search':('discerning', 'insightful', 'searcher'),
        'sense-deception':('empathetic', 'enigmatic', 'sly'),
        'vigilance':('alert', 'energetic', 'precise'),

        # Water
        'climb':('agile', 'athletic', 'energetic'),
        'lifting':('athletic', 'broadshouldered', 'energetic'),
        'swim':('athletic', 'energetic', 'quick'),
        'boating':('agile', 'alert', 'athletic'),
        'coast/port-knowledge':('experienced', 'knowlegeable', 'recall'),
        'river/rivertown-knowledge':('experienced', 'knowlegeable', 'recall'),
        'boat-making':('astute', 'experienced', 'mechanically-inclined'),

        # Missile Weapon
        'crossbow':('agile', 'alert', 'targeteer'),
        'longbow':('agile', 'alert', 'targeteer'),
        'shortbow':('agile', 'alert', 'targeteer'),
        'sling':('agile', 'alert', 'targeteer'),

        # Thrown weapons
        'dagger-thrown':('agile', 'alert', 'targeteer'),
        'handaxe-thrown':('agile', 'alert', 'targeteer'),
        'spear-thrown':('agile', 'alert', 'targeteer'),

        # Hand Weapons
        'battle-axe':('brawny', 'broadshouldered', 'fierce'),
        'dagger':('agile', 'brawny', 'quick'),
        'flail':('agile', 'brawny', 'quick'),
        'garotte':('nimble', 'quick', 'wiry'),
        'hand-axe':('agile', 'brawny', 'quick'),
        'hammer':('brawny', 'broadshouldered', 'fierce'),
        'lance':('brawny', 'broadshouldered', 'tough'),
        'mace':('brawny', 'broadshouldered', 'fierce'),
        'pole-arm':('agile', 'brawny', 'broadshouldered'),
        'spear/staff':('agile', 'brawny', 'quick'),
        'sword':('agile', 'brawny', 'quick'),
        }

    SkillLevel = [
        (0, 'Unskilled'),
        (1, 'Apprentice'),
        (4, 'Journeyman'),
        (10, 'Master'),
        (20, 'Grand Master'),
        (35, 'Heroic Skill'),
        (56, 'Local Legend'),
        (84, 'Age Legend')]

    naturaltalent = 0

    def __init__(self, skillkey, points):
        self.skillkey = skillkey.replace(' ', '-').lower()
        self.points = points
        self.getTraits()

    def __repr__(self):
        return "<%s: %r %s (%d | %1.1f%s)>" % (self.__class__.__name__, self.skillkey, self.getTitle(), self.getLevel(), self.points, self.naturaltalent and ' natural tallent' or '')

    def getEffectiveLevel(self, traits):
        return self.getLevel() + sum(filter(None, map(traits.get, self.getTraits())))

    def getLevel(self):
        pts = self.points * (1 + self.naturaltalent)
        return bisect.bisect_right(self.SkillLevel, (pts, ())) - 1

    def getTitle(self):
        return self.SkillLevel[self.getLevel()][1]

    def getLevelAndTitle(self):
        level = self.getLevel()
        return level, self.SkillLevel[level][1]

    def getTraits(self):
        return self.TraitDependencyTable[self.skillkey]

    def incrementBy(self, skill):
        assert self.skillkey == skill.skillkey
        self.points += skill.points

    def skillTraitReferenceCounts(self, counts=None, weighted=False):
        if counts is None: counts = {}
        for trait in self.getTraits():
            if weighted:
                r = counts.setdefault(trait, [0])
                r[0] += self.points**2 #self.getLevel()**2
                r.append(self.skillkey)
                counts[trait] = r
            else:
                counts[trait] = counts.get(trait, 0) + 1
        return counts
    
def HobbySkill(*args, **kw): 
    skill = Skill(*args, **kw)
    skill.hobby = True
    return skill

def DreamSkill(*args, **kw):
    skill = HobbySkill(*args, **kw)
    return skill

#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#~ Character
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Character:
    def __init__(self):
        self.skills = {}
        self.traits = {}
        self.attributes = []
        self.equipment = []
        self.money = 0 # in silver shillings
        self.age = 13

    def addEquipment(self, equipment, cost, description=''):
        assert cost <= self.money
        self.money -= cost
        self.equipment.append((cost, equipment, description))

    def addTrait(self, trait, value=1):
        trait = trait.replace(' ', '-').lower()
        assert trait in Traits.Table
        self.traits[trait] = self.traits.get(trait, 0) + value
        return trait
    def addTraits(self, traits, value=1):
        for trait in traits:
            self.addTrait(trait, value)

    def addAttribute(self, attr):
        attr = attr.replace(' ', '-').lower()
        self.attributes.append(attr)
        return attr
    def addAttributes(self, attrs):
        map(self.addAttribute, attrs)

    def getStat(self, statkey):
        return Stat(statkey)

    def getSkill(self, skillkey):
        try:
            return self.skills[skillkey]
        except KeyError:
            return self.addSkill(Skill(skillkey, 0))

    def addSkill(self, skill):
        if skill.skillkey in self.skills:
            self.skills[skill.skillkey].incrementBy(skill)
        else:
            self.skills[skill.skillkey] = skill
        return skill

    def addSkills(self, skills):
        map(self.addSkill, skills)

    def addYear(self, occupation, income, skills):
        self.age += 1
        self.money += income
        # TODO: go through skills to make sure that they are "within budget"
        self.addSkills(skills)

    def skillTraitReferenceCounts(self, counts=None, weighted=False):
        if counts is None: counts = {}
        for skill in self.skills.values(): 
            skill.skillTraitReferenceCounts(counts, weighted)
        return counts

    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    #~ Debug printing
    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    def printSkills(self):
        skillformat = '%22s %d (base:%d %s)'
        items = [(s.getEffectiveLevel(self.traits), s.getLevel(), s.points, n, s) for n, s in self.skills.items()]
        items.sort()
        items.reverse()
        print "Skills"
        for skill in items:
            skill = skill[-1]
            print skillformat%(
                    skill.skillkey, 
                    skill.getEffectiveLevel(self.traits),
                    skill.getLevel(), 
                    ' '.join(['%s:%d'%(t, self.traits[t]) for t in skill.getTraits() if t in self.traits]),
                    )
        print

    def printUsedTraits(self, filter=False):
        traitformat = '%-8s %d %3d %-16s %s'
        usedtraits = self.skillTraitReferenceCounts(weighted=True)
        items = [(Traits.Table[t], t in self.traits, c[0], repr(t), ','.join(c[1:])) for t, c in usedtraits.items() if not filter or t not in char.traits]
        items.sort()
        items.reverse()
        print "Traits weighted by use:"
        for each in items:
            print traitformat%each
        print

    def printUnusedTraits(self):
        traitformat = '%-8s %d %3d %-16s %s'
        usedtraits = self.skillTraitReferenceCounts(weighted=True)
        unusedtraits = []
        for trait in Traits.Table.keys():
            c = usedtraits.get(trait, [0])
            item = (Traits.Table[trait], trait in self.traits, c[0], repr(trait), ','.join(c[1:]))
            if c[0] < 10:
                unusedtraits.append(item)
        unusedtraits.sort()
        unusedtraits.reverse()
        print "Unused traits:"
        for item in unusedtraits:
            print traitformat%item
        print