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.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()
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)