StorekeeperPlayerOwned:
  type: assignment
  debug: true
  
  default constants:
    server_price_requirment: true
    store open hour: 5
    store close hour: 18
    store greetings: li@Welcome to my store!|Feel free to look around!|Just give me a click if you need something!

  actions:

    # Just some setup of the triggers
    on remove:
    - flag server playerstore:<-:<npc.flag[playerstore]>
    on assignment:
    - trigger name:proximity toggle:true radius:30
    - trigger name:click toggle:true
    - trigger name:chat toggle:true
    - trigger name:damage toggle:true
    - flag npc cashregister:5
    on enter proximity:
    - foreach <npc.flag[playerstore].as_cuboid.list_entities> {
      - if !<def[value].has_framed_item> {
        - adjust %value% framed:<npc.flag[storeitems].get[<npc.flag[storeitemlocations].find[<def[value].location>]>]>
        }
      }

    - define name <player.name>
    - define keeper <player.flag[storekeepernpc]>
    - if !<def[keeper].flag[playerstore].as_cuboid.is_within[<player.location>]> && '<player.inventory.contains[i@shopping bag]>' {
      - inventory add o:in@def[name]_shopping_bag d:<def[keeper].inventory>
      - take "i@shopping bag"
      - narrate "<dark_red>No stealing items from my store!!"
      }
    - if <player> == <npc.owner> && <npc.can_see[<player>]||null> && !<player.flag[greeted]||null> {
      - narrate "<dark_purple>Hello <player.name> just ask for <green>'help' <dark_purple>if you need a command refresher for your shop"
      - flag player greeted duration:5m
      } else if !<player.flag[greeted]> && <npc.can_see[<player>]||null> {
      - if !<npc.flag[greeting]||null> == null {
        - narrate "<aqua><npc.flag[greeting].random>"
        }
        else {
        - narrate "<aqua><el@val[<npc.constant[store greetings]>].as_list.random>"
        }
      - flag player greeted duration:30s
      }
    on damage:
    - define name <player.name>
    - flag player storekeepernpc:n@<npc>
    - if <player> == <npc.owner> {
      - narrate "<dark_purple> The balance is <green><npc.flag[cashregister].as_int||null>"
      - narrate "<dark_purple>would you like to <green>'give' <dark_purple>money to your store or <green>'take' <dark_purple>money from your store?"
      } else if '!<player.inventory.contains[i@shopping bag]>' && '!<player.inventory.contains[i@selling_bag]||>' {
      - note 'in@player bag' as:<player.name>_shopping_bag
      - animate <npc> arm_swing
      - flag player storekeepernpc:<npc>
      - narrate '<aqua>Here, have a complimentary shopping bag!'
      - give <player> 'i@shopping bag'
      } else if <player.item_in_hand> == 'i@shopping bag' && <npc.owner> == server {
      - define total_price 0 
      - foreach <in@%name%_shopping_bag.list_contents> { 
        - adjust %value% quantity:1 save:item2
        - if <server.flag[<entry[item2].result.full.escaped>]||null> == null { 
          - flag server <entry[item2].result.full.escaped>:1.00 
          } 
        - adjust %value% quantity:1 save:item
        - define price <yaml[prices].read[prices.<entry[item].result.full.escaped>].mul[2].mul[<server.flag[<entry[item].result.full.escaped>]>].mul[<def[value].qty>]||null> 
        - define total_price <el@val[%total_price%].add[%price%]||null> 
        } 
      - narrate "<aqua>Ready to check out? Just click me with your bag!"
      - narrate "<aqua>your total price is <green>%total_price%"
      } else if <player.item_in_hand> == 'i@shopping bag' {
      - define total_price 0
      - define name <player.name>
      - foreach <in@%name%_shopping_bag.list_contents> { 
        - if !<npc.flag[sell_<def[value].full.escaped>].mul[<%value%.qty>]||null> == null {
          - define price <npc.flag[sell_<def[value].full.escaped>].mul[<def[value].qty>]||null>
          }
          else {
          - define price <el@val[<npc.flag[sell_<def[value].full.escaped>]>].mul[<def[value].qty>]||null>
          - define total_price <el@val[%total_price%].add[%price%]||null> 
          }
        } 
      - narrate "<aqua>Ready to check out? Just click me with your bag!"
      - narrate "<aqua>your total price is <green>%total_price%"
      } else if <player.item_in_hand> == 'i@selling_bag' && <npc.owner> == server {
      - define total_price 0
      - foreach <in@%name%_selling_bag.list_contents> { 
        - adjust %value% quantity:1 save:item
        - define price <yaml[prices].read[prices.<entry[item].result.full.escaped>].mul[<def[value].qty>]> 
        - define total_price <el@val[%total_price%].add[%price%]> 
        } 
      - narrate "<aqua>Ready to sell items? Just right click me with your bag!"
      - narrate "<aqua>your total price is <green>%total_price%"
      } else if <player.item_in_hand> == 'i@selling_bag' {
      - define total_price 0 
      - foreach <in@%name%_selling_bag.list_contents> { 
        - define price <npc.flag[buy_%value%].as_int||null> 
        - define total_price <el@val[%total_price%].add[%price%]||null> 
        } 
      - narrate "<aqua>Ready to sell items? Just right click me with your bag!"
      - narrate "<aqua>your total price is <green>%total_price%"
      }
      else {
      - flag player storekeepernpc:n@<npc>
      }
      
    on chat:
    - if <context.message> == greeting && <player> == <npc.owner> {
      - narrate "<dark_purple>Would you like to <green>add <dark_purple>or <green>remove<dark_purple> a greeting?"
      - flag player greeting
      - determine cancelled
      }
    - if <player.flag[greeting]> == true && <player> == <npc.owner> {
      - if <context.message> == add {
        - if <npc.flag[greeting].as_list.size> > 4 {
          - narrate "You cannot exceed five greetings!"
          - flag player greeting:!
          - determine cancelled
          - queue clear
          }
          else {
          - narrate "<dark_purple>Please say the greeting you would like to add to your store"
          - flag player greeting:!
          - flag player addgreeting
          - determine cancelled
          }
        }
        else if <context.message> == remove && <npc.owner> == <player> {
        - flag player greeting:!
        - flag player removegreeting
        - narrate "What line number would you like to remove?"
        - foreach <npc.flag[greeting].as_list||null> {
          - narrate "%loop_index%=%value%"
          }
        - determine cancelled
        }
      }
    - if <player.flag[removegreeting]||null> == true && <player> == <npc.owner> {
      - narrate "<npc.flag[greeting].get[<context.message>]>"
      - narrate "Has been removed"
      - flag npc greeting[<context.message>]:<-
      - flag player removegreeting:!
      - determine cancelled
      }
    - if <player.flag[addgreeting]||null> == true && <player> == <npc.owner> {
      - flag npc greeting:->:<context.message>
      - flag player addgreeting:!
      - narrate "<dark_purple>You added a new greeting to your list. Your new greeting is"
      - narrate "<green><context.message>"
      - determine cancelled
      }
    - if <context.message> == expand && <player> == <npc.owner> {
      - execute as_op "npc select <npc.id> as:<player>"
      - flag server playerstore:<-:<npc.flag[playerstore]>
      - give i@storelocationstick4
      - narrate "<dark_purple>please reselect the bottom and top corners of your cuboid then drop the selector"
      - determine cancelled
      }
    - if <context.message> == help && <player> == <npc.owner> {
      - narrate "<dark_purple>your shop commands are <green> Greeting, items, give, take, set, unset, expand."
      - narrate "<dark_purple>Click the npc with an item to set a price for it"
      - narrate "<dark_purple>Right click the npc without an item to view inventory for the store"
      - determine cancelled
      }
    - if <context.message> == items && <player> == <npc.owner> {
      - if <npc.flag[buyback]||null> == null {
        - narrate "<aqua>No items have been sold to your shop"
        }
        else {
        - give <npc.flag[buyback]>
        - flag npc buyback:!
        - determine cancelled
        }
      }
    - if <player.flag[givingtocashregister]||null> == true && <player> == <npc.owner> {
      - flag npc cashregister:+:<context.message>
      - take money qty:<context.message>
      - narrate "<dark_purple>You give <green><context.message> <dark_purple>to the cash register. The balance is now <green><npc.flag[cashregister].as_int||null>"
      - flag player givingtocashregister:!
      - determine cancelled
      }
    - if <context.message> == give && <player> == <npc.owner> {
      - flag player givingtocashregister
      - narrate "<dark_purple>How much would you like to give to the store?"
      - determine cancelled
      }
    - if <context.message> == take && <player> == <npc.owner> {
      - flag player takingfromcashregister
      - narrate "<dark_purple>How much would you like to take from the store?"
      - determine cancelled
      }
    - if <player.flag[takingfromcashregister]||null> == true && <player> == <npc.owner> {
      - if <npc.flag[cashregister]> > <context.message> {
        - flag npc cashregister:-:<context.message>
        - give money qty:<context.message>
        - narrate "<dark_purple>You take <green><context.message> <dark_purple>from the cash register. The balance is now <green><npc.flag[cashregister].as_int||null>"
        - flag player takingfromcashregister:!
        - determine cancelled
        }
        else if <npc.flag[cashregister]||null> < <context.message> {
        - narrate "<dark_red>You havnt got that much money in your cashregister!"
        }
      }
    - if <context.message> == unset && <player> == <npc.owner> {
      - flag server playerstore:<-:<npc.flag[playerstore]>
      - narrate "<dark_red>your store is now unprotected! tell the npc to 'set' the store back up when you are done editing"
      - determine cancelled
      }
    - if <context.message> == sell {
      - if <npc.owner> == server {
        - note 'in@selling bag' as:<player.name>_selling_bag
        - animate <npc> arm_swing
        - narrate '<aqua>Here is your item selling bag!'
        }
        else {
        - note 'in@player bag' as:<player.name>_selling_bag
        - animate <npc> arm_swing
        - narrate '<aqua>Here is your item selling bag!'
        - narrate "<aqua>We buy the following items that you have"
        - foreach <player.inventory.list_contents.simple> {
          - if !<npc.flag[buy_<%value%.full.escaped>]||null> == null {
            - if <%value%.display||null> == null {
              - narrate "<aqua>We buy <green><%value%.material.name||null> <aqua>for <green><npc.flag[buy_<%value%.escaped||null>]||null> coins a piece"
              }
              else {
              - narrate "<aqua>We buy <green><%value%.display||null> <aqua>for <green><npc.flag[buy_<%value%.full.escaped||null>]||null> coins a piece"
              }
            }
          }
        }
      - drop 'i@selling_bag' <npc.location.add[<npc.location.direction.vector.mul[2]||null>].add[0,1,0]||null> 
      - determine cancelled
      }
    - if <context.message> == set && <player> == <npc.owner> && !<server.flag[playerstore].as_list||null> contains <npc.flag[playerstore]||null> {
      - narrate "<&b>your store is now open for business!"
      - flag server playerstore:->:<npc.flag[playerstore]||null>
      - flag npc storeitems:!
      - foreach <npc.flag[playerstore].as_cuboid.list_entities||null> {
        - if <def[value].entity_type> == item_frame {
          - flag npc storeitems:->:<def[value].framed_item||null>
          - flag npc storeitemlocations:->:<def[value].location||null>
          }
        }
      - determine cancelled
      }
    - if <context.message> == buying && <player> == <npc.owner> {
      - if <npc.constant[server_price_requirment]> == true {
        - narrate "<dark_purple>please set a price below <green><yaml[prices].read[prices.<npc.flag[currentitem]||null>]||null> <dark_purple>for that item."
        - flag player settype:buy
        - determine cancelled
        }
        else {
        - flag player settype:buy
        - narrate "<dark_purple>please set a price for that item"
        - determine cancelled
        }
      }
    - if <context.message> == selling && <player> == <npc.owner> {
      - if <npc.constant[server_price_requirment]||false> == true {
        - narrate "<dark_purple>please set a price above <green><yaml[prices].read[prices.<npc.flag[currentitem]||null>]||null> <dark_purple>for that item."
        - flag player settype:sell
        - determine cancelled
        }
        else {
        - flag player settype:sell
        - narrate "<dark_purple>please set a price for that item"
        - determine cancelled
        }
      }
    - if !<npc.flag[currentitem]||null> == null && <player> == <npc.owner> {
      - if <player.flag[settype]||null> == buy && <npc.constant[server_price_requirment]||false> == true {
        - if <context.message> > <yaml[prices].read[prices.<npc.flag[currentitem]||null>]||null> && <context.message.is[matches].to[integer]||false> {
          - narrate "<dark_red>your price needs to be below the base price. this price will not be set for this item."
          - flag npc currentitem:!
          - flag player settype:!
          - determine cancelled
          }
          else if <context.message> < <yaml[prices].read[prices.<npc.flag[currentitem]||null>]||null> && <context.message.is[matches].to[integer]||false> {
          - flag npc <player.flag[settype]||null>_<npc.flag[currentitem]||null>:<context.message>
          - if <npc.flag[currentitem].unescaped.display||null> == null {
            - narrate "<dark_purple><npc.flag[currentitem].unescaped.material.name||null> <player.flag[settype]||null> price is now set to <green><context.message>"
            }
            else {
            - narrate "<dark_purple><npc.flag[currentitem].unescaped.display||null> <player.flag[settype]||null> price is now set to <green><context.message>"
            }
          - flag npc currentitem:!
          - flag player settype:!
          - determine cancelled
          }
          else {
          - narrate "<dark_red>That doesn not match a valid number! please set a proper number for a price"
          - determine cancelled
          }
        }
      }
    - if !<npc.flag[currentitem]||null> == null && <player> == <npc.owner> {
      - if <player.flag[settype]||null> == sell && <npc.constant[server_price_requirment]||null> == true {
        - if <context.message> < <yaml[prices].read[prices.<npc.flag[currentitem]||null>]||null> && <context.message.is[matches].to[integer]||false> {
          - narrate "<dark_red>your price needs to be above the base price. this price will not be set for this item."
          - flag npc currentitem:!
          - flag player settype:!
          - determine cancelled
          }
          else if <context.message> > <yaml[prices].read[prices.<npc.flag[currentitem]||null>]||null> && <context.message.is[matches].to[integer]||false> {
          - flag npc <player.flag[settype]||null>_<npc.flag[currentitem]||null>:<context.message>
          - if <npc.flag[currentitem].unescaped.display||null> == null {
            - narrate "<dark_purple><npc.flag[currentitem].unescaped.material.name||null> <player.flag[settype]||null> price is now set to <green><context.message>"
            }
            else {
            - narrate "<dark_purple><npc.flag[currentitem].unescaped.display||null> <player.flag[settype]||null> price is now set to <green><context.message>"
            }
          - flag npc currentitem:!
          - flag player settype:!
          - determine cancelled
          }
          else {
          - narrate "<dark_red>That doesn not match a valid number! please set a proper number for a price"
          - determine cancelled
          }
        }
      }
    - if !<npc.flag[currentitem]> == null && <player> == <npc.owner> { 
      - if !<npc.constant[server_price_requirment]||false> == true {
        - if <context.message.is[matches].to[integer]||false> {
          - flag npc <player.flag[settype]||null>_<npc.flag[currentitem]||null>:<context.message>
          - if <npc.flag[currentitem].unescaped.display||null> == null {
            - narrate "<dark_purple><npc.flag[currentitem].unescaped.material.name||null> <player.flag[settype]||null> price is now set to <green><context.message>"
            }
            else {
            - narrate "<dark_purple><npc.flag[currentitem].unescaped.display||null> <player.flag[settype]||null> price is now set to <green><context.message>"
            }
          - flag npc currentitem:!
          - flag player settype:!
          - determine cancelled
          }
          else {
          - narrate "<dark_red>That is not a valid number. please select a valid number for the price"
          - determine cancelled
          }
        }
    on click:
    - define name <player.name>
    - if <player> == <npc.owner> && !<player.item_in_hand> == i@air {
      - adjust <player.item_in_hand> quantity:1 save:item8
      - flag npc currentitem:<entry[item8].result.full.escaped>
      - narrate "<dark_purple>will you be <green>'selling' <dark_purple>or <green>'buying' <dark_purple>for this item?"
      - queue clear
      - determine cancelled
      }
      else if <player> == <npc.owner> && <player.item_in_hand> == i@air {
      - inventory open d:<npc.inventory>
      }
      
    - if <player.item_in_hand> == "i@shopping bag" { 
      - if <in@%name%_shopping_bag.qty> == 0 { 
        - narrate "<aqua>your shopping bag is empty!" 
        } else if <npc.owner> == server {
        - flag player delay duration:3s
        - chat "ok let's total these items up for you then!" 
        - define total_price 0 
        - foreach <in@%name%_shopping_bag.list_contents> { 
          - adjust %value% quantity:1 save:item2
          - if <server.flag[<entry[item2].result.full.escaped>]||null> == null { 
            - flag server <entry[item2].result.full.escaped>:1.00 
            } 
          - adjust %value% quantity:1 save:item
          - define price <yaml[prices].read[prices.<entry[item].result.full.escaped||null>].mul[2].mul[<server.flag[<entry[item].result.full.escaped||null>]||null>].mul[<%value%.qty||null>]> 
          - define total_price <el@val[%total_price%].add[%price%]||null> 
          } 
        - if <player.money> < %total_price% { 
          - narrate "<dark_red>YOU NEED MONEYS D=" 
          - queue clear 
          } 
        - flag player bagnumber:+:1
        - note "in@player bag" "as:<player.name> <player.flag[bagnumber].as_int>_item_bag"
        - take money qty:%total_price% 
        - run "itemgiverPlayer Owned" delay:1s 
        - take 'i@shopping bag'
        - narrate "<aqua>The shopkeeper takes <green>%total_price% coins"
        - narrate "<gold>You are all checked out. have a great day!"
        - narrate "<red>Do not open your item bag until you are ready to take all the items out"
        - foreach <in@%name%_shopping_bag.list_contents.full.escaped> { 
          - adjust %value% quantity:1 save:item9
          - flag server <entry[item9].result>adjust:+:<def[value].qty>
          - run script:price_adjuster def:<entry[item9].result>
          }
        } 
        else { 
        - flag player delay duration:3s
        - chat "ok let's total these items up for you then!" 
        - define total_price 0 
        - foreach <in@%name%_shopping_bag.list_contents> { 
          - adjust %value% quantity:1 save:item2
          - if <server.flag[<<entry[item2].result>.full.escaped>]> == null { 
            - flag server <<entry[item2].result>.full.escaped>:1.00 
            } 
          - define price <el@val[<npc.flag[sell_<entry[item2].result.full.escaped>]>].mul[<%value%.qty>]>
          - define total_price <el@val[%total_price%].add[%price%]> 
          } 
        - if <player.money> < %total_price% { 
          - narrate "<dark_red>YOU NEED MONEYS D=" 
          - queue clear 
          } 
        - if <npc.inventory.list_contents.simple> contains <in@<player.name>_shopping_bag.list_contents.simple> {
          - narrate "<aqua>I am sorry but we just ran out of some of those items!"
          - queue clear
          }
        - flag player bagnumber:+:1
        - note "in@player bag" "as:<player.name> <player.flag[bagnumber].as_int>_item_bag"
        - take money qty:%total_price% 
        - flag npc cashregister:+:%total_price%
        - run "itemgiverPlayer Owned" delay:1s 
        - take 'i@shopping bag'
        - narrate "<aqua>The shopkeeper takes <green>%total_price% coins"
        - narrate "<gold>You are all checked out. have a great day!"
        - narrate "<red>Do not open your item bag until you are ready to take all the items out"
        - foreach <in@%name%_shopping_bag.list_contents.full.escaped> { 
          - adjust %value% quantity:1 save:item9
          - flag server <entry[item9].result>adjust:+:<def[value].qty>
          - run script:price_adjuster def:<entry[item9].result>
          }
        }          
      } else if <player.item_in_hand> == "i@selling_bag" { 
      - flag player delay duration:3s
      - if <in@%name%_selling_bag.qty> == 0 { 
        - narrate "<dark_red>your selling bag is empty!" 
        } 
        else if <in@%name%_selling_bag.contains['i@shopping bag']> {
        - chat "i am sorry but i do not buy back my shopping bags."
        } 
        else if <npc.owner> == server {
        - chat "ok let's total these items up for you then!" 
        - define total_price 0 
        - foreach <in@%name%_selling_bag.list_contents> { 
          - adjust %value% quantity:1 save:item
          - define price <yaml[prices].read[prices.<entry[item].result.full.escaped>].mul[<def[value].qty>]||null> 
          - define total_price <el@val[%total_price%].add[%price%]||null> 
          } 
        - note as:<player.name>_selling_bag remove
        - give money qty:%total_price% 
        - take 'i@selling_bag'
        - narrate "<aqua>The shopkeeper gives you <green>%total_price% coins"
        - foreach <in@%name%_shopping_bag.list_contents.full.escaped> { 
          - adjust %value% quantity:1 save:item9
          - flag server <entry[item9].result>adjust:-:<def[value].qty>
          - run script:price_adjuster def:<entry[item9].result>
          }
        - queue clear
        }
        else {
        - chat "ok let's total these items up for you then!" 
        - define total_price 0 
        - foreach <in@%name%_selling_bag.list_contents> { 
          - adjust %value% quantity:! save:item
          - define price <el@val[<npc.flag[buy_<def[item].full.escaped>]>].mul[<def[value].qty>]>
          - define total_price <el@val[%total_price%].add[%price%]||null> 
          } 
        - if %total_price% < <npc.flag[wallet].as_int||null> {
          - flag npc buyback:->:<in@%name%_selling_bag.list_contents>
          - note 'in@player bag' as:<player.name>_selling_bag
          - give money qty:%total_price% 
          - flag npc cashregister:-:%total_price%
          - take 'i@selling_bag'
          - narrate "<aqua>The shopkeeper gives you <green>%total_price% coins"
          - foreach <in@%name%_shopping_bag.list_contents.full.escaped> { 
            - adjust %value% quantity:1 save:item9
            - flag server <entry[item9].result>adjust:-:<def[value].qty>
            - run script:price_adjuster def:<entry[item9].result>
            }
          - queue clear
          } 
          else {
          - narrate "<aqua>I am sorry I don't have the funds to buy all of that back!"
          }
        }
      } 
      else if <player.inventory> contains 'i@shopping bag' || <player.inventory> contains 'i@selling_bag' {
      - queue clear
      } 
      else if <player> == <npc.owner> {
      - queue clear
      }
      else {
      - chat "Please visit http://youtu.be/2f3Dk4cPCXs for a short tutorial of how to use our stores."
      }
    }

