JBM 프로그래밍

Turtle Game 8 - 다양한 액션 추가하기

오비티 — Mon, 18 May 2020 04:18:27 +0900

Turtle Game 8 - 다양한 액션 추가하기

bubble003.wav

0.05MB

Turtle Game 8 - 다양한 액션 추가하기

앞선 강좌를 통해 거북이가 벌레를 잡아먹고, 점수를 올리는 간단한 게임을 만들었었다.

추가적으로 벌레를 먹은 뒤에 다른 기능들을 구현해보도록 하자.

1. 점수에 따라 거북이의 크기와 색상 변경하기

현재 거북이의 크기는 2로 고정되어 있다. 점수에 따라 거북이의 크기를 변하게 할 수 있고, 거북이의 색상을 변하게 할 수 있다.

거북이의 크기에 따라 색상을 다르게 해주기 위해 색상 리스트를 만든다.

tcolors = ['#95B9D3', '#77ADD3', '#4497D2', '#2A84C5', '#1A5D8E', '#CE8F91','#CB4E53','#B4252A','#8B1317','#780409']

점수에 따라 거북이의 크기를 크게하기 위해 크기와 색상을 변수로 설정한다.

#거북이 크기 값
turtlesize = 1
#거북이의 크기
p.turtlesize(turtlesize,turtlesize)

#거북이의 초기 색상
p.color(tcolors[0])

점수에 따라 거북이의 크기를 변경해주고, 색상을 변경하는 코드를 작성한다.

1) 점수를 10으로 나누어서 나머지가 0일때, 즉 10의 배수일 때마다 거북이의 크기를 1 증가시킨다.

2) 거북이의 크기가 무한대로 커지는 것을 방지하기 위해 크기가 30을 초과하면 30으로 고정시킨다.

3) 거북이의 색상을 10단계로 나누어 두었다. 점수를 나누어서 그 몫이 10보다 작으면, 몫에 해당하는 값을 색상 리스트의 인덱스로 사용하여 색상을 변경해준다.

score += 1

if(score % 10 == 0):
turtlesize += 1
if turtlesize > 30:
turtlesize = 30
p.turtlesize(turtlesize,turtlesize)

k = score // 10
if k < 10:
p.color(tcolors[k])

거북이의 크기가 점점 커지면 벌레를 그 만큼 잘 잡을 수 있어야 한다. 따라서 거북이와 벌레의 충돌 거리 부분을 거북이의 크기에 비례해서 거리도 커지게 만든다.

충돌 확인 함수에 거리값을 변경해주는 코드를 추가한다.

#충돌 확인 함수
def isCollision(t1, t2):
#수학식에서 두 점 사이의 거리
d = math.sqrt( math.pow(t1.xcor() - t2.xcor(), 2) + math.pow(t1.ycor() - t2.ycor(), 2))

  coll = turtlesize * 10

  if d < coll:
return True
else:
return False

위의 코드를 적용한 전체코드는 아래와 같다.

import turtle as t
import random
import math


#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")
screen.tracer(2)


#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)


for x in range(4):
    mypen.forward(600)
    mypen.right(90)

mypen.hideturtle()

#Create bugs 
maxBugs = 20
bugs = []
colors = ['red','blue','purple','white','black', 'pink','#FFFF00']
shapes = ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle']
tcolors = ['#95B9D3', '#77ADD3', '#4497D2', '#2A84C5', '#1A5D8E', '#CE8F91','#CB4E53','#B4252A','#8B1317','#780409']
for count in range(maxBugs):
    c = random.randint(0,6)
    s = random.randint(0,5)
    bugs.append(t.Turtle())
    bugs[count].color(colors[c])
    bugs[count].shape(shapes[s])
    bugs[count].penup()
    bugs[count].speed(0)
    bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
    bugs[count].right(random.randint(0,360))

#거북이의 크기 변수
turtlesize = 1
#Turtle 객체 p 생성
p = t.Turtle()
#p 객체의 모양을 거북이로 만들기
p.shape("turtle")
#p 객체 크기 설정
p.turtlesize(turtlesize,turtlesize)
#p 객체 색상 설정, 
#색상은 색상 이름 또는 색상 코드(#FFFFFF) 등을 이용하여 설정 할 수 있다.
p.color(tcolors[0])
#거북이를 따라다니는 선을 제거
p.penup()
#거북이의 움직임 속도
speed = 1
#거북이 점수
score = 0

def turnleft():
    p.left(30)


def turnright():
    p.right(30)


def increasespeed():
    global speed
    speed += 1


def decreasespeed():
    global speed
    speed -= 1


#점수 입력 함수
def setScore(score): 
    mypen.undo()
    mypen.penup()
    mypen.hideturtle()
    mypen.setposition(-290, 310)
    scorestring = "Score: %s" % score
    mypen.write(scorestring, False, align="left", font=("Arial", 14, "normal"))   
 
#충돌 확인 함수   
def isCollision(t1, t2):
    #수학식에서 두 점 사이의 거리
    d = math.sqrt( math.pow(t1.xcor() - t2.xcor(), 2) + math.pow(t1.ycor() - t2.ycor(), 2))
     
    coll = turtlesize * 10
     
    if d < coll:
        return True
    else:
        return False

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
    p.forward(speed)
    
    #울타리 체크
    if p.xcor() > 300 or p.xcor() < -300:
        p.right(180)
    
    if p.ycor() > 300 or p.ycor() < -300:
        p.right(180)
            
    #다수의 벌레 움직이기
    for count in range(maxBugs):        
        
        bugs[count].forward(5)
    
        #울타리 체크
        if bugs[count].xcor() > 300 or bugs[count].xcor() < -300:
            bugs[count].right(180)
            #soundBounce()
                    
        if bugs[count].ycor() > 300 or bugs[count].ycor() < -300:
            bugs[count].right(180)    
   
        if isCollision(p, bugs[count]):
            #벌레가 먹히면 색상, 모양 변경후 다른 곳으로 이동
            bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
            bugs[count].right(random.randint(0,360))
            s = random.randint(0,5)
            c = random.randint(0,6)
            bugs[count].shape(shapes[s])        
            bugs[count].color(colors[c])
            
            #벌레를 먹었을 때, 점수 1 추가
            score += 1
            
            #점수에 따라 거북이 크기와 색상 변경하기
            if(score % 10 == 0):
                turtlesize += 1
                if turtlesize > 30:
                    turtlesize = 30
                p.turtlesize(turtlesize,turtlesize)
                
                k = score // 10
                if k < 10:
                    p.color(tcolors[k])
                               
            #점수를 표시
            setScore(score)

실행 결과

# 점수에 따라 거북이의 색상과 크기가 변경되는 것을 확인할 수 있다.

# p.penup() 주석처리한 것을 해제한다.

2. 충돌시 소리나게 하기

파이썬에서 소리를 재생하는 모듈은 다양하다. 우리는 playsound 모듈을 사용한다.

1) playsound 설치

명령프롬프트(command prompt)를 실행하여 playsound를 설치한다.

2) 사운드 재생 함수 생성

playsound()의 두번째 인자는 백그라운드로 실행할 것인가 여부를 결정한다. False가 백그라운드.

사운드 파일은 소유하고 있는 어떤 것도 가능하며, 마땅한 사운드 파일이 없으면 다운 받아서 사용해도 된다.

