################################################################################
#
#                          M a s t e r C h e f   N P C 
#                           Feed those hungry denizens
#
#
#   Author: |Anthony|
#   Version: 0.1
#   dScript Version: 0.9.5-b1522
#
# 
#
################################################################################
#
MasterChefNPC:
  type: assignment
  debug: false

  actions:
    on assignment:
      - run locally assignment instantly
    on spawn:
      - run locally spawn instantly
    on despawn:
      - run locally despawn instantly
    on click:
      - if <player.has_permission[chef.admin]> {
        - run locally click instantly
        }
        else {
        - chat "<&7>You can tell me to find the <&f>sink<&7>, <&f>prep<&7>, <&f>oven<&7>, <&f>stove<&7>, <&f>grill<&7>, or <&f>fridge<&7> and I will find it."
        - chat "<&7>Or you can tell me <&f>potato<&7> and I will make a baked potato for you."
        }
    on damage:
      - run locally damage instantly
    on chat:
      - wait 10t
      - run locally chat instantly def:<c.message>

  assignment:
    - trigger name:chat state:true radius:5 cooldown:5s
    - trigger name:click state:true radius:5 cooldown:5s
    - trigger name:proximity state:false
    - trigger name:damage state:true radius:5 cooldown:5s
    - vulnerable state:false
    - lookclose true range:5 realistic
    - flag npc respawn_location:<npc.location>
    - flag npc Pathfind.FidgetRadius:5
    - flag npc Pathfind.FidgetSpeed:0.7
    - flag npc Pathfind.FidgetWait:10
    - flag npc Pathfind.FidgetLocation:<npc.location>
    - flag npc Pathfind.FidgetHeight:1
    - flag npc Pathfind.FidgetPathMaterial:<npc.location.standing_on.material.name>
    - inject locally spawn instantly


  spawn:
    - chat "Alright, time to start work..." no_target
#    - run s@Fidget id:fidgetQueue_<npc.id>


  despawn:
    - chat "Phew... I<&sq>m glad to be done work for the day!" no_target


  damage:
    - chat "Why would you do that?" no_target


  click:
    - if <npc.has_flag[following]> {
      - if <npc.flag[following].as_player.is[==].to[<player>]> {
        - follow stop
        - if <queue.exists[Following_<npc.id>]> queue queue:Following_<npc.id> stop
        - chat "Ok. I<&sq>ll wait right here..."
        - flag npc following:!
#        - run s@Fidget id:fidgetQueue_<npc.id>
        - queue stop
        }
        else {
        - chat "I<&sq>m a little busy right now..."
        - queue stop
        }
      }
      else {
      - if <queue.exists[fidgetQueue_<npc.id>]> queue queue:fidgetQueue_<npc.id> stop
      - flag npc following:<player>
      - run locally follow id:Following_<npc.id>
      }

  follow:
    - if !<npc.flag[following].as_player.is_online> {
      - flag npc following:!
      - follow stop
      - run s@Fidget id:fidgetQueue_<npc.id>
      - queue stop
      }
    - follow target:<npc.flag[following].as_player>
    - wait 5s
    - inject locally follow

  chat:
    - ^if <npc.has_flag[following]> {
      - chat "I<&sq>m a little busy right now following <npc.flag[following].as_player.name>..."
      - queue stop
      }
    - ^define foodItems li@potato
    - ^define food '<def[1].split[ ].get[1].escaped||null>'
    - ^narrate "%1%"
    - ^if <def[1].is[==].to[potato]> {
      - chat "Ok, one baked potato coming up!"
      - inject locally bakedPotato
      - queue stop
      }
    - ^define options li@fridge|fancyFridge|grill|sink|prep|oven|stove
    - ^define equipment '<def[1].split[ ].get[1].escaped||null>'
    - ^define range '<def[1].split[ ].get[2].escaped||15>'
    - ^if !<def[range].is[MATCHES].to[number]> {
      - chat "Hey, that<&sq> s not a number!"
      }
    - ^if !<def[options].contains[%equipment%]> {
      - chat "I don<&sq>t know anything about that."
      - queue stop
      }
    - ^if <queue.exists[fidgetQueue_<npc.id>]> queue queue:fidgetQueue_<npc.id> stop
    - ^inject locally find%equipment% instantly
    - ^if <def[locations].as_list.is_empty> {
      - chat "I couldn<&sq>t find the %equipment%."
      - queue stop
      }
    - ^chat "I found <def[locations].size.as_int> %equipment%."
    - ^define destination <def[locations].random>
