Exemple #1
0
class Ship:
    def __init__(self, pos):
        self.pos = Vector(pos)
        self.image = pygame.Surface((40, 40), pygame.SRCALPHA)
        # self.copyimage = self.image.copy()
        self.speed = Vector((0, 0))
        self.angle_speed = 5
        self.state = NORMAL
        self.direction = Vector((1, 0))

        self.draw()

    def events(self, event):
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                self.state = TURN_LEFT
            if event.key == pygame.K_RIGHT:
                self.state = TURN_RIGHT
            if event.key == pygame.K_DOWN:
                self.state = SLOW
            if event.key == pygame.K_UP:
                self.state = FAST
            if event.key == pygame.K_ESCAPE:
                sys.exit()
        if event.type == pygame.KEYUP:
            self.state = NORMAL

    def update(self):
        if self.pos.x > Display[0]:
            self.pos = Vector((-50, self.pos.y))
        if self.pos.y > 850:
            self.pos = Vector((self.pos.x, -50))
        if self.pos.y < -50:
            self.pos = Vector((self.pos.x, 850))
        if self.pos.x < -50:
            self.pos = Vector((850, self.pos.y))

        if self.state == TURN_LEFT:
            self.speed.rotate(-self.angle_speed)
            # (Так не надо)self.image = pygame.transform.rotate(self.copyimage, self.angle + Angle)

        if self.state == TURN_RIGHT:
            self.speed.rotate(self.angle_speed)

        if self.state == FAST:
            if self.speed.len() == 0:
                self.speed = self.direction
            self.speed = self.speed + self.speed.normalize()
        if self.speed.len() == 0:
            return

        if self.state == SLOW:
            if self.speed.len() < 1:
                self.direction = self.speed
                self.speed = Vector((0, 0))

            else:
                self.speed = self.speed - self.speed.normalize()

        self.pos += self.speed

    def draw(self):
        pygame.draw.lines(self.image, (0, 0, 200), False, [(35, 20), (20, 15), (0, 0), (0, 40), (20, 25), (35, 20)])

    def render(self, screen):
        r = Vector(self.image.get_rect().center)  # r - центр фигуры для вектора направления
        rotate_image = pygame.transform.rotate(self.image, self.speed.angle)
        origin_rect = self.image.get_rect()
        rotate_rect = rotate_image.get_rect()
        rotate_rect.center = origin_rect.center
        rotate_rect.move_ip(self.pos.as_point())
        screen.blit(rotate_image, rotate_rect)
        pygame.draw.line(screen, (200, 255, 200), (self.pos + r).as_point(),
                         (self.pos + self.speed * 20 + r).as_point())
        pygame.draw.lines(self.image, (0, 0, 200), False, [(35, 20), (20, 15), (0, 0), (0, 40), (20, 25), (35, 20)])