itemgiverPlayer Owned:
  type: task
  debug: true
  script:
  - define name <player.name>
  - inventory add o:in@%name%_shopping_bag 'd:in@<player.name> <player.flag[bagnumber].as_int>_item_bag'
  - ^adjust 'i@item_bag' "lore:<player.name> <player.flag[bagnumber].as_int>" save:playersbag
  - give <entry[playersbag].result.full>
Item Frame Shop Player Owned:
  type: world
  debug: true
  events:
    on server start:
    - yaml load:prices.yml id:prices
    on price command:
    - if <player.is_op> {
      - adjust <player.item_in_hand.full> quantity:1 save:item3
      - if !<yaml[prices].contains[prices.<entry[item3].result.full.escaped>]||null> {
        - flag player setpriceserver:<entry[item3].result.full.escaped>
        - narrate "<dark_purple>what is the base price you want for that item?"
        - determine cancelled
        }
        else {
        - narrate "<dark_purple>That item already has a current price of <green><yaml[prices].read[prices.<entry[item3].result.full.escaped>]||null>"
        - narrate "<dark_purple>To adjust that items price use the /adjust_price command"
        - determine cancelled
        }
      }
    on adjust_price command:
    - adjust <player.item_in_hand.full> quantity:1 save:item3
    - yaml id:prices set prices.<entry[item3].result.full.escaped>:!
    - flag player setpriceserver:<entry[item3].result.full.escaped>
    - narrate "<dark_purple>what is the base price you want for that item?"
    - determine fulfilled
    on player chats:
    - if <player.is_op> && !<player.flag[setpriceserver]||null> == null {
      - if <context.message.is[matches].to[integer]||false> {
        - yaml id:prices set prices.<player.flag[setpriceserver]>:<context.message>
        - yaml savefile:prices.yml id:prices
        - narrate "<dark_purple><player.flag[setpriceserver].unescaped.display> price is now set to <green><yaml[prices].read[prices.<player.flag[setpriceserver]>]||null>"
        - flag setpriceserver:!
        - determine cancelled
        }
        else {
        - narrate "<dark_red>That is not a valid number"
        - narrate "<dark_purple>what is the base price you want for that item?"
        - determine cancelled
        }
      }
    on stop command:
    - foreach <server.flag[storenpcs].as_list> {
      - flag %value% playerstoreinventory:<def[value].inventory.list_contents>
      }
    on player teleports:
    - if '<player.inventory.contains[i@shopping bag]||null>' {
      - queue clear
      } 
      else if '<player.inventory.contains[i@shopping bag]>' {
      - inventory add o:in@<player.name>_shopping_bag d:<player.flag[storekeepernpc].inventory>
      - take "i@shopping bag"
      - narrate "<dark_red>No stealing items from my store!!"
      }
    on player quits:
    - if '<player.inventory.contains[i@shopping bag]>' {
      - inventory add o:in@<player.name>_shopping_bag d:<player.flag[storekeepernpc].as_npc.inventory>
      - take "i@shopping bag"
      - narrate "<dark_red>No stealing items from my store!!"
      }
    on store_setup command:
    - give <player> i@playerstorekeeperegg
    - determine fulfilled
    on player clicks with i@playerstorekeeperegg:
    - if <global.flag[playerstore].escape_contents||null> == null {
      - run "storelocationstick3" as:<player> delay:1t
      - create player storekeeper <player.location.cursor_on.add[0.5,1,0.5]>
      - execute as_op "npc select"
      - narrate "<dark_purple>please select the bottom and top corners of your cuboid then drop the selector"
      - take i@playerstorekeeperegg
      - lookclose <player.selected_npc> state:true
      - queue clear
      }
    - foreach <global.flag[playerstore].escape_contents> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]||null> {
        - narrate "you cannot place your store inside of someone another store"
        - determine cancelled
        }
      }
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if !<def[value].unescaped.as_cuboid.is_within[<context.location>]||null> {
        - run "storelocationstick3" as:<player> delay:1t
        - create player storekeeper <player.location.cursor_on.add[0.5,1,0.5]>
        - execute as_op "npc select"
        - narrate "<dark_purple>please select the bottom and top corners of your cuboid then drop the selector"
        - take i@playerstorekeeperegg
        - lookclose <player.selected_npc> state:true
        - queue clear
        }
      }
    on item_frame damaged by entity_explosion:
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.entity.location>]||null> {
        - determine cancelled
        }
      }
    on item_frame damaged by block_explosion:
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.entity.location>]||null> {
        - determine cancelled
        }
      }
    on player right clicks with i@storelocationstick4:
    - if <global.flag[playerstore].escape_contents||null> == null {
      - run "storelocationstick2" def:<context.location> as:<player> delay:1t
      - flag player location1:<context.location>
      - narrate "<dark_purple>Cuboid location 1 selected"
      - determine cancelled
      }
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]||null> {
        - determine cancelled
        }
        else {
        - run "storelocationstick2" def:<context.location> as:<player> delay:1t
        - flag player location1:<context.location>
        - narrate "<dark_purple>Cuboid location 1 selected"
        - determine cancelled
        }
      }
    on player left clicks with i@storelocationstick4:
    - if <global.flag[playerstore].escape_contents||null> == null {
      - run "storelocationstick2" def:<context.location> as:<player> delay:1t
      - flag player location2:<context.location>
      - narrate "<dark_purple>Cuboid location 2 selected"
      - determine cancelled
      }
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]> {
        - determine cancelled
        }
        else {
        - flag player location2:<context.location>
        - run "storelocationstick2" def:<context.location> as:<player> delay:1t
        - narrate "<dark_purple>Cuboid location 2 selected"
        - determine cancelled
        }
      }
    on player drops i@storelocationstick4:
    - execute as_op "npc owner <player.name> --id <player.selected_npc.id>"
    - assignment set npc:<player.selected_npc> script:StorekeeperPlayerOwned
    - flag <player.selected_npc> playerstore:cu@<player.flag[location1]>|<player.flag[location2]>
    - flag player location1:!
    - flag player location2:!
    - flag server storenpcs:->:<npc>
    - run "storeselectorremover2" delay:1t
    - narrate "<dark_purple>tell the npc <green>'SET' <dark_purple>to set the items in the frame"
    - determine cancelled
    on player right clicks e@item_frame:
    - define name <player.name>
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]||null> {
        - if <player.item_in_hand.scriptname> == 'shopping bag' {
          - if <in@%name%_shopping_bag.stacks> >= 18 {
            - narrate "<aqua>Your shopping bag is full!"
            } 
            else if <player.flag[storekeepernpc].as_npc.owner> == server {
            - inventory add o:<c.entity.framed_item> d:in@<player.name>_shopping_bag
            - if <c.entity.framed_item.display||null> != null {
              - narrate "<aqua>You add a <green><c.entity.framed_item.display> <aqua>to your shopping bag."
              }
              else {
              - narrate "<aqua>You add <green><c.entity.framed_item.material.name.replace[_].with[ ]> <aqua>to your shopping bag."
              - playsound <player> sound:DIG_GRASS
              }
            }
            else if <player.flag[storekeepernpc].as_npc.inventory.list_contents.simple> contains <context.entity.framed_item> {
            - inventory add o:<c.entity.framed_item> d:in@<player.name>_shopping_bag
            - take <c.entity.framed_item> from:<player.flag[storekeepernpc].as_npc.inventory>
            - if <c.entity.framed_item.display||null> != null {
              - narrate "<aqua>You add a <green><c.entity.framed_item.display> <aqua>to your shopping bag."
              }
              else {
              - narrate "<aqua>You add <green><c.entity.framed_item.material.name.replace[_].with[ ]> <aqua>to your shopping bag."
              - playsound <player> sound:DIG_GRASS
              }
              else {
              - narrate "<dark_red>That item is out of stock!"
              }
            }
          - determine cancelled
          }
        }
      }
    on player places block:
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]||null> {
        - if <player.is_sneaking> && <player.is_op> {
          - queue clear
          } else {
          - determine cancelled
          }
        }
      }
    on player breaks e@item_frame:
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]||null> {
        - if <player.is_sneaking> && <player.is_op> {
          - queue clear
          } 
          else {
          - if <c.hanging.framed_item.display||null> != null {
            - narrate "It's a <c.hanging.framed_item.display>."
            }
            else {
            - narrate "It's <c.hanging.framed_item.material.formatted>."
            }
          - narrate "Right click it with your shopping bag to add it to your transaction."
          - determine cancelled
          }
        }
      }

    on player breaks block:
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]||null> {
        - if <player.is_sneaking> && <player.is_op> {
          - queue clear
          } else {
          - determine cancelled
          }
        - if <player.flag[storekeeper_warned]||null> == null {
            - narrate '<aqua>[storekeeper] -> You<&co> <dark_red>Hey! <aqua>You break it, you buy it! <dark_red>Be careful!'
            - flag <player> storekeeper_warned duration:5s
          } 
        }
      }
    
    on entity damages e@item_frame:
    - foreach <global.flag[playerstore].escape_contents||null> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.entity.location>]||null> {
        - if <player.is_sneaking> && <player.is_op> {
          - queue clear
          } 
          else {
          - foreach <global.flag[playerstore].escape_contents||null> {
            - if <def[value].unescaped.as_cuboid.is_within[<context.entity.location>]||null> {
              - if <server.flag[<context.entity.framed_item.full.escaped>]||null> == null {
                - flag server <context.entity.framed_item.full.escaped>:1.00
                - determine cancelled
                } 
                else if <player.flag[storekeepernpc].as_npc.owner> == server {
                - define price <yaml[prices].read[prices.<context.entity.framed_item.full.escaped>].mul[2].mul[<server.flag[<context.entity.framed_item.full.escaped>]>].as_int||null>
                - narrate "<green>%price%"
                - determine cancelled
                }
                else {
                - define price <player.flag[storekeepernpc].as_npc.flag[sell_<context.entity.framed_item.full.escaped>]||null>
                - narrate "<green>%price%"
                - determine cancelled
                }
              }
            }
          }
        }
      }
      
    on player right clicks entity with i@shopping bag:
    - if <context.entity.is_npc||null> {
      - flag player shopkeeper:<npc>
      }
    on player places item_frame:
    - foreach <global.flag[playerstore].escape_contents> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]> {
        - if <player.is_sneaking> && <player.is_op> {
          - queue clear
          } else {
          - determine cancelled
          }
        }
      }
    on player right clicks with i@shopping bag:  
    - define name <player.name>
    - define is_shopping false  
    - foreach <global.flag[playerstore].escape_contents||null> {  
      - if <player.location.is_within[<def[value].unescaped>]> {  
        - define is_shopping true  
        - foreach stop  
        }  
      }  
    - if !<player.inventory.qty[i@shopping bag]> >= 2 {
      - take 'i@shopping bag' qty:36
      - note 'in@player bag' as:<player.name>_shopping_bag
      }
    - if !%is_shopping% {  
      - inventory clear d:in@<player.name>_shopping_bag  
      - take 'i@shopping bag'  
      - narrate '<dark_red>You are not shopping right now!'  
      }  
      else if in@<player.name>_shopping_bag == null && %is_shopping% {  
      - note 'in@player bag' as:<player.name>_shopping_bag  
      }   
      else if %is_shopping% {
      - narrate '<aqua>You take a look in your shopping bag...'  
      - inventory open d:in@<player.name>_shopping_bag    
      }   
    - determine cancelled  


    on player right clicks with i@selling_bag:
    - define name <player.name>
    - define is_shopping false  
    - foreach <global.flag[playerstore].escape_contents||null> {  
      - if <player.location.is_within[<def[value].unescaped>]> {  
        - define is_shopping true  
        - foreach stop  
        }  
      }  
    - if !%is_shopping% { 
      - define name <player.name>
      - foreach <in@%name%_selling_bag.list_contents> {
        - drop %value% <player.location>
        }    
      - inventory clear d:in@<player.name>_selling_bag
      - narrate '<dark_red>You are not in a shop right now!'
      - take 'i@selling_bag'
      - determine cancelled
      }  
      else if <in@%name%_shopping_bag||null> == null && %is_shopping% {  
      - note 'in@player bag' as:<player.name>_selling_bag
      - inventory open d:in@<player.name>_selling_bag
      - determine cancelled
      }   
      else if %is_shopping% {  
      - inventory open d:in@<player.name>_selling_bag
      - determine cancelled
      }   
    - determine cancelled  
    
    on player right clicks with i@item_bag:
    - foreach <global.flag[playerstore].escape_contents> {
      - if <def[value].unescaped.as_cuboid.is_within[<context.location>]> && <player.location.facing[<player.flag[shopkeeper]>]> {
        } else {
        - narrate '<aqua>You take a look in your shopping bag...'
        - inventory open "d:in@<context.item.lore.as_string.strip_color>_item_bag"
        }
      - determine cancelled   
      }
    on player drops i@shopping bag:
    - narrate '<aqua>You ditch your shopping bag.'
    - if !<player.flag[storekeepernpc].as_npc.owner> == server {
      - inventory add o:in@<player.name>_shopping_bag 'd:<player.flag[storekeepernpc].as_npc.inventory>'
      }
    - run "bagremovertaskPlayer Owned" delay:1t
    - determine cancelled
    on player drops i@selling_bag:
    - define name <player.name>
    - foreach <in@%name%_selling_bag.list_contents> {
      - drop %value% <player.location>
      }
    - narrate '<aqua>You ditch your selling bag.'
    - run "bagremovertask1Player Owned" delay:1t
    - note in@<player.name>_selling_bag remove
    - determine cancelled
    on player clicks in inventory:
    - define name <player.name>
    - if <c.inventory> == 'in@<player.name>_shopping_bag' && <player.item_in_hand> == 'i@shopping bag' {
      - determine passively cancelled
      - inventory update d:<player.inventory>
      }
    - if <c.inventory> == 'in@<player.name>_shopping_bag' && <player.item_in_hand> == 'i@shopping bag' {
      - if <context.is_shift_click> {
        - determine passively cancelled
        - inventory update d:<player.inventory>
        }
      }
    - if <c.inventory> == 'in@<player.name>_selling_bag' {
      - if "li@i@shopping bag|i@selling_bag|i@item_bag" contains <context.item> {
        - inventory update
        - determine cancelled
        }
      }
    on player picks up i@shopping bag:
    - if '<player.inventory.contains[i@shopping bag]>' {
        - determine cancelled
      } else {
        - note 'in@player bag' as:<player.name>_shopping_bag
        - narrate "<aqua>You pick up a brand new shopping bag. It's empty!"
      }
    on player closes inventory:
    - if <player.item_in_hand> == 'i@item_bag' {
      - if <context.inventory> == <player.inventory> {
        } 
        else {
        - define item <player.item_in_hand.lore.as_string.strip_color>
        - foreach <in@%item%_item_bag.list_contents> {
          - drop %value% <player.location>
          }
        - narrate "<dark_red>your shopping bag ripped"
        - take iteminhand
        }
      }
      

    on player picks up i@playerstorekeeperegg:
    - narrate "<aqua>To learn how to set up the frame shop please visit <green>https://www.youtube.com/watch?v=FlYEog5-KxU"
    on player clicks i@playerstorekeeperegg in inventory:
    - narrate "<aqua>To learn how to set up the frame shop please visit <green>https://www.youtube.com/watch?v=FlYEog5-KxU"
