Merge branch 'encukou-media-accessors'

pokedex/data/csv/item_flag_map.csv

@@ -484,6 +484,7 @@ item_id,item_flag_id
 245,7
 246,5
 246,7
+246,8
 247,5
 247,7
 248,5
@@ -501,6 +502,7 @@ item_id,item_flag_id
 254,7
 255,5
 255,7
+255,8
 256,5
 256,7
 257,5

pokedex/db/media.py

@@ -0,0 +1,514 @@
+
+"""Media accessors
+
+Most media accessor __init__s take an ORM object from the pokedex package.
+Their various methods take a number of arguments specifying exactly which
+file you want (such as the female sprite, backsprite, etc.).
+ValueError is raised when the specified file cannot be found.
+
+The accessors use fallbacks: for example Bulbasaur's males and females look the
+same, so if you request Bulbasaur's female sprite, it will give you the common
+image. Or for a Pokemon without individual form sprites, you will get the
+common base sprite. Or for versions witout shiny Pokemon, you will always
+get the non-shiny version (that's how shiny Pokemon looked there!).
+However arguments such as `animated` don't use fallbacks.
+You can set `strict` to True to disable these fallbacks and cause ValueError
+to be raised when the exact specific file you asked for is not found. This is
+useful for listing non-duplicate sprites, for example.
+
+Use keyword arguments when calling the media-getting methods, unless noted
+otherwise.
+
+The returned "file" objects have useful attributes like relative_path,
+path, and open().
+
+All images are in the PNG format, except animations (GIF). All sounds are OGGs.
+"""
+
+import os
+import pkg_resources
+
+class MediaFile(object):
+    """Represents a file: picture, sound, etc.
+
+    Attributes:
+    relative_path: Filesystem path relative to the media directory
+    path: Absolute path to the file
+
+    exists: True if the file exists
+
+    open(): Open the file
+    """
+    def __init__(self, *path_elements):
+        self.path_elements = path_elements
+        self._dexpath = '/'.join(('data', 'media') + path_elements)
+
+    @property
+    def relative_path(self):
+        return os.path.join(*self.path_elements)
+
+    @property
+    def path(self):
+        return pkg_resources.resource_filename('pokedex', self._dexpath)
+
+    def open(self):
+        """Open this file for reading, in the appropriate mode (i.e. binary)
+        """
+        return open(self.path, 'rb')
+
+    @property
+    def exists(self):
+        return pkg_resources.resource_exists('pokedex', self._dexpath)
+
+    def __eq__(self, other):
+        return self.path == other.path
+
+    def __ne__(self, other):
+        return self.path != other.path
+
+    def __str__(self):
+        return '<Pokedex file %s>' % self.relative_path
+
+class BaseMedia(object):
+    def from_path_elements(self, path_elements, basename, extension,
+            surely_exists=False):
+        filename = basename + extension
+        path_elements = [self.toplevel_dir] + path_elements + [filename]
+        mfile = MediaFile(*path_elements)
+        if surely_exists or mfile.exists:
+            return mfile
+        else:
+            raise ValueError('File %s not found' % mfile.relative_path)
+
+class _BasePokemonMedia(BaseMedia):
+    toplevel_dir = 'pokemon'
+    has_gender_differences = False
+    form = None
+    introduced_in = 0
+
+    # Info about of what's inside the pokemon main sprite directories, so we
+    # don't have to check directory existence all the time.
+    _pokemon_sprite_info = {
+            'red-blue': (1, set('back gray'.split())),
+            'red-green': (1, set('back gray'.split())),
+            'yellow': (1, set('back gray gbc'.split())),
+            'gold': (2, set('back shiny'.split())),
+            'silver': (2, set('back shiny'.split())),
+            'crystal': (2, set('animated back shiny'.split())),
+            'ruby-sapphire': (3, set('back shiny'.split())),
+            'emerald': (3, set('animated back shiny frame2'.split())),
+            'firered-leafgreen': (3, set('back shiny'.split())),
+            'diamond-pearl': (4, set('back shiny female frame2'.split())),
+            'platinum': (4, set('back shiny female frame2'.split())),
+            'heartgold-soulsilver': (4, set('back shiny female frame2'.split())),
+            'black-white': (5, set('back shiny female'.split())),
+        }
+
+    def __init__(self, pokemon_id, form_postfix=None):
+        BaseMedia.__init__(self)
+        self.pokemon_id = str(pokemon_id)
+        self.form_postfix = form_postfix
+
+    def _get_file(self, path_elements, extension, strict, surely_exists=False):
+        basename = str(self.pokemon_id)
+        if self.form_postfix:
+            fullname = basename + self.form_postfix
+            try:
+                return self.from_path_elements(
+                        path_elements, fullname, extension,
+                        surely_exists=surely_exists)
+            except ValueError:
+                if strict:
+                    raise
+        return self.from_path_elements(path_elements, basename, extension,
+                surely_exists=surely_exists)
+
+    def sprite(self,
+            version='black-white',
+
+            # The media directories are in this order:
+            animated=False,
+            back=False,
+            color=None,
+            shiny=False,
+            female=False,
+            frame=None,
+
+            strict=False,
+        ):
+        """Get a main sprite sprite for a pokemon.
+
+        Everything except version should be given as a keyword argument.
+
+        Either specify version as an ORM object, or give the version path as
+        a string (which is the only way to get 'red-green'). Leave the default
+        for the latest version.
+
+        animated: get a GIF animation (currently Crystal & Emerald only)
+        back: get a backsprite instead of a front one
+        color: can be 'color' (RGBY only) or 'gbc' (Yellow only)
+        shiny: get a shiny sprite. In old versions, gives a normal sprite unless
+            `strict` is set
+        female: get a female sprite instead of male. For pokemon with no sexual
+            dimorphism, gets the common sprite unless `strict` is set.
+        frame: set to 2 to get the second frame of the animation
+            (Emerald, DPP, and HG/SS only)
+
+        If the sprite is not found, raise a ValueError.
+        """
+        if isinstance(version, basestring):
+            version_dir = version
+            try:
+                generation, info = self._pokemon_sprite_info[version_dir]
+            except KeyError:
+                raise ValueError('Version directory %s not found', version_dir)
+        else:
+            version_dir = version.identifier
+            try:
+                generation, info = self._pokemon_sprite_info[version_dir]
+            except KeyError:
+                version_group = version.version_group
+                version_dir = '-'.join(
+                        v.identifier for v in version_group.versions)
+                generation, info = self._pokemon_sprite_info[version_dir]
+        if generation < self.introduced_in:
+            raise ValueError("Pokemon %s didn't exist in %s" % (
+                    self.pokemon_id, version_dir))
+        path_elements = ['main-sprites', version_dir]
+        if animated:
+            if 'animated' not in info:
+                raise ValueError("No animated sprites for %s" % version_dir)
+            path_elements.append('animated')
+            extension = '.gif'
+        else:
+            extension = '.png'
+        if back:
+            if version_dir == 'emerald':
+                # Emerald backsprites are the same as ruby/sapphire
+                if strict:
+                    raise ValueError("Emerald uses R/S backsprites")
+                if animated:
+                    raise ValueError("No animated backsprites for Emerald")
+                path_elements[1] = version_dir = 'ruby-sapphire'
+            if version_dir == 'crystal' and animated:
+                raise ValueError("No animated backsprites for Crystal")
+            path_elements.append('back')
+        if color == 'gray':
+            if 'gray' not in info:
+                raise ValueError("No grayscale sprites for %s" % version_dir)
+            path_elements.append('gray')
+        elif color == 'gbc':
+            if 'gbc' not in info:
+                raise ValueError("No GBC sprites for %s" % version_dir)
+            path_elements.append('gbc')
+        elif color:
+            raise ValueError("Unknown color scheme: %s" % color)
+        if shiny:
+            if 'shiny' in info:
+                path_elements.append('shiny')
+            elif strict:
+                raise ValueError("No shiny sprites for %s" % version_dir)
+        if female:
+            female_sprite = self.has_gender_differences
+            # Chimecho's female back frame 2 sprite has one hand in
+            # a slightly different pose, in Platinum and HGSS
+            # (we have duplicate sprites frame 1, for convenience)
+            if self.pokemon_id == '358' and back and version_dir in (
+                    'platinum', 'heartgold-soulsilver'):
+                female_sprite = True
+            female_sprite = female_sprite and 'female' in info
+            if female_sprite:
+                path_elements.append('female')
+            elif strict:
+                raise ValueError(
+                    'Pokemon %s has no gender differences' % self.pokemon_id)
+        if not frame or frame == 1:
+            pass
+        elif frame == 2:
+            if 'frame2' in info:
+                path_elements.append('frame%s' % frame)
+            else:
+                raise ValueError("No frame 2 for %s" % version_dir)
+        else:
+            raise ValueError("Bad frame %s" % frame)
+        return self._get_file(path_elements, extension, strict=strict,
+                # Avoid a stat in the common case
+                surely_exists=(self.form and version_dir == 'black-white'
+                    and not back and not female
+                    and not self.form_postfix))
+
+    def _maybe_female(self, path_elements, female, strict):
+        if female:
+            if self.has_gender_differences:
+                elements = path_elements + ['female']
+                try:
+                    return self._get_file(elements, '.png', strict=strict)
+                except ValueError:
+                    if strict:
+                        raise
+            elif strict:
+                raise ValueError(
+                    'Pokemon %s has no gender differences' % self.pokemon_id)
+        return self._get_file(path_elements, '.png', strict=strict)
+
+    def icon(self, female=False, strict=False):
+        """Get the Pokemon's menu icon"""
+        return self._maybe_female(['icons'], female, strict)
+
+    def sugimori(self, female=False, strict=False):
+        """Get the Pokemon's official art, drawn by Ken Sugimori"""
+        return self._maybe_female(['sugimori'], female, strict)
+
+    def overworld(self,
+            direction='down',
+            shiny=False,
+            female=False,
+            frame=1,
+            strict=False,
+        ):
+        """Get an overworld sprite
+
+        direction: 'up', 'down', 'left', or 'right'
+        shiny: true for a shiny sprite
+        female: true for female sprite (or the common one for both M & F)
+        frame: 2 for the second animation frame
+
+        strict: disable fallback for `female`
+        """
+        path_elements = ['overworld']
+        if shiny:
+            path_elements.append('shiny')
+        if female:
+            if self.has_gender_differences:
+                path_elements.append('female')
+            elif strict:
+                raise ValueError('No female overworld sprite')
+            else:
+                female = False
+        path_elements.append(direction)
+        if frame and frame > 1:
+            path_elements.append('frame%s' % frame)
+        try:
+            return self._get_file(path_elements, '.png', strict=strict)
+        except ValueError:
+            if female and not strict:
+                path_elements.remove('female')
+                return self._get_file(path_elements, '.png', strict=strict)
+            else:
+                raise
+
+    def footprint(self, strict=False):
+        """Get the Pokemon's footprint"""
+        return self._get_file(['footprints'], '.png', strict=strict)
+
+    def trozei(self, strict=False):
+        """Get the Pokemon's animated Trozei sprite"""
+        return self._get_file(['trozei'], '.gif', strict=strict)
+
+    def cry(self, strict=False):
+        """Get the Pokemon's cry"""
+        return self._get_file(['cries'], '.ogg', strict=strict)
+
+    def cropped_sprite(self, strict=False):
+        """Get the Pokemon's cropped sprite"""
+        return self._get_file(['cropped'], '.png', strict=strict)
+
+class PokemonFormMedia(_BasePokemonMedia):
+    """Media related to a Pokemon form
+    """
+    def __init__(self, pokemon_form):
+        pokemon_id = pokemon_form.form_base_pokemon_id
+        if pokemon_form.identifier:
+            form_postfix = '-' + pokemon_form.identifier
+        else:
+            form_postfix = None
+        _BasePokemonMedia.__init__(self, pokemon_id, form_postfix)
+        self.form = pokemon_form
+        pokemon = pokemon_form.form_base_pokemon
+        self.has_gender_differences = pokemon.has_gender_differences
+        self.introduced_in = pokemon.generation_id
+
+class PokemonMedia(_BasePokemonMedia):
+    """Media related to a Pokemon
+    """
+    def __init__(self, pokemon):
+        _BasePokemonMedia.__init__(self, pokemon.id)
+        self.form = pokemon.default_form
+        self.has_gender_differences = (pokemon.has_gender_differences)
+        self.introduced_in = pokemon.generation_id
+
+class UnknownPokemonMedia(_BasePokemonMedia):
+    """Media related to the unknown Pokemon ("?")
+
+    Note that not a lot of files are available for it.
+    """
+    def __init__(self):
+        _BasePokemonMedia.__init__(self, '0')
+
+class EggMedia(_BasePokemonMedia):
+    """Media related to a pokemon egg
+
+    Note that not a lot of files are available for these.
+
+    Give a Manaphy as `pokemon` to get the Manaphy egg.
+    """
+    def __init__(self, pokemon=None):
+        if pokemon and pokemon.identifier == 'manaphy':
+            postfix = '-manaphy'
+        else:
+            postfix = None
+        _BasePokemonMedia.__init__(self, 'egg', postfix)
+
+class SubstituteMedia(_BasePokemonMedia):
+    """Media related to the Substitute sprite
+
+    Note that not a lot of files are available for Substitute.
+    """
+    def __init__(self):
+        _BasePokemonMedia.__init__(self, 'substitute')
+
+class _BaseItemMedia(BaseMedia):
+    toplevel_dir = 'items'
+    def underground(self, rotation=0):
+        """Get the item's sprite as it appears in the Sinnoh underground
+
+        Rotation can be 0, 90, 180, or 270.
+        """
+        if rotation:
+            basename = self.identifier + '-%s' % rotation
+        else:
+            basename = self.identifier
+        return self.from_path_elements(['underground'], basename, '.png')
+
+class ItemMedia(_BaseItemMedia):
+    """Media related to an item
+    """
+    def __init__(self, item):
+        self.item = item
+        self.identifier = item.identifier
+
+    def sprite(self, version=None):
+        """Get the item's sprite
+
+        If version is not given, use the latest version.
+        """
+        identifier = self.identifier
+        # Handle machines
+        # We check the identifier, so that we don't query the machine
+        # information for any item.
+        if identifier.startswith(('tm', 'hm')):
+            try:
+                int(identifier[2:])
+            except ValueError:
+                # Not really a TM/HM
+                pass
+            else:
+                machines = self.item.machines
+                if version:
+                    try:
+                        machine = [
+                                m for m in machines
+                                if m.version_group == version.version_group
+                            ][0]
+                    except IndexError:
+                        raise ValueError("%s doesn't exist in %s" % (
+                                identifier, version.identifier))
+                else:
+                    # They're ordered, so get the last one
+                    machine = machines[-1]
+                type_identifier = machine.move.type.identifier
+                identifier = identifier[:2] + '-' + type_identifier
+        elif identifier.startswith('data-card-'):
+            try:
+                int(identifier[10:])
+            except ValueError:
+                # Not a real data card???
+                pass
+            else:
+                identifier = 'data-card'
+        if version is not None:
+            generation_id = version.generation.id
+            if generation_id <= 3 and identifier == 'dowsing-mchn':
+                identifier = 'itemfinder'
+            try:
+                gen = 'gen%s' % generation_id
+                return self.from_path_elements([gen], identifier, '.png')
+            except ValueError:
+                pass
+        return self.from_path_elements([], identifier, '.png',
+                surely_exists=True)
+
+    def underground(self, rotation=0):
+        """Get the item's sprite as it appears in the Sinnoh underground
+
+        Rotation can be 0, 90, 180, or 270.
+        """
+        if not self.item.appears_underground:
+            raise ValueError("%s doesn't appear underground" % self.identifier)
+        return super(ItemMedia, self).underground(rotation=rotation)
+
+    def berry_image(self):
+        """Get a berry's big sprite
+        """
+        if not self.item.berry:
+            raise ValueError("%s is not a berry" % self.identifier)
+        return self.from_path_elements(['berries'], self.identifier, '.png')
+
+class UndergroundRockMedia(_BaseItemMedia):
+    """Media related to a rock in the Sinnoh underground
+
+    rock_type can be one of: i, ii, o, o-big, s, t, z
+    """
+    def __init__(self, rock_type):
+        self.identifier = 'rock-%s' % rock_type
+
+class UndergroundSphereMedia(_BaseItemMedia):
+    """Media related to a sphere in the Sinnoh underground
+
+    color can be one of: red, blue, green, pale, prism
+    """
+    def __init__(self, color, big=False):
+        self.identifier = '%s-sphere' % color
+        if big:
+            self.identifier += '-big'
+
+class _SimpleIconMedia(BaseMedia):
+    def __init__(self, thing):
+        self.identifier = thing.identifier
+
+    def icon(self):
+        return self.from_path_elements([], self.identifier, '.png')
+
+class DamageClassMedia(_SimpleIconMedia):
+    toplevel_dir = 'damage-classes'
+
+class HabitatMedia(_SimpleIconMedia):
+    toplevel_dir = 'habitats'
+
+class ShapeMedia(_SimpleIconMedia):
+    toplevel_dir = 'shapes'
+
+class ItemPocketMedia(_SimpleIconMedia):
+    toplevel_dir = 'item-pockets'
+    def icon(self, selected=False):
+        if selected:
+            return self.from_path_elements(
+                    ['selected'], self.identifier, '.png')
+        else:
+            return self.from_path_elements([], self.identifier, '.png')
+
+class _LanguageIconMedia(_SimpleIconMedia):
+    def icon(self, lang='en'):
+        return self.from_path_elements([lang], self.identifier, '.png')
+
+class ContestTypeMedia(_LanguageIconMedia):
+    toplevel_dir = 'contest-types'
+
+class TypeMedia(_LanguageIconMedia):
+    toplevel_dir = 'types'
+
+''' XXX: No accessors for:
+chrome
+fonts
+ribbons
+'''

