## 엔더리치 제단 관련 컨텐츠
##


endlich_infusion_world_event:
    type: world
    debug: false
    events:
        on player clicks beacon with endlich_item_infusion_wand:
        - determine passively cancelled
        - run endlich_infusion_stage def:<context.location>|<player> instantly

        ## 엔티티 flag test event(pickup prevent)

endlich_infusion_stage:
    type: task
    debug: false
    definitions: location|player
    script:

    ## 시간체크 나중에 삭제
    - define currenttime <server.current_time_millis>
    ## 중심핵이 맞는가?
    - ~run endlich_altar_exist_check def:<def[location]> instantly
    - if <player.flag[endlich_altar_exist_check]||false> != true {
        - narrate "<&3>중심핵에 오류가 있습니다. 다시 설치해 보시십시오."
        - queue clear }
    - if <yaml[endlich].read[altar.<def[location].simple>.status]> == initial {
        - narrate "<&c>제단이 아직 적절하게 설치되지 않았습니다. 연금술 완드로 제단을 설치하십시오."
        - queue clear }

    # 기본조건 체크
    ## 대기시간 
    - if <player.has_flag[endlich_infusion_cooldown]> {
        - actionbar "<&b>잠시 기다리십시오. <player.flag[endlich_infusion_cooldown].expiration.formatted||0>"
        - queue clear }
    - flag player endlich_infusion_cooldown d:1s
    ## 내 완드 맞나?
    - if <player.item_in_hand.lore.find_partial[<player.name>]> == -1 {
        - actionbar "<&6>당신의 완드가 아닙니다..."
        - playsound <player.location> volume:1 pitch:1 sound:ENTITY_VILLAGER_NO
        - playeffect <player.location.add[0,1,0]> effect:VILLAGER_ANGRY qty:1 offset:0
        - queue clear }
    ## 워프 최소조건?
    - if <def[player].flag[endlich_warp]> < 40 {
        - actionbar "<&6>아무 일도 일어나지 않았습니다..."
        - playsound <player.location> volume:1 pitch:1 sound:ENTITY_VILLAGER_NO
        - playeffect <player.location.add[0,1,0]> effect:VILLAGER_ANGRY qty:1 offset:0
        - queue clear }

    ## 각종 양식 체크해서 넘겨받아야 함(player flag형태로 받음)
        ## 제단 사용(양식을 준수했는가?) 가능 불가능 <player.flag[endlich_infusion_possibility]>
        ## 인퓨전 단계 <player.flag[endlich_infusion_level]> -> 인퓨전 레벨
        ## 안정성 <player.flag[endlich_infusion_stability]> -> 인퓨전 성공 확률
    - ~run endlich_altar_check_basic def:<def[location]> instantly
    ## 제단 양식에 문제가 있는가?
    - if <player.flag[endlich_infusion_possibility]> == false {
        - narrate "<&c>제단에 문제가 있습니다. 연금술 완드로 제단을 다시 설치해야 합니다."
        - yaml id:endlich set altar.<def[location].simple.escaped>.status:initial
        - queue clear
    }
    ## 인퓨전 레벨 체크
    - ~run endlich_altar_check_level def:<def[location]> instantly
    ## 안정성 체크
    - ~run endlich_altar_check_stability def:<def[location]> instantly

    #- narrate "<&6>인퓨전 가능여부 : <&b><player.flag[endlich_infusion_possibility]>"
    #- narrate "<&6>인퓨전 레벨 : <&b><player.flag[endlich_infusion_level]>"
    #- narrate "<&6>인퓨전 안정성 : <&b><player.flag[endlich_infusion_stability]>"

    # 인퓨전 시작 스테이지
    - ~run endlich_infusion_start def:<def[location]> instantly

    ## 인퓨전 종료
    - flag player endlich_infusion_possibility:!
    - flag player endlich_infusion_level:!
    - flag player endlich_infusion_stability:!
    - flag player endlich_altar_exist_check:!

    ## 시간체크 나중에 삭제.
    - define timespent <server.current_time_millis.sub[<def[currenttime]>]>
    - narrate "<&b>spent-time-tick:<&c><def[timespent].round_to[5]>"