#    - ^showfake glowstone %destination% d:5s
    - ~walkto '<def[destination].split[/].get[2].as_location>' speed:0.7
    - ^chat "Ok, I made it to the %equipment%."
    - ^wait 5s
#    - ^run s@Fidget id:fidgetQueue_<npc.id>


################################################################################
#
#  Kitchen Equipment Locators
#
  findFridge:
  # The Fridge is 2 ironblocks tall with a stone button on the front of the top block
    - define ironBlocks <npc.location.find.blocks[iron_block].within[%range%]||null>
    - if <def[ironBlocks].is[!=].to[null]>
      && !<def[ironBlocks].is_empty> {
      - define locations li@
      - foreach %ironBlocks% {
        - define iron '%value%'
        - if <def[iron].below.material.is[!=].to[m@iron_block]||true> foreach next

        - define east '<def[iron].add[1,0,0]>'
        - define west '<def[iron].add[-1,0,0]>'
        - define north '<def[iron].add[0,0,1]>'
        - define south '<def[iron].add[0,0,-1]>'
        - define cardinals li@east|west|north|south

        - foreach %cardinals% {
          - define location '<def[%value%]>'

          - if <def[location].material.is[==].to[m@stone_button]>
            && <def[location].sub[0,1,0].material.is[==].to[m@air]>
            && <def[location].sub[0,2,0].material.is_solid> {
            - define locations <def[locations].include[%iron%/<def[location].below>]>
            }
          }
        }
      }


  findFancyFridge:
  # The Fridge is 2 ironblocks tall with an iron door on the front
    - define ironBlocks <npc.location.find.blocks[iron_block].within[%range%]||null>
    - if <def[ironBlocks].is[!=].to[null]>
      && !<def[ironBlocks].is_empty> {
      - define locations li@
      - foreach %ironBlocks% {
        - define iron '%value%'
        - if <def[iron].below.material.is[!=].to[m@iron_block]||true> foreach next

        - define east '<def[iron].add[1,0,0]>'
        - define west '<def[iron].add[-1,0,0]>'
        - define north '<def[iron].add[0,0,1]>'
        - define south '<def[iron].add[0,0,-1]>'
        - define cardinals li@east|west|north|south

        - foreach %cardinals% {
          - define location '<def[%value%]>'

          - if <def[location].material.name.is[==].to[iron_door_block]>
            && <def[location].sub[0,1,0].material.name.is[==].to[m@iron_door_block]>
            && <def[location].sub[0,2,0].material.is_solid> {
            - define locations <def[locations].include[%iron%/<def[location].below>]>
            }
          }
        }
      }


  findGrill:
  # The Grill is a trapdoor over fire
  # This currently sets the location to walk to as the solid block the player
  #  would stand on. This differs from all of the other equipment search
  #  functions since they all return the air block in front of the equipment.
  #  I want to keep this just to see if there is a noticeable difference.
    - define fireBlocks <npc.location.find.blocks[m@fire].within[%range%]||null>
    - if <def[fireBlocks].is[!=].to[null]>
      && !<def[fireBlocks].is_empty> {
      - define locations li@
      - foreach %fireBlocks% {
        - define fire '%value%'
        - if <def[fire].above.material.is[!=].to[m@trap_door]||true> foreach next

        - define east '<def[fire].add[1,0,0]>'
        - define west '<def[fire].add[-1,0,0]>'
        - define north '<def[fire].add[0,0,1]>'
        - define south '<def[fire].add[0,0,-1]>'
        - define cardinals li@east|west|north|south

        - foreach %cardinals% {
          - define location '<def[%value%]>'

          - if <def[location].material.is_solid>
            && <def[location].above.material.is[==].to[m@air]>
            && <def[location].add[0,2,0].material.is[==].to[m@air]> {
            - define locations <def[locations].include[%fire%/%location%]>
            }
          }
        }
      }


  findSink:
  # The sink is a Cauldron full of water with a tripwire hook above
    - define cauldronBlocks <npc.location.find.blocks[cauldron,3].within[%range%]||null>
    - if <def[cauldronBlocks].is[!=].to[null]>
      && !<def[cauldronBlocks].is_empty> {
      - define locations li@
      - foreach %cauldronBlocks% {
        - define cauldron '%value%'
        - if <def[cauldron].above.material.is[!=].to[m@tripwire_hook]||true> foreach next

        - define east '<def[cauldron].add[1,0,0]>'
        - define west '<def[cauldron].add[-1,0,0]>'
        - define north '<def[cauldron].add[0,0,1]>'
        - define south '<def[cauldron].add[0,0,-1]>'
        - define cardinals li@east|west|north|south

        - foreach %cardinals% {
          - define location '<def[%value%]>'

          - if <def[location].material.is[==].to[m@air]>
            && <def[location].above.material.is[==].to[m@air]>
            && <def[location].below.material.is_solid> {
            - define locations <def[locations].include[%cauldron%/%location%]>
            }
          }
        }
      }


  findPrep:
  # The Prep station is the top half stone slab with a wood pressure plate on top
    - define prepBlocks <npc.location.find.blocks[stone_slab_up].within[%range%]||null>
    - if <def[prepBlocks].is[!=].to[null]>
      && !<def[prepBlocks].is_empty> {
      - define locations li@
      - foreach %prepBlocks% {
        - define prep '%value%'
        - if <def[prep].above.material.is[!=].to[m@wood_plate]||true> foreach next

        - define east '<def[prep].add[1,0,0]>'
        - define west '<def[prep].add[-1,0,0]>'
        - define north '<def[prep].add[0,0,1]>'
        - define south '<def[prep].add[0,0,-1]>'
        - define cardinals li@east|west|north|south

        - foreach %cardinals% {
          - define location '<def[%value%]>'

          - if <def[location].material.is[==].to[m@air]>
            && <def[location].above.material.is[==].to[m@air]>
            && <def[location].below.material.is_solid> {
            - define locations <def[locations].include[%prep%/%location%]>
            }
          }
        }
      }


  findOven:
  # The oven is a 2 tall by 2 wide set of furnaces.
  # We will accept furnaces that are on or off
    - define furnaceBlocks <npc.location.find.blocks[furnace|burning_furnace].within[%range%]||null>
    - if <def[furnaceBlocks].is[!=].to[null]>
      && !<def[furnaceBlocks].is_empty> {
      - define locations li@
      - foreach %furnaceBlocks% {
        - define furnace1 '%value%'
        - if <def[furnace1].below.material.is[!=].to[m@furnace]||true>
          && <def[furnace1].below.material.is[!=].to[m@burning_furnace]||true> foreach next

        - define east '<def[furnace1].add[1,0,0]>'
        - define west '<def[furnace1].add[-1,0,0]>'
        - define north '<def[furnace1].add[0,0,1]>'
        - define south '<def[furnace1].add[0,0,-1]>'
        - define cardinals li@east|west|north|south

        - foreach %cardinals% {
          - define furnace2 '<def[%value%]>'

          - if <el@[<def[furnace2].material.is[!=].to[m@furnace]>].or[<def[furnace2].material.is[!=].to[m@burning_furnace]>]>
            && <el@[<def[furnace2].below.material.is[!=].to[m@furnace]>].or[<def[furnace2].below.material.is[!=].to[m@burning_furnace]>]> foreach next

          - define east '<def[furnace2].add[1,0,0]>'
          - define west '<def[furnace2].add[-1,0,0]>'
          - define north '<def[furnace2].add[0,0,1]>'
          - define south '<def[furnace2].add[0,0,-1]>'
          - define cardinals li@east|west|north|south

          - foreach %cardinals% {
            - define location '<def[%value%]>'

            - if <def[location].material.is[==].to[m@air]>
              && <def[location].sub[0,1,0].material.is[==].to[m@air]>
              && <def[location].sub[0,2,0].material.is_solid> {
              - define locations <def[locations].include[%furnace2%/<def[location].sub[0,1,0]>]>
              }
            }
          }
        }
      }


  findStove:
  # The Stove is a furnace with a stone pressure plate on top
    - define stoveBlocks <npc.location.find.blocks[furnace|burning_furnace].within[%range%]||null>
    - if <def[stoveBlocks].is[!=].to[null]>
      && !<def[stoveBlocks].is_empty> {
      - define locations li@
      - foreach %stoveBlocks% {
        - define stove '%value%'
        - if <def[stove].above.material.is[!=].to[m@stone_plate]||true> foreach next

        - define east '<def[stove].add[1,0,0]>'
        - define west '<def[stove].add[-1,0,0]>'
        - define north '<def[stove].add[0,0,1]>'
        - define south '<def[stove].add[0,0,-1]>'
        - define cardinals li@east|west|north|south

        - foreach %cardinals% {
          - define location '<def[%value%]>'

          - if <def[location].material.is[==].to[m@air]>
            && <def[location].above.material.is[==].to[m@air]>
            && <def[location].below.material.is_solid> {
            - define locations <def[locations].include[%stove%/%location%]>
            }
          }
        }
      }


