def __init__(self, name=None, orbit_distance=None, min_size=0.0,
max_size=0.0):
"""
This is the constructor for the `Planet` class. Since `Planet` is an
abstract class, this constructor should never be called unless called
by one of `Planet`'s three subclasses.
Keyword Args:
name (str):
The name of the planet we're creating.
orbit_distance (float):
min_size (float);
max_size (float):
"""
# Preconditions.
assert min_size != 0.0
assert max_size != 0.0
assert min_size < max_size
# Assign name.
if name is not None:
self.name = name
else:
self.name = ""
# Assign size.
self.size = rand_float_range(min_size, max_size)
# If we are given an orbit distance, then calculate an orbital period
if orbit_distance is not None:
self.orbit_distance = orbit_distance
self.orbit_period = orbit_distance * rand_float_range(0.5, 1.5)
else:
self.orbit_distance = -1
self.orbit_period = -1
def __init__(self, name, star_spectral_class=None, generate_planets=False):
"""
Args:
name (str):
The name of this system.
Postconditions:
If a `star_spectral_class` was given, then a `star_size` will also
be calculated.
"""
self.name = name
if star_spectral_class is not None:
self.star_spectral_class = star_spectral_class
# TODO set size
self.star_size = rand_float_range(0.5, 3.0)
def generate_system(name, scheme):
"""
Args:
name (str):
What we want to name this `System`.
scheme (int):
A system naming scheme code defined at the top of this module. Use
`SYSTEM_SCHEME_SYLLABLES` to generate new names for planets. Use
`SYSTEM_SCHEME_STAR` to name planets after `name` (for example,
"Ceti Alpha V" and "Ceti Alpha VI").
Returns:
A `System` generated at random.
Notes:
The `position` attribute of the returned `System` will not be set.
"""
# Declare global variables.
global SYSTEM_MAX_PLANETS
global SYSTEM_MIN_PLANETS
# How many planets does this system have?
num_planets = random.randint(SYSTEM_MIN_PLANETS, SYSTEM_MAX_PLANETS)
# Generate a random spectral class.
star_spectral_class = _random_spectral_class()
# Now calculate the maximum and minimum distances planets can be between.
min_orbit_dist = 0.1
max_orbit_dist = 30.0 # TODO
# Calculate the orbiting distances between the planets.
orbit_distances = []
for a in xrange(0, num_planets):
distance = rand_float_range(min_orbit_dist, max_orbit_dist)
orbit_distances.append(distance)
orbit_distances.sort()
# This is the probability of a planet being rocky as a function of its
# orbital distance from its star.
chance_rocky = lambda d: 0.5 # TODO
# This is the probability of a planet being habitable GIVEN that it is
# rocky as a function of its orbital distance.
chance_habitable = lambda d: 0.25 # TODO
# Begin creating the planets
planets = []
a = 1 # used for iteration
for distance in orbit_distances:
planet_type = None
# Case: Rocky or habitable planet
if coinflip(chance_rocky(distance)):
planet_type = planet_lib.RockyPlanet
if coinflip(chance_habitable(distance)):
planet_type = planet_lib.HabitablePlanet
else:
planet_type = planet_lib.GasPlanet
planet = planet_type(orbit_distance=distance)
# TODO setup planet
planet.name = _planet_name(name, scheme, a)
planets.append(planet)
a += 1
# Setup the system that we will return
system = System(name, star_spectral_class=star_spectral_class)
return system
