728x90
반응형
SMALL

 

 

# 서버코드
import socket
import argparse
import threading
import time

user_list = {}

def handle_receive(client_socket, addr, user):
    while 1:
        data = client_socket.recv(1024)
        data = data.decode()

        if data == "/종료" or data == "/exit" : break        
        print(user,data)

        #받은 데이터를 모든 클라이언트에게 전송한다.
        for con in user_list.values():
            try:
                con.sendall(data.encode())
            except:
                print("클라이언트 소켓 에러")

    del user_list[user]
    client_socket.close()

if __name__ == '__main__':

    host = "host_ip" #127.0.0.1
    port = 4000

    #IPv4 체계, TCP 타입 소켓 객체를 생성
    # socket.AF_INET: 해당 소켓을 IP version 4 용으로 사용하겠다는 의미
    # socket.SOCK_STREAM: 해당 소켓에 TCP 패킷을 받겠다는 의미
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    #포트를 사용 중 일때 에러를 해결하기 위한 구문
    #기본적으로 socket을 사용하고 나면 사용한 port는 close로 닫아주는게 맞다.
    #그래야 해당 port를 다른데서도 사용할 수 있으니깐.
    #근데 port를 닫았다고해도 일정시간 동안은 TIME_WAIT 상태로 대기한다고 한다.
    #그리고 이 상태에서는 즉각적으로 다시 바로 사용할 수 없다.
    #그래서 socket을 쓰고 close를 했는데도 already in use 에러가 발생하게된다.
    #이런 에러를 막기위해서 setsockopt을 사용한다. 사용법은 아래와 같다.
    #socket.SO_REUSEADDR: 방금 사용하고 close한 port를 즉시 다시 사용한다는 의미
    server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    #ip주소와 port번호를 함께 socket에 바인드 한다.
    #포트의 범위: 1~65535
    server_socket.bind((host, port))
    server_socket.listen(5)# 클라이언트 최대 접속 수

    print('채팅서버를 시작합니다.')
    while 1:
        try:
            #클라이언트 함수가 접속하면 새로운 소켓을 반환한다.
            client_socket, addr = server_socket.accept()#클라이언트 접속까지 대기함
        except:            
            #의도하지 않은 서버 종료에 대한 예외 처리
            #프로그램 중단시 모든 클라이언트 소켓들 닫기.
            for user, con in user_list:
                con.close()
            server_socket.close()            
            break

        user = client_socket.recv(1024)
        user = user.decode()
        print(user,'서버에 접속하였습니다.')
        user_list[user] = client_socket
                        
        #daemon 속성은 서브쓰레드가 데몬 쓰레드인지 아닌지를 지정하는 것인데,
        #데몬 쓰레드란 백그라운드에서 실행되는 쓰레드로 메인 쓰레드가 종료되면 즉시 종료되는 쓰레드이다.
        #반면 데몬 쓰레드가 아니면 해당 서브쓰레드는 메인 쓰레드가 종료할 지라도 자신의 작업이 끝날 때까지 계속 실행된다.
        receive_thread = threading.Thread(target=handle_receive, args=(client_socket, addr,user))
        receive_thread.daemon = True
        receive_thread.start()
import socket
import threading

def handle_receive(client_socket, user):
    while True:
        try:
            data = client_socket.recv(1024)#데이터가 수신될 때까지 대기함
        except:
            print("연결 끊김")
            break
        data = data.decode()#바이트 타입의 데이터를 decode()로 문자열로 변환
        if not user in data:#자신의 데이터를 제외한 나머지 데이터를 출력함
            print(data)

def handle_send(client_socket, user):
    while True:        
        data = input()#사용자로부터 문자열을 입력받는 함수
        #데이터는 encode()함수를 이용하여 바이트형으로 변환
        client_socket.sendall(data.encode())#소켓을 통해 서버로 데이터 보내기
        if data == "/종료" or data == "/exit": break
    client_socket.close()
    print('소켓 닫기')