endlich_infusion_start:
    type: task
    definitions: location
    script:
    # get ingredient entities
    - define entities li@
    - define altar_anvil li@<def[location].add[4,-1,0]>|<def[location].add[0,-1,4]>|<def[location].add[-4,-1,0]>|<def[location].add[0,-1,-4]>
    - foreach <def[altar_anvil]> {
        - define current_entity <def[value].find.entities[dropped_item].within[2].get[1]||null>
        - define entities <def[entities].include[<def[value].find.entities[dropped_item].within[2].get[1]||null>]>
        - if <def[entities].get[<def[loop_index]>]> != null {
            - teleport <def[entities].get[<def[loop_index]>]> <def[value].center.add[0,0.5,0]> }
    }
    - define entities <def[entities].exclude[null]>

    - define main_entity li@
    - define main_entity <def[main_entity].include[<def[location].find.entities[dropped_item].within[2]>].exclude[null]>

        ## item steal prevent
    - define delay 60
    - adjust <def[entities]> pickup_delay:<def[delay]>s
    - adjust <def[main_entity]> pickup_delay:<def[delay]>s
        ## infusion duplicaion prevent

    - if <def[entities].size> == 0 {
        - actionbar "<&6>재료가 아무것도 없습니다."
        - inject endlich_infusion_stop instantly
        - queue clear }

    - narrate <def[main_entity].size>
    - if <def[main_entity].size> != 1 {
        - actionbar "<&6>주 재료가 없거나 너무 많습니다."
        - inject endlich_infusion_stop instantly
        - queue clear }
    - teleport <def[main_entity].get[1]> <def[location].center.add[0,0.5,0]>

    ## get dropped item's data(on anvil)
    ## ingredient list -> material_name(scriptname)/quantity
    ## use list.map_get -> li@name/5|name/15.map_get[name] returns a.
    - define ingredient li@
    - define ingredient_qty li@
    - foreach <def[entities]> {
        - if <def[value].item.scriptname||null> == null {
            - define ingredient <def[ingredient].include[<def[value].item.material.name>]> }
         else {
            - define ingredient <def[ingredient].include[<def[value].item.scriptname>]> }
        - define ingredient_qty <def[ingredient_qty].include[<def[value].item.quantity>]> }

    ## finding the matched infusion.
    - define recipes <yaml[endlich].list_keys[infusion]>
        ## comparing recipes one by one
    - foreach <def[recipes]> {
        - define current_recipe <def[value]>
        - define recipe_ingredient <yaml[endlich].list_keys[infusion.<def[current_recipe]>.ingredient.sub]>
        - define check <def[ingredient].contains[<def[recipe_ingredient]>]>
        #재료가 있는지 여부를 확인하고 있다면 루프 종료
        - if <def[ingredient].contains[<def[recipe_ingredient]>]> == true foreach stop }

    #매칭 재료가 없는 경우 큐 클리어.
    - if <def[check]> == false {
        - actionbar "<&c>인퓨전에 필요한 재료가 없습니다."
        - inject endlich_infusion_stop instantly
        - queue clear }

    # 주 재료 확인하기
    ## 인퓨전의 종류에 따라 달라짐
    - narrate "주 재료 확인 <def[current_recipe]> <yaml[endlich].list_keys[infusion.<def[current_recipe]>.ingredient.main]>"
    - narrate "<yaml[endlich].read[infusion.<def[current_recipe]>.ingredient.main.item]>"
    - narrate "<yaml[endlich].read[infusion.<def[current_recipe]>.ingredient.main.search]>"
    - define type <yaml[endlich].list_keys[infusion.<def[current_recipe]>.ingredient.main]>
    - narrate <def[type]>...
    #- narrate "<&c>변수확인: <&6>type <def[type]>  <def[current_recipe]>"
    - foreach <def[type]> {
        - define type <def[value]>
        - if <def[type]> == item {
            - define main_req <yaml[endlich].read[infusion.<def[current_recipe]>.ingredient.main.<def[type]>]>
            - if !<def[main_entity].get[1].item.material.name.contains[<def[main_req]>]> {
                - actionbar "<&c>인퓨전에 필요한 주 재료가 없습니다. <&b><def[main_req]><&c>가 필요합니다."
                - inject endlich_infusion_stop instantly
                - queue clear }
            }
        - if <def[type]> == search {
            - define main_req <yaml[endlich].read[infusion.<def[current_recipe]>.ingredient.main.<def[type]>]>
            - if !<def[main_entity].get[1].item.material.name.contains_any[<def[main_req]>]> {
                - actionbar "<&c>인퓨전에 필요한 주 재료의 종류가 없습니다. <&b><def[main_req]><&c>가 필요합니다."
                - inject endlich_infusion_stop instantly
                - queue clear }
        }
    }
    - inject endlich_infusion_stop instantly
    - queue clear
    # 이미 인퓨전이 되어있는 아이템인지 확인
    - foreach <def[main_entity]> {
        - if <def[value].item.lore.find_partial[Infusion]||-1> != -1 {
            - actionbar "<&c>이미 인퓨전된 장비입니다."
            - inject endlich_infusion_stop instantly
            - queue clear }
    }
    ## 재료가 있는 경우 수량체크 시작 
    ## also select target entity.
    - define target_entities li@
    - define target_quantity li@

    - foreach <def[recipe_ingredient]> {
        - define req_quantity <yaml[endlich].read[infusion.<def[current_recipe]>.ingredient.sub.<def[value]>]>
        ## 몇번쨰 리스트인지 정의
        - define order <def[ingredient].find[<def[value]>]>
        - define target_entities <def[target_entities].include[<def[entities].get[<def[order]>]>]>
        - define target_quantity <def[target_quantity].include[<def[req_quantity]>]>
        - if <def[ingredient_qty].get[<def[order]>]> != <def[req_quantity]> {
                - actionbar "<&c><def[ingredient].get[<def[order]>]><&4>의 수량이 정확하지 않습니다. <&6>요구량:<&b><def[req_quantity]> <&6>현재 수량:<&b><def[ingredient_qty].get[<def[order]>]> "
                #- narrate <def[ingredient]>,<def[order]>번째=<def[ingredient].get[<def[order]>]>
                #- narrate "<def[ingredient].get[<def[order]>]>보유량 : <def[ingredient_qty].get[<def[order]>]>"
                - inject endlich_infusion_stop instantly
                - queue clear }
    }
    ## 제단 레벨 요구치 충족 여부 확인
    - define altar_level <yaml[endlich].read[infusion.<def[current_recipe]>.info.altar_level]>
    #- narrate "altar level:<player.flag[endlich_infusion_level]>, req_level:<yaml[endlich].read[infusion.<def[current_recipe]>.info.altar_level]>"

    - define explain <yaml[endlich].read[infusion.<def[current_recipe]>.info.explain]>
    - if <player.flag[endlich_infusion_level]> < <def[altar_level]> {
        - actionbar "<&9>제단 레벨이 부족합니다. <&2><def[explain]><&9>에는 최소 <&2><def[altar_level]><&9>이 필요합니다."
        - inject endlich_infusion_stop instantly
        - queue clear }
    ## 유저의 워프 수치 충족 여부 확인
    - define warp_req <yaml[endlich].read[infusion.<def[current_recipe]>.info.warp_req]>
    - if <player.flag[endlich_warp]> < <def[warp_req]> {
        - actionbar "<&6>엔드 수치가 부족합니다. <&a><def[explain]><&6>에는 최소 <&b><def[warp_req]><&6>의 엔드 수치가 필요합니다."
        - inject endlich_infusion_stop instantly
        - queue clear }


    ## 인퓨전 중복 방지
    - foreach <def[main_entity]> {
        - if <def[value].has_flag[infusion]> {
            - actionbar "<&4>인퓨전이 이미 진행 중입니다."
            - queue clear }
    }
    - foreach <def[main_entity]> {
        - flag <def[value]> infusion:main/<def[loop_index]>/<util.date.time> d:<def[delay]>s }

    - foreach <def[target_entities]> {
        - if <def[value].has_flag[infusion]> {
            - actionbar "<&4>인퓨전이 이미 진행 중입니다."
            - queue clear }
    }
    - foreach <def[target_entities]> {
        - flag <def[value]> infusion:sub/<def[loop_index]>/<util.date.time> d:<def[delay]>s }

    ## 모든조건 통과, 인퓨전 시작.
    ###엔티티들이 활성화되어있는지 마지막으로 확인
    - if <def[target_entities].parse[is_spawned].contains[null]>
      || <def[target_entities].parse[is_spawned].contains[false]> queue clear
    - if <def[main_entity].parse[is_spawned].contains[null]>
      || <def[main_entity].parse[is_spawned].contains[false]> queue clear
        ## 버그방지(중간에 채가기 금지)
    - adjust <def[target_entities]> pickup_delay:999s
    - adjust <def[main_entity]> pickup_delay:999s

    ## 인퓨전 성공률 계산
    - define possiblity <yaml[endlich].read[infusion.<def[current_recipe]>.info.possiblity]>
    - define possiblity <def[possiblity].sub[<player.flag[endlich_infusion_stability]>]>
    ## 인퓨전 이펙트 시작
    - define entities_foreffect <def[target_entities].escaped>
    #- narrate "<def[current_recipe]>, <player.flag[endlich_infusion_level]>"
    #- ~run endlich_infusion_effect_start def:<def[entities_foreffect]>|<def[location]>|<def[altar_level]>

    - narrate "인퓨전 실패 체크 <def[possiblity]>"
    - if <util.random.int[0].to[100]> > <def[possiblity]> {
       # - narrate "인퓨전을 실패하였습니다. 실패 이벤트 실행."
        - ~run endlich_infusion_failure def:<def[location]>|<def[possiblity]>
        - inject endlich_infusion_stop instantly
        - queue clear }

    #마지막 변환, 물건 제거하기.
    - foreach <def[target_entities]> {
        - define itemname <def[value].item.scriptname||<def[value].item.material.name>>
        - define needed_quantity <def[value].item.quantity.sub[<def[target_quantity].get[<def[loop_index]>]>]>
        - adjust <def[value]> item:<def[itemname]>[quantity=<def[needed_quantity]>]
    }

    ## 결과물 이벤트 작동하고 마무리
    - define result <yaml[endlich].list_keys[infusion.<def[current_recipe]>.result]>
    ## result ->drop summon addlore getwarp 들이 등록됨
    - foreach <def[result]> {
        - if <yaml[endlich].read[infusion.<def[current_recipe]>.result.<def[value]>]> != null {
            ## drop의 경우
            - if <def[value]||null> == drop {
                - inject endlich_infusion_result_drop instantly }
            ## addlore event
            - if <def[value]||null> == addlore {
                - inject endlich_infusion_result_addlore instantly }
            ## summon event
            - if <def[value]||null> == summon {
                - inject endlich_infusion_result_summon instantly }
            ## getwarp event
            - if <def[value]||null> == getwarp {
                - run endlich_getwarp_task def:<player>|<yaml[endlich].read[infusion.<def[current_recipe]>.result.getendwarp]> instantly
            }
        }
    }

    ## 레시피 발견 이벤트
    - define random <util.random.decimal[0].to[5]>
    - flag player endlich_infusion_exp:+:<def[random]>
    - define random <util.random.decimal[<player.flag[endlich_infusion_exp]>].to[10]>
    - if <def[random]> > 9 {
        - flag player endlich_infusion_exp:!
        - playsound <player.location> volume:1 pitch:0.5 sound:ENTITY_PLAYER_LEVELUP
        - playeffect <player.location> effect:VILLAGER_HAPPY qty:5
        - narrate "<&6>인퓨전에 대한 <&b>새로운 영감<&6>이 떠올랐습니다. 잊어버리기 전에 기록해야합니다."
        - narrate "<&c>'인퓨전 연구일지'<&6>라는 제목이 붙은 <&b>쓰여진 책<&6>을 들고 제단을 클릭하십시오."
        - flag player endlich_cauldron_discover:true d:1h }

