Как сделать так что бы пули летели туда куда смотрит корабль

import math
import random
import pygame
from pygame.locals import *
 
WINDOW_W = 800
WINDOW_H = 640
 
class Sprite():
def __init__(self, x, y, filename):
self.bitmap = pygame.image.load(filename)
self.rect = self.bitmap.get_rect()
self.rect.x = x
self.rect.y = y
self.x = x
self.y = y
 
def render(self, screen):
screen.blit(self.bitmap, self.rect)
 
class Bullet(Sprite):
def __init__(self, x, y, filename, parent):
super(Bullet, self).__init__(x, y, filename)
self.dmg = 50
self.speed = 20
self.parent = parent
def collide(self, enemies):
for enemy in pygame.sprite.spritecollide(self, enemies, None):
if enemy.hp > 0:
enemy.damage(self.dmg)
self.parent.del_bullet(self)
if enemy.hp == 0: self.parent.points += 1
def move(self, enemies):
self.rect.y -= self.speed
if self.rect.y < 0:
self.parent.del_bullet(self)
self.collide(enemies)
 
SPEED = 6
class Player(Sprite):
def __init__(self, x, y, filename, parent, width, height, hp):
self.bitmap = pygame.image.load(filename)
self.rect = self.bitmap.get_rect()
self.rect.x = x
self.rect.y = y
self.x = x
self.y = y
self.hp = hp
self.points = 0
self.parent = parent
self.set_target = False
self.in_move = False
self.angle = 0
self.r_speed = 4
self.target = None
self.effect = pygame.mixer.Sound('laser.ogg')
self.W = width
self.H = height
self.vx = 0
self.vy = 0
self.left = False
self.right = False
self.up = False
self.down = False
self.image = self.bitmap
self.bullets = []
 
self.font = pygame.font.Font(None, 50)
self.text = self.font.render('Очков: '+str(self.points), True, (255, 0, 0))
def rotate(self, target): # ( )
x_ = self.rect.x+self.rect.width/2
y_ = self.rect.y+self.rect.height/2
dx = x_ - target[0]
dy = y_ - target[1]
dist = math.sqrt(dx**2+dy**2)
if dist != 0:
new_angle = math.acos(dy/dist)*180/math.pi
if dx != 0:
new_angle *= abs(dx)/dx
 
font = pygame.font.Font(None, 40)
self.text = font.render(str(new_angle), True, (255, 0, 0))
 
d_angle = self.angle - new_angle
d2_angle = 360 - d_angle
 
if self.angle - new_angle > 5:
if self.angle - new_angle < 180:
self.angle -= self.r_speed
else:
self.angle += self.r_speed
elif self.angle - new_angle < -5:
if self.angle - new_angle > -180:
self.angle += self.r_speed
else:
self.angle -= self.r_speed
 
if self.angle > 180: self.angle = -180
if self.angle < -180: self.angle = 180
 
old_center = self.bitmap.get_rect().center
self.image = pygame.transform.rotate(self.bitmap, self.angle)
self.rect = self.image.get_rect()
self.rect.center = old_center
self.rect.x += self.x
self.rect.y += self.y
 
def set_control(self, parent):
self.parent = parent
def del_bullet(self, item):
if item in self.bullets:
i = self.bullets.index(item)
del self.bullets[i]
def fire(self, image):
 
self.effect.play(0)
bullet = Bullet(self.rect.x+self.W/2, self.rect.y+self.H/2, image, self)
self.bullets.append(bullet)
def collide(self, enemies):
for enemy in pygame.sprite.spritecollide(self, enemies, None):
if enemy.hp > 0:
enemy.damage(enemy.hp)
self.damage(20)
def damage(self, dmg):
if dmg >= self.hp:
self.parent.game_over()
self.hp = 0
else:
self.hp -= dmg
def move(self, enemies):
if self.set_target: #
target = self.target #
self.in_move = True
else:
target = pygame.mouse.get_pos() # - ( )
 
self.rotate(target) #
 
self.center_x = self.rect.x+self.rect.width/2 #
self.center_y = self.rect.y+self.rect.height/2
# 50 ( )
if math.sqrt((self.center_x-target[0])**2 + (self.center_y-target[1])**2) < 50:
self.in_move = False #
self.vx = 0
self.vy = 0
self.set_target = False
if self.left:
if self.rect.x > 0: self.vx = -SPEED
else: self.vx = 0
 
