파이썬 유치원 (유아반)

1 파이썬 유치원

파이썬 유치원은 유튜브 채널 김왼손의 왼손코딩에서 구독자와 함께 진행하는 프로젝트입니다. 프로젝트 기간 동안 스스로 학습하면서 나만의 프로그램을 만들어 봅니다. 파이썬 유치원 1기는 2020년 5월 1일부터 31일까지 한달 동안 진행합니다.

파이썬 유치원에는 강의가 없습니다. 사실 강의만 들어서는 머리에 남는 게 없습니다. 직접 만들어 봐야 합니다. 모든 분야가 그렇겠지만 코딩은 더욱 그렇습니다. 이제 강의는 그만 듣고 직접 만들어 봅시다. 모든 정보는 유튜브와 구글에 있으니까요. 파이썬 유치원에서는 방향과 방법을 함께 고민합니다. 유치원 선생님은 아이가 하고 싶은 대로 자유롭게 두면서 아이가 흥미를 잃지 않게, 다치지 않게 옆에서 도와줍니다. 파이썬 유치원에서의 김왼손은 그런 역할입니다.

파이썬 유치원의 모든 진행 상황은 유튜브 채널 김왼손의 왼손코딩에서 공유합니다. 매주 토요일 저녁 유튜브 라이브에서 어떻게 하고 있는지 함께 살펴보고 어려움이 있다면 함께 고민합니다. 각자의 진행 내용은 제타위키의 파이썬 유치원 문서에서 공유합니다. 진행 내용을 공유하고 서로 의견을 나눌 수 있습니다.

파이썬 유치원 유아반은 파이썬이나 코딩을 배워본 적은 있지만 잘 하지 못하는 분들을 대상으로 합니다.

3 유아반 친구들

3.1 맨탈 와르르맨션(맨탈 붕괴)

3.1.1 제목

탐험의 땅,익스(EXplore)

3.1.2 설명

파이게임으로 화면 반복하는 스토리형 탐험게임 만들기(게임명:EXS.the island of traveling(WIDTH:900,HEIGHT:600)

3.1.3 실행화면

실행화면을 넣어주세요.

3.1.4 난이도

총 12스테이지가 있으며,4개 마다 난이도가 달라짐

3.1.4.1 easy

쉬운 적들이 나타남 상점에 약한 무기가 나옴

3.1.4.2 medium

중간 적들이 나타남 상점에 포션이 등장,괜찮은 무기가 등장

3.1.4.3 hard

어려운 적들 등장(???도 등장) 상점에 강력한 무기가 등장

3.1.5 게임 요소

3.1.5.2 적

난이도에 따라서 달라짐(우측 상단에서 확인 가능)

3.1.5.3 상점

3.1.5.3.1 HP포션

HP를 일정량 회복할 수 있고,버프를 주는 것도 있다.

3.1.5.3.2 무기

공격력을 높여주는 아이템.몬스터를 시원하게 날릴 수 있음.

3.1.5.3.3 방어구

플레이어를 방어 해주며, 방어구가 있으면 적이 곤란해 할 수 있다.

3.1.5.4 여관

들어가면 돈을 내고 쉴 수 있다.(HP풀 회복)

3.1.5.5 (이스터 에그?)

쉿,비밀

3.1.6 코드

https://github.com/animicibal22534?tab=repositories

3.1.7 업데이트

가이드 완료(일러스트 몇개 완성)

3.1.8 댓글

• 김왼손: pygame 쉽지 않던데 대단하네요. :)

3.2 김민재

3.2.1 제목

스스로 척척 계산기

3.2.2 설명

파이참을 이용해 계산기 기능과 디자인, 형태까지 만드는 코드

파일:계산기

3.2.3 실행화면

실행화면을 넣어주세요.

3.2.4 코드

# This Python file uses the following encoding: utf-8
# -*- coding: utf-8 -*-

from tkinter import *

def press(value):
    global calc
    global value1
    if value == 'C':
        expression_field.delete(0, "end")
        calc = 0.0
    elif value == '=':
        equalpress()
    else:
        value1 = expression_field.get()
        value1 = value1 + value
        expression_field.delete(0, "end")
        expression_field.insert(0, value1)

def equalpress():
    calc = expression_field.get()
    total = str(eval(calc))
    expression_field.delete(0, END)
    expression_field.insert(0, total)
    calc = ""

window = Tk()
window.title("계산기")

equa = ""
equation = StringVar()
calc = StringVar()
expression_field = Entry(window, width="32", bg="white") #색깔
expression_field.grid(row=0, column=0, columnspan=4)

text_list = ['789/', '456*', '123-', '0.=+']
for r, text in enumerate(text_list):
    for c, t in enumerate(text):
        Button(window, text=t, command=lambda t=t: press(t), height=1, width=7).grid(row=r+1, column=c)

Button(window, text="C", command=lambda: press('C'), height=1, width=7).grid(row=1, column=4)

window.mainloop()

3.2.5 댓글

• 김왼손: 와.. 대부분의 계산기 기능이 만들어졌네요. 계산기는 인터넷에 공개되어 있는 코드가 많을텐데 한번 참고해 보면 어떨까요? :)
• 김민재: 왼손님이 지적해 주신것(코드를 줄여봐라)를 한번 해봤어요. 저는 모르겠었는데 지식인의 도움을 받아서 완성했습니다!
• 김민재: 계산기 디자인은 '#색깔' 한곳만 바꿔주면 디자인이 달라집니다!
• Projects.Kinder : 와~ 반복되었던 버튼에 대한 코드들이 다 사라졌네요!! :) 대단하세요~~ 참고해서 제가 만든 구구단을 업그레이드 해봐야겠어요~~

3.3 김지수

3.3.1 제목

제목을 정해주세요.

3.3.2 설명

3.3.2.1 수준

한입에 쏙 파이썬 2/3 수강, 아직 익숙치 않아서 코드를 따라하면서 매우 낮은 수준의 엑셀 읽고 쓰기 가능

3.3.2.2 목표

업무자동화 프로그램

• 엑셀파일 - pdf 파일(주로 table 자료)을 읽어서 엑셀에 작성
• 함수와 macro를 이용하듯이 파이썬으로 엑셀을 활용하고 싶습니다. ( ex : 회사 재고의 수입된 날짜와 로트 별로 집계 금액 산출)
• 항목별 책정된 금액을 재고 별로 할당하는 시스템. 예를 들자면 총 자금 100만원 중 50만원을 'A' 항목에 책정하고 그 금액은 'a1','a2','a3' 재고에만 할당시켜서 자동으로 매출매입현황을 파악할 수 있는 엑셀 환경을 파이썬으로 구축하고 싶습니다.
• 관심있는 특정 키워드를 포함한 뉴스기사 서칭
• '3'의 내용을 보고할 목적으로 이메일 전송

3.3.3 실행화면

실행화면을 넣어주세요.

3.3.4 코드

from openpyxl import load_workbook
import pandas as pd
from pandas import Series, DataFrame
import win32com.client as win32
excel = win32.gencache.EnsureDispatch('Excel.Application')
import os
import warnings 
warnings.filterwarnings("ignore")

def sort():
    ws1['A1'].value = '년'
    ws1['B1'].value = '월'
    ws1['C1'].value = '품목명'
    ws1['D1'].value = '수량'
    ws1['E1'].value = '단가'
    ws1['F1'].value = '공급가액'
    ws1['G1'].value = '부가세'
    ws1['H1'].value = '합계'
    ws1['I1'].value = '거래처명'
    ws1['J1'].value = '적요'

wb1 = load_workbook('testing.xlsx', data_only = True)
ws1 = wb1['Sheet1']
wb1.remove(wb1['Sheet1'])
ws1 = wb1.create_sheet('Sheet1')
ws1 = wb1['Sheet1']

sort()

user_input = '' 
user_input = input('몇 월 까지의 매출 자료를 불러옵니까? : ')
for month in range(1,int(user_input)+1):
    wb2 = load_workbook(str(str(month).zfill(2))+'매출.xlsx',data_only = True)
    ws2 = wb2['판매현황']
    for row1 in ws2.rows:
        if '계' and '일자' not in row1[0].value and '-' in row1[0].value :
            devision = [str(row1[0].value).split('/')[0], str(row1[0].value).split('/')[1],str(row1[1].value).split(' [')[0]]
            for num in range(2,9):
                devision.append(str(row1[num].value))
            ws1.append(devision)
 
#반복문으로 입력되게 수정
            
wb1.remove(wb1['Sheet2'])
ws1_2 = wb1.create_sheet('Sheet2')
user_input = '' 
user_input = input('몇 월, 몇 일의 재고 자료를 불러옵니까?(mmdd): ')

wb2 = load_workbook(user_input+'재고.xlsx',data_only = True)
ws2 = wb2['재고현황']
ws1_2 = wb1['Sheet2']

for row2 in ws2.rows:
    ws1_2.append([str(row2[1].value),str(row2[3].value)])

ws1_2.delete_rows(1)
ws1_2.delete_rows(int(ws1_2.max_row))
ws1_2.delete_rows(int(ws1_2.max_row))

wb1.save('testing.xlsx')

df = pd.read_excel('testing.xlsx', sheet_name = 'Sheet2')
df2 = pd.read_excel('testing.xlsx', sheet_name = 'Sheet1')
df2 = pd.merge(df2, df, how = 'left', on = '품목명')
df2.to_excel('testing_2.xlsx', index = False)

#vlookup 함수를 문자열로 사용하면 pivot_table로 활용할 때 값이 수식을 불러들여 NaN 값이 발생해서 pandas에서 merge를 활용해 vlookup을 구현, DataFrame을 엑셀로 저장

table_1 = pd.pivot_table(df2, index=['품목명','재고수량','거래처명'], columns=['년','월'], values=['수량'], aggfunc='sum')
table_2 = pd.pivot_table(df2, index=['품목명','재고수량'], columns=['년','월'], values=['수량'], aggfunc='sum')
writer = pd.ExcelWriter( 'ERP 매출 재고 통합자료.xlsx', engine = 'xlsxwriter')
table_2.to_excel(writer, sheet_name = 'Sheet1')
table_1.to_excel(writer, sheet_name = '거래처 포함')
writer.save()

#pandas의 pivot_table을 사용하여 엑셀의 피벗테이블을 구현

wb3 = excel.Workbooks.Open(str(os.path.dirname(os.path.realpath(__file__)))+'\\'+'ERP 매출 재고 통합자료.xlsx')

#다른 PC에서도 프로그램을 사용하므로 경로 입력을 현재 파일의 절대 경로를 문자열로 입력하고  파일 이름을 추가 해줌

ws3_1 = wb3.Worksheets("Sheet1")
ws3_2 = wb3.Worksheets("거래처 포함")
ws3_1.Columns.AutoFit()
ws3_2.Columns.AutoFit()
wb3.Save()
excel.Application.Quit()

#서식을 조작하여 열의 너비를 자동으로 맞추기 위해 추가한 코드

3.3.5 댓글

• 김왼손: 완성되면 바로 써먹을수 있겠는데요? 대단합니다. :)

3.4 Kim KY

3.4.1 제목

제목을 정해주세요.

3.4.2 설명

장비가동률을 기반으로 한 장비별 전문화 아이템 산출

3.4.3 실행화면

실행화면을 넣어주세요.

3.4.4 코드

# 파이썬 시작하기
a = input('program_number?')
i = input('연월일(yyyy.mm.dd)?')
year = i[0:4]
month = i[5:7]
date = i[8:]

print('='*50)
print('program_number #' + a)
print('Life is short, You need Python')
print(f'연도 : {year}년')
print(f'날짜 : {month}월 {date}일')
print('='*50)

3.4.5 댓글

• 김왼손: 뭔가 전문적인 느낌이 드는 주제네요. :)

