본문 바로가기

게임/원피스랜덤디펜스 - 조합도우미

원랜디 조합도우미

 원피스 랜덤 디펜스라는 워크래프트 유즈맵입니다. 라운드마다 랜덤하게 주어지는 캐릭터들을 조합하여 더 강한 캐릭터를 만들어가면서 풀어나가는 게임입니다. 대략 6단계의 캐릭터 등급이 있습니다. 캐릭터마다 조합법이 있는데 보통 한 단계 아래의 캐릭터 3개가 재료가 됩니다. (예를들어 5등급 캐릭터를 만들려면 6등급 캐릭터 3개를 모아야됩니다.)

 

보통 1등급 캐릭터(6등급 캐릭터 3^5개) 2개는 만들어야 클리어가 가능하기에 신중하게 조합해야 합니다.

조합도우미는 지금 가지고 있는 유닛들로 가장 효율적인 조합 트리를 선택하는데 도움을 주는 프로그램이라고 보시면 될 것 같습니다.

 

 

 프로그래밍을 배우고 거의 처음 만든 실용 프로그램이라 기억에 남네용 ㅎㅎ

blog.naver.com/fox_93/221342405353

 

원랜디 조합도우미 상세설명서(fix2기준)

#명령어 'ㅎ' 추가됨: 희귀함 필요 갯수 출력 '본조합' -> 'ㅂ'으로 바꿈 3: 이제 희귀함도 나옴 : 불멸...

blog.naver.com

 

 

#간단한 사용예시입니다

 

6행에서 import한 pasi.py(사용코드입력해야 프로그램 쓸 수 있게 하는 프로그램)는 아래 포스팅에 코드 전문이 있습니다.

yanoos.tistory.com/41

 

인터넷이 없는 상황에서도 쓸 수 있는 사용 인증 키

제 첫 실용 프로그램이었던 원랜디 조합도우미입니다. 원피스랜덤디펜스라는 게임을 할 때 보다 편하게 하기 위해 만든 프로그램입니다. 소스는 6행만 보시면 됩니다. 6행에 보면 pasi를 import했

yanoos.tistory.com

 

지금은 안들어가지는데 웹으로도 만들어봤었습니다

 

 

#-*-coding: utf-8-*-
#ORDCombi.py
#원랜디 조합도우미
import sys
sys.path.append('C:/ordhelper/tocken3/AtoZ/1')
import pasi

#모든캐릭 기본유닛으로 분해v
#가장 일치도 높은 캐릭터 추천v
#단위별 조합표v
#20190312
#보유 최소단위 유닛 버그 수정 v

'''언젠가쓸지도...#######################################################################################################################
#import openpyxl

#엑셀 조합표 열기
#wb = openpyxl.load_workbook('Combination.xlsx')
#열려있는 시트 
#ws = wb.active
class coalmot():

'''
#stun_ad = ['키드희귀','죠즈','바제스','임팩트다이얼','봉쿠레히든','레드포스호히든','아오키지히든','아카이누히든','이완코브히든','피셔타이거히든','드레곤전설','라분전설','제파전설','후지토라전설','샹크스전설','시키전설','쿠마전설','루피초월','로빈초월','도플라밍고초월','시라호시초월','후지토라초월','거프불멸','버기영원','크로커다일제한','핸콕영원']
#stun_ap = ['키드희귀','죠즈','바제스','임팩트다이얼','레드포스호히든','아오키지히든','이완코브히든','피셔타이거히든','후지토라전설','샹크스전설','시키전설','쿠마전설','아오키지초월','키자루초월','샹크스초월','후지토라초월','시라호시초월','센고쿠불멸','시키불멸','드레곤불멸','제트불멸','핸콕영원']
newstun = ['거프불멸',1, '도플라밍고초월',1, '드레곤불멸',1, '드레곤전설',1, '라분전설',1, '레드포스호히든',1, '로빈초월',1, '루피초월',1, '봉쿠레히든',0.5, '샹크스전설',1, '샹크스초월',2, '센고쿠불멸',1,'시라호시초월',1, '시키불멸',1.5, '시키전설',1, '아오키지초월',1, '아오키지히든',0.5,'이완코브히든',0.5, '제트불멸',1, '제파전설',1, '쿠마전설',1, '크로커다일제한',0.5, '키자루초월',1, '피셔타이거히든',1, '핸콕영원',0.75, '후지토라전설',1, '후지토라초월',0.75]
atack_speed= ['로우','로우희귀','레일리전설','발라티에히든','로우전설','라분전설','슈가전설','제프전설','히루루크전설','쵸파초월','브룩초월','샹크스초월','레일리불멸','드레곤불멸','버기영원']
ad_deal = ['루피초월','조로초월','우솝초월','시라호시초얼','도플라밍고초월','사보초월','로져불멸','레일리불멸','스코퍼가반불멸','거프불멸','흰수염불멸','핸콕영원','스모커영원','카번딧슈영원','크로커다일제한','레베카제한']
ad_sub = ['코알라히든','베르고히든','미호크히든','거프전설','루피개틀링전설','모리아전설','마르코전설','센고쿠전설','흰수염전설','코비','로빈초월','버기영원']
amorbreak = ['항마의상',10,'미호크히든',30,'모비딕호히든',10,'레베카히든',15,'파이러츠도킹6히든',10,'킬러히든',15,'봉쿠레히든',10,'사보히든',20,'베르고히든',50,'코알라히든',30,'에이스전설',30,'시저전설',30,'쵸파전설',30,'제프전설',30,'흰수염전설',12,'레일리전설',40,'센고쿠전설',5,'비비',10,'루피초월',40,'조로초월',50,'우솝초월',10,'쵸파초월',60,'로빈초월',45,'도플라밍고초월',30,'사보초월','30%','타시기초월',60,'로져불멸',60,'흰수염불멸',50,'레일리불멸',20,'핸콕영원',40,'카번딧슈영원',25,'버기영원',30,'스모커영원',30,'레베카제한',38,'크로커다일제한',25]
mana = ['슈가','코알라히든','키자루히든','코비전설','징베전설','프랑키초월']
ap_deal = ['나미초월','상디초월','프랑키초월','브룩초월','시라호시초얼','아카이누초월','아오키지초월','키자루초월','티치초월','샹크스초월','로우초월','센고쿠불멸','시키불멸','드레곤불멸','에이스영원','핸콕영원','비비영원','미호크영원','에넬제한','레드필드제한']
ap_sub =['페로나히든','시류히든','킨에몬히든','징베전설','나미전설','에이스전설','제파전설','코비전설']
apbreak = ['방주맥심히든','프랑키초월','브룩초월','시키불멸','에넬제한']
move = ['키드희귀',28,'스모커',8,'나미크리마',15,'크로커',10,'키드',10,'크로커제로',20,'스모커희귀',25,'사보',25,'페로나희귀',27,'흰수염전설',60,'후지토라전설',40,'마르코전설',35,'나미전설',43,'페로나히든',35,'아인제한',45,'사보히든',25,'모비딕호히든',40,'비비',30,'도플라밍고',30,'아오키지히든',40]
unique = ['거프','검은수염','도플라밍고','로우희귀','레오파드','기어써드','류마','마르코불사조','마젤란','모몬가','미호크','바르토로메오','바제스','항마의상','반더데켄','벤베크만','브룩희귀','비비','사보','상디디아블','센토마루','샹크스','슈가','스모커희귀','시류','아오키지','아카이누','뇌신','오즈','임팩트다이얼','이완코브','제프','조로희귀','죠즈','가드포인트','크로커제로','키드희귀','키자루','킨에몬','페로나희귀','꾸드방','핸콕']
unit_a = ['루피','조로','나미','우솝','상디','쵸파','칼병','총병','버기']

unit_b = ['에이스','로빈','브룩','저격왕','프랑키','후쿠로','스모커','블루노','하찌','페로나','이나즈마','베포','쵸파럼블볼']

