def load_level2(app):
'''(App) -> NoneType
...'''
BLUE = (0, 0, 255)
MOON1_ORBIT, MOON1_RADIUS = 1, 15
MOON2_ORBIT, MOON2_RADIUS = 3, 20
ASTEROID1_STARTX, ASTEROID1_STARTY, ASTEROID1_RADIUS = 100, 0, 12
ASTEROID2_STARTX, ASTEROID2_STARTY, ASTEROID2_RADIUS = 780, 800, 12
ASTEROID3_STARTX, ASTEROID3_STARTY, ASTEROID3_RADIUS = 780, 400, 12
PLANET_RADIUS = 50
app.num_orbits = 3
app.planet = Planet(BLUE, app.level_center, PLANET_RADIUS)
app.moons.append(Moon(MOON1_ORBIT, MOON1_RADIUS))
app.moons.append(Moon(MOON2_ORBIT, MOON2_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID1_STARTX, ASTEROID1_STARTY, ASTEROID1_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID2_STARTX, ASTEROID2_STARTY, ASTEROID2_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID3_STARTX, ASTEROID3_STARTY, ASTEROID3_RADIUS))
app.asteroids_ingame = app.asteroids.copy()
def setUp(self) -> None:
self.moons = [
Moon(-1, 0, 2),
Moon(2, -10, -7),
Moon(4, -8, 8),
Moon(3, 5, -1),
]
def test_part_1(self):
moons = [
Moon(-9, 10, -1),
Moon(-14, -8, 14),
Moon(1, 5, 6),
Moon(-19, 7, 8),
]
self.assertEqual(main_part_1(moons), 8538)
def test_phobos_rise_and_set_before_deimos(self):
"""
Phobos |---------|
Deimos |---------|
Overlap X
"""
phobos, deimos = Moon(1, 0, 2, 0, 'Phobos'), Moon(3, 0, 4, 0, 'Deimos')
self.assertEqual(phobos.calculate_overlap_time(deimos), 0)
def test_get_cycle_times(self):
moons = [
Moon(-9, 10, -1),
Moon(-14, -8, 14),
Moon(1, 5, 6),
Moon(-19, 7, 8),
]
self.assertEqual(get_cycle_times(moons), [161428, 231614, 108344])
def test_phobos_rise_before_deimos_phobos_set_after_deimos(self):
"""
Phobos |---------|
Deimos |---|
Overlap |---|
"""
phobos, deimos = Moon(1, 0, 4, 0, 'Phobos'), Moon(2, 0, 3, 0, 'Deimos')
self.assertEqual(phobos.calculate_overlap_time(deimos), 100)
def test_main_1(self):
moons = [
Moon(-8, -10, 0),
Moon(5, 5, 10),
Moon(2, -7, 3),
Moon(9, -8, -3),
]
post_run_moons = run_time(moons, 100)
self.assertEqual(total_energy(post_run_moons), 1940)
def test_deimos_set_at_same_time_as_phobos_rise(self):
"""
Phobos |----|
Deimos |----|
Overlap |
"""
phobos, deimos = Moon(11, 0, 12, 0,
'Phobos'), Moon(12, 0, 13, 0, 'Deimos')
self.assertEqual(phobos.calculate_overlap_time(deimos), 1)
def test_deimos_set_at_same_time_as_phobos_rise_midnight(self):
"""
Zero |
Phobos |----|
Deimos |----|
Overlap |
"""
phobos, deimos = Moon(24, 0, 0, 0,
'Phobos'), Moon(0, 0, 1, 0, 'Deimos')
self.assertEqual(phobos.calculate_overlap_time(deimos), 1)
def test_deimos_and_phobos_overlap_two_times(self):
"""
Zero |
Phobos ------| |-------
Deimos |-----------|
Overlap |--| + |--|
"""
phobos, deimos = Moon(15, 0, 7, 0,
'Phobos'), Moon(4, 0, 16, 0, 'Deimos')
self.assertEqual(phobos.calculate_overlap_time(deimos), 400)
def test_phobos_rise_after_deimos_deimos_set_after_phobos_deimos_and_phobos_set_after_midnight(
self):
"""
Zero |
Phobos |----|
Deimos |---------|
Overlap |----|
"""
phobos, deimos = Moon(22, 0, 2, 0,
'Phobos'), Moon(23, 0, 1, 0, 'Deimos')
self.assertEqual(phobos.calculate_overlap_time(deimos), 300)
def send_command():
phobos = Moon(int(input_phobos_rise_hour.get()),
int(input_phobos_rise_minute.get()),
int(input_phobos_set_hour.get()),
int(input_phobos_set_minute.get()), 'Phobos')
deimos = Moon(int(input_deimos_rise_hour.get()),
int(input_deimos_rise_minute.get()),
int(input_deimos_set_hour.get()),
int(input_deimos_set_minute.get()), 'Deimos')
overlap = phobos.calculate_overlap_time(deimos)
return_label.config(text="Overlaping time: " + str(overlap) + " min")
def set_date(self, adate):
self.adate = adate
self.label.set_text(str(adate.day))
self.moon = Moon(adate)
self.image.set_from_pixbuf(
GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(comun.IMAGESDIR, self.moon.image()), 60, 60))
def __init__(self, infile_coords='GWsky_coords'):
"""Creating a class in which the instance attributes are based on the dictionary
"GWsky_coords" by default. GWsky_coords is created and pickled by the "user_values"
module and will be deleted when the "ShowSkyCoverageGUI" will be closed.
It contains the keys: "ra", "dec". ra and dec represents the central location of a FoV.
Starting sky coordinates:
self.input_ra: right ascension [deg]
self.input_dec: declination [deg]
"""
self.infile_coords = infile_coords
self.entries_GWsky_new = [] # new entries during the FoV sequence
self.user = UserValues() # compositions
self.lvc = LVCskymap()
self.query = Query()
self.airmass = Airmass()
self.moon = Moon()
with open(infile_coords, 'rb') as data:
coords_GWsky = pickle.load(data)
for k, v in coords_GWsky.items():
setattr(self, k, v)
def testSatellite(self):
distance: float = 17
orbits: str = "Mars"
satellite: Moon = Moon(distance, orbits, 3, "black")
self.assertEqual(satellite.distance, distance)
self.assertEqual(satellite.orbits, orbits)
def main():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height)) #,RESIZABLE)
pygame.display.set_caption("Alien Invasion")
play_button = Button(ai_settings, screen, "Play")
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
ship = Ship(ai_settings, screen)
moon = Moon(ai_settings, screen)
earth = Earth(ai_settings, screen)
stars = Group()
bullets = Group()
aliens = Group()
gf.create_fleet(ai_settings, screen, ship, aliens)
gf.create_multilayer_star(ai_settings, screen, stars)
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_aliens(ai_settings, stats, sb, screen, ship, aliens,
bullets)
stats.update_highscore()
gf.update_screen(ai_settings, screen, stats, stars, sb, [moon, earth],
[ship], play_button, aliens, bullets)
def testDefaultMoon(self):
size : int = 3
color : str = "blue"
phase : int = 0
moon : Moon = Moon(size, color, phase)
self.assertEqual(moon.phase,phase)
self.assertEqual(moon.color,color)
self.assertEqual(moon.size,size)
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, datas):
self.__moons = []
r = r"^<x=(?P<x>-?\d+), y=(?P<y>-?\d+), z=(?P<z>-?\d+)>$"
for data in datas:
match = re.match(r, data)
self.__moons.append(
Moon(int(match.group("x")), int(match.group("y")),
int(match.group("z"))))
def testDefaultMoon(self):
distance: float = 17
orbits: str = "Mars"
size: int = 3
color: str = "blue"
phase: int = 0
moon: Moon = Moon(distance, orbits, size, color, phase)
self.assertEqual(moon.phase, phase)
self.assertEqual(moon.color, color)
self.assertEqual(moon.size, size)
def test():
moons = [
Moon(p) for p in ((-1, 0, 2), (2, -10, -7), (4, -8, 8), (3, 5, -1))
]
simulate(moons, 10)
assert sum([moon.energy()[2] for moon in moons]) == 179
vpos, vvel = ([2, 1, -3], [1, -8, 0], [3, -6, 1],
[2, 0, 4]), ([-3, -2, 1], [-1, 1, 3], [3, 2,
-3], [1, -1, -1])
for i in range(4):
assert vpos[i] == moons[i].pos and vvel[i] == moons[i].vel
moons = [
Moon(p) for p in ((-8, -10, 0), (5, 5, 10), (2, -7, 3), (9, -8, -3))
]
simulate(moons, 100)
assert sum([moon.energy()[2] for moon in moons]) == 1940
assert part2(((-1, 0, 2), (2, -10, -7), (4, -8, 8), (3, 5, -1))) == 2772
assert part2(
((-8, -10, 0), (5, 5, 10), (2, -7, 3), (9, -8, -3))) == 4686774924
def set_date(self, adate):
self.adate = adate
self.label.set_text(str(adate.day))
self.moon = Moon(adate)
# phasename = self.moon.phase()
# i = adate.day
# roundedpos = round(float(self.moon.position()), 3)
self.image.set_from_pixbuf(
GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(comun.IMAGESDIR, self.moon.image()), 60, 60))
def load_level3(app):
'''(App) -> NoneType
...'''
GREEN = (0, 255, 0)
MOON1_ORBIT, MOON1_RADIUS = 1, 20
MOON2_ORBIT, MOON2_RADIUS = 2, 10
MOON3_ORBIT, MOON3_RADIUS = 3, 15
MOON4_ORBIT, MOON4_RADIUS = 5, 15
ASTEROID1_STARTX, ASTEROID1_STARTY, ASTEROID1_RADIUS = 100, 100, 12
ASTEROID2_STARTX, ASTEROID2_STARTY, ASTEROID2_RADIUS = 680, 800, 12
ASTEROID3_STARTX, ASTEROID3_STARTY, ASTEROID3_RADIUS = 780, 400, 12
ASTEROID4_STARTX, ASTEROID4_STARTY, ASTEROID4_RADIUS = 400, 50, 12
ASTEROID5_STARTX, ASTEROID5_STARTY, ASTEROID5_RADIUS = 0, 400, 12
ASTEROID6_STARTX, ASTEROID6_STARTY, ASTEROID6_RADIUS = 780, 0, 12
PLANET_RADIUS = 50
app.num_orbits = 5
app.planet = Planet(GREEN, app.level_center, PLANET_RADIUS)
app.moons.append(Moon(MOON1_ORBIT, MOON1_RADIUS))
app.moons.append(Moon(MOON2_ORBIT, MOON2_RADIUS))
app.moons.append(Moon(MOON3_ORBIT, MOON3_RADIUS))
app.moons.append(Moon(MOON4_ORBIT, MOON4_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID1_STARTX, ASTEROID1_STARTY, ASTEROID1_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID2_STARTX, ASTEROID2_STARTY, ASTEROID2_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID3_STARTX, ASTEROID3_STARTY, ASTEROID3_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID4_STARTX, ASTEROID4_STARTY, ASTEROID4_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID5_STARTX, ASTEROID5_STARTY, ASTEROID5_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID6_STARTX, ASTEROID6_STARTY, ASTEROID6_RADIUS))
app.asteroids_ingame = app.asteroids.copy()
def testCycle(self):
size : int = 3
color : str = "samantha"
phase : int = 2
moon : Moon = Moon(size, color, phase)
self.assertEqual(moon.phase,phase)
self.assertEqual(moon.color,color)
self.assertEqual(moon.size,size)
moon.color = "white"
if moon.phase == 2:
print("half moon")
moon.cycle()
self.assertEqual(moon.phase,phase+1)
def part2(vals: list) -> int:
dims = [0, 0, 0]
for i in range(3):
moons = [Moon(val) for val in vals]
oPos = [moon.pos[i] for moon in moons]
while True:
simulate(moons)
dims[i] += 1
if [moon.pos[i] for moon in moons] == oPos and \
[moon.vel[i] for moon in moons] == [0, 0, 0, 0]:
break
return lcm(dims[0], lcm(dims[1], dims[2]))
def testCycle(self):
distance: float = 17
orbits: str = "Mars"
size: int = 3
color: str = "samantha"
phase: int = 2
moon: Moon = Moon(distance, orbits, size, color, phase)
self.assertEqual(moon.phase, phase)
self.assertEqual(moon.color, color)
self.assertEqual(moon.size, size)
moon.color = "white"
if moon.phase == 2:
print("half moon")
moon.cycle()
self.assertEqual(moon.phase, phase + 1)
def run_game():
pygame.init()
pygame.mixer.music.load('music/Phantom from Space.mp3')
pygame.mixer.music.play(-1)
pygame.mixer.music.set_volume(0.5)
sw_settings = Settings()
screen = pygame.display.set_mode(
(sw_settings.screen_width, sw_settings.screen_height))
pygame.display.set_caption("Earth's Defender")
earth = Earth(sw_settings, screen)
moon = Moon(sw_settings, screen)
sun = Sun(sw_settings, screen)
play_button = Button(sw_settings, screen, "Play")
pause_message = PauseMessage(sw_settings, screen, "Pause")
game_stats = GameStats(sw_settings)
scoreboard = Scoreboard(sw_settings, screen, game_stats)
ship = Ship(sw_settings, screen)
alien_boss = AlienBoss(sw_settings, screen)
bullets = Group()
aliens = Group()
aliens_bullets = Group()
asteroids = Group()
gf.create_fleet(sw_settings, screen, ship, aliens)
while True:
gf.check_events(sw_settings, screen, game_stats, scoreboard,
play_button, pause_message, ship, aliens, bullets,
aliens_bullets, asteroids)
if game_stats.game_active and game_stats.game_pause:
ship.update()
gf.update_bullets(sw_settings, screen, game_stats, scoreboard,
ship, aliens, bullets, aliens_bullets, asteroids,
alien_boss)
gf.update_aliens(sw_settings, game_stats, scoreboard, screen, ship,
aliens, bullets, aliens_bullets, asteroids)
gf.check_alien_fires(sw_settings, screen, aliens, aliens_bullets)
gf.update_aliens_bullets(sw_settings, game_stats, scoreboard,
screen, ship, aliens, bullets,
aliens_bullets, asteroids)
gf.check_asteroid_fall(sw_settings, screen, asteroids)
gf.update_asteroids(sw_settings, game_stats, scoreboard, screen,
ship, aliens, bullets, aliens_bullets,
asteroids)
gf.update_alien_boss(sw_settings, screen, game_stats, alien_boss,
aliens, aliens_bullets, bullets, asteroids)
gf.update_screen(sw_settings, screen, earth, moon, sun, game_stats,
scoreboard, ship, aliens, bullets, aliens_bullets,
asteroids, play_button, pause_message, alien_boss)
def find_loop(self):
initial_state = [Moon(*m.position) for m in self.__moons]
axe_infos = []
for axe in range(3):
previous_state = []
current_state = self.get_state_for_axe(axe)
i = 0
while current_state not in previous_state:
previous_state.append(current_state)
self.update_axe(axe)
i += 1
current_state = self.get_state_for_axe(axe)
axe_infos.append(i - previous_state.index(current_state))
print(axe_infos)
return axe_infos
def find_period(raw_data):
moons = [Moon(line) for line in raw_data]
x_calculator = MoonsPeriodCalculator(lambda m: f"{m.p.x}:{m.v.x}", moons)
y_calculator = MoonsPeriodCalculator(lambda m: f"{m.p.y}:{m.v.y}", moons)
z_calculator = MoonsPeriodCalculator(lambda m: f"{m.p.z}:{m.v.z}", moons)
x_period = None
y_period = None
z_period = None
while True:
step(moons)
x_period = x_calculator.next(moons)
y_period = y_calculator.next(moons)
z_period = z_calculator.next(moons)
if (x_period is not None) and (y_period is not None) and (z_period
is not None):
break
return np.lcm.reduce([x_period, y_period, z_period])
def load_level1(app):
'''(App) -> NoneType
...'''
RED = (255, 0, 0)
MOON1_ORBIT, MOON1_RADIUS = 1, 20
ASTEROID1_STARTX, ASTEROID1_STARTY, ASTEROID1_RADIUS = 0, 0, 12
PLANET_RADIUS = 50
app.num_orbits = 1
app.planet = Planet(RED, app.level_center, PLANET_RADIUS)
app.moons.append(Moon(MOON1_ORBIT, MOON1_RADIUS))
app.asteroids.append(
Asteroid(ASTEROID1_STARTX, ASTEROID1_STARTY, ASTEROID1_RADIUS))
app.asteroids_ingame = app.asteroids.copy()