사운드의 위치를 "./sound/bubble003.wav"로 했기 때문에 프로젝트 폴더의 하위에 sound 폴더를 만들어서 그 곳에 사운드 파일을 넣으면 된다.

def soundCollision():
playsound("./sound/bubble003.wav", False)

3) 충돌시 사운드 함수 실행

if isCollision(p, bugs[count]):
  soundCollision()

#벌레가 먹히면 색상, 모양 변경후 다른 곳으로 이동
bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
bugs[count].right(random.randint(0,360))
   s = random.randint(0,5)
c = random.randint(0,6)
bugs[count].shape(shapes[s])
bugs[count].color(colors[c])

#벌레를 먹었을 때, 점수 1 추가
score += 1

#점수에 따라 거북이 크기 커지게 하기
if(score % 10 == 0):
turtlesize += 1
if turtlesize > 30:
turtlesize = 30
p.turtlesize(turtlesize,turtlesize)

k = score // 10
if k < 10:
p.color(tcolors[k])


#점수를 표시
setScore(score)

사운드 기능 추가한 전체 코드

import turtle as t
import random
import math
from playsound import playsound

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")
screen.tracer(2)

#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen.hideturtle()

#Create bugs
maxBugs = 20
bugs = []
colors = ['red','blue','purple','white','black', 'pink','#FFFF00']
shapes = ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle']
tcolors = ['#95B9D3', '#77ADD3', '#4497D2', '#2A84C5', '#1A5D8E', '#CE8F91','#CB4E53','#B4252A','#8B1317','#780409']
for count in range(maxBugs):
c = random.randint(0,6)
s = random.randint(0,5)
bugs.append(t.Turtle())
bugs[count].color(colors[c])
bugs[count].shape(shapes[s])
bugs[count].penup()
bugs[count].speed(0)
bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
bugs[count].right(random.randint(0,360))

#거북이의 크기 변수
turtlesize = 1
#Turtle 객체 p 생성
p = t.Turtle()
#p 객체의 모양을 거북이로 만들기
p.shape("turtle")
#p 객체 크기 설정
p.turtlesize(turtlesize,turtlesize)
#p 객체 색상 설정,
#색상은 색상 이름 또는 색상 코드(#FFFFFF) 등을 이용하여 설정 할 수 있다.
p.color(tcolors[0])
#거북이를 따라다니는 선을 제거
p.penup()
#거북이의 움직임 속도
speed = 1
#거북이 점수
score = 0

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

#점수 입력 함수
def setScore(score):
mypen.undo()
mypen.penup()
mypen.hideturtle()
mypen.setposition(-290, 310)
scorestring = "Score: %s" % score
mypen.write(scorestring, False, align="left", font=("Arial", 14, "normal"))

def soundCollision():
playsound("./sound/bubble003.wav", False)

#충돌 확인 함수
def isCollision(t1, t2):
#수학식에서 두 점 사이의 거리
d = math.sqrt( math.pow(t1.xcor() - t2.xcor(), 2) + math.pow(t1.ycor() - t2.ycor(), 2))

coll = turtlesize * 10

if d < coll:
return True
else:
return False

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

#울타리 체크
if p.xcor() > 300 or p.xcor() < -300:
p.right(180)

if p.ycor() > 300 or p.ycor() < -300:
p.right(180)


#다수의 벌레 움직이기
for count in range(maxBugs):

bugs[count].forward(5)

#울타리 체크
if bugs[count].xcor() > 300 or bugs[count].xcor() < -300:
bugs[count].right(180)
#soundBounce()


if bugs[count].ycor() > 300 or bugs[count].ycor() < -300:
bugs[count].right(180)

if isCollision(p, bugs[count]):
  soundCollision()

#벌레가 먹히면 색상, 모양 변경후 다른 곳으로 이동
bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
bugs[count].right(random.randint(0,360))
s = random.randint(0,5)
c = random.randint(0,6)
bugs[count].shape(shapes[s])
bugs[count].color(colors[c])

#벌레를 먹었을 때, 점수 1 추가
score += 1

#점수에 따라 거북이 크기 커지게 하기
if(score % 10 == 0):
turtlesize += 1
if turtlesize > 30:
turtlesize = 30
p.turtlesize(turtlesize,turtlesize)

k = score // 10
if k < 10:
p.color(tcolors[k])


#점수를 표시
setScore(score)

각자 아이디어를 내어서 다른 기능들로 추가하면서 게임을 즐겨보자~~~~

Turtle Game 8 - 다양한 액션 추가하기 끝

Turtle Game 7 - 벌레를 먹을때마다 점수 올리기

오비티 — Mon, 18 May 2020 04:17:33 +0900

Turtle Game 7 - 벌레를 먹을때마다 점수 올리기

Turtle Game 7 - 벌레를 먹을때마다 점수 올리기

앞서서 거북이가 벌레를 먹는 것을 구현하였다.

이번에는 거북이가 벌레를 먹었을 때, 점수를 표시해보도록 한다.

1. 점수 구현하기

울타리를 그릴 때, mypen 객체를 사용하였다. 울타리를 그리고 난 뒤, 놀고 있는 mypen 객체를 이용하여 점수를 입력해본다.

Turtle() 객체는 write 메서드가 있다. 말 그대로 글자를 쓸 수 있는 메서드이다.

아래의 함수를 만들어서 점수를 표시해보도록 하자.

거북이의 점수 score는 score = 0으로 초기화 한다.

점수 표시 코드

socre = 0

def setScore(score):

#mypne의 이전 행동을 되돌린다. 반복적으로 write를 할때, 겹쳐서 쓰는 것을 방지한다.
mypen.undo()

#mypen 객체의 위치가 어디에 있던 점수를 표시하기 위한 좌표까지 이동시, 선을 그리지 않게 한다.
mypen.penup()

#mypen 객체의 shape는 보이지 않아야 한다. 숨김 변경
mypen.hideturtle()

#점수를 표시하기 위한 위치로 이동, 울타리의 왼쪽 위 정도로 정한다.
mypen.setposition(-290, 310)

#점수 표시 형태, socre는 인자로 받아온 값이다.
scorestring = "Score: %s" % score

#mypen이 있는 위치에서 글자를 표시한다.
mypen.write(scorestring, False, align="left", font=("Arial", 14, "normal"))

2. 충돌 확인 함수 작성

앞선 강좌에서 거북이와 벌레의 충돌을 계산하는 아래의 식을 만들어서 for 구문 안에 넣었었다.

#거북이와 벌레 거리 구하는 식

d = math.sqrt( math.pow(p.xcor() - bugs[count].xcor(), 2) + math.pow(p.ycor() - bugs[count].ycor(), 2))

편의를 위해 충돌 함수를 만들어서 사용하도록 한다.

충돌함수 코드

def isCollision(t1, t2):
#수학식에서 두 점 사이의 거리
d = math.sqrt( math.pow(t1.xcor() - t2.xcor(), 2) + math.pow(t1.ycor() - t2.ycor(), 2))

if d < 20:
return True
else:
return False

전체코드

# 충돌여부를 함수를 이용하여 확인하고, 충돌이 인정되면 벌레를 이동시키고 점수를 올려준다.

import turtle as t
import random
import math

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")
screen.tracer(2)

#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen.hideturtle()

#Create bugs
maxBugs = 20
bugs = []
colors = ['red','blue','purple','white','black', 'pink','#FFFF00']
shapes = ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle']

