monsters.py

# See bottom of file for a list of possible arguments.
# As an example,
#   monsters.py re
# calls print_resists.

import os
import os.path
import sys
import re

from operator import attrgetter, itemgetter


mon_data_path = os.path.join(os.path.expanduser('~'),
                             "crawl/crawl-ref/source/mon-data.h")
# Constants
MAG_IMMUNE = 270
BINARY_RESISTS = set(('curare', 'drown', 'hellfire', 'sticky'))

def read_mon_data(h=mon_data_path, debug=True):
    """Read mon-data.h"""
    data = str(open(h).read())

# Join preprocessor lines so they are stripped together later
    data = re.sub(r"\\"+r"\n", "", data)
# Strip out axed monsters
    data = re.sub("(?ms)static monsterentry mondata.*"
                  "#define AXED_MON[^}]*}[^}]*}[^}]*},",
                  "(", data)
#
    data = re.sub("AXED_MON(.*)", "", data)
    data = re.sub(r"(?ms)DUMMY\(.*?\)", "", data)

# Strip out block comments
    data = re.sub("(?ms)\/\*.*?\*\/", "", data)

# Strip other comments
    data = re.sub('//.*', '', data)
    data = re.sub('#.*', '', data)

# mrd(MR_X | MR_Y, 2) => MR_X2 | MR_Y2
    def mrd_convert(x):
        level = x.group(2)
        if int(level) == 1:
            level = ''
        resists = x.group(1).split('|')
        return ' | '.join("%s%s" % (res.strip(), level) for res in resists)
    data = re.sub('(?ms)mrd\((MR_[A-Z_\s|]+)+, (\d)\)', mrd_convert, data)

# Replace energy:
    def energy(x):
        return "(%s, %s)" % (x.group(1), x.group(2))
    data = re.sub('([A-Z0-9_-]*_ENERGY)\((.*?)\)', energy, data)

# Replace pipes by commas
    def pipes(x):
        return "(%s)" % re.sub('(?ms)\s*\|\s*', ',', x.group(0))
    data = re.sub('(?m)(\(.*\)|<<.*>>|[A-Z0-9_-]*)'
                  '(\s*\|\s*(\(.*\)|<<.*>>|[A-Z0-9_-]*))+', pipes, data)

# Stringify bare enums:
    def stringify(x):
        return "'%s'" % x.group(1)
    data = re.sub("(?<!['\"])([A-Z0-9_-]{2,})", stringify, data)

# Replace placeholders
    data = re.sub('(<<|{{)', '(', data)
    data = re.sub('(>>|}})', ')', data)

# Replace }s by )s unless they're a monster glyph.
    data = re.sub("}(?!['\"]);*", ')', data)
    data = re.sub("{", '(', data)

    if debug:
    # Write debug data right before trying to parse
        output_path = os.path.join(os.getcwd(), "data.py")
        with open(output_path, "w") as f:
            f.write(data)

    # Eval it, storing it as a tuple
    return eval(data)

mondata = read_mon_data()


class Resistance(object):
    '''Store the four main resistances to always display.

    Additional resists are then added where necessary.
    Convert vulnerability to negative resistance.
    '''
    def __init__(self, resists):
        '''[maxlevel, level]'''
        self.fire = 0
        self.cold = 0
        self.pois = 0
        self.elec = 0

        for r in resists:
            level = -1 if r.startswith('MR_VUL_') else 1
            r = r[7:].lower()
            if r[-1] in '01234':
                level = level * min(3, int(r[-1]))
                r = r[:-1]
            # Some names that are easier to understand or abbreviate
            r = {
                'poison':       'pois',
                'rotting':      'rot',
                'asphyx':       'curare',
                'water':        'drown',
                'sticky_flame': 'sticky',
                }.get(r, r)
            setattr(self, r, level)

        if getattr(self, 'hellfire', None):
            self.fire = 3

    def __repr__(self):
        s = ''
        for resist in [
                'fire', 'cold', 'pois', 'elec',
                'neg', 'holy', 'rot', 'acid', 'steam',
                'curare', 'drown ', 'sticky', 'hellfire']:
            resist = resist.strip()
            level = getattr(self, resist, None)
            maxlevel = 1 if resist in BINARY_RESISTS else 3

            if level is None:
                # Optional and not present
                continue
            dot = 'x' if level < 0 else '+'
            level = abs(level)
            # Should only affect `hellfire`
            resist = resist[:6]
            s += "%-4s %s%s%s  " % (
                resist,
                dot * level,
                '.' * (maxlevel - level),
                ' ' * (3 - maxlevel - max(0, len(resist) - 4)))
        return s.strip()


