def checkUpdate(self):
print("Checking update...")
p1 = Planet(1.0, 1.0, 3.0, 4.0, 5.0, "jupiter.gif")
p1.update(2.0, 1.0, -0.5)
self.checkEquals(7.8, p1.xxPos, "update()", 0.01)
self.checkEquals(8.6, p1.yyPos, "update()", 0.01)
self.checkEquals(3.4, p1.xxVel, "update()", 0.01)
self.checkEquals(3.8, p1.yyVel, "update()", 0.01)
class Game:
def __init__(self, screen, level):
self.screen = screen
self.level = level
self.level_data = ''
self.FPS = 30
self.in_game = True
self.hurled = False
self.__load_level()
self.__create_objects()
self.__load_positions()
self.__game_loop()
##
def __load_level(self):
try:
path = '../data/levels/level_{}.lvl'.format(self.level)
self.level_data = open(path)
self.level_data = self.level_data.read().split('\n')
except:
self.in_game = False
if self.level_data == ['']:
self.in_game = False
def __create_objects(self):
if self.in_game:
self.earth = ''
self.black_hole = ''
self.stars = []
self.neutron_stars = []
def __load_positions(self):
for data in self.level_data:
name, x, y = self.__break_data(data)
if name == 'earth':
self.earth = Planet(x, y)
if name == 'black_hole':
self.black_hole = Black_Hole(x, y)
if name == 'star':
self.stars.append(Star(x, y))
if name == 'neutron_star':
self.neutron_stars.append(Neutron_Star(x, y))
def __break_data(self, data):
data = data.split()
return data[0], int(data[1]), int(data[2])
def __game_loop(self):
while self.in_game:
self.__clear_screen()
self.__check_events()
self.__show()
self.__update()
self.__gravity_interation()
self.__set_fps()
self.__check_game_status()
pygame.display.update()
##
def __check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.in_game = False
if event.type == pygame.MOUSEBUTTONUP:
x, y = event.pos[0], event.pos[1]
if not self.hurled:
self.earth.throw(x, y)
self.hurled = True
if event.type == pygame.KEYDOWN and event.unicode == ' ':
self.__init__(self.screen, self.level)
def __clear_screen(self):
self.screen.fill((10, 0, 20))
def __show(self):
self.earth.show(self.screen)
self.black_hole.show(self.screen)
for star in self.stars:
star.show(self.screen)
for star in self.neutron_stars:
star.show(self.screen)
def __update(self):
self.earth.update()
def __gravity_interation(self):
if self.hurled:
for i in self.stars:
self.earth.gravity(i)
for i in self.neutron_stars:
self.earth.gravity(i)
self.earth.gravity(self.black_hole)
def __set_fps(self):
pygame.time.Clock().tick(self.FPS)
def __check_game_status(self):
if self.earth.contact(self.black_hole):
self.next_level()
return
for i in self.stars:
if self.earth.contact(i):
self.in_game = False
return
for i in self.neutron_stars:
if self.earth.contact(i):
self.in_game = False
return
def next_level(self):
new_level = self.level + 1
self.__init__(self.screen, new_level)
class TestPlanet(unittest.TestCase):
"""
This class contains few basic tests for the planet class.
"""
def setUp(self):
self.mock_planet1 = Planet("Test1", (0, 0, 0), 5, 1, (0, 0))
self.mock_planet2 = Planet("Test2", (0, 0, 0), 5, 1, (0, 0))
def test_get_gravity_force_calc(self):
"""
A simple test to make sure we are calculating correctly the gravitional force
"""
Planet.G = 1
"""
F = (G * m1 * m2) / d ** 2
Direction = (pos1 - pos2 / d) * -1
"""
self.mock_planet2.pos = np.array((0, 5))
self.mock_planet2.mass = 10
"""
In this case we set G = 1
d = 5
m1 = 1
m2 = 10
pos1 = (0, 0)
pos2 = (0, 5)
therefore
F = (1 * 1 * 10) / 5 ** 2 = 0.4
Direction will be = (((0, 0) - (0, 5)) / 5) * -1 = (0, 1)
so final force should be:
F = (0, 1) * 0.4 = (0, 0.4)
"""
force = self.mock_planet1.get_gravity_force(self.mock_planet2)
fx = force[0]
fy = force[1]
self.assertAlmostEqual(fx, 0)
self.assertAlmostEqual(fy, 0.4)
def test_get_gravity_force_rasies(self):
"""
A simple test to see if the right excpetions rasies
for spesific paramters
"""
self.assertRaises(ValueError, self.mock_planet1.get_gravity_force,
None),
self.assertRaises(ZeroDivisionError,
self.mock_planet1.get_gravity_force,
self.mock_planet1)
def test_apply_force_calc(self):
"""
A test to check we are apply force correctly
"""
mock_force = np.array((5, 0))
mock_mass = 1
inital_velocity = np.array((0, 0))
expected_vx, expected_vy = inital_velocity + (mock_force / mock_mass)
self.mock_planet1.mass = mock_mass
self.mock_planet1.velocity = inital_velocity
self.mock_planet1.apply_force(mock_force)
calc_vx, calc_vy = self.mock_planet1.velocity
self.assertAlmostEqual(expected_vx, calc_vx)
self.assertAlmostEqual(expected_vy, calc_vy)
def test_apply_force_rasies(self):
"""
A test to make sure the right exception rasies
"""
self.assertRaises(ValueError, self.mock_planet1.apply_force, None)
def test_update(self):
"""
A test to make sure we are updating the planet position
correctly.
"""
mock_pos = np.array((0, 0))
mock_inital_velocity = np.array((0, 5))
self.mock_planet1.mass = 1
self.mock_planet1.pos = mock_pos
self.mock_planet1.velocity = mock_inital_velocity
expected_px, expected_py = mock_pos + mock_inital_velocity
self.mock_planet1.update()
calc_px, calc_py = self.mock_planet1.pos
self.assertAlmostEqual(expected_px, calc_px)
self.assertAlmostEqual(expected_py, calc_py)
def test_clicked_on(self):
"""
A test to make sure clicked_on is working correctly.
"""
self.assertTrue(self.mock_planet1.clicked_on(np.array((1, 0))))
self.assertFalse(self.mock_planet2.clicked_on(np.array((7, 0))))
class Universe():
def __init__(self, zoom_factor, zoom_speed, max_zoom, min_zoom, resolution,assignment):
print "And God said, 'Let there be light,' and there was light. A new universe was created"
self.stars = self.generate_starfield(8000, resolution[0]*max_zoom*2, resolution[1]*max_zoom*2)
self.rockets = []
self.explosions = []
self.zoom_factor = zoom_factor
self.zoom_speed = zoom_speed
self.min_zoom_factor = min_zoom
self.max_zoom_factor = max_zoom
self.planet = "Not initialized"
self.view_manager = Viewmanager()
self.view_manager.add_view((10,10), (300, 200))
self.init_view = False
self.rocket_shot = False
self.reset_view = False
self.assignment = assignment
self.level=int(1)
self.fuel_used = 0.0
self.can_shoot = False
self.fuel_max = 0.0
if assignment=="RUSSIAN":
self.assignment="Destroy All Russian Satellites"
if assignment=="AMERICAN":
self.assignment="Destroy All American Satellites"
if assignment=="EUROPEAN":
self.assignment="Destroy All European Satellites"
if assignment=="LANDER":
self.assignment="Destroy the Lander(s)"
if assignment=="ROCK":
self.assignment="Destroy All Space Rocks"
if assignment=="ALIEN":
self.assignment="Destroy All Alien Spacecrafts"
def get_zoom_factor(self):
return self.zoom_factor
def create_planet(self, name, mass, radius, rot_speed, sprite):
self.planet = Planet(self, name, mass, radius, rot_speed, (0,0), sprite)
def create_launcher(self, *l):
self.planet.create_launcher(*l)
def create_satellite(self, distance, direction, angle, nationality, name):
self.planet.create_satellite(distance, direction, angle, nationality, name)
def get_planet(self):
return self.planet
def get_can_shoot(self):
return self.can_shoot
def set_can_shoot(self, b):
self.can_shoot = b
def change_level(self,i):
self.level=i
def add_fuel(self, df):
self.fuel_used+=df
def get_fuel_used(self):
return self.fuel_used
def get_fuel_max(self):
return self.fuel_max
def change_fuel_max(self,a):
self.fuel_max=a
def get_all_satellites(self):
return self.planet.get_satellites()
def get_satellites(self):
if self.assignment=="Destroy All Russian Satellites":
return self.planet.get_russian_satellites()
if self.assignment=="Destroy All American Satellites":
return self.planet.get_american_satellites()
if self.assignment=="Destroy All European Satellites" or self.assignment=="Destroy the Lander(s)":
return self.planet.get_european_satellites()
if self.assignment=="Destroy All Space Rocks":
return self.planet.get_rock_satellites()
if self.assignment=="Destroy All Alien Spacecrafts":
return self.planet.get_alien_satellites()
def get_all_satellites(self):
return self.planet.get_satellites()
def get_rockets(self):
return self.rockets
def get_launcher(self):
return self.planet.get_launcher()
def get_assignment(self):
return self.assignment
def launch_rocket(self, pos, dir, angle, initial_speed, rocket_fuel, spr1, spr2):
self.rockets.append(Rocket(self, pos, dir, angle, initial_speed, 1e3, 200e3, rocket_fuel, spr1, spr2))
self.rocket_shot = True
def get_gravity(self, pos):
return self.planet.get_gravity(pos)
def check_collisions(self):
for r in self.rockets:
if check_collision(self.planet.get_pos(), r.get_pos(), self.planet.get_radius()-10):
self.destruct_rocket(r, r)
break
for s in self.planet.get_satellites():
if check_collision(r.get_pos(), s.get_pos(), 20):
self.destruct_rocket(r, s)
self.planet.remove_satellite(s)
break
def destruct_rocket(self, r, object):
self.reset_view = True
r.explode()
self.reset_view = True
self.explosions.append(Explosion(r.get_pos(), 0.04, object.get_nationality()))
self.rockets.remove(r)
self.planet.load_rocket()
def draw(self, screen):
if not self.init_view:
self.view_manager.set_target(0, self.planet.get_launcher(), screen)
self.init_view = True
if self.rocket_shot:
self.view_manager.set_target(0, self.rockets[-1], screen)
self.rocket_shot = False
if self.reset_view:
self.view_manager.set_target(0, self.get_launcher(), screen)
self.reset_view = False
if pygame.mouse.get_pressed()[2]:
for satellite in self.planet.get_satellites():
s_pos = to_ints(to_screen(scale_pos(satellite.get_pos(), self.zoom_factor)))
if get_distance_between(s_pos, pygame.mouse.get_pos()) < 30*self.zoom_factor:
self.view_manager.set_target(0, satellite, screen)
for rocket in self.planet.get_rockets():
rocket_pos = to_ints(to_screen(scale_pos(rocket.get_pos(), self.zoom_factor)))
if get_distance_between(rocket_pos, pygame.mouse.get_pos()) < 30*self.zoom_factor:
self.view_manager.set_target(0, rocket, screen)
launcher = self.get_launcher()
launcher_pos = to_ints(to_screen(scale_pos(launcher.get_pos(), self.zoom_factor)))
if get_distance_between(launcher_pos, pygame.mouse.get_pos()) < 30*self.zoom_factor:
self.view_manager.set_target(0, launcher, screen)
planet_pos = to_ints(to_screen(scale_pos(self.planet.get_pos(), self.zoom_factor)))
if get_distance_between(planet_pos, pygame.mouse.get_pos()) < 30*self.zoom_factor:
self.view_manager.set_target(0, self.planet, screen)
self.draw_stars(screen, self.stars)
self.planet.draw(screen, self.zoom_factor)
for rocket in self.rockets:
rocket.draw(screen, self.zoom_factor)
for explosion in self.explosions:
explosion.draw(screen, self.zoom_factor)
self.view_manager.draw(screen, self.planet, self.rockets, 1.25)
def draw_stars(self, screen, list):
resolution = (screen.get_rect().width, screen.get_rect().height)
i=0
for pos in list:
i+=1
if(i%3)==0:
draw_pos = to_screen(scale_pos(pos, self.zoom_factor))
if draw_pos[0] > -10 and draw_pos[0] < resolution[0]+10 and\
draw_pos[1] > -10 and draw_pos[1] < resolution[1]+10:
pygame.gfxdraw.filled_circle(screen, int(draw_pos[0]), int(draw_pos[1]), 1, (200,0,0))
if(i%3)==1:
draw_pos = to_screen(scale_pos(pos, self.zoom_factor))
if draw_pos[0] > -10 and draw_pos[0] < resolution[0]+10 and\
draw_pos[1] > -10 and draw_pos[1] < resolution[1]+10:
pygame.gfxdraw.filled_circle(screen, int(draw_pos[0]), int(draw_pos[1]), 1, (0,0,200))
if(i%3)==2:
draw_pos = to_screen(scale_pos(pos, self.zoom_factor))
if draw_pos[0] > -10 and draw_pos[0] < resolution[0]+10 and\
draw_pos[1] > -10 and draw_pos[1] < resolution[1]+10:
pygame.gfxdraw.filled_circle(screen, int(draw_pos[0]), int(draw_pos[1]), 1, (255,255,255))
def update(self, dt):
self.check_collisions()
self.planet.update(dt)
for rocket in self.rockets:
rocket.update(dt)
for explosion in self.explosions:
explosion.update(dt)
if explosion.is_done():
self.explosions.remove(explosion)
def pass_event(self, event):
if event.type == pygame.MOUSEBUTTONDOWN:
if event.button == 4:
self.zoom_factor *= self.zoom_speed
if self.zoom_factor > self.max_zoom_factor:
self.zoom_factor = self.max_zoom_factor
if event.button == 5:
self.zoom_factor /= self.zoom_speed
if self.zoom_factor < self.min_zoom_factor:
self.zoom_factor = self.min_zoom_factor
self.planet.pass_event(event)
for rocket in self.rockets:
rocket.pass_events(event)
def generate_starfield(self, n, width, height):
star_list = []
for i in xrange(n):
tempX = random.randrange(-width, width, 1)
tempY = random.randrange(-height, height, 1)
pos = (int(tempX), int(tempY))
star_list.append(pos)
return star_list
