# Example Inv Script

brew_menu:
    type: inventory
    inventory: CHEST
    title: Advanced Brewing
    size: 27
    slots:
    - "[<item[brew_null]>] [<item[brew_null]>] [<item[brew_guide1]>] [<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_guide2]>] [<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_guide3]>] [<item[brew_pot]>] [<item[brew_pot]>] [<item[brew_pot]>] [<item[brew_impurity]>] [<item[brew_null]>] [<item[brew_null]>]"

brew_guide1:
    type: item
    material: PAPER
    display name: Brewing Instructions
    lore:
    - "Step 1: Put water bottles in bottle slots."
    - "Step 2: Add Blaze Powder as fuel"
    - "Step 3: Add Nether Wart as the first ingredient"
    - "Step 4: Open valve to distill Nether Wart into potion"
    - "Step 5: Add catalyst to determine primary effect (Listed at end)"
    - "Step 6: Add any modifier effects (Listed at end), Refilling fuel as needed"
    - "Step 7: Add Nether Wart at the end to finalize the process"
    - "Note: Impurity determines the likelihood for an unintended side effect"

brew_impurity:
    type: item
    material: WITHER_SKELETON_SKULL
    display name: Impurity Level
    lore:
    - "Impurity: ERROR"

brew_guide2:
    type: item
    material: PAPER
    display name: Brewing Catalysts
    lore:
    - "Catalysts: Effect/Corruption"
    - "Sugar: Speed/Slowness"
    - "Rabbit's Foot: Jump Boost/Slowness"
    - "Glistering Melon: Health/Harm"
    - "Spider Eye: Poison/Wither"
    - "Pufferfish: Water Breathing"
    - "Magma Cream: Fire Resistance"
    - "Golden Carrot: Night Vision/Invisibility"
    - "Blaze Powder: Strength/Weakness"
    - "Ghast Tear: Regeneration/Weakness"
    - "T******: Resistance"
    - "Phantom Membrane: Slow Fall"
    - "*************Sea: Conduit Power"
    - "*******: Haste"
    - "E******: Ab******/**ck"
    - "**a****: Hea******/Blindness"

