def flat_height(size):
# Check arguments
exception.arg_check(size, float)
# Get width
width = flat_width(size)
# Calculate height
return (math.sqrt(3.) / 2. * width)
def __init__(self,
name,
majorRow = None,
majorCol = None,
rows = None,
cols = None):
# General information
self.name = exception.arg_check(name, str, 'Default Name')
self.majorRow = exception.arg_check(majorRow, int, SECTOR_MAJOR_ROW)
self.majorCol = exception.arg_check(majorCol, int, SECTOR_MAJOR_COL)
self._rows = exception.arg_check(rows, int, SECTOR_ROWS)
self._cols = exception.arg_check(cols, int, SECTOR_COLS)
# Roll information
self.corporations = list()
self.heresies = list()
self.parties = list()
self.religions = list()
# Custom information
self.hexes = dict()
for sRow in range(self._rows):
for sCol in range(self._cols):
# Add empty hex info for each row/col
self.hexes[(sRow,sCol)] = hexinfo.Hex()
self.routes = list()
# Images
self.images = image.SectorImage(self.name,
self.majorRow,
self.majorCol,
self._rows,
self._cols)
def __init__(self, objectType=None, worldObj=None):
# Initialize base class
BaseOrbitalObject.__init__(
self,
objectType=exception.arg_check(
objectType, str, TABLE_ORBITAL_OBJECT_TYPE['SMALL_MOON']),
worldObj=exception.arg_check(worldObj, world.World, None))
def flat_vertex(size, vertex):
# Check arguments
exception.arg_check(vertex, int)
# Vertex angle
deg = 60. * vertex
rad = (math.pi / 180.) * deg
# Pixel position
return (size * math.cos(rad), size * math.sin(rad))
def __init__(self, title=None, border=None):
# Map title
self.title = exception.arg_check(title, str, '')
# Map border
self.border = exception.arg_check(border, str, MAP_BORDER)
# Map padding
self.mapPadding = 1
# Orbit padding
self.orbitPadding = 2
# Map orbits
self.orbits = list()
def set_rgba(self, r, g, b, a=None):
# Check arguments
r = exception.arg_check(r, int)
g = exception.arg_check(g, int)
b = exception.arg_check(b, int)
a = exception.arg_check(a, int, 255)
# Check r,g,b,a ranges
self._r = exception.arg_range_check(r, 0, 255)
self._g = exception.arg_range_check(g, 0, 255)
self._b = exception.arg_range_check(b, 0, 255)
self._a = exception.arg_range_check(a, 0, 255)
def __init__(self,
name = None,
stars = None,
objects = None,
worlds = None):
# Check arguments
self.name = exception.arg_check(name,str,'')
self.stars = exception.arg_check(stars,list,list())
self.objects = exception.arg_check(objects,list,list())
for o in objects:
if not (isinstance(o,orbitalobject.BaseObject)):
raise exception.InvalidListItemType(o,orbitalobject.BaseObject)
self.worlds = exception.arg_check(worlds,list,list())
def __init__(self,
name='',
atmosphere='',
biosphere='',
population='',
populationAlt=0,
tags=['', ''],
temperature='',
techLevel='0'):
# General information
self.name = exception.arg_check(name, str, '')
# Roll information
self.atmosphere = exception.arg_check(atmosphere, str, '')
self.biosphere = exception.arg_check(biosphere, str, '')
self.population = exception.arg_check(population, str, '')
self.tags = exception.arg_check(tags, list, ['', ''])
for tag in tags:
if not (isinstance(tag, str)):
raise exception.InvalidListItemType(tag, str)
self.temperature = exception.arg_check(temperature, str, '')
self.techLevel = exception.arg_check(techLevel, str, '0')
# Alternate roll information
self.populationAlt = exception.arg_check(populationAlt, int, 0)
def update_hex_image(self, hRow, hCol):
# Check arguments
hRow = exception.arg_check(hRow,int)
hCol = exception.arg_check(hCol,int)
# Get system data
systemData = self.hexes[(hRow,hCol)].system
# Get hex image.
hexImage = self.images.hexMap.hexInfo[(hRow,hCol)]
# Reset hex image.
hexImage.reset()
# Add system to hex image
hexImage.add_system(systemData.name)
# Add worlds to hex image
for w in systemData.sorted_worlds():
hexImage.add_world(text=w.techLevel)
def __init__(self, title=None, border=None, colSep=None, rowSep=None):
# Table title
self.title = exception.arg_check(title, str, '')
# Table border character
self.border = exception.arg_check(border, str, TABLE_BORDER)
# Table column separator character
self.colSep = exception.arg_check(colSep, str, TABLE_COL_SEP)
# Table row separator character
self.rowSep = exception.arg_check(rowSep, str, TABLE_ROW_SEP)
# Column Headings
self.headings = list()
# Column justification
self.justify = list()
# Data rows
self.rows = list()
def __init__(self,
objectType=None,
stations=None,
moons=None,
rings=None,
worldObj=None):
# Check arguments
self.stations = exception.arg_check(stations, list, list())
self.moons = exception.arg_check(moons, list, list())
self.rings = exception.arg_check(rings, bool, False)
# Initialize base class
BaseOrbitalObject.__init__(
self,
objectType=exception.arg_check(objectType, str,
TABLE_ORBITAL_OBJECT_TYPE['ROCKY']),
worldObj=exception.arg_check(worldObj, world.World, None))
def set_seed(self, seedString):
# Check arguments
# name
seedString = exception.arg_check(seedString, str)
# Set seed
random.set_seed(random.seed_alphabet_decode(seedString))
self.seed = seedString
def add_row(self, row=None):
# Check that row is a list
row = exception.arg_check(row, list, list())
# Add empty data if row data does not have enough columns
row += ['' for diff in xrange(len(self.headings) - len(row))]
# Add to rows list
self.rows.append(row)
def rgba(self, a=None):
# Check argument types
a = exception.arg_check(a, int, self._a)
# Check argument ranges
a = exception.arg_range_check(a, 0, 255)
# Return rgba
return (self._r, self._g, self._b, a)
def __init__(self, objectType=None):
# Initialize base class
BaseOrbitalObject.__init__(
self,
objectType=exception.arg_check(
objectType, str,
TABLE_ORBITAL_OBJECT_TYPE['ROCKY_ASTEROID_BELT']))
def __init__(self,
color=None,
colorText=None,
classification=None,
spectralSubclass=None,
spectralSubclassMod=None,
luminosity=None):
# Check arguments.
self.color = exception.arg_check(color, str, '')
self.colorText = exception.arg_check(colorText, str, '')
self.classification = exception.arg_check(classification, str, '')
self.spectralSubclass = exception.arg_check(spectralSubclass, int, 0)
self.luminosity = exception.arg_check(luminosity, str, 'V')
exception.arg_check(spectralSubclassMod, float, 0)
# Calculate other star data equation.
# y is value from table
# x is modified subclass in range [0,1]
# y = Ax + B
# y = ((y1-y0)/(x1-x0))*x + B
MASS_A = TABLE_MASS_MAP[classification][1] - TABLE_MASS_MAP[
classification][0]
MASS_B = TABLE_MASS_MAP[classification][0] # Because x0 is 0
RADIUS_A = TABLE_RADIUS_MAP[classification][1] - TABLE_RADIUS_MAP[
classification][0]
RADIUS_B = TABLE_RADIUS_MAP[classification][0] # Because x0 is 0
# Calculate values.
self.solarMass = MASS_A * spectralSubclassMod + MASS_B
self.solarRadius = RADIUS_A * spectralSubclassMod + RADIUS_B
def add_heading(self, heading=None, justify=None):
# If argument is a single value make it a list with one entry
if (type(heading) is not list):
heading = [heading]
# Add each heading in list
for h in heading:
# Add heading
self.headings.append(exception.arg_check(h, str, ''))
# Set column justification
j = exception.arg_check(justify, str, 'L')
if ((j != JUSTIFY_LEFT.lower()) or (j != JUSTIFY_CENTER.lower())
or (j != JUSTIFY_RIGHT.lower()) or (j != JUSTIFY_LEFT)
or (j != JUSTIFY_CENTER) or (j != JUSTIFY_RIGHT)):
self.justify.append(j.upper())
else:
# TODO, raise unknown justification error
self.justify.append(JUSTIFY_LEFT)
# Append empty data to end of rows if they exist already
for r in self.rows:
r.append('')
def print_sector_map(self,
coords = None):
# Process arguments
coords = exception.arg_check(coords,bool,False)
# Create hexmap
hexMap = text.HexMap(title = self.name + ' - ' + 'Sector Map',
size = text.SMALL_MAP,
rows = SECTOR_ROWS,
cols = SECTOR_COLS,
coords = coords)
# Add systems to map
sIndex = 1
for systemKey in self.sorted_systems():
(row,col) = systemKey
hexMap.add_label(str(sIndex),row,col)
sIndex += 1
# Print hexmap
hexMap.print_text()
def add_label(self, label, row, col):
# Check arguments
exception.arg_check(label, str)
exception.arg_check(row, int)
exception.arg_check(col, int)
# Array character row offset to start this hex from
cRowOffset = row * (self.hexHeight - 1)
# Offset more for odd columns
if (col % 2 != 0):
cRowOffset += (self.hexHeight - 1) / 2
# Array character column offset
cColOffset = col * int(math.ceil(self.hexWidth * 3.0 / 4.0))
# Offset to center of hex
cRowOffset += self.hexLabel[0]
cColOffset += self.hexLabel[1]
# Print
for i in xrange(len(label)):
self.hexMap[cRowOffset][cColOffset + i] = label[i]
def add_orbit(self, bodies=None, satellites=None):
# Check arguments
bodies = exception.arg_check(bodies, list, list())
satellites = exception.arg_check(satellites, list, list())
for b in bodies:
exception.arg_check(b, str)
for s in satellites:
exception.arg_check(s, str)
# Create list for orbit
orbit = list()
# Add bodies to orbit
for b in bodies:
orbit.append(b)
# Add satellites to orbit
for s in satellites:
orbit.append(ORBIT_SATELLITE_SYMBOL + s)
# Add orbit to map list
self.orbits.append(orbit)
def odd_q_center(size, row, col):
# Check arguments
exception.arg_check(size, float)
exception.arg_check(row, int)
exception.arg_check(col, int)
# Hex size
width = flat_width(size)
height = flat_height(size)
# Center
cX = width * ((1. / 2.) + (3. / 4.) * float(col))
# Center position Y
# Even columns
if (col % 2 == 0):
cY = height * ((1. / 2.) + float(row))
# Odd columns
else:
cY = height * (1. + float(row))
# Center position
return (cX, cY)
def flat_vertical_spacing(size):
# Check arguments
exception.arg_check(size, float)
# Calculate vertical spacing
return (flat_height(size))
def __init__(self, objectType=None, worldObj=None):
# Check arguments
self.objectType = exception.arg_check(objectType, str)
self.world = exception.arg_check(worldObj, world.World, None)
def set_color(self, _color):
# Check arguments
_color = exception.arg_check(_color, Color, NONE)
# Set rgba values from _color argument
r, g, b, a = _color.rgba()
self.set_rgba(r, g, b, a)
def update_system_map_image(self, hRow, hCol):
systemData = self.hexes[(hRow,hCol)].system
# System orbit maps.
orbitMapGroup = self.images.orbitMapGroup
# Check arguments
hRow = exception.arg_check(hRow,int)
hCol = exception.arg_check(hCol,int)
# Reset orbit map image.
orbitMapGroup.reset_hex(hRow,
hCol)
# Create new system map.
orbitMapGroup.add_system(self.majorRow,
self.majorCol,
hRow,
hCol,
systemData.name)
# Add stars.
for s in systemData.stars:
orbitMapGroup.maps[(hRow,hCol)].add_star(s.color,
s.classification,
s.spectralSubclass,
s.luminosity,
s.solarMass,
s.solarRadius)
# Add planets and asteroid belts.
for o in systemData.objects:
# Planets.
if ( type(o) is orbitalobject.Planet ):
# Get world name if planet is a world.
planetWorld = None
# Orbital object has world member variable.
if not (o.world is None):
# World object has name member variable.
planetWorld = o.world.name
# Add planet.
orbitMapGroup.maps[(hRow,hCol)].add_planet(o.objectType,
o.rings,
planetWorld)
# Add stations to planet.
for s in o.stations:
# Get station world name.
stationWorld = s.world.name
# Add station.
orbitMapGroup.maps[(hRow,hCol)].add_station(s.objectType,
stationWorld)
# Add moons to planet.
for m in o.moons:
# Get world name if moon is a world.
moonWorld = None
# Orbital object has world member variable.
if not (m.world is None):
# World object has name member variable.
moonWorld = m.world.name
# Add moon
orbitMapGroup.maps[(hRow,hCol)].add_moon(m.objectType,
moonWorld)
# Asteroid belts.
elif ( type(o) is orbitalobject.AsteroidBelt ):
# Add belt.
orbitMapGroup.maps[(hRow,hCol)].add_belt(o.objectType)
def __init__(self,
title=None,
size=None,
rows=None,
cols=None,
coords=None,
border=None):
# Argument parsing -----------------------------------------------------
# Map title
self.title = exception.arg_check(title, str, '')
# Map size
if (not ((size == LARGE_MAP) or (size == SMALL_MAP))):
# TODO: raise error of invalid map size argument
size = SMALL_MAP
self.size = exception.arg_check(size, str, SMALL_MAP)
# Hex text info
if (self.size == LARGE_MAP):
hexText = LARGE_ODDR_TEXT
self.hexWidth = LARGE_ODDR_TEXT_W
self.hexHeight = LARGE_ODDR_TEXT_H
hexCoord = LARGE_ODDR_TEXT_COORD
self.hexLabel = LARGE_ODDR_TEXT_LABEL
else:
hexText = SMALL_ODDR_TEXT
self.hexWidth = SMALL_ODDR_TEXT_W
self.hexHeight = SMALL_ODDR_TEXT_H
hexCoord = SMALL_ODDR_TEXT_COORD
self.hexLabel = SMALL_ODDR_TEXT_LABEL
# Map rows
self.rows = exception.arg_check(rows, int, sector.SECTOR_ROWS)
# Map columns
self.cols = exception.arg_check(cols, int, sector.SECTOR_COLS)
# Print map coordinates flag
coords = exception.arg_check(coords, bool, False)
# Map border
self.border = exception.arg_check(border, str, MAP_BORDER)
# Map padding
self.padding = 1
# Create empty grid from template --------------------------------------
# Calculate number of rows
charRows = self.rows * self.hexHeight + int(
math.ceil((self.hexHeight - 1) / 2.0))
# Subtract the rows where the grid overlaps
charRows -= (self.rows - 1)
# Calculate number of columns
# Add full width of 0th column
charCols = self.hexWidth
# Every extra column is 3/4 of the width to the right
charCols += (self.cols - 1) * int(math.ceil(self.hexWidth * 3.0 / 4.0))
# Fill hexmap
self.hexMap = [([' '] * charCols) for i in xrange(charRows)]
# Array character row offset to start this hex from
cEvenColRowOffset = 0
cOddColRowOffset = (self.hexHeight - 1) / 2
# For every hex row
for row in xrange(self.rows):
# Array character column offset to start this hex from
cColOffset = 0
# For every hex col
for col in xrange(self.cols):
# Rows to copy from template
tRows = xrange(self.hexHeight)
# Cols to copy from template
tCols = xrange(self.hexWidth)
# Copy template
for tr in tRows:
for tc in tCols:
# Use different row offsets for even vs odd rows
useOffset = cEvenColRowOffset
if (col % 2 != 0):
useOffset = cOddColRowOffset
# Don't copy spaces
if (hexText[tRows[tr]][tCols[tc]] != ' '):
self.hexMap[useOffset +
tr][cColOffset +
tc] = hexText[tRows[tr]][tCols[tc]]
# Add hex coords
if (coords):
coordStr = '0{0}0{1}'.format(row, col)
coordROffset = hexCoord[0]
coordCOffset = hexCoord[1]
for i in xrange(len(coordStr)):
self.hexMap[useOffset +
coordROffset][cColOffset + coordCOffset +
i] = coordStr[i]
# Update character column offset
cColOffset += int(math.ceil(self.hexWidth * 3.0 / 4.0))
# Update character row offset
cEvenColRowOffset += self.hexHeight - 1
cOddColRowOffset += self.hexHeight - 1
def flat_horizontal_spacing(size):
# Check arguments
exception.arg_check(size, float)
# Calculate horizontal spacing
return (flat_width(size) * 3. / 4.)
def __init__(self, worldObj=None):
# Initialize base class
BaseOrbitalObject.__init__(
self,
objectType=TABLE_ORBITAL_OBJECT_TYPE['SPACE_STATION'],
worldObj=exception.arg_check(worldObj, world.World, None))
def flat_width(size):
# Check arguments
exception.arg_check(size, float)
# Calculate width
return (size * 2.)