unit_c = ['기어세컨드','나미크리마','검은다리','귀기','마기탄','타시기','오하라','마르코','챠카','루치','갱뱃지', '로우', '쿠마', '드레이크', '킬러', '봉쿠레', '이나즈마혁명군', '파이러츠도킹5', '크로커', '모리아', '헤르메포', '에이스2번대','징베', '아론', '조로초신성', '스쿼드', '점프강화', '쵸두강', '바질호킨스', '키드', '에넬', '화염탄', '압살롬']
unit_e = ['미호크히든', '레베카히든', '류마히든', '마젤란히든', '반더데켄히든', '베르고히든', '봉쿠레히든', '사보히든', '시류히든', '아오키지히든', '아카이누히든', '이완코브히든', '코알라히든', '키자루히든', '킨에몬히든', '킬러히든', '파이러츠도킹6히든', '페로나히든', '피셔타이거히든', '레드포스호히든', '모비딕호히든', '발라티에히든', '방주맥심히든', '써니호히든']
unit_d = ['거프전설', '티치전설', '나미전설', '드레곤전설', '라분전설', '레이쥬전설', '레일리전설', '루치전설', '로우전설', '루피개틀링전설', '루피나메전설', '마르코전설', '모리아전설', '바르토로메오전설', '상디전설', '샹크스전설', '센고쿠전설', '슈가전설', '시저전설', '시키전설', '에이스전설', '제파전설', '제프전설', '조로전설', '징베전설', '쵸파전설', '카르가라전설', '코비전설', '쿠마전설', '핸콕전설', '후지토라전설', '흰수염전설', '히루루크전설']
unit_f = ['카타쿠리제한','로져불멸', '레일리불멸', '스코퍼가반불멸', '거프불멸', '흰수염불멸', '센고쿠불멸', '시키불멸', '드레곤불멸', '제트불멸', '미호크영원', '버기영원', '비비영원', '스모커영원', '에이스영원', '카번딧슈영원','빅1','빅2','빅3','빅파','빅센', '핸콕영원', '레드필드제한', '에넬제한', '크로커다일제한', '레베카제한', '루피초월', '조로초월', '나미초월', '우솝초월', '상디초월', '쵸파초월', '로빈초월', '프랑키초월', '브룩초월', '시라호시초월', '아카이누초월', '아오키지초월', '키자루초월', '티치초월', '샹크스초월', '로우초월', '도플라밍고초월', '사보초월', '후지토라초월', '타시기초월', '빅맘초월']
how_to_use='''
##도움말
신기능은 '도움말히든' 입력해주세요
 -'1.인벤추가' ~ '5.인벤토리출력'은 숫자만 입력하고 엔터치시면 바로 작동합니다.
  (ex 인벤추가가 하고싶다면 '1' 입력 후 엔터)
 -숫자 명령어 외의 명령어는 아래를 참고해주세요


#인벤토리에는 기본적으로 변화기회2번이 들어있습니다
#'인벤초기화''를 해도 변화기회2번은 들어있습니다(없애려면 '삭제')

#명령어 ()
 '1' - 내게 있는 유닛을 프로그램에 입력하는 것
 '2' - 만들고자 하는 유닛에 필요한 재료 찾을때 사용
     - 최소단위로 나옴
     - ex) 인벤토리에 우솝2 상디1이 있을 때, 에넬 검색시  루피1 쵸파1 이렇게 나옴

 '3' - 초불영제 각각 최근접 조합 출력(이건 써보면앎)
 '4' - *중요* 워크에서 유닛을 조합했을때 프로그램에 이를 반영하는것
     - 유닛 만들고 반드시 해줘야함
     - 하나하나 할 필요는 없고 최종적으로 만든 유닛만 입력하면 됨
     - ex) 인벤토리에 우솝2 루피 쵸파 상디가 있고 에넬을 만들 때, 저격왕 베포 하나하나 만들기 할 필요는 없고 에넬만 입력하면 됨 
 -'ㅎ' 입력시 희귀함 필요갯수 출력
 -'ㅂ' - 입력유닛의 원래 조합식 출력
 '영역' - 초불영제 희귀 이감 방깎 등의 영역별 근접조합 탐색
 '찾' - 그런유닛 없음 뜨면 사용하세요. 유닛의 프로그램용 이름 찾기
 '삭제' - 유닛을 팔았을때, 잘못 등록했을때 사용해주세요
 '보유' - 입력유닛 제작 위한 재료 중, 보유중인 재료 출력 
         여기 뜨는거 빼고 다팔아도됨
         (최후의 유닛 만들 때 유용)
 '인벤초기화' - 프로그램 인벤토리를 초기화함. 한판 끝났거나 실수해서 프로그램과 워크 유닛에 차이가 있을때 사용
#주의사항
 1.유닛 만들고 반드시 만들기에 입력 해주셔야합니다(안할시 워크 - 프로그램 유닛에 차이생김)
 2.만들기 할 때 만드는 도중에 도박한다던지 위습넣는다던지 재료 추가시키지마셈 (1과같은이유)
 3.있는재료 있는지 모르고 만들어서 쓰는 상황 조심(1과같은이유)
 4.아무튼 만들기 할 때 초집중하셈 워크-프로그램 유닛차이생기면 선위 날리고 인벤 초기화해서 다시써야되고 귀찮아짐
'''

hidden_use='''
##히든도움말

#명령어(히든)
 개인입력
 개인조합
 개인삭제
 #개인xx류의 자세한 사용 설명은 블로그에(하단 블로그주소)
 https://blog.naver.com/fox_93


'''