3.5 김매매

3.5.1 제목

제목을 정해주세요.

3.5.2 수준

구글에 파이썬 예제라고 치면 나오는 300문제 다 풀 수 있음

3.5.3 목표

1.김매매: 휴대폰 배터리 상태와 온도 알림 어플 2. fps게임할때 화면을 확대해 스코프 없이도 줌을 할수 있는 프로그램(모바일 포함) 3. 버튼 하나로 음악을 재생, 정지를 해 게임 로딩시간을 지루하지 않게 하는 프로그램 4. 휴대폰 게임 할때 버튼 위치를 옮길 수 없을때 임의로 지정한 곳을 터치하면 버튼이 인식되는 어플 왠만하면 모바일로 갈거임

3.5.4 실행화면

실행화면을 넣어주세요.

3.5.5 코드

#'국민 갓겜 가위바위보를 만들었습니다.'

print('게임을 시작합니다. 시작하려면 아무키나 입력하시고\n 종료하시려면 "종료"를 입력해 주세요')
skill=input()
list=['가위', '바위', '보']
win='제가 이겼군요 하핳'
lose='제가 졌군요ㅠㅠ'
tie='비겼네요 다시'
winc=0
losec=0
tiec=0
scissors=0
rock=0
paper=0
while skill!='종료':
    print('안 내면 진 거 가위바위보')
    skill=input()
    if skill=='가위':
        scissors+=1
        import random
        resurt=random.choice(list)
        print(resurt)
        if resurt=='가위':
            print(tie)
            tiec+=1
            print('\n')
        elif resurt=='바위':
            print(win)
            winc+=1
            print('\n')
        elif resurt=='보':
            print(lose)
            losec+=1
            print('\n')
    elif skill=='바위':
        rock+=1
        import random
        resurt=random.choice(list)
        print(resurt)
        if resurt=='가위':
            print(lose)
            losec+=1
            print('\n')
        elif resurt=='바위':
            print(tie)
            tiec+=1
            print('\n')
        elif resurt=='보':
            print(win)
            winc+=1
            print('\n')
    elif skill=='보':
        paper+=1
        import random
        resurt=random.choice(list)
        print(resurt)
        if resurt=='가위':
            print(win)
            winc+=1
            print('\n')
        elif resurt=='바위':
            print(lose)
            losec+=1
            print('\n')
        elif resurt=='보':
            print(tie)
            tiec+=1
            print('\n')
    else:
        if skill!='종료':
            print('이상한거 내지 말고 재대로 내봐요')
            print('\n')
    continue
print('게임이 종료돠었습니다.')
print('승리 :',winc)
print('패배 :',losec)
print('무승부 :',tiec)
print('\n')
print('가위를 낸 횟수 :',scissors)
print('바위를 낸 횟수 :',rock)
print('보를 낸 횟수 :',paper)
print('수고하셨습니다.')
input('창을 닫으시려면 아무 키나 입력하세요')

3.5.6 댓글

• 김왼손: 훌륭한 가위바위보 게임입니다. :)

3.6 ckstmznf

3.6.1 제목

제목을 정해주세요.

3.6.2 설명

GUI를 이용해서 나를 소개하는 프로그램 만들기

3.6.3 실행화면

실행화면을 넣어주세요.

3.6.4 참고영상

https://youtu.be/OtqWefBqbxA

3.6.5 1일차(부제 : 기획)

지난주 밖에 나가야 해서 참여를 못했지만---귀찮이즘이---PyQt5의 강의 영상은 꾸준히 보아 학습하였다. 오늘부터 시작을 한다. 먼저 기획을 한다면 기본 메뉴 ┌기본 프로필

             |─할수 있는 언어
             |─사용 할수 있는 소프트 웨어
            └기타 내용

3.6.6 코드

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton

class Exam(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()
    def initUI(self):
        x = 15

        btn_gibon = QPushButton("기본 메뉴 입니다.", self)
        btn_gibon.resize(btn_gibon.sizeHint())
        # btn_gibon.setToolTip("저의 기본 정보를 볼수 있는 메뉴입니다.")
        btn_gibon.move(50,x)
        x += 70

        btn_gibon = QPushButton("기본 정보", self)
        btn_gibon.resize(btn_gibon.sizeHint())
        btn_gibon.setToolTip("저의 기본 정보를 볼수 있는 메뉴입니다.")
        btn_gibon.move(50,x)
        x += 70

        btn_gibon = QPushButton("할수 있는 언어", self)
        btn_gibon.resize(btn_gibon.sizeHint())
        btn_gibon.setToolTip("제가 할수 있는 언어들입니다.")
        btn_gibon.move(50,x)
        x += 70

        btn_gibon = QPushButton("사용 할수 있는 소프트 웨어", self)
        btn_gibon.resize(btn_gibon.sizeHint())
        btn_gibon.setToolTip("제가 사용할수 있는 소프트 웨어들 입니다.")
        btn_gibon.move(50,x)
        x += 70

        btn_gibon = QPushButton("그 밖의 내용", self)
        btn_gibon.resize(btn_gibon.sizeHint())
        btn_gibon.setToolTip("그 밖의 기타 내용 입니다.")
        btn_gibon.move(50,x)
        
        self.setGeometry(500,500,400,400)
        self.setWindowTitle("기본 메뉴")
        self.show()


app = QApplication(sys.argv)
w = Exam()
sys.exit(app.exec_())

3.6.7 발전 내용

3.6.7.1 1일차

1일차 기획을 한 기본 메뉴들을 만들었다. 내가 지금 하고있는게 정석인지 안니지는 모르겠지만...

3.6.8 댓글

• 김왼손: 자기소개 프로그램이라니.. 기대됩니다. :)

3.7 Yoon

3.7.1 제목

제목을 정해주세요.

3.7.2 설명

간단한 게임들을 만들어보고 싶어요.

3.7.3 실행화면

실행화면을 넣어주세요.

3.7.4 코드

일단은 Python 기초강의 영상보면서 공부중입니다.
2020.05.06 : 미운코딩새끼 28강까지 정리 완료
2020.05.07 : 미운코딩새끼 46강까지 정리 완료
2020.05.08 : 미운코딩새끼 완료
https://www.notion.so/Python-414973d8d54a43c7a9495d201babed29
코드 적어본것 깃허브
https://github.com/YoonJeong-Choi/PythonPreschool
2020.05.09~10 : snake game 시작, 도움 - https://python.bakyeono.net/chapter-12-1.html
~ 2020.05.15 : snake game 재시작, 점수, 속도 기능 추가
~ 2020.05.19 : 메인화면 시작, 종료 버튼 추가

import pygame
import random # 랜덤으로 사과 띄움
import time
from datetime import datetime
from datetime import timedelta
from tkinter import *
# import tkinter.messagebox

pygame.init() # pygame 초기화

SCREEN_WIDTH = 440 # 화면 너비
SCREEN_HEIGHT = 440 # 화면 높이
BLOCK_SIZE = 20 # 블록 크기(네모 한칸 크기)
# 화면의 가로세로가 400이고 블록의 크기가 20이기 때문에 가로, 세로는 20칸씩 블록이 들어갈 수 있다.

# 화면의 테두리부분 영역
EDGE = []
for w in range(0, 22) :
    EDGE.append((0, w))
    EDGE.append((21, w))
    EDGE.append((w, 0))
    EDGE.append((w, 21))