if __name__ == '__main__':
    
    port = 4000 # 포트넘버
    host = 'server_ip' #서버 IP #127.0.0.1
    user = 'user_id'

    #IPv4 체계, TCP 타입 소켓 객체를 생성
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 지정한 host와 prot를 통해 서버에 접속합니다.
    client_socket.connect((host, port))

    # 문자열을 전송할 때 encode()을 이용한다. 파이썬 문자열의 encode() 메소드는 문자열을 byte로 변환해주는 메소드이기 때문이다.
    # 파이썬 내부에서 다뤄지는 문자열은 파이썬에서 생성된 객체이고, 이를 바로 트랜스포트에 그대로 싣는 것은 불가능합니다.
    # 그러므로 적절한 인코딩을 하여 보내야만 합니다.
    # 만약 encode()을 사용하지 않을 경우 에러가 발생 한다. 
    client_socket.sendall(user.encode())

    receive_thread = threading.Thread(target=handle_receive, args=(client_socket, user))
    receive_thread.daemon = True
    receive_thread.start()

    send_thread = threading.Thread(target=handle_send, args=(client_socket, user))
    send_thread.daemon = True
    send_thread.start()

    #join()은 부모쓰레드가 자식 쓰레드가 종료될 때까지 기다려준다.
    #즉 전체 프로그램의 실행이 하나의 쓰레드이고 부모쓰레드가 되며,
    #먼저 send_thread, receive_thread가 종료된후 프로그램이 종료하게 된다.
    send_thread.join()    
    receive_thread.join()
728x90
반응형
LIST
728x90
반응형
SMALL

아래 이미지 파일을 다운로드 & 소스와 같은 폴더에 복사후 실행하기 바랍니다.

arrow.png
0.32MB

 

protocol() 함수는 이벤트와 함수를 연결하는 기능을 하며 아래 코드에는 위도우 창 닫기 이벤트(WM_DELETE_WINDOW)와 on_closing() 함수를 연결하여, 윈도우 창을 닫을 때 on_closing() 함수를 호출합니다.

 

from tkinter import *


class StageCanvas:
    def __init__(self,window):
        self.window = window
        self.canvas=Canvas(self.window, bg ="white") # game scene canvas
        self.canvas.create_text(320,300,font="Times 15 italic bold",text="Backspace 키 메뉴로 돌아가기")
        self.canvas.create_text(320,360,font="Times 15 italic bold",text="Stage Scene")
        

    def display(self):
        pass

    def pack(self):
        self.canvas.pack(expand=True, fill=BOTH)

    def unpack(self):
        self.canvas.pack_forget()

    def keyReleaseHandler(self, event):
        if event.keycode == 8:
            return 0
        else:
            return -1

    def destroy(self):
        self.canvas.destroy()


class MenuCanvas:
    def __init__(self,window):
        self.window = window
        self.menu_idx = 0

        self.canvas=Canvas(self.window, bg ="white")# menu canvas

        self.canvas.create_text(320,360,font="Times 15 italic bold",text="Scene Change")
                
        self.canvas.create_text(320,160,font="Times 15 italic bold",text="Start")
        self.canvas.create_text(320,200,font="Times 15 italic bold",text="Option")
        self.canvas.create_text(320,240,font="Times 15 italic bold",text="Exit")


        self.arrowimg = PhotoImage(file="arrow.png").subsample(20)
        self.arrow = self.canvas.create_image(250,160, image = self.arrowimg,tags="arrow")


    def display(self):
        pass
        

    def pack(self):
        self.canvas.pack(expand=True, fill=BOTH)

    def unpack(self):
        self.canvas.pack_forget()


    def keyReleaseHandler(self, event):
        if event.keycode == 38 and self.menu_idx > 0: # up direction key
            self.menu_idx = self.menu_idx - 1
            self.canvas.move(self.arrow, 0, -40)
            return -1
        elif event.keycode == 40 and self.menu_idx < 2: # down direction key
            self.menu_idx = self.menu_idx + 1
            self.canvas.move(self.arrow, 0, 40)
            return -1
        elif event.keycode == 32:
            return self.menu_idx


    def destroy(self):
        self.canvas.destroy()




class SceneChange:
    def __init__(self):
        self.window = Tk()
        self.window.title("장면전환")
        self.window.geometry("640x480")

        self.window.protocol("WM_DELETE_WINDOW", self.on_closing)

        self.scene_idx = 0
        
        self.stage = StageCanvas(self.window)
        self.menu = MenuCanvas(self.window)
        self.menu.pack()


        self.canvas_list = []
        self.canvas_list.append(self.stage)
        self.canvas_list.append(self.stage)

        self.window.bind("<KeyPress>",self.keyPressHandler)
        self.window.bind("<KeyRelease>",self.keyReleaseHandler)

        while True:
            #
            #
            for canvas in self.canvas_list:
                canvas.display()


            self.window.after(33)
            self.window.update()

    def on_closing(self):
        for canvas in self.canvas_list:
            canvas.destroy()

        self.window.destroy()

    def keyReleaseHandler(self, event):

        result = -1

        if self.scene_idx == 0:
            result = self.menu.keyReleaseHandler(event)

        elif self.scene_idx == 1:
            result = self.stage.keyReleaseHandler(event)

        if self.scene_idx == 0 and result==0:
            self.scene_idx = 1
            self.menu.unpack()
            self.stage.pack()

        elif self.scene_idx==1 and result==0:
            self.scene_idx = 0
            self.menu.pack()#메뉴 canvas 나타남
            self.stage.unpack()# Main 장면 canvas 사라짐
                
    def keyPressHandler(self,event):
        print(event.keycode)


