def IntegrateEuler(self, arr):
self.v.x +=(self.f.x/self.mass)*dt
self.x += self.v.x*dt
if fn.collision(self, arr):
self.x -= self.v.x*dt
self.v.x = -self.v.x
self.v.y += (self.f.y/self.mass)*dt
self.y += self.v.y*dt
if fn.collision(self, arr):
self.y -= self.v.y*dt
self.v.y = -self.v.y
def run_game():
d_settings = Settings()
screen = pygame.display.set_mode((d_settings.screen_w, d_settings.screen_h))
screen.fill(d_settings.bg_colour)
car = Car(d_settings, screen)
car2 = Car2(d_settings, screen)
line = Line(screen)
bullets = Group()
drones = []
stats = Stats(d_settings, drones, bullets)
play_button = Button(d_settings, screen, 'start')
pygame.init()
points = PointButton(d_settings, screen, d_settings.points)
#making a Car
pygame.display.set_caption('Rocket Car')
while True:
f.check_events(d_settings, screen, car,car2, bullets, stats, play_button)
if not stats.active:
pygame.mouse.set_visible(True)
d_settings = Settings()
screen = pygame.display.set_mode((d_settings.screen_w, d_settings.screen_h))
screen.fill(d_settings.bg_colour)
car = Car(d_settings, screen)
car2 = Car2(d_settings, screen)
line = Line(screen)
bullets = Group()
drones = []
stats = Stats(d_settings, drones, bullets)
play_button = Button(d_settings, screen, 'start')
f.screen_update(d_settings, screen, car, car2, line, bullets, drones, stats, play_button, points)
if stats.active:
f.make_drones(d_settings, drones, screen)
if stats.two_player:
f.collision(bullets, drones, d_settings, car2)
if len(drones) < 1:
f.create_drone(d_settings, screen, drones)
f.collision(bullets, drones, d_settings, car)
car.update()
car2.update()
bullets.update()
stats.reset()
# delete the old bullets
f.fire_bullets(d_settings, screen,car, bullets)
f.screen_update(d_settings, screen, car, car2, line, bullets, drones, stats, play_button, points)
def eval(self):
if collision(self, self.target):
print("you win")
self.target.ammo += self.ammo
self.target.hp += self.hp
self.vanish()
self.elapsed += 50
if self.elapsed >= self.max_time:
self.vanish()
def stop(self):
if not check_inbound(self.position, self.ventana):
self.timer.stop()
self.image.hide()
else:
for zombie in self.ventana.zombies:
if collision(self, zombie):
zombie.die()
self.ventana.zombies.remove(zombie)
def set_coords(self):
col = True
while col:
x = random.randint(0, 800)
y = random.randint(0, 600)
self.position = (x, y)
col = False
for zombie in self.ventana.zombies:
if collision(self, zombie):
col = True
self.image.setGeometry(self.position[0], self.position[1], self.dim, self.dim)
fontsize="x-large")
plt.subplots_adjust(top=0.92,
bottom=0.08,
left=0.10,
right=0.95,
hspace=0.25,
wspace=0.35)
initial_time = time.time()
i = 1
for t in range(max_iter):
# streaming step
f = functions.streaming(f, width, length, boundry)
# collision step
f, rho, u = functions.collision(f, omega)
if t % 200 == 199:
sys.stdout.write('iteration {}/{}\n'.format(t + 1, max_iter))
ax = plt.subplot(2, 3, i)
ax.set_ylabel("width")
ax.set_xlabel("velocity in x direction")
ax.set_yticks(np.arange(0, width + 1, 5))
im = ax.plot(u[:, 0, 1], np.arange(width))
ax.set_title('Velocity in x direction after {} iteration'.format(t +
1))
i += 1
elapsed_time = time.time() - initial_time
print("elapsed time: ", elapsed_time)
plt.savefig("M4_velocity_evolution_over_time.png")
def update(self, delta_time): #Continuesly updates values
if(self.update == True and self.skip_update == False): # we skip a frame when seaching for shoot possibilites as this takes a long time
if self.slowed:
self.TIME_MULTIPLIER = self.old_TIME_MULTIPLIER
self.slowed = False
else:
if self.satellite.time_to_shoot.value != float("inf"):
self.TIME_MULTIPLIER = int(self.satellite.time_to_shoot.value/10)*2
if self.TIME_MULTIPLIER < 5:
self.TIME_MULTIPLIER = 5
#See if we move too fast for achieving the satellites objective
if(self.satellite.time_to_shoot < delta_time * self.TIME_MULTIPLIER * u.s):
self.old_TIME_MULTIPLIER = self.TIME_MULTIPLIER
self.TIME_MULTIPLIER = (self.satellite.time_to_shoot / delta_time*u.s).value
self.slowed = True
if(self.satellite.time_to_hit < delta_time * self.TIME_MULTIPLIER * u.s):
self.old_TIME_MULTIPLIER = 1# Slow way down when nearing something to hit self.TIME_MULTIPLIER
self.TIME_MULTIPLIER = (self.satellite.time_to_hit / delta_time*u.s).value
self.satellite.time_to_hit = float("inf")*u.s
#self.satellite.give_next_objetive()
self.slowed = True
self.total_time += delta_time * self.TIME_MULTIPLIER #Update total time elapsed
if self.center_option: # when satellite is center of canvas
self.canvas_info[0] = self.satellite.model_x.value * 1000
self.canvas_info[1] = self.satellite.model_y.value * 1000
else: #when earth is center of canvas
self.canvas_info[0] = SCREEN_WIDTH/2
self.canvas_info[1] = SCREEN_HEIGHT/2
if self.satellite.time_to_shoot <= 0: #shoots projectile
shot = self.satellite.get_projectile()
self.projectile_list.append(shot)
self.sprites_list.append(shot)
self.satellite.time_to_shoot = float("inf") * u.s
self.satellite.update(delta_time*self.TIME_MULTIPLIER, self.canvas_info, self.total_time) #update satellite varibles
for member in self.projectile_list: #update projectiles
member.update(delta_time*self.TIME_MULTIPLIER, self.canvas_info)
for member in self.debris_list: #Update debris
member.update(delta_time*self.TIME_MULTIPLIER, self.canvas_info)
for member in self.netted_debris_list: #Update nettet debris
member.update(delta_time*self.TIME_MULTIPLIER, self.canvas_info)
#Check if debris is within the karman line plus the radius of earth
if np.sqrt(member.debris.model_x**2 + member.debris.model_y**2) < 6371*u.km + 100*u.km:
member.kill()
print("Killed netted debris")
self.netted_debris_list.remove(member)
self.earth.update(delta_time*self.TIME_MULTIPLIER, self.canvas_info)
#Test for collisions:
for idx, projectile in enumerate(self.projectile_list):
for idy, debris in enumerate(self.debris_list):
if functions.collision(projectile, debris):
print("Collision detected at X:{}, Y:{}".format(projectile.center_x, projectile.center_y))
self.netted_debris_list.append(Classes.netted_debris(projectile,debris))
self.projectile_list.remove(projectile)
self.debris_list.remove(debris)
self.satellite.give_next_objetive()
self.skip_update = False
