[Pygame] Momentum Based Movement 관성이 적용된 자연스러운 움직임

Python 2023. 9. 5. 18:12 |
반응형

움직이던 물체의 속도가 갑자기 0이 되는 것은 자연스럽지 못하다. 자연스럽게 천천히 멈추는 캐릭터를 만들어 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
running = True
 
player = pygame.image.load("player.png").convert()
player.set_colorkey(player.get_at((0, 0)))
player_size = (player.get_width()*1.5, player.get_height()*1.5)
player = pygame.transform.scale(player, player_size)
player_pos = player.get_rect()
player_pos.center = (screen.get_width()/2, screen.get_height()/2)
player_speed = 4
player_direction = -1
 
left_released = False
right_released = False
slipcount = 0
slipduration = 60
# 캐릭터 미끄러지는 동작 관련 변수들.
 
while running:    
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            running = False
 
        # 왼쪽, 오른쪽 방향키를 떼는 순간.
        if event.type == pygame.KEYUP and event.key == pygame.K_LEFT:
            left_released = True
            right_released = False
            slipcount = 0    
        elif event.type == pygame.KEYUP and event.key == pygame.K_RIGHT:
            right_released = True
            left_released = False
            slipcount = 0
        # 캐릭터의 미끄러지는 동작이 끝나기 전에 반대 방향 키를 누르는 경우에 대비.
 
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        if player_direction > 0:
            player = pygame.transform.flip(player, True, False)
            player_direction = -1
        player_pos.move_ip(-player_speed, 0)
    if keys[pygame.K_RIGHT]:
        if player_direction < 0:
            player = pygame.transform.flip(player, True, False)
            player_direction = 1            
        player_pos.move_ip(player_speed, 0)
    
    # 왼쪽으로 이동 중 키를 놓았을때 slipduration 프레임 동안 미끄러진다.
    if left_released == True:
        player_pos.move_ip(-pygame.math.lerp(player_speed, 0, (slipcount/slipduration)), 0)
        slipcount += 1
 
        # sliupduration이 지나면 초기화.
        if slipcount > slipduration:
            slipcount = 0
            left_released = False
    
    # 오른쪽으로 이동 중 키를 놓았을때 slipduration 프레임 동안 미끄러진다.
    if right_released == True:
        player_pos.move_ip(pygame.math.lerp(player_speed, 0, (slipcount/slipduration)), 0)
        slipcount += 1
 
        # sliupduration이 지나면 초기화.
        if slipcount > slipduration:
            slipcount = 0
            right_released = False
        
    screen.fill("black")
    screen.blit(player, player_pos)
    
    pygame.display.flip()
    clock.tick(60)
 
pygame.quit()
  

 

 

공룡이 바로 멈추지 않고 약간 더 움직인다.

 

이번엔 관성이 적용된 것처럼 천천히 출발하고 천천히 멈추는 캐릭터를 만들어 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
running = True
 
player = pygame.image.load("player.png").convert()
player.set_colorkey(player.get_at((0, 0)))
player_size = (player.get_width()*1.5, player.get_height()*1.5)
player = pygame.transform.scale(player, player_size)
player_pos = player.get_rect()
player_pos.center = (screen.get_width()/2, screen.get_height()/2)
player_direction = -1
 