logtimes = 999999999999999
#최소단위유닛, 저장
min_unit = ['압살롬','루피','조로','나미','우솝','쵸파','상디','버기','총병','칼병','좀비','레일리','해적선','장군좀비','초월용쿠마','변화기회','거인족']
#모든유닛이름(인벤 저장시 오타 방지용)
all_unit =['카타쿠리제한','루치초월','카쿠희귀','루피', '조로', '나미', '우솝', '쵸파', '상디', '버기', '총병', '칼병', '좀비', '레일리', '해적선', '장군좀비', '초월용쿠마', '변화기회', '거인족', '에이스', '로빈', '브룩', '저격왕', '프랑키', '후쿠로', '스모커', '블루노', '하찌', '페로나', '이나즈마', '베포', '쵸파럼블볼', '기어세컨드', '나미크리마', '검은다리', '귀기', '마기탄', '타시기', '오하라', '마르코', '챠카', '루치', '갱뱃지', '로우', '쿠마', '드레이크', '킬러', '봉쿠레', '이나즈마혁명군', '파이러츠도킹5', '크로커', '모리아', '헤르메포', '에이스2번대', '징베', '아론', '조로초신성', '스쿼드', '점프강화', '쵸두강', '바질호킨스', '키드', '에넬', '화염탄', '압살롬', '벤베크만', '기어써드', '상디디아블', '조로희귀', '미호크', '핸콕', '크로커제로', '비비', '꾸드방', '센토마루', '스모커희귀', '마젤란', '모몬가', '시류', '레오파드', '아오키지', '키자루', '아카이누', '검은수염', '로우희귀', '항마의상', '바제스', '오즈', '류마', '페로나희귀', '슈가', '브룩희귀', '도플라밍고', '가드포인트', '샹크스', '이완코브', '사보', '마르코불사조', '죠즈', '바르토로메오', '반더데켄', '임팩트다이얼', '뇌신', '제프', '킨에몬', '키드희귀', '거프', '미호크히든', '레베카히든', '류마히든', '마젤란히든', '반더데켄히든', '베르고히든', '봉쿠레히든', '사보히든', '시류히든', '아오키지히든', '아인제한', '아카이누히든', '이완코브히든','코알라히든', '키자루히든', '킨에몬히든', '킬러히든', '파이러츠도킹6히든', '페로나히든', '피셔타이거히든', '레드포스호히든', '모비딕호히든', '발라티에히든', '방주맥심히든', '써니호히든', '거프전설', '티치전설', '나미전설', '드레곤전설', '라분전설', '레이쥬전설', '레일리전설', '루치전설', '로우전설', '루피개틀링전설', '루피나메전설', '마르코전설', '모리아전설', '바르토로메오전설', '상디전설', '샹크스전설', '센고쿠전설', '슈가전설', '시저전설', '시키전설', '에이스전설', '제파전설', '제프전설', '조로전설', '징베전설', '쵸파전설', '카르가라전설', '코비전설', '쿠마전설', '핸콕전설', '후지토라전설', '흰수염전설', '히루루크전설', '로져불멸', '레일리불멸', '스코퍼가반불멸', '거프불멸', '흰수염불멸', '센고쿠불멸', '시키불멸', '드레곤불멸', '제트불멸', '미호크영원', '버기영원', '비비영원', '스모커영원', '에이스영원', '카번딧슈영원','빅1','빅2','빅3','빅파','빅센', '핸콕영원', '레드필드제한', '에넬제한', '크로커다일제한', '레베카제한', '루피초월', '조로초월', '나미초월', '우솝초월', '상디초월', '쵸파초월', '로빈초월', '프랑키초월', '브룩초월', '시라호시초월', '아카이누초월', '아오키지초월', '키자루초월', '티치초월', '샹크스초월', '로우초월', '도플라밍고초월', '사보초월', '후지토라초월', '타시기초월', '빅맘초월']
#모든 유닛 조합 key = 캐릭명(str), value = 그캐릭재료들(리스트)
all_combination={'카타쿠리제한':['레이쥬전설','제프','기어세컨드'],'에이스': ['루피', '총병'],'아인제한':['베르고히든','아오키지','드레이크'],'로빈': ['나미', '상디'], '브룩': ['조로', '쵸파'], '저격왕': ['우솝', '우솝'], '프랑키': ['우솝', '루피'], '후쿠로': ['칼병', '칼병'], '스모커': ['총병', '칼병'], '블루노': ['총병', '총병'], '하찌': ['나미', '총병'], '페로나': ['버기', '나미'], '이나즈마': ['상디', '조로'], '베포': ['쵸파', '루피'], '쵸파럼블볼': ['쵸파', '쵸파'], '기어세컨드': ['루피', '루피', '루피'], '나미크리마': ['나미', '나미', '나미'], '검은다리': ['상디', '상디', '상디'], '귀기': ['조로', '조로', '조로'], '마기탄': ['버기', '버기', '버기'], '타시기': ['로빈', '총병', '칼병'], '오하라': ['로빈', '로빈', '쵸파'], '마르코': ['블루노', '에이스', '상디'], '챠카': ['블루노', '후쿠로', '쵸파'], '루치': ['후쿠로', '로빈', '루피'], '갱뱃지': ['후쿠로', '총병', '버기'], '로우': ['베포', '스모커', '버기'], '쿠마': ['베포', '프랑키', '조로'], '드레이크': ['스모커', '후쿠로', '쵸파'], '킬러': ['스모커', '브룩', '버기'], '봉쿠레': ['이나즈마', '로빈', '나미'], '이나즈마혁명군': ['이나즈마', '이나즈마'], '파이러츠도킹5': ['프랑키', '프랑키', '조로'], '크로커': ['프랑키', '저격왕', '버기'], '모리아': ['브룩', '브룩', '상디'], '헤르메포': ['브룩', '조로', '상디'], '에이스2번대': ['에이스', '에이스', '우솝'], '징베': ['에이스', '후쿠로', '버기'], '아론': ['하찌', '하찌', '루피'], '조로초신성': ['하찌', '조로', '칼병'], '스쿼드': ['쵸파럼블볼', '프랑키', '나미'], '점프강화': ['쵸파럼블볼', '이나즈마', '칼병'], '쵸두강': ['쵸파럼블볼', '로빈', '버기'], '바질호킨스': ['페로나', '블루노', '우솝'], '키드': ['페로나', '베포', '버기'], '에넬': ['저격왕', '베포', '상디'], '화염탄': ['저격왕', '저격왕'], '압살롬': ['좀비', '좀비', '좀비', '상디'], '벤베크만': ['화염탄', '타시기', '에넬'], '기어써드': ['기어세컨드', '봉쿠레', '에넬'], '상디디아블': ['검은다리', '점프강화', '키드'], '조로희귀': ['귀기', '모리아', '타시기'], '미호크': ['귀기', '조로초신성', '드레이크'], '핸콕': ['나미크리마', '아론', '기어세컨드'], '크로커제로': ['크로커', '징베', '봉쿠레'], '비비': ['챠카', '크로커', '나미크리마'], '꾸드방': ['파이러츠도킹5', '쿠마', '루치'], '센토마루': ['쿠마', '쵸두강', '갱뱃지'], '스모커희귀': ['타시기', '드레이크', '기어세컨드'], '마젤란': ['징베', '마기탄', '에이스2번대'], '모몬가': ['징베', '헤르메포', '타시기'], '시류': ['드레이크', '갱뱃지', '검은다리'], '카쿠희귀': ['루치', '챠카', '오하라'], '아오키지': ['오하라', '스쿼드', '에넬'], '키자루': ['헤르메포', '로우', '키드'], '아카이누': ['에이스2번대', '크로커', '이나즈마혁명군'], '검은수염': ['에이스2번대', '스쿼드', '드레이크'], '로우희귀': ['로우', '파이러츠도킹5', '쵸두강'], '항마의상': ['바질호킨스', '킬러', '로우'], '바제스': ['바질호킨스', '마르코', '마기탄'], '오즈': ['모리아', '모리아', '기어세컨드'], '류마': ['모리아', '귀기', '페로나', '저격왕', '칼병'], '페로나희귀': ['압살롬', '페로나', '검은다리', '쵸두강'], '슈가': ['쵸두강', '귀기', '페로나', '우솝'], '브룩희귀': ['브룩', '모리아', '루치'], '도플라밍고': ['점프강화', '마기탄', '루치'], '가드포인트': ['점프강화', '헤르메포', '로우'], '샹크스': ['마기탄', '기어세컨드', '화염탄'], '이완코브': ['이나즈마혁명군', '오하라', '크로커'], '사보': ['이나즈마혁명군', '쿠마', '마르코'], '마르코불사조': ['마르코', '챠카', '점프강화'], '죠즈': ['스쿼드', '조로초신성', '갱뱃지'], '바르토로메오': ['조로초신성', '아론', '파이러츠도킹5'], '반더데켄': ['아론', '헤르메포', '징베'], '임팩트다이얼': ['화염탄', '갱뱃지', '나미크리마'], '뇌신': ['에넬', '검은다리', '화염탄'], '제프': ['봉쿠레', '바질호킨스', '이나즈마혁명군'], '킨에몬': ['킬러', '에이스2번대', '조로초신성'], '키드희귀': ['킬러', '나미크리마', '키드'], '미호크히든': ['미호크', '샹크스', '죠즈'], '레베카히든': ['바제스', '기어써드', '로빈'], '류마히든': ['조로희귀', '류마', '브룩'],'반더데켄히든': ['반더데켄', '검은수염', '아론', '해적선'], '베르고히든': ['상디디아블', '킨에몬', '바르토로메오', '타시기'], '봉쿠레히든': ['핸콕', '봉쿠레', '마기탄', '이나즈마혁명군'], '사보히든': ['오즈', '로우희귀', '사보'], '시류히든': ['시류', '키자루', '항마의상', '벤베크만'], '아오키지히든': ['아오키지', '죠즈', '모몬가'],'아카이누히든': ['아카이누', '반더데켄', '키드희귀'], '이완코브히든': ['이완코브', '크로커제로', '마기탄', '봉쿠레'], '코알라히든': ['징베전설', '비비', '로빈'], '킨에몬히든': ['킨에몬', '조로희귀', '키드'], '킬러히든': ['키드희귀', '헤르메포', '킬러', '바질호킨스'], '페로나히든': ['모리아전설', '페로나희귀', '압살롬', '저격왕', '저격왕', '장군좀비'], '피셔타이거히든': ['반더데켄', '핸콕', '파이러츠도킹5', '레일리'], '레드포스호히든': ['샹크스', '벤베크만', '해적선','변화기회'], '모비딕호히든': ['죠즈', '마르코', '에이스', '해적선'], '발라티에히든': ['제프', '기어세컨드', '해적선'], '방주맥심히든': ['뇌신', '임팩트다이얼', '갱뱃지', '해적선'], '써니호히든': ['꾸드방', '카쿠희귀', '해적선'], '거프전설': ['모몬가', '스모커희귀', '마젤란'], '티치전설': ['검은수염', '시류', '바제스'], '나미전설': ['비비', '브룩희귀', '페로나희귀'], '드레곤전설': ['이완코브', '사보', '비비'], '라분전설': ['브룩희귀', '바르토로메오', '시류'], '레이쥬전설': ['마젤란', '꾸드방', '크로커제로'], '레일리전설': ['레일리', '센토마루', '징베'], '루치전설': ['카쿠희귀', '로우희귀', '스모커희귀'], '로우전설': ['로우희귀', '키드희귀', '센토마루'], '루피개틀링전설': ['기어써드', '비비', '카쿠희귀'], '루피나메전설': ['오즈', '류마', '기어써드','압살롬'], '마르코전설': ['마르코불사조', '꾸드방', '핸콕'], '모리아전설': ['오즈', '류마', '슈가'], '바르토로메오전설': ['바르토로메오', '사보', '기어써드'], '상디전설': ['상디디아블', '이완코브', '항마의상'], '샹크스전설': ['샹크스', '벤베크만', '상디디아블'], '센고쿠전설': ['아카이누', '아오키지', '키자루'], '슈가전설': ['슈가', '임팩트다이얼', '항마의상'], '시저전설': ['도플라밍고', '키자루', '스모커희귀'], '시키전설': ['뇌신', '카쿠희귀', '마젤란'], '에이스전설': ['마르코불사조', '모몬가', '검은수염'], '제파전설': ['아오키지', '바제스', '임팩트다이얼'], '제프전설': ['제프', '킨에몬', '슈가'], '조로전설': ['조로희귀', '페로나희귀', '미호크'], '징베전설': ['반더데켄', '로우희귀', '아카이누'], '쵸파전설': ['가드포인트', '벤베크만', '센토마루'], '카르가라전설': ['임팩트다이얼', '뇌신', '브룩희귀'], '코비전설': ['시류', '샹크스', '제프'], '쿠마전설': ['센토마루', '꾸드방', '가드포인트'], '핸콕전설': ['핸콕', '상디디아블', '미호크'], '후지토라전설': ['킨에몬', '도플라밍고', '크로커제로'], '흰수염전설': ['죠즈', '마르코불사조', '킨에몬'], '히루루크전설': ['가드포인트', '반더데켄', '바제스'], '로져불멸': ['센고쿠전설', '에이스전설', '거프전설'], '레일리불멸': ['레일리전설', '핸콕전설', '루피나메전설'], '스코퍼가반불멸': ['레이쥬전설', '조로전설', '샹크스전설'], '거프불멸': ['거프전설', '코비전설', '루피개틀링전설','변화기회'], '흰수염불멸': ['흰수염전설', '바르토로메오전설', '마르코전설'], '센고쿠불멸': ['센고쿠전설', '레이쥬전설', '루치전설'], '시키불멸': ['시키전설', '상디전설', '카르가라전설'], '드레곤불멸': ['드레곤전설', '쿠마전설', '제프전설'], '제트불멸': ['제파전설', '루피개틀링전설', '슈가전설','변화기회'], '미호크영원': ['페로나히든', '미호크히든', '시류', '조로초신성', '해적선', '해적선'], '버기영원': ['나미전설', '이완코브히든', '샹크스','마젤란','마기탄','압살롬'], '비비영원': ['크로커다일제한', '비비', '기어써드', '벤베크만', '오하라', '파이러츠도킹5','변화기회'], '에이스영원': ['에이스전설', '마르코전설', '징베', '스쿼드', '마기탄','변화기회'], '카번딧슈영원': ['로우전설', '킬러히든', '기어써드', '조로초신성', '초월용쿠마'], '핸콕영원': ['핸콕전설', '피셔타이거히든', '기어써드', '모몬가', '징베'], '레드필드제한': ['히루루크전설', '바르토로메오전설', '브룩희귀'], '에넬제한': ['시저전설', '방주맥심히든', '해적선', '나미크리마'], '크로커다일제한': ['비비', '아카이누히든', '크로커제로','변화기회'], '레베카제한': ['슈가전설', '레베카히든', '도플라밍고', '변화기회','변화기회'], '루피초월': ['루피개틀링전설', '루피나메전설', '뇌신', '초월용쿠마'], '조로초월': ['조로전설', '미호크히든', '바르토로메오', '페로나', '초월용쿠마'], '나미초월': ['나미전설', '시키전설', '나미크리마', '아론', '초월용쿠마'], '우솝초월': ['카르가라전설', '슈가전설', '벤베크만', '페로나', '초월용쿠마'], '상디초월': ['상디전설', '제프전설', '나미크리마', '초월용쿠마'], '쵸파초월': ['쵸파전설', '히루루크전설', '초월용쿠마'], '로빈초월': ['바르토로메오전설', '루치전설', '오하라', '크로커', '초월용쿠마'], '프랑키초월': ['쿠마전설', '카쿠희귀', '킨에몬히든', '프랑키', '초월용쿠마'], '브룩초월': ['라분전설', '류마히든', '페로나희귀', '모리아', '초월용쿠마'], '시라호시초월': ['징베전설', '반더데켄히든', '비비', '초월용쿠마'], '아카이누초월': ['센고쿠전설', '아카이누히든', '에이스2번대', '초월용쿠마'], '아오키지초월': ['제파전설', '아오키지히든', '오하라', '스모커', '초월용쿠마'], '키자루초월': ['후지토라전설', '키자루', '레일리전설', '조로초신성', '아론', '초월용쿠마'], '빅1': ['빅맘초월','드레곤불멸'],'빅2':['빅맘초월','발라티에히든','아오키지히든'],'빅3': ['빅맘초월','에넬제한'],'빅파':['빅맘초월','시류히든','라분전설','아오키지히든'],'빅센':['빅맘초월','센고쿠불멸'],'티치초월': ['티치전설', '흰수염전설', '바질호킨스', '초월용쿠마'], '샹크스초월': ['샹크스전설', '미호크히든', '키드희귀', '기어세컨드', '초월용쿠마'], '로우초월': ['로우전설', '시저전설', '베포', '베포', '초월용쿠마'], '도플라밍고초월': ['베르고히든', '도플라밍고', '슈가', '로우희귀', '초월용쿠마','변화기회'], '사보초월': ['마르코전설', '사보히든', '해적선', '바제스', '에이스2번대', '초월용쿠마'], '후지토라초월': ['후지토라전설', '킨에몬히든', '모몬가', '스모커', '초월용쿠마'], '타시기초월': ['코비전설', '시저전설', '타시기', '스모커', '초월용쿠마','변화기회'], '빅맘초월': ['레이쥬전설', '상디전설', '발라티에히든', '브룩', '초월용쿠마'],'루치초월':['루치전설','사보히든','오하라','초월용쿠마']}
#인벤토리
inventory = ['변화기회','변화기회']
all_johap =[]

