# Example Inv Script

brew_menu:
    type: inventory
    inventory: CHEST
    title: Advanced Brewing
    size: 27
    slots:
    - "[<item[brew_null]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_ingredient]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_null]>]"
    - "[<item[brew_null]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_fuellevel]>] [<item[brew_valve]>] [<item[brew_fuelslot]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_null]>]"
    - "[<item[brew_step]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_pot]>] [<item[brew_pot]>] [<item[brew_pot]>] [<item[brew_null]>] [<item[brew_null]>] [<item[brew_null]>]"

brew_fuellevel:
    type: item
    material: COAL_BLOCK
    display name: Fuel Level
    lore:
    - "Fuel Level: ERROR"

brew_null:
    type: item
    material: GRAY_STAINED_GLASS_PANE
    display name: 'null'

brew_fuelslot:
    type: item
    material: COAL
    display name: Input Blaze Powder, 1 powder = 2 distill

brew_pot:
    type: item
    material: GLASS_BOTTLE
    display name: Put filled potion bottles here
    lore:
    - "Once removed they cannot be distilled further"

brew_valve:
    type: item
    material: LEVER
    display name: Click here to distill ingredient

brew_ingredient:
    type: item
    material: EGG
    display name: Ingredients

brew_step:
    type: item
    material: BLAZE_POWDER
    display name: Brewing Step
    lore:
    - "Next Step: ERROR"