player_speed = 0
player_speed_step = 0.1
player_max_speed = 4
# 속도 관련 변수들.
 
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            running = False
 
    keys = pygame.key.get_pressed()
    if keys[pygame.K_LEFT]:
        if player_direction > 0:
            player = pygame.transform.flip(player, True, False)
            player_direction = -1
        if (abs(player_speed) <= player_max_speed):
            player_speed -= player_speed_step
            if player_speed < -player_max_speed:
                player_speed = -player_max_speed
    # 왼쪽 방향키를 누르면 속도가 음의 방향으로 player_speed_step 씩 증가하다
    # player_max_speed 에서 멈춘다.
 
    if keys[pygame.K_RIGHT]:
        if player_direction < 0:
            player = pygame.transform.flip(player, True, False)
            player_direction = 1
        if (abs(player_speed) <= player_max_speed):
            player_speed += player_speed_step
            if player_speed > player_max_speed:
                player_speed = player_max_speed
    # 오른쪽 방향키를 누르면 속도가 양의 방향으로 player_speed_step 씩 증가하다
    # player_max_speed 에서 멈춘다.
 
    # 왼쪽으로 가는 도중 오른쪽 방향키를 동시에 누른다고 오른쪽으로 가지는
    # 않지만 오른쪽을 바라본다. 하지만 오른쪽으로 가는 도중 왼쪽 방향키를
    # 동시에 눌러도 바라보는 방향이 바뀌지는 않는다. 이유는 왼쪽 방향키
    # 검사보다 오른쪽 방향키 검사(오른쪽으로 바라보게 하는)가 나중에 오기
    # 때문이다. 두 방향 중 나중에 검사하는 오른쪽 방향이 항상 적용되는 것이다.
 
    if not keys[pygame.K_LEFT] and not keys[pygame.K_RIGHT]:
        if player_speed > 0:
            player_speed -= player_speed_step
        elif player_speed < 0:
            player_speed += player_speed_step
    # 오른쪽이나 왼쪽 방향키를 누르고 있지 않으면 속도가 0에 가까워진다.
    
    if abs(player_speed) < 0.1:
        player_speed = 0
    # 속도의 절대값이 0.1보다 작으면 0으로 변경한다.
 
    player_pos.move_ip(player_speed, 0)
 
    screen.fill("black")
    screen.blit(player, player_pos)
    
    pygame.display.flip()
    clock.tick(60)
 
pygame.quit()
  

 

 

매 프레임마다 player_speed_step 만큼 속도가 증감된다.

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Cursor 파이게임 커서  (0) 2023.09.10
[Pygame] Joystick 파이게임 조이스틱  (0) 2023.09.06
[Pygame] Look at the Mouse Slowly 파이게임 마우스 따라 천천히 회전하기  (0) 2023.09.05
[Pygame] Look at the Mouse 파이게임 마우스 따라 회전하기  (0) 2023.09.05
[Pygame] Sprite Collision Detection 파이게임 스프라이트 충돌 감지  (0) 2023.09.04
Posted by J-sean
:

[Pygame] Look at the Mouse Slowly 파이게임 마우스 따라 천천히 회전하기

Python 2023. 9. 5. 14:19 |
반응형

캐릭터가 마우스를 따라 천천히 회전 하도록 해 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
 
class Player(pygame.sprite.Sprite):
    def __init__(self, pos):
        super().__init__()
        self.image = pygame.image.load("player.png").convert()
        self.image.set_colorkey(self.image.get_at((0, 0)))
        self.image = pygame.transform.scale(self.image,
                    (self.image.get_width()*1.5, self.image.get_height()*1.5))
        self.original_image = self.image
        # 원본 이미지 보관.
        self.rect = self.image.get_rect(center=pos)
        self.pos = pygame.math.Vector2(pos)
        # pos를 벡터로 변환.
 
        self.preangle = 0
 
    def rotate(self):        
        direction = pygame.mouse.get_pos() - self.pos
        # 플레이어에서 마우스로의 벡터.
        radius, angle = direction.as_polar()
        # radius는 마우스까지의 거리, angle은 방위각.
        # 오른쪽=0(-0), 아래=90, 왼쪽=180(-180), 위=-90
        
        if abs(angle - self.preangle) < 0.5:
        # 이전 프레임의 각도와 현재 각도의 차이가 0.5도 미만이면 보간 없이 회전한다.
            self.image = pygame.transform.rotate(self.original_image, -angle+180)
            # 이미지를 회전하고 각도 보정. 이전 프레임의 회전된 이미지가 아닌
            # 원본 이미지를 이용한다.
            self.rect = self.image.get_rect(center=self.rect.center)
            # rect 재설정.
            self.preangle = angle
        else:
            angle = pygame.math.lerp(self.preangle, angle, 0.02)
            # 이전 프레임의 각도와 현재 각도 사이를 프레임당 2% 보간(interpolate)한다.
            self.preangle = angle        
            self.image = pygame.transform.rotate(self.original_image, -angle+180)
            self.rect = self.image.get_rect(center=self.rect.center)
 
    def update(self):
        self.rotate()
 
def main():
    all_sprites = pygame.sprite.Group(Player(screen.get_rect().center))
 
    running = True
 
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False 
    
        all_sprites.update()
    
        screen.fill("black")
        all_sprites.draw(screen)
    
        pygame.display.flip()
        clock.tick(60)
 
    pygame.quit()
 
if __name__ == '__main__':
   main()
  

 

 

캐릭터가 마우스를 향해 천천히 회전한다.