# 시작 버튼 영역
START = []
for s in range(0, 8) :
    START.append((SCREEN_WIDTH // 22 * 7 + BLOCK_SIZE * s, SCREEN_HEIGHT // 2 + BLOCK_SIZE // 2))
    START.append((SCREEN_WIDTH // 22 * 7 + BLOCK_SIZE * s, SCREEN_HEIGHT // 2 + BLOCK_SIZE // 2 + BLOCK_SIZE))
    START.append((SCREEN_WIDTH // 22 * 7 + BLOCK_SIZE * s, SCREEN_HEIGHT // 2 + BLOCK_SIZE // 2 + BLOCK_SIZE * 2))

# 종료 버튼 영역
EXIT = []
for s in range(0, 8) :
    EXIT.append((SCREEN_WIDTH // 22 * 7 + BLOCK_SIZE * s, SCREEN_HEIGHT // 3 * 2 + BLOCK_SIZE // 2))
    EXIT.append((SCREEN_WIDTH // 22 * 7 + BLOCK_SIZE * s, SCREEN_HEIGHT // 3 * 2 + BLOCK_SIZE // 2 + BLOCK_SIZE))
    EXIT.append((SCREEN_WIDTH // 22 * 7 + BLOCK_SIZE * s, SCREEN_HEIGHT // 3 * 2 + BLOCK_SIZE // 2 + BLOCK_SIZE * 2))

# 색
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
SNAKEGREEN = (29, 139, 21)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
BLACK = (0, 0, 0)
BROWN = (124, 56, 0)
LIGHTGRAY = (234, 234, 234)
DARKGRAY = (140, 140, 140)

# 점수
score = 0
# pygeme.display.set_mode((화면 너비, 화면 높이)) 화면 객체 반환
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))

pygame.display.set_caption('SnakeGame') # title 설정

# 화면
# 시작 화면
def draw_main(screen) :
    background = pygame.Rect((0, 0), (SCREEN_WIDTH, SCREEN_HEIGHT))
    pygame.draw.rect(screen, WHITE, background)
    # 시작버튼
    for start in START :
        startButton = pygame.Rect((start[0], start[1]), (BLOCK_SIZE, BLOCK_SIZE))
        pygame.draw.rect(screen, GREEN, startButton)
    # 시작글씨
    font = pygame.font.Font('freesansbold.ttf', BLOCK_SIZE * 2) # 폰트 설정
    text = font.render('start!', True, BLACK) # 글자 설정 render('출력', True, 글자색, 배경색)
    textRect = text.get_rect()
    textRect.center = (int(((SCREEN_WIDTH // 4) + (BLOCK_SIZE * 5.5))), ((SCREEN_HEIGHT // 2) + (BLOCK_SIZE * 2)))
    screen.blit(text, textRect)
    # 제목
    title_font = pygame.font.Font('freesansbold.ttf', BLOCK_SIZE * 3) # 폰트 설정
    title_text = title_font.render('Snake Game', True, SNAKEGREEN) # 글자 설정 render('출력', True, 글자색, 배경색)
    title_textRect = title_text.get_rect()
    title_textRect.center = (int(((SCREEN_WIDTH // 4) + (BLOCK_SIZE * 5.5))), (SCREEN_HEIGHT // 3))
    screen.blit(title_text, title_textRect)
    # 종료버튼
    for exit in EXIT :
        exitButton = pygame.Rect((exit[0], exit[1]), (BLOCK_SIZE, BLOCK_SIZE))
        pygame.draw.rect(screen, LIGHTGRAY, exitButton)
    # 종료글씨
    exit_font = pygame.font.Font('freesansbold.ttf', BLOCK_SIZE * 2) # 폰트 설정
    exit_text = exit_font.render('exit', True, DARKGRAY) # 글자 설정 render('출력', True, 글자색, 배경색)
    exit_textRect = exit_text.get_rect()
    exit_textRect.center = (int(((SCREEN_WIDTH // 4) + (BLOCK_SIZE * 5.5))), (SCREEN_HEIGHT // 3 * 2  + BLOCK_SIZE * 2))
    screen.blit(exit_text, exit_textRect)

# 게임 배경
def draw_background(screen) :
    # 화면 전체에 강과 땅을 그려준다.
    # pygame.Rect((x, y), (사각형 너비, 사각형 높이))
    background = pygame.Rect((0, 0), (SCREEN_WIDTH, SCREEN_HEIGHT))
    # pygame.draw.rect(사각형을 그릴 화면, 색, 사각형 정보)
    pygame.draw.rect(screen, BROWN, background)
    # 테두리는 파란색으로 칠해준다.
    for edge in EDGE :
        edges = pygame.Rect((edge[0] * BLOCK_SIZE, edge[1] * BLOCK_SIZE), (BLOCK_SIZE, BLOCK_SIZE))
        pygame.draw.rect(screen, BLUE, edges)


# 블록을 그리는 함수 이 함수로 뱀이나 사과같은것들을 그려준다.
def draw_block(screen, color, position) :
    # position[n] * BLOCK_SIZE는 블록의 위치를 나타낸다.
    # 화면크기가 400*400, 블록이 20*20이기 때문에 화면은 가로, 세로 20칸이 된다. x, y를 이를 이용해 설정한것
    block = pygame.Rect((position[0] * BLOCK_SIZE, position[1] * BLOCK_SIZE), (BLOCK_SIZE, BLOCK_SIZE))
    pygame.draw.rect(screen, color, block)


# 블록 위치 = 뱀이 처음 나올 위치
block_position = [9, 9]
# 마지막으로 블록을 움직인인 때 = 마지막으로 버튼을 누른 때
# datetime.now()는 현재 시간을 알려준다.
last_moved_time = datetime.now()
# 처음 블록의 방향은 아래
block_direction = 'down'

# 방향 키 입력에 따라 블록의 방향 dictionary
DIRECTION_ON_KEY = {
    pygame.K_UP : 'up',
    pygame.K_DOWN : 'down',
    pygame.K_LEFT : 'left',
    pygame.K_RIGHT : 'right'
}

# 뱀
class Snake :
    color = GREEN
    # speed = 0.3
    def __init__(self) :
        self.positions = [(11, 11)] # 뱀의 위치. 뱀이 길어질수록 이 배열도 길어질것이다.
        self.direction = 'down' # 뱀의 방향
        self.speed = 0.3

    def draw(self, screen) :
        # 뱀그리기. 사과를 먹을수록 길어져야한다.
        # 여러 블록으로 이루어져있기 때문에 반복문을 돌며 그린다.
        for position in self.positions:
            draw_block(screen, self.color, position)
    # 뱀이 움직이면 머리가 움직인것에 따라 꼬리까지 따라가게 만드는 함수
    def crawl(self) :
        # 뱀의 머리는 인스턴스 변수인 positions[0] 위치이다.
        head_position = self.positions[0]
        # x, y 변수에 머리의 x, y좌표를 넣어준다.
        x, y = head_position
        # 만약 현재 뱀이 움직이는 방향이 아래라면
        if self.direction == 'down' :
            # 뱀의 머리 위치를 한칸 아래로 바꿔주고,
            # 기존 뱀의 위치 중 꼬리가 있던 부분 직전까지 더해준다.
            # 이렇게하면 머리의 위치를 앞에 추가해줌으로써
            # 머리부터 꼬리까지 각자 블럭의 앞에 있던 칸으로 따라간다.
            self.positions = [(x, y + 1)] + self.positions[:-1]
        elif self.direction == 'up' :
            self.positions = [(x, y - 1)] + self.positions[:-1]
        elif self.direction == 'left' :
            self.positions = [(x - 1, y)] + self.positions[:-1]
        elif self.direction == 'right' :
            self.positions = [(x + 1, y)] + self.positions[:-1]
    # 뱀의 방향을 바꾸는 함수
    def turn(self, direction) :
        self.direction = direction
    # 뱀을 키워주는 함수
    def grow(self) :
        # 뱀 꼬리의 뒤에 한칸 붙여준다.
        x, y = self.positions[-1]
        if self.direction == 'up' :
            self.positions.append((x, y - 1))
        elif self.direction == 'down' :
            self.positions.append((x, y + 1))
        elif self.direction == 'left' :
            self.positions.append((x - 1, y))
        elif self.direction == 'right' :
            self.positions.append((x + 1, y))
        # 뱀의 속도를 높여준다.
        if len(self.positions) > 15  and len(self.positions) < 25  :
            self.speed = 0.2
        elif len(self.positions) > 25 :
            self.speed = 0.1        

# 사과
class Apple :
    color = RED
    def __init__(self, position = (7, 7)) :
        self.position = position # 사과 위치

    def draw(self, screen) :
        # 사과 그리기
        draw_block(screen, self.color, self.position)    

# 게임판 : 뱀과 사과를 그려준다
class Board :
    width = 20
    height = 20
    
    def __init__(self) :
        self.snake = Snake()
        self.apple = Apple()

    def draw(self, screen) :
        self.apple.draw(screen) # 게임판 위의 사과 그리기
        self.snake.draw(screen) # 게임판 위의 뱀 그리기
    # 사과 만들기 - 사과에 사과만들기를하면 snake인스턴스를 못쓴다.
    def put_new_apple(self) :
        # 0 부터 20까지 랜덤으로 수를 정해 사과 위치를 정한다.
        self.apple = Apple((random.randint(1, 20), random.randint(1, 20)))
        # 뱀의 몸과 겹치면 사과를 다시만든다.
        for position in self.snake.positions :
            if self.apple.position == position :
                self.put_new_apple()
                break
    # 시간이 지나면 process_turn 메소드가 실행되며 저절로 뱀이 움직인다.
    def process_turn(self) :
        self.snake.crawl()
        # 뱀머리가 몸이나 벽에 부딛히면 게임이 끝난다.
        if self.snake.positions[0] in self.snake.positions[1:] or self.snake.positions[0] in EDGE:
            play = False
            return play
            
        # 움직이다가 사과 == 뱀머리 이면 뱀을 길게만들고 새 사과를 만든다.
        if self.snake.positions[0] == self.apple.position:
            self.snake.grow()
            self.put_new_apple()
            return 1
        return 1
    # 점수를 표시해주는 메소드.
    def write_score(self, screen) :
        score = 'score : {}'.format(len(self.snake.positions) - 1)
        # 상단에 점수표시
        font = pygame.font.Font('freesansbold.ttf', BLOCK_SIZE) # 폰트 설정
        text = font.render(score, True, BLACK, WHITE) # 글자 설정 render('출력', True, 글자색, 배경색)
        textRect = text.get_rect()
        textRect.center = (SCREEN_WIDTH // 2, BLOCK_SIZE // 2)
        screen.blit(text, textRect)    

class Play_Again :
    replay = True    
    def __init__ (self, replay) :
        # 윈도우 창 생성
        replay_window = Tk()
        # 윈도우 창 타이틀 지정
        replay_window.title('Game Over')
        # 윈도우 창의 크기 지정
        replay_window.geometry('230x100')
        # 윈도우 창 크기변경 가능?
        replay_window.resizable(0, 0)
        # 라벨
        show_text = Label(replay_window, text='~Game Over~\n다시하시겠습니까?').place(x = 60, y = 15)
        # 버튼
        replay_btn = Button(replay_window, text='Play Again', command = lambda: (self.Play(replay), replay_window.destroy())).place(x = 40, y = 60)
        exit_btn = Button(replay_window, text='Exit', command = lambda: (self.End(replay), replay_window.destroy())).place(x = 150, y = 60)
        # 윈도우 창 유지
        replay_window.mainloop()
        
    def Play(self, replay) : 
        self.replay = True
        return self.replay

    def End(self, replay) :
        self.replay = False
        return self.replay

# 게임 화면
def play_game(play, last_moved_time) :
    board = Board()
    while play :
        # pygame.event.get() 발생한 이벤트 목록을 읽는다.
        events = pygame.event.get()
            
        # 반복문을 이용하여 이벤트 목록을 본다.
        for event in events :
            # 종료 이벤트가 발생하면 종료한다.
            if event.type == pygame.QUIT :
                # exit()
                pygame.quit()
            # 어떤 버튼을 눌렀다면 아래처럼 행동한다.
            if event.type == pygame.KEYDOWN :
                # 만약 눌린 버튼이 화살표키라면 블록의 방향을 화살표 키에 맞게 바꾼다.
                if event.key in DIRECTION_ON_KEY :
                    # dictionary
                    board.snake.turn(DIRECTION_ON_KEY[event.key])
            
        # datetime.now() - last_moved_time을 이용하여 마지막으로 버튼을 누른지 0.3초가 지났다면
        # timedelta() 두 날짜(일,주 등등)나 시간(초, 분 등등)의 차이를 알려준다.
        if timedelta(seconds = board.snake.speed) <= datetime.now() - last_moved_time :
            play = board.process_turn()
            last_moved_time = datetime.now() # 마지막으로 움직인 시간 알려줌
                
        draw_background(screen) # 배경그리기
        board.draw(screen) # 화면판에 게임판그리기
        board.write_score(screen)
                
        # 화면 새로고침
        pygame.display.update()
            
# 처음시작?
first = True
# 재시작?
replay = True
# 게임실행
play = True

while replay :
    if first == True :
        screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
        draw_main(screen)
        pygame.display.update()
        events = pygame.event.get()
        for event in events :
            # 마우스 up 이벤트
            if event.type == pygame.MOUSEBUTTONUP :
                # start 버튼 범위
                if pygame.mouse.get_pos()[0] in range(START[0][0], START[-1][0]) and pygame.mouse.get_pos()[1] in range(START[0][1], START[-1][1]) :
                    first = False
                    play_game(play, last_moved_time)
                    play = False
                # exit 버튼 범위
                if pygame.mouse.get_pos()[0] in range(EXIT[0][0], EXIT[-1][0]) and pygame.mouse.get_pos()[1] in range(EXIT[0][1], EXIT[-1][1]) :
                    play = False
                    replay = False
                    first = False
    else :
        play_game(play, last_moved_time)
        play = False
    # 종료버튼을 누르면 게임종료
    if not play and not replay and not first :
        break
    if not play and replay:
        # 게임이 종료되면 play == False가 되며 while을 빠져나온다.
        play_again = Play_Again(replay)
        replay = play_again.replay
        if replay :
            # 만약 재시작을 한다고 했다면 play = True가 되며 다시 게임이 시작된다.
            play = True
            continue
        # 하지만 재시작을 하지 않는다 했다면 반복문은 종료된다.
        break
   
# 게임도 종료된다. exit()
pygame.quit()

3.7.5 댓글

• 김왼손: 스네이크 게임은 아주 유명하죠. 좋은 시작입니다. :)

3.8 어쭈구저쭈구

3.8.1 제목

제목을 정해주세요.

3.8.2 설명

컴퓨터와 턴제로 싸우는 게임 만들기

3.8.3 실행화면

실행화면을 넣어주세요.

3.8.4 목표

자바나 코틀린 배우면 모바일로 만들고 싶습니다

3.8.5 코드

3.8.5.1 pyght

from random import choice
from time import sleep as wait
from os import system 
import Setting
import wizard
import worrior
import condition

jobs = ['마법사', '전사', '암살자', '언데드', '무작위']
levels = ['하', '중', '상', '최상']

player_con = []
enemy_con = []

# 플레이어 상태 변수

player_fireturn = 0
player_poisonturn = 0
player_bloodturn = 0
player_thirstyturn = 0
player_recover_up = 0
player_recover_down = 0
player_faintturn = 0
player_harmoniousturn = 0
player_reproduceturn = 0
player_barrier = 0
player_barrierturn = 0
player_undying = 0

# 적 상태 변수

enemy_fireturn = 0
enemy_poisonturn = 0
enemy_bloodturn = 0
enemy_thirstyturn = 0
enemy_recover_up = 0
enemy_recover_down = 0
enemy_faintturn = 0
enemy_harmoniousturn = 0
enemy_reproduceturn = 0
enemy_barrier = 0
enemy_barrierturn = 0
enemy_undying = 0

# 직업 정하기
print("당신의 직업을 정해주세요. -> 마법사, 전사, 암살자, 언데드, 무작위")

while True:
    player_job = input()
    if player_job in jobs:
        if player_job == '무작위':
            jobs.remove('무작위')
            player_job = choice(jobs)
            jobs.append('무작위')
        print('당신의 직업은 {}입니다.'.format(player_job))
        break
    else:
        print('다시 선택해 주십시오.')

#마법사 전용 변수
if player_job == '마법사':
    player_wizard_get_mana = 4
    player_up_wizard_igmagicdefence = 1

print('상대의 직업을 정해주세요. -> 마법사, 전사, 암살자, 언데드, 무작위')

while True:
    enemy_job = input()
    if enemy_job in jobs:
        if enemy_job == '무작위':
            jobs.remove('무작위')
            enemy_job = choice(jobs)
            jobs.append('무작위')
        print('적의 직업은 {}입니다.'.format(enemy_job))
        break
    else:
        print('다시 선택해 주십시오.')

print('----------------------------------------------------\n')
print("난이도를 정해주세요. -> 하, 중, 상, 최상")

if enemy_job == '마법사':
    enemy_wizard_get_mana = 4
    enemy_up_wizard_igmagicdefence = 1

# 난이도 정하기

while True:
    level = input()
    if level in levels:
        print('난이도는 {}입니다.'.format(level))
        break
    else:
        print('다시 선택해 주십시오.')


player, enemy, player_acts, enemy_acts= Setting.set(player_job, enemy_job, level)

player_att, player_rest, player_check, player_skill1, player_skill2, player_skill3, player_skill4, player_skill5 = Setting.skillset(player_job)
enemy_att, enemy_rest, enemy_check, enemy_skill1, enemy_skill2, enemy_skill3, enemy_skill4, enemy_skill5 = Setting.skillset(enemy_job)

player_first_hp = player['체력']
enemy_first_hp = enemy['체력']

#wait(5)
system('cls')

while True:

    wait(0.5)

    # 체력, 마나 재생
    player_get_hp, player_get_mana = condition.recover(player['체력재생력'], player['마나재생력'], player_con, player_job)
    player['체력'] += player_get_hp
    player['마나'] += player_get_mana

    #마법사 패시브
    if player_job == '마법사':
        player['주문력'] += 2
        if player['주문력'] >= 300 and player_up_wizard_igmagicdefence >= 1:
            print('마법관통력 증가')
            player['마법관통력'] += 25
            player_up_wizard_igmagicdefence -= 1
        if player_wizard_get_mana == 0:
            print('안정 발동')
            player['마나'] += 35
            player['주문력'] += 5
            player_wizard_get_mana = 3
        else:
            player_wizard_get_mana -= 1
        
            
    # 잃은 피해 계산
    player_lost_hp = player_first_hp - player['체력']
    enemy_lost_hp = enemy_first_hp - enemy['체력']
    if player_lost_hp < 0:
        player_lost_hp = 0
    if enemy_lost_hp < 0:
        enemy_lost_hp = 0

    # 플레이어_화염
    if player_fireturn >= 1:
        if '화염' in player_con:
            pass
        else:
            player_con.append('화염')
    if player_fireturn == 0:
        if '화염' in player_con:
            player_con.remove('화염')
        else:
            pass

    # 플레이어_중독
    if player_poisonturn >= 1:
        if '중독' in player_con:
            pass
        else:
            player_con.append('중독')
    if player_poisonturn == 0:
        if '중독' in player_con:
            player_con.remove('중독')
        else:
            pass

    # 플레이어_출혈
    if player_bloodturn >= 1:
        if '출혈' in player_con:
            pass
        else:
            player_con.append('출혈')
    if player_bloodturn == 0:
        if '출혈' in player_con:
            player_con.remove('출혈')
        else:
            pass

    # 플레이어_갈증
    if player_thirstyturn >= 1:
        if '갈증' in player_con:
            pass
        else:
            player_con.append('갈증')
    if player_thirstyturn == 0:
        if '갈증' in player_con:
            player_con.remove('갈증')
        else:
            pass

    # 플레이어_재생
    if player_reproduceturn >= 1:
        if '재생' in player_con:
            pass
        else:
            player_con.append('재생')
    if player_reproduceturn == 0:
        if '재생' in player_con:
            player_con.remove('재생')
        else:
            pass

    # 플레이어_조화
    if player_harmoniousturn >= 1:
        if '조화' in player_con:
            pass
        else:
            player_con.append('조화')
    if player_harmoniousturn == 0:
        if '조화' in player_con:
            player_con.remove('조화')
        else:
            pass

    # 플레이어_불사
    if player_undying >= 1:
        if '불사' not in player_con:
            player_con.append('불사')
    if player_undying == 0:
        if '불사' in player_con:
            player_con.remove('불사')


    # 플레이어_방어막
    if player_barrierturn >= 1:
        if '방어막' in player_con:
            pass
        else:
            player_con.append('방어막')
    if player_barrierturn == 0:
        player_barrier = 0
        if '방어막' in player_con:
            player_con.remove('방어막')
        else:
            pass

    #플레이어_치료증폭:
    if player_recover_up >= 1:
        if '치료증폭' in player_con:
            pass
        else:
            player_con.append('치료증폭')
        player_recover_up -= 1

    #플레이어_치료감소
    if player_recover_down >= 1:
        if '치료감소' in player_con:
            pass
        else:
            player_con.append('치료감소')
        player_recover_down -= 1

    #플레이어_기절
    if player_faintturn >= 1:
        if '기절' in player_con:
            pass
        else:
            player_con.append('기절')
        player_faintturn -= 1

    if '기절' not in player_con:
        while True:
            # 플레이어 선택
            print('다음 것중에 하나를 선택해주세요')
            print(player_acts)
            player_choice = input()
            if player_choice not in player_acts:
                print('다시 선택해 주세요')
            else:
                break

        if player_choice == '공격':
            if player_job == '전사':
                enemy['체력'], enemy_faintturn = player_att(enemy['체력'], player['공격력'], enemy['방어력'], player['물리관통력'], enemy_faintturn)
            elif player_job == '암살자':
                enemy['체력'] = player_att(enemy['체력'], player['공격력'], player['주문력'], enemy['방어력'], player['물리관통력'])
            else:
                enemy['체력'] = player_att(enemy['체력'], player['공격력'], enemy['방어력'], player['물리관통력'])
        if player_choice == '휴식':
            player['체력'], player['마나'] = player_rest(player['체력'], player['마나'], player['체력재생력'], player['마나재생력'], player_con)
        if player_choice == '상태확인':
            player_check(player, player_con)
        if player_job == '마법사':
            if player_choice == '메테오':
                enemy['체력'], player['마나'], enemy_fireturn = player_skill1(enemy['체력'], player['주문력'], enemy['마법저항력'], player['마법관통력'], player['마나'], enemy_fireturn)
                player['주문력'] += 5
            if player_choice == '치유':
                player['체력'], player['방어력'], player['마법저항력'], player['마나'] = player_skill2(player['체력'], player['주문력'], player['방어력'], player['마법저항력'], player['마나'])
                player['주문력'] += 5
            if player_choice == '저주':
                enemy_poisonturn, enemy_thirstyturn, enemy_recover_down, enemy['방어력'], enemy['마법저항력'], player['마나'] = player_skill4(enemy_poisonturn, enemy_thirstyturn, enemy_recover_down, enemy['방어력'], enemy['마법저항력'], player['마나'])
                player['주문력'] += 5
            if player_choice == '파괴':
                enemy['체력'], player['주문력'], player['마나'] = player_skill5(enemy['체력'], enemy_lost_hp, player['주문력'], enemy['마법저항력'], player['마법관통력'], player['마나'])
                player['주문력'] += 5
        if player_job == '전사':
            if player_choice == '의지':
                player['공격력'], player['방어력'], player['마나'] = player_skill1(player['공격력'], player['방어력'], player['마나'])
            if player_choice == '강타':
                enemy['체력'], player['마나'] = player_skill2(enemy['체력'], player['공격력'], enemy['방어력'], player['물리관통력'], enemy_con, player['마나'])
            if player_choice == '포효':
               enemy_faintturn, player['마나'] = player_skill4(enemy_faintturn, enemy_con, player['방어력'], player['마나'])
            if player_choice == '결집':
                player['체력'], player['방어력'], player['마법저항력'], player_recover_up, player['마나'] = player_skill5(player['체력'], player_first_hp, enemy_first_hp, player['방어력'], player['마법저항력'], player_con, player_recover_up, player['마나'])
        if player_job == '암살자':
            if player_choice == '기습':
                enemy['체력'], player['마나'] = player_skill1(enemy['체력'], player['공격력'], player['주문력'], enemy['방어력'], player['물리관통력'], player['마나'])
            if player_choice == '칼춤':
                enemy_bloodturn, player_reproduceturn, player['마나'] = player_skill3(enemy_bloodturn, player_reproduceturn, player['주문력'], player['마나'])
            if player_choice == '불검':
                enemy['체력'], enemy_bloodturn, enemy_fireturn, enemy_recover_down, player['마나'] = player_skill4(enemy_bloodturn, enemy_fireturn, enemy_recover_down, enemy['체력'], player['공격력'], enemy['방어력'], enemy_first_hp, player['물리관통력'], player['마나'])
            if player_choice == '혼돈':
                enemy_faintturn, player['공격력'], player['주문력'], player['마나'] = player_skill5(enemy_faintturn, player['공격력'], player['주문력'], player['마나'])
    else:
        print('플레이어가 기절중입니다!')

    player_lost_hp = player_first_hp - player['체력']
    enemy_lost_hp = enemy_first_hp - enemy['체력']
    if player_lost_hp < 0:
        player_lost_hp = 0
    if enemy_lost_hp < 0:
        enemy_lost_hp = 0



    # 플레이어_화염
    if player_fireturn >= 1:
        player['체력'], player_fireturn = condition.fire(player['체력'], player_first_hp, player_fireturn)

    # 플레이어_중독
    if player_poisonturn >= 1:
        player['체력'], player_poisonturn = condition.poison(player['체력'], player_lost_hp, player_poisonturn)

    # 플레이어_출혈
    if player_bloodturn >= 1:
        player['체력'], player_bloodturn = condition.blood(player['체력'], player_bloodturn)

    # 플레이어_갈증
    if player_thirstyturn >= 1:
        player['마나'], player_thirstyturn = condition.thirsty(player['마나'], player_thirstyturn)

    # 플레이어_재생
    if player_reproduceturn >= 1:
        player['체력'], player_reproduceturn = condition.reproduce(player['체력'], player_first_hp, player_lost_hp, player_reproduceturn, player_con, player_job)

    # 플레이어_조화
    if player_harmoniousturn >= 1:
        player['마나'], player_harmoniousturn = condition.harmonious(player['마나'], player_harmoniousturn, player_con, player_job)

    # 플레이어_불사
    if player_undying >= 1:
        player_undying -= 1
        if player['체력'] <= 0:
            player['체력'] = int(player_first_hp / 10) + (player['주문력'] * 5)
            print('불사 발동')

    # 적_불사
    if enemy_undying >= 1:
        if enemy['체력'] <= 0:
            enemy['체력'] = int(enemy_first_hp / 10) + (enemy['주문력'] * 5)
            print('적 불사 발동')


    # 플레이어_치료증폭
    if player_recover_up == 0:
        if '치료증폭' in player_con:
            player_con.remove('치료증폭')

    # 플레이어_치료감소
    if player_recover_down == 0:
        if '치료감소' in player_con:
            player_con.remove('치료감소')

    # 플레이어_기절
    if player_faintturn == 0:
        if '기절' in player_con:
            player_con.remove('기절')

    if player['체력'] <= 0 or enemy['체력'] <= 0:
        print('게임이 끝났습니다!')
        if player['체력'] <= 0:
            print('----------------------------------------------------\n')
            player_check(player, player_con)
            print('----------------------------------------------------\n')
            print('적이 이겼습니다!')
            break
        else:
            print('----------------------------------------------------\n')
            print('적의 스탯 ')
            print('체력 : {},  마나 : {}'.format(enemy['체력'], enemy['마나']))
            print('공격력 : {},  주문력 : {}'.format(enemy['공격력'], enemy['주문력']))
            print('방어력 : {},  마법저항력 : {}'.format(enemy['방어력'], enemy['마법저항력']))
            print('물리관통력 : {},  마법관통력 : {}'.format(enemy['물리관통력'], enemy['마법관통력']))
            print('체력재생력 : {},  마나재생력 : {}'.format(enemy['체력재생력'], enemy['마나재생력']))
            print('적의 상태 : ', enemy_con)
            print('----------------------------------------------------\n')
            print('당신이 이겼습니다!')
            break

    print('----------------------------------------------------\n')

    # 체력, 마나 재생
    enemy_get_hp, enemy_get_mana = condition.recover(enemy['체력재생력'], enemy['마나재생력'], enemy_con, enemy_job)
    enemy['체력'] += enemy_get_hp
    enemy['마나'] += enemy_get_mana

    #마법사 패시브
    if enemy_job == '마법사':
        enemy['주문력'] += 2
        if enemy['주문력'] >= 200 and enemy_up_wizard_igmagicdefence == 1:
            enemy['마법관통력'] += 25
            enemy_up_wizard_igmagicdefence -= 1
        if enemy_wizard_get_mana == 0:
            print('안정 발동')
            enemy['마나'] += 35
            enemy['주문력'] += 5
            enemy_wizard_get_mana = 3
        else:
            enemy_wizard_get_mana -= 1

    # 적_화염
    if enemy_fireturn >= 1:
        if '화염' in enemy_con:
            pass
        else:
            enemy_con.append('화염')
    if enemy_fireturn == 0:
        if '화염' in enemy_con:
            enemy_con.remove('화염')
        else:
            pass

    # 적_중독
    if enemy_poisonturn >= 1:
        if '중독' in enemy_con:
            pass
        else:
            enemy_con.append('중독')
    if enemy_poisonturn == 0:
        if '중독' in enemy_con:
            enemy_con.remove('중독')
        else:
            pass

    # 적_출혈
    if enemy_bloodturn >= 1:
        if '출혈' in enemy_con:
            pass
        else:
            enemy_con.append('출혈')
    if enemy_bloodturn == 0:
        if '출혈' in enemy_con:
            enemy_con.remove('출혈')
        else:
            pass

    # 적_갈증
    if enemy_thirstyturn >= 1:
        if '갈증' in enemy_con:
            pass
        else:
            enemy_con.append('갈증')
    if enemy_thirstyturn == 0:
        if '갈증' in enemy_con:
            enemy_con.remove('갈증')
        else:
            pass

    # 적_재생
    if enemy_reproduceturn >= 1:
        if '재생' in enemy_con:
            pass
        else:
            enemy_con.append('재생')
    if enemy_reproduceturn == 0:
        if '재생' in enemy_con:
            enemy_con.remove('재생')
        else:
            pass

    # 적_조화
    if enemy_harmoniousturn >= 1:
        if '조화' in enemy_con:
            pass
        else:
            enemy_con.append('조화')
    if enemy_harmoniousturn == 0:
        if '조화' in enemy_con:
            enemy_con.remove('조화')
        else:
            pass

    # 적_불사
    if enemy_undying >= 1:
        if '불사' not in enemy_con:
            enemy_con.append('불사')
    if enemy_undying == 0:
        if '불사' in enemy_con:
            enemy_con.remove('불사')

    # 적_방어막
    if enemy_barrierturn >= 1:
        if '방어막' in player_con:
            pass
        else:
            enemy_con.append('방어막')
    if enemy_barrierturn == 0:
        enemy_barrier = 0
        if '방어막' in player_con:
            enemy_con.remove('방어막')
        else:
            pass

    #적_치료증폭:
    if enemy_recover_up >= 1:
        if '치료증폭' in enemy_con:
            pass
        else:
            enemy_con.append('치료증폭')
        enemy_recover_up -= 1


    #적_치료감소
    if enemy_recover_down >= 1:
        if '치료감소' in enemy_con:
            pass
        else:
            enemy_con.append('치료감소')
        enemy_recover_down -= 1

    #적_기절
    if enemy_faintturn >= 1:
        if '기절' in enemy_con:
            pass
        else:
            enemy_con.append('기절')
        enemy_faintturn -= 1


    # 적 상태
    print('적의 스탯 ')
    print('체력 : {},  마나 : {}'.format(enemy['체력'], enemy['마나']))
    print('공격력 : {},  주문력 : {}'.format(enemy['공격력'], enemy['주문력']))
    print('방어력 : {},  마법저항력 : {}'.format(enemy['방어력'], enemy['마법저항력']))
    print('물리관통력 : {},  마법관통력 : {}'.format(enemy['물리관통력'], enemy['마법관통력']))
    print('체력재생력 : {},  마나재생력 : {}'.format(enemy['체력재생력'], enemy['마나재생력']))
    print('적의 상태 : ', enemy_con)

    if '기절' not in enemy_con:
        enemy_choice = choice(enemy_acts)
        print(enemy_choice)
        if enemy_choice == '공격':
            if enemy_job == '전사':
                player['체력'], player_faintturn = enemy_att(player['체력'], enemy['공격력'], player['방어력'], enemy['물리관통력'], player_faintturn)
            elif enemy_job == '암살자':
                player['체력'] = enemy_att(player['체력'], enemy['공격력'], enemy['주문력'], player['방어력'], enemy['물리관통력'])
            else:
                player['체력'] = enemy_att(player['체력'], enemy['공격력'], player['방어력'], enemy['물리관통력'])
        if enemy_choice == '휴식':
            enemy['체력'], enemy['마나'] = enemy_rest(enemy['체력'], enemy['마나'], enemy['체력재생력'], enemy['마나재생력'], enemy_con)
        if enemy_job == '마법사':
            if enemy_choice == '메테오':
                player['체력'], enemy['마나'], player_fireturn = enemy_skill1(player['체력'], enemy['주문력'], player['마법저항력'], enemy['마법관통력'], enemy['마나'], player_fireturn)
                enemy['주문력'] += 5
            if enemy_choice == '치유':
                enemy['체력'], enemy['방어력'], enemy['마법저항력'], enemy['마나'] = enemy_skill2(enemy['체력'], enemy['주문력'], enemy['방어력'], enemy['마법저항력'], enemy['마나'])
                enemy['주문력'] += 5
            if enemy_choice == '저주':
                player_poisonturn, player_thirstyturn, player_recover_down, player['방어력'], player['마법저항력'], enemy['마나'] = enemy_skill4(player_poisonturn, player_thirstyturn, player_recover_down, player['방어력'], player['마법저항력'], enemy['마나'])
                enemy['주문력'] += 5
            if enemy_choice == '파괴':
                player['체력'], enemy['주문력'], enemy['마나'] = enemy_skill5(player['체력'], player_lost_hp, enemy['주문력'], player['마법저항력'], enemy['마법관통력'], enemy['마나'])
                enemy['주문력'] += 5
        if enemy_job == '전사':
            if enemy_choice == '의지':
                enemy['공격력'], enemy['방어력'], enemy['마나'] = enemy_skill1(enemy['공격력'], enemy['방어력'], enemy['마나'])
            if enemy_choice == '강타':
                player['체력'], enemy['마나'] = enemy_skill2(player['체력'], enemy['공격력'], player['방어력'], enemy['물리관통력'], player_con, enemy['마나'])
            if enemy_choice == '포효':
               player_faintturn, enemy['마나'] = enemy_skill4(player_faintturn, player_con, enemy['방어력'], enemy['마나'])
            if enemy_choice == '결집':
                enemy['체력'], enemy['방어력'], enemy['마법저항력'], enemy_recover_up, enemy['마나'] = enemy_skill5(enemy['체력'], enemy_first_hp, player_first_hp, enemy['방어력'], enemy['마법저항력'], enemy_con, enemy_recover_up, enemy['마나'])
        if enemy_job == '암살자':
            if enemy_choice == '기습':
                player['체력'], enemy['마나'] = enemy_skill1(player['체력'], enemy['공격력'], enemy['주문력'], player['방어력'], enemy['물리관통력'], enemy['마나'])
            if enemy_choice == '칼춤':
                player_bloodturn, enemy_reproduceturn, enemy['마나'] = enemy_skill3(player_bloodturn, enemy_reproduceturn, enemy['주문력'], enemy['마나'])
            if enemy_choice == '불검':
                player['체력'], player_bloodturn, player_fireturn, player_recover_down, enemy['마나'] = enemy_skill4(player_bloodturn, player_fireturn, player_recover_down, player['체력'], enemy['공격력'], player['방어력'], player_first_hp, enemy['물리관통력'], enemy['마나'])
            if enemy_choice == '혼돈':
                player_faintturn, enemy['공격력'], enemy['주문력'], enemy['마나'] = enemy_skill5(player_faintturn, enemy['공격력'], enemy['주문력'], enemy['마나'])

    # 적_화염
    if enemy_fireturn >= 1:
        enemy['체력'], enemy_fireturn = condition.fire(enemy['체력'], enemy_first_hp, enemy_fireturn)

    # 적_중독
    if enemy_poisonturn >= 1:
        enemy['체력'], enemy_poisonturn = condition.poison(enemy['체력'], enemy_lost_hp, enemy_poisonturn)

    # 적_출혈
    if enemy_bloodturn >= 1:
        enemy['체력'], enemy_bloodturn = condition.blood(enemy['체력'], enemy_bloodturn)

    # 적_갈증
    if enemy_thirstyturn >= 1:
        enemy['마나'], enemy_thirstyturn = condition.thirsty(enemy['마나'], enemy_thirstyturn)

    # 적_재생
    if enemy_reproduceturn >= 1:
        enemy['체력'], enemy_reproduceturn = condition.reproduce(enemy['체력'], enemy_first_hp, enemy_lost_hp, enemy_reproduceturn, enemy_con, enemy_job)

    # 적_조화
    if enemy_harmoniousturn >= 1:
        enemy['마나'], enemy_harmoniousturn = condition.harmonious(enemy['마나'], enemy_harmoniousturn, enemy_con, enemy_job)

    # 적_불사
    if enemy_undying >= 1:
        enemy_undying -= 1
        if enemy['체력'] <= 0:
            enemy['체력'] = int(enemy_first_hp / 10) + (enemy['주문력'] * 5)
            print('적 불사 발동')

    # 플레이어_불사
    if player_undying >= 1:
        if player['체력'] <= 0:
            player['체력'] = int(player_first_hp / 10) + (player['주문력'] * 5)
            print('불사 발동')


    # 적_치료증폭
    if enemy_recover_up == 0:
        if '치료증폭' in enemy_con:
            enemy_con.remove('치료증폭')

    # 적_치료감소
    if enemy_recover_down == 0:
        if '치료감소' in enemy_con:
            enemy_con.remove('치료감소')

    # 적_기절
    if enemy_faintturn == 0:
        if '기절' in enemy_con:
           enemy_con.remove('기절')

    #게임종료
    if player['체력'] <= 0 or enemy['체력'] <= 0:
        print('게임이 끝났습니다!')
        if player['체력'] <= 0:
            print('----------------------------------------------------\n')
            player_check(player, player_con)
            print('----------------------------------------------------\n')
            print('적이 이겼습니다!')
            break
        else:
            print('----------------------------------------------------\n')
            print('적의 스탯 ')
            print('체력 : {},  마나 : {}'.format(enemy['체력'], enemy['마나']))
            print('공격력 : {},  주문력 : {}'.format(enemy['공격력'], enemy['주문력']))
            print('방어력 : {},  마법저항력 : {}'.format(enemy['방어력'], enemy['마법저항력']))
            print('물리관통력 : {},  마법관통력 : {}'.format(enemy['물리관통력'], enemy['마법관통력']))
            print('체력재생력 : {},  마나재생력 : {}'.format(enemy['체력재생력'], enemy['마나재생력']))
            print('적의 상태 : ', enemy_con)
            print('----------------------------------------------------\n')
            print('당신이 이겼습니다!')
            break
    print('----------------------------------------------------\n')

3.8.5.2 condition

# 화염 : 자신의 턴 끝날때마다 자신의 기본체력의 3%만큼 고정피해를 입습니다.

def fire(hp, first_hp, nowturn):
    player_new_hp = hp - int(first_hp /  100 * 3)
    turn = nowturn - 1
    return player_new_hp, turn

# 중독 : 자신의 턴 끝날때마다 자신의 잃은체력의 5%만큼 고정피해를 입습니다.

def poison(hp, lost_hp, nowturn):
    player_new_hp = hp - int(lost_hp /  20)
    turn = nowturn - 1
    return player_new_hp, turn


# 출혈 : 자신의 턴 끝날때마다 자신의 현재체력의 5%만큼 고정피해를 입습니다.

def blood(hp, nowturn):
    player_new_hp = hp - int(hp /  20)
    turn = nowturn - 1
    return player_new_hp, turn

# 갈증 : 자신의 턴 끝날때마다 (현재마나의 5% + 7)만큼 마나를 잃습니다.

def thirsty(mana, nowturn):
    player_new_mana = mana - int(mana /  20 + 7) 
    turn = nowturn - 1
    return player_new_mana, turn

# 조화 : 자신의 턴 끝날때마다 (현재마나의 5% + 7)만큼 마나를 얻습니다.

def harmonious(mana, nowturn, player_con, player_job):
    plus_hp, plus_mp = recover(0, int(mana / 20 + 7), player_con, player_job) 
    player_new_mana = mana + plus_mp
    turn = nowturn - 1
    return player_new_mana, turn

# 재생 : 자신의 턴 끝날때마다 (기본체력의 3% + 잃은체력의 5%)만큼 체력을 얻습니다. 

def reproduce(hp, first_hp, lost_hp, nowturn, player_con, player_job):
    plus_hp, plus_mp = recover(int(first_hp * 0.03 + lost_hp / 20), 0, player_con, player_job) 
    player_new_hp = hp + plus_hp
    turn = nowturn - 1
    return player_new_hp, turn


# 기절 : 기절에 걸린 적은 자신의 턴에 아무것도 할 수 없습니다.
    

# 침묵 : 걸린 상대는 스킬을 사용할 수 없습니다. (패시브 제외)


# 무장해제 : 걸린 상대는 기본공격을 사용할 수 없습니다.


# 치료감소 : 자신이 받는 모든 회복에 대해서 40%만큼 감소합니다.


# 치료증폭 : 자신이 받는 모든 회복에 대해서 40%만큼 증가합니다.


def recover(hp, mana, con, partjob):
    re_hp = hp
    re_mana = mana
    if '치료감소' in con:
        re_hp = int(re_hp * 0.6)
        re_mana = int(re_mana * 0.6)
    if '치료증폭' in con:
        re_hp = int(re_hp * 1.4)
        re_mana = int(re_mana * 1.4)
    if partjob == 1 or partjob == '전사':
        re_hp = int(re_hp * 1.3)
        re_mana = int(re_mana * 1.3)
    return re_hp, re_mana

# 방어막 : 자신이 입은 피해만큼 흡수해주는 방어막을 생성해줍니다. (방어막은 방어력과 마법저항력의 영향을 받지 않습니다. 또한, '흔적'을 제외한 다른 상태효과에 영향을 받지 않습니다.)

def barrier(player_barrier, get_barrier, nowturn):
    new_barrier = player_barrier + get_barrier
    turn = nowturn - 1
    return new_barrier, turn

# 흔적 : 받는 피해가 30% 증가합니다. 

def trace(player_traceturn, player_con):
    pass

# 불사 : 플레이어가 치명적인 공격을 받아 죽으면, 체력이 '기본체력의 10% + 주문력의 500%'인 상태로 부활합니다.

3.8.5.3 Setting

import wizard
import worrior
import assassin


def set(player_job, enemy_job, level):
    # 플레이어에게 기본 스탯 대입
    if player_job == "마법사":
        print(''' -------------------------------------------------------------------------------
패시브 : \n마법사는 자신의 턴 시작할때마다 2만큼 주문력을 얻습니다. 스킬을 사용하면 5의 주문력을 얻습니다. 주문력이 300이상이 되면 마법관통력을 15만큼얻습니다.\n
메테오 : \n마법사가 적에게 (주문력의 230%)의 피해를 마법피해를 입힙니다. 상대는 2턴동안 '화염'효과를 받습니다.(마나: 65)\n
치유 : \n마법사가 (주문력의 100%) + 200 만큼 회복하고 방어력과 마법저항력을 6만큼 얻습니다. 만약 체력이 1500이하라면 (주문력의 120% + 300)만큼 더 회복됩니다. (마나 : 85)\n 
안정 : \n4턴마다 마나를 35 얻습니다. (패시브)\n
저주 : \n상대를 저주하여 4턴동안 '중독', '갈증', '치료감소' 효과를 줍니다. 또한 방어력과 마법저항력을 6만큼 감소시킵니다. (마나 : 125)\n
파괴 : \n상대에게 (주문력의 450% + 상대잃은체력의 35%)만큼 마법피해를 입힙니다. 이 스킬후 마법사는 ('파괴'로 입힌피해량의 5% + 30)만큼 주문력을 얻습니다. (마나 420)\n
-------------------------------------------------------------------------------''')
        a = wizard.wizard
        c = wizard.acts
    elif player_job == "전사":
        print(''' -------------------------------------------------------------------------------
패시브 : \n전사는 적을 기본공격하면 20%확률로 2턴동안 기절시킵니다. \n
의지 : \n자신의 공격력과 방어력을 각각 10, 4만큼 얻습니다. (마나 : 40) \n
강타 : \n상대를 강하게 내리쳐 (공격력의 200%)만큼 물리피해를 입힙니다. 만약 상대가 기절중이라면 (공격력의 150%)만큼 추가 물리피해를 입힙니다. (마나 : 80) \n
재생 : \n전사의 기본회복량은 130% 입니다. (패시브)\n
포효 : \n상대를 3턴동안 기절시킵니다. 만약 적이 '기절'효과를 받고있는 상태면 (방어력의 20%)만큼 마나를 돌려받습니다.(마나 : 120)\n
결집 : \n자신의 체력을 (자신 기본체력의 20% + 상대 기본체력의 20%)만큼 회복시킵니다. 또한 방어력과 마법저항력을 30만큼 얻습니다. hp가 2000이하면 '치료증폭'효과를 8턴동안 받습니다. (마나 : 370)\n
-------------------------------------------------------------------------------''')
        a = worrior.worrior
        c = worrior.acts
    elif player_job == '암살자':
        print(''' -------------------------------------------------------------------------------
패시브 : \n기본공격시 25%확률로 치명타가 터집니다. 치명타는 (공격력의 200%)만큼 물리피해를 줍니다. \n
기습 : \n적에게  (공격력의 190% + 주문력 300%)에 해당하는 물리피해를 입힙니다. 25%확률로 고정피해를 입힙니다. (마나 : 80) \n
암살 : \n만약 상대의 피가 (500 + 주문력의 300%)이하일때 기본공격을 하면 상대가 즉사합니다. (패시브) 
칼춤 : \n상대에게 '출혈' 효과를 (3 + 주문력의 1%)턴동안 부여합니다. 암살자는 (3 + 주문력의 1%)턴동안 '재생'효과를 받습니다. (마나 : 60) \n
불검 : \n상대에게 3턴동안 '출혈', 화염', '치료감소' 효과를 부여하고 (공격력의 280% + 상대기본체력의 5%)만큼 물리피해를 줍니다. (마나 : 145) \n 
혼돈 : \n5턴 동안 적을 기절시킵니다. 암살자는 공격력을 (150), 주문력을 (100)만큼 얻습니다. (마나 : 300) \n
-------------------------------------------------------------------------------''')
        a = assassin.assassin
        c = assassin.acts
    # 적에게 기본 스탯 대입
    if enemy_job == "마법사":
        b = wizard.enemy_wizard
        d = wizard.enemy_acts
    elif enemy_job == '전사':
        b = worrior.enemy_worrior
        d = worrior.enemy_acts
    elif enemy_job == '암살자':
        b = assassin.enemy_assassin
        d = assassin.enemy_acts
    return a, b ,c ,d


# 스킬 대입
def skillset(job):
    if job == '마법사':
        return wizard.att, wizard.rest, wizard.check, wizard.meteor, wizard.hill, None, wizard.curse, wizard.destroy
    if job == '전사':
        return worrior.att, worrior.rest, worrior.check, worrior.determination, worrior.glow, None, worrior.shout, worrior.gather
    if job == '암살자':
        return assassin.att, assassin.rest, assassin.check, assassin.ambush, None, assassin.knifedance, assassin.fireknife, assassin.chaos

3.8.5.4 worrior

from condition import recover
from random import choice

# 전사 기본스탯
worrior = {'체력': 5430, '공격력': 382, '주문력': 0, '방어력': 140, '마법저항력': 120, '마나': 320, '물리관통력': 0, '마법관통력': 0, '체력재생력': 12, '마나재생력': 6}
enemy_worrior = {'체력': 5430, '공격력': 382, '주문력': 0, '방어력': 140, '마법저항력': 120, '마나': 320, '물리관통력': 0, '마법관통력': 0, '체력재생력': 12, '마나재생력': 6}

acts = ['공격', '휴식', '상태확인', '의지', '강타', '포효', '결집']
enemy_acts = ['공격', '휴식', '의지', '강타', '포효', '결집', '공격', '공격', '휴식', '휴식']
twenty = [0, 0, 0, 0, 1]

def att(enemy_hp, player_attack, enemy_defence, player_ig_defence, enemy_faintturn):
    new_enemy_faintturn = enemy_faintturn
    new_enemy_hp = int(enemy_hp - (player_attack * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100)))))
    will_faint = choice(twenty)
    if will_faint == 1:
        new_enemy_faintturn += 2
        print('패시브 발동')
    return new_enemy_hp, new_enemy_faintturn

def rest(player_hp, player_mana, player_rehp, player_remana, player_con):
    new_player_plushp, new_player_plusmana = recover(player_rehp * 4, player_remana * 3, player_con, 1)
    new_player_hp = player_hp + new_player_plushp
    new_player_mana = player_mana + new_player_plusmana
    return new_player_hp, new_player_mana

def check(player, player_con):
    print('플레이어의 스탯 ')
    print('체력 : {},  마나 : {}'.format(player['체력'], player['마나']))
    print('공격력 : {},  주문력 : {}'.format(player['공격력'], player['주문력']))
    print('방어력 : {},  마법저항력 : {}'.format(player['방어력'], player['마법저항력']))
    print('물리관통력 : {},  마법관통력 : {}'.format(player['물리관통력'], player['마법관통력']))
    print('체력재생력 : {},  마나재생력 : {}'.format(player['체력재생력'], player['마나재생력']))
    print('나의 상태 : ', player_con)

# 패시브 : 전사는 적을 기본공격하면 20%확률로 2턴동안 기절시킵니다.


# 의지 : 자신의 공격력과 방어력을 각각 10, 4만큼 얻습니다. (마나 : 40)

def determination(player_attack, player_defence, player_mana):
    if player_mana >= 40:
        new_player_attack = player_attack + 10
        new_player_defence = player_defence + 4
        new_player_mana = player_mana - 40
        return new_player_attack, new_player_defence, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(40 - player_mana))
        return player_attack, player_defence, player_mana

# 강타 : 상대를 강하게 내리쳐 (공격력의 200%)만큼 물리피해를 입힙니다. 만약 상대가 기절중이라면 (공격력의 150%)만큼 추가 물리피해를 입힙니다.  (마나 : 80)

def glow(enemy_hp, player_attack, enemy_defence, player_ig_defence, enemy_con, player_mana):
    if player_mana >= 80:
        new_enemy_hp = int(enemy_hp - (player_attack * 2 * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100)))))
        if '기절' in enemy_con:
            print('추가 피해')
            new_enemy_hp -= int(player_attack * 1.5 * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100))))
        new_player_mana = player_mana - 80
        return new_enemy_hp, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(80 - player_mana))
        return enemy_hp, player_mana

# 끈질김 : 전사의 기본회복량은 130% 입니다. (패시브)


# 포효 : 상대를 3턴동안 기절시킵니다. 만약 적이 '기절'효과를 받고있는 상태면 (방어력의 20%)만큼 마나를 돌려받습니다. (마나 : 120)

def shout(enemy_faintturn, enemy_con, player_defence, player_mana):
    if player_mana >= 120:
        new_player_mana = player_mana - 120
        new_enemy_faintturn = enemy_faintturn + 3
        if '기절' in  enemy_con:
            new_player_mana += int(player_defence * 0.2)
            print('마나를 {}만큼 돌려받았습니다.'.format(int(player_defence * 0.2)))
        return new_enemy_faintturn, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(120 - player_mana))
        return enemy_faintturn, player_mana
        
# 결집 : 자신의 체력을 (자신 기본체력의 20% + 상대 기본체력의 20%)만큼 회복시킵니다. 또한 방어력과 마법저항력을 30만큼 얻습니다. hp가 2000이하면 '치료증폭'효과를 8턴동안 받습니다. (마나 : 370)
def gather(player_hp, player_first_hp, enemy_first_hp, player_defence, player_magicdefence, player_con, player_recover_up, player_mana):
    if player_mana >= 370:
        player_plus_hp, gabage = recover(int((player_first_hp + enemy_first_hp) * 0.2), 0, player_con, 1)
        new_player_hp = player_hp + player_plus_hp
        new_player_defence = player_defence + 30
        new_player_magicdefence = player_magicdefence + 30
        new_player_recover_up = player_recover_up
        if player_hp <= 2000:
            new_player_recover_up += 8
        new_player_mana = player_mana - 370
        return new_player_hp, new_player_defence, new_player_magicdefence, new_player_recover_up, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(370 - player_mana))
        return player_hp, player_defence, player_magicdefence, player_recover_up, player_mana

3.8.5.5 assassin

from random import choice
from condition import recover

# 암살자 기본스탯
assassin = {'체력': 3660, '공격력': 492, '주문력': 0, '방어력': 85, '마법저항력': 45, '마나': 320, '물리관통력': 25, '마법관통력': 0, '체력재생력': 7, '마나재생력': 6}
enemy_assassin = {'체력': 3660, '공격력': 492, '주문력': 0, '방어력': 85, '마법저항력': 45, '마나': 320, '물리관통력': 25, '마법관통력': 0, '체력재생력': 7, '마나재생력': 6}
critical = [0, 0, 0, 1]

acts = ['공격', '휴식', '상태확인', '기습', '칼춤', '불검', '혼돈']
enemy_acts = ['공격', '휴식', '기습', '칼춤', '불검', '혼돈', '공격', '공격']

def att(enemy_hp, player_attack, player_magic, enemy_defence, player_ig_defence):
    if enemy_hp <= (500 + player_magic * 3):
        print('암살 발동')
        return -99999
    iscritical = choice(critical)
    if iscritical == 0:
        new_enemy_hp = int(enemy_hp - (player_attack * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100)))))
    else:
        new_enemy_hp = int(enemy_hp - (player_attack * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100))) * 2))
        print('치명타 발동')
        
    return new_enemy_hp

def rest(player_hp, player_mana, player_rehp, player_remana, player_con):
    new_player_plushp, new_player_plusmana = recover(player_rehp * 4, player_remana * 3, player_con, 0)
    new_player_hp = player_hp + new_player_plushp
    new_player_mana = player_mana + new_player_plusmana
    return new_player_hp, new_player_mana

def check(player, player_con):
    print('플레이어의 스탯 ')
    print('체력 : {},  마나 : {}'.format(player['체력'], player['마나']))
    print('공격력 : {},  주문력 : {}'.format(player['공격력'], player['주문력']))
    print('방어력 : {},  마법저항력 : {}'.format(player['방어력'], player['마법저항력']))
    print('물리관통력 : {},  마법관통력 : {}'.format(player['물리관통력'], player['마법관통력']))
    print('체력재생력 : {},  마나재생력 : {}'.format(player['체력재생력'], player['마나재생력']))
    print('나의 상태 : ', player_con)

# 패시브 : 기본공격시 25%확률로 치명타가 터집니다. 치명타는 (공격력의 200%)만큼 물리피해를 줍니다. 치명타가 터지면 '방어막'을 (공격력의 100%)만큼 3턴동안 얻습니다. 


# 기습 : 적에게  (공격력의 190% + 주문력 200%)에 해당하는 물리피해를 입힙니다. 25%확률로 고정피해를 입힙니다. (마나 : 80)

def ambush(enemy_hp, player_attack, player_magic, enemy_defence, player_ig_defence, player_mana):
    if player_mana >= 80:
        iscritical = choice(critical)
        if iscritical == 0:
            print('고정피해')
            new_enemy_hp = int(enemy_hp - ((player_attack * 1.9 + player_magic * 3) * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100)))))
        if iscritical == 1:
            new_enemy_hp = enemy_hp - int(player_attack * 1.9 + player_magic * 3)
        new_player_mana = player_mana - 80
        return new_enemy_hp, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(80 - player_mana))
        return enemy_hp, player_mana