'''
#모든유닛 이름 저장
where = 1
while True:
        if str(ws.cell(where,1).value)[0] =='S'or str(ws.cell(where,1).value)[0] =='E':
                where += 1
                
                continue
        elif ws.cell(where,1).value == 'quit':
                
                break
        elif ws.cell(where,1).value ==None:
                where+=1
                
                continue
        else:
                all_unit.append(ws.cell(where,1).value)
                where+=1
                

#모든유닛 조합 저장
where = 1
while True:
        if str(ws.cell(where,1).value)[0] =='S'or str(ws.cell(where,1).value)[0] =='E':
                where += 1
                
                continue
        elif ws.cell(where,1).value == 'quit':
                
                break
        elif ws.cell(where,1).value ==None:
                where+=1
                
                continue
        else:
                if ws.cell(where,1).value != None:
                        imsi_combination=[]
                        col =2
                        while True:
                                if ws.cell(where,col).value == None:
                                        if len(imsi_combination)>0:
                                                all_combination[ws.cell(where,1).value] = imsi_combination
                                        break
                                else:
                                        imsi_combination.append(ws.cell(where,col).value)
                                        col+=1
                where+=1

wb.close()
'''
#################################################################함수 공간###############################################################
ucnum = 0
#[빅1,빅2,빅3]같은거
pclist = []