'player bag':
  type: inventory
  size: 18

  # It's empty!
'selling bag':
  type: inventory
  size: 18

'shopping bag':
  type: item

  material: boat
  display name: shopping bag
  lore:
  - Give this to a shopkeeper to check out.
  - Right click to see the contents.
'item_bag':
  type: item

  material: boat
  display name: item bag
  lore:
  - <red>this bag contains the items you bought
'selling_bag':
  type: item

  material: boat
  display name: selling bag
  lore:
  - <green>Right click the shopkeeper with this bag to sell the items in it.
  - <green>Left click the shopkeeper with this bag to see what the 
  - <green>total price of your items will be.
storelocationstick4:
  type: item
  material: m@iron_hoe
  display name: store_selector_tool
storeselectorremover2:
  type: task
  debug: false
  script:
  - take i@storelocationstick4
bagremovertaskPlayer Owned:
  type: task
  debug: false
  script:
  - take 'i@shopping bag'
bagremovertask1Player Owned:
  type: task
  debug: false
  script:
  - take 'i@selling_bag'
playerstorekeeperegg:
  type: item
  material: m@monster_egg
  display name: shop_keeper
storelocationstick3:
  type: task
  debug: false
  script:
  - give <player> "i@storelocationstick4"
storelocationstick2:
  type: task
  script:
  - showfake m@red_wool %1% to:<player> d:30s