# 암살 : 만약 상대의 피가 (500 + 주문력의 300%)이하일때 기본공격을 하면 상대를 즉사시킵니다. (패시브) 


# 칼춤 : 상대에게 '출혈' 효과를 (3 + 주문력의 1%)턴동안 부여합니다. 암살자는 (3 + 주문력의 1%)턴동안 '재생'효과를 받습니다. (마나 : 60) 

def knifedance(enemy_bloodturn, player_reproduceturn, player_magic, player_mana):
    if player_mana >= 60:
        new_enemy_bloodturn = enemy_bloodturn + int(player_magic * 0.01 + 3)
        new_player_reproduceturn = player_reproduceturn + int(player_magic * 0.01 + 3)
        new_player_mana = player_mana - 60
        return new_enemy_bloodturn, new_player_reproduceturn, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(60 - player_mana))
        return enemy_bloodturn, player_reproduceturn, player_mana
        


# 불검 : 상대에게 3턴동안 '출혈', 화염', '치료감소' 효과를 부여하고 (공격력의 280% + 상대기본체력의 5%)만큼 물리피해를 줍니다. (마나 : 145) 

def fireknife(enemy_bloodturn, enemy_fireturn, enemy_recover_down, enemy_hp, player_attack, enemy_defence, enemy_first_hp, player_ig_defence, player_mana):
    if player_mana >= 145:
        new_enemy_hp = int(enemy_hp - ((player_attack * 2.8 + enemy_first_hp * 0.05) * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100)))))
        new_enemy_bloodturn = enemy_bloodturn + 3
        new_enemy_fireturn = enemy_fireturn + 3
        new_enemy_recover_down = enemy_recover_down + 3
        new_player_mana = player_mana - 145
        return new_enemy_hp, new_enemy_bloodturn, new_enemy_fireturn, new_enemy_recover_down, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(140 - player_mana))
        return enemy_hp, enemy_bloodturn, enemy_fireturn, enemy_recover_down, player_mana