endlich_infusion_result_drop:
    type: task
    speed: 0t
    script:
    - foreach <def[main_entity]> {
        - define main_entity_location <def[value].location>
        - define itemname <def[value].item.scriptname||<def[value].item.material.name>>
        - define needed_quantity <def[value].item.quantity.sub[1]>
        - adjust <def[value]> item:<def[itemname]>[quantity=<def[needed_quantity]>] }
    - define drop <yaml[endlich].read[infusion.<def[current_recipe]>.result.drop]>
    - drop <def[drop]> <def[main_entity_location]> speed:0
    - narrate "drop: at, <&b><def[main_entity]>"
    - narrate "drop: what, <&b><def[drop]> <def[main_entity_location]>"

endlich_infusion_result_addlore:
    type: task
    speed: 0t
    script:
    - define main_entity_item <def[main_entity].get[1].item>
    - define lore <yaml[endlich].read[infusion.<def[current_recipe]>.result.addlore.title]>
    - define lore_warp_req <yaml[endlich].read[infusion.<def[current_recipe]>.result.addlore.warp_req]>
    - if <def[main_entity_item].lore||null> == null {
        - define newlore "<&6>--<&5>Endlich Infusion<&6>--|<&6><def[lore]>|<&6>Endlich req <&b><def[lore_warp_req]>"
        }
      else {
        - define newlore "<def[main_entity_item].lore>|<&6>--<&5>Endlich Infusion<&6>--|<&6><def[lore]>|<&6>end require <&b><def[lore_warp_req]>"
        }
    - adjust <def[main_entity_item]> lore:<def[newlore]> save:infusion
    - define main_entity_item <entry[infusion].result>
    - remove <def[main_entity]>
    - drop <def[main_entity_item]> <def[location].center.above> speed:0