for count in range(maxBugs):
c = random.randint(0,6)
s = random.randint(0,5)
bugs.append(t.Turtle())
bugs[count].color(colors[c])
bugs[count].shape(shapes[s])
bugs[count].penup()
bugs[count].speed(0)
bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
bugs[count].right(random.randint(0,360))

#Turtle 객체 p 생성
p = t.Turtle()
#p 객체의 모양을 거북이로 만들기
p.shape("turtle")
#p 객체 크기 설정
p.turtlesize(2,2)
#p 객체 색상 설정,
#색상은 색상 이름 또는 색상 코드(#FFFFFF) 등을 이용하여 설정 할 수 있다.
p.color("blue")
#거북이를 따라다니는 선을 제거
#p.penup()

#거북이의 움직임 속도
speed = 1

#거북이 점수
score = 0

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

#점수 입력 함수
def setScore(score):
mypen.undo()
mypen.penup()
mypen.hideturtle()
mypen.setposition(-290, 310)
scorestring = "Score: %s" % score
mypen.write(scorestring, False, align="left", font=("Arial", 14, "normal"))

#충돌 확인 함수
def isCollision(t1, t2):
#수학식에서 두 점 사이의 거리
d = math.sqrt( math.pow(t1.xcor() - t2.xcor(), 2) + math.pow(t1.ycor() - t2.ycor(), 2))

if d < 20:
return True
else:
return False

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

#울타리 체크
if p.xcor() > 300 or p.xcor() < -300:
p.right(180)

if p.ycor() > 300 or p.ycor() < -300:
p.right(180)


#다수의 벌레 움직이기
for count in range(maxBugs):

bugs[count].forward(5)

#울타리 체크
if bugs[count].xcor() > 300 or bugs[count].xcor() < -300:
bugs[count].right(180)
#soundBounce()


if bugs[count].ycor() > 300 or bugs[count].ycor() < -300:
bugs[count].right(180)

  if isCollision(p, bugs[count]):
#벌레가 먹히면 색상, 모양 변경후 다른 곳으로 이동
bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
bugs[count].right(random.randint(0,360))
s = random.randint(0,5)
c = random.randint(0,6)
bugs[count].shape(shapes[s])
bugs[count].color(colors[c])

  #벌레를 먹었을 때, 점수 1 추가
score += 1

#점수를 표시
setScore(score)

Turtle Game 7 - 벌레를 먹을때마다 점수 올리기 끝

Turtle Game 6 - 벌레 잡아먹기

오비티 — Mon, 18 May 2020 04:16:52 +0900

Turtle Game 6 - 벌레 잡아먹기

Turtle Game 6 - 벌레 잡아먹기

앞선 강좌에서 거북이와 벌레를 만들어 울타리속에서 움직이도록 만들었다.

이번에는 거북이가 벌레를 잡아먹는 동작을 구현해보도록 한다.

1. 거북이가 벌레를 잡아먹는 로직

거북이가 벌레를 잡아먹는것을 어떻게 표현할까?

현실적으로 보면 거북이가 벌레를 먹는 것은 입을 벌려 벌레를 입속에 집어 넣는 것이다.

Turtle 모듈의 거북이는 입도 없고, 입을 벌려서 벌레를 먹는 것을 구현할 수 없다. 그래서 거북이가 벌레를 먹는다는 것은 거북이가 벌레와 만나는 것으로 생각한다.

그렇다면 거북이와 벌레가 만나는 것은 어떻게 구현할까?

거북이는 객체이다. 벌레도 객체이다. 두 객체의 위치는 좌표로 나타낼 수 있다.

따라서, 두 객체가 만난다는 것을 프로그램적으로 생각하면, 움직이는 두 객체의 좌표가 같을 때 만났다고 할 수 있다.

하지만, 움직이는 두 객체의 좌표가 일치되기는 힘들다. 특히 우리는 거북이 게임을 통해 거북이가 벌레를 잡아먹는 것을 구현하려고 하는데, 거북이와 벌레의 좌표가 일치되어어야만 벌레를 먹은 것으로 생각한다면 벌레 한마리 잡아먹기가 매우 힘들 것이다.

따라서 거북이와 벌레의 좌표가 일치되지는 않더라도 두 객체의 거리가 일정 값 이하가 되면 만났다고 생각하여 거북이가 벌레를 먹은것으로 한다.

그렇다면 두 객체의 거리는 어떻게 구할 수 있을까?

두 객체의 거리는 점과 점사이의 거리 또는 좌표간의 거리를 구하는 공식으로 구할 수 있다.

점과 점사이의 거리 구하는 공식은 다음 링크에서 확인한다. https://www.jbmpa.com/python_tip/10

1) 거북이가 벌레의 거리를 통해 벌레를 잡아먹은 효과 구현

# for count in range(maxBugs): 구문 안에 입력

# math를 사용하기 위해서 import math 를 추가함

#두 점의 거리 구하기

d = math.sqrt( math.pow(p.xcor() - bugs[count].xcor(), 2) + math.pow(p.ycor() - bugs[count].ycor(), 2))

#두 점과의 거리가 0일때 일치, 서로간의 거리가 20정도 되면 먹은 것으로 생각
if d < 20:
print("벌레 먹음")
else:

#벌레 못 먹음
pass

전체 코드

import turtle as t
import random
import math

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")
screen.tracer(2)

#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)
mypen.hideturtle()

#Create bugs
maxBugs = 20
bugs = []
colors = ['red','blue','purple','white','black', 'pink','#FFFF00']
shapes = ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle']

#거북이의 움직임 속도
speed = 1

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

#울타리 체크
if p.xcor() > 300 or p.xcor() < -300:
p.right(180)

if p.ycor() > 300 or p.ycor() < -300:
p.right(180)


#다수의 벌레 움직이기
for count in range(maxBugs):

bugs[count].forward(5)

#울타리 체크
if bugs[count].xcor() > 300 or bugs[count].xcor() < -300:
bugs[count].right(180)
#soundBounce()

if bugs[count].ycor() > 300 or bugs[count].ycor() < -300:
bugs[count].right(180)

#두 점의 거리 구하기
d = math.sqrt( math.pow(p.xcor() - bugs[count].xcor(), 2) + math.pow(p.ycor() - bugs[count].ycor(), 2))

#두 점과의 거리가 0일때 일치, 서로간의 거리가 20정도 되면 먹은 것으로 생각
if d < 20:
print("벌레 먹음", count)
else:
#벌레 못 먹음
pass

2. 거북이가 벌레를 먹은 이후 동작 구현

위에서 거북이가 벌레를 먹은 것을 표현하기 위해 거북이와 벌레가 만났을 때, 즉 두 객체의 좌표간의 거리를 구하여 구현하였다.

보통 게임에서 두 객체의 거리를 구하는 것을 많이 사용하는데, 만난다는 표현보다는 "두 객체의 충돌"이라는 표현을 많이 사용한다.

이후에는 우리도 충돌이라는 용어를 사용하도록 한다.

이번에는 거북이와 벌레가 충돌이후, 다양한 동작들을 구현해보도록 한다.

1) 거북이와 충돌후 벌레의 위치 옮기기

거북이가 벌레를 먹고 난 뒤, 벌레가 계속 움직이면 좌표간의 거리때문에 여러번 먹은 것이 될 수 있다. 따라서 거북이와 벌레가 충돌하면 바로 벌레의 위치를 옮겨보도록 하자.

