def galaxy_from_dict(data, game):
"""
Creates the `Galaxy` for `game` from the `dict` `data`.
Args:
data (list):
The list of `System` dictionaries.
game (Game):
The `Game` that the `Galaxy` is used for.
Returns:
The `Galaxy` that was parsed from the given `dict` and `Game`.
"""
systems = []
for system_dict in data:
system = system_lib.system_from_dict(system_dict, game)
systems.append(system)
# Create the galaxy and return it.
galaxy = Galaxy(game)
galaxy.systems = systems
return galaxy
def __init__(self, game, generate=False):
"""
Not only is this the constructor for the `Galaxy` class, this also will
generate a random `Galaxy` if and only if the correct and precise
keyword arguments are passed in (hint: to generate a `Galaxy`, set
`generate` to `True`).
Args:
game (Game):
The `Game` which this `Galaxy` will be used for.
Keyword Args:
generate (boolean):
Set to `True` if this `Galaxy` is to be generated at random.
Note:
It is the responsibility of the caller of this constructor to save
this galaxy to disk.
"""
# Assign attributes.
self.game = game
# Escape gase.
if not generate:
return
# Declare global variables.
global GALAXY_START_JSON
global GALAXY_DEFAULT_RANGE
global GALAXY_LENGTH
global GALAXY_WIDTH
global GALAXY_HEIGHT
global STARS_PER_CUBIC_LY
# Open the JSON
import os
current_directory = os.path.dirname(__file__)
json_f = open(current_directory+GALAXY_START_JSON)
json_contents = json_f.read()
data = json.loads(json_contents)
json_f.close()
# Append default systems.
for system in data:
# Parse the system dict and assign the system object a unique ID.
self._system_unique_counter += 1
system_obj = system_lib.system_from_dict(system, game)
system_obj.unique = self._system_unique_counter
system_obj.galaxy = self
# Assign the planets of this system unique identifiers
system_planets = system_obj.flat_planets()
for planet in system_planets:
self._planet_unique_counter += 1
planet.unique = self._planet_unique_counter
self.systems.append(system_obj)
# The dimensions of the galaxy.
adj_dim = lambda x: (x - 1) / 2
abs_sum = lambda x, y, z: abs(x) + abs(y) + abs(z)
width = irange(-adj_dim(GALAXY_WIDTH), adj_dim(GALAXY_WIDTH))
length = irange(-adj_dim(GALAXY_LENGTH), adj_dim(GALAXY_LENGTH))
height = irange(-adj_dim(GALAXY_HEIGHT), adj_dim(GALAXY_HEIGHT))
positions = [(x, y, z) for x in width for y in length for z in height]
gdr = GALAXY_DEFAULT_RANGE
in_default_range = lambda x, y, z: (abs_sum(x, y, z) <= gdr)
in_discover_range = lambda x, y, z: (abs_sum(x, y, z) <= gdr + 4)
# Loop through the galatic grid. For the positions outside the range of
# default systems, randomly create new ones.
generated = 0
for (x, y, z) in positions:
if in_default_range(x, y, z):
continue
elif coinflip(STARS_PER_CUBIC_LY):
generated += 1
self._system_unique_counter += 1
new_sys = self._create_system(x, y, z)
new_sys.unique = self._system_unique_counter
if in_discover_range(x, y, z):
new_sys.discovered_by = set(game.players)
# Assign the new planets unique identifiers.
new_sys_planets = new_sys.flat_planets()
for planet in new_sys_planets:
self._planet_unique_counter += 1
planet.unique = self._planet_unique_counter
self.systems.append(new_sys)
# Save to disk
print "Generated {0} systems".format(str(generated))