endlich_infusion_result_summon:
    type: task
    speed: 0t
    script:
    - define summon <yaml[endlich].read[infusion.<def[current_recipe]>.result.summon]>
    - remove <def[main_entity]>
    - inject endlich_infusion_result_summon_<def[summon]>

endlich_infusion_result_summon_helloworld:
    type: task
    speed: 0t
    script: 
    - narrate helloworld<queue.list>
## 인퓨전 중단
## 실패는 인퓨전에 도입했으나 확률적으로 실패한 경우
## 중단은 인퓨전을 중단하고 엔티티 정보를 해제하는 과정.
endlich_infusion_stop:
    type: task
    definitions: sub_entity|main_entity|player
    speed: 0t
    script:
    - playsound <player.location> volume:1 pitch:1 sound:ENTITY_VILLAGER_NO
    - playeffect <player.location.add[0,1,0]> effect:VILLAGER_ANGRY qty:1 offset:0
    - adjust <def[entities]> pickup_delay:1s
    - adjust <def[main_entity]> pickup_delay:1s
    - foreach <def[main_entity]> {
        - flag <def[value]> infusion:! }
    - foreach <def[target_entities]> {
        - flag <def[value]> infusion:! }

endlich_infusion_main_item_check:
    type: task
    definitions: sub_entity|main_entity|player
    speed: 0t
    script:
    ## 맞는 장비인지 확인
    - define require <yaml[endlich].read[infusion.<def[current_recipe]>.main_require.material]>
    - if <def[main_entity].get[1].item.material.name.contains_any[<def[require]>]> {
        - narrate true }
      else { 
        - actionbar "<&c>인퓨전에 적합한 주 재료가 필요합니다."
        - playsound <player.location> volume:1 pitch:1 sound:ENTITY_VILLAGER_NO
        - playeffect <player.location.add[0,1,0]> effect:VILLAGER_ANGRY qty:1 offset:0
        - adjust <def[entities]> pickup_delay:5s
        - adjust <def[main_entity]> pickup_delay:5s
        - queue clear }
    ## 이미 인퓨전된 장비인지 확인