################################################################################
#
#  Recipes
#
  bakedPotato:
  # Walk to fridge and get potato
    - ^lookclose <npc> state:false
    - ^inject locally findFancyFridge instantly
    - ^define destination '<def[locations].random>'
    - ^define door '<def[destination].split[/].get[2].as_location>'
    - ~walkto %door% speed:0.7
    - ^look <npc> '<def[destination].split[/].get[1].as_location>'
#    - ^playsound <npc.location> sound:door_open
    - ^switch %door% state:toggle
    - ^wait 15t
    - ~equip <npc> hand:<i@potato_item>
    - ^switch %door% state:toggle
#    - ^playsound <npc.location> sound:door_close
    - ^wait 5t
  # Walk to sink and wash potato
    - ^inject locally findSink instantly
    - ^define destination '<def[locations].random>'
    - ~walkto '<def[destination].split[/].get[2].as_location>' speed:0.7
    - ^look <npc> '<def[destination].split[/].get[1].as_location>'
    - ~equip <npc> hand:<i@air>
    - ^displayitem <i@potato_item> '<def[destination].split[/].get[1].as_location>' d:50t
    - ^animate <npc> animation:SNEAK
    - ^animate <npc> animation:ARM_SWING
    - ^playsound <npc.location> sound:splash2
    - ^repeat 5 {
      - animate <npc> animation:ARM_SWING
      - playsound <npc.location> sound:swim
      - wait 5t
      }
    - ^playsound <npc.location> sound:splash2
    - ^animate <npc> animation:ARM_SWING
    - ^animate <npc> animation:STOP_SNEAKING
    - ~equip <npc> hand:<i@potato_item>
    - ^wait 10t
  # Walk to prep area and prep potato
    - ^inject locally findPrep instantly
    - ^define destination '<def[locations].random>'
    - ~walkto '<def[destination].split[/].get[2].as_location>' speed:0.7
    - ^look <npc> '<def[destination].split[/].get[1].as_location>'
    - ^animate <npc> animation:SNEAK
    - ^animate <npc> animation:ARM_SWING
    - ~equip <npc> hand:<i@air>
    - ^displayitem <i@potato_item> '<def[destination].split[/].get[1].as_location>' d:50t
    - ^repeat 5 {
      - animate <npc> animation:ARM_SWING
      - playsound <npc.location> sound:step_ladder
      - wait 5t
      }
    - ~equip <npc> hand:<i@potato_item>
    - ^animate <npc> animation:STOP_SNEAKING
  # Walk to oven and cook potato
    - ^wait 5t
    - ^inject locally findOven instantly
    - ^define destination '<def[locations].random>'
    - ~walkto '<def[destination].split[/].get[2].as_location>' speed:0.7
    - ^define furnace '<def[destination].split[/].get[1].as_location>'
    - ^look <npc> %furnace%
    - ~equip <npc> hand:<i@air>
    - ^animate <npc> animation:ARM_SWING
    - ^wait 5t
    - ^playsound <npc.location> sound:ghast_fireball
    - ^showfake m@burning_furnace,<def[furnace].material.data> %furnace% to:<npc.location.find.players.within[10]> d:200t
    - ^repeat 20 {
      - ^define sound '<li@fuse|fire.random>'
      - ^playsound <npc.location> sound:%sound%
      - ^wait 5t
      }
    - ^animate <npc> animation:ARM_SWING
    - ~equip <npc> hand:<i@baked_potato>
    - ^lookclose <npc> state:true
    - ^chat "Here it is, one baked potato!" no_targets
    - ^wait 15t
    - ~equip <npc> hand:<i@air>
    - ^give i@baked_potato