벌레의 위치를 옮길 때, 벌레의 모양과 색상도 변경한다.

벌레 위치 옮기기

#두 점의 거리 구하기
d = math.sqrt( math.pow(p.xcor() - bugs[count].xcor(), 2) + math.pow(p.ycor() - bugs[count].ycor(), 2))

#두 점과의 거리가 0일때 일치, 서로간의 거리가 20정도 되면 먹은 것으로 생각
if d < 20:

  #벌레가 먹히면 색상, 모양 변경후 다른 곳으로 이동
  bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
  bugs[count].right(random.randint(0,360))
  s = random.randint(0,5)
  c = random.randint(0,6)
  bugs[count].shape(shapes[s])
   bugs[count].color(colors[c])
else:
#벌레 못 먹음
pass

전체 코드

import turtle as t
import random
import math

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")
screen.tracer(2)

#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen.hideturtle()

#Create bugs
maxBugs = 20
bugs = []
colors = ['red','blue','purple','white','black', 'pink','#FFFF00']
shapes = ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle']

#거북이의 움직임 속도
speed = 1

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

#울타리 체크
if p.xcor() > 300 or p.xcor() < -300:
p.right(180)

if p.ycor() > 300 or p.ycor() < -300:
p.right(180)

#다수의 벌레 움직이기
for count in range(maxBugs):

bugs[count].forward(5)

#울타리 체크
if bugs[count].xcor() > 300 or bugs[count].xcor() < -300:
bugs[count].right(180)
#soundBounce()

if bugs[count].ycor() > 300 or bugs[count].ycor() < -300:
bugs[count].right(180)

#두 점의 거리 구하기
d = math.sqrt( math.pow(p.xcor() - bugs[count].xcor(), 2) + math.pow(p.ycor() - bugs[count].ycor(), 2))

#두 점과의 거리가 0일때 일치, 서로간의 거리가 20정도 되면 먹은 것으로 생각
if d < 20:
#벌레가 먹히면 색상, 모양 변경후 다른 곳으로 이동
bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))
bugs[count].right(random.randint(0,360))
s = random.randint(0,5)
c = random.randint(0,6)
bugs[count].shape(shapes[s])
bugs[count].color(colors[c])
else:
#벌레 못 먹음
pass

실행 결과 - 거북이가 벌레를 먹으면 벌레는 다른 모양과 색상으로 변경되어 다른 곳에서 나타난다.

Turtle Game 6 - 벌레 잡아먹기 끝

Turtle Game 5 - 벌레 생성

오비티 — Mon, 18 May 2020 04:16:12 +0900

Turtle Game 5 - 벌레 생성

Turtle Game 5 - 벌레 생성

앞선 강좌에서 거북이와 울타리를 생성해서 거북이가 울타리 밖으로 나가지 못하는 코드를 구현하였다.

이제 거북이가 돌아다니면서 먹을 먹이(벌레)들을 생성하는 코드를 추가해 보자.

1. 벌레 생성

벌레도 거북이와 같은 방법으로 Turtle() 객체로 생성할 수 있다.

벌레를 생성하는 코드는 아래와 같다.

1) 벌레 생성 코드

bug = t.Turtle()
bug .color("red")
bug .shape("circle")
bug .penup()
bug .speed(0)
bug .setposition(-100, -100)

벌레 역시 거북이처럼 울타리 안에서 지속적으로 움직이게 만들어보자. 아래의 코드는 while True: 구문 속에 들어가야 한다.

2) 벌레 동작 코드

bug.forward(5)

if bug .xcor() > 300 or bug .xcor() < -300:
bug .right(180)

if bug .ycor() > 300 or bug .ycor() < -300:
bug .right(180)

전체 코드 - 이전 강좌의 코드에서 추가되거나 수정된 것은 붉은색으로 표시하였다.

import turtle as t

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen.hideturtle()

bug = t.Turtle()
bug .color("red")
bug .shape("circle")
bug .penup()
bug .speed(0)
bug .setposition(-100, -100)

#거북이의 움직임 속도
speed = 1

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

#울타리 체크
if p.xcor() > 300 or p.xcor() < -300:
p.right(180)

if p.ycor() > 300 or p.ycor() < -300:
p.right(180)

bug.forward(5)
if bug.xcor() > 300 or bug.xcor() < -300:
bug.right(180)

if bug.ycor() > 300 or bug.ycor() < -300:
bug.right(180)

실행화면 - Ctrl + F11

2. 다수의 벌레 생성

1번에서 벌레 한마리를 생성해서 울타리 안에서 계속 움직이는 코드를 추가하였다. 이번에는 벌레 1마리가 아니라 여러마리를 만들어서 제각각 움직이는 코드를 만들어보자.

벌레는 생성하는 코드는 모두 같다. 다만 여러마리의 벌레를 만들기 위해서 벌레 객체를 리스트로 만든다. 나머지는 동일하다.

생성되는 벌레는 색상과 모양을 다양하게 만들도록 해보자.

1) 다수의 벌레 생성 코드

#벌레의 갯수 지정
maxBugs = 20

#벌레 리스트 생성
bugs = []

#벌레의 다양한 색상을 위해 색상 리스트 생성
colors = ['red','blue','purple','white','black', 'pink','#FFFF00']

#벌레의 다양한 모양을 위해 shape 리스트 생성
shapes = ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle']

for count in range(maxBugs):
#색상을 랜덤하게 선택
c = random.randint(0,6)

#모양을 랜덤하게 선택
s = random.randint(0,5)

#Turtle()객체를 생성하여 bugs 리스트에 하나씩 추가
bugs.append(t.Turtle())
bugs[count].color(colors[c])
bugs[count].shape(shapes[s])
bugs[count].penup()
bugs[count].speed(0)

#X좌표, Y좌표를 랜덤으로 생성해서 위치를 이동
bugs[count].setposition(random.randint(-300, 300), random.randint(-300, 300))

#0 ~ 360도까지 방향을 랜덤으로 생성
bugs[count].right(random.randint(0,360))

random.randint(1, 100)은 1에서 100까지의 정수를 랜덤으로 반환한다.

random 모듈을 사용하기 위해서는 random 모듈을 import 하여야 한다.

random 함수에 대한 내용은 다음 링크의 7번에서 확인한다. https://www.jbmpa.com/python_basic/13

2) 벌레 동작 코드

리스트로 만들어진 벌레 역시 모두 움직이도록 한다. 벌레가 리스트이므로 벌레 숫자만큼 for 문을 이용하여 움직이는 코드를 만든다. 아래의 코드는 while True: 구문 속에 들어가야 한다.

#벌레 움직이기
for count in range(maxBugs):

bugs[count].forward(5)

if bugs[count].xcor() > 300 or bugs[count].xcor() < -300:
bugs[count].right(180)

if bugs[count].ycor() > 300 or bugs[count].ycor() < -300:
bugs[count].right(180)

최종 전체코드

import turtle as t
import random

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

#스크린의 그래픽 그리는 속도를 높임
screen.tracer(2)

#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen.hideturtle()

#Create bugs
maxBugs = 20
bugs = []
colors = ['red','blue','purple','white','black', 'pink','#FFFF00']
shapes = ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle']

#거북이의 움직임 속도
speed = 1

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

