데이터 분석가:Applied Data Analytics/파이썬
파이썬으로 게임만들기
데이터분석
2025. 2. 4. 14:26
320x100
728x90
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 100, 25, 5, job)
elif job == '마법사':
super().__init__(name, 1, 50, 50, 2, job)
elif job == '힐러':
super().__init__(name, 1, 75, 25, 3, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack += 10
self.defense += 5
self.experience = 0
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러): ")
player = Player(name, job)
# 몬스터들과 전투
for monster_name, monster_level in monster_dict.items():
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
if not player.is_alive():
print("게임오버!")
break
else:
print("모든 몬스터를 처치했습니다. 축하합니다!")
# 게임 시작
if __name__ == "__main__":
main()
코드 설명:
- Character 클래스:
- 기본적인 캐릭터의 속성(이름, 레벨, 체력, 공격력, 방어력, 직업)을 정의.
- is_alive() 메서드는 캐릭터가 살아있는지 체크.
- take_damage()는 공격을 받았을 때 체력을 차감. 방어력이 데미지보다 크면 체력이 감소하지 않음.
- attack_target()은 랜덤한 데미지로 타겟에게 공격.
- Player 클래스: Character 클래스를 상속받으며, 플레이어의 경험치 관리와 레벨업 시스템을 추가.
- gain_experience() 메서드는 경험치를 추가하고, 50 이상일 경우 level_up()을 호출하여 레벨업.
- level_up() 메서드는 공격력과 방어력을 증가시키고, 경험치를 초기화.
- Monster 클래스: Character 클래스를 상속받으며, 몬스터의 체력, 공격력, 방어력은 레벨에 비례해 랜덤으로 설정.
- Battle 함수: 플레이어와 몬스터가 서로 공격하며 전투를 진행합니다. 체력이 0 이하가 될 때까지 공격을 주고받으며, 승리 시 경험치를 획득하고 레벨업할 수 있다.
- Main 함수:
- 사용자로부터 이름과 직업을 입력받고, 몬스터와 전투를 진행.
- 전투 도중 플레이어가 사망하면 게임 오버를 출력하고 종료.
검토 :
1. 게임이 순식간에 진행되어 종료됨. > 진행과정을 보면서 순차적으로 배틀 계속 포기 선택필요.
2. 체력은 레벨업을 했는데도 그대로임 > 레벨업시 체력이 초기화 되게 변경.
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.max_health = health # 최대 체력
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 100, 25, 5, job) #레벨, 체력, 공격력, 방어력
elif job == '마법사':
super().__init__(name, 1, 60, 50, 2, job)
elif job == '힐러':
super().__init__(name, 1, 50, 25, 4, job)
elif job == '궁수':
super().__init__(name, 1, 70, 50, 3, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack += 10
self.defense += 5
self.experience = 0
self.health = self.max_health # 레벨업 시 체력을 초기값으로 리셋
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러, 궁수): ")
player = Player(name, job)
# 몬스터들과 전투
for monster_name, monster_level in monster_dict.items():
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
if not player.is_alive():
print("게임오버!")
break
# 전투 후 계속할지 물어보기
continue_battle = input("계속 전투하시겠습니까? (Y/N): ")
if continue_battle.lower() != 'Y':
print(f"{monster_name}과의 전투를 종료하고 다른 몬스터와 전투를 진행합니다.")
continue
else:
print("모든 몬스터를 처치했습니다. 축하합니다!")
# 게임 시작
if __name__ == "__main__":
main()
추가 검토 : 몬스터와 배틀종료후 계속전투 여부 확인으로 N를 선택시 동일한 몬스터와 다시 배틀하게 하고
케릭터가 레벨업을 할경우 초기설정값 (체력, 공격력, 방어력)값을 5%씩 올라가게 케릭터 능력수정
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.max_health = health # 최대 체력
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 100, 25, 5, job) # 레벨, 체력, 공격력, 방어력
elif job == '마법사':
super().__init__(name, 1, 60, 50, 2, job)
elif job == '힐러':
super().__init__(name, 1, 50, 25, 4, job)
elif job == '궁수':
super().__init__(name, 1, 70, 50, 3, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack = int(self.attack * 1.05) # 공격력 5% 증가
self.defense = int(self.defense * 1.05) # 방어력 5% 증가
self.health = int(self.max_health * 1.05) # 체력 5% 증가
self.experience = 0
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러, 궁수): ")
player = Player(name, job)
# 몬스터들과 전투
monster_name_list = list(monster_dict.items()) # 몬스터 목록을 리스트로 변환
index = 0
while index < len(monster_name_list):
monster_name, monster_level = monster_name_list[index]
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
# 만약 플레이어가 죽었다면 게임 종료
if not player.is_alive():
print("게임오버!")
break
# 전투 후 계속할지 물어보기
continue_battle = input("다음 레벨 몬스터와 전투하시겠습니까? (Y/N): ")
if continue_battle.lower() == 'Y':
index += 1 # 'Y'를 선택하면 다음 레벨 몬스터로 넘어감
elif continue_battle.lower() == 'N':
print(f"{monster_name}과의 전투를 다시 시작합니다.")
# 'N'을 선택하면 현재 몬스터와 전투를 다시 시작함
else:
print("모든 몬스터를 처치했습니다. 축하합니다!")
# 게임 시작
if __name__ == "__main__":
main()
문제 : 레벨업시 체력, 공격력, 방어력 계속 안올라감 -> 재수정
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.max_health = health # 최대 체력
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 100, 25, 5, job) # 레벨, 체력, 공격력, 방어력
elif job == '마법사':
super().__init__(name, 1, 60, 50, 2, job)
elif job == '힐러':
super().__init__(name, 1, 50, 25, 4, job)
elif job == '궁수':
super().__init__(name, 1, 70, 50, 3, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack = int(self.attack * 1.05) # 공격력 5% 증가 후 정수로 변환
self.defense = int(self.defense * 1.05) # 방어력 5% 증가 후 정수로 변환
self.health = int(self.max_health * (1.05 ** self.level)) # 체력 5% 증가 후 정수로 변환
self.experience = 0
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
print(f"체력: {self.health}, 공격력: {self.attack}, 방어력: {self.defense}")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러, 궁수): ")
player = Player(name, job)
# 몬스터들과 전투
monster_name_list = list(monster_dict.items()) # 몬스터 목록을 리스트로 변환
index = 0
while index < len(monster_name_list):
monster_name, monster_level = monster_name_list[index]
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
# 만약 플레이어가 죽었다면 게임 종료
if not player.is_alive():
print("게임오버!")
break
# 전투 후 계속할지 물어보기
continue_battle = input("다음 레벨 몬스터와 전투하시겠습니까? (Y/N): ")
if continue_battle.lower() == 'Y':
index += 1 # 'Y'를 선택하면 다음 레벨 몬스터로 넘어감
elif continue_battle.lower() == 'N':
print(f"{monster_name}과의 전투를 다시 시작합니다.")
# 'N'을 선택하면 현재 몬스터와 전투를 다시 시작함
else:
print("모든 몬스터를 처치했습니다. 축하합니다!")
# 게임 시작
if __name__ == "__main__":
main()
레벨업시 캐릭터 체력, 공격력, 방어는 상승 > ok
몬스터 배틀 후 다음 레벨 몬스터와 전투한다고 Y를 했는데도 같은 몬스터와 배틀하는 문제 수정필요
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.max_health = health # 최대 체력
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 100, 25, 5, job) # 레벨, 체력, 공격력, 방어력
elif job == '마법사':
super().__init__(name, 1, 60, 50, 2, job)
elif job == '힐러':
super().__init__(name, 1, 50, 25, 4, job)
elif job == '궁수':
super().__init__(name, 1, 70, 50, 3, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack += 10 # 공격력 10 증가
self.defense += 10 # 방어력 10 증가
self.health = int(self.max_health + 10 * self.level) # 체력 10씩 증가
self.experience = 0
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
print(f"체력: {self.health}, 공격력: {self.attack}, 방어력: {self.defense}")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러, 궁수): ")
player = Player(name, job)
# 몬스터들과 전투
monster_name_list = list(monster_dict.items()) # 몬스터 목록을 리스트로 변환
index = 0 # 현재 전투할 몬스터의 인덱스
while index < len(monster_name_list):
monster_name, monster_level = monster_name_list[index]
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
# 만약 플레이어가 죽었다면 게임 종료
if not player.is_alive():
print("게임오버!")
break
# 전투 후 계속할지 물어보기
continue_battle = input("다음 레벨 몬스터와 전투하시겠습니까? (Y/N): ")
if continue_battle.lower() == 'Y':
index += 1 # 'Y'를 선택하면 몬스터 목록에서 인덱스 증가(다음 몬스터로 전투)
if index >= len(monster_name_list): # 모든 몬스터를 처치한 경우
print("모든 몬스터를 처치했습니다. 축하합니다!")
break
elif continue_battle.lower() == 'N':
print(f"{monster_name}과의 전투를 다시 시작합니다.")
# 'N'을 선택하면 현재 몬스터와 전투를 다시 시작함
# 게임 시작
if __name__ == "__main__":
main()
레벨업시 수치상승을 정수로 변경함
결투 선택시 Y시 다음 몬스터로 안넘어가는 문제 발생 ->수정필요
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.max_health = health # 최대 체력
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 100, 25, 5, job) # 레벨, 체력, 공격력, 방어력
elif job == '마법사':
super().__init__(name, 1, 60, 50, 2, job)
elif job == '힐러':
super().__init__(name, 1, 50, 25, 4, job)
elif job == '궁수':
super().__init__(name, 1, 70, 50, 3, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack += 10 # 공격력 10 증가
self.defense += 10 # 방어력 10 증가
self.health = int(self.max_health + 10 * self.level) # 체력 10씩 증가
self.experience = 0
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
print(f"체력: {self.health}, 공격력: {self.attack}, 방어력: {self.defense}")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러, 궁수): ")
player = Player(name, job)
# 몬스터들과 전투
monster_name_list = list(monster_dict.items()) # 몬스터 목록을 리스트로 변환
index = 0 # 현재 전투할 몬스터의 인덱스
while index < len(monster_name_list):
monster_name, monster_level = monster_name_list[index]
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
# 만약 플레이어가 죽었다면 게임 종료
if not player.is_alive():
print("게임오버!")
break
# 전투 후 계속할지 물어보기
continue_battle = input("다음 레벨 몬스터와 전투하시겠습니까? (Y/N): ")
if continue_battle.lower() == 'Y':
index += 1 # 'Y'를 선택하면 몬스터 목록에서 인덱스 증가(다음 몬스터로 전투)
if index >= len(monster_name_list): # 모든 몬스터를 처치한 경우
print("모든 몬스터를 처치했습니다. 축하합니다!")
break
elif continue_battle.lower() == 'N':
print(f"{monster_name}과의 전투를 다시 시작합니다.")
# 'N'을 선택하면 현재 몬스터와 전투를 다시 시작함
continue # 현재 몬스터와 계속 전투하도록 진행
# 게임 시작
if __name__ == "__main__":
main()
Y, N에서 다음전개부분 오류
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.max_health = health # 최대 체력
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 100, 25, 5, job) # 레벨, 체력, 공격력, 방어력
elif job == '마법사':
super().__init__(name, 1, 60, 50, 2, job)
elif job == '힐러':
super().__init__(name, 1, 50, 25, 4, job)
elif job == '궁수':
super().__init__(name, 1, 70, 50, 3, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack += 10 # 공격력 10 증가
self.defense += 10 # 방어력 10 증가
self.health = int(self.max_health + 10 * self.level) # 체력 10씩 증가
self.experience = 0
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
print(f"체력: {self.health}, 공격력: {self.attack}, 방어력: {self.defense}")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러, 궁수): ")
player = Player(name, job)
# 몬스터들과 전투
monster_name_list = list(monster_dict.items()) # 몬스터 목록을 리스트로 변환
index = 0 # 현재 전투할 몬스터의 인덱스
while index < len(monster_name_list):
monster_name, monster_level = monster_name_list[index]
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
# 만약 플레이어가 죽었다면 게임 종료
if not player.is_alive():
print("게임오버!")
break
# 전투 후 계속할지 물어보기
while True: # 잘못된 입력에 대해 계속 묻기 위한 루프
continue_battle = input("다음 레벨 몬스터와 전투하시겠습니까? (Y/N): ").lower()
if continue_battle == 'y':
index += 1 # 'Y'를 선택하면 몬스터 목록에서 인덱스 증가(다음 몬스터로 전투)
break # 'Y'를 선택하면 다음 몬스터로 진행
elif continue_battle == 'n':
print(f"{monster_name}과의 전투를 다시 시작합니다.")
battle(player, monster) # 'N'을 선택하면 같은 몬스터와 계속 전투
break # 'N'을 선택하면 현재 몬스터와 계속 전투를 반복하도록 함
else:
print("잘못된 입력입니다. Y 또는 N을 입력해주세요.") # 잘못된 입력을 처리하는 메시지
else:
print("모든 몬스터를 처치했습니다. 축하합니다!")
# 게임 시작
if __name__ == "__main__":
main()
다음레벨 몬스터로 넘어가는 부분 수정됨.
케릭터 능력치 수정하여 케릭터간의 밸런스 조절
import random
# Character 클래스 정의
class Character:
def __init__(self, name, level, health, attack, defense, job):
self.name = name
self.level = level
self.max_health = health # 최대 체력
self.health = health
self.attack = attack
self.defense = defense
self.job = job
def is_alive(self):
return self.health > 0
def take_damage(self, damage):
actual_damage = max(0, damage - self.defense) # 방어력이 데미지보다 클 경우 체력 감소 없음
self.health -= actual_damage
def attack_target(self, target):
damage = random.randint(1, self.attack) # 공격력 1부터 공격력까지의 랜덤한 데미지
print(f"{target.name}(이)가 {damage}만큼의 피해를 입었습니다.")
target.take_damage(damage)
print(f"{target.name}의 남은 체력 : {target.health}")
# Player 클래스 정의 (Character 클래스 상속)
class Player(Character):
def __init__(self, name, job):
self.job = job
if job == '탱커':
super().__init__(name, 1, 120, 15, 20, job) # 레벨, 체력, 공격력, 방어력
elif job == '마법사':
super().__init__(name, 1, 40, 35, 5, job)
elif job == '힐러':
super().__init__(name, 1, 80, 20, 10, job)
elif job == '궁수':
super().__init__(name, 1, 60, 25, 6, job)
self.experience = 0
def gain_experience(self, amount):
self.experience += amount
print(f"{amount}만큼의 경험치를 획득했습니다.")
if self.experience >= 50:
self.level_up()
def level_up(self):
self.level += 1
self.attack += 2 # 공격력 2 증가
self.defense += 5 # 방어력 5 증가
self.health = int(self.max_health + 5 * self.level) # 체력 5씩 증가
self.experience = 0
print(f"{self.name}이(가) 레벨업 했습니다! 레벨 {self.level}이 되었습니다.")
print(f"체력: {self.health}, 공격력: {self.attack}, 방어력: {self.defense}")
# Monster 클래스 정의 (Character 클래스 상속)
class Monster(Character):
def __init__(self, name, level):
health = random.randint(10, 30) * level
attack = random.randint(5, 20) * level
defense = random.randint(1, 5) * level
super().__init__(name, level, health, attack, defense, "몬스터")
# Battle 함수 정의
def battle(player, monster):
while player.is_alive() and monster.is_alive():
print(f"\n{player.name}의 턴입니다.")
player.attack_target(monster)
if not monster.is_alive():
print(f"{monster.name}을(를) 처치했습니다!")
player.gain_experience(monster.level * 20)
print(f"{player.name}의 HP가 {player.health} 남았습니다.")
print("축하합니다. 전투 승리하셨습니다!")
break
print(f"{monster.name}의 턴입니다.")
monster.attack_target(player)
if not player.is_alive():
print(f"{player.name}이(가) 전투에서 패배하셨습니다.")
break
# Main 함수 정의
def main():
# 몬스터 이름과 레벨 딕셔너리
monster_dict = {'슬라임': 1, '고블린': 2, '오크': 3, '골램': 4}
# 사용자로부터 이름과 직업 입력받기
name = input("플레이어의 이름을 입력하세요: ")
job = input("직업을 선택하세요 (탱커, 마법사, 힐러, 궁수): ")
player = Player(name, job)
# 몬스터들과 전투
monster_name_list = list(monster_dict.items()) # 몬스터 목록을 리스트로 변환
index = 0 # 현재 전투할 몬스터의 인덱스
while index < len(monster_name_list):
monster_name, monster_level = monster_name_list[index]
monster = Monster(monster_name, monster_level)
print(f"\n{monster_name}과(와) 전투를 시작합니다!")
battle(player, monster)
# 만약 플레이어가 죽었다면 게임 종료
if not player.is_alive():
print("게임오버!")
break
# 전투 후 계속할지 물어보기
while True: # 잘못된 입력에 대해 계속 묻기 위한 루프
continue_battle = input("다음 레벨 몬스터와 전투하시겠습니까? (Y/N): ").lower()
if continue_battle == 'y':
index += 1 # 'Y'를 선택하면 몬스터 목록에서 인덱스 증가(다음 몬스터로 전투)
break # 'Y'를 선택하면 다음 몬스터로 진행
elif continue_battle == 'n':
print(f"{monster_name}과의 전투를 다시 시작합니다.")
battle(player, monster) # 'N'을 선택하면 같은 몬스터와 계속 전투
break # 'N'을 선택하면 현재 몬스터와 계속 전투를 반복하도록 함
else:
print("잘못된 입력입니다. Y 또는 N을 입력해주세요.") # 잘못된 입력을 처리하는 메시지
else:
print("모든 몬스터를 처치했습니다. 축하합니다!")
# 게임 시작
if __name__ == "__main__":
main()
프로젝트 회고
이 프로젝트를 진행하며, 파이썬을 처음 배우면서 게임을 만드는 게 생각보다 훨씬 더 복잡하다는 것을 깨달았다.처음에는 "게임 만들기가 재밌고 간단할 줄 알았는데? 실제로 코드를 작성하면서 여러 문제를 해결해야 했고, 그 과정에서 점점 더 많은 것을 배울 수 있었던 것 같다.
- 게임의 흐름을 이해하는 것의 중요성 : 처음엔 게임의 흐름이나 구조를 잘 이해하지 못해서 코드가 어떻게 이어지는지 잘 모를 때가 많았어요. 예를 들어, 전투 후 'Y'와 'N'을 선택하는 부분에서, 어떻게 몬스터가 바뀌는지와 같은 흐름을 제대로 구현하는 것이 생각보다 어려웠습니다. 이런 부분을 구현하려면 사용자의 선택을 처리하는 방식이 어떻게 돌아가는지 깊이 생각해야 하는거 같습니다.(실제로 게임을 하다보면 상위레벨의 몬스터는 어느정도 능력치와 레벨업이 된다음 도전하는경우가 많아서 다음레벨 몬스터와 전투하지 않으면 계속 같은 레벨몬스터와 전투를 하게 하여 레벨업이 될 수 있도록 적용했습니다.
- 반복문과 조건문이 왜 중요한지? : 게임에서 반복적으로 전투를 하는 부분을 작성할 때, while문과 if-else문을 이해하는 게 얼마나 중요한지 절실하게 느꼈습니다. 잘못된 입력을 처리하는 부분에서 반복문을 사용하고, if문을 활용해서 맞게 조건을 나누는 과정에서 시행착오를 겪었어요. 이런 부분을 제대로 이해하는 데 시간이 좀 걸렸지만, 그만큼 조건문과 반복문에 대한 이해도가 높아졌습니다.
- 디버깅은 중요하다 : 프로젝트 초반에는 코드가 잘 되지 않아서 코드가 돌아가는 것 같다가도 index 값이 제대로 반영되지 않는다거나, continue와 break가 엉켜서 루프가 제대로 동작하지 않는 문제가 생겼습니다. 그때마다 코드의 흐름을 천천히 따라가며 디버깅을 했는데, 그 과정에서 논리적 사고가 정말 중요한것 같습니다. 실제로 오류를 찾고 수정하는 일이 게임 개발의 중요한 부분이라는 걸 느꼈습니다.
- 작은 문제들이 모여 큰 문제를 만든다는 깨달음 : 작은 부분에서 오류가 발생할 때는 별거 아니라고 생각했는데, 결국 그 작은 문제가 쌓여서 큰 버그가 되니 예를 들어, 전투후 다음레벨 몬스터로 Y/N 로 선택후 에 몬스터가 제대로 바뀌지 않는 문제나, 잘못된 입력을 처리하는 코드가 제대로 동작하지 않았던것 같습니다. 이럴 때마다 코드의 작은 부분까지도 꼼꼼히 체크해야 한다는 걸 알게 되었고, 결국 세심한 코드 작성이 프로젝트의 성공을 좌우한다는 생각을 하게 됐습니다.
결론적으로 이 프로젝트는 단순한 게임 만들기라고 생각했지만, 그 안에서 많은 것을 배운 시간이었으며, 문제를 해결하는 과정에서 점점 더 프로그래밍에 대한 이해가 깊어졌고, 디버깅의 중요성, 반복문과 조건문의 활용, 그리고 작은 문제도 철저히 확인하는게 중요하다고 느꼈고 처음 시작할 때는 어떻게 해야 할지 막막했지만, 끝내 게임이 완성될 때의 기쁨은 정말 크고 보람있는거 같습니다.
특히 게임 프로그램을 만드는 입장에서 실제로 게임의 구성부터 실제 게임유져가 되어 게임 케릭터들을 선택하고 실제로 게임을 해보면서 게임을 너무 싶게 만들어서도 안되고, 게임을 너무 어렵게 만들어서도 안된다는 기준으로 어느정도 유져가 성취감이 있을 수 있게 할려고 고민했으며, 게임내에서 각 케릭터들의 능력치 밸런스로 처음 케릭터 의 직업을 선택해서 잘고르면 쉽게 게임을 할 수있는 경우를 최대한 배재 할려고 노력했으며, 직업별로 고유 능력을 어떻게 분배할까를 실제로 게임을 실행해 보면서 케릭터의 능력치를 수정해 가며 밸런스를 균형있게 맞출려고 시도하는게 시간이 많이 걸리는거 같습니다. 실제 전체 몬스터를 순차적으로 처치하는 기준에서는 탱커(25%), 마법사(10%), 궁수(20%), 힐러(5%미만)으로 승률을 설정하여 결국 레벨업으로 캐릭터의 능력치를 상승시킨 다음 다음 레벨 몬스터로 전투해야 승률이 높게 나오게 게임을 구성했으며, 결국은 예전 게임처럼 한번 만들어 놓은 게임들을 유저들이 즐기는것이 아니라 요즘 게임은 처음에 베타버전부터 유져가 참여하여 버그나 게임상에 문제점 그리고 케릭터들간에 능력치 밸런스 문제들을 사전에 테스트하면서 진행하는것이 프로젝트를 처음부터 완벽하게 만들어서 내놓고 프로젝트를 끝내는것이 아니라 유저들과 테스트를 하면서 수정하고 업그레이드 하면서 실시간으로 프로젝트를 진행하는 애자일 프로젝트 방식이 요구된다는것을 느낄 수 있는 프로젝트였던거 같습니다.