예제 #1
0
def build_db(filename):
    '''Create and populate the Naev database.'''
    with db.connect(filename) as conn:
        make_db(conn)

        # Store the star systems.
        ssystems = []
        for ssysfile in datafiles('SSystems'):
            ssys = SSystem(ssysfile)
            ssystems.append(ssys)
            store_ssys(conn, ssys)

        # Store the assets.
        assets = []
        for assetfile in datafiles('Assets'):
            asset = Asset(assetfile)
            assets.append(asset)

            asset_ssys = None
            if not asset.virtual:
                # Find which system has the asset.
                for ssys in ssystems:
                    if asset.name in ssys.assets:
                        asset_ssys = ssys.name
                        break
                if asset_ssys is None:
                    print("Asset '{}' belongs to no "
                          "system. Skipped!".format(asset.name),
                          file=sys.stderr)
                    continue

            store_asset(conn, asset, asset_ssys)

        # Store the jumps between systems, and the locations of virtual assets.
        for ssys in ssystems:
            store_jumps(conn, ssys)
            for asset_name in ssys.assets:
                # Find the asset.
                for asset in assets:
                    if asset.name == asset_name:
                        this_asset = asset
                        break
                else:
                    # The named asset doesn't exist.
                    continue
                if this_asset.virtual:
                    store_vasset_location(conn, ssys, this_asset)
예제 #2
0
파일: starmap.py 프로젝트: aminouara/naev
def main():
    '''Generate an SVG map and print it to standard output.

	The data files are assumed to be in ./dat/ssys/, relative to the
	current path, so this should be run from the root of the Naev
	source directory.
		BR change : runs from naevroot/utils/starmap
		so data is in ../../dat/ssys
	'''
    sys.stderr.write("Begin\n")
    # Local variables
    naevRoot = '../..'
    logging.basicConfig(level=logging.DEBUG)
    ssystems = []
    assets = []

    sys.stderr.write("\tLoading stellar systems\n")
    for ssysfile in datafiles('SSystems', naevRoot):
        # Parse each XML file into a SSystem object.
        try:
            ssystems.append(SSystem(ssysfile))
        except:
            print("Choked on '{}'".format(ssysfile), file=sys.stderr)
            raise
    sys.stderr.write("\t\t" + str(len(ssystems)) + " systems loaded\n")

    sys.stderr.write("\tLoading assets\n")
    for assetfile in datafiles('Assets', naevRoot):
        # Parse each XML file into a Asset object.
        try:
            assets.append(Asset(assetfile))
        except:
            print("Choked on '{}'".format(assetfile), file=sys.stderr)
            raise
    sys.stderr.write("\t\t" + str(len(assets)) + " assets loaded\n")

    sys.stderr.write("\tBuilding map\n")
    makemap(ssystems, assets)
    sys.stderr.write("Normal end\n")
예제 #3
0
def main():
    '''Generate an SVG map and print it to standard output.

    The data files are assumed to be in ./dat/ssys/, relative to the
    current path, so this should be run from the root of the Naev
    source directory.

    '''
    ssystems = []
    for ssysfile in datafiles('SSystems'):
        # Parse each XML file into a SSystem object.
        ssystems.append(SSystem(ssysfile))
    makemap(ssystems)