brew_handler:
    type: world
    events:
        on player opens brew_menu:
        - flag <player> brew_step:0
        - flag <player> brew_fuel:0
        - flag <player> brew_dur:1
        - flag <player> brew_str:1
        - flag <player> brew_side:0
        - flag <player> brew_state:0
        - flag <player> brew_pure:0
        - flag <player> brew_inversion:true
        - flag <player> brew_type:POTION
        - wait 1t
                            # 0 for norm, 1 for splash, 2 for linger
        - inventory adjust d:<context.inventory> slot:19 "lore:Next Step: <proc[brew_getStep].context[<player.flag[brew_step]>]>"
        - inventory adjust d:<context.inventory> slot:13 "lore:Fuel Level: <player.flag[brew_fuel]>"
        on player clicks brew_fuellevel in brew_menu:
        - determine cancelled
        on player left clicks brew_ingredient in brew_menu:
        - if <context.cursor_item> == <item[air]>:
            - determine cancelled
        - take slot:<context.slot> from:<context.inventory>
        on player left clicks brew_fuelslot in brew_menu:
        - if <context.cursor_item> == <item[blaze_powder]>:
            - take slot:<context.slot> from:<context.inventory>
            - wait 1t
            - inventory set d:<context.inventory> o:<context.cursor_item> slot:<context.slot>
        - else:
            - determine cancelled
        on player right clicks brew_fuelslot in brew_menu:
        - determine cancelled
        - if <context.cursor_item> == <item[blaze_powder]>:
            - take slot:<context.slot> from:<context.inventory>
            - wait 1t
            - inventory set d:<context.inventory> o:<context.cursor_item.with[quantity=1]> slot:<context.slot>
            - wait 1t
            - determine cancelled
        on player clicks brew_valve in brew_menu:
        - determine passively cancelled
        - if <context.inventory.slot[15]> == <item[blaze_powder]>:
            - flag <player> brew_fuel:+:2
            - wait 1t
            - if <context.inventory.slot[15].quantity.sub[1]> != 0:
                - inventory set d:<context.inventory> o:<context.inventory.slot[15].with[quantity=<context.inventory.slot[15].quantity.sub[1]>]> slot:15
            - else:
                - inventory set d:<context.inventory> o:<item[brew_fuelslot]> slot:15
            - inventory adjust d:<context.inventory> slot:13 "lore:Fuel Level: <player.flag[brew_fuel]>"
        - if <player.flag[brew_fuel]> > 0:
            - choose <player.flag[brew_step]>:
                - case 0:
                    - if <context.inventory.slot[5]> == <item[nether_wart]>:
                        - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                        - flag <player> brew_step:1
                        - wait 1t
                        - inventory adjust d:<context.inventory> slot:19 "lore:Next Step: <proc[brew_getStep].context[<player.flag[brew_step]>]>"
                        - foreach <list[22|23|24]>:
                            - if <context.inventory.slot[<[value]>].material.name> == potion:
                                - inventory adjust d:<context.inventory> slot:<[value]> "potion_effects:AWKWARD,false,false"
                    - else:
                        - stop
                - case 1:
                    - define catalyst:<proc[brew_getEffect_flag].context[<context.inventory.slot[5]>]>
                    - if <[catalyst]> == NULL:
                        - stop
                    - else:
                        - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                        - flag <player> brew_step:2
                        - wait 1t
                        - inventory adjust d:<context.inventory> slot:19 "lore:Next Step: <proc[brew_getStep].context[<player.flag[brew_step]>]>"
                        - foreach <list[22|23|24]>:
                            - if <context.inventory.slot[<[value]>].material.name> == potion:
                                - inventory adjust d:<context.inventory> slot:<[value]> "potion_effects:THICK,false,false"
                        - flag <player> brew_effect:<[catalyst]>
                - case 2:
                    - define effect:<proc[brew_getMod].context[<context.inventory.slot[5].material.name>]>
                    - choose <[effect]>:
                        - case CORRUPT:
                            - define tempEff:<player.flag[brew_effect]>
                            - if <player.flag[brew_inversion]>:
                                - flag <player> brew_effect:<proc[brew_getInv].context[<player>]>
                                - if <player.flag[brew_effect]> != NULL:
                                    - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                    - flag <player> brew_inversion:false
                                    - flag <player> brew_side:+:20
                                - else:
                                    - flag <player> brew_effect:<[tempEff]>
                        - case PURIFY:
                            - if <player.flag[brew_pure]> < 4:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - flag <player> brew_pure:+:1
                                - flag <player> brew_side:-:10
                        - case DUR:
                            - if <player.flag[brew_effect]> != HEAL && <player.flag[brew_effect]> != HARM:
                                - if <player.flag[brew_dur]> < 5:
                                    - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                    - flag <player> brew_dur:+:1
                                    - flag <player> brew_side:+:10
                        - case AMP:
                            - if <player.flag[brew_str]> < 5:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - flag <player> brew_str:+:1
                                - flag <player> brew_side:+:15
                        - case SPLASH:
                            - if <player.flag[brew_type]> == POTION:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - flag <player> brew_type:SPLASH_POTION
                                - flag <player> brew_side:+:5
                        - case LINGER:
                            - if <player.flag[brew_type]> == LINGERING_POTION:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - flag <player> brew_type:LINGERING_POTION
                                - flag <player> brew_side:+:15
                        - case COMPLETE:
                            - flag <player> brew_step:0
                            - inventory adjust d:<context.inventory> slot:19 "lore:Next Step: <proc[brew_getStep].context[<player.flag[brew_step]>]>"
                            - if <player.flag[brew_side]> > <util.random.int[1].to[100]>:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - if <player.flag[brew_state]> == 1:
                                    - define secondary1:<proc[brew_getSideNeg]>
                                    - define secondary2:<proc[brew_getSideNeg]>
                                    - define secondary3:<proc[brew_getSideNeg]>
                                - else:
                                    - define secondary1:<proc[brew_getSidePos]>
                                    - define secondary2:<proc[brew_getSidePos]>
                                    - define secondary3:<proc[brew_getSidePos]>
                                - if <context.inventory.slot[22].material.name> == potion:
                                    - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,true,true,<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>|<player.flag[brew_effect]>,<player.flag[brew_str]>,<proc[brew_getDur].context[<player>],true,true>|<[secondary1]>,<player.flag[brew_str].add[1].div_int[2]>,<proc[brew_getSecDur].context[<player>|<[secondary1]>,true,true]>]> slot:22
                                - if <context.inventory.slot[23].material.name> == potion:
                                    - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,true,true,<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>|<player.flag[brew_effect]>,<player.flag[brew_str]>,<proc[brew_getDur].context[<player>],true,true>|<[secondary2]>,<player.flag[brew_str].add[1].div_int[2]>,<proc[brew_getSecDur].context[<player>|<[secondary2]>,true,true]>]> slot:22
                                - if <context.inventory.slot[24].material.name> == potion:
                                    - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,true,true,<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>|<player.flag[brew_effect]>,<player.flag[brew_str]>,<proc[brew_getDur].context[<player>],true,true>|<[secondary3]>,<player.flag[brew_str].add[1].div_int[2]>,<proc[brew_getSecDur].context[<player>|<[secondary3]>,true,true]>]> slot:22
                            - else:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - if <context.inventory.slot[22].material.name> == potion:
                                    - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,true,true,<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>|<player.flag[brew_effect]>,<player.flag[brew_str]>,<proc[brew_getDur].context[<player>],true,true>]> slot:22
                                - if <context.inventory.slot[22].material.name> == potion:
                                    - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,true,true,<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>|<player.flag[brew_effect]>,<player.flag[brew_str]>,<proc[brew_getDur].context[<player>],true,true>]> slot:23
                                - if <context.inventory.slot[22].material.name> == potion:
                                    - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,true,true,<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>&comma<util.random.int[0].to[255]>|<player.flag[brew_effect]>,<player.flag[brew_str]>,<proc[brew_getDur].context[<player>],true,true>]> slot:24
                        - default:
                            - stop
            - flag <player> brew_fuel:-:1
            - inventory adjust d:<context.inventory> slot:13 "lore:Fuel Level: <player.flag[brew_fuel]>"
        on player clicks brew_null in brew_menu:
        - determine cancelled
        on player clicks brew_step in brew_menu:
        - determine cancelled
        on player clicks in brew_menu with air priority:50:
        - if <context.clicked_inventory> == <context.inventory>:
            - if <context.item> != <item[brew_pot]> && <context.item> != <item[brew_null]> && <context.item> != <item[brew_valve]> && <context.item> != <item[brew_step]> && <context.item> != <item[brew_fuelslot]> && <context.item> != <item[brew_fuellevel]>:
                - if <context.slot> == 22 || <context.slot> == 23 || <context.slot> == 24:
                    - if <player.flag[brew_step]> != 0:
                        - determine cancelled
                - wait 1t
                - choose <context.slot>:
                    - case 5:
                        - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                    - case 15:
                        - inventory set d:<context.inventory> o:<item[brew_fuelslot]> slot:15
                    - case 22:
                        - inventory set d:<context.inventory> o:<item[brew_pot]> slot:22
                    - case 23:
                        - inventory set d:<context.inventory> o:<item[brew_pot]> slot:23
                    - case 24:
                        - inventory set d:<context.inventory> o:<item[brew_pot]> slot:24
                    - default:
                        - narrate <context.slot>
            - else:
                - determine cancelled
        on player drags in brew_menu priority:100:
        - determine cancelled
        on player clicks brew_pot in brew_menu:
        - if <context.cursor_item> == <item[potion].with[potion_effects=Water,false,false]>:
            - take slot:<context.slot> from:<context.inventory>
            - wait 1t
            - inventory set d:<context.inventory> o:<context.cursor_item.with[quantity=1]> slot:<context.slot>
            - wait 1t
            - determine cancelled
        - else:
            - narrate "Please insert water bottles"
            - determine cancelled
        on player closes brew_menu:
        - flag <player> brew_fuel:!
        - flag <player> brew_pure:!
        - flag <player> brew_inversion:!
        - flag <player> brew_type:!
        - flag <player> brew_step:!
        - flag <player> brew_dur:!
        - flag <player> brew_str:!
        - flag <player> brew_side:!
        - flag <player> brew_state:!
        - flag <player> brew_effect:!
        - foreach <list[5|15|22|23|24]>:
            - if <context.inventory.slot[<[value]>]> != <item[brew_ingredient]> && <context.inventory.slot[<[value]>]> != <item[brew_pot]> && <context.inventory.slot[<[value]>]> != <item[brew_fuelslot]>:
                - give <context.inventory.slot[<[value]>]>