캐릭터를 중점으로 마우스가 2/4분면과 3/4분면 경계를 지날때는 생각과 다르게 반대 방향으로 회전한다.

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Joystick 파이게임 조이스틱  (0) 2023.09.06
[Pygame] Momentum Based Movement 관성이 적용된 자연스러운 움직임  (0) 2023.09.05
[Pygame] Look at the Mouse 파이게임 마우스 따라 회전하기  (0) 2023.09.05
[Pygame] Sprite Collision Detection 파이게임 스프라이트 충돌 감지  (0) 2023.09.04
[Pygame] Bezier Curve 파이게임 베지어 곡선  (0) 2023.09.04
Posted by J-sean
:

[Pygame] Look at the Mouse 파이게임 마우스 따라 회전하기

Python 2023. 9. 5. 00:48 |
반응형

캐릭터가 마우스를 따라 회전 하도록 해 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
 
class Player(pygame.sprite.Sprite):
    def __init__(self, pos):
        super().__init__()
        self.image = pygame.image.load("player.png").convert()
        self.image.set_colorkey(self.image.get_at((0, 0)))
        self.image = pygame.transform.scale(self.image,
                    (self.image.get_width()*1.5, self.image.get_height()*1.5))
        self.original_image = self.image
        # 원본 이미지 보관.
        self.rect = self.image.get_rect(center=pos)
        self.pos = pygame.math.Vector2(pos)
        # pos를 벡터로 변환.
 
    def rotate(self):        
        direction = pygame.mouse.get_pos() - self.pos
        # 플레이어에서 마우스로의 벡터.
        radius, angle = direction.as_polar()
        print(angle)
        # radius는 마우스까지의 거리, angle은 방위각.
        # 오른쪽=0(-0), 아래=90, 왼쪽=180(-180), 위=-90
        self.image = pygame.transform.rotate(self.original_image, -angle+180)
        # 이미지를 회전하고 각도 보정. 이전 프레임의 회전된 이미지가 아닌
        # 원본 이미지를 이용한다.
        self.rect = self.image.get_rect(center=self.rect.center)
        # rect 재설정.
 
    def update(self):
        self.rotate()
 
def main():
    all_sprites = pygame.sprite.Group(Player(screen.get_rect().center))
 
    running = True
 
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False 
    
        all_sprites.update()
    
        screen.fill("black")
        all_sprites.draw(screen)
    
        pygame.display.flip()
        clock.tick(60)
 
    pygame.quit()
 
if __name__ == '__main__':
   main()
  

 

 

캐릭터가 마우스를 따라 회전한다.

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Momentum Based Movement 관성이 적용된 자연스러운 움직임  (0) 2023.09.05
[Pygame] Look at the Mouse Slowly 파이게임 마우스 따라 천천히 회전하기  (0) 2023.09.05
[Pygame] Sprite Collision Detection 파이게임 스프라이트 충돌 감지  (0) 2023.09.04
[Pygame] Bezier Curve 파이게임 베지어 곡선  (0) 2023.09.04
[Pygame] Tweening 파이게임 트윈(트위닝)  (0) 2023.09.04
Posted by J-sean
:

[Pygame] Sprite Collision Detection 파이게임 스프라이트 충돌 감지

Python 2023. 9. 4. 17:01 |
반응형

스프라이트 그룹의 충돌을 감지해 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
 
class Player(pygame.sprite.Sprite):
    def __init__(self, position):
        pygame.sprite.Sprite.__init__(self)
 
        self.direction = -1
        self.speed = 4
        self.image = pygame.image.load("player.png").convert()
        self.image.set_colorkey(self.image.get_at((0, 0)))
        self.size = (self.image.get_width()*1.5, self.image.get_height()*1.5)
        self.image = pygame.transform.scale(self.image, self.size)
        self.rect = self.image.get_rect(center=position)
 
    def flip_image(self):
        self.image = pygame.transform.flip(self.image, True, False)
        
    def update(self):
        pass
# 플레이어 클래스
 
class Bubble(pygame.sprite.Sprite):
    def __init__(self, position):
        pygame.sprite.Sprite.__init__(self)
 
        self.image = pygame.image.load("bubble.png").convert()
        self.image.set_colorkey(self.image.get_at((0, 0)))
        self.size = (self.image.get_width()*6, self.image.get_height()*6)
        self.image = pygame.transform.scale(self.image, self.size)
        self.rect = self.image.get_rect(center=position)
        self.collided = False
 
    def update(self):
        if self.collided == True:
            self.rect.top -= 1