예제 #4
0
def main():
    ssystems = []
    for ssysfile in datafiles('SSystems'):
        # Parse each XML file into a SSystem object.
        ssystems.append(SSystem(ssysfile))

    neb_densest_at, neb_density, neb_densities = [], 0.0, []
    neb_worst_at, neb_volatility, neb_volatilities = [], 0.0, []
    int_worst_at, interference, interferences = [], 0.0, []

    largest_system, hi_radius, radii = [], 0.0, []
    smallest_system, lo_radius = [], float('Inf')

    most_stars_at, most_stars, stars = [], 0, []
    least_stars_at, least_stars = [], float('Inf')

    for ssys in ssystems:
        neb_densities.append(ssys.nebula.density)
        if ssys.nebula.density > neb_density:
            neb_densest_at, neb_density = [ssys.name], ssys.nebula.density
        elif ssys.nebula.density == neb_density:
            neb_densest_at.append(ssys.name)
        # ...else this isn't a candidate for the densest nebula.

        neb_volatilities.append(ssys.nebula.volatility)
        if ssys.nebula.volatility > neb_volatility:
            neb_worst_at, neb_volatility = [ssys.name], ssys.nebula.volatility
        elif ssys.nebula.volatility == neb_volatility:
            neb_worst_at.append(ssys.name)
        # ...else this isn't a candidate for the most dangerous nebula.

        interferences.append(ssys.interference)
        if ssys.interference > interference:
            int_worst_at, interference = [ssys.name], ssys.interference
        elif ssys.interference == interference:
            int_worst_at.append(ssys.name)
        # ...else this isn't a candidate for the highest interference.

        radii.append(ssys.radius)
        if ssys.radius > hi_radius:
            largest_system, hi_radius = [ssys.name], ssys.radius
        elif ssys.radius == hi_radius:
            largest_system.append(ssys.name)
        # ...else this isn't a candidate for the largest system.
        if ssys.radius < lo_radius:
            smallest_system, lo_radius = [ssys.name], ssys.radius
        elif ssys.radius == lo_radius:
            smallest_system.append(ssys.name)
        # ...else this isn't a candidate for the smallest system.

        stars.append(ssys.stars)
        if ssys.stars > most_stars:
            most_stars_at, most_stars = [ssys.name], ssys.stars
        elif ssys.stars == most_stars:
            most_stars_at.append(ssys.name)
        # ...else this isn't a candidate for the starriest system.
        if ssys.stars < least_stars:
            least_stars_at, least_stars = [ssys.name], ssys.stars
        elif ssys.stars == least_stars:
            least_stars_at.append(ssys.name)
        # ...else this isn't a candidate for the least starry system.

    print('Radius: μ={}, σ={}'.format(*stats(radii)))
    print('The largest system radius',
          '({}) is found in {}.'.format(hi_radius, liststr(largest_system)))
    print('The smallest system radius',
          '({}) is found in {}.'.format(lo_radius, liststr(smallest_system)))
    print()
    print('Nebula density: μ={}, σ={}'.format(*stats(neb_densities)))
    print('The densest nebula ({}) is in {}.'.format(neb_density,
                                                     liststr(neb_densest_at)))
    print()
    print('Nebula volatility: μ={}, σ={}'.format(*stats(neb_volatilities)))
    print('The nebula is at its most volatile',
          '({}) in {}.'.format(neb_volatility, liststr(neb_worst_at)))
    print()
    print('Interference: μ={}, σ={}'.format(*stats(interferences)))
    print('Interference is at its peak',
          '({}) in {}.'.format(interference, liststr(int_worst_at)))
    print()
    print('Stars: μ={}, σ={}'.format(*stats(stars)))
    print('The most starry skies',
          '({}) are found in {}.'.format(most_stars, liststr(most_stars_at)))
    print('The least starry skies',
          '({}) are found in {}.'.format(least_stars, liststr(least_stars_at)))