# 혼돈 : 5턴 동안 적을 기절시킵니다. 암살자는 공격력을 (150), 주문력을 (100)만큼 얻습니다. (마나 : 300)

def chaos(enemy_faintturn, player_attack, player_magic, player_mana):
    if player_mana >= 300:
        new_enemy_faintturn = enemy_faintturn + 5
        new_player_attack = player_attack + 150
        new_player_magic = player_magic + 100
        new_player_mana = player_mana - 330
        return new_enemy_faintturn, new_player_attack, new_player_magic, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(300 - player_mana))
        return enemy_faintturn, player_attack, player_magic, player_mana

3.8.5.6 wizard

from condition import recover


# 마법사 기본스탯
wizard = {'체력': 3860, '공격력': 295, '주문력': 130, '방어력': 80, '마법저항력': 160, '마나': 420, '물리관통력': 0, '마법관통력': 15, '체력재생력': 10, '마나재생력': 7}
enemy_wizard = {'체력': 3860, '공격력': 295, '주문력': 130, '방어력': 80, '마법저항력': 160, '마나': 420, '물리관통력': 0, '마법관통력': 15, '체력재생력': 10, '마나재생력': 7}

acts = ['공격', '휴식', '상태확인', '메테오', '치유', '저주', '파괴']
enemy_acts = ['공격', '휴식', '메테오', '치유', '저주', '파괴']