## 인퓨전 실패 이벤트
endlich_infusion_failure:
    type: task
    definitions: location|possiblity
    speed: 0t
    script:
    # get ingredient entities
    - define entities li@
    - define altar_anvil li@<def[location].add[4,-1,0]>|<def[location].add[0,-1,4]>|<def[location].add[-4,-1,0]>|<def[location].add[0,-1,-4]>
    - foreach <def[altar_anvil]> {
        - define entities <def[entities].include[<def[value].find.entities[dropped_item].within[2].get[1]||null>]> }
    - define entities <def[entities].exclude[null]>
    - define main_entity li@
    - define main_entity <def[main_entity].include[<def[location].find.entities[dropped_item].within[2].get[1]>].exclude[null]>

    # 부재료 랜덤하게 삭제
    - foreach <def[entities]> {
        - if <def[value].item.scriptname||null> == null {
            - define itemname <def[value].item.material.name> }
         else {
            - define itemname <def[value].item.scriptname> }
        - define loss_quantity <def[value].item.quantity.sub[<util.random.int[1].to[<def[value].item.quantity>]>]>
        - adjust <def[value]> item:<def[itemname]>[quantity=<def[loss_quantity]>]
        - playsound <def[value].location> volume:1 pitch:1 sound:BLOCK_CHORUS_FLOWER_DEATH
        - playeffect <def[value].location> effect:SPELL_WITCH qty:50 data:1 offset:0
        - wait 0.3s }
    # 본재료 삭제 -> 제단 안정성에 따라.
    - if <util.random.int[1].to[100]> < <player.flag[endlich_infusion_stability]> {
        - explode power:3 <def[main_entity].location> fire
        - playsound <def[main_entity].location> volume:1 pitch:1 sound:BLOCK_CHORUS_FLOWER_DEATH
        - playeffect <def[main_entity].location> effect:SPELL_WITCH qty:50 data:1 offset:0 }

    # 랜덤폭파
    - define radius <def[location].center.find.blocks[air].within[10]>
    - define radius <def[radius].random[<util.random.int[1].to[<def[possiblity]>].round>]>
    - narrate "폭파횟수 <def[radius].size>"
    - foreach <def[radius]> {
        - wait 0.1s
        - explode power:<util.random.int[1].to[2]> <def[value]> fire }
    # 심각한 엔드워프
    - if <util.random.int[1].to[100]> < <player.flag[endlich_infusion_stability]> {
        - run endlich_getwarp_task def:<player>|high instantly }
      else {
        - run endlich_getwarp_task def:<player>|moderate instantly }