# 버블 클래스
# 충돌(self.collided)을 감지하면 위치(self.rect.top)가 변한다.
 
def main():
    player = Player((screen.get_width()/2, screen.get_height()/2))
    player_sprite = pygame.sprite.Group(player)
    # 플레이어 스프라이트 그룹
 
    bubbles = [
        Bubble((40, screen.get_height()/2)),
        Bubble((160, screen.get_height()/2)),
        Bubble((480, screen.get_height()/2)),
        Bubble((600, screen.get_height()/2))]
    bubble_sprites = pygame.sprite.Group(bubbles)
    # 버블 스프라이트 그룹
 
    running = True
 
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False
 
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            if player.direction > 0:
                player.flip_image()
                player.direction = -1
            player.rect.move_ip(-player.speed, 0)
        if keys[pygame.K_RIGHT]:
            if player.direction < 0:
                player.flip_image()
                player.direction = 1
            player.rect.move_ip(player.speed, 0)
 
        collision = pygame.sprite.spritecollide(player, bubble_sprites, False)
        for bubble in collision:
            bubble.collided = True
        # 플레이어와 버블의 충돌을 감지하고 충돌한 버블의 collided 값을 True로 바꾼다.
 
        player_sprite.update()
        bubble_sprites.update()
 
        screen.fill("black")
        player_sprite.draw(screen)
        bubble_sprites.draw(screen)
    
        pygame.display.flip()
        clock.tick(60)
 
    pygame.quit()
 
if __name__ == '__main__':
   main()
  

 

 

공룡과 충돌한 버블은 하늘로 올라간다.

※ 참고

pygame.sprite.spritecollideany()
Simple test if a sprite intersects anything in a group.
● spritecollideany(sprite, group, collided = None) -> Sprite Collision with the returned sprite.
● spritecollideany(sprite, group, collided = None) -> None No collision
If the sprite collides with any single sprite in the group, a single sprite from the group is returned. On no collision None is returned.

If you don't need all the features of the pygame.sprite.spritecollide() function, this function will be a bit quicker.

The collided argument is a callback function used to calculate if two sprites are colliding. It should take two sprites as values and return a bool value indicating if they are colliding. If collided is not passed, then all sprites must have a "rect" value, which is a rectangle of the sprite area, which will be used to calculate the collision.

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Look at the Mouse Slowly 파이게임 마우스 따라 천천히 회전하기  (0) 2023.09.05
[Pygame] Look at the Mouse 파이게임 마우스 따라 회전하기  (0) 2023.09.05
[Pygame] Bezier Curve 파이게임 베지어 곡선  (0) 2023.09.04
[Pygame] Tweening 파이게임 트윈(트위닝)  (0) 2023.09.04
[Pygame] Sprite Animation 파이게임 스프라이트 애니메이션  (0) 2023.09.03
Posted by J-sean
:

[Pygame] Bezier Curve 파이게임 베지어 곡선

Python 2023. 9. 4. 12:42 |
반응형

베지어 곡선을 계산하고 적용해 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#import numpy as np
import bezier
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
running = True
 
#nodes = np.asfortranarray([
#    [0.0, 640.0*2/4, 640.0*3/4, 640.0],
#    [0.0, 960.0, -960.0, 960.0],
#    ])
#curve = bezier.Curve(nodes, degree=3)
 
#nodes = np.asfortranarray([
#    [0.0, 640.0*2/4, 640.0*3/4, 640.0],
#    [0.0, 960.0, -960.0, 960.0],
#    ])
 
#nodes = np.array([
#    [0.0, 640.0*2/4, 640.0*3/4, 640.0],
#    [0.0, 960.0, -960.0, 960.0],
#    ])
 
nodes = [
    [0.0, 640.0*2/4, 640.0*3/4, 640.0],
    [0.0, 960.0, -960.0, 960.0],
    ]
# 곡선 위 노드 행렬. 행은 차원, 열은 노드의 좌표를 나타낸다.
# (0, 0), (640*2/4, 960), (640*3/4, -960), (640, 960)
 
curve = bezier.Curve.from_nodes(nodes)
# 베지어 곡선을 생성한다. 차수는 node로부터 계산한다.
 
index = 0.0
 
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            running = False
 
    screen.fill("black")
 
    index += 0.005
    if index > 1:
        index = 0.0
 
    coord = curve.evaluate(index)
    # 베지어 곡선 위 index 지점 좌표를 계산한다. index는 1을 넘을 수 있다.
    pygame.draw.circle(screen, "yellow", (coord[0][0], coord[1][0]), 100)
    pygame.display.flip()
 
    clock.tick(60)
 