def att(enemy_hp, player_attack, enemy_defence, player_ig_defence):
    new_enemy_hp = int(enemy_hp - (player_attack * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100)))))
    return new_enemy_hp

def rest(player_hp, player_mana, player_rehp, player_remana, player_con):
    new_player_plushp, new_player_plusmana = recover(player_rehp * 4, player_remana * 3, player_con, 0)
    new_player_hp = player_hp + new_player_plushp
    new_player_mana = player_mana + new_player_plusmana
    return new_player_hp, new_player_mana

def check(player, player_con):
    print('플레이어의 스탯 ')
    print('체력 : {},  마나 : {}'.format(player['체력'], player['마나']))
    print('공격력 : {},  주문력 : {}'.format(player['공격력'], player['주문력']))
    print('방어력 : {},  마법저항력 : {}'.format(player['방어력'], player['마법저항력']))
    print('물리관통력 : {},  마법관통력 : {}'.format(player['물리관통력'], player['마법관통력']))
    print('체력재생력 : {},  마나재생력 : {}'.format(player['체력재생력'], player['마나재생력']))
    print('나의 상태 : ', player_con)

# 패시브 : 마법사는 자신의 턴 시작할때마다 2만큼 주문력을 얻습니다. 스킬을 사용하면 5의 주문력을 얻습니다. 주문력이 300이상이 되면 마법관통력을 (25)만큼얻습니다.