def insert_user_combination():
	personal_combination=[]
	global ucnum
	ucnum+=1
	while True:
		#personal_combination이라는 캐릭터의 재료
		ucunit = input('유닛이름 입력(입력완료시 \'**\')\n:')
		if ucunit =='**':
			all_combination[str(ucnum)] = personal_combination
			pclist.append(str(ucnum))
			break
		if ucunit in all_unit:
			#personal_combination = 빅1 같은거
			personal_combination.append(ucunit)
			print(personal_combination)
		else:
			print(ucunit+'같은 유닛 없슴')
def print_user_combination():
        for check_char in pclist:
                all_key = [check_char]
                print("개인조합"+check_char,end=' ')
                #필요한수, 캐릭명, 재료(리스트)
                result =[]
                #한 캐릭터씩 집어넣는 포문
                for key in all_key:
                        #i = 완성품
                        #mo = 재료들
                        mo = all_combination[key][:]            
                        imsi_inven = inventory[:]
                        while True:
                                del_list=[]
                                #임시인벤에 있는 재료 지우고
                                for mt in mo:
                                        if mt in imsi_inven:
                                                imsi_inven.remove(mt)
                                                del_list.append(mt)
                                for dl in del_list:
                                        mo.remove(dl)
                        
                        
                                if len(mo) ==0:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        if min_check(mo) ==1:
                                                result.append([len(mo),key,mo])
                                                break
                                        else:
                                                decomposition(mo)
                #모든캐릭 조합
                result.sort()
                #루피루피 이런거 루피2로 바꾸는곳
                for i in result:
                        asdf = {}
                        for j in i[2]:
                                try:
                                        asdf[j] +=1
                                except:
                                        asdf[j] = 1
                        i[2] =asdf
                print(all_combination[check_char],end='')
                print("\n["+str(result[0][0])+"] 필요유닛:",result[0][2],"\n")	
def del_personal_combination():
	delnum = input('삭제할 개인조합 번호(*번호주의,숫자만입력,종료원할시\'**\'입력)')
	try:
		pclist.remove(delnum)
	except:
		print("##################뭔가 잘못됨####################")

#인벤토리 추가
def find_name():
	htfind = '''\n\n사용법은 다음과같다
	찾으려는 유닛의 키워드를 입력한다.
	#키워드는 최대한 작게, 한개의 키워드만 입력.
	##정 안나오면 이건 들어가겠지 싶은 한글자만 입력해보자(루피면 '루' 쵸파면 '쵸' 이런식으로)

	ex) 상디디아블잠브 찾는법
	키워드에 '상디'입력
	or
	키워드에 '디아'입력
	or
	키워드에 '디' 입력

	ex2) 파이러츠도킹5 찾는법
	키워드에 '파이러츠'입력
	or
	키워드에 '도킹'입력
	or
	키워드에 '파' 입력

	ex3) 루피나이트메어 찾는법
	키워드에 '루피'입력
	or
	키워드에 '나이트메어'입력
	or
	키워드에 '나' 입력
	'''





	while True:
		ptrl =[]
		find = input('키워드(\'사용법\' 입력시 사용법출력, \'**\' 입력시 종료)\n:')
		if find =='**':
			break
		if find =='사용법':
			print(htfind)
			continue

		for i in all_unit:
			if find in i:
				ptrl.append(i)

		if len(ptrl) == 0:
			print('다른 키워드로 찾아보세요\n')
			continue
		else:
			for j in ptrl:
				print(j)


def sell_check():
        while True:
                check_char = input("확인할 캐릭터이름\n:")
                if check_char in all_unit:
                        break
                else:
                        print("캐릭명오류")
        if check_char in unit_a:
                print("기본유닛 사용불가\n(\'보유\'기능은 만들고자 하는 캐릭터의 재료중에 내가 가지고 있는 캐릭터를 알려주는 기능입니다.)")
                return
                        
        #unit_a
        all_key = [check_char]
        #필요한수, 캐릭명, 재료(리스트)
        result =[]
        imsiresult = []
        #한 캐릭터씩 집어넣는 포문
        for key in all_key:
                #i = 완성품
                #mo = 재료들
                mo = all_combination[key][:]            
                imsi_inven = inventory[:]
                while True:
                        del_list=[]
                        #임시인벤에 있는 재료 지우고
                        for mt in mo:
                                if mt in imsi_inven:
                                        imsi_inven.remove(mt)
                                        del_list.append(mt)
                        for dl in del_list:
                                imsiresult.append(dl)
                                mo.remove(dl)
                
                
                        if len(mo) ==0:
                                result.append([len(mo),key,mo])
                                break
                        else:
                                if min_check(mo) ==1:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        decomposition(mo)
        imsiresult.sort()
        asdf = {}
        for i in imsiresult:
                try:
                        asdf[i] +=1
                except:
                        asdf[i] = 1
        asdfkey=list(asdf.keys())
        asdfkey.sort()
        for k in asdfkey:
                print(str(k)+str(asdf[k]))
                

def add_inven():
        while True:
                name = input("인벤에 넣을 캐릭 이름(종료원할시 \"**\")\n:")
                if name =="**":
                        break
                if name not in all_unit:
                	print("\n##############################\n"+str(name)+"같은 캐릭터 없음\n###############################\n\n")
                	continue

    

                while True:
                        num = input("몇개?\n:")
                        try:
                                num=int(num)
                                break
                        except:
                                print("###########################숫자만 쓰세요#####################")

                if name in all_unit:
                        for i in range(num):
                                inventory.append(name)
                        print(str(name),str(num)+"개 저장완료\n")
                else:
                        print("\n##############################\n"+str(name)+"같은 캐릭터 없음\n###############################\n\n")
#인벤 삭제
def del_inven():
        while True:
                name = input("삭제할 캐릭 이름(종료원할시 \"**\")\n:")
                if name =="**":
                        break
                while True:
                        num = input("몇개?\n:")
                        try:
                                num=int(num)
                                break
                        except:
                                print("숫자만 쓰세여 숫자모름?;;")
                try:
                    if name in all_unit and name in inventory:
                            for i in range(num):
                                    inventory.remove(name)
                            print(str(name),str(num)+"개 삭제완료\n")
                            print("현재 인벤에 "+name,"수는 "+str(inventory.count(name))+"개 입니다\n\n")
                    else:
                            print("인벤에 "+str(name)+"같은 캐릭터 없음\n")
                except:
                    print("##########유닛수오류############")
                    print("해당유닛 수 확인 후 삭제 또는 추가해주세요")
                    print("현재 인벤에 "+name,"수는 "+str(inventory.count(name))+"개 입니다\n\n")
                    return
