def setUp(self):
"""
Instantiates the planet data structure and fills it with paths
example planet:
+--+
| |
+-0,3------+
| |
0,2-----2,2 (target)
| /
+-0,1 /
| | /
+-0,0-1,0
|
(start)
"""
# set your data structure
self.planet = Planet()
# add the paths
self.planet.add_path(((0, 0), Direction.NORTH),
((0, 1), Direction.SOUTH), 1)
self.planet.add_path(((0, 1), Direction.WEST),
((0, 0), Direction.WEST), 1)
def setUp(self):
"""
Planet:
+--+
| |
+-0,3------+
| |
0,2-----2,2 (target)
| /
+-0,1 /
| | /
+-0,0-1,0
|
(start)
Instantiates the planet data structure and fills it with paths
MODEL YOUR TEST PLANET HERE (if you'd like):
"""
# set your data structure
self.planet = Planet()
# ADD YOUR PATHS HERE:
# self.planet.add_path(...)
'''
def fetch_planets(self):
self.logger.info('Fetching planets..')
resp = self.br.open(self.PAGES['main']).read()
self.calc_time(resp)
soup = BeautifulSoup(resp)
self.planets = []
self.moons = []
try:
for i, c in enumerate(soup.find('select').findAll('option')):
url = c['value']
name, coords = c.contents[0].split(' ')[0:2]
p = Planet('1', name, coords[1:-1], url, False)
if i == 0:
p.mother = True
self.planets.append(p)
#p_id = int(c.parent.get('id').split('-')[1])
# construct_mode = len(
# c.parent.findAll(
# 'a',
# 'constructionIcon')) != 0
# check if planet has moon
# moon = c.parent.find('a', 'moonlink')
# if moon and 'moonlink' in moon['class']:
# url = moon.get('href')
# m_id = url.split('cp=')[1]
# m = Moon(m_id, coords, url)
# self.moons.append(m)
except:
self.logger.exception('Exception while fetching planets')
def __init__(self, mqtt_client):
""" Initializes communication module, connect to server, subscribe, etc. """
# THESE TWO VARIABLES MUST NOT BE CHANGED
self.client = mqtt_client
self.client.on_message = self.on_message
# ADD YOUR VARIABLES HERE
# Basic configuration of MQTT
# Wichtig?
self.client.on_message = self.on_message_excepthandler
self.client.username_pw_set('118', password='******') # Your group credentials
self.client.connect('mothership.inf.tu-dresden.de', port=8883)
self.client.subscribe('explorer/118', qos=1) # Subscribe to topic explorer/xxx
# self.send_ready()
# Start listening to incoming messages
self.client.loop_start()
#self.timer()
self.planet = Planet()
#Parameter:
self.data = None
self.topic = "explorer/118"
self.planet_Chan = None
self.aktX = None
self.aktY = None
self.direc = None
def test_add_rover(self):
planet = Planet(2, 2)
rover = Rover(1, 2, 'N', planet)
self.assertEqual(len(planet.rovers), 0)
planet.add_rover(rover)
self.assertEqual(len(planet.rovers), 1)
def on_touch_down(self, touch):
self.touch_start = touch.pos
self.touch_end = touch.pos
if HAS_CHARGE:
charge = self.def_charge
'''
if 'button' in touch.profile:
if touch.button == 'right':
charge = -1.
'''
# print(f'keyboard_modifiers {self._keyboard_modifiers}')
if 'ctrl' in self._keyboard_modifiers:
charge *= -1.
# print(f'charge {charge}')
self.touch_planet = Planet(pos=list(
self.to_num_dimension(touch.pos)),
mass=1,
num_dimension=self.num_dimension,
charge=charge)
else:
self.touch_planet = Planet(pos=list(
self.to_num_dimension(touch.pos)),
mass=1,
num_dimension=self.num_dimension)
self.append(self.touch_planet)
return False
def setUp(self):
"""
Instantiates the planet data structure and fills it with paths
MODEL YOUR TEST PLANET HERE (if you'd like):
"""
# set your data structure
self.planet = Planet()
# ADD YOUR PATHS HERE:
self.planet.add_path(((0, 0), Direction.NORTH),
((0, 1), Direction.SOUTH))
self.planet.add_path(((0, 0), Direction.EAST),
((0, 1), Direction.EAST))
self.planet.add_path(((0, 1), Direction.NORTH),
((1, 2), Direction.WEST))
self.planet.add_path(((1, 2), Direction.SOUTH),
((1, 1), Direction.NORTH))
self.planet.add_path(((1, 1), Direction.EAST),
((2, 1), Direction.WEST))
self.planet.add_path(((1, 1), Direction.SOUTH),
((2, 0), Direction.WEST))
self.planet.add_path(((2, 1), Direction.NORTH),
((2, 2), Direction.SOUTH))
self.planet.add_path(((2, 2), Direction.NORTH),
((2, 2), Direction.WEST))
self.planet.add_path(((2, 0), Direction.NORTH),
((2, 1), Direction.SOUTH))
self.planet.add_path(((2, 0), Direction.EAST),
((4, 0), Direction.WEST))
self.planet.add_path(((4, 0), Direction.NORTH),
((4, 1), Direction.SOUTH))
self.planet.add_path(((4, 0), Direction.EAST),
((4, 1), Direction.EAST))
class ExampleTestPlanet(unittest.TestCase):
def setUp(self):
"""
Instantiates the planet data structure and fills it with paths
+--+
| |
+-0,3------+
| |
0,2-----2,2 (target)
| /
+-0,1 /
| | /
+-0,0-1,0
|
(start)
"""
# Initialize your data structure here
self.planet = Planet()
self.planet.add_path(((0, 0), Direction.NORTH), ((0, 1), Direction.SOUTH), 1)
self.planet.add_path(((0, 1), Direction.WEST), ((0, 0), Direction.WEST), 1)
@unittest.skip('Example test, should not count in final test results')
def test_target_not_reachable_with_loop(self):
"""
This test should check that the shortest-path algorithm does not get stuck in a loop between two points while
searching for a target not reachable nearby
Result: Target is not reachable
"""
self.assertIsNone(self.planet.shortest_path((0, 0), (1, 2)))
class Game(object):
def __init__(self):
# Global setup
self.screen_w = 640
self.screen_h = 480
self.screen_size = (self.screen_w, self.screen_h)
self.screen = pygame.display.set_mode(self.screen_size)
pygame.display.set_caption('Hero I')
self.clock = pygame.time.Clock()
self.fps = 60
self.planet = Planet(*self.screen_size)
self.player = Player(self.screen_w / 2, self.screen_h / 2)
self.spider = Monster('spider', 50, 100)
self.slime = Monster('slime', 200, 400)
self.monsters = pygame.sprite.Group(self.spider, self.slime)
self.allsprites = pygame.sprite.Group(self.player, self.monsters)
self.camera = Camera(self.screen_size)
def main_loop(self):
""" This is the Main Loop of the Game. """
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return None
elif event.type == KEYDOWN:
if event.key in (K_LEFT, K_RIGHT, K_UP, K_DOWN):
self.player.change_speed(event.key, key_down=True)
elif event.key in (K_ESCAPE, K_q):
pygame.event.post(pygame.event.Event(QUIT))
elif event.type == KEYUP:
if event.key in (K_LEFT, K_RIGHT, K_UP, K_DOWN):
self.player.change_speed(event.key, key_down=False)
self.screen.fill(Color('#FF00FF'))
self.player.update()
self.planet.update()
self.camera.update(self.player.center)
for tile, position in self.planet.render(self.player.center):
self.screen.blit(tile, self.camera.apply(position))
for a in self.allsprites:
if a is not self.player:
a.update()
self.screen.blit(a.image, self.camera.apply(a.rect.topleft))
pygame.display.update()
self.clock.tick(self.fps)
def fetch_planets(self):
self.logger.info('Fetching planets..')
resp = self.br.open(self.PAGES['main']).read()
self.calc_time(resp)
soup = BeautifulSoup(resp)
self.planets = []
self.moons = []
try:
for i, c in enumerate(soup.find('select').findAll('option')):
url = c['value']
name, coords = c.contents[0].split(' ')[0:2]
p = Planet('1', name, coords[1:-1], url, False)
if i == 0:
p.mother = True
self.planets.append(p)
#p_id = int(c.parent.get('id').split('-')[1])
# construct_mode = len(
# c.parent.findAll(
# 'a',
# 'constructionIcon')) != 0
# check if planet has moon
# moon = c.parent.find('a', 'moonlink')
# if moon and 'moonlink' in moon['class']:
# url = moon.get('href')
# m_id = url.split('cp=')[1]
# m = Moon(m_id, coords, url)
# self.moons.append(m)
except:
self.logger.exception('Exception while fetching planets')
def fetch_planets(self):
self.logger.info('Fetching planets..')
resp = self.br.open(self.PAGES['main']).read()
self.calc_time(resp)
soup = BeautifulSoup(resp)
self.planets = []
self.moons = []
try:
for i, c in enumerate(soup.findAll('a', 'planetlink')):
name = c.find('span', 'planet-name').text
coords = c.find('span', 'planet-koords').text[1:-1]
url = c.get('href')
p_id = int(c.parent.get('id').split('-')[1])
construct_mode = len(c.parent.findAll('a',
'constructionIcon')) != 0
p = Planet(p_id, name, coords, url, construct_mode)
if i == 0:
p.mother = True
self.planets.append(p)
#check if planet has moon
moon = c.parent.find('a', 'moonlink')
if moon and 'moonlink' in moon['class']:
url = moon.get('href')
m_id = url.split('cp=')[1]
m = Moon(m_id, coords, url)
self.moons.append(m)
except:
self.logger.exception('Exception while fetching planets')
else:
self.check_attacks(soup)
def destroy_temp_planet(planet_name):
try:
p = Planet(direc=planet_name)
except KeyError:
pass
else:
p.delete()
class Picture:
def __init__(self, width, height):
self.mWidth = width
self.mHeight = height
self.mSky = Sky(width, height)
self.mPlanet1 = Planet(200, 210, 215)
self.mPlanet1.setColor(204, 204, 204)
self.mMountain1 = Mountain(width, height)
self.mCrater1 = Crater(40, 130, 100, 100)
self.mCrater2 = Crater(35, 120, 50, 50)
self.mCrater3 = Crater(90, 10, 90, 90)
self.mCrater4 = Crater(250, 90, 100, 100)
self.mCrack1 = Crack(290, 250)
self.mCrack2 = Crack(285, 240)
self.mHill1 = Hill(175, 400)
self.mHill2 = Hill(300, 380)
self.mHill3 = Hill(500, 450)
self.mStar = Star(width, height)
return
def draw(self, surface):
self.mSky.draw(surface)
self.mPlanet1.draw(surface)
self.mMountain1.draw(surface)
self.mCrater1.draw(surface)
self.mCrater2.draw(surface)
self.mCrater3.draw(surface)
self.mCrater4.draw(surface)
self.mCrack1.draw(surface)
self.mCrack2.draw(surface)
self.mHill1.draw(surface)
self.mHill2.draw(surface)
self.mHill3.draw(surface)
self.mStar.draw(surface)
return
def setUp(self):
self._solarsystem = Solar_system()
#self._planet_1 = None
route_1_x = [1000, 0, 0]
route_1_v = [0, -1000, 0]
route_1 = Route(route_1_x, route_1_v)
name_1 = "Aalto-3"
mass_1 = 10
state_1 = State.ALIVE
self._satellite_1 = Satellite(name_1, route_1, mass_1, state_1)
route_1_x = [152100000000, 0, 0]
route_1_v = [0, 29780, 0]
route_1 = Route(route_1_x, route_1_v)
name_1 = "Earth"
mass_1 = 5.97237*10**24
diameter = 2*6371000
self._planet_1 = Planet(name_1, route_1, mass_1, diameter)
self.pos_test_string = "x:220my:100kmz:20m"
self.test_read = Read_planets()
test_file = open("test_read.txt")
self._solarsystem.read_planets(test_file)
test_file.close()
def fetch_planets(self):
self.logger.info('Fetching planets..')
resp = self.br.open(self.PAGES['main']).read()
self.calc_time(resp)
soup = BeautifulSoup(resp)
self.planets = []
self.moons = []
try:
for i, c in enumerate(soup.findAll('a', 'planetlink')):
name = c.find('span', 'planet-name').text
coords = c.find('span', 'planet-koords').text[1:-1]
url = c.get('href')
p_id = int(c.parent.get('id').split('-')[1])
construct_mode = len(c.parent.findAll('a', 'constructionIcon')) != 0
p = Planet(p_id, name, coords, url, construct_mode)
if i == 0:
p.mother = True
self.planets.append(p)
#check if planet has moon
moon = c.parent.find('a', 'moonlink')
if moon and 'moonlink' in moon['class']:
url = moon.get('href')
m_id = url.split('cp=')[1]
m = Moon(m_id, coords, url)
self.moons.append(m)
except:
self.logger.exception('Exception while fetching planets')
else:
self.check_attacks(soup)
class ExampleTestPlanet(unittest.TestCase):
def setUp(self):
"""
Instantiates the planet data structure and fills it with paths
example planet:
+--+
| |
+-0,3------+
| |
0,2-----2,2 (target)
| /
+-0,1 /
| | /
+-0,0-1,0
|
(start)
"""
# set your data structure
self.planet = Planet()
# add the paths
self.planet.add_path(((0, 0), Direction.NORTH),
((0, 1), Direction.SOUTH), 1)
self.planet.add_path(((0, 1), Direction.WEST),
((0, 0), Direction.WEST), 1)
def test_target_not_reachable_with_loop(self):
# does the shortest path algorithm loop infinitely?
# there is no shortest path
self.assertIsNone(self.planet.shortest_path((0, 0), (1, 2)))
def __init__(self, total_time, dt):
self.solver = Solver(total_time, dt)
self.planets = np.array([
Planet(self.solver, 1, [0, 0], [0, 0], True),
Planet(self.solver, 3e-6, [1, 0], [0, 2 * np.pi]),
Planet(self.solver, 9.5e-4, [5.2, 0], [0, 2.75])
])
def main():
ferengi = Planet(distance=500, speed=-1)
betasoide = Planet(distance=2000, speed=-3)
vulcan = Planet(distance=1000, speed=5)
star_trek_galaxy = Galaxy([ferengi, betasoide, vulcan])
draft_days = 0
perfect_days = 0
rainy_day = 0
most_rain_day = -1
most_rain_perimeter = 0
for day in range(3650):
alignment = star_trek_galaxy.planets_are_aligned(day)
if alignment is PlanetsPosition.ALIGNED_WITH_THE_SUN:
draft_days += 1
elif alignment is PlanetsPosition.ALIGNED_WITH_EACHOTHER:
perfect_days += 1
else:
# if we are here, planets are forming a polygon
(sunsPosition, per) = star_trek_galaxy.calculate_suns_position(day)
if sunsPosition is PlanetsPosition.SUN_INSIDE_POLYGON:
rainy_day += 1
if per > most_rain_perimeter:
most_rain_day = day
most_rain_perimeter = per
print('Draft:', draft_days)
print('Perfect:', perfect_days)
print('Rainy:', rainy_day)
print('Most rain:', most_rain_day)
def generate(self, objectno) -> Planet:
model = markov_namemaker.train("PlanetNames.txt")
for i in range(objectno):
newplanet = Planet(model.generate())
newplanet.populate(random.randint(1, 50))
self.planets.append(newplanet)
def load_planets(self):
self.orbit_root_mercury = render.attachNewNode('orbit_root_mercury')
self.orbit_root_venus = render.attachNewNode('orbit_root_venus')
self.orbit_root_mars = render.attachNewNode('orbit_root_mars')
self.orbit_root_earth = render.attachNewNode('orbit_root_earth')
self.orbit_root_moon = (
self.orbit_root_earth.attachNewNode('orbit_root_moon'))
self.sky = loader.loadModel("models/sky_dome.blend")
self.sky_tex = loader.loadTexture("models/sky_tex2_cut.jpg")
self.sky_tex.setWrapU(Texture.WM_clamp)
self.sky.setTexture(self.sky_tex, 1)
self.sky.reparentTo(render)
self.sky.setScale(300)
self.sky.setHpr(270, 0, 0)
self.Sun = Star(self, 'Sun', 'models/planet_sphere',
'models/sun_1k_tex.jpg', 2)
self.Mercury = Planet(self, 'Mercury', 'models/planet_sphere',
'models/mercury_1k_tex.jpg',
self.orbit_root_mercury, 0.385, 0.38, False, 1, {
'Coal': 'Common',
'Iron': 'Common'
})
self.Venus = Planet(self, 'Venus', 'models/planet_sphere',
'models/venus_1k_tex.jpg', self.orbit_root_venus,
0.923, 0.72, False, 2, {
'Coal': 'Common',
'Uranium': 'Normal'
})
self.Mars = Planet(self, 'Mars', 'models/planet_sphere',
'models/mars_1k_tex.jpg', self.orbit_root_mars,
0.512, 1.52, False, 1, {
'Gemstone': 'Rare',
'Iron': 'Rare'
})
self.Mars.probed = True
self.Earth = Planet(self, 'Earth', 'models/planet_sphere',
'models/earth_1k_tex.jpg', self.orbit_root_earth,
1, 1, True, 1, {
'Iron': 'Normal',
'Coal': 'Common'
})
self.orbit_root_moon.setPos(self.orbitscale, 0, 0)
self.Earth_Moon = Moon(self, 'Moon', 'models/planet_sphere',
'models/moon_1k_tex.jpg', self.orbit_root_moon,
0.1, 0.1, False, 0, {
'Cheese': 'Rare',
'Coal': 'Common'
})
def __init__(self, args):
"""
constructor
"""
# initialise members
self._model, self._architecture = loadFromFile(args.model_path)
self._planet = Planet()
return
def Acc_Grav(self, Planet):
x = Planet.x_position()
#print("x",x)
y = Planet.y_position()
self._r = np.sqrt((x)**2 + (y)**2)
self._A_x = -G * x * m_sun / self._r**3
self._A_y = -G * y * m_sun / self._r**3
#print("self",self._A_x)
return self._A_x, self._A_y, self._r
def test_axial_tilt():
planet = Planet(SUN)
planet.mass = planet.earth_in_solar_masses
planet.axis = 1
tilts = set()
for i in range(0, 100):
tilts.add(Planet(SUN).axial_tilt())
assert len(tilts) > 0
assert min(tilts) > 0
assert max(tilts) < 360
def loadPaths(filename):
with open(filename, "r") as infile:
data = json.load(infile)
# print(data)
bodies = []
for i in data:
body = Planet()
body.loadSerialized(i)
bodies.append(body)
return bodies
def __init__(self, parent, control="RANDOM"):
self.parent = parent
if (control == "LUNA"):
self.initluna()
return
if (control == "PHOBOS"):
self.initphobos()
return
if (control == "DEIMOS"):
self.initdeimos()
return
if (control == "IO"):
self.initio()
return
if (control == "EUROPA"):
self.initeuropa()
return
if (control == "GANYMEDE"):
self.initganymede()
return
if (control == "CALLISTO"):
self.initcallisto()
return
if (control == "TITAN"):
self.inittitan()
return
if (control == "TRITON"):
self.inittriton()
return
if (control == "CHARON"):
self.initcharon()
return
self.index = random.randint(
0, 2147483647
) #I want these to be indicies but here I can assure they're unique which is a start
self.resources = [
random.randint(0, 255),
random.randint(0, 255),
random.randint(0, 255)
]
self.size = random.lognormvariate(math.log(1.5), 0.3)
self.culture = OnlineMarkov()
for i in range(-1, int(self.size * 2 / 2)):
cultureString = self.culture.randomString(int(self.size * 2 / 2))
#print(cultureString)
self.culture.contribute(cultureString)
self.radius = random.lognormvariate(math.log(parent.size * 2), 0.125)
#print(self.radius)
self.inclination = random.normalvariate(0, 15)
self.longitudeAscendingNode = random.uniform(0, 360)
self.trueAnomaly = random.uniform(0, 360)
self.period = Planet.getPeriodFromRadius(self.radius, self.parent.size)
self.rotationMatrix = Planet.eulerAngles2Matrix(
self.inclination, self.longitudeAscendingNode)
self.position = self.getPosition()
def spawn_planets(num):
global planet
for i in range(num):
# This represents a planet
planet = Planet(Vec2d(1, 1), 50, 0.5)
# Set a random location for the planets
planet.reset_pos(screen_width)
# Add the planet to the list of objects
planet_list.add(planet)
all_sprites_list.add(planet)
def misfit(args, n_slices, n_iterations, moho_depth, T_pot, perplex_mantle_file):
cmb_depth, core_density_deficit = args
core_density_deficit = core_density_deficit / 1000.
if core_density_deficit < -3000. or core_density_deficit > 5000. or cmb_depth < 100.e3:
misfit = 1.e12
else:
mars = Planet(n_slices, moho_depth, cmb_depth, observed_mean_radius, core_density_deficit, core_Vp_fraction, T_pot, perplex_mantle_file)
mars.generate_profiles( n_iterations )
misfit = np.sqrt((1. - mars.mass/observed_mass)*(1. - mars.mass/observed_mass)
+ (1. - mars.moment_of_inertia_factor/observed_moment)*(1. - mars.moment_of_inertia_factor/observed_moment))
print(args, misfit)
return misfit
def __init__(self, no_name_level,
battery): ##width height tile rover x y list, battery
"""
Initialises the rover
"""
self.no_name_level = no_name_level
self.rover_map = []
self.battery = battery
self.width = self.no_name_level[0]
self.height = self.no_name_level[1]
self.tile = self.no_name_level[2]
self.x = self.no_name_level[3]
self.y = self.no_name_level[4]
self.rover_coordinates = [self.x, self.y]
self.tiles = []
for i in self.tile:
i = i[:-1]
self.tiles.append(i)
self.tiles_arranged = [
self.tiles[i:i + self.width]
for i in range(0, len(self.tile), self.width)
]
planet_co = []
for i in self.tiles_arranged:
self.planet = []
for n in i:
n = n.split(',')
if len(n) != 3:
a = ['-']
n += a
self.planet.append(n)
else:
self.planet.append(n)
planet_co.append(self.planet)
self.planet_map = Planet(planet_co, self.width, self.height)
self.coordinates = Planet(planet_co, self.width, self.height)
self.coordinates = Planet.coordinates(self.coordinates)
self.planet_map = Planet.coordinates_dict(
self.planet_map
) #this is my map in dictionary format(coordinates : tile)
pass
class Main():
def __init__(self):
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
self.size = (600, 600)
self.screen = pygame.display.set_mode(self.size) # pygame.RESIZABLE)
pygame.display.set_caption("Game Name goes Here")
self.done = False
self.clock = pygame.time.Clock()
self.planet = Planet(self.size)
self.lines = True
self.points = True
#self.unit = Unit()
def redraw(self):
self.screen.fill((0xFF,) * 3)
self.screen.blit(*self.planet.blit_params())
#self.screen.blit(*self.unit.blit_params())
def run(self):
self.redraw()
while not self.done:
self.clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.done = True
elif event.type == pygame.MOUSEMOTION:
pass
elif event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 0:
pass
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_l:
self.lines ^= True
self.planet.redraw(self.lines, self.points)
if event.key == pygame.K_p:
self.points ^= True
self.planet.redraw(self.lines, self.points)
elif event.type == pygame.KEYUP:
pass
elif event.type == pygame.VIDEORESIZE:
pass
#self.unit.move()
self.redraw()
pygame.display.flip()
pygame.quit()
def __init__ (self, ident, *args):
self.player_ident = ident
self.img_ident = 'player{0}'.format(ident)
Planet.__init__(self, *args)
self.launch_speed = conf.ASTEROID_LAUNCH_SPEED
self._since_last_launch = conf.ASTEROID_LAUNCH_GAP
self.n_dots = conf.PLAYER_N_DOTS
self.aiming = [[0, 0], [0, 0]] # (defensive, offensive) (x, y)
self.aiming_angle = [0, 0]
self._fire_last = [0, 0] # (defensive, offensive) - since fire are axes
self._dots = []
self._aim_mag = 0
self.score = 0
def solar_system():
# distance : in millions of km
# radius : in thousands of km, all get divided by 2 and the sun by 10 on top for size on screen
# velocity : in km/s
# mass : in kg
sun = Planet([center_w, center_h], 696.340 / 20, [0, 0], 1.989 * 10**30,
(255, 255, 0), "Sun")
mercury = Planet([center_w - 69.8, center_h], 2.439, [0, 38.86],
3.301 * 10**23, (128, 128, 128), "Mercury")
venus = Planet([center_w - 108, center_h], 6.051, [0, 35], 4.8675 * 10**24,
(255, 128, 0), "Venus")
earth = Planet([center_w - 152.1, center_h], 6.371, [0, 29.3],
5.972 * 10**24, BLUE, "Earth")
mars = Planet([center_w - 228, center_h], 3.390, [0, 21.972],
6.4185 * 10**23, RED, "Mars")
m = 1.5 * 10**29
x = 97.000436
y = 24.308753
vx = 9.3240737
vy = 8.6473146
p1 = Planet([center_w + x, center_h + y], 10, [vx / 2, -vy / 2], m, BLUE)
p2 = Planet([center_w - x, center_h - y], 10, [vx / 2, -vy / 2], m, RED)
p3 = Planet([center_w, center_h], 10, [-vx, vy], m, WHITE)
# planets = [p1, p2, p3] # 8 figure
planets = [sun, mercury, venus, mars, earth] # solar system
return planets, SolarSystem(planets)
def load_planets(self):
''' Load the planets for this system. '''
if not self.planets:
if self.name.lower() == "sol":
self.add_planet(
Planet("Mercury",
[.24 * 365, .39, .2056, 7.01, .034, 5.43, 440]))
self.add_planet(
Planet("Venus",
[.62 * 365, .72, .0068, 3.39, .085, 5.25, 735]))
self.add_planet(
Planet("Earth", [365, 1.0, .0167, 0.0, 0.089, 5.52, 288]))
self.add_planet(
Planet("Mars",
[1.88 * 365, 1.52, .0934, 1.85, .048, 3.93, 218]))
self.add_planet(
Planet("Jupiter",
[11.86 * 365, 5.2, .0483, 1.31, 1.00, 1.33, 123]))
self.add_planet(
Planet("Saturn",
[29.46 * 365, 9.5, .0560, 2.49, .84, 0.71, 103]))
self.add_planet(
Planet("Uranus",
[84.01 * 365, 19.2, .0461, 0.77, .36, 1.24, 73]))
self.add_planet(
Planet("Neptune",
[164.8 * 365, 30.0, .0097, 1.77, .35, 1.67, 63]))
else:
self.get_exoplanets()
return self.planets
class RoverTestCase(unittest.TestCase):
# initial creation of the roverobject
def setUp(self): # creating same planet and rover for each test case
self.planet = Planet(10, 10)
self.rover = Rover(0, 0, 'N', self.planet)
def tearDown(self):
print('\n \n')
def test_will_rover_move(self):
givecommands = ['f', 'r', 'f',
'f'] # these are the commands that should be executed
self.assertTrue(Rover.readcommands(self.rover, givecommands,
self.planet),
msg=Rover.giveroverlocation(self.rover))
def test_will_rover_refuse_unknown_commands(self):
givecommands = ['s', 'n', 'a', 'r']
self.assertTrue(Rover.readcommands(self.rover, givecommands,
self.planet),
msg=Rover.giveroverlocation(self.rover))
def test_will_rover_refuse_numeric_commands(self):
givecommands = [3, 2, 5.2, 'r']
self.assertTrue(Rover.readcommands(self.rover, givecommands,
self.planet),
msg=Rover.giveroverlocation(self.rover))
def test_will_rover_stop_at_obstacle(self):
self.planet.addobstacle(1, 2)
givecommands = ['f', 'f', 'r', 'f', 'f', 'b']
self.assertTrue(Rover.readcommands(self.rover, givecommands,
self.planet),
msg=Rover.giveroverlocation(self.rover))
def test_will_false_obstacle_input_be_ignored(self):
self.planet.addobstacle('sboj', 'adbiun')
givecommands = ['f', 'f', 'r', 'f', 'f', 'b']
self.assertTrue(Rover.readcommands(self.rover, givecommands,
self.planet),
msg=Rover.giveroverlocation(self.rover))
def test_does_wrapping_work(self):
givecommands = ('l', 'f')
self.assertTrue(Rover.readcommands(self.rover, givecommands,
self.planet),
msg=Rover.giveroverlocation(self.rover))
def assign_home_sector(self, player, planet_name, ship_name):
"""Find an unused sector and assign this player to it.
This should only run if the player doesn't have a parent (which means they don't have a ship).'"""
if player.parent:
self.log.debug(
"assign_home_sector(): Player %s already has a parent, returning True"
% player.name)
return True
home_sector = self._find_empty_sector()
self.log.debug(
"assign_home_sector(): Home sector determined to be %s" %
home_sector.name)
#We call get_sector, which will create it if it doesn't exist
home_sector = self.get_sector(
"%s-%s" % (home_sector.cluster_name, home_sector.name))
if home_sector:
#Create planet
planet = Planet(initial_state={'name': planet_name})
self.log.debug("assign_home_sector(): Adding planet %s" % planet)
self.assign_child(home_sector, planet)
#Create ship
ship = Ship(initial_state={'name': ship_name})
self.assign_child(home_sector, ship)
#Move player to ship
self.assign_child(ship, player)
return True
else:
self.log.error(
"assign_home_sector(): db.add_sector() returned None, so the sector was not successfully created"
)
return False
def find_inactive_nearby(self, from_planet, radius=100, min_ponts=20000):
self.logger.info("Searching inactives near %s in radius %s" %
(from_planet, radius))
scores = etree.parse('general.xml').getroot()
military_scores = etree.parse('military.xml').getroot()
players = etree.parse('players.xml').getroot()
galaxy = etree.parse('galaxy.xml').getroot()
inactives = []
for player in players.findall('player'):
status = player.get('status')
if status == 'i' or status == 'I':
p = Player(idx=player.get('id'), name=player.get('name'))
p.score = self.get_score(player=p, scores=scores)
p.military_score = self.get_score(player=p,
scores=military_scores)
if int(p.score) > min_ponts:
inactives.append(p)
for planet in galaxy.findall('planet[@player=\'' + p.idx +
'\']'):
pl = Planet(id=planet.get('id'),
name=planet.get('name'),
coords=planet.get('coords'),
url=None)
if from_planet.is_in_range(coords=pl.coords,
radius=radius):
self.logger.info(pl.coords)
p.planets.append(pl)
return inactives
def __init__(self):
"""Inits the SolarSystem class."""
self.planets = []
for i in range(9):
self.planets.append(Planet(planet_id=i))
def generate(self, width, height, density, seed=None):
"""
Setup this galaxy with the correct width, height and generate the new planets.
"""
self.width = width
self.height = height
maxPlanets = (self.width-2) * (self.height-2) * density
prng = random.Random(seed)
while len(self.planets) < maxPlanets:
x = prng.randint(1, self.width-1)
y = prng.randint(1, self.height-1)
if (x,y) not in self.planets:
newPlanet = Planet(x,y)
newPlanet.generate(prng)
self.planets[(x,y)] = newPlanet
return
class PlanetTestCase(unittest.TestCase):
def setUp(self):
self.planet = Planet('Earth', 6367445, 5515)
def tearDown(self):
self.planet = None
def test_calculate_mass(self):
planet_mass = self.planet.calculate_mass()
self.assertTrue(4.47291861801e+24 < planet_mass < 4.47291861803e+24, 'planet mass is wrong, got ' + str(planet_mass))
def test_calculate_volume(self):
planet_volume = self.planet.calculate_volume()
self.assertTrue(8.11045986947e+20 < planet_volume < 8.11045986949e+20, 'planet volume is wrong, got ' + str(planet_volume))
def test_calculate_object_weight(self):
object_weight = self.planet.calculate_object_weight(1)
self.assertTrue(7.35986561504 < object_weight < 7.35986561506, 'object weight is wrong, got ' + str(object_weight))
def __init__(self,parent):
self.parent = parent
self.width = parent.width
self.height = parent.height
self.planet = Planet(parent,self)
self.objects = []
self.message = []
self.satellite = 0
self.info = [['Temperature',0],['Air pressure',0],['Water',0],['CO2',0],['O2',0],['Satellite',0],['Mine',0],['Nuclear',0],['Algae',0],['Tree',0],['Animal',0]]
def __init__(self):
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
self.size = (600, 600)
self.screen = pygame.display.set_mode(self.size) # pygame.RESIZABLE)
pygame.display.set_caption("Game Name goes Here")
self.done = False
self.clock = pygame.time.Clock()
self.planet = Planet(self.size)
self.lines = True
self.points = True
def __init__(self):
# Global setup
self.screen_w = 640
self.screen_h = 480
self.screen_size = (self.screen_w, self.screen_h)
self.screen = pygame.display.set_mode(self.screen_size)
pygame.display.set_caption('Hero I')
self.clock = pygame.time.Clock()
self.fps = 60
self.planet = Planet(*self.screen_size)
self.player = Player(self.screen_w/2, self.screen_h/2)
self.spider = Monster('spider', 50, 100)
self.slime = Monster('slime', 200, 400)
self.monsters = pygame.sprite.Group(self.spider, self.slime)
self.allsprites = pygame.sprite.Group(self.player, self.monsters)
self.camera = Camera(self.screen_size)
def setUp(self):
self.planet = Planet('Earth', 6367445, 5515)
class World:
def __init__(self,parent):
self.parent = parent
self.width = parent.width
self.height = parent.height
self.planet = Planet(parent,self)
self.objects = []
self.message = []
self.satellite = 0
self.info = [['Temperature',0],['Air pressure',0],['Water',0],['CO2',0],['O2',0],['Satellite',0],['Mine',0],['Nuclear',0],['Algae',0],['Tree',0],['Animal',0]]
def addObject(self,moverName,location,velocity):
if moverName == '':
return
mover = Meteor(self.parent,self,location=location,velocity=velocity)
if Inventory.items[ShopWindow.items.index(moverName)] == 0:
return
Inventory.items[ShopWindow.items.index(moverName)] -= 1
if moverName == 'Fire':
mover = Fire(self.parent,self,location=location,velocity=velocity,image='red.png')
if moverName == 'Ice':
mover = Ice(self.parent,self,location=location,velocity=velocity,image='blue.png')
if moverName == 'Dry Ice':
mover = DryIce(self.parent,self,location=location,velocity=velocity,image='purple.png')
if moverName == 'Satellite':
mover = Satellite(self.parent,self,location=location,velocity=velocity,image='satellite.png')
if moverName == 'Mine':
mover = Mine(self.parent,self,location=location,velocity=velocity,image='mine.png')
if moverName == 'Nuclear':
mover = Nuclear(self.parent,self,location=location,velocity=velocity,image='nuclear.png')
if moverName == 'Algae':
mover = Algae(self.parent,self,location=location,velocity=velocity,image='algae.png')
if moverName == 'Tree':
mover = Tree(self.parent,self,location=location,velocity=velocity,image='tree.png')
if moverName == 'Animal':
mover = Animal(self.parent,self,location=location,velocity=velocity,image='animal.png')
self.objects.append(mover)
def run(self):
self.objects = [m for m in self.objects if not m.isDead()]
self.satellite = 0
for m in self.objects:
if type(m) == type(Satellite(self.parent,self)):
self.satellite += 1
m.run()
m.applyForce(Gravity.getForce(m.location,self.planet.location))
for m2 in self.objects:
if m == m2:
continue
if m.isCollide() or m2.isCollide():
continue
if m.isCollide(m2):
m.explosion()
m2.explosion()
self.planet.run()
self.update()
self.output()
def update(self):
self.info[0][1] = self.planet.temperature
self.info[1][1] = self.planet.atmosphere
self.info[2][1] = self.planet.water
self.info[3][1] = self.planet.co2
self.info[4][1] = self.planet.oxygen
self.info[5][1] = self.satellite
self.info[6][1] = self.planet.mine
self.info[7][1] = self.planet.nuclear
self.info[8][1] = self.planet.algae
self.info[9][1] = self.planet.tree
self.info[10][1] = self.planet.animal
def output(self):
margin = 0
length = len(self.message)
for i in range(length-1,-1,-1):
margin = self.height-100-(length-i)*50
text = self.message[i][0]
cnt = self.message[i][1]
if cnt > 112:
color = QColor(255,255,255,(128-cnt)*16)
elif cnt < 16:
color = QColor(255,255,255,cnt*16)
else:
color = QColor(255,255,255)
pen = QColor(color)
font = QFont('Consolas',15)
qp = QPainter()
qp.begin(self.parent)
qp.setPen(pen)
qp.setFont(font)
qp.drawText(50,margin,text)
qp.end()
if cnt == 0:
self.message.pop(i)
else:
self.message[i][1] -= 1
def getInfo(self,id):
if id >= 8:
return self.planet.getAmount(self.info[id][1])
if id >= 5:
return str(self.info[id][1])
if id >= 2:
return self.planet.getAmount(self.info[id][1])
return self.planet.getStatus(self.info[id][1])
def move (self, phys, dt): Planet.move(self, phys, dt) self._since_last_launch += dt angle = self.aiming_angle[1]
NCFMAS_compositions.append(map(float, perplex_mantle_file.replace(',', '.').split("_")[3:9]))
mFeO = 71.844
mMgO = 40.3044
Mg_numbers[i] = 100.*(NCFMAS_compositions[i][3]/mMgO) / ((NCFMAS_compositions[i][2]/mFeO) + (NCFMAS_compositions[i][3]/mMgO))
Si_contents[i] = NCFMAS_compositions[i][5]
print('Processing composition', str(i+1)+'/'+str(len(perplex_mantle_files))+':', NCFMAS_compositions[i], Mg_numbers[i])
res = minimize(misfit, [1700.e3, 2000.e3], method='Nelder-Mead', tol=1.e4,
args=(n_slices, n_iterations, moho_depth, T_pot, perplex_mantle_file)) # tol is depth in m
cmb_depths[i] = res.x[0]
core_density_deficits[i] = res.x[1]/1000.
mars = Planet(n_slices, moho_depth, cmb_depths[i], observed_mean_radius, core_density_deficits[i], core_Vp_fraction, T_pot, perplex_mantle_file)
mars.generate_profiles( n_iterations )
cmb_pressures[i] = mars.cmb_pressure
cmb_temperatures[i] = mars.cmb_temperature
misfits[i] = res.fun
data_to_print = NCFMAS_compositions[i]
data_to_print.extend([Mg_numbers[i], cmb_depths[i]/1000., cmb_pressures[i]/1.e9, cmb_temperatures[i], core_density_deficits[i], misfits[i]])
print(data_to_print)
output.append(data_to_print)
np.savetxt(fname=outfile, header='NCFMAS, Mg number, CMB depth, CMB pressure, CMB temperature, Core density deficit, misfit', fmt="%.4f", X=output)
'''
from mcpi import block
from time import sleep
#Main program
#create connection to minecraft
mc = Minecraft.create()
pos = Vec3(0,30,0)
mc.player.setTilePos(pos.x + 25 ,pos.y + 20, pos.z + 25)
#create Alderaan
alderaanPos = pos.clone()
alderaanPos.x += 50
alderaanPos.z += 50
alderaan = Planet(alderaanPos, 10, block.WOOL.id, 3)
#create DeathStar
sleep(15)
deathstarPos = pos.clone()
deathstar = DeathStar(deathstarPos, 15)
sleep(12)
mc.postToChat("Not Alderaan, we are peaceful, we have no weapons.")
#blow up Alderaan
sleep(3)
deathstar.fire(alderaanPos.x, alderaanPos.y, alderaanPos.z, 0.5, 1)
alderaan.destroy(2)
#millenium falcon arrives
sleep(10)
def hit_by_asteroid(self, asteroid): rtn = Planet.hit_by_asteroid(self, asteroid) self.score -= 1 #asteroid.player.increment_score() return rtn
__author__ = 'Mark Weinreuter'
# Wichtig! Die Klassen importieren
from mond import Mond
from planet import Planet
# Eine Instanz unserer Klasse anlegen
erde = Planet("Erde", 6378.15)
mars = Planet("Mars", 3397)
# Instanzen unsere Mond-Klasse
erdmond = Mond("ErdMond")
phobos = Mond("Phobos")
deimos = Mond("Deimos")
print(erde)
erde.gib_monde_aus()
# Monde hinzufügen
erde.fuege_mond_hinzu(erdmond)
mars.fuege_mond_hinzu(phobos)
mars.fuege_mond_hinzu(deimos)
print(erde)
erde.gib_monde_aus()
volMars = mars.berechne_volumen()
print("Mars hat ein errechnetes Volumen von: %d" % volMars)
print("Laut Wikipedia hat Mars ein Volumen von: %d" % 1631400000000) # Da ist eine 0 zu viel?? :)
# Zu Welchem Planet gehört der Mond?
#program.variables.blocks = 0
#tiles.apply( 1 )
#program.variables.tex = 1
#program.variables.v = Program.Vertex
#program.variables.n = Program.Normal
#program.variables.t = Program.TexCoord0
#program.apply()
pos = numpy.array((0., 0., -20.))
look = numpy.array((0., 0., 1.))
up = numpy.array((0., 1., 0.))
c = Camera( pos, look, up )
#w = World( r )
w = Planet( r )
handle_key = {}
handle_event = {}
handle_event[ KEYDOWN ] = lambda ev: handle_key[ ev.key ]( ev.key, True )
handle_event[ KEYUP ] = lambda ev: handle_key[ ev.key ]( ev.key, False )
handle_event[ MOUSEMOTION ] = lambda ev: c.rotate( -ev.rel[1]*0.01, -ev.rel[0]*0.01 )
handle_key[K_w] = lambda k, d: c.set_translation( z = (0.05 if d else 0.) )
handle_key[K_s] = lambda k, d: c.set_translation( z = (-0.05 if d else 0.) )
handle_key[K_a] = lambda k, d: c.set_translation( x = (-0.05 if d else 0.) )
handle_key[K_d] = lambda k, d: c.set_translation( x = (0.05 if d else 0.) )
handle_key[K_p] = lambda k, d: pdb.set_trace()
handle_key[K_UP] = lambda k, d: c.set_rotation( x = (0.01 if d else 0.) )
handle_key[K_DOWN] = lambda k, d: c.set_rotation( x = (-0.01 if d else 0.) )
shutil.copytree(opt['new_planet_dir'], path, symlinks=True)
except(OSError), errstr:
if os.path.exists(path):
msg = "%s planet already exists. Please choose another subdirectory name." % subdir
err.add(msg)
log.info(msg)
return False
err.add("Couldn't create planet: %s" % errstr)
return False
from planet import Planet
if not name: name = 'Planet %s' % subdir
p = Planet({'direc':subdir,
'name':name,
'user':user,
'email':email,
'password':'******',
'feeds':{'http://hackervisions.org/?feed=rss2':{'image':'http://www.softwarefreedom.org/img/staff/vasile.jpg','name':'James Vasile', 'feedurl':'http://hackervisions.org/?feed=rss2'}}
})
p.save()
mopt = dict(opt.items()+p.__dict__.items())
templates.Welcome(mopt).write(path, 'index.html')
log.info("Made planet: %s" % path)
return True
def main():
global Form
pygame.init()
screen = pygame.display.set_mode(size, HWSURFACE|OPENGL|DOUBLEBUF)
pygame.display.set_caption('ARToolKit')
glutInit()
planets = []
dom = parse('planets.xml')
xmlplanets = dom.getElementsByTagName('planet')
for xmlplanet in xmlplanets:
texture = "img/%s" % xmlplanet.getAttribute('texture')
pattern = "Data/%s" % xmlplanet.getAttribute('pattern')
radius = int(xmlplanet.getAttribute('radius'))
planet = Planet(texture, str(pattern), radius)
for moon in xmlplanet.childNodes:
if moon.__class__.__name__ == 'Element':
moon_texture = "img/%s" % moon.getAttribute('texture')
planet.add_moon(Moon(moon_texture))
# if
# for
planets.append(planet)
# for
running = True
while running:
for event in pygame.event.get():
if event.type == QUIT or event.type == KEYDOWN and event.key == K_ESCAPE: running = False
class Game(object):
def __init__(self):
# Global setup
self.screen_w = 640
self.screen_h = 480
self.screen_size = (self.screen_w, self.screen_h)
self.screen = pygame.display.set_mode(self.screen_size)
pygame.display.set_caption('Hero I')
self.clock = pygame.time.Clock()
self.fps = 60
self.planet = Planet(*self.screen_size)
self.player = Player(self.screen_w/2, self.screen_h/2)
self.spider = Monster('spider', 50, 100)
self.slime = Monster('slime', 200, 400)
self.monsters = pygame.sprite.Group(self.spider, self.slime)
self.allsprites = pygame.sprite.Group(self.player, self.monsters)
self.camera = Camera(self.screen_size)
def main_loop(self):
""" This is the Main Loop of the Game. """
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
return None
elif event.type == KEYDOWN:
if event.key in (K_LEFT, K_RIGHT, K_UP, K_DOWN):
self.player.change_speed(event.key, key_down=True)
elif event.key in (K_ESCAPE, K_q):
pygame.event.post(pygame.event.Event(QUIT))
elif event.type == KEYUP:
if event.key in (K_LEFT, K_RIGHT, K_UP, K_DOWN):
self.player.change_speed(event.key, key_down=False)
self.screen.fill(Color('#FF00FF'))
self.player.update()
self.planet.update()
self.camera.update(self.player.center)
for tile, position in self.planet.render(self.player.center):
self.screen.blit(tile, self.camera.apply(position))
for a in self.allsprites:
if a is not self.player:
a.update()
self.screen.blit(a.image, self.camera.apply(a.rect.topleft))
pygame.display.update()
self.clock.tick(self.fps)