brew_open:
    type: world
    events:
        on player right clicks brewing_stand:
        - determine passively cancelled
        - inventory open d:<inventory[brew_menu]>

brew_getStep:
    type: procedure
    definitions: stepNum
    script:
    - choose <[stepNum]>:
        - case 0:
            - determine "Place water bottles and distill nether wart"
        - case 1:
            - determine "Determine primary type with catalyst"
        - case 2:
            - determine "Add extra effects or complete with nether wart"

brew_getSideNeg:
    type: procedure
    script:
    - random:
        - determine SLOW
        - determine SLOW_DIGGING
        - determine HARM
        - determine BLINDNESS
        - determine HUNGER
        - determine WEAKNESS
        - determine POISON
        - determine WITHER
        - determine UNLUCK

brew_getSidePos:
    type: procedure
    script:
    - random:
        - determine SPEED
        - determine INCREASE_DAMAGE
        - determine JUMP
        - determine REGENERATION
        - determine DAMAGE_RESISTANCE
        - determine INVISIBILITY
        - determine HEALTH_BOOST
        - determine ABSORPTION



                # CALL THIS ONLY ONCE, USED TO GET EFFECT AND SET A BIT OF THE INITIAL SIDE MODIFIERS
brew_getEffect_flag:
    type: procedure
    definitions: ingredient|brewer
    script:
    - choose <[ingredient].material.name>:
        - case sugar:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:10
            - determine SPEED
        - case rabbit_foot:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:10
            - determine JUMP
        - case glistering_melon_slice:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:20
            - determine HEAL
        - case spider_eye:
            - flag <[brewer]> brew_state:2
            - flag <[brewer]> brew_side:+:15
            - determine POISON
        - case pufferfish:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:20
            - determine WATER_BREATHING
        - case magma_cream:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:35
            - determine FIRE_RESISTANCE
        - case golden_carrot:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:20
            - determine NIGHT_VISION
        - case blaze_powder:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:35
            - determine INCREASE_DAMAGE
        - case ghast_tear:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:20
            - determine REGENERATION
        - case turtle_shell:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:70
            - determine DAMAGE_RESISTANCE
        - case phantom_membrane:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:5
            - determine SLOW_FALLING
        - case heart_of_the_sea:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:25
            - determine CONDUIT_POWER
        - case feather:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:40
            - determine FAST_DIGGING
        - case emerald:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:50
            - determine ABSORPTION
        - case diamond:
            - flag <[brewer]> brew_state:1
            - flag <[brewer]> brew_side:+:50
            - determine HEALTH_BOOST
        - default:
            - determine NULL