## 제단의 기본조건 체크
endlich_altar_check_basic:
    type: task
    debug: false
    definitions: location
    script:
    #상단다이아
    - if <def[location].add[0,5,0].material.name> != diamond_block {
        - flag player endlich_infusion_possibility:false
        - queue clear }
    #석탄블럭
    - define altar_base cu@<def[location].add[5,-4,5]>|<def[location].add[-5,-4,-5]>
    - if <def[altar_base].blocks[coal_block].size> < 121 {
        - flag player endlich_infusion_possibility:false
        - queue clear }
    #흑요석기반
    - define altar_corebase cu@<def[location].add[1,-1,1]>|<def[location].add[-1,-3,-1]>
    - if <def[altar_corebase].blocks[obsidian].size> < 27 {
        - flag player endlich_infusion_possibility:false
        - queue clear }
    #모루
    - define altar_anvil li@<def[location].add[4,-1,0]>|<def[location].add[0,-1,4]>|<def[location].add[-4,-1,0]>|<def[location].add[0,-1,-4]>
    - if <def[altar_anvil].parse[material.name].find_all[anvil].size> < 4 {
        - flag player endlich_infusion_possibility:false
        - queue clear }
    - flag player endlich_infusion_possibility:true

## 인퓨전 레벨 체크 - 비콘의 갯수를 센다. 최고레벨 3까지.
endlich_altar_check_level:
    type: task
    debug: false
    definitions: location
    script:
    - define altar_total cu@<def[location].add[5,7,5]>|<def[location].add[-5,-4,-5]>
    - define altar_beacon <def[altar_total].blocks[beacon].size>
    - define level <def[altar_beacon].div[2].round.min[3].round>
    - flag player endlich_infusion_level:<def[level]>