SceneChange()
728x90
반응형
LIST
728x90
반응형
SMALL

tkinter 를 이용한 마우스 이벤트는

window에 bind 함수를 이용하여 마우스 이벤트를 각각 연결시킨다.

 

이때 bind() 함수는 다음과 같이 두 개의 이자를 가져야 한다.

 - bind("이벤트명",연결함수) #이벤트 연결을 위한 가장 중요한 함수!!!!!

 

이벤트 종류는 다음과 같다.

<Button-1> : 마우스 왼쪽 버튼 클릭
<Button-2> : 마우스 중간 버튼 클릭
<Button-3> : 마우스 오른쪽 버튼 클릭
<Button-4> : 마우스 휠을 스크롤바에서 위로 올릴 때(scroll up event)
<Button-5> : 마우스 휠을 스크롤바에서 아래로 내릴 때(scroll down event)
<ButtonPress> : 아무 마우스 버튼이라도 눌리면 호출 된다. 휠까지도
<Double-Button-1> : 마우스 왼쪽 버튼 더블 클릭
<Double-Button-2> : 마우스 중간 버튼 더블 클릭
<Double-Button-3> : 마우스 오른쪽 버튼 더블 클릭
<Return> : 엔터가 눌러짐
<Key> : 키가 눌러짐
<Enter> : 마우스 포인터가 위젯에 들어올 때
<Leave> : 마우스 포인터가 위젯을 떠날때
<Configure> : 위젯 사이즈에 변화가 있을때

 

이중에서 마우스와 관련 된 이벤트를 적용한 코드 예제는 아래와 같다.

from tkinter import *

class MouseEvent:
    def __init__(self):
        window = Tk()
        window.title("마우스 이벤트")
        window.geometry("640x480")
        
        self.canvas=Canvas(window, bg ="white")
        self.canvas.pack(expand=True, fill=BOTH)
        window.bind("<Button-1>",self.MouseClickEvent)
        window.bind('<Double-1>', self.MouseDoubleClickEvent)
        window.bind('<B1-Motion>', self.MouseMotionEvent) 

        self.mousestr = "Mouse: "
        self.mouse_id = self.canvas.create_text(320,240,font="Times 15 italic bold",text=self.mousestr)    
        self.canvas.create_text(320,360,font="Times 15 italic bold",text="Mouse Event Example")
        
        while True:
            #
            self.canvas.itemconfigure(self.mouse_id, text=self.mousestr)
            #
            window.after(33)
            window.update()

    def MouseClickEvent(self, event):
        self.mousestr = "Mouse: " + str(event.x) + ", " + str(event.y) + "에서 마우스 클릭 이벤트 발생"
        

    def MouseDoubleClickEvent(self, event):
        self.mousestr = "Mouse: " + str(event.x) + ", " + str(event.y) + "에서 마우스 더블 클릭 이벤트 발생"

    def MouseMotionEvent(self, event):
        self.mousestr = "Mouse: " + str(event.x) + ", " + str(event.y) + "에서 마우스 모션 이벤트 발생"


MouseEvent()
728x90
반응형
LIST
728x90
반응형
SMALL

애니메이션 이미지는 여러개의 이미지가 겹쳐진 gif 포맷으로 되어 있다

그 이미지를 파이썬에 적용하기 위해서는 gif 가 몇장의 이미지로 구성되어 있는지 확인을 해야한다.

[gif png, jpg 이미지 추출 방법]

gif 읽기 방법은 gif 의 이미지들 모두 읽어서 각각 리스트에 저장하고

 

다음 이미지를 한장씩 보여주면서 애니메이션이 재생되는 방식이다.

 

그래서 리스트에 gif 에 포함된 모든 이미지를 저장하고 index를 증가시키면서 다음이미지를 보여준다.

 