#리스트의 재료가 모두 최소단위인지 확인하는 함수
def min_check(material):
        for i in material:
                if i not in min_unit:
                        #모두 최소단위는 아님
                        return 0
        else:
                #모두 최소단위임
                return 1

#리스트의 재료를 한단계 분해하는 함수
def decomposition(material):
        del_list = []
        for i in range(len(material)):
                if material[i] not in min_unit:
                        del_list.append(material[i])
        for i in del_list:
                material += all_combination[i]
                material.remove(i)
        return material





#만들기
def makechar():
        while True:
                ii = input('만들 캐릭터 이름 입력(종료키:**)\n:')
                if ii=="**":
                        return 0
                if ii in all_combination.keys():
                        break
        all_key = []

        all_key.append(ii)
        result = []
        #한 캐릭터씩 집어넣는 포문
        for key in all_key:
                #i = 완성품
                #mo = 재료들
                mo = all_combination[key][:]
                imsi_inven = inventory
                while_count =0
                while True:
                        while_count +=1
                        if while_count >=100:
                                print("SYSTEM ERROR: 인벤에 재료 다 없는데 만들기 하면 오류남..\n")
                                for i in result:
                                        imsi_inven.append(i)
                                return 0
                                        
                        del_list = []
                        #임시인벤에 있는 재료 지우고
                        for mt in mo:
                                if mt in imsi_inven:
                                        imsi_inven.remove(mt)
                                        del_list.append(mt)
                        for dl in del_list:
                                mo.remove(dl)
                                result.append(dl)
                        if len(mo) ==0:
                                break
                        else:
                                decomposition(mo)
        result.sort()
        asdf = {}
        for i in result:
                try:
                        asdf[i] +=1
                except:
                        asdf[i] = 1
        print("삭제된유닛",asdf)
        inventory.append(ii)