brew_getDur:
    type: procedure
    definitions: brewer
    script:
    - if <[brewer].flag[brew_effect]> != HEAL && <[brewer].flag[brew_effect]> != HARM:
        - determine <[brewer].flag[brew_dur].mul[30].add[30]>
    - else:
        - determine 1

brew_getSecDur:
    type: procedure
    definitions: brewer|effect
    script:
    - if <[effect]> != HEAL && <[effect]> != HARM:
        - determine <[brewer].flag[brew_dur].mul[10].add[30]>
    - else:
        - determine 1

brew_getMod:
    type: procedure
    definitions: ingredient
    script:
    - choose <[ingredient]>:
        - case fermented_spider_eye:
            - determine CORRUPT
        - case redstone_dust:
            - determine DUR
        - case glowstone_dust:
            - determine AMP
        - case gunpowder:
            - determine SPLASH
        - case dragon_breath:
            - determine LINGER
        - case nether_wart:
            - determine COMPLETE
        - case milk_bucket:
            - determine PURIFY
        - default:
            - determine NULL

brew_getInv:
    type: procedure
    definitions: brewer
    script:
    - choose <[brewer].flag[brew_effect]>:
        - case SPEED:
            - flag <[brewer]> brew_state:2
            - determine SLOW
        - case JUMP:
            - flag <[brewer]> brew_state:2
            - determine SLOW
        - case HEAL:
            - flag <[brewer]> brew_state:2
            - determine HARM
        - case POISON:
            - flag <[brewer]> brew_state:2
            - determine WITHER
        - case NIGHT_VISION:
            - flag <[brewer]> brew_state:1
            - determine INVISIBILITY
        - case INCREASE_DAMAGE:
            - flag <[brewer]> brew_state:2
            - determine WEAKNESS
        - case REGENERATION:
            - flag <[brewer]> brew_state:2
            - determine WEAKNESS
        - case HEALTH_BOOST:
            - flag <[brewer]> brew_state:2
            - determine BLINDNESS
        - case ABSORPTION:
            - flag <[brewer]> brew_state:1
            - determine LUCK
        - default:
            - determine NULL