for 문과 PhotoImage 함수를 이용하여 gif 파일 안에 이미지를 하나씩 읽어 올 수 있다. 이때 중요한 부분은 format 설정임(아래 코드 참조)

 

dragon-gif.gif
0.43MB

 

from tkinter import * # tkinter에서 모든 정의를 임포트한다.


class LoadGIFImage:
	def __init__(self):
		window = Tk() # 윈도우 생성
		window.title("GIF Image Example") # 제목을 설정
		window.geometry("640x480") # 윈도우 크기 설정
		window.resizable(0,0)        
		self.canvas = Canvas(window, bg = "white")
		self.canvas.pack(expand=True,fill=BOTH)	
		
		self.my_image_number = 0 
		#마지막 range(60) 에서 60 은 gif 이미지 수를 나타냄
		#gif 파일의 이미지를 한장씩 읽고 리스트에 저장함
		self.myimages = [PhotoImage(file='dragon-gif.gif',format = 'gif -index %i' %(i)) for i in range(60)]
		
		
		#아래 코드에서 subsample(2) 는 이미지 크기를 작게함. 인수 값에 따라 작아짐
		#self.myimages = [PhotoImage(file='dragon-gif.gif',format = 'gif -index %i' %(i)).subsample(1) for i in range(60)]

		#이미지를 canvas에 그리고 id 값을 생성후 self.dragon 변수에 저장
		self.dragon = self.canvas.create_image(300,240, image = self.myimages[0],tags="dragon")

		self.canvas.create_text(320,360,font="Times 15 italic bold",text="Load GIF Image")

		while True:

			#canvas에서 self.dragon 이미지를 읽어오고 gif의 다음 이미지로 교체함
			self.canvas.itemconfig(self.dragon, image = self.myimages[self.my_image_number%len(self.myimages)])    

			self.my_image_number += 1
			window.after(33)
			window.update()

		#window.mainloop() # 이벤트 루프를 생성한다.


LoadGIFImage() # GUI 생성한다.

 

728x90
반응형
LIST
728x90
반응형
SMALL

아래 이미지, 사운드(효과음) 파일을 다운로드 받고 소스코드 폴더에 함께 복사한 후 실행시키기 바랍니다.

tank.png
0.14MB
tankmove.MP3
0.29MB

from tkinter import *
import pygame

class ObjectControlByKeyEvent:
    def __init__(self):
        window = Tk()
        window.title("키보드를 이용한 이미지 컨트롤")
        window.geometry("640x480")
        self.keys = set()
        self.canvas=Canvas(window, bg ="white")
        self.canvas.pack(expand=True, fill=BOTH)
        window.bind("<KeyPress>",self.keyPressHandler)
        window.bind("<KeyRelease>",self.keyReleaseHandler)
        
        self.tankimg = PhotoImage(file="tank.png").subsample(8)
        self.tank = self.canvas.create_image(320,240, image = self.tankimg,tags="tank")

        #Effect sound
        self.sounds = pygame.mixer
        self.sounds.init()
        self.s_effect1 = self.sounds.Sound("tankmove.mp3")
        
        self.canvas.create_text(320,350,font="Times 15 italic bold",text="← 또는 → 키를 입력하시오")
        self.canvas.create_text(320,450,font="Times 15 italic bold",text="Object Control By KeyEvent")

        while True:
            #
            self.display()
            window.after(33)
            window.update()

    def display(self):
        for key in self.keys:
            if key == 39: # right direction key                
                #self.s_effect1.play()
                self.canvas.move(self.tank, 5, 0)
            if key == 37: # left direction key                
                #self.s_effect1.play()
                self.canvas.move(self.tank, -5, 0)

    def keyReleaseHandler(self, event):
        if event.keycode in self.keys:
            #self.s_effect1.stop()
            self.keys.remove(event.keycode)

    def keyPressHandler(self,event):        
        self.keys.add(event.keycode)
        
ObjectControlByKeyEvent()
728x90
반응형
LIST
728x90
반응형
SMALL

파이썬에서 모든 이벤트 처리는 bind를 통해서 이루어진다. bind는 "묶다" 라는 의미로서 이벤트가 발생할 때 어떠 함수가 호출 되도록 할 것인지를 연결하는 역할을 합니다. 다른 언어에도 bind 이외에 다른 용어 또는 키워드를 사용하지만 동일한 의미를 가지고 있습니다.
 