예제 #5
0
def main():
    ssystems = []
    for ssysfile in datafiles('SSystems'):
        # Parse each XML file into a SSystem object.
        ssystems.append(SSystem(ssysfile))

    neb_densest_at, neb_density, neb_densities = [], 0.0, []
    neb_worst_at, neb_volatility, neb_volatilities = [], 0.0, []
    int_worst_at, interference, interferences = [], 0.0, []

    largest_system, hi_radius, radii = [], 0.0, []
    smallest_system, lo_radius = [], float('Inf')

    most_stars_at, most_stars, stars = [], 0, []
    least_stars_at, least_stars = [], float('Inf')

    most_jumps_at, most_jumps, jumps = [], 0, []
    least_jumps_at, least_jumps = [], float('Inf')
    zero_jumps_at = []

    most_planets_at, most_planets, planets = [], 0, []
    least_planets_at, least_planets = [], float('Inf')
    zero_planets_at = []

    for ssys in ssystems:
        neb_densities.append(ssys.nebula.density)
        if ssys.nebula.density > neb_density:
            neb_densest_at, neb_density = [ssys.name], ssys.nebula.density
        elif ssys.nebula.density == neb_density:
            neb_densest_at.append(ssys.name)
        # ...else this isn't a candidate for the densest nebula.

        neb_volatilities.append(ssys.nebula.volatility)
        if ssys.nebula.volatility > neb_volatility:
            neb_worst_at, neb_volatility = [ssys.name], ssys.nebula.volatility
        elif ssys.nebula.volatility == neb_volatility:
            neb_worst_at.append(ssys.name)
        # ...else this isn't a candidate for the most dangerous nebula.

        interferences.append(ssys.interference)
        if ssys.interference > interference:
            int_worst_at, interference = [ssys.name], ssys.interference
        elif ssys.interference == interference:
            int_worst_at.append(ssys.name)
        # ...else this isn't a candidate for the highest interference.

        radii.append(ssys.radius)
        if ssys.radius > hi_radius:
            largest_system, hi_radius = [ssys.name], ssys.radius
        elif ssys.radius == hi_radius:
            largest_system.append(ssys.name)
        # ...else this isn't a candidate for the largest system.
        if ssys.radius < lo_radius:
            smallest_system, lo_radius = [ssys.name], ssys.radius
        elif ssys.radius == lo_radius:
            smallest_system.append(ssys.name)
        # ...else this isn't a candidate for the smallest system.

        stars.append(ssys.stars)
        if ssys.stars > most_stars:
            most_stars_at, most_stars = [ssys.name], ssys.stars
        elif ssys.stars == most_stars:
            most_stars_at.append(ssys.name)
        # ...else this isn't a candidate for the starriest system.
        if ssys.stars < least_stars:
            least_stars_at, least_stars = [ssys.name], ssys.stars
        elif ssys.stars == least_stars:
            least_stars_at.append(ssys.name)
        # ...else this isn't a candidate for the least starry system.

        jump_num = len(ssys.jumps)
        jumps.append(jump_num)
        if jump_num > most_jumps:
            most_jumps_at, most_jumps = [ssys.name], jump_num
        elif jump_num == most_jumps:
            most_jumps_at.append(ssys.name)
        # ...else this isn't a candidate for the system with the most jumps.
        if jump_num == 0:
            zero_jumps_at.append(ssys.name)
        # ...else this isn't a system with zero jumps.
        else:
            if jump_num < least_jumps:
                least_jumps_at, least_jumps = [ssys.name], jump_num
            elif jump_num == least_jumps:
                least_jumps_at.append(ssys.name)
        # ...else this isn't a candidate for the system with the least jumps.

        planet_num = 0
        for asset in ssys.assets:
            if not (asset.find('Virtual') + 1):
                planet_num = planet_num + 1
        # ...else this asset is Virtual.
        planets.append(planet_num)
        if planet_num > most_planets:
            most_planets_at, most_planets = [ssys.name], planet_num
        elif planet_num == most_planets:
            most_planets_at.append(ssys.name)
        # ...else this isn't a candidate for the system with the most planets.
        if planet_num == 0:
            zero_planets_at.append(ssys.name)
        # ...else this isn't a system with zero planets.
        else:
            if planet_num < least_planets:
                least_planets_at, least_planets = [ssys.name], planet_num
            elif planet_num == least_planets:
                least_planets_at.append(ssys.name)
        # ...else this isn't a candidate for the system with the least planets.

    print('Radius: μ={}, σ={}'.format(*stats(radii)))
    print('The largest system radius',
          '({}) can be found in {}.'.format(hi_radius, liststr(largest_system)))
    print('The smallest system radius',
          '({}) can be found in {}.'.format(lo_radius, liststr(smallest_system)))
    print()
    print('Nebula density: μ={}, σ={}'.format(*stats(neb_densities)))
    print('The densest part of the nebula',
          '({}) can be found in {}.'.format(neb_density, liststr(neb_densest_at)))
    print()
    print('Nebula volatility: μ={}, σ={}'.format(*stats(neb_volatilities)))
    print('The most volatile part of the nebula',
          '({}) can be found in {}.'.format(neb_volatility, liststr(neb_worst_at)))
    print()
    print('Interference: μ={}, σ={}'.format(*stats(interferences)))
    print('Interference is at its peak',
          '({}) in {}.'.format(interference, liststr(int_worst_at)))
    print()
    print('Stars: μ={}, σ={}'.format(*stats(stars)))
    print('The most starry skies',
          '({}) are found in {}.'.format(most_stars, liststr(most_stars_at)))
    print('The least starry skies',
          '({}) are found in {}.'.format(least_stars, liststr(least_stars_at)))
    print()
    print('Jumps: μ={}, σ={}'.format(*stats(jumps)))
    print('The most jump points',
          '({}) are found in {}.'.format(most_jumps, liststr(most_jumps_at)))
    print('The least jump points',
          '({}) are found in {}.'.format(least_jumps, liststr(least_jumps_at)))
    print('There are zero jump points in {}.'.format(liststr(zero_jumps_at)))
    print()
    print('Planets: μ={}, σ={}'.format(*stats(planets)))
    print('The most planets',
          '({}) can be found in {}.'.format(most_planets, liststr(most_planets_at)))
    print('The least planets',
          '({}) can be found in {}.'.format(least_planets, liststr(least_planets_at)))
    print('There are zero planets in {} systems.'.format(len(zero_planets_at)))
    print()

    assets = []
    for assetsfile in datafiles('Assets'):
        # Parse each XML file into a Asset object.
        assets.append(Asset(assetsfile))

    furthest, hi_orbit, orbits = [], 0.0, []
    nearest, lo_orbit = [], float('Inf')

    best_hidden, hi_hide, hides = [], 0.0, []
    worst_hidden, lo_hide = [], float('Inf')
    
    most_pop, hi_pop, pops = [], 0.0, []
    least_pop, lo_pop, total_pops = [], float('Inf'), []

    world_classes, class_matches = dict(), dict()
    
    for asset in assets:
        if not asset.virtual:
            orbit = hypot(asset.pos.x, asset.pos.y)
            orbits.append(orbit)
            if orbit > hi_orbit:
                furthest, hi_orbit = [asset.name], orbit
            elif orbit == hi_orbit:
                furthest.append(asset.name)
            # ...else this isn't a candidate for the biggest orbit.
            if orbit < lo_orbit:
                nearest, lo_orbit = [asset.name], orbit
            elif orbit == lo_orbit:
                nearest.append(asset.name)
            # ...else this isn't a candidate for the smallest orbit.

            hides.append(asset.hide)
            if asset.hide > hi_hide:
                best_hidden, hi_hide = [asset.name], asset.hide
            elif asset.hide == hi_hide:
                best_hidden.append(asset.name)
            # ...else this isn't a candidate for the best hidden.
            if asset.hide < lo_hide:
                worst_hidden, lo_hide = [asset.name], asset.hide
            elif asset.hide == lo_hide:
                worst_hidden.append(asset.name)
            # ...else this isn't a candidate for the least hidden.

            if asset.world_class in world_classes:
                world_classes[asset.world_class] += 1
            else:
                world_classes.update({asset.world_class: 1,})
            if asset.world_class.isalpha:
                if asset.gfx['space'][0] == asset.world_class:
                    if asset.world_class in class_matches:
                        class_matches[asset.world_class] += 1
                    else:
                        class_matches.update({asset.world_class: 1,})
                elif asset.gfx['space'][5] ==  asset.world_class:
                    if asset.world_class in class_matches:
                        class_matches[asset.world_class] += 1
                    else:
                        class_matches.update({asset.world_class: 1,})
                elif asset.gfx['space'][0] == 'a': 
                    if asset.gfx['space'][9] ==  asset.world_class:
                        if asset.world_class in class_matches:
                            class_matches[asset.world_class] += 1
                        else:
                            class_matches.update({asset.world_class: 1,})
            # ...else world class doesn't match the planet, moon or asteroid space graphic

            total_pops.append(asset.population)
            if asset.population > 0:
                pops.append(asset.population)
                if asset.population > hi_pop:
                    most_pop, hi_pop = [asset.name], asset.population
                elif asset.population == hi_pop:
                    most_pop.append(asset.name)
                # ...else this isn't a candidate for the biggest population.
                if asset.population < lo_pop:
                    least_pop, lo_pop = [asset.name], asset.population
                elif asset.population == lo_pop:
                    least_pop.append(asset.name)
                # ...else this isn't a candidate for the smallest population.

    print('Orbit: μ={}, σ={}'.format(*stats(orbits)))
    print('The biggest orbit',
          '({}) can be found in {}.'.format(hi_orbit, liststr(furthest)))
    print('The smallest orbit',
          '({}) can be found in {}.'.format(lo_orbit, liststr(nearest)))
    print()
    print('Difficulty in sensing: μ={}, σ={}'.format(*stats(hides)))
    print('The asset(s) most difficult to find',
          '({}) is or are {}.'.format(hi_hide, liststr(best_hidden)))
    print('The asset(s) least difficult to find',
          '({}) is or are {}.'.format(lo_hide, liststr(worst_hidden)))
    print()
    print('Population (everywhere): μ={}, σ={}'.format(*stats(total_pops)))
    print('Population (inhabitted planets only): μ={}, σ={}'.format(*stats(pops)))
    print('The biggest population',
          '({}) can be found on {}.'.format(hi_pop, liststr(most_pop)))
    print('The smallest (greater than zero) population',
          '({}) can be found on {}.'.format(lo_pop, liststr(least_pop)))
    print()
    for world_class in sorted(world_classes.keys()):
        asset_type = 'unknown'
        station_type = 'unknown'    
        extra_data = ''

        if world_class in ['0', '1', '2', '3']:
            # would prefer to pull the following data from naev/src/space.h
            asset_type = 'station'
            if world_class == '0': station_type = 'civilian'
            elif world_class == '1': station_type = 'military'
            elif world_class == '2': station_type = 'interfactional'
            elif world_class == '3': station_type = 'robotic'
            extra_data = ' (' + station_type + ')'
        elif world_class in class_matches:
            asset_type = 'planet'
            extra_data = ' (' + repr(math.ceil((world_classes[world_class] - class_matches[world_class]) / world_classes[world_class] * 100)) + '% don\'t match their space GFX)'
        else:
            asset_type = 'planet'
            extra_data = ' (100% don\'t match their space GFX)'

        if world_classes[world_class] == 1:
            print('There is 1 class {} {}{}.'
                  .format(world_class, asset_type, extra_data))
        else:
            print('There are {} class {} {}s{}.'
                  .format(world_classes[world_class], world_class, asset_type, extra_data))
    print()