다수의 거북이 객체가 생성되면 속도가 느려진다. screen.tracer(2)를 추가하여 그래픽에서 그림을 그리는 속도를 높이면 속도가 빨라진다.

실행화면 - Ctrl + F11

Turtle Game 5 - 벌레 생성 끝

Turtle Game 4 - 울타리 안에서 못 벗어나게 하기

오비티 — Mon, 18 May 2020 04:15:25 +0900

Turtle Game 4 - 울타리 안에서 못 벗어나게 하기

Turtle Game 4 - 울타리 안에서 못 벗어나게 하기

앞선 강좌에서 화면 안에 울타리를 그려보았다.

하지만 여전히 거북이는 울타리 밖으로 나갈 수 있다. 이번에는 거북이가 울타리 밖으로 나가지 못하도록 하는 코드를 추가해 본다.

1. 울타리의 개념

저번 강좌에서 그린 울타리는 한 좌표에서 다른 좌표로 선을 그린 것 뿐이다.

이 선을 구성하는 것은 각 점이며, 각 점은 좌표를 가진다. 아래 그림을 보자.

오른쪽 울타리 - 검은색 선을 생각해본다.

오른쪽 울타리는 오른쪽 위(300, 300)에서 오른쪽 아래(300, -300)까지 이어진 선이다.

그리고 이 선을 4등분하여 나오는 점을 표시하면, 위쪽에서 아래쪽으로 각 점의 좌표는 아래와 같다.

(300, 300)

(300, 150)

(300, 0)

(300, -150)

(300, -300)

좌표 값을 보면 X축의 값은 300으로 고정되어 있고, Y축의 값만 변한다.

따라서 오른쪽 울타리(검은색 선)는 X축의 값이 300이고 Y축의 값은 300 ~ -300인 점의 모임이라고 할 수 있다.

같은 방식으로 왼쪽 울타리는 X축의 값이 -300이고, Y축의 값이 300 ~ -300인 점의 모임이 된다.

2. 거북이와 울타리의 관계

우리의 주인공 거북이는 화면 내에서 어디든지 돌아다닐 수 있다.

우리의 목표는 이 거북이가 울타리 밖으로 못 나가게 하는 것이다.

거북이를 울타리 밖으로 못나가게 한다는 것을 프로그램적으로 말하면 거북이가 울타리로 그려진 선의 좌표를 넘지 못하게 한다는 것이 된다.

1번의 그림에서 나오는 오른쪽 울타리를 생각해보자. 이 오른쪽 울타리의 X좌표 값은 300이다. Y축의 좌표 값이 얼마가 되던, 오른쪽 울타리의 X좌표 값은 300으로 고정되어 있다.

이 것을 이용하며 생각해보면, 거북이가 오른쪽 울타리를 넘지 않는다는 것은 결국 거북이의 X좌표가 300이상 넘어가지 못하게 한다는것이 된다.

Turtle 객체의 좌표(coordinates)는 xcor()와 ycor()메서드로 구할 수 있다.

즉, 거북이의 X좌표값은 p.xcor() 이며, Y좌표 값은 p.ycor()가 된다.

3. 거북이를 울타리 안에 가두기

1번과 2번의 로직에서 거북이와 울타리의 관계를 알아내었다.

이제 거북이를 울타리 밖으로 나가지 못하는 코드를 작성해보자.

1) 오른쪽 울타리 못 넘게 하기

거북이의 X좌표 값은 p.xcor() 이다.

오른쪽 울타리의 X좌표 값은 300이다.

따라서 거북이의 X좌표값이 300보다 크게되면 반대방향으로 방향을 회전하게 만든다.

if p.xcor() > 300:

p.right(180)

2) 왼쪽 울타리 못 넘게 하기

왼쪽 울타리의 X좌표 값은 -300이다.

따라서 거북이의 X좌표값이 -300보다 작게되면 반대방향으로 방향을 회전하게 만든다.

if p.xcor() < -300:

p.right(180)

3) 위쪽 울타리 못 넘게 하기

거북이의 Y좌표 값은 p.ycor() 이다.

위쪽 울타리의 Y좌표 값은 300이다.

따라서 거북이의 Y좌표값이 300보다 크게되면 반대방향으로 방향을 회전하게 만든다.

if y.xcor() > 300:

p.right(180)

4) 아래쪽 울타리 못 넘게 하기

아래쪽 울타리의 Y좌표 값은 -300이다.

따라서 거북이의 Y좌표값이 -300보다 작게되면 반대방향으로 방향을 회전하게 만든다.

if y.xcor() < -300:

p.right(180)

1), 2)번 코드를 합치고, 3) 4)번 코드를 합치면 아래와 같다.

if p.xcor() > 300 or p.xcor() < -300:
p.right(180)

if p.ycor() > 300 or p.ycor() < -300:
p.right(180)

매우 긴 설명(?)에 비해 코드는 매우 단순하다. 좌표와 선과의 관계 개념을 정확하게 이해하기 위한 긴 설명이라 생각하자~

이제 이전에 작성했던 코드에 추가해본다.

울타리를 넘지 못하게 하는 코드는 while True: 구문 안에 존재해야 한다.

완성된 코드를 추가한 전체 코드는 아래와 같다.

import turtle as t

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

#울타리 그리기
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen.hideturtle()

#거북이의 움직임 속도
speed = 1

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

#울타리 체크
  if p.xcor() > 300 or p.xcor() < -300:
p.right(180)

if p.ycor() > 300 or p.ycor() < -300:
p.right(180)

실행 결과

# 방향키를 이용하여 거북이를 마음대로 움직여 보자.

# 아래 캡쳐된 이미지는 울타리 밖으로 나가지 못하는 것을 보여주기 위해 거북이의 penup()을 주석처리하여 실행한 결과이다.

Turtle Game 4 - 울타리 안에서 못 벗어나게 하기 끝

Turtle Game 3 - 울타리 만들기

오비티 — Mon, 18 May 2020 04:14:45 +0900

Turtle Game 3 - 울타리 만들기

Turtle Game 3 - 울타리 만들기

앞선 강좌에서 거북이의 방향과 속도를 제어하는 것을 구현하였다.

하지만 여전히 거북이는 화면 밖으로 벗어날 수 있고, 화면을 벗어난 거북이는 어디에 있는지 찾기가 힘들어진다.

따라서 화면(window) 안에 울타리를 만들고, 울타리 밖으로 벗어나지 못하게 하는 코드를 추가해본다.

1. 울타리 만들기

Turtle 모듈에서 Turtle 객체가 생성되는 지점은 정 가운데이다.

좌표로써 말하면 정 가운데의 X, Y 좌표값이 (0, 0)인 지점이 된다.

※ 좌표에 대한 예제는 다음 링크에서 확인한다. https://www.jbmpa.com/python_tip/10

만약 생성된 화면안에 울타리를 만든다고 한다면, 아래 그림의 파란색 라인처럼 생각할 수 있다.

파란색 라인의 각 모서리의 좌표는 각각 다음과 같다.

왼쪽 위 ( -300, 300)

오른쪽 위 (300,300)

오른쪽 아래 (300, -300)

왼쪽 아래 (-300, -300)

위의 좌표를 생각하면서, Turtle 모듈을 이용해서 사각형을 만드는 방법을 전체적으로 구상해보면 다음과 같다.