파이썬에서 이벤트와 함수와의 연결은 아래와 같은 형식으로 작성을 합니다.
 

widget.bind("이벤트 종류",함수명)
 

위젯은 윈도우, 버튼, 라벨 등 을 작성하고 bind() 함수를 이용하여 위젯에 발생한 이벤트를 두번째로 작성된 함수명으로 전달을 합니다.  아래 코드는 window 위젯에 키 이벤트처리를 위한 기본 예제 코드입니다.

from tkinter import *


def keyPressHandler(event):
	print("Press: ",event.keycode)

def keyReleaseHandler(event):
	print("Release: ",event.keycode)

window = Tk()
window.geometry("640x480")

window.bind("<KeyPress>",keyPressHandler)
window.bind("<KeyRelease>",keyReleaseHandler)

window.mainloop()

키를 눌렀을 때 KeyPressHandler 함수가 호출되고 호출된 함수안에 작성된 print() 함수를 실행합니다(Line 4, 5). 이때 계속 누르고 있으면 연속으로 계속 호출되는 것이 아닌 키를 누르는 시점에 한 번 호출됩니다. 반대로 키를 떼는 순간 keyReleaseHandler() 함수를 호출합니다.
이벤트에 의해 호출되는 함수를 정의할 때는 항상 매개변수 1개를 선언해야 합니다. 매개변수의 역할은 이벤트가 발생할 때 이벤트에 대한 정보를 함께 함수로 전달하는데 이때 전달된 정보가 매개변수에 저장됩니다. 위 예제의 키 이벤트의 경우 어떤 키가 눌러졌는지 키 정보가 event 변수에 저장됩니다. 그리고 event.keycode는 눌러진 키의 아스키코드 값을 알 수 있습니다.
키보드 이외에 마우스와 같은 많은 이벤트들이 있으며 필요에 따라 직접 찾아서 사용해보기 바랍니다.
 
이제 키보드 이벤트 기능을 게임 기본구조 코드에 적용하도록 하겠습니다.
일반적으로 게임에서는 키 입력에 따른 콘텐츠를 조작을 위해 키보드 이벤트를 사용한다. 이때 2가지 중요한 이슈가 있는데,
 
첫번째는 2개 이상의 키입력을 어떻게 처리 할 것인가?
두번째는 이벤트 처리 시점 입니다.
 
2개 이상의 키를 눌렀을 때 눌러진 상태를 알려주는 친절한 프로그래밍 언어는 없습니다.(라이브러리에서 지원해주는 경우는 있음) 가령, 대각선 위(북동 방향)로 계속 이동하도록 프로그래밍을 한다고 가정을 하였을 때, →, ↑ 방향 키를 동시에 누르고 있으면 두 키가 눌러진 시점에서 이벤트만 한번이 발생하고 끝입니다. 아래와 같이 프로그래밍을 한다면 누르는 시점 한번만 이동하고 더이상 움직임이 없다는 것입니다.

def keyPressHandler(event):
	if (event.keycode==38):#아스키코드 38 는 ↑ 키
    	# 콘텐츠 위로 이동 코드
	elif (event.keycode==39):#아스키코드 39 는 → 키
    	# 콘텐츠 앞으로 이동 코드

그래서
1. 키 이벤트 발생한 시점에서 콘텐츠(이미지)의 이동 코드를 작성하면 안되고, 콘텐츠의 이동 코드는 다른 코드영역(무한루프 영역)에서 작성해야 합니다.
2. KeyPress 이벤트 처리 함수에는 어떤 키가 눌러졌는지에 대한 키 정보를 저장하는 코드를 작성합니다. 그리고 KeyRelease 에는 저장된 키 정보에서 떼어진 키를 삭제하는 코드를 작성합니다.
 
 
앞에 내용들을 포함하여 작성한 코드는 아래와 같습니다.

from tkinter import *

keys = set()

def keyReleaseHandler(event):
    if event.keycode in keys:
        keys.remove(event.keycode)

def keyPressHandler(event):
    keys.add(event.keycode)
        
window = Tk()
window.geometry("640x480")

window.bind("<KeyPress>",keyPressHandler)
window.bind("<KeyRelease>",keyReleaseHandler)                

while True:
	#
	if (len(keys)>0):
		print("Key: ", keys)
	#
	window.after(33)
	window.update()

눌러진 키 정보를 저장할 때는 파이썬 자료구조 중 집합인 set() 을 이용하였습니다. set() 의 경우 유일한 값만 가지기 때문에 동일한 키값을 입력해도 자동으로 하나로 처리가 되는 장점이 있습니다.
 