##안정성체크
endlich_altar_check_stability:
    type: task
    definitions: location
    script:
    ## 안정성 체크 - 제단 내 블럭 수 세기
    - define altar_total cu@<def[location].add[5,7,5]>|<def[location].add[-5,-4,-5]>
    - define blocks <def[altar_total].blocks.parse[material.name]>
    - define kindofblocks <def[blocks].deduplicate>
    - define blocknumber li@
    - foreach <def[kindofblocks]> {
        - define blocknumber <def[blocknumber].include[<def[value]>/<def[blocks].count[<def[value]>]>]> }
    #- narrate "<&6>block consisted"
    #- narrate "<def[blocknumber].separated_by[<n>]>"
    #- narrate "<def[blocknumber]>"

    ## 필요한 자료 추출
    - define total_size <def[blocks].size>
    - define air <def[blocks].find_all[air].size>
    - define bone_block <def[blocks].find_all[bone_block].size>
    - define beacon <def[blocks].find_all[beacon].size>
    - define dragon_egg <def[blocks].find_all[dragon_egg].size>
    - define skull <def[blocks].find_all[skull].size>
    - define obsidian <def[blocks].find_all[obsidian].size>
    - define end_bricks <def[blocks].find_all[end_bricks].size>
    - define anvil <def[blocks].find_all[anvil].size>
    - define coal_block <def[blocks].find_all[coal_block].size>

    - define gold_block <def[blocks].find_all[gold_block].size>
    - define iron_block <def[blocks].find_all[iron_block].size>
    - define emerald_block <def[blocks].find_all[emerald_block].size>
    - define diamond_block <def[blocks].find_all[diamond_block].size>
    - define metal_block <el@0.add[<def[gold_block]>].add[<def[diamond_block]>].add[<def[iron_block]>].add[<def[emerald_block]>]>
    - define obsiandend <el@0.add[<def[obsidian]>].add[<def[end_bricks]>]>

    - define essential_block <def[bone_block].add[<def[beacon]>].add[<def[dragon_egg]>].add[<def[skull]>].add[<def[obsidian]>].add[<def[end_bricks]>].add[<def[metal_block]>].add[<def[anvil]>].add[<def[coal_block]>]>
    - define deco_block <def[total_size].sub[<def[air]>].sub[<def[essential_block]>]>


    - define unstablity el@0
    #뼈(bone_block) 블럭은 금속 블럭보다 1.2배 많아야한다. 모자라면 개당 0.3%
    - define bone_unstable <def[metal_block].mul[1.2].sub[<def[bone_block]>].mul[0.3].max[0]>
    - define unstablity <def[unstablity].add[<def[bone_unstable]>]>

    #- narrate "<&c>bone unstablitiy <&2><def[bone_unstable]>"
    #금속블럭은 최소한 비콘 수 * 9 모자라면 개당 1%
    - define metal_unstable <def[beacon].mul[9].sub[<def[metal_block]>].mul[1].max[0]>
    - define unstablity <def[unstablity].add[<def[metal_unstable]>]>

    #- narrate "<&c>metal unstablitiy <&2><def[metal_unstable]>"
    #용알(dragon_egg)의 갯수는 비콘 수 -1 * 2, 없으면 5%실패
    - define egg_unstable <def[beacon].sub[1].mul[2].sub[<def[dragon_egg]>].mul[5].max[0]>
    - define unstablity <def[unstablity].add[<def[egg_unstable]>]>

    #- narrate "<&c>egg_unstable <&2><def[egg_unstable]>"
    #머리(skull)의 갯수는 용알 1개당 2개, 없으면 개당 1%실패
    - define skull_unstable <def[dragon_egg].mul[2].sub[<def[skull]>].mul[1].max[0]>
    - define unstablity <def[unstablity].add[<def[skull_unstable]>]>

    #- narrate "<&c>skull_unstable <&2><def[skull_unstable]>"
    #금 블럭 개당 - 0.1%
    - define gold_unstable <def[gold_block].mul[0.1]>
    - define unstablity <def[unstablity].add[<def[gold_unstable]>]>

    #- narrate "<&c>gold_unstable <&2><def[gold_unstable]>"
    #철 블럭 개당 - 0.15%
    - define iron_unstable <def[iron_block].mul[0.15]>
    - define unstablity <def[unstablity].add[<def[iron_unstable]>]>

    #- narrate "<&c>iron_unstable <&2><def[iron_unstable]>"
    #옵시디언 비율 30%기준 30% 미만시 1%당 1% 실패
    #엔드블럭 비율 30%기준 30% 미만시 1%당 1% 실패
    - define obsidian_unstable <def[obsidian].div[<def[obsiandend]>].sub[0.3].mul[-1].max[0]>
    - define end_unstable <def[end_bricks].div[<def[obsiandend]>].sub[0.3].mul[-1].max[0]>
    - define unstablity <def[unstablity].add[<def[obsidian_unstable]>]>
    - define unstablity <def[unstablity].add[<def[end_unstable]>]>

    #- narrate "<&c>obsidian_unstable <&2><def[obsidian_unstable]>"
    #- narrate "<&c>end_unstable <&2><def[end_unstable]>"
    #위 조건에 해당하지 않는 블럭을 제외한 기타 블럭의 수가 5% 이상 설치. 장식이 되어있어야 함. 개당 0.1%
    - define deco_unstable <def[essential_block].mul[0.05].sub[<def[deco_block]>].mul[0.1].max[0]>
    #- narrate "<&c>deco unstable <&2><def[deco_unstable]>"
    #- narrate "current to deco <def[deco_block]> deco needed <def[essential_block].mul[0.05].round_up>"

    - define unstablity <def[unstablity].add[<def[deco_unstable]>]>

    - flag player endlich_infusion_stability:<def[unstablity]>

#
#
#
# dummy remove later
enchantment_remove_test:
    type: task
    script:
    - define item <player.item_in_hand>
    - define name <player.item_in_hand.>
    - adjust <player.item_in_hand> enchantments:! save:item
    - narrate <entry[item].result.enchantments.with_levels>
    - take <player.item_in_hand>
    - give <entry[item].result>

enchantment_levelreduce_test:
    type: task
    speed: 0t
    script:
    - define list <player.item_in_hand.enchantments.get[1]>
    - narrate <def[list]>
    - adjust <player.item_in_hand> enchantments:<def[list]>,10 save:item
    - narrate <entry[item].result.enchantments.with_levels>
    - take <player.item_in_hand>
    - give <entry[item].result>