1) Turtle 객체 mypen을 한 개 생성한다.

2) mypen의 최초 위치는 (0,0) 이므로, 왼쪽 위(-300, 300)로 이동 시켜준다.'

3) 왼쪽 위로 이동할 때, 선이 그려지면 안되므로 이동하기전에 penup()을 한다.

4) 왼쪽 위로 이동하였으면, 오른쪽 위(300, 300)까지 이동한다.

5) 오른쪽 위로 이동할때는 선이 그려져야 하므로, pendown()을 한다.

6) 이동 거리는 300 + 300 이므로 600이 된다.

7) 오른쪽 위에 도달하였으면, 아래로 선을 그어야 한다. Turtle 객체는 기본적으로 오른쪽으로 향하고 있기 때문에 아래로 방향을 바꾸려면 오른쪽으로 90도 회전하면 된다. 따라서 right(90)을 해준다.

8) 오른쪽 위에서 오른쪽 아래로 이동한다. 이동 거리는 600이다.

9) 오른쪽 아래에 도달하였으면 다시 오른쪽으로 90도 회전(right(90))한다.

10) 앞으로 600만큼 이동한다. 방향은 90도를 두번 회전하였기 때문에 오른쪽 방향에서 180도, 즉 왼쪽을 향하게 된다. 따라서 거북이는 왼쪽 아래 모서리로 진행한다.

11) 왼쪽 아래에 도달하였으면 다시 오른쪽으로 90도 회전한다.

12) 앞으로 600만큼 이동한다. 방향은 위쪽이 되므로 최종도착지점은 왼쪽 위(-300, 300)가 된다.

위에서 구상한 내용을 코드로 작성해 보자.

# Turtle 객체를 생성하여 mypen에 저장한다. shape를 지정하지 않으면 기본 값인 "classic"이 된다.

mypen = t.Turtle()

# 왼쪽 위로 이동하기 위해서 펜을 든다. 중앙에서 왼쪽 위까지 선이 그려지는 것을 방지한다.
mypen.penup()

# mypen 객체를 왼쪽 위(-300, 300)으로 이동한다. 객체를 이동시키는 메서드는 setposition() 이다.
mypen.setposition(-300, 300)

# 왼쪽 위로 이동을 하였으면, 펜을 다시 내린다. 선을 긋기 위함이다.
mypen.pendown()

# 펜사이즈를 3으로 한다.
mypen.pensize(3)

사각형(울타리)을 그리기 위한 과정은 7)에서 12)까지의 과정이다.

왼쪽 위, 오른쪽 위, 오른쪽 아래. 왼쪽 아래 등으로 복잡한 것 같지만 자세히 보면 매우 단순한 것을 알 수 있다.

즉, 앞으로 이동 후 방향 회전, 앞으로 이동 후 방향 회전이 반복된다는 것을 알 수 있다.

따라서 앞으로 600만큼 이동, 방향 90도회전을 4번 반복하는 코드를 작성한다.

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen 객체는 울타리를 그리고 나면 더이상 할 일이 없다. 따라서 mypen 객체의 shape를 안 보이도록 한다.

mypen.hideturtle()

울타리를 만드는 코드는 주인공 거북이보다 먼저 생성되어야 하므로, 거북이를 생성하는 코드 위쪽에 추가한다.

모든 코드를 종합하면 아래와 같다.

import turtle as t

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

#Draw border
mypen = t.Turtle()
mypen.penup()
mypen.setposition(-300, 300)
mypen.pendown()
mypen.pensize(3)

for x in range(4):
mypen.forward(600)
mypen.right(90)

mypen.hideturtle()

#거북이의 움직임 속도
speed = 1

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

실행 결과

Turtle Game 3 - 울타리 만들기 끝

Turtle Game 2 - Turtle 움직임 제어하기

오비티 — Mon, 18 May 2020 04:13:59 +0900

Turtle Game 2 - Turtle 움직임 제어하기

Turtle Game 2 - Turtle 움직임 제어하기

앞선 강좌에서 turtle 모듈을 이용하여 거북이를 생성하고 움직이는 것을 구현하였다.

하지만 while 구문에 의해서 거북이는 앞으로만 움직였으며, 화면 밖으로 넘어가서도 여전히 앞으로만 움직이고 있을 것이다.

이제 키보드의 방향키를 이용하여 거북이의 움직임을 제어하는 코드와 거북이의 속도를 제어하는 코드를 추가해본다.

1. 키보드의 입력 대기

Turtle 모듈의 Screen() 객체는 화면(window) 안에서 일어나는 이벤트를 관리한다.

따라서 키보드의 입력을 기다리기 위해서 listen() 메서드를 이용하여 키보드의 입력, 즉 키보드 입력 이벤트를 대기하는 코드를 추가한다.

screen.listen()

2. 키보드 이벤트 제어

키보드의 입력 이벤트는 스크린 객체의 onkey() 메서드로 체크할 수 있다. 키보드 입력 이벤트 메서드는 아래와 같다.

onkey() | onkeyrelease() - 키보드의 키를 눌렀다가 뗄 때 발생하는 이벤트

onkeypress() - 키보드의 키를 누르고 있을 때 발생하는 이벤트

추가적으로 마우스 클릭 이벤트에 대한 메서드는 아래와 같다.

onclick() | onscreenclick() - 마우스를 클릭했을 때 발생하는 이벤트

onkey() 이벤트를 사용하기 위해서는 아래와 같은 형태로 사용하면 된다.

screen.onkey(함수, 키보드의 키 심볼)

즉, 키보드의 키를 눌렀다가 뗄 때, 함수를 실행시키게 된다. 연결할 함수의 이름만 적어주며 괄호는 넣지 않는다.

3. 방향키를 이용하여 함수 실행

키보드 이벤트에 대한 코드를 이해하였다면, 방향키를 이용하여 함수를 실행하는 코드를 작성해본다.

왼쪽 방향키(←) 를 누르면 왼쪽으로, 오른쪽 방향키(→)를 누르면 오른쪽으로 방향을 변경하는 코드와

위(↑), 아래 방향키(↓)를 통해 속도를 제어하는 코드를 만들어 본다.

screen.onkey(turnleft, "Left")

screen.onkey(turnright, "Right")

screen.onkey(increasespeed, "Up")

screen.onkey(decreasespeed, "Down")

왼쪽 방향키의 심볼은 "Left"이다.

오른쪽 방향키의 심볼은 "Right"이다.

위쪽 방향키의 심볼은 "Up"이다.

아래쪽 방향키의 심볼은 "Down"이다.

자세한 키보드 심볼은 다음 주소에서 확인할 수 있다. https://www.jbmpa.com/python_tip/7

4. 함수 생성

키보드 이벤트를 통해서 키보드를 눌렀을 때 실행 할 함수를 만들어본다.

def turnleft():
p.left(30)

turnleft() 함수는 screen.onkey(turnleft, "Left") 에서 지정한 함수이다. 즉, 왼쪽 방향키를 눌렀을 때 실행할 함수이다.

거북이 객체 p는 left()라는 메서드를 통해서 방향을 변경한다.

최초 거북이가 생성되면 거북이는 오른쪽으로 머리를 향하게 된다.

이때, left(각도)를 이용하여 거북이를 왼쪽으로 지정한 각도만큼 방향을 변경해 줄 수 있다.