위 코드를 게임 기본 코드 구조에 적용하면 아래와 같습니다. 이벤트 처리 함수의 경우, 클래스 멤버함수이기 때문에 매개변수가 하나 더 추가 되며 두번째 매개변수에 이벤트 정보가 저장됩니다.

from tkinter import *

class KeyboardEvent:
    def __init__(self):
        window = Tk()
        window.title("키보드 이벤트")
        window.geometry("640x480")
        
        self.keys = set()
        self.canvas=Canvas(window, bg ="white")
        self.canvas.pack(expand=True, fill=BOTH)
        
        window.bind("<KeyPress>",self.keyPressHandler)
        window.bind("<KeyRelease>",self.keyReleaseHandler)                
        
        self.canvas.create_text(320,400,font="Times 15 italic bold",text="Key Event Example")
        
        while True:
            #
            if(len(self.keys)>0):
            	print("Key: ", self.keys)            
            #
            window.after(33)
            window.update()

    def keyReleaseHandler(self, event):
        if event.keycode in self.keys:
            self.keys.remove(event.keycode)

    def keyPressHandler(self,event):
        self.keys.add(event.keycode)

KeyboardEvent()
728x90
반응형
LIST
728x90
반응형
SMALL
from tkinter import *
import pygame

class GameSound:
	def __init__(self):
		window = Tk() # 윈도우 생성
		window.title("게임사운드") # 제목을 설정
		window.geometry("640x480") # 윈도우 크기 설정
		window.resizable(0,0)        
		
		
		self.canvas = Canvas(window, bg = "white")
		self.canvas.pack(expand=True,fill=BOTH)
		window.bind("<KeyPress>",self.keyPressHandler)
		window.bind("<KeyRelease>",self.keyReleaseHandler)

		#pygame 에서 music vs sound
		# music: 배경음악 재생을 위해 사용
		# sound: 효과음을 위해 사용

        #BG sound.
		pygame.init()
		pygame.mixer.music.load("bgm.wav") #Loading File Into Mixer
		pygame.mixer.music.play(-1) #Playing It In The Whole Device
		self.canvas.create_text(320,400,font="Times 15 italic bold",text="Sound Example")

		#Effect sound
		self.sounds = pygame.mixer
		self.sounds.init()
		self.s_effect1 = self.sounds.Sound("gunsound.mp3")
				
		while True:
			#
			window.after(33)
			window.update()

	def keyReleaseHandler(self, event):
		if event.keycode in self.keys:
		    self.keys.remove(event.keycode)

	def keyPressHandler(self, event):		
		self.s_effect1.play()
		self.keys.add(event.keycode)

GameSound()

tkinter에서는 사운드와 관련된 클래스 및 함수를 제공하지 않습니다.  그래서 코드에서는 pygame 모듈을 이용하여 사운드 재생방법을 설명을 하도록 하겠습니다. (앞서 설명된 게임 기본 코드 구조 위에서 추가된 내용들만 설명)

 

사운드의 종류는 크게 기본적으로 배경사운드, 이펙트사운드로 구분될 수 있습니다. 배경사운드는 게임의 전체적인 분위기를 담당하고 이펙트 사운드는 그 순간의 효과 또는 느낌(타격감, 행위(점프, 스피드업, 아이템 획득), 죽음 등)을 담당하며, 사운드를 게임의 진행에 있어서 필수적인 요소입니다. 그래서 위 코드에서는 배경사운드와 이펙트사운드의 재생 방법에 대해서 설명하도록 하겠습니다.

 

pygame에서 사운드 재생 방법은 music와 sound 이렇게 2가지를 제공하고 있습니다.

차이점은 music의 경우 하나의 재생만 가능하고 만약 다른 파일을 load() 해서 재생하면 기존 재생은 멈추게 되며, 반대로 sound 는 여러 개가 동시 재생이 가능하고 같은 사운드의 중첩해서 재생도 가능합니다.

그리고 music의 경우 파일이 저장된 장치(ssd 또는 hard disk 등)에서 재생을 하지만 sound의 경우 파일 전체를 메모리에 가져온 후 재생하게 됩니다. 즉 music은 큰 용량을 가진 음악 파일 재생에 유리하며 sound의 경우 작은 용량과 짧은 사운드(이펙트)에 유리합니다.