if self.right:
if
 
self.rect.x+self.W < WINDOW_W: self.vx = SPEED
else: self.vx = 0
 
if self.up:
if self.rect.y > 0: self.vy = -SPEED
else: self.vy = 0
 
if self.down:
if self.rect.y+self.H < WINDOW_H: self.vy = SPEED
else: self.vy = 0
 
if not (self.left or self.right): self.vx = 0
 
if not (self.up or self.down): self.vy = 0
 
self.x += self.vx
self.y += self.vy
 
for bullet in self.bullets:
bullet.move(enemies)
 
self.collide(enemies)
 
def render(self, screen):
rect = Rect((10, 10), (self.hp*5, 30))
pygame.draw.rect(screen, (255, 0, 0), rect, 0)
 
self.text = self.font.render('Очков: '+str(self.points), True, (0, 255, 0))
screen.blit(self.text, (10, 40))
 
for bullet in self.bullets:
bullet.render(screen)
screen.blit(self.image, self.rect)
 
class Animation():
def __init__(self, sprites, time=100):
self.sprites = sprites
self.time = time
self.work_time = 0
self.skip_frame = 0
self.frame = 0
def update(self, dt):
self.work_time += dt
self.skip_frame = self.work_time // self.time
if self.skip_frame > 0:
self.work_time = self.work_time % self.time
self.frame += self.skip_frame
if self.frame >= len(self.sprites):
self.frame = 0
def get_sprite(self):
return self.sprites[self.frame]
 
class Animation_damage(Animation):
def __init__(self, sprites, anim_time):
super(Animation_damage, self).__init__(sprites, anim_time)
self.anim_time = anim_time
# self.worked = 0
self.on_damage = False
def set_parent(self, parent):
self.parent = parent
def anim(self, dt):
if self.on_damage:
if self.frame < len(self.sprites)-1:#self.worked < self.anim_time*len(self.sprites):
self.update(dt)
#self.worked += dt
else:
#self.worked = 0
self.on_damage = False
self.frame = 0
if self.parent.hp == 0:
self.parent.parent.del_ship(self.parent)
def get_sprite(self):
return self.sprites[self.frame]
 
class Death_sprite(Sprite):
def __init__(self, x, y, w, h, filename, parent):
super(Death_sprite, self).__init__(x, y, filename)
self.surface = pygame.Surface((w, h))
self.surface.set_colorkey((0, 0, 0))
self.alpha = 255
self.parent = parent
def render(self, screen):
self.surface.set_alpha(self.alpha)
self.alpha -= 3
self.surface.fill((0, 0, 0))
self.surface.blit(self.bitmap, (0, 0))
screen.blit(self.surface, self.rect)
if self.alpha <= 0:
self.parent.del_sprite(self)
 
class Enemy(Sprite):
def __init__(self, x, y, w, h, filename, hp, damage_anim, parent):
super(Enemy, self).__init__(x, y, filename)
self.W = w
self.H = h
self.hp = hp
self.anim = damage_anim
self.parent = parent
self.effect = pygame.mixer.Sound('crash.wav')
def die(self):
self.parent.del_ship(self)
def set_speed(self, vx, vy):
self.vx = vx
self.vy = vy
def move(self, dt):
if self.rect.x < 0: self.vx = -self.vx
 
if self.rect.x+self.W > WINDOW_W: self.vx = -self.vx
 
if self.rect.y > WINDOW_H: self.die()
 
self.rect.x += self.vx
self.rect.y += self.vy
 
self.anim.anim(dt)
 
def damage(self, dmg):
self.effect.play()
self.anim.on_damage = True
if dmg >= self.hp:
self.vx = 0
self.vy = 0
self.parent.add_sprite(Death_sprite(self.rect.x, self.rect.y, 50, 38, 'crash.png', self.parent))
self.hp = 0
else:
self.hp -= dmg
 
def render(self, screen):
if self.hp > 0:
screen.blit(self.bitmap, self.rect)
if self.anim.on_damage:
screen.blit(self.anim.get_sprite(), self.rect)
 
 
class Wave():
TYPES = (('enemy1.png', 50, (47, 42)), ('enemy2.png', 100, (52, 42)), ('enemy3.png', 300, (41, 42)))
def __init__(self, parent, n, type, offset_x, offset_y, vx, vy):
self.music = pygame.mixer.Sound('wave1.wav')
self.music.play(-1)
self.parent = parent
self.enemies = []
self.sprites = []
file = Wave.TYPES[type][0]
hp = Wave.TYPES[type][1]
w = Wave.TYPES[type][2][0]
h = Wave.TYPES[type][2][1]
 