class Energy(object):
    '''How quickly the energy granted by speed is used up.

    Most monsters should just use DEFAULT_ENERGY, where all the different
    types of actions use 10 energy units.

    #define MOVE_ENERGY(x)     { x,  x, 10, 10, 10, 10, 10, 100}
    #define ACTION_ENERGY(x)   {10, 10,  x,  x,  x,  x,  x, x * 10}
    #define ATTACK_ENERGY(x)   {10, 10,  x, 10, 10, 10, 10, 100}
    #define MISSILE_ENERGY(x)  {10, 10, 10,  x, 10, 10, 10, 100}
    #define SPELL_ENERGY(x)    {10, 10, 10, 10,  x, 10, 10, 100}
    #define SWIM_ENERGY(x)     {10,  x, 10, 10, 10, 10, 10, 100}
    '''
    def __init__(self,
        move = 10,
        swim = 10,
        attack = 10,
        missile = 10,
        spell = 10,
        mysteryA = 10,
        mysteryB = 10,
        mysteryC = 10 * 10
        ):

        self.move     = move
        self.swim     = swim
        self.attack   = attack
        self.missile  = missile
        self.spell    = spell
        self.mysteryA = mysteryA
        self.mysteryB = mysteryB
        self.mysteryC = mysteryC

    def move_speed(self, speed):
        self.move = speed
        self.swim = speed

    def move_energy(self, move):
        self.move = 100./move
        self.swim = 100./move

    def action_energy(self, action):
        self.attack   = action
        self.missile  = action
        self.spell    = action
        self.mysteryA = action
        self.mysteryB = action
        self.mysteryC = action * 10

    def attack_energy(self, attack):
        self.attack = attack

    def missile_energy(self, missile):
        self.missile = missile

    def spell_energy(self, spell):
        self.spell = spell

    def swim_energy(self, swim):
        self.swim = swim

    def __repr__(self):
        return ''.join('%-3d' % getattr(self, e)
            for e in [
                'move',
                'swim',
                'attack',
                'missile',
                'spell',
                'mysteryA',
                'mysteryB',
                'mysteryC',
            ])


class HP(object):
    def __init__(self, hd, avg_hpx10):
        '''
            Monsters' hp will vary between +-33% of that value; 95% of the
            time within +-10%.
        '''
        self.hd = hd
        self.avg = int(avg_hpx10 / 10)
        self.min = int(self.avg * 0.67)
        self.min10 = int(self.avg * 0.90)
        self.max = int(self.avg * 1.33)
        self.max10 = int(self.avg * 1.1)


    @property
    def fixed(self):
        return self.min == self.max

    def __repr__(self):
        return "[{:.<4d}.{:.>4}]     [{:.<4d}.{:.>4}]"\
               .format(self.min10, self.max10, self.min, self.max)