# 메테오 : 마법사가 적에게 (주문력의 230%)의 피해를 마법피해를 입힙니다. 상대는 2턴동안 '화염'효과를 받습니다.(마나: 65) 

def meteor(enemy_hp, player_mag, enemy_magicdefence, player_ig_magicdefence, player_mana, enemy_fire):
    if player_mana >= 65:
        new_enemy_hp = int(enemy_hp - (player_mag * 2.3 * (1 - (enemy_magicdefence / (enemy_magicdefence  + 100) * (1 - player_ig_magicdefence /100)))))
        new_player_mana = player_mana - 65
        new_enemy_fire = enemy_fire + 2
        return new_enemy_hp, new_player_mana, new_enemy_fire
    else:
        print('마나가 {}만큼 부족합니다.'.format(65 - player_mana))
        return enemy_hp, player_mana, enemy_fire


# 치유 : 마법사가 (주문력의 100%) + 200 만큼 회복하고 방어력과 마법저항력을 6만큼 얻습니다. 만약 체력이 1500이하라면 (주문력의 120% + 300)만큼 더 회복됩니다. (마나 : 85)

def hill(player_hp, player_magic, player_defence, player_magicdefence, player_mana):
    if player_mana >= 85:
        new_player_hp = player_hp + player_magic + 200
        if player_hp <= 1500:
            new_player_hp += int(player_magic * 1.2 + 300)
        new_player_defence = player_defence + 6
        new_player_magicdefence = player_magicdefence + 6
        new_player_mana = player_mana - 85
        return new_player_hp, new_player_defence, new_player_magicdefence, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(85 - player_mana))
        return player_hp, player_defence, player_magicdefence, player_mana 