Exemple #2
0
class Ship:
    def __init__(self, pos):
        # self.w = 45
        # self.h = 40
        self.rotate_speed = 5
        self.state = NORMAL
        self.pos = Vector(pos)
        self.image = pygame.Surface((45, 40), pygame.SRCALPHA)
        self.speed = Vector((0, 0))
        self.normal_speed = Vector((1, 0))  # Скорость и направление, сохраняемые при полном торможении
        self.max_speed = 10

    def events(self, event):
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_UP:
                self.state = SPEED_UP
            if event.key == pygame.K_DOWN:
                self.state = SPEED_DOWN
            if event.key == pygame.K_LEFT:
                self.state = TURN_LEFT
            if event.key == pygame.K_RIGHT:
                self.state = TURN_RIGHT
        if event.type == pygame.KEYUP:
            self.state = NORMAL

    def update(self):
        if self.state == TURN_LEFT:
            self.speed.rotate(-self.rotate_speed)
            pygame.transform.rotate(self.image, self.speed.angle)
        if self.state == TURN_RIGHT:
            self.speed.rotate(self.rotate_speed)
        if self.state == SPEED_UP:
            if self.speed.len() < self.max_speed:
                self.speed = self.speed + self.speed.normalize()
                if self.speed.len() == 0:
                    self.speed = self.normal_speed
        if self.speed.len() == 0:
            return
        if self.state == SPEED_DOWN:
            if self.speed.len() < 1:
                self.normal_speed = self.speed
                self.speed = Vector((0, 0))
            else:
                self.speed = self.speed - self.speed.normalize()
        self.pos += self.speed
        if self.pos.as_point()[0] > 800:
            self.pos = Vector((0, self.pos.as_point()[1]))
        if self.pos.as_point()[1] > 600:
            self.pos = Vector((self.pos.as_point()[0], 0))
        if self.pos.as_point()[1] < -1:
            self.pos = Vector((self.pos.as_point()[0], 599))
        if self.pos.as_point()[0] < -1:
            self.pos = Vector((799, self.pos.as_point()[1]))

    def draw(self):
        pygame.draw.lines(
            self.image,
            (155, 0, 0),
            False,
            [
                (40, 20),
                (38, 18),
                (32, 18),
                (32, 16),
                (26, 16),
                (26, 18),
                (26, 15),
                (30, 10),
                (30, 8),
                (36, 8),
                (36, 6),
                (30, 6),
                (28, 4),
                (20, 4),
                (14, 10),
                (10, 10),
                (6, 14),
                (6, 24),
                (12, 30),
                (16, 30),
                (22, 36),
                (30, 36),
                (32, 34),
                (36, 34),
                (36, 32),
                (30, 32),
                (30, 30),
                (26, 26),
                (26, 22),
                (26, 24),
                (32, 24),
                (32, 22),
                (38, 22),
                (40, 20),
            ],
        )
        pygame.draw.rect(self.image, (255, 255, 255), self.image.get_rect(), 1)

    def render(self, screen):
        r = Vector(self.image.get_rect().center)
        rotate_image = pygame.transform.rotate(self.image, self.speed.angle)
        origin_rect = self.image.get_rect()
        rotate_rect = rotate_image.get_rect()
        rotate_rect.center = origin_rect.center
        rotate_rect.move_ip(self.pos.as_point())
        screen.blit(rotate_image, rotate_rect)
        pygame.draw.line(screen, (0, 255, 0), (self.pos + r).as_point(), ((self.pos + self.speed * 5) + r).as_point())
Exemple #3
0
class Game_Object:
    def __init__(self, coords=(0,0), speed=(0,0)):
        self.coords = Vector(coords)
        self.speed = Vector(speed)  #пикселей/сек
        self.max_speed = 100
        self.len_speed = self.speed.len()
        self.color = (250,0,0)
        self.acsel = Vector((0,0))
        self.len_acsel = self.acsel.len()
        self.d_acsel = 0            #Изменение ускорения, x пикс/сек
        self.friction = 0         #Сила трения
        self.status = STOP
        self.angle_speed = 40      #Угловая скорость, градусов/сек

    def event(self, event):
        """
        Обработка событий объектом
        """
        if event.type == KEYDOWN:
            if event.key == K_LEFT:
                self.status = TURN_RIGHT
            elif event.key == K_RIGHT:
                self.status = TURN_LEFT
            elif event.key == K_UP:
                self.d_acsel = +12
            elif event.key == K_DOWN:
                self.d_acsel = -6
        elif event.type == KEYUP:
            if event.key == K_LEFT:
                self.status = MOVE
            elif event.key == K_RIGHT:
                self.status = MOVE
            elif event.key == K_UP or event.key == K_DOWN:
                self.d_acsel = 0

    def change_acselerate(self):
        self.acsel = self.speed.normalize()* (self.d_acsel + self.friction) #?
        self.len_acsel = self.acsel.len()

    def change_speed(self, dt):
        self.speed+= self.acsel*(dt/1000)
        self.len_speed = self.speed.len()
        #fixme: добавить ограничение на max_speed

    def move(self, dt):
        self.coords += (self.speed*(dt/1000))

    def update(self, dt):
        """
        Обновление состояния объкта (вызывается каждый кадр)
        """
        if self.status == TURN_LEFT:
            self.speed.rotate(self.angle_speed/1000*dt)
        elif self.status == TURN_RIGHT:
            self.speed.rotate(-self.angle_speed/1000*dt)
        self.change_acselerate()
        self.change_speed(dt)
        self.move(dt)

    def render(self, screen):
        center = self.coords.as_point()
        dx = 4
        dy = 4
        #cross
        pygame.draw.line(screen, (0,250,0), (self.coords.x, self.coords.y-dy),(self.coords.x, self.coords.y+dy))
        pygame.draw.line(screen, (0,250,0), (self.coords.x-dx, self.coords.y),(self.coords.x+dx, self.coords.y))

        pygame.draw.line(screen, self.color, (self.coords.as_point()),(self.coords+self.speed).as_point())
        pygame.draw.line(screen, (0,0,250), (self.coords.as_point()),(self.coords+self.acsel*2).as_point(),4)