class Monster(object):
    def __init__(self,
        id,
        glyph,
        color,
        name,
        flags,
        resistances,
        xp_modifier,
        genus,
        species,
        holiness,
        mr_modifier,
        attacks,
        hd,
        avg_hpx10,
        ac,
        ev,
        spellbook,
        corpse_type,
        shout_type,
        intelligence,
        habitat,
        speed,
        energy,
        item_use,
        size,
        shape=None,
        tile=None,
        corpse=None,
        *args, **kwargs):

        self.id          = id
        self.glyph       = glyph
        self.color       = color
        self.name        = name

        if isinstance(flags, tuple):
            self.flags   = ', '.join(f for f in sorted(flags))
        else:
            self.flags   = flags

        if resistances == 'MR_NO_FLAGS':
            self.resistances = tuple()
        elif isinstance(resistances, tuple):
            self.resistances = resistances
        else:
            self.resistances = (resistances, )

        self.resists = Resistance(self.resistances)

        self.xp_modifier = int(xp_modifier)
        self.genus       = genus
        self.species     = species

        self.holiness    = holiness
        #
        # monster::res_holy_energy via monster::undead_or_demonic
        if ((self.holiness in ('MH_UNDEAD', 'MH_DEMONIC')
               and self.id != 'MONS_PROFANE_SERVITOR')
            or self.genus == 'MONS_DEMONSPAWN'):
            setattr(self.resists, 'holy', -2)
        # monster::res_holy_energy
        elif self.holiness == 'MH_HOLY' or self.id == 'MONS_PROFANE_SERVITOR':
            setattr(self.resists, 'holy', 1)
        # monster::res_negative_energy
        if self.holiness != 'MH_NATURAL':
            setattr(self.resists, 'neg', 3)
        # Missing but feasible:
        # monster::res_torment
        # rPois for e.g. abominations and other undead
        # monster::res_rotting
        # one/three level distinction?

        if mr_modifier == 'MAG_IMMUNE':
            self.mr_modifier = MAG_IMMUNE
        else:
            self.mr_modifier = int(mr_modifier)

        self.attacks     = []
        for attack in attacks:
            if attack == 'AT_NO_ATK':
                continue
            at_type, at_flavor, damage = attack
            # [3:] gets rid of AT_ and AF_ prefixes
            at_flavor = at_flavor[3:].lower()
            if at_flavor == 'plain':
                at_flavor = ''
            self.attacks.append((int(damage), at_type[3:], at_flavor))

        self.hd           = int(hd)
        self.hp           = HP(int(hd), float(avg_hpx10))
        self.ac           = int(ac)
        self.ev           = int(ev)
        self.spellbook    = spellbook
        self.corpse_type  = corpse_type
        self.shout_type   = shout_type
        self.intelligence = intelligence
        self.habitat      = habitat
        self.speed        = int(speed)
        self.tile         = tile
        self.corpse       = corpse

        self.energy       = Energy()
        if energy == 'DEFAULT_ENERGY':
            self.energy.move_speed(self.speed)
        elif len(energy) == 2:
            # E.g. ('SWIM_ENERGY', 6) or ('SPELL_ENERGY', '20')
            # => call  swim_energy(6)  or  spell_energy(20)
            getattr(self.energy, energy[0].lower())(int(energy[1]))
        else:
            # E.g. ('10', 6, 8, 8, 8, 8, 8, '80')
            e_int = (int(e) for e in energy)
            self.energy = Energy(*e_int)

        self.item_use     = item_use
        self.size         = size
        self.shape        = shape

    @property
    def mr(self):
        '''monster.cc: monster::res_magic

        int u = (get_monster_data(base_type))->resist_magic;
        // Negative values get multiplied with monster hit dice.
        if (u < 0)
            u = hit_dice * -u * 4 / 3;

        Note that we indicate magic immunity by python-side MAG_IMMUNE = 270.
        '''
        if self.mr_modifier < 0:
            return int(self.hd * -self.mr_modifier * 4. / 3)
        else:
            return self.mr_modifier

    @property
    def mr_immune(self):
        return self.mr == MAG_IMMUNE

    def __repr__(self):
        return self.name


def title(heading, f, x='-'):
    if f is None:
        f = sys.stdout
    print(('\n' + heading + '\n' + x * len(heading)), file=f)
    return f