# 안정 : 4턴마다 마나를 35 얻습니다. (패시브)


# 저주 : 상대를 저주하여 4턴동안 '중독', '갈증', '치료감소' 효과를 줍니다. 또한 방어력과 마법저항력을 6만큼 감소시킵니다. (마나 : 125)

def curse(enemy_poison, enemy_thirsty, enemy_recover_down, enemy_defence, enemy_magicdefence, player_mana):
    if player_mana >= 125:
        new_enemy_posionturn = enemy_poison + 4
        new_enemy_thirstyturn = enemy_thirsty + 4
        new_enemy_recover_down = enemy_recover_down + 4
        new_enemy_defence = enemy_defence - 6
        new_enemy_magicdefence = enemy_magicdefence - 6
        new_player_mana = player_mana - 125
        return new_enemy_posionturn, new_enemy_thirstyturn, new_enemy_recover_down, new_enemy_defence, new_enemy_magicdefence, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(125 - player_mana))
        return enemy_poison, enemy_thirsty, enemy_recover_down, enemy_defence, enemy_magicdefence, player_mana


# 파괴 : 상대에게 (주문력의 450% + 상대잃은체력의 35%)만큼 마법피해를 입힙니다. 마법사는 ('파괴'로 입힌피해량의 5% + 30)만큼 주문력을 얻습니다. (마나 420) 

def destroy(enemy_hp, enemy_lost_hp, player_magic, enemy_magicdefence, player_ig_magicdefence, player_mana):
    if player_mana >= 420:
        first_hp = enemy_hp
        new_enemy_hp = int(enemy_hp - ((enemy_lost_hp * 0.4 + player_magic * 3.5) * (1 - (enemy_magicdefence / (enemy_magicdefence  + 100) * (1 - player_ig_magicdefence /100)))))
        damaged = enemy_hp - new_enemy_hp
        new_player_magic = player_magic + int(damaged / 20 + 20)
        print('마법사가 주문력을 {}만큼 얻었습니다!'.format(int(damaged / 20 + 20)))
        new_player_mana = player_mana - 420
        return new_enemy_hp, new_player_magic, new_player_mana
    else:
        print('마나가 {}만큼 부족합니다.'.format(420 - player_mana))
        return enemy_hp, player_magic, player_mana

3.8.5.7 undead

from condition import recover


# 언데드 기본스탯
wizard = {'체력': 4460, '공격력': 312, '주문력': 170, '방어력': 80, '마법저항력': 80, '마나': 340, '물리관통력': 0, '마법관통력': 20, '체력재생력': 9, '마나재생력': 8}
enemy_wizard = {'체력': 4460, '공격력': 312, '주문력': 170, '방어력': 80, '마법저항력':80, '마나': 340, '물리관통력': 0, '마법관통력': 20, '체력재생력': 9, '마나재생력': 8}

acts = ['공격', '휴식', '상태확인', '메테오', '치유', '저주', '파괴']
enemy_acts = ['공격', '휴식', '메테오', '치유', '저주', '파괴']

def att(enemy_hp, player_attack, enemy_defence, player_ig_defence):
    new_enemy_hp = int(enemy_hp - (player_attack * (1 - (enemy_defence / (enemy_defence  + 100) * (1 - player_ig_defence /100)))))
    return new_enemy_hp

def rest(player_hp, player_mana, player_rehp, player_remana, player_con):
    new_player_plushp, new_player_plusmana = recover(player_rehp * 4, player_remana * 3, player_con, 0)
    new_player_hp = player_hp + new_player_plushp
    new_player_mana = player_mana + new_player_plusmana
    return new_player_hp, new_player_mana

def check(player, player_con):
    print('플레이어의 스탯 ')
    print('체력 : {},  마나 : {}'.format(player['체력'], player['마나']))
    print('공격력 : {},  주문력 : {}'.format(player['공격력'], player['주문력']))
    print('방어력 : {},  마법저항력 : {}'.format(player['방어력'], player['마법저항력']))
    print('물리관통력 : {},  마법관통력 : {}'.format(player['물리관통력'], player['마법관통력']))
    print('체력재생력 : {},  마나재생력 : {}'.format(player['체력재생력'], player['마나재생력']))
    print('나의 상태 : ', player_con)


# 패시브 : 언데드의 체력이 1000이하면 각성합니다. 각성시 자신의 스킬을 강화시키고, 주문력과 마나를 각각 100, 200만큼 얻습니다. 각성시 언데드의 체력이 1000이 넘어도 각성상태는 유지합니다.


# 지속적인 두려움 : 게임 시작시 (400 + 상대기본체력의 20%)만큼 고정피해를 입힙니다. 자신의 턴 시작할때마다 상대에게 (주문력의 30% + 20)만큼 마법피해를 입힙니다. 각성 시 (주문력의 10% + 20)만큼 추가고정피해를 입힙니다. (패시브)


# 흡수 : 상대에게 (주문력의 200%)만큼 마법피해를 입히고 3턴동안 '중독'시킵니다. 자신의 체력을 (주문력의 200%)만큼 회복시키고 3턴동안 '재생'효과를 얻습니다. 각성 시 (주문력의 200%)만큼 추가마법피해를 입힙니다. (마나 : 90)
def absorb(enemy_hp, player_hp, player_mag, enemy_magicdefence, player_ig_magicdefence, enemy_poisonturn, player_reproduceturn, player_mana, is_stronger):
    if player_mana >= 90:
        new_enemy_hp = int(enemy_hp - (player_mag * 2 * (1 - (enemy_magicdefence / (enemy_magicdefence  + 100) * (1 - player_ig_magicdefence /100)))))

# 균형 : 자신에게 걸린 '화염', '중독', '출혈', '갈증'효과를 없애고, '재생', '치료증폭'효과를 5턴동안 얻습니다. 각성 시 '조화'효과를 3턴동안 얻습니다. (마나 : 80)


# 불멸 : 자신에게 '불사' 효과를 3턴동안 부여합니다. 각성 시 '불사' 효과를 6턴동안 부여합니다. (마나 : 160)


# 죽음 : 적에게 (500 + 주문력의 300%)만큼 고정피해를 입힙니다. 각성 시 (상대현재체력의 40%)만큼 추가 고정피해를 입힙니다. (마나 : 350)

3.8.6 class

class champion:
    def __init__(self, job, level, stat):
        self.job = job
        self.level = level

3.8.7 패치노트

3.8.7.1 2020.05.16

'언데드'직업 계획

'불사', '조화', '재생' 효과 추가

잃은 체력이 -가 되는 버그 해결

상대를 이제 정할수 있음

자신의 직업을 이제 무작위로 고를수있음

마법사 :

안정 마나회복 : 50 -> 35

저주 감소한 방어력, 마법저항력 : 5 -> 6

파괴 소모마나 : 400 -> 420

파괴 피해량 : (주문력의 350% + 상대잃은체력의 60%) -> (주문력의 350% + 상대잃은체력의 40%)

전사 :

기본 체력 : 5140 -> 5430

결집 체력회복 : (기본체력 30% + 상대기본체력의 30%) -> (기본체력 20% + 상대기본체력의 20%)

암살자:

기본 방어력 : 80 -> 85

치명타확률 : 40% -> 25%

기습 고정피해확률 : 40% -> 25%

기습 피해량 : (공격력의 240% + 주문력 300%) -> (공격력의 190% + 주문력 200%)

혼돈 기절: 4 -> 5

혼돈 소모마나 : 330 -> 300

3.8.7.2 2020.05.23

게임 종료시 자신의 상태가 제대로 표시되지않는 버그 수정

'갈증' 효과가 오히려 증가하는 버그 수정

마법사 :

마법사 패시브 - 증가하는 마법관통력 : 15 -> 25

치유 회복량 : (주문력의 100% + 120) -> (주문력의 100% + 200)

치유 추가회복량 : (주문력의 120%) -> (주문력의 120% + 300)

저주 마나 소모량 : 120 -> 125

파괴 피해량 : (주문력의 400% + 상대잃은체력의 40%) -> (주문력의 450% + 상대잃은체력의 35%)

암살자 :

기본체력 : 3460 -> 3660

공격력 : 482 -> 492

칼춤 출혈 및 재생 턴 : (2 + 주문력의 1%) -> (3 + 주문력의 1%)

칼춤 마나 소모량 : 50 -> 60

기타 :

조화 마나 회복량 : (현재마나의 5% + 10) -> (현재마나의 5% + 7)

class 파일 추가

3.8.8 하고싶은말

구현할것이 아직 많이 남았네요 ㄷ 직업들을 클래스와 상속을 이용해 다시 만들고싶지만 시간이 너무 오래걸릴거같네요

3.8.9 댓글

• 김왼손: 설정이 아주 탄탄하네요. 노력에 박수를 보냅니다. :)

3.9 야호

3.9.1 제목

제목을 정해주세요.

3.9.2 설명

pygame을 이용한 간단한 슈팅게임

3.9.3 실행화면

실행화면을 넣어주세요.

3.9.4 코드

import pygame
import random
form time import sleep

BLACK = (0, 0, 0)
RED = (255, 0, 0)
pad_width = 480
pad_height = 640
fight_width = 36
fight_height = 38
enemy_width = 26
enemy_height = 20

def drawScore(count):
    global gamepad
    font = pygame.font.SysFont(None, 20)
    text = font.render('Enemy Kills: ' + str(count), True, (255, 255, 255))
    gamepad.blit(text, (0, 0))

def drawPassed(count):
    global gamepad
    font = pygame.font.SysFont(None, 20)
    text = font.render('Enemy Passed: ' + str(count), True, RED)
    gamepad.blit(text, (360, 0))

def dispMessage(text):
    global gamepad
    textfont = pygame.font.Font('freesansblod.ttf', 80)
    text = textfont.render(text, True, RED)
    textpos = text.get_rect()
    textpos.center = (pad_width/2, pad_height/2)
    gamepad.blit(text, textpos)
    pygame.display.update()
    sleep(2)
    runGame()

def crash():
    global gamepad
    dispMessage('Crashed^-^;')

def gameover():
    global gamepad
    dispMessage('Game Over')

def drawObject(obj, x, y):
    global gamepad
    gamepad.blit(obj, (x,y))

def runGame():
    global gamepad, clock, fighter, enemy, bullet

아직 미완..

3.9.5 댓글

• 김왼손: 오.. 완성되면 저도 플레이 해보고 싶네요. :)

3.10 JT

3.10.1 제목

제목을 정해주세요.

3.10.2 설명

데이터 프로세싱과 Visualization 툴을 만들고 싶습니다.

3.10.2.1 목표1

데이터를 읽어와서 분석을 위한 데이터 프로세싱을 실행한다.

3.10.2.2 목표2

준비된 데이터를 다양한 그래프 형태로 도식화한다.

3.10.2.3 목표3

API를 통해 직접적으로 데이터를 불러들여온다.

3.10.3 실행화면

실행화면을 넣어주세요.

3.10.4 코드

3.10.4.1 코드: 목표1

print('Hello Python!')

3.10.4.2 코드: 목표2

print('Hello Python!')

3.10.4.3 코드: 목표3

print('Hello Python!')

3.10.5 댓글

• 김왼손: 어떤 프로그램이 나올지 기대됩니다. :)