pygame.quit()
  

 

 

베지어 곡선을 따라 원이 이동한다.

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Look at the Mouse 파이게임 마우스 따라 회전하기  (0) 2023.09.05
[Pygame] Sprite Collision Detection 파이게임 스프라이트 충돌 감지  (0) 2023.09.04
[Pygame] Tweening 파이게임 트윈(트위닝)  (0) 2023.09.04
[Pygame] Sprite Animation 파이게임 스프라이트 애니메이션  (0) 2023.09.03
[Pygame] Alpha Channel 파이게임 알파채널  (0) 2023.09.03
Posted by J-sean
:

[Pygame] Tweening 파이게임 트윈(트위닝)

Python 2023. 9. 4. 01:35 |
반응형

Tweening을 적용해 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import pygame
import pytweening
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
running = True
 
player = pygame.image.load("player.png").convert()
player.set_colorkey(player.get_at((0, 0)))
player_size = (player.get_width()*1.5, player.get_height()*1.5)
player = pygame.transform.scale(player, player_size)
player_pos = player.get_rect()
player_pos.center = (screen.get_width()/2-200, screen.get_height()/2)
 
n = 0
# pytweening 인수
 
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            running = False
    
    n += 0.005
    if n > 1:
        n = 0
 
    dx = int(pytweening.easeInOutBounce(n) * 400)
    #dx = int(pytweening.easeInOutElastic(n) * 400)
    # 최종적으로 400 픽셀 이동. (0 <= n <= 1)
        
    screen.fill("black")
    screen.blit(player, (player_pos.left+dx, player_pos.top))
        
    pygame.display.flip()
    clock.tick(60)
 
pygame.quit()
  

 

 

easeInOutBounce

 

easeInOutElastic

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Sprite Collision Detection 파이게임 스프라이트 충돌 감지  (0) 2023.09.04
[Pygame] Bezier Curve 파이게임 베지어 곡선  (0) 2023.09.04
[Pygame] Sprite Animation 파이게임 스프라이트 애니메이션  (0) 2023.09.03
[Pygame] Alpha Channel 파이게임 알파채널  (0) 2023.09.03
[Pygame] Elapsed Time 파이게임 경과된 시간 구하기  (0) 2023.09.03
Posted by J-sean
:

[Pygame] Sprite Animation 파이게임 스프라이트 애니메이션

Python 2023. 9. 3. 23:18 |
반응형

스프라이트 애니메이션을 만들어 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
 
# 이미지 로드 함수.
def LoadImage(path, scale=None, colorkey=None):
    image = pygame.image.load(path).convert()
 
    if scale is not None:
        image = pygame.transform.scale(image, (image.get_width()*scale, image.get_height()*scale))
 
    if colorkey is not None:
        if colorkey == -1:
            colorkey = image.get_at((0, 0))
        image.set_colorkey(colorkey)
 
    return image
 
# pygame.sprite.Sprite 클래스를 상속하는 클래스는 update()를 재정의하고 image, rect 속성을 가져야한다.
class Cat(pygame.sprite.Sprite):
    def __init__(self, position):
        #super(Cat, self).__init__()        
        pygame.sprite.Sprite.__init__(self)
 
        self.elapsedTime = 0
        self.limitTime = 1000/8
        # 1초에 한 사이클. Cat의 Run 동작은 8프레임이다.
        
        self.direction = 1
        self.speed = 4
        self.index = 0
        self.images = [
            LoadImage("Run1.png", 0.5, -1), LoadImage("Run2.png", 0.5, -1), LoadImage("Run3.png", 0.5, -1),
            LoadImage("Run4.png", 0.5, -1), LoadImage("Run5.png", 0.5, -1), LoadImage("Run6.png", 0.5, -1),
            LoadImage("Run7.png", 0.5, -1), LoadImage("Run8.png", 0.5, -1) ]
        self.image = self.images[self.index]
        self.rect = self.image.get_rect(center=position)
 
    def flip_image(self):
        self.images = [pygame.transform.flip(image, True, False) for image in self.images]
        # list comprehension
 
    def update(self):
        # 1초에 8프레임 업데이트.
        self.elapsedTime += clock.get_time()
        if self.elapsedTime < self.limitTime:
            pass
        else:
            self.elapsedTime = 0
            self.index += 1
            if self.index >= len(self.images):
                self.index = 0
            self.image = self.images[self.index]
 