그러므로 music의 경우 배경사운드에 이용되고 sound의 경우 이펙트사운드에 사용합니다.

 

위 소스에 대한 주요 코드 설명은 아래와 같습니다.

  • pygame 모듈을 사용하기 위해 pygame을 import 한다.(line 2)
  • pygame을 사용하기 위해서는 pygame.init()함수를 호출해야한다.(line 21)
  • 위 코드에서 music.load(), music.play() 함수를 이용하여 배경음악을 무한반복 재생한다.(line 22, 23)
  • effect sound를 위해 sounds 를 초기화 한다.(line 28)
  • 이펙트 사운드 'gunsound.mp3'  파일을 읽고 sound 객체를 반환한다. sound 객체는 이펙트 사운드는 게임중 재생 및 멈춤을 컨트롤할 수 있다.
  • line 41에서 이펙트 사운드를 재생한다.

위 코드만으로 간단히 게임에서 필요한 음악 재생은 가능하며 좀 더 다양한 기능을 구현하기 위해서는 아래의 링크를 참조하기 바랍니다.

 

 

https://www.pygame.org/docs/ref/music.html

 

pygame.mixer.music — pygame v2.1.1 documentation

Resets playback of the current music to the beginning. If pause() has previoulsy been used to pause the music, the music will remain paused. Note rewind() supports a limited number of file types and notably WAV files are NOT supported. For unsupported file

www.pygame.org

https://www.pygame.org/docs/ref/mixer.html

 

pygame.mixer — pygame v2.1.1 documentation

