|
런타임(디버그)에 collision shape이 표시되도록 해 보자.
| [Godot] CharacterBody2D Inertial Motion 캐릭터 관성 운동 (0) | 2024.02.15 |
|---|---|
| [Godot] 2D Splash Dynamic Wave 자연스러운 물결 파동 3. 응용 (0) | 2024.02.11 |
| [Godot] Crashes/Freezes When Opening Project Settings (1) | 2023.12.03 |
| [Godot] Bezier Spline Curve 베지어 스플라인 곡선 (0) | 2023.10.21 |
| [Godot] 2D Splash Dynamic Wave 자연스러운 물결 파동 2. 구현 (0) | 2023.10.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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
#include <iostream>
#include "SDL.h"
#include "box2d/box2d.h"
class DebugDrawer : public b2Draw
{
public:
DebugDrawer(SDL_Renderer* renderer) {
this->renderer = renderer;
}
private:
SDL_Renderer* renderer;
void DrawSolidPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {}
void DrawPoint(const b2Vec2& p, float size, const b2Color& color) {}
void DrawPolygon(const b2Vec2* vertices, int32 vertexCount, const b2Color& color) {
SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
SDL_FRect* rect = new SDL_FRect{ vertices[0].x, vertices[0].y, vertices[1].x
- vertices[0].x, vertices[3].y - vertices[0].y };
SDL_RenderDrawRectF(renderer, rect);
}
void DrawCircle(const b2Vec2& center, float radius, const b2Color& color) {}
void DrawSolidCircle(const b2Vec2& center, float radius, const b2Vec2& axis, const b2Color& color) {}
void DrawSegment(const b2Vec2& p1, const b2Vec2& p2, const b2Color& color) {}
void DrawTransform(const b2Transform& xf) {}
};
int main(int argc, char* argv[]) {
SDL_Init(SDL_INIT_VIDEO);
SDL_Window* window = SDL_CreateWindow("SDL Test", SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED, 640, 480, SDL_WINDOW_RESIZABLE);
SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Surface* playerSurface = SDL_LoadBMP("player.bmp");
SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, playerSurface);
// World 정의
b2Vec2 gravity(0.0f, 9.8f);
b2World world(gravity);
// DebugDraw 정의
DebugDrawer* debugDrawer = new DebugDrawer(renderer);
debugDrawer->SetFlags(b2Draw::e_shapeBit | b2Draw::e_jointBit |
b2Draw::e_centerOfMassBit | b2Draw::e_aabbBit | b2Draw::e_pairBit);
world.SetDebugDraw(debugDrawer);
// Player 정의
b2BodyDef playerBodyDef;
playerBodyDef.type = b2_dynamicBody;
playerBodyDef.position.Set(0.0f, 0.0f);
playerBodyDef.linearVelocity = b2Vec2(50.0f, 0.0f);
playerBodyDef.angularVelocity = 0.2f;
b2Body* playerBody = world.CreateBody(&playerBodyDef);
b2PolygonShape dynamicBox;
dynamicBox.SetAsBox((float)playerSurface->w / 2, (float)playerSurface->h / 2);
b2FixtureDef fixtureDef;
fixtureDef.shape = &dynamicBox;
fixtureDef.density = 1.0f;
fixtureDef.friction = 0.3f;
fixtureDef.restitution = 0.5f;
playerBody->CreateFixture(&fixtureDef);
// Ground 정의
b2BodyDef groundBodyDef;
groundBodyDef.position.Set(0.0f, 400.0f);
b2Body* groundBody = world.CreateBody(&groundBodyDef);
b2PolygonShape groundBox;
groundBox.SetAsBox(500.0f, 0.0f);
SDL_Rect groundRect = { 0, 400, 500, 10 };
groundBody->CreateFixture(&groundBox, 0.0f);
// Wall 정의
b2BodyDef wallBodyDef;
wallBodyDef.position.Set(300.0f, 0.0f);
b2Body* wallBody = world.CreateBody(&wallBodyDef);
b2PolygonShape wallBox;
wallBox.SetAsBox(0.0f, 480.0f);
SDL_Rect wallRect = { 300, 0, 10, 480 };
wallBody->CreateFixture(&wallBox, 0.0f);
float timeStep = 1.0f / 500.0f;
int velocityIterations = 6;
int positionIterations = 2;
SDL_Event event;
bool quit = false;
while (!quit) {
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_QUIT:
quit = true;
break;
case SDL_KEYDOWN:
printf("Key pressed: %s\n", SDL_GetKeyName(event.key.keysym.sym));
if (event.key.keysym.sym == SDLK_SPACE) {
playerBody->SetTransform(b2Vec2(0.0f, 0.0f), 0.0f);
playerBody->SetLinearVelocity(b2Vec2(50.0f, 0.0f));
playerBody->SetAngularVelocity(0.2f);
}
if (event.key.keysym.sym == SDLK_ESCAPE)
quit = true;
break;
default:
break;
}
}
world.Step(timeStep, velocityIterations, positionIterations);
SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
SDL_RenderClear(renderer);
// Ground 그리기
SDL_SetRenderDrawColor(renderer, 220, 140, 20, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &groundRect);
// Wall 그리기
SDL_SetRenderDrawColor(renderer, 64, 64, 64, SDL_ALPHA_OPAQUE);
SDL_RenderFillRect(renderer, &wallRect);
// Player 그리기
b2Vec2 playerPosition = playerBody->GetPosition();
SDL_Rect destRect = { (int)playerPosition.x - playerSurface->w / 2,
(int)playerPosition.y - playerSurface->h / 2, playerSurface->w, playerSurface->h };
SDL_RendererFlip flip = SDL_FLIP_NONE;
float angle = playerBody->GetAngle() * (180 / (float)M_PI);
SDL_RenderCopyEx(renderer, texture, NULL, &destRect, angle, NULL, flip);
// DebugDraw 그리기
world.DebugDraw();
// 가장 마지막에 contact point 그리기
SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE);
for (b2Contact* contact = world.GetContactList(); contact; contact = contact->GetNext()) {
for (int i = 0; i < contact->GetManifold()->pointCount; i++)
{
b2Vec2 point = contact->GetFixtureA()->GetBody()->GetWorldPoint(
contact->GetManifold()->points[i].localPoint);
SDL_FRect rect = { point.x - 5, point.y - 5, 10, 10 };
SDL_RenderFillRectF(renderer, &rect);
}
}
// A very important point to note if you do this, is that the existence of a contact in these
// lists does not mean that the two fixtures of the contact are actually touching - it only means
// their AABBs are touching. If you want to know if the fixtures themselves are really touching
// you can use IsTouching() to check.
SDL_RenderPresent(renderer);
}
delete debugDrawer;
SDL_DestroyTexture(texture);
SDL_FreeSurface(playerSurface);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
|
코드를 입력하고 빌드한다.
이제 검은색으로 법선 벡터 그리는 코드를 추가하자.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
// 가장 마지막에 contact point & 법선 벡터 그리기
for (b2Contact* contact = world.GetContactList(); contact; contact = contact->GetNext()) {
for (int i = 0; i < contact->GetManifold()->pointCount; i++)
{
b2Vec2 point = contact->GetFixtureA()->GetBody()->GetWorldPoint(
contact->GetManifold()->points[i].localPoint);
SDL_FRect rect = { point.x - 5, point.y - 5, 10, 10 };
SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE);
SDL_RenderFillRectF(renderer, &rect);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
SDL_RenderDrawLineF(renderer, point.x, point.y,
point.x + contact->GetManifold()->localNormal.x * 20, point.y + contact->GetManifold()->localNormal.y * 20);
}
}
// A very important point to note if you do this, is that the existence of a contact in these
// lists does not mean that the two fixtures of the contact are actually touching - it only means
// their AABBs are touching. If you want to know if the fixtures themselves are really touching
// you can use IsTouching() to check.
|
코드를 수정하고 빌드한다.
속도(velocity) 벡터는 아래와 같은 코드로 표시할 수 있다.
|
1
2
3
4
|
SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
b2Vec2 position = playerBody->GetPosition();
SDL_RenderDrawLineF(renderer, position.x, position.y,
position.x + playerBody->GetLinearVelocity().x * 10, position.y + playerBody->GetLinearVelocity().y * 10);
|
※ 참고
| [SDL] SDL 2D Camera - 2D 카메라 (0) | 2024.02.01 |
|---|---|
| [SDL] SDL Box2D Add Collision Shape - Box2D 충돌 감지 (1) | 2024.01.30 |
| [SDL] SDL Box2D DebugDraw - 디버그 드로우 (1) | 2024.01.30 |
| [SDL] SDL Box2D Collision - Box2D 충돌 (1) | 2024.01.30 |
| [SDL] SDL Box2D - 물리 라이브러리 (0) | 2024.01.27 |
보글보글 같은 플랫폼 게임에서 볼 수 있는 캐릭터와 플랫폼의 한 쪽 방향 충돌 체크를 구현해 보자.
CollisionShape2D - One Way Collision 속성을 체크한다.
필요하다면 Sprite2D - Transform - Scale을 조절한다.
플레이어는 스크립트를 추가한다.
|
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
|
using Godot;
public partial class Player : CharacterBody2D
{
public const float Speed = 300.0f;
public const float JumpVelocity = -600.0f;
// 플랫폼에 올라갈 수 있을 정도의 점프
// Get the gravity from the project settings to be synced with RigidBody nodes.
public float gravity = ProjectSettings.GetSetting("physics/2d/default_gravity").AsSingle();
public override void _PhysicsProcess(double delta)
{
Vector2 velocity = Velocity;
// Add the gravity.
if (!IsOnFloor())
velocity.Y += gravity * (float)delta;
// Handle Jump.
if (Input.IsActionJustPressed("ui_accept") && IsOnFloor())
velocity.Y = JumpVelocity;
// 플랫폼에서 내려오기
if (Input.IsActionJustPressed("ui_down") && IsOnFloor())
Position += new Vector2(0, 1);
// Get the input direction and handle the movement/deceleration.
// As good practice, you should replace UI actions with custom gameplay actions.
Vector2 direction = Input.GetVector("ui_left", "ui_right", "ui_up", "ui_down");
// direction 벡터는 키 입력이 반영되어 길이가 1인 normalized vector 값이 설정된다.
// 예를들어 오른쪽 방향키가 눌렸다면 (1, 0), 아래 방향키가 눌렸다면 (0, 1),
// 왼쪽+위 방향키가 눌렸다면 (-0.707, -0.707)이 설정된다.
if (direction != Vector2.Zero)
{
velocity.X = direction.X * Speed;
}
else
{
velocity.X = Mathf.MoveToward(Velocity.X, 0, Speed);
}
Velocity = velocity;
MoveAndSlide();
}
}
|
플레이어 스크립트를 위와 같이 작성한다.
※ 참고
| [Godot] Ambient Light for 2D 환경광 주변광 (0) | 2023.09.24 |
|---|---|
| [Godot] Hide/disable/confine Mouse Cursor 마우스 커서 숨기기 (0) | 2023.09.23 |
| [Godot] Character Move with Tween 캐릭터 이동(트윈) (0) | 2023.09.21 |
| [Godot] Character Double Jump 캐릭터 이중 점프 (0) | 2023.09.20 |
| [Godot] Character Move 캐릭터 이동 (0) | 2023.09.20 |
충돌 감지 영역을 원으로 지정하고 스프라이트 충돌을 확인해 보자.
|
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
102
103
104
105
106
|
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)
# rectangle이 아닌 circle을 이용해 충돌 감지하기 위한 반지름 속성 설정.
self.radius = 40
# 충돌 감지 circle 표시
pygame.draw.circle(self.image, "red", self.image.get_rect().center, self.radius, 2)
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
# rectangle이 아닌 circle을 이용해 충돌 감지하기 위한 반지름 속성 설정.
self.radius = 40
# 충돌 감지 circle 표시
pygame.draw.circle(self.image, "red", self.image.get_rect().center, self.radius, 2)
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)
# spritecollide()의 마지막 인수 collided에 collide_circle()를 대입한다.
collision = pygame.sprite.spritecollide(player, bubble_sprites, False, pygame.sprite.collide_circle)
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()
|
좀 더 확실한 확인을 위해 공룡과 버블의 충돌 감지 circle의 radius를 20으로 바꾸고 다시 실행해 보자.
| Python SoundDevice 파이썬 사운드 디바이스 (0) | 2023.12.12 |
|---|---|
| Python Core Audio Windows Library 파이썬 코어 오디오 라이브러리 (0) | 2023.10.26 |
| [Pygame] Math Vector 파이게임 수학 벡터 (0) | 2023.09.14 |
| [Pygame] Bouncing Ball 벽에 튕기는 공 만들기 (0) | 2023.09.13 |
| [Pygame] PyOpenGL Image Rendering 파이게임 이미지 렌더링 (0) | 2023.09.12 |
스프라이트 그룹의 충돌을 감지해 보자.
|
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.
| [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 |
캐릭터의 충돌을 감지하고 표시해 보자.
|
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
|
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
# pygame 세팅
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
# player 세팅
enemy = pygame.image.load("enemy.png").convert()
enemy.set_colorkey(enemy.get_at((0, 0)))
enemy_size = (enemy.get_width()*1.5, enemy.get_height()*1.5)
enemy = pygame.transform.scale(enemy, enemy_size)
enemy_pos = enemy.get_rect(center=(500, screen.get_height()/2))
# enemy 세팅
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
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)
hitbox = player.get_rect(center=player_pos.center)
hitbox = hitbox.inflate(-10, -10)
# 분명한 충돌 판정을 위해 player hitbox의 범위를 줄여준다.
clip = None
if hitbox.colliderect(enemy.get_rect(center=enemy_pos.center)):
print("collide")
clip = hitbox.clip(enemy.get_rect(center=enemy_pos.center))
print(clip)
# player와 enemy가 충돌하면 "collide" 메세지를 출력하고 충돌 영역은
# clip에 저장한다.
screen.fill("black")
screen.blit(player, player_pos)
screen.blit(enemy, enemy_pos)
if clip is not None:
pygame.draw.rect(screen, "blue", clip)
# player와 enemy가 충돌한 영역이 clip에 저장되었다면 파란 사각형으로
# 표시힌다.
pygame.display.flip()
clock.tick(60)
pygame.quit()
|
| [Pygame] Alpha Channel 파이게임 알파채널 (0) | 2023.09.03 |
|---|---|
| [Pygame] Elapsed Time 파이게임 경과된 시간 구하기 (0) | 2023.09.03 |
| [Pygame] Rendering Font 파이게임 텍스트(폰트) 렌더링 (0) | 2023.09.02 |
| [Pygame] Moving Character 파이게임 캐릭터 움직이기 (0) | 2023.09.02 |
| [Pygame] Loading Sound 파이게임 사운드 로드하고 출력하기 (0) | 2023.09.02 |