위의 코드는 왼쪽 방향키를 눌렀다가 뗐을 때, 왼쪽으로 30도만큼 방향을 변경하라는 의미가 된다.

마찬가지로 오른쪽 방향키를 눌렀을 때, 방향을 변경하는 코드는 아래와 같다.

def turnright():
p.right(30)

마지막으로 위 방향키(↑)를 눌렀을 때, 거북이의 속도를 높이고, 아래 방향키(↓)를 눌렀을 때 거북이의 속도를 낮추는 코드는 아래와 같다.

speed 변수는 함수 밖에서 선언되었고, 모든 곳에서 사용되어야 하므로 전역변수(global)로 선언하여 사용한다.

def increasespeed():

global speed
speed += 1

def decreasespeed():

global speed
speed -= 1

전체코드는 아래와 같다.

주의할 점은 while True: 구문이 가장 마지막에 있어야 한다. 이유는 while True:구문을 만나면 무한반복을 하므로, while True:구문 다음이 실행되지 않는다. 따라서 모든 코드는 while True:구문 앞에 와야 한다.

import turtle as t

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

#거북이의 움직임 속도
speed = 1

def turnleft():
p.left(30)

def turnright():
p.right(30)

def increasespeed():
global speed
speed += 1

def decreasespeed():
global speed
speed -= 1

screen.listen()
screen.onkey(turnleft, "Left")
screen.onkey(turnright, "Right")
screen.onkey(increasespeed, "Up")
screen.onkey(decreasespeed, "Down")

while True:
p.forward(speed)

실행 결과

# 방향키를 이용하여 거북이의 방향과, 속도를 조절해보자.

# 아래의 캡쳐된 이미지는 거북이의 움직임을 보여주기 위해서 p.penup() 부분을 주석처리하여 실행한 결과이다.

Turtle Game 2 - Turtle 움직임 제어하기 끝

Turtle Game 1 - Turtle 모듈 사용하기

오비티 — Mon, 18 May 2020 04:13:20 +0900

Turtle Game 1 - Turtle 모듈 사용하기

Turtle 모듈 사용하기

Turtle은 그래픽 환경에서 프로그래밍을 쉽게 배울 수 있도록 파이썬에서 제공하는 모듈이다. Turtle 모듈의 몇 가지 메서드를 익혀서 사용하면 간단하게 게임을 만들 수 있다.

기본적으로 사각형, 삼각형, 거북이 모양의 Shape를 이용하여 앞으로, 뒤로 가는 등의 동작을 만들 수 있고, Shape의 이동 궤적을 선으로 그려줌으로써 다양항 도형등을 만들어 낼 수 있다.

Turtle 모듈의 문서는 아래의 링크에서 모두 확인 할 수 있다.

https://docs.python.org/3.7/library/turtle.html

본 강좌에서 사용하는 Turtle Game의 내용은 아래의 유튜브 강좌를 참고하였으며, 본 강좌에서 몇 개의 기능을 추가하였다.

영상으로 보고자하면 아래의 링크에서 강좌를 따라가면 된다. 참고로 영어로 된 강좌이나 코드를 보면 쉽게 이해가능 할 것이다.

https://www.youtube.com/watch?v=PTgyzZGknvg

Turtle Game 만들기 1

Turtle 모듈을 사용하기 위해서는 turtle 모듈을 import 하기만 하면된다.

아래의 코드를 통해서 간단히 turtle 모듈을 실행해본다.

import turtle as t

screen = t.Screen()

p= t.Turtle()
p.shape("turtle")

screen.mainloop()

위의 코드를 입력하고 Ctrl + F11을 눌러 실행하면 아래의 그래픽 화면이 나타나게 된다.

코드 설명

>> import turtle as t

turtle 모듈을 t 라는 이름으로 import 한다.

>> screen = t.Screen()

t 모듈의 Screen() 객체를 통해 전체 화면을 제어하는 객체를 생성한다.

Screen() 객체는 화면의 크기, 배경색, 키보드 입출력 이벤트등을 관리한다.

>> p = t.Turtle()
>> p.shape("turtle")

t 모듈의 Turtle() 객체를 이용하여 turtle을 생성한다. Turtle 객체는 모양, 모션, 펜, 상태등을 관리한다.

Turtle() 객체를 통해 생성된 객체를 p에 저장하고 나서, p의 모양(shape)을 "turtle"로 설정해준다.

모양(shape)은 다음 7개를 설정해 줄 수 있다. shape()에 아무값도 넣지 않은 default 는 "classic" 이다.

"arrow"

"blank"

"circle"

"classic"

"square"

"triangle"

"turtle"

>> screen.mainloop()

메인 화면을 유지시켜주는 역할을 한다. 파이썬의 command prompt는 실행이 모두 되고나면 기본적으로 화면이 꺼진다.

따라서 코드대로 모두 실행후에 화면이 꺼지기 때문에 메인화면을 반복적으로 실행시켜 화면이 꺼지지 않게 한다.

이후에 다른 코드를 넣고나서 mainloop()가 필요없어질 때 위 코드는 삭제나 주석처리를 하도록 한다.

1. 화면 배경색, 거북이 색상 변경

위의 코드를 이해했으면, 화면의 배경색, 거북이의 색상등을 변경하는 코드를 추가한다.

코드에 대한 설명은 주석으로 대신한다.

import turtle as t

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

#Turtle 객체 p 생성
p = t.Turtle()
#p 객체의 모양을 거북이로 만들기
p.shape('turtle')
#p 객체 크기 설정
p.turtlesize(2,2)
#p 객체 색상 설정,
#색상은 색상 이름 또는 색상 코드(#FFFFFF) 등을 이용하여 설정 할 수 있다.
p.color("blue")

screen.mainloop()

실행 결과

- 화면 배경색 lightgreen

- 거북이 크기 2

- 거북이 색상 blue

2. 거북이 움직임 생성

우리는 거북이를 이용하여 게임을 만들기로 했으므로 정적인 거북이를 동적으로 만들어야 한다.

생성된 거북이를 지속적으로 움직이게 만드는 코드를 넣기 위하여 아래의 코드를 추가한다.

while True:

p.forward(1)

생성된 p 객체를 앞으로 움직이게 만드는 메서드는 forward()이다.

while 구문을 이용하여 거북이를 앞으로 계속 움직이게 만든다.

while 구문에 의하여 메인화면이 지속적으로 유지되므로 screen.mainloop() 코드는 주석처리나 삭제를 해도 된다.

수정된 코드

import turtle as t

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

while True:
p.forward(1)

#screen.mainloop()

실행 결과

실행을 하고 나면 거북이는 앞으로 계속 1칸씩 움직이게 된다. 그리고 화면 밖으로 벗어날 것이다.

거북이의 움직임은 다음에 제어하도록 하고, 우선은 거북이가 움직일때마다 따라나오는 선을 없애보도록 한다.

Turtle 모듈에서 생성된 객체는 기본적으로 자신의 움직임을 선으로 그리게 된다.

선은 pen 메서드로 제어하며, 아래와 같이 사용할 수 있다.

pendown() - 선 그리기, 기본값

penup() - 선 그리지 않기

pensize() - 선 크기

pencolor() - 선 색상

선을 그리거나, 안 그리는 것은 우리가 글씨를 쓸 때 펜을 종이에 붙이는 개념으로 이해하면 된다.