begin sound playback play(loops=0, maxtime=0, fade_ms=0) -> Channel Begin playback of the Sound (i.e., on the computer's speakers) on an available Channel. This will forcibly select a Channel, so playback may cut off a currently playing sound if necessary.

www.pygame.org

 

 

728x90
반응형
LIST
728x90
반응형
SMALL
from tkinter import *

class BasicForm:
    def __init__(self):
        window = Tk()
        window.title("기본폼")
        window.geometry("640x480")
        
        self.canvas=Canvas(window, bg ="white")
        self.canvas.pack(expand=True, fill=BOTH)

        self.canvas.create_text(320,440,font="Times 15 italic bold",text="Basic Form")
        
        while True:
            #
            window.after(33)
            window.update()


BasicForm()

위 코드와 이후 공유되는 코드들은 파이썬에서 GUI 개발 모듈인 tkinter 를 이용한 게임 제작에 필요한 몇가지 기능들을 구현한 내용입니다.

코드에 대한 설명은 기초적인 파이썬 문법과 클래스에 대한 이해와 사용이 가능하다는 가정하에 작성을 하도록 하겠습니다.

-------------------------------------------------------------------------------------------------------

파이썬에서 tkinter 모듈을 이용하여 GUI 기반의 윈도우 프로그래밍을 할 수 있다. tkinter 에서 가장 기본 단위를 위젯이라고 하며 위젯의 종류에는 버튼(button), 라벨(label), 콤보박스(combobox), 캔버스(canvas) 등 이 있다. 게임을 위해서는 이미지를 이용한 애니메이션이 기본이되며 이와 같은 기능 구현은 캔버스에서 가능하다. 그러므로 작성된 코드에는 사운드를 제외한 대부분의 기능들을 캔버스만을 이용한다.

 

그림 1. 게임 코드 영역

게임을 만들때 일반적으로 코드는 3가지 영역(준비, 무한루프, 이벤트처리)으로 구분되어 작성된다.

  1. 준비영역에서는 윈도우를 생성, 사운드 및 이미지 파일등의 리소스 파일 로딩, 그리고 게임에 필요한 변수들을 초기화하는 코드가 작성된다(line5 ~12). 
  2. 무한루프 영역에서는 게임이 실행되는 동안 변화되는 데이터, 이미지의 위치, 사운드 on / off 등에 대한 코드를 작성한다.(line 15~17)
  3. 마지막으로 이벤츠처리 영역에는 키 또는 마우스 입력이 있을 때 처리해야 될 코드(이미지 위치값 이동, 사운드 on/off등)를 작성한다.(위 예제코드에는 이벤트처리 영역이 미 작성됨)

준비영역은 최초 게임 코드가 시작될 시 한번만 실행되며, 무한루프 영역은 계속 반복해서 실행된다.(일반적으로 while 을 이용한 무한루프형식으로 작성됨) 이벤트처리 영역은 키 또는 마우스 입력이 있을 시 실행되고 실행이 끝나면 다시 무한루프 영역의 코드가 실행되며, 이러한 방식을 Event-based Programming 방식이라고 한다. 무한루프 영역에서 키 또는 마우스 입력이 있을 시 바로 이벤트처리 영역으로 이동하는 것이 아닌 루프영역에서 마지막 코드인 window.update() 함수 호출시 이벤트처리 영역으로 이동하여 코드가 실행된다.

 

준비 영역과 무한루프 영역에 대한 코드 설명은 아래와 같다.

  • 윈도우 프로그래밍에서 가장 먼저 해야될 일은 윈도우 만들기다. Tk 클래스를 이용하여 윈도우 창을 생성할 수 있다.(line 5) 그리고 title, geometry 함수를 이용하여 윈도우 이름과 크기를 설정한다. (line 6~7)
  • 다음으로 캔버스 객체를 생성하는데, 생성시 캔버스가 붙여질 윈도우를 인수로 작성한다.(line 9) 윈도우 틀이 만들어지고 그 앞에 캔버스를 붙인 후 캔버스 위에 원하는 위치에 이미지를 그릴 수 있는 것이다.

그림 2. 윈도우, 캔버스, 이미지 레이어 구조

  • 윈도우도 하나의 위젯으로 생각할 수 있는데 위젯 간에 서로 붙이기 위해서는 붙일 대상 위젯 지정(line 9)과 실제 붙이는 동작이 있어야 되며 그 중에 하나가 pack() 이라는 함수이다.(line 10) 옵션은 윈도우에 꽉차게 그리기 위해 expand를 true 그리고 fill=BOTH로 설정하였다.
  • 캔버스는 도화지 처럼 무엇이든 그릴 수 있는 함수를 제공하고 있다. 그 함수들의 이름은 "create_"로 시작되며 create_rectangle, create_oval, create_line, create_text, create_image 등 그리는데 필요한 다양한 함수들을 이용할 수 있다. 위 코드에서는 create_text() 함수를 이용하여 "Basic Form" 글자를 320, 400 위치에 작성한다.

그림 3. canvas 클래스에서 사용되는 다양한 create 함수들

  • 캔버스에 무언가를 그리기 위해서는 기준좌표와 기준점이 어디 인지 알아야 된다. 아래 그림은 width: 640, hegiht: 480 크기로 그려진 윈도우의 좌표를 보여준다. 윈도우의 기준좌표는 왼쪽 위가 되며 0, 0 의 좌표값을 가진다. 그리고 그려지는 글자는 글자크기의 가운데 위치가 기준점이 된다. 그래서 글자는 코드에서 작성된 320, 400 의 위치에 글자의 기준점이 맞춰서 그려지게 된다.

그림 4. 기준좌표와 기준점

  • 무한루프 영역에서는 윈도우 클래스의 after()와 update() 함수가 호출된다(line 16, 17). after() 에는 33 이 작성되어 있으며 33은 대기 시간(단위: ms) 나타낸다. 위 코드에서는 게임영상을 초당 30 프레임로 동작하게 하기위해 33 을 작성하였다. 마지막으로 update() 함수 호출시 변화된 내용의 반영과 앞서 설명된 키 또는 마우스 이벤트들이 처리된다.
  • 무한루프 영역에서 이미지의 위치 변경 코드가 작성되어 있으면 그 코드가 호출된 시점에서 바로 이미지의 위치변경이 되는 것은 아니다. 이미지의 위치변경 코드가 많을 경우 코드마다 바로 위치변경하여 화면에 보여주게 되면 컴퓨터가 많은 부하가 발생할 수 있다. 그렇게 때문에 변화된 내용들을 모아서 특정 시간 마다 한번에 처리하면 부하를 줄일 수 있다. 모든 게임에서 그래픽 애니메이션은 이러한 방식으로 처리됨을 명심하기 바란다.

앞서 설명된 내용들은 다른 프로그래밍 언어(c++, java, visual basic등)로 게임을 제작할 때도 동일한 영역과 동작방식을 가지고 있어서 위 내용들을 이해하면 다른 프로그래밍 언어를 이용한 게임제작도 쉽게 할 수 있다. 모든 게임 개발 및 동작을 위한 코드 구조가 위와 동일하다고 생각하면된다(Unity, UnReal Engine 역시 기본구조는 동일함).

이상으로 게임 기본구조에 대한 설명 끝~~!

 

코드 실행결과

728x90
반응형
LIST

+ Recent posts