def generate_systems(pos_list, gsd):
"""
Generates and populates star systems at all positions in specified list.
"""
sys_list = []
for position in pos_list:
star_type = pick_star_type(gsd.age)
system = fo.create_system(star_type, "", position.x, position.y)
if system == fo.invalid_object():
# create system failed, report an error and try to continue with next position
util.report_error(
"Python generate_systems: create system at position (%f, %f) failed"
% (position.x, position.y))
continue
sys_list.append(system)
for orbit in range(fo.sys_get_num_orbits(system)):
# check for each orbit if a planet shall be created by determining planet size
planet_size = planets.calc_planet_size(star_type, orbit,
gsd.planetDensity,
gsd.shape)
if planet_size in planets.planet_sizes:
# ok, we want a planet, determine planet type and generate the planet
planet_type = planets.calc_planet_type(star_type, orbit,
planet_size)
if fo.create_planet(planet_size, planet_type, system, orbit,
"") == fo.invalid_object():
# create planet failed, report an error and try to continue with next orbit
util.report_error(
"Python generate_systems: create planet in system %d failed"
% system)
return sys_list
def execute_turn_events():
print "Executing turn events for turn", fo.current_turn()
# creating fields
systems = fo.get_systems()
radius = fo.get_universe_width() / 2.0
if random() < max(0.0003 * radius, 0.03):
if random() < 0.4:
field_type = "FLD_MOLECULAR_CLOUD"
size = 5.0
else:
field_type = "FLD_ION_STORM"
size = 5.0
x = y = radius
dist_from_center = 0.0
while (dist_from_center < radius) or any(hypot(fo.get_x(s) - x, fo.get_y(s) - y) < 50.0 for s in systems):
angle = random() * 2.0 * pi
dist_from_center = radius + uniform(min(max(radius * 0.02, 10), 50.0), min(max(radius * 0.05, 20), 100.0))
x = radius + (dist_from_center * sin(angle))
y = radius + (dist_from_center * cos(angle))
print "...creating new", field_type, "field, at distance", dist_from_center, "from center"
if fo.create_field(field_type, x, y, size) == fo.invalid_object():
print >> sys.stderr, "Turn events: couldn't create new field"
# creating monsters
gsd = fo.get_galaxy_setup_data()
monster_freq = MONSTER_FREQUENCY[gsd.monsterFrequency]
# monster freq ranges from 30 (= one monster per 30 systems) to 3 (= one monster per 3 systems)
# (example: low monsters and 150 Systems results in 150 / 30 * 0.001 = 0.005)
if monster_freq > 0 and random() < len(systems) / monster_freq * 0.001:
#only spawn Krill at the moment, other monsters can follow in the future
if random() < 1:
monster_type = "SM_KRILL_1"
else:
monster_type = "SM_FLOATER"
# search for systems without planets or fleets
candidates = [s for s in systems if len(fo.sys_get_planets(s)) <= 0 and len(fo.sys_get_fleets(s)) <= 0]
if not candidates:
print >> sys.stderr, "Turn events: unable to find system for monster spawn"
else:
system = choice(candidates)
print "...creating new", monster_type, "at", fo.get_name(system)
# create monster fleet
monster_fleet = fo.create_monster_fleet(system)
# if fleet creation fails, report an error
if monster_fleet == fo.invalid_object():
print >> sys.stderr, "Turn events: unable to create new monster fleet"
else:
# create monster, if creation fails, report an error
monster = fo.create_monster(monster_type, monster_fleet)
if monster == fo.invalid_object():
print >> sys.stderr, "Turn events: unable to create monster in fleet"
return True
def execute_turn_events():
print "Executing turn events for turn", fo.current_turn()
# creating fields
systems = fo.get_systems()
radius = fo.get_universe_width() / 2.0
if random() < max(0.0003 * radius, 0.03):
if random() < 0.4:
field_type = "FLD_MOLECULAR_CLOUD"
size = 5.0
else:
field_type = "FLD_ION_STORM"
size = 5.0
x = y = radius
dist_from_center = 0.0
while (dist_from_center < radius) or any(
hypot(fo.get_x(s) - x,
fo.get_y(s) - y) < 50.0 for s in systems):
angle = random() * 2.0 * pi
dist_from_center = radius + uniform(
min(max(radius * 0.02, 10), 50.0),
min(max(radius * 0.05, 20), 100.0))
x = radius + (dist_from_center * sin(angle))
y = radius + (dist_from_center * cos(angle))
print "...creating new", field_type, "field, at distance", dist_from_center, "from center"
if fo.create_field(field_type, x, y, size) == fo.invalid_object():
print >> sys.stderr, "Turn events: couldn't create new field"
return True
def generate_fields(systems):
"""
Generates stationary fields in some randomly chosen empty no star systems.
"""
# filter out all empty no star systems
candidates = [
s for s in systems
if (fo.sys_get_star_type(s) == fo.starType.noStar) and (
not fo.sys_get_planets(s))
]
# make sure we have at least one empty no star system, otherwise return without creating any fields
if not candidates:
print("...no empty no star systems found, no fields created")
return
# pick 10-15% of all empty no star systems to create stationary fields in them, but at least one
accepted = sample(candidates,
max(int(len(candidates) * uniform(0.1, 0.15)), 1))
for system in accepted:
# randomly pick a field type
field_type = choice(["FLD_NEBULA_1", "FLD_NEBULA_2", "FLD_NEBULA_3"])
# and create the field
if fo.create_field_in_system(field_type, uniform(40, 120),
system) == fo.invalid_object():
# create field failed, report an error
report_error(
"Python generate_fields: create field %s in system %d failed" %
(field_type, system))
print("...fields created in %d systems out of %d empty no star systems" %
(len(accepted), len(candidates)))
def execute_turn_events():
print "Executing turn events for turn", fo.current_turn()
# creating fields
systems = fo.get_systems()
radius = fo.get_universe_width() / 2.0
if random() < max(0.0003 * radius, 0.03):
if random() < 0.4:
field_type = "FLD_MOLECULAR_CLOUD"
size = 5.0
else:
field_type = "FLD_ION_STORM"
size = 5.0
x = y = radius
dist_from_center = 0.0
while (dist_from_center < radius) or any(hypot(fo.get_x(s) - x, fo.get_y(s) - y) < 50.0 for s in systems):
angle = random() * 2.0 * pi
dist_from_center = radius + uniform(min(max(radius * 0.02, 10), 50.0), min(max(radius * 0.05, 20), 100.0))
x = radius + (dist_from_center * sin(angle))
y = radius + (dist_from_center * cos(angle))
print "...creating new", field_type, "field, at distance", dist_from_center, "from center"
if fo.create_field(field_type, x, y, size) == fo.invalid_object():
print >> sys.stderr, "Turn events: couldn't create new field"
return True
def compile_home_system_list(num_home_systems, systems):
"""
Compiles a list with a requested number of home systems.
"""
# if the list of systems to choose home systems from is empty, report an error and return empty list
if not systems:
util.report_error("Python generate_home_system_list: no systems to choose from")
return []
# calculate an initial minimal number of jumps that the home systems should be apart,
# based on the total number of systems to choose from and the requested number of home systems
min_jumps = max(int(float(len(systems)) / float(num_home_systems * 2)), 5)
# try to find the home systems, decrease the min jumps until enough systems can be found, or the min jump distance
# gets reduced to 0 (meaning we don't have enough systems to choose from at all)
while min_jumps > 0:
print "Trying to find", num_home_systems, "home systems that are at least", min_jumps, "jumps apart"
# try to find home systems...
home_systems = find_systems_with_min_jumps_between(num_home_systems, systems, min_jumps)
# ...check if we got enough...
if len(home_systems) >= num_home_systems:
# ...yes, we got what we need, so let's break out of the loop
break
print "Home system min jump conflict: %d systems and %d empires, tried %d min jump and failed"\
% (len(systems), num_home_systems, min_jumps)
# ...no, decrease the min jump distance and try again
min_jumps -= 1
# check if the loop above delivered a list with enough home systems, or if it exited because the min jump distance
# has been decreased to 0 without finding enough systems
# in that case, our galaxy obviously is too crowded, report an error and return an empty list
if len(home_systems) < num_home_systems:
util.report_error("Python generate_home_system_list: requested %d homeworlds in a galaxy with %d systems"
% (num_home_systems, len(systems)))
return []
# make sure all our home systems have a "real" star (that is, a star that is not a neutron star, black hole,
# or even no star at all) and at least one planet in it
for home_system in home_systems:
# if this home system has no "real" star, change star type to a randomly selected "real" star
if fo.sys_get_star_type(home_system) not in starsystems.star_types_real:
star_type = random.choice(starsystems.star_types_real)
print "Home system", home_system, "has star type", fo.sys_get_star_type(home_system),\
", changing that to", star_type
fo.sys_set_star_type(home_system, star_type)
# if this home system has no planets, create one in a random orbit
# we take random values for type and size, as these will be set to suitable values later
if not fo.sys_get_planets(home_system):
print "Home system", home_system, "has no planets, adding one"
planet = fo.create_planet(random.choice(planets.planet_sizes_real),
random.choice(planets.planet_types_real),
home_system, random.randint(0, fo.sys_get_num_orbits(home_system) - 1), "")
# if we couldn't create the planet, report an error and return an empty list
if planet == fo.invalid_object():
util.report_error("Python generate_home_system_list: couldn't create planet in home system")
return []
return home_systems
def populate_monster_fleet(fleet_plan, system):
"""
Create a monster fleet in ''system'' according to ''fleet_plan''
"""
# create monster fleet
monster_fleet = fo.create_monster_fleet(system)
if monster_fleet == fo.invalid_object():
raise MapGenerationError("Python generate_monsters: unable to create new monster fleet %s" % fleet_plan.name())
# add monsters to fleet
for design in fleet_plan.ship_designs():
if fo.create_monster(design, monster_fleet) == fo.invalid_object():
raise MapGenerationError("Python generate_monsters: unable to create monster %s" % design)
print "Spawn", fleet_plan.name(), "at", fo.get_name(system)
def populate_monster_fleet(fleet_plan, system):
"""
Create a monster fleet in ''system'' according to ''fleet_plan''
"""
# create monster fleet
monster_fleet = fo.create_monster_fleet(system)
if monster_fleet == fo.invalid_object():
raise MapGenerationError("Python generate_monsters: unable to create new monster fleet %s"
% fleet_plan.name())
# add monsters to fleet
for design in fleet_plan.ship_designs():
if fo.create_monster(design, monster_fleet) == fo.invalid_object():
raise MapGenerationError("Python generate_monsters: unable to create monster %s" % design)
print "Spawn", fleet_plan.name(), "at", fo.get_name(system)
def generate_systems(pos_list, gsd):
"""
Generates and populates star systems at all positions in specified list.
"""
sys_list = []
for position in pos_list:
star_type = pick_star_type(gsd.age)
system = fo.create_system(star_type, "", position[0], position[1])
if system == fo.invalid_object():
# create system failed, report an error and try to continue with next position
util.report_error(
"Python generate_systems: create system at position (%f, %f) failed"
% (position[0], position[1]))
continue
sys_list.append(system)
orbits = list(range(fo.sys_get_num_orbits(system)))
if not planets.can_have_planets(star_type, orbits, gsd.planet_density,
gsd.shape):
continue
# Try to generate planets in each orbit.
# If after each orbit is tried once there are no planets then
# keep trying until a single planet is placed.
# Except for black hole systems, which can be empty.
at_least_one_planet = False
random.shuffle(orbits)
for orbit in orbits:
if planets.generate_a_planet(system, star_type, orbit,
gsd.planet_density, gsd.shape):
at_least_one_planet = True
if at_least_one_planet or can_have_no_planets(star_type):
continue
recursion_limit = 1000
for _, orbit in product(range(recursion_limit), orbits):
if planets.generate_a_planet(system, star_type, orbit,
gsd.planet_density, gsd.shape):
break
else:
# Intentionally non-modal. Should be a warning.
print(
("Python generate_systems: place planets in system %d at position (%.2f, %.2f) failed"
% (system, position[0], position[1])),
file=sys.stderr,
)
return sys_list
def generate_systems(pos_list, gsd):
"""
Generates and populates star systems at all positions in specified list.
"""
sys_list = []
for position in pos_list:
star_type = pick_star_type(gsd.age)
system = fo.create_system(star_type, "", position.x, position.y)
if system == fo.invalid_object():
# create system failed, report an error and try to continue with next position
util.report_error("Python generate_systems: create system at position (%f, %f) failed"
% (position.x, position.y))
continue
sys_list.append(system)
for orbit in range(0, fo.sys_get_num_orbits(system) - 1):
# check for each orbit if a planet shall be created by determining planet size
planet_size = planets.calc_planet_size(star_type, orbit, gsd.planetDensity, gsd.shape)
if planet_size in planets.planet_sizes:
# ok, we want a planet, determine planet type and generate the planet
planet_type = planets.calc_planet_type(star_type, orbit, planet_size)
if fo.create_planet(planet_size, planet_type, system, orbit, "") == fo.invalid_object():
# create planet failed, report an error and try to continue with next orbit
util.report_error("Python generate_systems: create planet in system %d failed" % system)
return sys_list
def generate_a_planet(system, star_type, orbit, planet_density, galaxy_shape):
"""
Place a planet in an orbit of a system. Return True on success
"""
planet_size = calc_planet_size(star_type, orbit, planet_density, galaxy_shape)
if planet_size not in planet_sizes:
return False
# ok, we want a planet, determine planet type and generate the planet
planet_type = calc_planet_type(star_type, orbit, planet_size)
if planet_type == fo.planetType.unknown:
return False
if fo.create_planet(planet_size, planet_type, system, orbit, "") == fo.invalid_object():
# create planet failed, report an error
util.report_error("Python generate_systems: create planet in system %d failed" % system)
return False
return True
def generate_systems(pos_list, gsd):
"""
Generates and populates star systems at all positions in specified list.
"""
sys_list = []
for position in pos_list:
star_type = pick_star_type(gsd.age)
system = fo.create_system(star_type, "", position[0], position[1])
if system == fo.invalid_object():
# create system failed, report an error and try to continue with next position
util.report_error("Python generate_systems: create system at position (%f, %f) failed"
% (position[0], position[1]))
continue
sys_list.append(system)
orbits = range(fo.sys_get_num_orbits(system))
if not planets.can_have_planets(star_type, orbits, gsd.planet_density, gsd.shape):
continue
# Try to generate planets in each orbit.
# If after each orbit is tried once there are no planets then
# keep trying until a single planet is placed.
# Except for black hole systems, which can be empty.
at_least_one_planet = False
random.shuffle(orbits)
for orbit in orbits:
if planets.generate_a_planet(system, star_type, orbit, gsd.planet_density, gsd.shape):
at_least_one_planet = True
if at_least_one_planet or can_have_no_planets(star_type):
continue
recursion_limit = 1000
for _, orbit in product(range(recursion_limit), orbits):
if planets.generate_a_planet(system, star_type, orbit, gsd.planet_density, gsd.shape):
break
else:
# Intentionally non-modal. Should be a warning.
print >> sys.stderr, ("Python generate_systems: place planets in system %d at position (%.2f, %.2f) failed"
% (system, position[0], position[1]))
return sys_list
def generate_fields(systems):
"""
Generates stationary fields in some randomly chosen empty no star systems.
"""
# filter out all empty no star systems
candidates = [s for s in systems if (fo.sys_get_star_type(s) == fo.starType.noStar) and (not fo.sys_get_planets(s))]
# make sure we have at least one empty no star system, otherwise return without creating any fields
if not candidates:
print "...no empty no star systems found, no fields created"
return
# pick 10-20% of all empty no star systems to create stationary fields in them, but at least one
accepted = sample(candidates, max(int(len(candidates) * uniform(0.1, 0.2)), 1))
for system in accepted:
# randomly pick a field type
field_type = choice(["FLD_NEBULA_1", "FLD_NEBULA_2"])
# and create the field
if fo.create_field_in_system(field_type, uniform(40, 120), system) == fo.invalid_object():
# create field failed, report an error
report_error("Python generate_fields: create field %s in system %d failed" % (field_type, system))
print "...fields created in %d systems out of %d empty no star systems" % (len(accepted), len(candidates))
def generate_a_planet(system, star_type, orbit, planet_density, galaxy_shape):
"""
Place a planet in an orbit of a system. Return True on success
"""
planet_size = calc_planet_size(star_type, orbit, planet_density,
galaxy_shape)
if planet_size not in planet_sizes:
return False
# ok, we want a planet, determine planet type and generate the planet
planet_type = calc_planet_type(star_type, orbit, planet_size)
if planet_type == fo.planetType.unknown:
return False
if fo.create_planet(planet_size, planet_type, system, orbit,
"") == fo.invalid_object():
# create planet failed, report an error
util.report_error(
"Python generate_systems: create planet in system %d failed" %
system)
return False
return True
def setup_empire(empire, empire_name, home_system, starting_species,
player_name):
"""
Sets up various aspects of an empire, like empire name, homeworld, etc.
"""
# set empire name, if no one is given, pick one randomly
if not empire_name:
print "No empire name set for player", player_name, ", picking one randomly"
empire_name = next(empire_name_generator)
fo.empire_set_name(empire, empire_name)
print "Empire name for player", player_name, "is", empire_name
# check starting species, if no one is given, pick one randomly
if starting_species == "RANDOM" or not starting_species:
print "Picking random starting species for player", player_name
starting_species = next(starting_species_pool)
print "Starting species for player", player_name, "is", starting_species
universe_statistics.empire_species[starting_species] += 1
# pick a planet from the specified home system as homeworld
planet_list = fo.sys_get_planets(home_system)
# if the system is empty, report an error and return false, indicating failure
if not planet_list:
report_error("Python setup_empire: got home system with no planets")
return False
homeworld = random.choice(planet_list)
# set selected planet as empire homeworld with selected starting species
fo.empire_set_homeworld(empire, homeworld, starting_species)
# set homeworld focus
# check if the preferred focus for the starting species is among
# the foci available on the homeworld planet
available_foci = fo.planet_available_foci(homeworld)
preferred_focus = fo.species_preferred_focus(starting_species)
if preferred_focus in available_foci:
# if yes, set the homeworld focus to the preferred focus
print "Player", player_name, ": setting preferred focus", preferred_focus, "on homeworld"
fo.planet_set_focus(homeworld, preferred_focus)
elif len(available_foci) > 0:
# if no, and there is at least one available focus,
# just take the first of the list
if preferred_focus == "":
print "Player", player_name, ": starting species", starting_species, "has no preferred focus, using",\
available_foci[0], "instead"
else:
print "Player", player_name, ": preferred focus", preferred_focus, "for starting species",\
starting_species, "not available on homeworld, using", available_foci[0], "instead"
fo.planet_set_focus(homeworld, available_foci[0])
else:
# if no focus is available on the homeworld, don't set any focus
print "Player", player_name, ": no available foci on homeworld for starting species", starting_species
# give homeworld starting buildings
print "Player", player_name, ": add starting buildings to homeworld"
for item in fo.load_starting_buildings():
fo.create_building(item.name, homeworld, empire)
# unlock starting techs, buildings, hulls, ship parts, etc.
# use default content file
print "Player", player_name, ": add unlocked items"
for item in fo.load_item_spec_list():
fo.empire_unlock_item(empire, item.type, item.name)
# add premade ship designs to empire
print "Player", player_name, ": add premade ship designs"
for ship_design in fo.design_get_premade_list():
fo.empire_add_ship_design(empire, ship_design)
# add starting fleets to empire
# use default content file
print "Player", player_name, ": add starting fleets"
fleet_plans = fo.load_fleet_plan_list()
for fleet_plan in fleet_plans:
# first, create the fleet
fleet = fo.create_fleet(fleet_plan.name(), home_system, empire)
# if the fleet couldn't be created, report an error and try to continue with the next fleet plan
if fleet == fo.invalid_object():
report_error("Python setup empire: couldn't create fleet %s" %
fleet_plan.name())
continue
# second, iterate over the list of ship design names in the fleet plan
for ship_design in fleet_plan.ship_designs():
# create a ship in the fleet
# if the ship couldn't be created, report an error and try to continue with the next ship design
if fo.create_ship("", ship_design, starting_species,
fleet) == fo.invalid_object():
report_error(
"Python setup empire: couldn't create ship %s for fleet %s"
% (ship_design, fleet_plan.name()))
return True
def compile_home_system_list(num_home_systems, systems, gsd):
"""
Compiles a list with a requested number of home systems.
"""
print "Compile home system list:", num_home_systems, "systems requested"
# if the list of systems to choose home systems from is empty, report an error and return empty list
if not systems:
report_error(
"Python generate_home_system_list: no systems to choose from")
return []
# calculate an initial minimal number of jumps that the home systems should be apart,
# based on the total number of systems to choose from and the requested number of home systems
# don't let min_jumps be either:
# a.) larger than a defined limit, because an unreasonably large number is really not at all needed,
# and with large galaxies an excessive amount of time can be used in failed attempts
# b.) lower than the minimum jump distance limit that should be considered high priority (see options.py),
# otherwise no attempt at all would be made to enforce the other requirements for home systems (see below)
min_jumps = min(
HS_MAX_JUMP_DISTANCE_LIMIT,
max(int(float(len(systems)) / float(num_home_systems * 2)),
HS_MIN_DISTANCE_PRIORITY_LIMIT))
# home systems must have a certain minimum of systems and planets in their near vicinity
# we will try to select our home systems from systems that match this criteria, if that fails, we will select our
# home systems from all systems and add the missing number planets to the systems in their vicinity afterwards
# the minimum system and planet limit and the jump range that defines the "near vicinity" are controlled by the
# HS_* option constants in options.py (see there)
# we start by building two additional pools of systems: one that contains all systems that match the criteria
# completely (meets the min systems and planets limit), and one that contains all systems that match the criteria
# at least partially (meets the min systems limit)
pool_matching_sys_and_planet_limit = []
pool_matching_sys_limit = []
for system in systems:
systems_in_vicinity = fo.systems_within_jumps_unordered(
HS_VICINITY_RANGE, [system])
if len(systems_in_vicinity) >= HS_MIN_SYSTEMS_IN_VICINITY:
pool_matching_sys_limit.append(system)
if count_planets_in_systems(
systems_in_vicinity) >= min_planets_in_vicinity_limit(
len(systems_in_vicinity)):
pool_matching_sys_and_planet_limit.append(system)
print(
len(pool_matching_sys_and_planet_limit),
"systems meet the min systems and planets in the near vicinity limit")
print len(pool_matching_sys_limit
), "systems meet the min systems in the near vicinity limit"
# now try to pick the requested number of home systems
# we will do this by calling find_home_systems, which takes a list of tuples defining the pools from which to pick
# the home systems; it will use the pools in the order in which they appear in the list, so put better pools first
# we will make two attempts: the first one with the filtered pools we just created, and tell find_home_systems
# to start with the min_jumps jumps distance we calculated above, but not to go lower than
# HS_MIN_DISTANCE_PRIORITY_LIMIT
print "First attempt: trying to pick home systems from the filtered pools of preferred systems"
pool_list = [
# the better pool is of course the one where all systems meet BOTH the min systems and planets limit
(pool_matching_sys_and_planet_limit,
"pool of systems that meet both the min systems and planets limit"),
# next the less preferred pool where all systems at least meets the min systems limit
# specify 0 as number of requested home systems to pick as much systems as possible
(pool_matching_sys_limit,
"pool of systems that meet at least the min systems limit"),
]
home_systems = find_home_systems(num_home_systems, pool_list, min_jumps,
HS_MIN_DISTANCE_PRIORITY_LIMIT)
# check if the first attempt delivered a list with enough home systems
# if not, we make our second attempt, this time disregarding the filtered pools and using all systems, starting
# again with the min_jumps jump distance limit and specifying 0 as number of required home systems to pick as much
# systems as possible
if len(home_systems) < num_home_systems:
print "Second attempt: trying to pick home systems from all systems"
home_systems = find_home_systems(num_home_systems,
[(systems, "complete pool")],
min_jumps, 1)
# check if the selection process delivered a list with enough home systems
# if not, our galaxy obviously is too crowded, report an error and return an empty list
if len(home_systems) < num_home_systems:
report_error(
"Python generate_home_system_list: requested %d homeworlds in a galaxy with %d systems"
% (num_home_systems, len(systems)))
return []
# check if we got more home systems than we requested
if len(home_systems) > num_home_systems:
# yes: calculate the number of planets in the near vicinity of each system
# and store that value with each system in a map
hs_planets_in_vicinity_map = {
s: calculate_home_system_merit(s)
for s in home_systems
}
# sort the home systems by the number of planets in their near vicinity using the map
# now only pick the number of home systems we need, taking those with the highest number of planets
home_systems = sorted(home_systems,
key=hs_planets_in_vicinity_map.get,
reverse=True)[:num_home_systems]
# make sure all our home systems have a "real" star (that is, a star that is not a neutron star, black hole,
# or even no star at all) and at least one planet in it
for home_system in home_systems:
# if this home system has no "real" star, change star type to a randomly selected "real" star
if fo.sys_get_star_type(home_system) not in star_types_real:
star_type = random.choice(star_types_real)
print "Home system", home_system, "has star type", fo.sys_get_star_type(home_system),\
", changing that to", star_type
fo.sys_set_star_type(home_system, star_type)
# if this home system has no planets, create one in a random orbit
# we take random values for type and size, as these will be set to suitable values later
if not fo.sys_get_planets(home_system):
print "Home system", home_system, "has no planets, adding one"
planet = fo.create_planet(
random.choice(planet_sizes_real),
random.choice(planet_types_real), home_system,
random.randint(0,
fo.sys_get_num_orbits(home_system) - 1), "")
# if we couldn't create the planet, report an error and return an empty list
if planet == fo.invalid_object():
report_error(
"Python generate_home_system_list: couldn't create planet in home system"
)
return []
# finally, check again if all home systems meet the criteria of having the required minimum number of planets
# within their near vicinity, if not, add the missing number of planets
print "Checking if home systems have the required minimum of planets within the near vicinity..."
for home_system in home_systems:
# calculate the number of missing planets, and add them if this number is > 0
systems_in_vicinity = fo.systems_within_jumps_unordered(
HS_VICINITY_RANGE, [home_system])
num_systems_in_vicinity = len(systems_in_vicinity)
num_planets_in_vicinity = count_planets_in_systems(systems_in_vicinity)
num_planets_to_add = min_planets_in_vicinity_limit(
num_systems_in_vicinity) - num_planets_in_vicinity
print "Home system", home_system, "has", num_systems_in_vicinity, "systems and", num_planets_in_vicinity,\
"planets in the near vicinity, required minimum:", min_planets_in_vicinity_limit(num_systems_in_vicinity)
if num_planets_to_add > 0:
systems_in_vicinity.remove(
home_system
) # don't add planets to the home system, so remove it from the list
# sort the systems_in_vicinity before adding, since the C++ engine doesn't guarrantee the same
# platform independence as python.
add_planets_to_vicinity(sorted(systems_in_vicinity),
num_planets_to_add, gsd)
# as we've sorted the home system list before, lets shuffle it to ensure random order and return
random.shuffle(home_systems)
return home_systems
def add_planets_to_vicinity(vicinity, num_planets, gsd):
"""
Adds the specified number of planets to the specified systems.
"""
print "Adding", num_planets, "planets to the following systems:", vicinity
# first, compile a list containing all the free orbits in the specified systems
# begin with adding the free orbits of all systems that have a real star (that is, no neutron star, black hole,
# and not no star), if that isn't enough, also one, by one, add the free orbits of neutron star, black hole and
# no star systems (in that order) until we have enough free orbits
# for that, we use this list of tuples
# the first tuple contains all real star types, the following tuples the neutron, black hole and no star types,
# so we can iterate over this list and only add the free orbits of systems that match the respective star types
# each step
# this way we can prioritize the systems we want to add planets to by star type
acceptable_star_types_list = [
star_types_real, (fo.starType.noStar, ), (fo.starType.neutron, ),
(fo.starType.blackHole, )
]
# store the free orbits as a list of tuples of (system, orbit)
free_orbits_map = []
# now, iterate over the list of acceptable star types
for acceptable_star_types in acceptable_star_types_list:
# check all systems in the list of systems we got passed into this function
for system in vicinity:
# if this system has a star type we want to accept in this step, add its free orbits to our list
if fo.sys_get_star_type(system) in acceptable_star_types:
free_orbits_map.extend([
(system, orbit) for orbit in fo.sys_free_orbits(system)
])
# check if we got enough free orbits after completing this step
# we want 4 times as much free orbits as planets we want to add, that means each system shouldn't get more
# than 2-3 additional planets on average
if len(free_orbits_map) > (num_planets * 4):
break
# if we got less free orbits than planets that should be added, something is wrong
# in that case abort and log an error
if len(free_orbits_map) < num_planets:
report_error(
"Python add_planets_to_vicinity: less free orbits than planets to add - cancelled"
)
print "...free orbits available:", free_orbits_map
# as we will pop the free orbits from this list afterwards, shuffle it to randomize the order of the orbits
random.shuffle(free_orbits_map)
# add the requested number of planets
while num_planets > 0:
# get the next free orbit from the list we just compiled
system, orbit = free_orbits_map.pop()
# check the star type of the system containing the orbit we got
star_type = fo.sys_get_star_type(system)
if star_type in [fo.starType.noStar, fo.starType.blackHole]:
# if it is a black hole or has no star, change the star type
# pick a star type, continue until we get a real star
# don't accept neutron, black hole or no star
print "...system picked to add a planet has star type", star_type
while star_type not in star_types_real:
star_type = pick_star_type(gsd.age)
print "...change that to", star_type
fo.sys_set_star_type(system, star_type)
# pick a planet size, continue until we get a size that matches the HS_ACCEPTABLE_PLANET_SIZES option
planet_size = fo.planetSize.unknown
while planet_size not in HS_ACCEPTABLE_PLANET_SIZES:
planet_size = calc_planet_size(star_type, orbit,
fo.galaxySetupOption.high,
gsd.shape)
# pick an according planet type
planet_type = calc_planet_type(star_type, orbit, planet_size)
# finally, create the planet in the system and orbit we got
print "...adding", planet_size, planet_type, "planet to system", system
if fo.create_planet(planet_size, planet_type, system, orbit,
"") == fo.invalid_object():
report_error(
"Python add_planets_to_vicinity: create planet in system %d failed"
% system)
# continue with next planet
num_planets -= 1
def compile_home_system_list(num_home_systems, systems):
"""
Compiles a list with a requested number of home systems.
"""
print "Compile home system list:", num_home_systems, "systems requested"
# if the list of systems to choose home systems from is empty, report an error and return empty list
if not systems:
report_error("Python generate_home_system_list: no systems to choose from")
return []
# calculate an initial minimal number of jumps that the home systems should be apart,
# based on the total number of systems to choose from and the requested number of home systems
# Don't let min_jumps be larger than 10, because a larger number is really not at all needed and with large
# galaxies an excessive amount of time can be used in failed attempts
min_jumps = min(10, max(int(float(len(systems)) / float(num_home_systems * 2)), 5))
# home systems must have a certain minimum of systems in their near vicinity
# we will try to select our home systems from systems that match this criteria, if that fails, we will select our
# home systems from all systems and add the missing number planets to the systems in their vicinity afterwards
# the minimum planet limit and the jump range that defines the "near vicinity" are controlled by the
# HS_* option constants in options.py (see there)
# lets start by filtering out all systems from the pool we got passed into this function that match the criteria
filtered_pool = [s for s in systems if has_min_planets_in_vicinity(s)]
print "Filtering out systems that meet the minimum planets in the near vicinity condition yielded",\
len(filtered_pool), "systems"
print "Using this as the preferred pool for home system selection"
# now try to pick the requested number of home systems by calling find_home_systems
# this function takes two pools, a "complete" pool and one with preferred systems
# it will try to pick the home systems from the preferred pool first, so pass our filtered pool as preferred pool
home_systems = find_home_systems(num_home_systems, systems, filtered_pool, min_jumps)
# check if the selection process delivered a list with enough home systems
# if not, our galaxy obviously is too crowded, report an error and return an empty list
if len(home_systems) < num_home_systems:
report_error("Python generate_home_system_list: requested %d homeworlds in a galaxy with %d systems"
% (num_home_systems, len(systems)))
return []
# check if we got more home systems than we requested
if len(home_systems) > num_home_systems:
# yes: calculate the number of planets in the near vicinity of each system
# and store that value with each system in a map
hs_planets_in_vicinity_map = {s: count_planets_in_systems(get_systems_within_jumps(s, HS_VICINITY_RANGE))
for s in home_systems}
# sort the home systems by the number of planets in their near vicinity using the map
# now only pick the number of home systems we need, taking those with the highest number of planets
home_systems = sorted(home_systems, key=hs_planets_in_vicinity_map.get, reverse=True)[:num_home_systems]
# make sure all our home systems have a "real" star (that is, a star that is not a neutron star, black hole,
# or even no star at all) and at least one planet in it
for home_system in home_systems:
# if this home system has no "real" star, change star type to a randomly selected "real" star
if fo.sys_get_star_type(home_system) not in star_types_real:
star_type = random.choice(star_types_real)
print "Home system", home_system, "has star type", fo.sys_get_star_type(home_system),\
", changing that to", star_type
fo.sys_set_star_type(home_system, star_type)
# if this home system has no planets, create one in a random orbit
# we take random values for type and size, as these will be set to suitable values later
if not fo.sys_get_planets(home_system):
print "Home system", home_system, "has no planets, adding one"
planet = fo.create_planet(random.choice(planet_sizes_real),
random.choice(planet_types_real),
home_system, random.randint(0, fo.sys_get_num_orbits(home_system) - 1), "")
# if we couldn't create the planet, report an error and return an empty list
if planet == fo.invalid_object():
report_error("Python generate_home_system_list: couldn't create planet in home system")
return []
# finally, check again if all home systems meet the criteria of having the required minimum number of planets
# within their near vicinity, if not, add the missing number of planets
print "Checking if home systems have the required minimum of planets within the near vicinity..."
for home_system in home_systems:
# calculate the number of missing planets, and add them if this number is > 0
systems_in_vicinity = get_systems_within_jumps(home_system, HS_VICINITY_RANGE)
num_systems_in_vicinity = len(systems_in_vicinity)
num_planets_in_vicinity = count_planets_in_systems(systems_in_vicinity)
num_planets_to_add = min_planets_in_vicinity_limit(num_systems_in_vicinity) - num_planets_in_vicinity
print "Home system", home_system, "has", num_systems_in_vicinity, "systems and", num_planets_in_vicinity,\
"planets in the near vicinity, required minimum:", min_planets_in_vicinity_limit(num_systems_in_vicinity)
if num_planets_to_add > 0:
systems_in_vicinity.remove(home_system) # don't add planets to the home system, so remove it from the list
add_planets_to_vicinity(systems_in_vicinity, num_planets_to_add)
# as we've sorted the home system list before, lets shuffle it to ensure random order and return
random.shuffle(home_systems)
return home_systems
def setup_empire(empire, empire_name, home_system, starting_species, player_name):
"""
Sets up various aspects of an empire, like empire name, homeworld, etc.
"""
# set empire name, if no one is given, pick one randomly
if not empire_name:
print "No empire name set for player", player_name, ", picking one randomly"
empire_name = next(empire_name_generator)
fo.empire_set_name(empire, empire_name)
print "Empire name for player", player_name, "is", empire_name
# check starting species, if no one is given, pick one randomly
if starting_species == "RANDOM" or not starting_species:
print "Picking random starting species for player", player_name
starting_species = next(starting_species_pool)
print "Starting species for player", player_name, "is", starting_species
statistics.empire_species[starting_species] += 1
# pick a planet from the specified home system as homeworld
planet_list = fo.sys_get_planets(home_system)
# if the system is empty, report an error and return false, indicating failure
if not planet_list:
report_error("Python setup_empire: got home system with no planets")
return False
homeworld = random.choice(planet_list)
# set selected planet as empire homeworld with selected starting species
fo.empire_set_homeworld(empire, homeworld, starting_species)
# set homeworld focus
# check if the preferred focus for the starting species is among
# the foci available on the homeworld planet
available_foci = fo.planet_available_foci(homeworld)
preferred_focus = fo.species_preferred_focus(starting_species)
if preferred_focus in available_foci:
# if yes, set the homeworld focus to the preferred focus
print "Player", player_name, ": setting preferred focus", preferred_focus, "on homeworld"
fo.planet_set_focus(homeworld, preferred_focus)
elif len(available_foci) > 0:
# if no, and there is at least one available focus,
# just take the first of the list
if preferred_focus == "":
print "Player", player_name, ": starting species", starting_species, "has no preferred focus, using",\
available_foci[0], "instead"
else:
print "Player", player_name, ": preferred focus", preferred_focus, "for starting species",\
starting_species, "not available on homeworld, using", available_foci[0], "instead"
fo.planet_set_focus(homeworld, available_foci[0])
else:
# if no focus is available on the homeworld, don't set any focus
print "Player", player_name, ": no available foci on homeworld for starting species", starting_species
# give homeworld starting buildings
# use the list provided in scripting/starting_unlocks/buildings.inf
print "Player", player_name, ": add starting buildings to homeworld"
for building in load_string_list(os.path.join(fo.get_resource_dir(), "scripting/starting_unlocks/buildings.inf")):
fo.create_building(building, homeworld, empire)
# unlock starting techs, buildings, hulls, ship parts, etc.
# use default content file
print "Player", player_name, ": add unlocked items"
for item in fo.load_item_spec_list():
fo.empire_unlock_item(empire, item.type, item.name)
# add premade ship designs to empire
print "Player", player_name, ": add premade ship designs"
for ship_design in fo.design_get_premade_list():
fo.empire_add_ship_design(empire, ship_design)
# add starting fleets to empire
# use default content file
print "Player", player_name, ": add starting fleets"
fleet_plans = fo.load_fleet_plan_list()
for fleet_plan in fleet_plans:
# first, create the fleet
fleet = fo.create_fleet(fleet_plan.name(), home_system, empire)
# if the fleet couldn't be created, report an error and try to continue with the next fleet plan
if fleet == fo.invalid_object():
report_error("Python setup empire: couldn't create fleet %s" % fleet_plan.name())
continue
# second, iterate over the list of ship design names in the fleet plan
for ship_design in fleet_plan.ship_designs():
# create a ship in the fleet
# if the ship couldn't be created, report an error and try to continue with the next ship design
if fo.create_ship("", ship_design, starting_species, fleet) == fo.invalid_object():
report_error("Python setup empire: couldn't create ship %s for fleet %s"
% (ship_design, fleet_plan.name()))
return True
def compile_home_system_list(num_home_systems, systems, gsd):
"""
Compiles a list with a requested number of home systems.
"""
print "Compile home system list:", num_home_systems, "systems requested"
# if the list of systems to choose home systems from is empty, report an error and return empty list
if not systems:
report_error("Python generate_home_system_list: no systems to choose from")
return []
# calculate an initial minimal number of jumps that the home systems should be apart,
# based on the total number of systems to choose from and the requested number of home systems
# don't let min_jumps be either:
# a.) larger than a defined limit, because an unreasonably large number is really not at all needed,
# and with large galaxies an excessive amount of time can be used in failed attempts
# b.) lower than the minimum jump distance limit that should be considered high priority (see options.py),
# otherwise no attempt at all would be made to enforce the other requirements for home systems (see below)
min_jumps = min(HS_MAX_JUMP_DISTANCE_LIMIT, max(int(float(len(systems)) / float(num_home_systems * 2)),
HS_MIN_DISTANCE_PRIORITY_LIMIT))
# home systems must have a certain minimum of systems and planets in their near vicinity
# we will try to select our home systems from systems that match this criteria, if that fails, we will select our
# home systems from all systems and add the missing number planets to the systems in their vicinity afterwards
# the minimum system and planet limit and the jump range that defines the "near vicinity" are controlled by the
# HS_* option constants in options.py (see there)
# we start by building two additional pools of systems: one that contains all systems that match the criteria
# completely (meets the min systems and planets limit), and one that contains all systems that match the criteria
# at least partially (meets the min systems limit)
pool_matching_sys_and_planet_limit = []
pool_matching_sys_limit = []
for system in systems:
systems_in_vicinity = get_systems_within_jumps(system, HS_VICINITY_RANGE)
if len(systems_in_vicinity) >= HS_MIN_SYSTEMS_IN_VICINITY:
pool_matching_sys_limit.append(system)
if count_planets_in_systems(systems_in_vicinity) >= min_planets_in_vicinity_limit(len(systems_in_vicinity)):
pool_matching_sys_and_planet_limit.append(system)
print len(pool_matching_sys_and_planet_limit), "systems meet the min systems and planets in the near vicinity limit"
print len(pool_matching_sys_limit), "systems meet the min systems in the near vicinity limit"
# now try to pick the requested number of home systems
# we will do this by calling find_home_systems, which takes a list of tuples defining the pools from which to pick
# the home systems; it will use the pools in the order in which they appear in the list, so put better pools first
# we will make two attempts: the first one with the filtered pools we just created, and tell find_home_systems
# to start with the min_jumps jumps distance we calculated above, but not to go lower than
# HS_MIN_DISTANCE_PRIORITY_LIMIT
print "First attempt: trying to pick home systems from the filtered pools of preferred systems"
pool_list = [
# the better pool is of course the one where all systems meet BOTH the min systems and planets limit
(pool_matching_sys_and_planet_limit, "pool of systems that meet both the min systems and planets limit"),
# next the less preferred pool where all systems at least meets the min systems limit
# specify 0 as number of requested home systems to pick as much systems as possible
(pool_matching_sys_limit, "pool of systems that meet at least the min systems limit"),
]
home_systems = find_home_systems(num_home_systems, pool_list, min_jumps, HS_MIN_DISTANCE_PRIORITY_LIMIT)
# check if the first attempt delivered a list with enough home systems
# if not, we make our second attempt, this time disregarding the filtered pools and using all systems, starting
# again with the min_jumps jump distance limit and specifying 0 as number of required home systems to pick as much
# systems as possible
if len(home_systems) < num_home_systems:
print "Second attempt: trying to pick home systems from all systems"
home_systems = find_home_systems(num_home_systems, [(systems, "complete pool")], min_jumps, 1)
# check if the selection process delivered a list with enough home systems
# if not, our galaxy obviously is too crowded, report an error and return an empty list
if len(home_systems) < num_home_systems:
report_error("Python generate_home_system_list: requested %d homeworlds in a galaxy with %d systems"
% (num_home_systems, len(systems)))
return []
# check if we got more home systems than we requested
if len(home_systems) > num_home_systems:
# yes: calculate the number of planets in the near vicinity of each system
# and store that value with each system in a map
hs_planets_in_vicinity_map = {s: count_planets_in_systems(get_systems_within_jumps(s, HS_VICINITY_RANGE))
for s in home_systems}
# sort the home systems by the number of planets in their near vicinity using the map
# now only pick the number of home systems we need, taking those with the highest number of planets
home_systems = sorted(home_systems, key=hs_planets_in_vicinity_map.get, reverse=True)[:num_home_systems]
# make sure all our home systems have a "real" star (that is, a star that is not a neutron star, black hole,
# or even no star at all) and at least one planet in it
for home_system in home_systems:
# if this home system has no "real" star, change star type to a randomly selected "real" star
if fo.sys_get_star_type(home_system) not in star_types_real:
star_type = random.choice(star_types_real)
print "Home system", home_system, "has star type", fo.sys_get_star_type(home_system),\
", changing that to", star_type
fo.sys_set_star_type(home_system, star_type)
# if this home system has no planets, create one in a random orbit
# we take random values for type and size, as these will be set to suitable values later
if not fo.sys_get_planets(home_system):
print "Home system", home_system, "has no planets, adding one"
planet = fo.create_planet(random.choice(planet_sizes_real),
random.choice(planet_types_real),
home_system, random.randint(0, fo.sys_get_num_orbits(home_system) - 1), "")
# if we couldn't create the planet, report an error and return an empty list
if planet == fo.invalid_object():
report_error("Python generate_home_system_list: couldn't create planet in home system")
return []
# finally, check again if all home systems meet the criteria of having the required minimum number of planets
# within their near vicinity, if not, add the missing number of planets
print "Checking if home systems have the required minimum of planets within the near vicinity..."
for home_system in home_systems:
# calculate the number of missing planets, and add them if this number is > 0
systems_in_vicinity = get_systems_within_jumps(home_system, HS_VICINITY_RANGE)
num_systems_in_vicinity = len(systems_in_vicinity)
num_planets_in_vicinity = count_planets_in_systems(systems_in_vicinity)
num_planets_to_add = min_planets_in_vicinity_limit(num_systems_in_vicinity) - num_planets_in_vicinity
print "Home system", home_system, "has", num_systems_in_vicinity, "systems and", num_planets_in_vicinity,\
"planets in the near vicinity, required minimum:", min_planets_in_vicinity_limit(num_systems_in_vicinity)
if num_planets_to_add > 0:
systems_in_vicinity.remove(home_system) # don't add planets to the home system, so remove it from the list
add_planets_to_vicinity(systems_in_vicinity, num_planets_to_add, gsd)
# as we've sorted the home system list before, lets shuffle it to ensure random order and return
random.shuffle(home_systems)
return home_systems
def add_planets_to_vicinity(vicinity, num_planets, gsd):
"""
Adds the specified number of planets to the specified systems.
"""
print "Adding", num_planets, "planets to the following systems:", vicinity
# first, compile a list containing all the free orbits in the specified systems
# begin with adding the free orbits of all systems that have a real star (that is, no neutron star, black hole,
# and not no star), if that isn't enough, also one, by one, add the free orbits of neutron star, black hole and
# no star systems (in that order) until we have enough free orbits
# for that, we use this list of tuples
# the first tuple contains all real star types, the following tuples the neutron, black hole and no star types,
# so we can iterate over this list and only add the free orbits of systems that match the respective star types
# each step
# this way we can prioritize the systems we want to add planets to by star type
acceptable_star_types_list = [
star_types_real,
(fo.starType.noStar,),
(fo.starType.neutron,),
(fo.starType.blackHole,)
]
# store the free orbits as a list of tuples of (system, orbit)
free_orbits_map = []
# now, iterate over the list of acceptable star types
for acceptable_star_types in acceptable_star_types_list:
# check all systems in the list of systems we got passed into this function
for system in vicinity:
# if this system has a star type we want to accept in this step, add its free orbits to our list
if fo.sys_get_star_type(system) in acceptable_star_types:
free_orbits_map.extend([(system, orbit) for orbit in fo.sys_free_orbits(system)])
# check if we got enough free orbits after completing this step
# we want 4 times as much free orbits as planets we want to add, that means each system shouldn't get more
# than 2-3 additional planets on average
if len(free_orbits_map) > (num_planets * 4):
break
# if we got less free orbits than planets that should be added, something is wrong
# in that case abort and log an error
if len(free_orbits_map) < num_planets:
report_error("Python add_planets_to_vicinity: less free orbits than planets to add - cancelled")
print "...free orbits available:", free_orbits_map
# as we will pop the free orbits from this list afterwards, shuffle it to randomize the order of the orbits
random.shuffle(free_orbits_map)
# add the requested number of planets
while num_planets > 0:
# get the next free orbit from the list we just compiled
system, orbit = free_orbits_map.pop()
# check the star type of the system containing the orbit we got
star_type = fo.sys_get_star_type(system)
if star_type in [fo.starType.noStar, fo.starType.blackHole]:
# if it is a black hole or has no star, change the star type
# pick a star type, continue until we get a real star
# don't accept neutron, black hole or no star
print "...system picked to add a planet has star type", star_type
while star_type not in star_types_real:
star_type = pick_star_type(gsd.age)
print "...change that to", star_type
fo.sys_set_star_type(system, star_type)
# pick a planet size, continue until we get a size that matches the HS_ACCEPTABLE_PLANET_SIZES option
planet_size = fo.planetSize.unknown
while planet_size not in HS_ACCEPTABLE_PLANET_SIZES:
planet_size = calc_planet_size(star_type, orbit, fo.galaxySetupOption.high, gsd.shape)
# pick an according planet type
planet_type = calc_planet_type(star_type, orbit, planet_size)
# finally, create the planet in the system and orbit we got
print "...adding", planet_size, planet_type, "planet to system", system
if fo.create_planet(planet_size, planet_type, system, orbit, "") == fo.invalid_object():
report_error("Python add_planets_to_vicinity: create planet in system %d failed" % system)
# continue with next planet
num_planets -= 1
def execute_turn_events():
print "Executing turn events for turn", fo.current_turn()
# creating fields
systems = fo.get_systems()
radius = fo.get_universe_width() / 2.0
if random() < max(0.0003 * radius, 0.03):
if random() < 0.4:
field_type = "FLD_MOLECULAR_CLOUD"
size = 5.0
else:
field_type = "FLD_ION_STORM"
size = 5.0
x = y = radius
dist_from_center = 0.0
while (dist_from_center < radius) or any(
hypot(fo.get_x(s) - x,
fo.get_y(s) - y) < 50.0 for s in systems):
angle = random() * 2.0 * pi
dist_from_center = radius + uniform(
min(max(radius * 0.02, 10), 50.0),
min(max(radius * 0.05, 20), 100.0))
x = radius + (dist_from_center * sin(angle))
y = radius + (dist_from_center * cos(angle))
print "...creating new", field_type, "field, at distance", dist_from_center, "from center"
if fo.create_field(field_type, x, y, size) == fo.invalid_object():
print >> sys.stderr, "Turn events: couldn't create new field"
# creating monsters
gsd = fo.get_galaxy_setup_data()
monster_freq = MONSTER_FREQUENCY[gsd.monsterFrequency]
# monster freq ranges from 1/30 (= one monster per 30 systems) to 1/3 (= one monster per 3 systems)
# (example: low monsters and 150 Systems results in 150 / 30 * 0.01 = 0.05)
if monster_freq > 0 and random() < len(systems) * monster_freq * 0.01:
#only spawn Krill at the moment, other monsters can follow in the future
if random() < 1:
monster_type = "SM_KRILL_1"
else:
monster_type = "SM_FLOATER"
# search for systems without planets or fleets
candidates = [
s for s in systems if len(fo.sys_get_planets(s)) <= 0
and len(fo.sys_get_fleets(s)) <= 0
]
if not candidates:
print >> sys.stderr, "Turn events: unable to find system for monster spawn"
else:
system = choice(candidates)
print "...creating new", monster_type, "at", fo.get_name(system)
# create monster fleet
monster_fleet = fo.create_monster_fleet(system)
# if fleet creation fails, report an error
if monster_fleet == fo.invalid_object():
print >> sys.stderr, "Turn events: unable to create new monster fleet"
else:
# create monster, if creation fails, report an error
monster = fo.create_monster(monster_type, monster_fleet)
if monster == fo.invalid_object():
print >> sys.stderr, "Turn events: unable to create monster in fleet"
return True
def generate_monsters(monster_freq, systems):
"""
Adds space monsters to systems.
"""
# first, calculate the basic chance for monster generation in a system
# based on the monster frequency that has been passed
# get the corresponding value for the specified monster frequency from the universe tables
inverse_monster_chance = fo.monster_frequency(monster_freq)
# as the value in the universe table is higher for a lower frequency, we have to invert it
# exception: a value of 0 means no monsters, in this case return immediately
if inverse_monster_chance <= 0:
return
basic_chance = 1.0 / float(inverse_monster_chance)
print "Default monster spawn chance:", basic_chance
expectation_tally = 0.0
actual_tally = 0
# get all monster fleets that have a spawn rate and limit both > 0 and at least one monster ship design in it
# (a monster fleet with no monsters in it is pointless) and store them with a spawn counter in a dict
# this counter will be set to the spawn limit initially and decreased every time the monster fleet is spawned
fleet_plans = {
fp: fp.spawn_limit()
for fp in fo.load_monster_fleet_plan_list(
"space_monster_spawn_fleets.txt") if fp.spawn_rate() > 0.0
and fp.spawn_limit() > 0 and fp.ship_designs()
}
# map nests to monsters for ease of reporting
nest_name_map = dict(
zip([
"KRAKEN_NEST_SPECIAL", "SNOWFLAKE_NEST_SPECIAL",
"JUGGERNAUT_NEST_SPECIAL"
], ["SM_KRAKEN_1", "SM_SNOWFLAKE_1", "SM_JUGGERNAUT_1"]))
tracked_plan_tries = {name: 0 for name in nest_name_map.values()}
tracked_plan_counts = {name: 0 for name in nest_name_map.values()}
tracked_plan_valid_locations = {
fp: 0
for fp, limit in fleet_plans.iteritems()
if fp.name() in tracked_plan_counts
}
tracked_nest_valid_locations = {nest: 0 for nest in nest_name_map}
if not fleet_plans:
return
# dump a list of all monster fleets meeting these conditions and their properties to the log
print "Monster fleets available for generation at game start:"
for fleet_plan in fleet_plans:
print "...", fleet_plan.name(), ": spawn rate", fleet_plan.spawn_rate(
),
print "/ spawn limit", fleet_plan.spawn_limit(),
print "/ effective chance", basic_chance * fleet_plan.spawn_rate(),
if len(systems) < 1000:
print "/ can be spawned at", len(
[s for s in systems if fleet_plan.location(s)]), "systems"
else:
print # to terminate the print line
if fleet_plan.name() in nest_name_map.values():
statistics.tracked_monsters_chance[
fleet_plan.name()] = basic_chance * fleet_plan.spawn_rate()
# for each system in the list that has been passed to this function, find a monster fleet that can be spawned at
# the system and which hasn't already been added too many times, then attempt to add that monster fleet by
# testing the spawn rate chance
for system in systems:
# collect info for tracked monster nest valid locations
for planet in fo.sys_get_planets(system):
for nest in tracked_nest_valid_locations:
#print "\t tracked monster check planet: %d size: %s for nest: %20s | result: %s" % (planet, fo.planet_get_size(planet), nest, fo.special_location(nest, planet))
if fo.special_location(nest, planet):
tracked_nest_valid_locations[nest] += 1
# collect info for tracked monster valid locations
for fp in tracked_plan_valid_locations:
if fp.location(system):
tracked_plan_valid_locations[fp] += 1
# filter out all monster fleets whose location condition allows this system and whose counter hasn't reached 0
suitable_fleet_plans = [
fp for fp, counter in fleet_plans.iteritems()
if counter and fp.location(system)
]
# if there are no suitable monster fleets for this system, continue with the next
if not suitable_fleet_plans:
continue
# randomly select one monster fleet out of the suitable ones and then test if we want to add it to this system
# by making a roll against the basic chance multiplied by the spawn rate of this monster fleet
expectation_tally += basic_chance * sum(
[fp.spawn_rate()
for fp in suitable_fleet_plans]) / len(suitable_fleet_plans)
fleet_plan = random.choice(suitable_fleet_plans)
if fleet_plan.name() in tracked_plan_tries:
tracked_plan_tries[fleet_plan.name()] += 1
if random.random() > basic_chance * fleet_plan.spawn_rate():
print "\t\t At system %4d rejected monster fleet %s from %d suitable fleets" % (
system, fleet_plan.name(), len(suitable_fleet_plans))
# no, test failed, continue with the next system
continue
actual_tally += 1
if fleet_plan.name() in tracked_plan_counts:
tracked_plan_counts[fleet_plan.name()] += 1
# all prerequisites and the test have been met, now spawn this monster fleet in this system
print "Spawn", fleet_plan.name(), "at", fo.get_name(system)
# decrement counter for this monster fleet
fleet_plans[fleet_plan] -= 1
# create monster fleet
monster_fleet = fo.create_monster_fleet(system)
# if fleet creation fails, report an error and try to continue with next system
if monster_fleet == fo.invalid_object():
util.report_error(
"Python generate_monsters: unable to create new monster fleet %s"
% fleet_plan.name())
continue
# add monsters to fleet
for design in fleet_plan.ship_designs():
# create monster, if creation fails, report an error and try to continue with the next design
if fo.create_monster(design, monster_fleet) == fo.invalid_object():
util.report_error(
"Python generate_monsters: unable to create monster %s" %
design)
print "Actual # monster fleets placed: %d; Total Placement Expectation: %.1f" % (
actual_tally, expectation_tally)
# finally, compile some statistics to be dumped to the log later
statistics.monsters_summary = [(fp.name(), fp.spawn_limit() - counter)
for fp, counter in fleet_plans.iteritems()]
statistics.tracked_monsters_tries.update(tracked_plan_tries)
statistics.tracked_monsters_summary.update(tracked_plan_counts)
statistics.tracked_monsters_location_summary.update([
(fp.name(), count)
for fp, count in tracked_plan_valid_locations.iteritems()
])
statistics.tracked_nest_location_summary.update([
(nest_name_map[nest], count)
for nest, count in tracked_nest_valid_locations.items()
])
def compile_home_system_list(num_home_systems, systems):
"""
Compiles a list with a requested number of home systems.
"""
# if the list of systems to choose home systems from is empty, report an error and return empty list
if not systems:
util.report_error(
"Python generate_home_system_list: no systems to choose from")
return []
# calculate an initial minimal number of jumps that the home systems should be apart,
# based on the total number of systems to choose from and the requested number of home systems
min_jumps = max(int(float(len(systems)) / float(num_home_systems * 2)), 5)
# try to find the home systems, decrease the min jumps until enough systems can be found, or the min jump distance
# gets reduced to 0 (meaning we don't have enough systems to choose from at all)
while min_jumps > 0:
print "Trying to find", num_home_systems, "home systems that are at least", min_jumps, "jumps apart"
# try to find home systems...
home_systems = find_systems_with_min_jumps_between(
num_home_systems, systems, min_jumps)
# ...check if we got enough...
if len(home_systems) >= num_home_systems:
# ...yes, we got what we need, so let's break out of the loop
break
print "Home system min jump conflict: %d systems and %d empires, tried %d min jump and failed"\
% (len(systems), num_home_systems, min_jumps)
# ...no, decrease the min jump distance and try again
min_jumps -= 1
# check if the loop above delivered a list with enough home systems, or if it exited because the min jump distance
# has been decreased to 0 without finding enough systems
# in that case, our galaxy obviously is too crowded, report an error and return an empty list
if len(home_systems) < num_home_systems:
util.report_error(
"Python generate_home_system_list: requested %d homeworlds in a galaxy with %d systems"
% (num_home_systems, len(systems)))
return []
# make sure all our home systems have a "real" star (that is, a star that is not a neutron star, black hole,
# or even no star at all) and at least one planet in it
for home_system in home_systems:
# if this home system has no "real" star, change star type to a randomly selected "real" star
if fo.sys_get_star_type(
home_system) not in starsystems.star_types_real:
star_type = random.choice(starsystems.star_types_real)
print "Home system", home_system, "has star type", fo.sys_get_star_type(home_system),\
", changing that to", star_type
fo.sys_set_star_type(home_system, star_type)
# if this home system has no planets, create one in a random orbit
# we take random values for type and size, as these will be set to suitable values later
if not fo.sys_get_planets(home_system):
print "Home system", home_system, "has no planets, adding one"
planet = fo.create_planet(
random.choice(planets.planet_sizes_real),
random.choice(planets.planet_types_real), home_system,
random.randint(0,
fo.sys_get_num_orbits(home_system) - 1), "")
# if we couldn't create the planet, report an error and return an empty list
if planet == fo.invalid_object():
util.report_error(
"Python generate_home_system_list: couldn't create planet in home system"
)
return []
return home_systems
def generate_monsters(monster_freq, systems):
"""
Adds space monsters to systems.
"""
# first, calculate the basic chance for monster generation in a system
# based on the monster frequency that has been passed
# get the corresponding value for the specified monster frequency from the universe tables
basic_chance = universe_tables.MONSTER_FREQUENCY[monster_freq]
# a value of 0 means no monsters, in this case return immediately
if basic_chance <= 0:
return
print "Default monster spawn chance:", basic_chance
expectation_tally = 0.0
actual_tally = 0
# get all monster fleets that have a spawn rate and limit both > 0 and at least one monster ship design in it
# (a monster fleet with no monsters in it is pointless) and store them in a list
fleet_plans = fo.load_monster_fleet_plan_list()
# create a map where we store a spawn counter for each monster fleet
# this counter will be set to the spawn limit initially and decreased every time the monster fleet is spawned
# this map (dict) needs to be separate from the list holding the fleet plans because the order in which items
# are stored in a dict is undefined (can be different each time), which would result in different distribution
# even when using the same seed for the RNG
spawn_limits = {fp: fp.spawn_limit() for fp in fleet_plans
if fp.spawn_rate() > 0.0 and fp.spawn_limit() > 0 and fp.ship_designs()}
# map nests to monsters for ease of reporting
nest_name_map = dict(zip(["KRAKEN_NEST_SPECIAL", "SNOWFLAKE_NEST_SPECIAL", "JUGGERNAUT_NEST_SPECIAL"], ["SM_KRAKEN_1", "SM_SNOWFLAKE_1", "SM_JUGGERNAUT_1"]))
tracked_plan_tries = {name: 0 for name in nest_name_map.values()}
tracked_plan_counts = {name: 0 for name in nest_name_map.values()}
tracked_plan_valid_locations = {fp: 0 for fp in fleet_plans if fp.name() in tracked_plan_counts}
tracked_nest_valid_locations = {nest: 0 for nest in nest_name_map}
if not fleet_plans:
return
# dump a list of all monster fleets meeting these conditions and their properties to the log
print "Monster fleets available for generation at game start:"
for fleet_plan in fleet_plans:
print "...", fleet_plan.name(), ": spawn rate", fleet_plan.spawn_rate(),
print "/ spawn limit", fleet_plan.spawn_limit(),
print "/ effective chance", basic_chance * fleet_plan.spawn_rate(),
if len(systems) < 1000:
print "/ can be spawned at", len([s for s in systems if fleet_plan.location(s)]), "systems"
else:
print # to terminate the print line
if fleet_plan.name() in nest_name_map.values():
statistics.tracked_monsters_chance[fleet_plan.name()] = basic_chance * fleet_plan.spawn_rate()
# for each system in the list that has been passed to this function, find a monster fleet that can be spawned at
# the system and which hasn't already been added too many times, then attempt to add that monster fleet by
# testing the spawn rate chance
for system in systems:
# collect info for tracked monster nest valid locations
for planet in fo.sys_get_planets(system):
for nest in tracked_nest_valid_locations:
#print "\t tracked monster check planet: %d size: %s for nest: %20s | result: %s" % (planet, fo.planet_get_size(planet), nest, fo.special_location(nest, planet))
if fo.special_location(nest, planet):
tracked_nest_valid_locations[nest] += 1
# collect info for tracked monster valid locations
for fp in tracked_plan_valid_locations:
if fp.location(system):
tracked_plan_valid_locations[fp] += 1
# filter out all monster fleets whose location condition allows this system and whose counter hasn't reached 0
suitable_fleet_plans = [fp for fp in fleet_plans if spawn_limits[fp] and fp.location(system)]
# if there are no suitable monster fleets for this system, continue with the next
if not suitable_fleet_plans:
continue
# randomly select one monster fleet out of the suitable ones and then test if we want to add it to this system
# by making a roll against the basic chance multiplied by the spawn rate of this monster fleet
expectation_tally += basic_chance * sum([fp.spawn_rate() for fp in suitable_fleet_plans]) / len(suitable_fleet_plans)
fleet_plan = random.choice(suitable_fleet_plans)
if fleet_plan.name() in tracked_plan_tries:
tracked_plan_tries[fleet_plan.name()] += 1
if random.random() > basic_chance * fleet_plan.spawn_rate():
print "\t\t At system %4d rejected monster fleet %s from %d suitable fleets" % (system, fleet_plan.name(), len(suitable_fleet_plans))
# no, test failed, continue with the next system
continue
actual_tally += 1
if fleet_plan.name() in tracked_plan_counts:
tracked_plan_counts[fleet_plan.name()] += 1
# all prerequisites and the test have been met, now spawn this monster fleet in this system
print "Spawn", fleet_plan.name(), "at", fo.get_name(system)
# decrement counter for this monster fleet
spawn_limits[fleet_plan] -= 1
# create monster fleet
monster_fleet = fo.create_monster_fleet(system)
# if fleet creation fails, report an error and try to continue with next system
if monster_fleet == fo.invalid_object():
util.report_error("Python generate_monsters: unable to create new monster fleet %s" % fleet_plan.name())
continue
# add monsters to fleet
for design in fleet_plan.ship_designs():
# create monster, if creation fails, report an error and try to continue with the next design
if fo.create_monster(design, monster_fleet) == fo.invalid_object():
util.report_error("Python generate_monsters: unable to create monster %s" % design)
print "Actual # monster fleets placed: %d; Total Placement Expectation: %.1f" % (actual_tally, expectation_tally)
# finally, compile some statistics to be dumped to the log later
statistics.monsters_summary = [(fp.name(), fp.spawn_limit() - counter) for fp, counter in spawn_limits.iteritems()]
statistics.tracked_monsters_tries.update(tracked_plan_tries)
statistics.tracked_monsters_summary.update(tracked_plan_counts)
statistics.tracked_monsters_location_summary.update([(fp.name(), count) for fp, count in tracked_plan_valid_locations.iteritems()])
statistics.tracked_nest_location_summary.update([(nest_name_map[nest], count) for nest, count in tracked_nest_valid_locations.items()])
def execute_turn_events():
print("Executing turn events for turn", fo.current_turn())
# creating fields
systems = fo.get_systems()
radius = fo.get_universe_width() / 2.0
field_types = [
"FLD_MOLECULAR_CLOUD", "FLD_ION_STORM", "FLD_NANITE_SWARM",
"FLD_METEOR_BLIZZARD", "FLD_VOID_RIFT"
]
if random() < max(0.00015 * radius, 0.03):
field_type = choice(field_types)
size = 5.0
x = y = radius
dist_from_center = uniform(0.35, 1.0) * radius
angle = random() * 2.0 * pi
x = radius + (dist_from_center * sin(angle))
y = radius + (dist_from_center * cos(angle))
print("...creating new", field_type, "field, at distance",
dist_from_center, "from center")
if fo.create_field(field_type, x, y, size) == fo.invalid_object():
print("Turn events: couldn't create new field", file=sys.stderr)
# creating monsters
gsd = fo.get_galaxy_setup_data()
monster_freq = MONSTER_FREQUENCY[gsd.monsterFrequency]
# monster freq ranges from 1/30 (= one monster per 30 systems) to 1/3 (= one monster per 3 systems)
# (example: low monsters and 150 Systems results in 150 / 30 * 0.01 = 0.05)
if monster_freq > 0 and random() < len(systems) * monster_freq * 0.01:
# only spawn Krill at the moment, other monsters can follow in the future
if random() < 1:
monster_type = "SM_KRILL_1"
else:
monster_type = "SM_FLOATER"
# search for systems without planets or fleets
candidates = [
s for s in systems if len(fo.sys_get_planets(s)) <= 0
and len(fo.sys_get_fleets(s)) <= 0
]
if not candidates:
print("Turn events: unable to find system for monster spawn",
file=sys.stderr)
else:
system = choice(candidates)
print("...creating new", monster_type, "at", fo.get_name(system))
# create monster fleet
monster_fleet = fo.create_monster_fleet(system)
# if fleet creation fails, report an error
if monster_fleet == fo.invalid_object():
print("Turn events: unable to create new monster fleet",
file=sys.stderr)
else:
# create monster, if creation fails, report an error
monster = fo.create_monster(monster_type, monster_fleet)
if monster == fo.invalid_object():
print("Turn events: unable to create monster in fleet",
file=sys.stderr)
return True
def compile_home_system_list(num_home_systems, systems):
"""
Compiles a list with a requested number of home systems.
"""
print "Compile home system list:", num_home_systems, "systems requested"
# if the list of systems to choose home systems from is empty, report an error and return empty list
if not systems:
report_error(
"Python generate_home_system_list: no systems to choose from")
return []
# calculate an initial minimal number of jumps that the home systems should be apart,
# based on the total number of systems to choose from and the requested number of home systems
# Don't let min_jumps be larger than 10, because a larger number is really not at all needed and with large
# galaxies an excessive amount of time can be used in failed attempts
min_jumps = min(
10, max(int(float(len(systems)) / float(num_home_systems * 2)), 5))
# home systems must have a certain minimum of systems in their near vicinity
# we will try to select our home systems from systems that match this criteria, if that fails, we will select our
# home systems from all systems and add the missing number planets to the systems in their vicinity afterwards
# the minimum planet limit and the jump range that defines the "near vicinity" are controlled by the
# HS_* option constants in options.py (see there)
# lets start by filtering out all systems from the pool we got passed into this function that match the criteria
filtered_pool = [s for s in systems if has_min_planets_in_vicinity(s)]
print "Filtering out systems that meet the minimum planets in the near vicinity condition yielded",\
len(filtered_pool), "systems"
print "Using this as the preferred pool for home system selection"
# now try to pick the requested number of home systems by calling find_home_systems
# this function takes two pools, a "complete" pool and one with preferred systems
# it will try to pick the home systems from the preferred pool first, so pass our filtered pool as preferred pool
home_systems = find_home_systems(num_home_systems, systems, filtered_pool,
min_jumps)
# check if the selection process delivered a list with enough home systems
# if not, our galaxy obviously is too crowded, report an error and return an empty list
if len(home_systems) < num_home_systems:
report_error(
"Python generate_home_system_list: requested %d homeworlds in a galaxy with %d systems"
% (num_home_systems, len(systems)))
return []
# check if we got more home systems than we requested
if len(home_systems) > num_home_systems:
# yes: calculate the number of planets in the near vicinity of each system
# and store that value with each system in a map
hs_planets_in_vicinity_map = {
s: count_planets_in_systems(
get_systems_within_jumps(s, HS_VICINITY_RANGE))
for s in home_systems
}
# sort the home systems by the number of planets in their near vicinity using the map
# now only pick the number of home systems we need, taking those with the highest number of planets
home_systems = sorted(home_systems,
key=hs_planets_in_vicinity_map.get,
reverse=True)[:num_home_systems]
# make sure all our home systems have a "real" star (that is, a star that is not a neutron star, black hole,
# or even no star at all) and at least one planet in it
for home_system in home_systems:
# if this home system has no "real" star, change star type to a randomly selected "real" star
if fo.sys_get_star_type(home_system) not in star_types_real:
star_type = random.choice(star_types_real)
print "Home system", home_system, "has star type", fo.sys_get_star_type(home_system),\
", changing that to", star_type
fo.sys_set_star_type(home_system, star_type)
# if this home system has no planets, create one in a random orbit
# we take random values for type and size, as these will be set to suitable values later
if not fo.sys_get_planets(home_system):
print "Home system", home_system, "has no planets, adding one"
planet = fo.create_planet(
random.choice(planet_sizes_real),
random.choice(planet_types_real), home_system,
random.randint(0,
fo.sys_get_num_orbits(home_system) - 1), "")
# if we couldn't create the planet, report an error and return an empty list
if planet == fo.invalid_object():
report_error(
"Python generate_home_system_list: couldn't create planet in home system"
)
return []
# finally, check again if all home systems meet the criteria of having the required minimum number of planets
# within their near vicinity, if not, add the missing number of planets
print "Checking if home systems have the required minimum of planets within the near vicinity..."
for home_system in home_systems:
# calculate the number of missing planets, and add them if this number is > 0
systems_in_vicinity = get_systems_within_jumps(home_system,
HS_VICINITY_RANGE)
num_systems_in_vicinity = len(systems_in_vicinity)
num_planets_in_vicinity = count_planets_in_systems(systems_in_vicinity)
num_planets_to_add = min_planets_in_vicinity_limit(
num_systems_in_vicinity) - num_planets_in_vicinity
print "Home system", home_system, "has", num_systems_in_vicinity, "systems and", num_planets_in_vicinity,\
"planets in the near vicinity, required minimum:", min_planets_in_vicinity_limit(num_systems_in_vicinity)
if num_planets_to_add > 0:
systems_in_vicinity.remove(
home_system
) # don't add planets to the home system, so remove it from the list
add_planets_to_vicinity(systems_in_vicinity, num_planets_to_add)
# as we've sorted the home system list before, lets shuffle it to ensure random order and return
random.shuffle(home_systems)
return home_systems