def main():
    cat = Cat(position=(screen.get_width()/2, screen.get_height()/2))
    #all_sprites = pygame.sprite.Group(cat)
    all_sprites = pygame.sprite.Group()
    # 스프라이트 오브젝트를 관리하기 위한 컨테이너 클래스
    all_sprites.add(cat)
    # 스프라이트를 삭제할 때는 all_sprites.remove(cat)
    running = True
    
    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False
            elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False
 
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            if cat.direction > 0:
                cat.flip_image()
                cat.direction = -1
            cat.rect.move_ip(-cat.speed, 0)
            
        if keys[pygame.K_RIGHT]:
            if cat.direction < 0:
                cat.flip_image()
                cat.direction = 1
            cat.rect.move_ip(cat.speed, 0)
 
        all_sprites.update()
        # 그룹에 속한 모든 스프라이트의 update()를 호출한다.
        
        screen.fill("blue")        
        all_sprites.draw(screen)
        # 그룹에 속한 모든 스프라이트의 image, rect 속성을 이용해 screen에 출력한다.
        # 그룹은 스프라이트의 순서(z-order)를 임의로 정한다.
        pygame.display.flip()
 
        clock.tick(60)
 
    pygame.quit()
 
if __name__ == '__main__':
   main()
  

 

Cat.zip
0.49MB

 

고양이가 자연스럽게 걷고있다.

 

※ 참고

Z-Order에 따라 스프라이트를 그려야 한다면 아래 링크를 확인하자.

LayeredUpdates

This group is fully compatible with pygame.sprite.Sprite.
You can set the default layer through kwargs using 'default_layer' and an integer for the layer. The default layer is 0.
If the sprite you add has an attribute _layer then that layer will be used. If the **kwarg contains 'layer' then the sprites passed will be added to that layer (overriding the sprite.layer attribute). If neither sprite has attribute layer nor **kwarg then the default layer is used to add the sprites.

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Bezier Curve 파이게임 베지어 곡선  (0) 2023.09.04
[Pygame] Tweening 파이게임 트윈(트위닝)  (0) 2023.09.04
[Pygame] Alpha Channel 파이게임 알파채널  (0) 2023.09.03
[Pygame] Elapsed Time 파이게임 경과된 시간 구하기  (0) 2023.09.03
[Pygame] Collision Detection 파이게임 충돌 감지  (0) 2023.09.02
Posted by J-sean
:

[Pygame] Alpha Channel 파이게임 알파채널

Python 2023. 9. 3. 22:37 |
반응형

colorkey로 투명하게 표현할 색을 지정할 수 있다. 이번엔 알파 채널(투명 배경)이 포함된 이미지를 사용해 보자.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pygame
 
pygame.init()
pygame.display.set_caption("Super fun game development")
screen = pygame.display.set_mode((640, 480))
clock = pygame.time.Clock()
running = True
 
#player = pygame.image.load("player.png").convert()
player = pygame.image.load("player.png").convert_alpha()
# 투명 알파채널을 가진 surface를 반환한다.
player_size = (player.get_width()*1.5, player.get_height()*1.5)
player = pygame.transform.scale(player, player_size)
player_pos = player.get_rect()
player_pos.center = (screen.get_width()/2, screen.get_height()/2)
 
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
        elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
            running = False
 
    screen.fill("blue")
    screen.blit(player, player_pos)
    
    pygame.display.flip()
    clock.tick(60)
 
pygame.quit()
  

 

player.png
0.00MB

 

공룡의 배경이 투명하게 표현되어 파란 배경화면이 그대로 표시된다.

 

주석처리된 convert()를 사용하면 공룡의 배경이 그대로 표시되어 파란 배경을 가린다.

 

반응형
저작자표시 비영리 변경금지

'Python' 카테고리의 다른 글

[Pygame] Tweening 파이게임 트윈(트위닝)  (0) 2023.09.04
[Pygame] Sprite Animation 파이게임 스프라이트 애니메이션  (0) 2023.09.03
[Pygame] Elapsed Time 파이게임 경과된 시간 구하기  (0) 2023.09.03
[Pygame] Collision Detection 파이게임 충돌 감지  (0) 2023.09.02
[Pygame] Rendering Font 파이게임 텍스트(폰트) 렌더링  (0) 2023.09.02
Posted by J-sean
:

티스토리툴바