따라서 pendown()은 종이에 펜을 대는 것이기 때문에 선이 그려지고,

penup()은 펜을 종이에서 떼는 것이기 때문에 선을 그리지 않는다.

따라서 p 객체에 penup() 메서드를 추가한다.

p.penup()

그리고 차후에 거북이의 속도를 제어하기 위해서 속도를 speed 변수를 이용하여 앞으로 가는 거리, 즉 forward() 값을 제어한다.

전체 코드

import turtle as t

#스크린 객체 생성
screen = t.Screen()
#스크린 배경색 지정
screen.bgcolor("lightgreen")

#거북이를 따라다니는 선을 제거
p.penup()

#거북이의 움직임 속도
speed = 1

while True:
p.forward(speed)

#screen.mainloop()

실행 결과

Turtle Game 1 - Turtle 모듈 사용하기 끝

두 개의 점과 점 사이의 거리 구하기

오비티 — Mon, 18 May 2020 04:12:15 +0900

두 개의 점과 점 사이의 거리 구하기

점과 점 사이의 거리 구하기

프로그래밍으로 2D 그래픽을 처리하려면 반드시 좌표(coordinates)에 대해서 알아야 한다.

일반적으로 좌표는 평면을 상하, 좌우로 선을 긋고 좌우의 선을 X축, 상하의 선을 Y축이라 표현한다.

X축과 Y축이 만나는 지점을 0으로 두고, 좌표는 (X축의 0점과의 거리, Y축의 0점과의 거리)로 표현된다.

X, Y 축 좌표

위의 좌표 상의 점 P1은 X축으로 2, Y축으로 3인 위치에 존재한다. 또한 P2는 X축으로 4, Y축으로 1인 위치에 존재한다.

두 점 사이의 거리를 구해보자.

우선, 피타고라스의 정리에서 직각을 끼고 있는 변 A, B와 빗변 C와의 관계는 A ** 2 + B ** 2 = C ** 2 와 같다.

즉, A의 제곱 + B의 제곱 = C의 제곱이 된다.

이를 위의 좌표에서 살펴보면 아래와 같다.

위의 그림에서 A의 길이는 2, B의 길이는 2이다.

이를 수식으로 표현하면 아래와 같다.

A = P2.X - P1.X = 4 - 2

B = P2.Y - P1.Y = 1 - 3

피타고라스의 정리에 의해 A와 B는 제곱을 할 것이므로 P1과 P2의 순서는 관계없다. 즉, P1 - P2 건 P2 - P1이건 상관 없다.

파이썬에서 제곱을 만드는 방법은 두가지가 있다.

1. 연산자로 제곱을 만드는 방법

A = P.X ** 2

2. 함수로 제곱을 만드는 방법

A = math.pow(P.X , 2)

위의 함수를 이용하여 A의 제곱 + B의 제곱을 구하면 아래와 같다.

math.pow(P1.X - P2.X , 2) + math.pow(P1.Y - P2.Y , 2)

이제 C값을 구하면 된다.

하지만 C의 제곱이 A의 제곱 + B의 제곱이므로, 우리가 원하는 점과 점사이의 거리는 A의 제곱 + B의 제곱한 결과의 제곱근(root)을 구해야 한다.

파이썬에서 root를 구하는 함수는 math.sqrt이다.

따라서 C는 아래와 같이 구할 수 있다.

C = math.sqrt( math.pow(P1.X - P2.X , 2) + math.pow(P1.Y - P2.Y , 2) )

모든 프로그래밍 공식은 만들어 졌다.

아래의 코드를 통해 실제 적용되는 점과 점 사이의 거리를 구해보자.

import math

# 점과 점 사이의 거리 구하는 함수
def distance(x1, y1, x2, y2):
result = math.sqrt( math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2))
return result

# 두 점의 좌표를 정한다.
P1 = (4, 1)
P2 = (2, 3)

#함수 호출
d = distance(P1[0], P1[1], P2[0], P2[1])

print(d)

2.8284271247461903

점과 점사이의 거리를 2차원 평면상에서 두 개의 객체의 거리라 생각할 수 있다. 따라서 이는 객체 사이의 거리를 계산하는 매우 중요한 방법 중 하나이다.

간단한 게임을 만들면서 이를 실제 이용해 보도록 한다.

현재 시간과 지난 시간 표시하기 time, datetime, elapsedtime

오비티 — Mon, 18 May 2020 04:11:24 +0900

현재 시간과 지난 시간 표시하기 time, datetime, elapsedtime

1. datetime 으로 시간 표시

import datetime

now = datetime.datetime.now()

print( now )
print( now.year )
print( now.month )
print( now.day )
print( now.hour )
print( now.minute )
print( now.second )

s = "%04d-%02d-%02d %02d:%02d:%02d" % (now.year, now.month, now.day, now.hour, now.minute, now.second)
print(s)

# 또는

s = now.strftime("%Y-%m-%d %H:%M:%S")

print(s)

# 또는

import time

# 유닉스 타임으로 변환 ( 1580628774 형식 시간)

utime = time.mktime(now.timetuple())

# 유닉스 타임을 시분초년월일 형식으로 변환

s = datetime.datetime.fromtimestamp(utime)

print(s)

2019-05-27 23:45:57.052725
2019
5
27
23
45
57
2019-05-27 23:45:57

2019-05-27 23:45:57

2. time 으로 시간 표시

import time

now = time.localtime()

print( now )
print( now.tm_year )
print( now.tm_mon )
print( now.tm_mday )
print( now.tm_hour )
print( now.tm_min )
print( now.tm_sec )

s = "%04d-%02d-%02d %02d:%02d:%02d" % (now.tm_year, now.tm_mon, now.tm_mday, now.tm_hour, now.tm_min, now.tm_sec)
print(s)

# 또는

s = time.strftime("%Y-%m-%d %H:%M:%S", now)

print(s)

time.struct_time(tm_year=2019, tm_mon=5, tm_mday=27, tm_hour=23, tm_min=47, tm_sec=39, tm_wday=0, tm_yday=147, tm_isdst=1)
2019
5
27
23
47
39
2019-05-27 23:47:39

2019-05-27 23:47:39

3. 경과 시간 계산하기

프로그램이 시작되고 경과된 시간을 00일 00시간 00분 00초 형식으로 표현하는 방법

import time

start_time = time.time()

def elapsedTime():

  # 현재의 시간에서 시작 시간을 빼준다. 경과시간 추출
  elapsed_time = time.time() - start_time

# 경과시간을 60으로 나누어 분(minute)과 초(second)를 구분한다.
m, s = divmod(elapsed_time, 60)

# 분을 60으로 나누어서 시간(hour)과 분(minute)을 구분한다.
h, m = divmod(m, 60)

# 시간을 24로 나누어서 일(day)과 시간(hour)을 구분한다.
  d, h = divmod(h, 24)

  if d > 0:
dtime = str(int(d)) + "일 "
else:
dtime = ""

if h > 0:
htime = str(int(h)) + "시간 "
else:
htime = ""

if m > 0:
mtime = str(int(m)) + "분 "
else:
mtime = ""

strTime = dtime + htime + mtime + str(int(s)) + "초"

return strTime

while True:
  try:
  #경과 시간 정보 출력
print(elapsedTime())
  except:
  pass
time.sleep(1)

0초
1초
2초
3초
4초
5초
6초
7초
8초
...

...