#계산
def cal():
        all_key = list(all_combination.keys())
        #필요한수, 캐릭명, 재료(리스트)
        result =[]
        #한 캐릭터씩 집어넣는 포문
        for key in all_key:
                #i = 완성품
                #mo = 재료들
                mo = all_combination[key][:]            
                imsi_inven = inventory[:]
                while True:
                        del_list=[]
                        #임시인벤에 있는 재료 지우고
                        for mt in mo:
                                if mt in imsi_inven:
                                        imsi_inven.remove(mt)
                                        del_list.append(mt)
                        for dl in del_list:
                                mo.remove(dl)
                
                
                        if len(mo) ==0:
                                result.append([len(mo),key,mo])
                                break
                        else:
                                if min_check(mo) ==1:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        decomposition(mo)
        #모든캐릭 조합
        result.sort()
        #루피루피 이런거 루피2로 바꾸는곳
        for i in result:
                asdf = {}
                for j in i[2]:
                        try:
                                asdf[j] +=1
                        except:
                                asdf[j] = 1
                i[2] =asdf
                
        immortal = []
        transcend = []
        restrict = []
        hidden = []
        eternal = []
        legend = []
        uniquelis = []
        for i in result:
                if '불멸' in i[1]:
                        immortal.append(i)
                elif '초월' in i[1]:
                        transcend.append(i)
                elif '히든' in i[1]:
                        hidden.append(i)
                elif '전설' in i[1]:
                        legend.append(i)
                elif '영원' in i[1]:
                        eternal.append(i)
                elif '제한' in i[1]:
                        restrict.append(i)
                elif i[1] in unique:
                        uniquelis.append(i)


        immortal.sort()
        transcend.sort()
        restrict.sort()
        eternal.sort()
        legend.sort()
        uniquelis.sort()

        nospc=0        
        num=0
        print('불멸 근접')
        for i in immortal:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=immortal[immortal.index(i)+1]
                        	print(nospc)
                else:
                        if immortal[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num +=1
                
        
        num=0
        print('초월 근접')
        for i in transcend:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=transcend[transcend.index(i)+1]
                        	print(nospc)
                else:
                        if transcend[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num+=1
        
        num=0
        print('제한 근접')
        for i in restrict:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=restrict[restrict.index(i)+1]
                        	print(nospc)
                else:
                        if restrict[num-1][0]==i[0] and i!= nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num +=1
        
        num=0
        print('히든 근접')
        for i in hidden:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=hidden[hidden.index(i)+1]
                        	print(nospc)
                else:
                        if hidden[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num +=1
        
        num=0
        print('영원 근접')
        for i in eternal:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=eternal[eternal.index(i)+1]
                        	print(nospc)
                else:
                        if eternal[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num+=1
        
        num=0
        print('전설 근접')
        for i in legend:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=legend[legend.index(i)+1]
                        	print(nospc)
                else:
                        if legend[num-1][0]==i[0] and i != nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num+=1

        num=0
        print('희귀 근접')
        for i in uniquelis:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=uniquelis[uniquelis.index(i)+1]
                        	print(nospc)
                else:
                        if uniquelis[num-1][0]==i[0] and i != nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num+=1

#######################위가 모드1 아래가 2############################################
def mod2cal():
        all_key = list(all_combination.keys())
        #필요한수, 캐릭명, 재료(리스트)
        result =[]
        #한 캐릭터씩 집어넣는 포문
        for key in all_key:
                #i = 완성품
                #mo = 재료들
                mo = all_combination[key][:]            
                imsi_inven = inventory[:]
                while True:
                        del_list=[]
                        #임시인벤에 있는 재료 지우고
                        for mt in mo:
                                if mt in imsi_inven:
                                        imsi_inven.remove(mt)
                                        del_list.append(mt)
                        for dl in del_list:
                                mo.remove(dl)
                
                
                        if len(mo) ==0:
                                result.append([len(mo),key,mo])
                                break
                        else:
                                if min_check(mo) ==1:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        decomposition(mo)
        #모든캐릭 조합
        result.sort()
        #루피루피 이런거 루피2로 바꾸는곳
        for i in result:
                asdf = {}
                for j in i[2]:
                        try:
                                asdf[j] +=1
                        except:
                                asdf[j] = 1
                i[2] =asdf
                
        immortal = []
        transcend = []
        restrict = []
        hidden = []
        eternal = []
        legend = []
        uniquelis = []
        for i in result:
                if '불멸' in i[1]:
                        immortal.append(i)
                elif '초월' in i[1]:
                        transcend.append(i)
                elif '히든' in i[1]:
                        hidden.append(i)
                elif '전설' in i[1]:
                        legend.append(i)
                elif '영원' in i[1]:
                        eternal.append(i)
                elif '제한' in i[1]:
                        restrict.append(i)
                elif i[1] in unique:
                        uniquelis.append(i)


        immortal.sort()
        transcend.sort()
        restrict.sort()
        eternal.sort()
        legend.sort()
        uniquelis.sort()

        nospc=0        
        num=0
        print('불멸 근접')
        for i in immortal:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=immortal[immortal.index(i)+1]
                        	print(nospc)
                else:
                        if immortal[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num +=1
                
        
        num=0
        print('초월 근접')
        for i in transcend:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=transcend[transcend.index(i)+1]
                        	print(nospc)
                else:
                        if transcend[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num+=1
        
        num=0
        print('제한 근접')
        for i in restrict:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=restrict[restrict.index(i)+1]
                        	print(nospc)
                else:
                        if restrict[num-1][0]==i[0] and i!= nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num +=1
        
        num=0
        print('히든 근접')
        for i in hidden:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=hidden[hidden.index(i)+1]
                        	print(nospc)
                else:
                        if hidden[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num +=1
        
        num=0
        print('영원 근접')
        for i in eternal:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=eternal[eternal.index(i)+1]
                        	print(nospc)
                else:
                        if eternal[num-1][0]==i[0] and i!=nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num+=1
        
        num=0
        print('전설 근접')
        for i in legend:
                if num ==0:
                        print(i)
                        if '레일리' in i[2].keys() or '해적선' in i[2].keys():
                        	nospc=legend[legend.index(i)+1]
                        	print(nospc)
                else:
                        if legend[num-1][0]==i[0] and i != nospc:
                                print(i)
                        else:
                                print()
                                print()
                                break
                num+=1

        num=0


def one_cal():
        while True:
                check_char = input("확인할 캐릭터이름\n:")
                if check_char in all_unit:
                        break
                else:
                        print("캐릭명오류")
        try:
                all_key = [check_char]
                #필요한수, 캐릭명, 재료(리스트)
                result =[]
                #한 캐릭터씩 집어넣는 포문
                for key in all_key:
                        #i = 완성품
                        #mo = 재료들
                        mo = all_combination[key][:]            
                        imsi_inven = inventory[:]
                        while True:
                                del_list=[]
                                #임시인벤에 있는 재료 지우고
                                for mt in mo:
                                        if mt in imsi_inven:
                                                imsi_inven.remove(mt)
                                                del_list.append(mt)
                                for dl in del_list:
                                        mo.remove(dl)
                        
                        
                                if len(mo) ==0:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        if min_check(mo) ==1:
                                                result.append([len(mo),key,mo])
                                                break
                                        else:
                                                decomposition(mo)
                #모든캐릭 조합
                result.sort()
                #루피루피 이런거 루피2로 바꾸는곳
                for i in result:
                        asdf = {}
                        for j in i[2]:
                                try:
                                        asdf[j] +=1
                                except:
                                        asdf[j] = 1
                        i[2] =asdf
                print("\n["+str(result[0][0])+"] 필요유닛:",result[0][2],"\n")
        except:
                print("####################오류####################")
                return 0






def nowstun():
	nowstun = 0
	acalstun=[]
	for i in inventory:
		if i in newstun:
			if i not in acalstun:
				nowstun += newstun[newstun.index(i)+1]
				acalstun.append(i)
	print("현재스턴:",nowstun,end =' ')

def nowmove():
	nowmove = 0
	acalmove = []
	for i in inventory:
		if i in move:
			if i not in acalmove:
				nowmove += move[move.index(i)+1]
				acalmove.append(i)
	print("현재이감:",nowmove,end =' ')
def nowbreak():
	nowbreak = 0
	acalbreak = []
	sabo =0
	for i in inventory:
		if i in amorbreak:
			if '사보초월' in i:
				sabo =1
			else:
				if i not in acalbreak:
					nowbreak += amorbreak[amorbreak.index(i)+1]
					acalbreak.append(i)
	print("현재방깎:",nowbreak,end='')
	if sabo ==1:
		print("+30%")
	else:
		print("")

def big_cal():
        for check_char in ('빅1','빅2','빅3','빅파','빅센'):
                all_key = [check_char]
                #필요한수, 캐릭명, 재료(리스트)
                result =[]
                #한 캐릭터씩 집어넣는 포문
                for key in all_key:
                        #i = 완성품
                        #mo = 재료들
                        mo = all_combination[key][:]            
                        imsi_inven = inventory[:]
                        while True:
                                del_list=[]
                                #임시인벤에 있는 재료 지우고
                                for mt in mo:
                                        if mt in imsi_inven:
                                                imsi_inven.remove(mt)
                                                del_list.append(mt)
                                for dl in del_list:
                                        mo.remove(dl)
                        
                        
                                if len(mo)==0:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        if min_check(mo) ==1:
                                                result.append([len(mo),key,mo])
                                                break
                                        else:
                                                decomposition(mo)
                #모든캐릭 조합
                result.sort()
                #루피루피 이런거 루피2로 바꾸는곳
                for i in result:
                        asdf = {}
                        for j in i[2]:
                                try:
                                        asdf[j] +=1
                                except:
                                        asdf[j] = 1
                        i[2] =asdf
                print(all_combination[check_char],end='')
                print("\n["+str(result[0][0])+"] 필요유닛:",result[0][2],"\n")
def choice_cal():
        all_key = list(all_combination.keys())
        #필요한수, 캐릭명, 재료(리스트)
        result =[]
        #한 캐릭터씩 집어넣는 포문
        for key in all_key:
                #i = 완성품
                #mo = 재료들
                mo = all_combination[key][:]            
                imsi_inven = inventory[:]
                while True:
                        del_list=[]
                        #임시인벤에 있는 재료 지우고
                        for mt in mo:
                                if mt in imsi_inven:
                                        imsi_inven.remove(mt)
                                        del_list.append(mt)
                        for dl in del_list:
                                mo.remove(dl)
                
                
                        if len(mo) ==0:
                                result.append([len(mo),key,mo])
                                break
                        else:
                                if min_check(mo) ==1:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        decomposition(mo)
        #모든캐릭 조합
        result.sort()
        #루피루피 이런거 루피2로 바꾸는곳
        for i in result:
                asdf = {}
                for j in i[2]:
                        try:
                                asdf[j] +=1
                        except:
                                asdf[j] = 1
                i[2] =asdf
                
        immortal = []
        transcend = []
        restrict = []
        hidden = []
        eternal = []
        legend = []

        for i in result:
                if '불멸' in i[1]:
                        immortal.append(i)
                elif '초월' in i[1]:
                        transcend.append(i)
                elif '히든' in i[1]:
                        hidden.append(i)
                elif '전설' in i[1]:
                        legend.append(i)
                elif '영원' in i[1]:
                        eternal.append(i)
                elif '제한' in i[1]:
                        restrict.append(i)

        immortal.sort()
        transcend.sort()
        restrict.sort()
        eternal.sort()
        legend.sort()
        hidden.sort()
        while True:
                see = input('불멸/초월/제한/영원/히든/전설/히든/희귀\n스턴/이감/공속/물리딜러/물리보조/방깎/마젠/마법딜러/마법보조/마방깎\n:')
                if see =='불멸'or see =='초월'or see =='제한'or see =='영원'or see =='전설' or see=='히든' or see=='스턴' or see=='마법스턴' or see=='공속' or see=='물리딜러' or see=='물리보조' or see=='방깎' or see=='마젠' or see =='마법딜러' or see=='마법보조' or see=='마방깎' or see=='이감' or see=='희귀':
                        break
        if see =='불멸':
                for i in immortal:
                        print(i)

        elif see=='초월':
                for i in transcend:
                        print(i)
        elif see=='제한':
                for i in restrict:
                        print(i)
        
        elif see=='영원':
                for i in eternal:
                        print(i)
        
        elif see=='전설':
                for i in legend:
                        print(i)
        elif see=='히든':
                for i in hidden:
                        print(i)
        
#여기부
        elif see=='스턴':
                for i in result:
                        if i[1] in newstun:
                                print("["+str(i[0])+"]"+str(i[1])+"("+str(newstun[newstun.index(i[1])+1])+"스턴)"+str(i[2:]))
        
        elif see=='마법스턴':
                for i in result:
                        if i[1] in stun_ap:
                                print(i)
        
        elif see=='공속':
                for i in result:
                        if i[1] in atack_speed:
                                print(i)
                        
        
        elif see=='물리딜러':
                for i in result:
                        if i[1] in ad_deal:
                                print(i)
                        
        
        elif see=='물리보조':
                for i in result:
                        if i[1] in ad_sub:
                                print(i)
                        
        
        elif see=='방깎':
                for i in result:
                        if i[1] in amorbreak:
                                print("["+str(i[0])+"]"+str(i[1])+"("+str(amorbreak[amorbreak.index(i[1])+1])+"깎)"+str(i[2:]))
        
        elif see=='마젠':
                for i in result:
                        if i[1] in mana:
                                print(i)
        
        elif see=='마법딜러':
                for i in result:
                        if i[1] in ap_deal:
                                print(i)
        
        elif see=='마법보조':
                for i in result:
                        if i[1] in ap_sub:
                                print(i)
        
        elif see=='마방깎':
                for i in result:
                        if i[1] in apbreak:
                                print(i)

        elif see=='이감':
                for i in result:
                        if i[1] in move:
                                print("["+str(i[0])+"]"+str(i[1])+"("+str(move[move.index(i[1])+1])+"감소)"+str(i[2:]))

        elif see=='희귀':
                for i in result:
                        if i[1] in unique:
                                print(i)
        
def print_inven():
        global inventory
        contents = {}
        for i in inventory:
                try:
                        contents[i]+=1
                except:
                        contents[i]=1
        contekey = list(contents.keys())
        check = 0
        for i in range(len(unit_a)):
            if unit_a[i] in contekey:
                if check ==0:
                    print('#흔함#')
                    check =1
                print(unit_a[i]+':' +str(contents[unit_a[i]]), end=' ')
            else:
                if check ==0:
                    print('#흔함#')
                    check = 1
                print(unit_a[i]+':0', end =' ')
        if check ==1:
            print()
            print()

        check =0
        for i in range(len(unit_b)):
            if unit_b[i] in contekey:
                if check ==0:
                    print('#안흔함#')
                    check =1
                print(unit_b[i]+':' +str(contents[unit_b[i]]), end=' ')
        if check ==1:
            print()
            print()

        check = 0
        for i in range(len(unit_c)):
            if unit_c[i] in contekey:
                if check ==0:
                    print('#특별함#')
                    check = 1
                print(unit_c[i]+':' +str(contents[unit_c[i]]), end=' ')
        if check ==1:
            print()
            print()

        check = 0
        for i in range(len(unique)):
            if unique[i] in contekey:
                if check ==0:
                    print('#희귀함#')
                    check =1
                print(unique[i]+':' +str(contents[unique[i]]), end=' ')
        if check ==1:
            print()
            print()


        check = 0
        for i in range(len(unit_d)):
            if unit_d[i] in contekey:
                if check ==0:
                    print('#전설#')
                    check = 1
                print(unit_d[i]+':' +str(contents[unit_d[i]]), end=' ')
        if check ==1:
            print()
            print()


        check = 0
        for i in range(len(unit_e)):
            if unit_e[i] in contekey:
                if check ==0:
                    print('#히든#')
                    check = 1
                print(unit_e[i]+':' +str(contents[unit_e[i]]), end=' ')
        if check ==1:
            print()
            print()


        check = 0
        for i in range(len(unit_f)):
            if unit_f[i] in contekey:
                if check ==0:
                    print('#초불영제#')
                    check = 1
                print(unit_f[i]+':' +str(contents[unit_f[i]]), end=' ')
        if check ==1:
            print()
            print()

def uniqueprin():
        all_key = list(all_combination.keys())
        #필요한수, 캐릭명, 재료(리스트)
        result =[]
        #한 캐릭터씩 집어넣는 포문
        for key in all_key:
                #i = 완성품
                #mo = 재료들
                mo = all_combination[key][:]            
                imsi_inven = inventory[:]
                while True:
                        del_list=[]
                        #임시인벤에 있는 재료 지우고
                        for mt in mo:
                                if mt in imsi_inven:
                                        imsi_inven.remove(mt)
                                        del_list.append(mt)
                        for dl in del_list:
                                mo.remove(dl)
                
                
                        if len(mo) ==0:
                                result.append([len(mo),key,mo])
                                break
                        else:
                                if min_check(mo) ==1:
                                        result.append([len(mo),key,mo])
                                        break
                                else:
                                        decomposition(mo)
        #모든캐릭 조합
        result.sort()
        #루피루피 이런거 루피2로 바꾸는곳
        for i in result:
                asdf = {}
                for j in i[2]:
                        try:
                                asdf[j] +=1
                        except:
                                asdf[j] = 1
                i[2] =asdf

        see='ㅎ'
        if see=='ㅎ':
                for i in result:
                        if i[1] in unique:
                                print(i)
def main():
        global inventory
        global logtimes
        print(" ________________________________________________________")
        choice = input("|1.인벤추가, 2.필요유닛검색, 3.근접조합 찾기, 찾-이름찾기|\n|4.만들기, 5.인벤토리 출력  *사용법은 \'도움말\'입력       |\n --------------------------------------------------------\n:")
        if choice =='1':
                add_inven()
        elif choice =='2':
                one_cal()
        elif choice=='3':
                cal()
        elif choice =='4':
                makechar()

        elif choice =='5':
                print_inven()
        elif choice =='인벤초기화':
                print("인벤토리 초기화됨")
                inventory =['변화기회','변화기회']
        elif choice =='삭제':
                '''
                while True:
                        del_unit = input('삭제할 유닛\n: ')
                        if del_unit in all_unit:
                                break
                if del_unit in inventory:
                        dc = inventory.count(del_unit)
                        for i in range(dc):
                                inventory.remove(del_unit)
                else:
                        print('인벤에 없는 유닛임')
                '''
                del_inven()
        elif choice =='영역':
                choice_cal()
        elif choice =='보유':
                sell_check()
        elif choice =='빅':
                big_cal()
        elif choice =='ㅂ' or choice =='q':
                original_combination =input('캐릭명입력:')
                try:
		                print(all_combination[original_combination])
		                print()
                except:
		                print('#########조합식이 있는 입력이 필요합니다#########')
        elif choice =='찾':
        		find_name()
        elif choice =='도움말':
        		print(how_to_use)
        elif choice =='도움말히든':
        		print(hidden_use)
        elif choice =='개인입력':
        		if logtimes>=40:
        			insert_user_combination()
        		else:
        			print("너는 아직 준비가 안됐다...(특정조건 클리어시 사용가능)")
        elif choice =='개인조합':
        		print_user_combination()
        elif choice =='개인삭제':
        		del_personal_combination()
        elif choice =='ㅎ' or choice =='g':
        		uniqueprin()
        elif choice =='ㄱ'or choice =='r':
        		mod2cal()

        else:
                pass
'''
def mklogt():
        global inventory
        global logtimes
        choice = '4'
        if choice =='1':
                add_inven()
        elif choice =='2':
                one_cal()
        elif choice=='3':
                cal()
        elif choice =='4':
                urt1f=open('C:/ordhelper/tocken3/AtoZ/1/urt1.txt','r')
                urt2f=open('C:/ordhelper/tocken3/AtoZ/1/urt2.txt','w')
                allrt1 = urt1f.read()
                urt2f.write(allrt1)
                urt1f.close()
                urt2f.close()
                urindex = 0
                urt1f=open('C:/ordhelper/tocken3/AtoZ/1/urt1.txt','w')
                urt2f=open('C:/ordhelper/tocken3/AtoZ/1/urt2.txt','r')
                hnlf=open('C:/ordhelper/__pycache__/hnl.txt','r')
                hnline = hnlf.readline()
                hnlf.close()
                while True:
                    line = urt2f.readline()
                    if not line:
                        break
                    if str(urindex) != hnline:
                        urt1f.write(line)
                    else:
                        urt1num = str(int(line[6:-1])+1)
                        urt1f.write(line[:6])
                        urt1f.write(urt1num)
                        urt1f.write('\n')
                        logtimes = int(urt1num)
                    urindex+=1
                urt1f.close()
                urt2f.close()
'''

def temp(unit,ty):
    if ty==1:
        global less
        less=[]

    a=all_combination[unit][:]
    for i in a:
        if i not in inventory:
            if i not in min_unit:
                temp(i,0)
            else:
                less.append(i)
    if ty==1:
        print(less)

#################################################################함수 공간###############################################################
#mklogt()
hiddenmessage = 0
while True:
        main()
        '''
        if logtimes >=20 and hiddenmessage <100 and hiddenmessage%3 ==1 and logtimes <70:
        	hiddenmessage+=1
        	print("###################\'도움말히든\'을 입력해보세요!###############")
        '''
        print("#made by yanoos#",end=' ')
        nowstun()
        nowmove()
        nowbreak()