brew_guide3:
    type: item
    material: PAPER
    display name: Brewing Modifiers
    lore:
    - "Modifier: Effect"
    - "Nether Wart: Complete"
    - "Redstone Dust: Duration"
    - "Glowstone Dust: Amplify"
    - "Gunpowder: Splash"
    - "***********ath: Lingering"
    - "Fe*******de****ye: Corrupt"
    - "M***: Purify"

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 distillations

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_ROD
    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:0
        - 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]>"
        - inventory adjust d:<context.inventory> slot:25 "lore:Impurity: <player.flag[brew_side]>"
        on player clicks in brew_menu priority:100:
        #Check for if the player is clicking in an invalid slot/item, should run last
        - if <context.clicked_inventory> == <context.inventory> && <list[5|14|15|22|23|24].find[<context.slot>]> == -1:
            - determine cancelled
        - else if <context.clicked_inventory> == <context.inventory>:
            - wait 1t
            - inventory set d:<context.inventory> o:<proc[brew_getBaseSlot].context[<context.slot>]> slot:<context.slot>
        - else:
            - determine cancelled
        on player left clicks brew_ingredient in brew_menu:
        - if <context.cursor_item.material.name> == air:
            - determine cancelled
        - else:
            - determine <item[air]>
            - inventory set d:<context.inventory> o:<context.cursor_item> slot:<context.slot>
        on player right clicks brew_ingredient in brew_menu:
        - if <context.cursor_item.material.name> == air:
            - determine cancelled
        - else:
            - inventory set d:<context.inventory> o:<context.cursor_item.with[quantity=1]> slot:<context.slot>
            - determine <context.cursor_item.with[quantity=<context.cursor_item.quantity.sub[1]>]>
        on player left clicks brew_fuelslot in brew_menu:
        - if <context.cursor_item.material.name> == blaze_powder:
            - inventory set d:<context.inventory> o:<context.cursor_item> slot:<context.slot>
            - determine <item[air]>
        - else:
            - narrate Please insert Blaze Powder as fuel
            - determine cancelled
        on player right clicks brew_fuelslot in brew_menu:
        - if <context.cursor_item.material.name> == blaze_powder:
            - inventory set d:<context.inventory> o:<context.cursor_item.with[quantity=1]> slot:<context.slot>
            - determine <context.cursor_item.with[quantity=<context.cursor_item.quantity.sub[1]>]>
        - else:
            - narrate Please insert Blaze Powder as fuel
            - determine cancelled
        on player clicks brew_valve in brew_menu:
        - determine passively cancelled
        - if <context.inventory.slot[15].material.name> == 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]>|<player>]>
                    - 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
                                - give <item[bucket]>
                        - 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]> < 4:
                                - 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[101].to[200]>:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - foreach <list[22|23|24]>:
                                    - if <context.inventory.slot[<[value]>].material.name> == potion:
                                        - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,false,false,<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|<proc[brew_getSide].context[<player>]>,<player.flag[brew_str].add[1].div_int[2]>,<proc[brew_getSecDur].context[<player>]>,true,true|<proc[brew_getSide].context[<player>]>,<player.flag[brew_str].div[3].add_int[1]>,<proc[brew_getSecDur].context[<player>].mul_int[2].div_int[3]>,true,true]> slot:<[value]>
                            - else if <player.flag[brew_side]> > <util.random.int[1].to[100]>:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - foreach <list[22|23|24]>:
                                    - if <context.inventory.slot[<[value]>].material.name> == potion:
                                        - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,false,false,<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|<proc[brew_getSide].context[<player>]>,<player.flag[brew_str].add[1].div_int[2]>,<proc[brew_getSecDur].context[<player>]>,true,true]> slot:<[value]>
                            - else:
                                - inventory set d:<context.inventory> o:<item[brew_ingredient]> slot:5
                                - foreach <list[22|23|24]>:
                                    - if <context.inventory.slot[<[value]>].material.name> == potion:
                                        - inventory set d:<context.inventory> o:<item[<player.flag[brew_type]>].with[potion_effects=THICK,false,false,<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:<[value]>
                            - flag <player> brew_dur:1
                            - flag <player> brew_str:0
                            - 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
                            - flag <player> brew_effect:!
                        - default:
                            - stop
            - flag <player> brew_fuel:-:1
            - inventory adjust d:<context.inventory> slot:13 "lore:Fuel Level: <player.flag[brew_fuel]>"
            - inventory adjust d:<context.inventory> slot:25 "lore:Impurity: <player.flag[brew_side]>"
        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]>:
            - inventory set d:<context.inventory> o:<context.cursor_item.with[quantity=1]> slot:<context.slot>
            - determine <item[air]>
        - 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_getSide:
    type: procedure
    definitions: brewer
    script:
    - choose <[brewer].flag[brew_state]>:
        - case 1:
            - determine <proc[brew_getSideNeg]>
        - case 2:
            - determine <proc[brew_getSidePos]>

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].mul[20]>
    - else:
        - determine 1

brew_getSecDur:
    type: procedure
    definitions: brewer
    script:
    - determine <[brewer].flag[brew_dur].mul[10].add[15].mul[20]>

brew_getMod:
    type: procedure
    definitions: ingredient
    script:
    - choose <[ingredient]>:
        - case fermented_spider_eye:
            - determine CORRUPT
        - case redstone:
            - 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

brew_getBaseSlot:
    type: procedure
    definitions: slotNum
    script:
    - choose <[slotNum]>:
        - case 5:
            - determine <item[brew_ingredient]>
        - case 15:
            - determine <item[brew_fuelslot]>
        - case 22:
            - determine <item[brew_pot]>
        - case 23:
            - determine <item[brew_pot]>
        - case 24:
            - determine <item[brew_pot]>