anim_sprite = pygame.image.load('explosive.png')
death_sprite = pygame.image.load('crash.png')
images = []
for i in range(2):
for j in range(4):
images.append(anim_sprite.subsurface((j*52, i*52, 52,
 
52)))
 
for i in range(n):
damage_anim = Animation_damage(images, 100)
self.enemies.append(Enemy(i*w+i*offset_x, i*offset_y-n*offset_y, w, h, file, hp, damage_anim, self))
self.enemies[i].set_speed(vx, vy)
damage_anim.set_parent(self.enemies[i])
 
def add_sprite(self, sprite):
self.sprites.append(sprite)
def del_sprite(self, death_sprite):
if death_sprite in self.sprites:
i = self.sprites.index(death_sprite)
del self.sprites[i]
def del_ship(self, enemy):
i = self.enemies.index(enemy)
del self.enemies[i]
 
def loop(self, dt):
if not self.enemies and not self.sprites:
self.parent.next_wave()
else:
for enemy in self.enemies:
enemy.move(dt)
def render(self, screen):
for enemy in self.enemies:
enemy.render(screen)
for sprite in self.sprites:
sprite.render(screen)
 
class App(): #управляющий приложением класс
def __init__(self):
self.running = True
self.window = None
self.clock = pygame.time.Clock()
self.fps = 60
self.dt = self.clock.tick(self.fps)
self.w_size = (WINDOW_W, WINDOW_H)
self.waves = []
self.stop = False
 
def on_init(self):
pygame.mixer.pre_init(44100, -16, 2, 2048)
pygame.init()
self.window = pygame.display.set_mode(self.w_size)
pygame.display.set_caption('TEST')
self.running = True
self.screen = pygame.Surface(self.w_size)
self.background = Sprite(0, 0, 'background.png')
self.player = Player(WINDOW_W/2, WINDOW_H/2, 'player.png',self, 46, 102, 100)
self.player.set_control(self)
 
self.waves.append(Wave(self, 7, 0, 20, 30, 6, 1))
self.waves.append(Wave(self, 5, 1, 100, 0, 0, 2))
self.waves.append(Wave(self, 2, 2, 100, 50, -4, 1))
 
self.current_wave = self.waves[0]
self.k = 0
 
self.font = pygame.font.Font(None, 100)
 
def game_over(self):
self.font = pygame.font.Font(None, 100)
#pygame.mixer.stop()
self.stop = True
def next_wave(self):
self.k += 1
if self.k < len(self.waves):
self.current_wave = self.waves[self.k]
def on_event(self, event):
#отслеживание событийa
if event.type == pygame.QUIT:
self.running = False
if event.type == pygame.KEYUP:
if event.key == pygame.K_a:
self.player.left = False
if event.key == pygame.K_d:
self.player.right = False
if event.key == pygame.K_w:
self.player.up = False
if event.key == pygame.K_s:
self.player.down = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_a:
self.player.left = True
if event.key == pygame.K_d:
self.player.right = True
if event.key == pygame.K_w:
self.player.up = True
if event.key == pygame.K_s:
self.player.down = True
if event.key == pygame.K_SPACE:
self.player.fire('laser.png')
 
def on_loop(self):
if not self.stop:
self.current_wave.loop(self.dt)
self.player.move(self.current_wave.enemies)
#игровые вычисления в цикле
def on_render(self):
#рисование объектов
self.draw_background()
self.current_wave.render(self.screen)
self.player.render(self.screen)
if self.stop:
self.text = self.font.render('GAME OVER', True, (255, 0, 0))
self.screen.blit(self.text, (200, 200))
pygame.display.flip()
def on_cleanup(self):
#завершение работы программы
pygame.quit()
 
def draw_background(self):
self.window.blit(self.screen, (0, 0))
self.background.render(self.screen)
 
def on_execute(self):
if self.on_init() == False:
self.running = False
 
pygame.key.set_repeat(1, 500)
while (self.running):
for event in pygame.event.get():
self.on_event(event)
self.on_loop()
self.on_render()
self.dt = self.clock.tick(self.fps)
self.on_cleanup()
 
def main():
theApp = App()
theApp.on_execute()
 
main()