pokedex/tests/test_media.py

@@ -0,0 +1,255 @@
+
+"""Test the media accessors.
+
+If run directly from the command line, also tests the accessors and the names
+of all the media by getting just about everything in a naive brute-force way.
+This, of course, takes a lot of time to run.
+"""
+
+import os
+import re
+
+from nose.tools import *
+from nose.plugins.skip import SkipTest
+import nose
+import pkg_resources
+
+from pokedex.db import tables, connect, media
+
+session = connect()
+basedir = pkg_resources.resource_filename('pokedex', 'data/media')
+
+path_re = re.compile('^[-a-z0-9./]*$')
+
+def test_totodile():
+    """Totodile's female sprite -- same as male"""
+    totodile = session.query(tables.Pokemon).filter_by(identifier=u'totodile').one()
+    accessor = media.PokemonMedia(totodile)
+    assert accessor.sprite() == accessor.sprite(female=True)
+
+def test_chimecho():
+    """Chimecho's Platinum female backsprite -- diffeent from male"""
+    chimecho = session.query(tables.Pokemon).filter_by(identifier=u'chimecho').one()
+    accessor = media.PokemonMedia(chimecho)
+    male = accessor.sprite('platinum', back=True, frame=2)
+    female = accessor.sprite('platinum', back=True, female=True, frame=2)
+    assert male != female
+
+def test_venonat():
+    """Venonat's shiny Yellow sprite -- same as non-shiny"""
+    venonat = session.query(tables.Pokemon).filter_by(identifier=u'venonat').one()
+    accessor = media.PokemonMedia(venonat)
+    assert accessor.sprite('yellow') == accessor.sprite('yellow', shiny=True)
+
+def test_arceus_icon():
+    """Arceus fire-form icon -- same as base icon"""
+    arceus = session.query(tables.Pokemon).filter_by(identifier=u'arceus').one()
+    accessor = media.PokemonMedia(arceus)
+    fire_arceus = [f for f in arceus.forms if f.identifier == 'fire'][0]
+    fire_accessor = media.PokemonFormMedia(fire_arceus)
+    assert accessor.icon() == fire_accessor.icon()
+
+@raises(ValueError)
+def test_strict_castform():
+    """Castform rainy form overworld with strict -- unavailable"""
+    castform = session.query(tables.Pokemon).filter_by(identifier=u'castform').first()
+    rainy_castform = [f for f in castform.forms if f.identifier == 'rainy'][0]
+    rainy_castform = media.PokemonFormMedia(rainy_castform)
+    rainy_castform.overworld('up', strict=True)
+
+@raises(ValueError)
+def test_strict_exeggcute():
+    """Exeggcutes's female backsprite, with strict -- unavailable"""
+    exeggcute = session.query(tables.Pokemon).filter_by(identifier=u'exeggcute').one()
+    accessor = media.PokemonMedia(exeggcute)
+    accessor.sprite(female=True, strict=True)
+
+
+
+def get_all_filenames():
+    print 'Reading all filenames...'
+
+    all_filenames = set()
+
+    for dirpath, dirnames, filenames in os.walk(basedir):
+        for filename in filenames:
+            path = os.path.join(dirpath, filename)
+            assert path_re.match(path), path
+            all_filenames.add(path)
+
+    return all_filenames
+
+def hit(filenames, method, *args, **kwargs):
+    """
+    Run the given accessor method with args & kwargs; if found remove the
+    result path from filenames and return True, else return False.
+    """
+    try:
+        medium = method(*args, **kwargs)
+        #print 'Hit', medium.relative_path
+        assert medium.exists
+    except ValueError, e:
+        #print 'DNF', e
+        return False
+    except:
+        print 'Error while processing', method, args, kwargs
+        raise
+    try:
+        filenames.remove(medium.path)
+    except KeyError:
+        pass
+    return True
+
+def check_get_everything():
+    """
+    For every the accessor method, loop over the Cartesian products of all
+    possible values for its arguments.
+    Make sure we get every file in the repo, and that we get a file whenever
+    we should.
+
+    Well, there are exceptions of course.
+    """
+
+    versions = list(session.query(tables.Version).all())
+    versions.append('red-green')
+
+    black = session.query(tables.Version).filter_by(identifier=u'black').one()
+
+    filenames = get_all_filenames()
+
+    # Some small stuff first
+
+    for damage_class in session.query(tables.MoveDamageClass).all():
+        assert hit(filenames, media.DamageClassMedia(damage_class).icon)
+
+    for habitat in session.query(tables.PokemonHabitat).all():
+        assert hit(filenames, media.HabitatMedia(habitat).icon)
+
+    for shape in session.query(tables.PokemonShape).all():
+        assert hit(filenames, media.ShapeMedia(shape).icon)
+
+    for item_pocket in session.query(tables.ItemPocket).all():
+        assert hit(filenames, media.ItemPocketMedia(item_pocket).icon)
+        assert hit(filenames, media.ItemPocketMedia(item_pocket).icon, selected=True)
+
+    for contest_type in session.query(tables.ContestType).all():
+        assert hit(filenames, media.ContestTypeMedia(contest_type).icon)
+
+    for elemental_type in session.query(tables.Type).all():
+        assert hit(filenames, media.TypeMedia(elemental_type).icon)
+
+    # Items
+    versions_for_items = [
+            None,
+            session.query(tables.Version).filter_by(identifier='emerald').one(),
+        ]
+
+    for item in session.query(tables.Item).all():
+        accessor = media.ItemMedia(item)
+        assert hit(filenames, accessor.berry_image) or not item.berry
+        for rotation in (0, 90, 180, 270):
+            assert hit(filenames, accessor.underground, rotation=rotation) or (
+                    not item.appears_underground or rotation)
+        for version in versions_for_items:
+            success = hit(filenames, accessor.sprite, version=version)
+            if version is None:
+                assert success
+
+    for color in 'red green blue pale prism'.split():
+        for big in (True, False):
+            accessor = media.UndergroundSphereMedia(color=color, big=big)
+            assert hit(filenames, accessor.underground)
+
+    for rock_type in 'i ii o o-big s t z'.split():
+        accessor = media.UndergroundRockMedia(rock_type)
+        for rotation in (0, 90, 180, 270):
+            success = hit(filenames, accessor.underground, rotation=rotation)
+            assert success or rotation
+
+    # Pokemon!
+    accessors = []
+
+    accessors.append(media.UnknownPokemonMedia())
+    accessors.append(media.EggMedia())
+    manaphy = session.query(tables.Pokemon).filter_by(identifier=u'manaphy').one()
+    accessors.append(media.EggMedia(manaphy))
+    accessors.append(media.SubstituteMedia())
+
+    print 'Loading pokemon'
+
+    for form in session.query(tables.PokemonForm).filter(tables.PokemonForm.identifier != '').all():
+        accessors.append(media.PokemonFormMedia(form))
+
+    for pokemon in session.query(tables.Pokemon).all():
+        accessors.append(media.PokemonMedia(pokemon))
+
+    for accessor in accessors:
+        assert hit(filenames, accessor.footprint) or not accessor.form
+        assert hit(filenames, accessor.trozei) or not accessor.form or (
+                accessor.form.pokemon.generation.id > 3)
+        assert hit(filenames, accessor.cry) or not accessor.form
+        assert hit(filenames, accessor.cropped_sprite) or not accessor.form
+        for female in (True, False):
+            assert hit(filenames, accessor.icon, female=female) or not accessor.form
+            assert hit(filenames, accessor.sugimori, female=female) or (
+                    not accessor.form or accessor.form.pokemon.id >= 647)
+            for shiny in (True, False):
+                for frame in (1, 2):
+                    for direction in 'up down left right'.split():
+                        assert hit(filenames, accessor.overworld,
+                                direction=direction,
+                                shiny=shiny,
+                                female=female,
+                                frame=frame,
+                            ) or not accessor.form or (
+                                    accessor.form.pokemon.generation.id > 4)
+                    for version in versions:
+                        for animated in (True, False):
+                            for back in (True, False):
+                                for color in (None, 'gray', 'gbc'):
+                                    success = hit(filenames,
+                                            accessor.sprite,
+                                            version,
+                                            animated=animated,
+                                            back=back,
+                                            color=color,
+                                            shiny=shiny,
+                                            female=female,
+                                            frame=frame,
+                                        )
+                                    if (version == black and not animated
+                                        and not back and not color and not
+                                        shiny and not female and
+                                        frame == 1):
+                                        # All pokemon are in Black
+                                        assert success or not accessor.form
+                                    if (str(accessor.pokemon_id) == '1'
+                                        and not animated and not color and
+                                        frame == 1):
+                                        # Bulbasaur is in all versions
+                                        assert success
+
+    # Remove exceptions
+    exceptions = [os.path.join(basedir, dirname) for dirname in
+            'chrome fonts ribbons'.split()]
+    exceptions.append(os.path.join(basedir, 'items', 'hm-'))
+    exceptions = tuple(exceptions)
+
+    for filename in tuple(filenames):
+        if filename.startswith(exceptions):
+            filenames.remove(filename)
+
+    if len(filenames):
+        print
+        print '-----------------'
+        print 'Unaccessed stuff:'
+        for filename in sorted(filenames):
+            print filename
+        print len(filenames), 'unaccessed files :('
+
+    return (not filenames)
+
+if __name__ == '__main__':
+    result = nose.run(defaultTest=__file__)
+    result = result and check_get_everything()
+    exit(not result)