def main():
    all_monsters = {}
    for m in mondata:
        mons = Monster(*m)
        all_monsters[mons.id] = mons
    monsters = sorted(all_monsters.values(), key=attrgetter('id'))

    def print_attacks(f=None):
        f = title('Monster attacks', f)
        for m in sorted(monsters, key=attrgetter('id')):
            s = ''
            for (dam, at, af) in m.attacks:
                s += '%d' % dam
                if af:
                    if af == 'crush' and at == 'CONSTRICT':
                        af = 'hold' if dam == 0 else 'constrict'
                    s += '(%s)' % af.replace('_', ' ')
                s += ','
            print((" %-22.22s  %s" % (m, s.strip(','))), file=f)

    def print_hp(f=None):
        f = title('Monsters by Average HP. '
                  '      95%: [90%..110%] 5%: [67%..133%]', f)
        for m in sorted(monsters, key=attrgetter('hp.avg'), reverse=True):
            # Skip some silly things
            if m.hp.max <= 0:
                # templates etc
                continue
            if m.hp.avg >= 1000000:
                # test spawner, test statue
                continue

            if m.hp.fixed:
                dot = '[*]'
                mhp = ''
            else:
                dot = '   '
                mhp = m.hp
            mname = "%-23.26s" % m
            mname = "{:>27}".format(mname)
            print(("%s%5d%s%-15s" % (dot, m.hp.avg, mname, mhp)), file=f)

    def print_dragons(f=None):
        f = title('Dragons by HD', f)
        for m in sorted(monsters, key=attrgetter('hd'), reverse=True):
            if 'DRAGON' not in m.genus or 'M_CANT_SPAWN' in m.flags:
                continue
            print(("%2d  %s" % (m.hd, m)), file=f)
        f = title('Draconians by HD', f)
        for m in sorted(monsters, key=attrgetter('hd'), reverse=True):
            if 'DRACONIAN' not in m.genus or 'M_CANT_SPAWN' in m.flags:
                continue
            print(("%2d  %s" % (m.hd, m)), file=f)

    def print_hd(f=None):
        f = title('Dragons and not-dragons by HD', f)
        for m in sorted(monsters, key=attrgetter('hd'), reverse=True):
            if 'M_CANT_SPAWN' in m.flags:
                continue
            print(("%2d  %s" % (m.hd, m)), file=f)

    def print_ac(f=None):
        f = title('Monsters by AC', f)
        for m in sorted(monsters, key=attrgetter('ac'), reverse=True):
            print(("%4d  %s" % (m.ac, m)), file=f)

    def print_defenses(f=None):
        f = title('Monsters by AC and EV', f)
        for m in sorted(monsters, key=lambda m: m.ac + m.ev, reverse=True):
            print(("%3d|%3d  %s" % (m.ac, m.ev, m)), file=f)

    def print_resists(f=None):
        f = title('Monster resistances (not nearly complete!)', f)
        for m in sorted(monsters, key=attrgetter('id')):
            print((" %-22.22s %s" % (m, m.resists)), file=f)

    def print_mr(f=None):
        f = title('Monsters by MR, [*]: immune', f)
        for m in sorted(monsters, key = attrgetter('mr'), reverse=True):
            if m.mr_immune:
                mr = '[*]'
            else:
                mr = '%3d' % m.mr
            print(("  %s  %s" % (mr, m)), file=f)

    def print_speed(f=None):
        f = title('Monsters by move speed (player: usually 10)', f)
        for m in sorted(monsters, key = lambda m: m.energy.move, reverse=True):
            print(("% 5.4s  %s" % (m.energy.move, m)), file=f)

    fnmap = {
        'ac': print_ac,
        'defenses': print_defenses,
        'attacks': print_attacks,
        'dragons': print_dragons,
        'hd': print_hd,
        'hp': print_hp,
        'mr': print_mr,
        'resists': print_resists,
        'speed': print_speed,
    }

    done = False
    write = True
    if len(sys.argv) > 1:
        if sys.argv[1].startswith('eve'):
            # Legacy compat: 'everything' used to be manually defined
            write = False
        else:
            # Provided string argument to run a specific mode
            for (abbr, fn) in fnmap.items():
                if abbr.startswith(sys.argv[1]):
                    done = True
                    fn()

    if not done:
        # Run everything
        for (abbr, fn) in sorted(fnmap.items(), key=itemgetter(0)):
            with open(abbr, 'w') as f:
                fn(f if write else None)


if __name__ == '__main__':
    main()