# +----------------------------------
# |   S.A.R.A.H 
# |   Self Actuated Real-Time Automated Helper
# +----------------------------------

Load_Sarah:
    type: task
    Script:
# Works
      - if <server.has_file[Sarah_Data.yml]> {
        - yaml "load:/Data/Sarah_Data.yml" id:Sarah_D
        - narrate "<dark_green>Loading <gold>S.A.R.A.H<dark_green>'s Data"
        } else {
        - yaml create id:Sarah_D
        - narrate "<red>Couldn't find Data file."
        - narrate "<dark_green>Creating new <gold>Sarah_Data.yml <dark_green>file"
        - yaml id:Sarah_D set Failed.Message:->:Temp
        - yaml id:Sarah_D set Failed.Message:<-:Temp
        - yaml id:Sarah_D set Failed.Definition:->:Temp
        - yaml id:Sarah_D set Failed.Definition:<-:Temp
        - yaml id:Sarah_D set Statistics.Failed.Messages:1
        - yaml id:Sarah_D set Statistics.Failed.Definitions:1
        - yaml id:Sarah_D set Statistics.Requests.Who_Am_I:0
        - yaml id:Sarah_D set Arithia.Races:->:Human
        - yaml id:Sarah_D set Fun.Quotes.wonderdude:->:Don<&sq>t<&sp>be<&sp>a<&sp>Drem,<&sp>be<&sp>an<&sp>optimist!
        - yaml id:Sarah_D set Fun.Quotes.Drem_:->:Tests by Dr. Drem
        - yaml id:Sarah_D set Fun.Quotes.Unknown:->:Some<&sp>say<&sp>the<&sp>original<&sp>server<&sq>s<&sp>name<&sp><&dq>Erecia<&dq><&sp>was<&sp>related<&sp>to<&sp>a<&sp>certain<&sp>masculine<&sp>feature,<&sp>but<&sp>who<&sp>can<&sp>say<&sp>for<&sp>sure.
        - yaml "savefile:/Data/Sarah_Data.yml" id:Sarah_D
        }


Save_Sarah:
    type: task
    Script:
      - yaml "savefile:/Data/Sarah_Data.yml" id:Sarah_D
      - narrate "<dark_green>Saving <gold>S.A.R.A.H<dark_green>'s Data"
      - run Save_Sarah delay:10m


SARAH:
    type: world
    events:
        on player joins:
#        - if <player.in_group[Owner]> || <player.in_group[Admin]> || <player.in_group[Mod]> || <player.in_group[HMod]> || <player.in_group[ModA]> || <player.in_group[Mod]> || <player.in_group[Event_Team_A]> {
#          - if <yaml[Sarah_D].read[Arithia.Accepted_IPs].contains[<player.ip.address>]> {
#            - queue clear
#            } else {
#            - execute as_server "kick <player.name> Joining Arithia with an unregistered IP address. If this is a mistake, contact an admin or higher ranked staff."
#            - execute as_server "banip <player.ip.address> Joining Arithia with an unregistered IP address. If this is a mistake, contact an admin or higher ranked staff."
#            - narrate "<gold>[<dark_red>WARNING<gold>] <red><player.name> Just attempted to join the server, with an invalid IP address." targets:<server.list_online_ops>
#            - yaml id:Sarah_D set Arithia.Denied_IPs:->:<player.name><&sp>IP<&co><&sp><player.ip.address>
#            }
#          }
        - if <player.name> != wonderdude {
          - narrate Format:Sarah_F "Welcome back <gold><player.name>"
          } else {
          - narrate Format:Sarah_F "Welcome back <red>Master"
          }

        - if <player.is_op> && (<yaml[Sarah_D].read[Failed.Message].size> != 0 || <yaml[Sarah_D].read[Failed.Definition].size> != 0) {
          - if <yaml[Sarah_D].read[Failed.Message].size> != 0 && <yaml[Sarah_D].read[Failed.Definition].size> != 0 {
            - if <yaml[Sarah_D].read[Failed.Message].size> > 1 && <yaml[Sarah_D].read[Failed.Definition].size> > 1 {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Message].size> <red>Failed Messages <gray>and <gold><yaml[Sarah_D].read[Failed.Definition].size> <blue>Failed Definitions"
              } else if <yaml[Sarah_D].read[Failed.Message].size> > 1 && <yaml[Sarah_D].read[Failed.Definition].size> == 1 {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Message].size> <red>Failed Messages <gray>and <gold><yaml[Sarah_D].read[Failed.Definition].size> <blue>Failed Definition"
              } else if <yaml[Sarah_D].read[Failed.Message].size> == 1 && <yaml[Sarah_D].read[Failed.Definition].size> > 1 {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Message].size> <red>Failed Message <gray>and <gold><yaml[Sarah_D].read[Failed.Definition].size> <blue>Failed Definitions"
              } else {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Message].size> <red>Failed Message <gray>and <gold><yaml[Sarah_D].read[Failed.Definition].size> <blue>Failed Definition"
              }
            } else if <yaml[Sarah_D].read[Failed.Message].size> != 0 && <yaml[Sarah_D].read[Failed.Definition].size> == 0 {
            - if <yaml[Sarah_D].read[Failed.Message].size> > 1 {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Message].size> <red>Failed Messages"
              } else {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Message].size> <red>Failed Message"
              }
            } else if <yaml[Sarah_D].read[Failed.Message].size> == 0 && <yaml[Sarah_D].read[Failed.Definition].size> != 0 {
            - if <yaml[Sarah_D].read[Failed.Definition].size> > 1 {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Definition].size> <blue>Failed Definitions"
              } else {
              - narrate Format:Sarah_F "I logged <gold><yaml[Sarah_D].read[Failed.Definition].size> <blue>Failed Definition"
              }
            }
          }


        on player (first) login:
        - narrate Format:Sarah_F "Welcome to <gold>Arithia"


        on player chats:
        - if <context.message.starts_with[Sarah,]> || <context.message.starts_with[Sarah.]> {
          - inject locally Message_Type
          - determine passively cancelled
          - inject locally Control_Center
          }





# +----------------------------------
# |   Message Type
# +----------------------------------
    Message_Type:
# Attempt to add a way to narrate to a specific player. (FAILED)
    - if <context.message.starts_with[Sarah,<&sp>@]> || <context.message.starts_with[Sarah.<&sp>@]> {
      - define Targets <server.match_player[<context.message.regex[.*(\@)(\w+).*].group[2]>]>
      - narrate format:Sarah_F"<red><context.message.regex[.*(\@)(\w+).*].group[2]>" targets:%Targets%
      } else if <context.message.starts_with[Sarah,]> {
      - define Targets <player>
      } else {
      - define Targets <server.list_online_players>
      - wait 0.01
      - inject locally Control_Center
      }





# +----------------------------------
# |   Control Center
# +----------------------------------
    Control_Center:
# |   Questions
    # Who is Sarah
    - if <context.message.contains[who<&sp>are<&sp>you]> || <context.message.contains[what<&sp>are<&sp>you]> inject locally Who_Am_I
    # What time is it?
    - if <context.message.contains[what<&sp>time<&sp>is<&sp>it]> inject locally Current_Time
    # What am I looking at?
    - if <context.message.contains[what<&sp>am<&sp>i<&sp>looking<&sp>at]> || <context.message.contains[who<&sp>am<&sp>i<&sp>looking<&sp>at]> inject locally Looking_at
    # Where am I looking at?
    - if <context.message.contains[where<&sp>am<&sp>i<&sp>looking<&sp>at]> {
      - inject locally Looking_at_Location
      } else if <context.message.contains[where<&sp>am<&sp>i]> {
      - inject locally Location
      }
    # How far?
    - if <context.message.contains[how<&sp>far]> inject locally How_Far
    # How do I switch characters?
    - if <context.message.contains[switch<&sp>characters]> inject locally Switching_Characters
    # Character Commands
    - if <context.message.contains[character<&sp>commands]> inject locally Character_Help
    # What are the commands?
    - if <context.message.contains[commands]> || <context.message.contains[cmds]> inject locally Commands_Help
    # Who is ...?
    - if <context.message.contains[<&sp>who<&sp>is<&sp>]> inject locally Who_Is
    # 1 or 2?
    - if <context.message.contains[<&sp>or<&sp>]> inject locally 1_or_2
    # What races are there?
    - if <context.message.contains[<&sp>races]> inject locally Arithia_Races

# |   Commands
    # Reload SARAH
    - if <context.message.contains[load<&sp>data]> inject locally Sarah_Load
    # Reload Scripts
    - if <context.message.contains[load<&sp>scripts]> inject locally Reload_Scripts
    # Save SARAH
    - if <context.message.contains[save<&sp>data]> inject locally Sarah_Save
    # Delete Failed Messages
    - if <context.message.contains[<&sp>clear<&sp>my<&sp>failed]> ||  <context.message.contains[<&sp>clear<&sp>failed]>  || <context.message.contains[<&sp>remove<&sp>failed]> || <context.message.contains[<&sp>remove<&sp>all<&sp>failed]> || <context.message.contains[<&sp>clear<&sp>all<&sp>failed]> {
      - inject locally Sarah_Remove_Failed
    # Failed
      } else if <context.message.contains[<&sp>failed]> {
      - inject locally Sarah_Failed
      }
    # Add information manually
    - if <context.message.starts_with[Sarah,<&sp>add<&sp>]> || <context.message.starts_with[Sarah,<&sp>add<&sp>]> inject locally Sarah_Add_Data
    # Remove information manually
    - if <context.message.starts_with[Sarah,<&sp>remove<&sp>]> || <context.message.starts_with[Sarah,<&sp>remove<&sp>]> inject locally Sarah_Remove_Data
    # Set information manually
    - if <context.message.starts_with[Sarah,<&sp>set<&sp>]> || <context.message.starts_with[Sarah,<&sp>set<&sp>]> inject locally Sarah_Set_Data
    # Kick
    - if <context.message.starts_with[Sarah,<&sp>kick<&sp>]> || <context.message.starts_with[Sarah.<&sp>kick<&sp>]> inject locally CMD_Kick
    # ban
    - if <context.message.starts_with[Sarah,<&sp>ban<&sp>]> || <context.message.starts_with[Sarah.<&sp>ban<&sp>]> inject locally CMD_Ban
    # Tell (someone)
    - if <context.message.starts_with[Sarah,<&sp>tell<&sp>]> || <context.message.starts_with[Sarah.<&sp>tell<&sp>]> inject locally Tell_Player
    # Say
    - if <context.message.contains[Sarah,<&sp>say<&sp>]> || <context.message.contains[Sarah.<&sp>say<&sp>]> inject locally CMD_Say
    # countdown
    - if <context.message.contains[countdown]> inject locally CMD_Countdown
    # Day
    - if <context.message.contains[make<&sp>it<&sp>day]> || <context.message.contains[make<&sp>it<&sp>bright]> || <context.message.contains[make<&sp>it<&sp>shine]> inject locally CMD_Time_Day
    # Night
    - if <context.message.contains[make<&sp>it<&sp>night]> || <context.message.contains[make<&sp>it<&sp>dark]> inject locally CMD_Time_Night
    # Dawn
    - if <context.message.contains[make<&sp>it<&sp>morning]> inject locally CMD_Time_Dawn
    # Sun
    - if <context.message.contains[make<&sp>it<&sp>sunny]> || <context.message.contains[make<&sp>it<&sp>shine]> inject locally CMD_Weather_Sun
    # Storm
    - if <context.message.contains[make<&sp>it<&sp>rain]> || <context.message.contains[make<&sp>it<&sp>storm]> inject locally CMD_Weather_Storm
    # Website
    - if <context.message.contains[website]> inject locally CMD_Website


# |   Fun
    # Add quote
    - if <context.message.contains[add<&sp>quote<&sp>by<&sp>]> inject locally Fun_Add_Quote
    # Quote by
    - if <context.message.contains[quote<&sp>by<&sp>]> inject locally Fun_Quote_By
    # FUN quote
    - if <context.message.contains[show<&sp>me<&sp>a<&sp>quote]> || <context.message.contains[give<&sp>me<&sp>a<&sp>quote]> || <context.message.contains[<&sp>random<&sp>quote]> inject locally Fun_Random_quote
    # Slap
    - if <context.message.contains[<&sp>slap<&sp>]> inject locally Fun_Slap
    # Swag / Yolo
    - if <context.message.contains[swag]> || <context.message.contains[yolo]> inject locally Fun_bad_word
    - if <context.message.contains[love]> && <context.message.contains[you]> inject locally Fun_love_you


# |   Chatter
    # Thank you Sarah
    - if <context.message.contains[thank<&sp>you]> inject locally Chatter_Thank_You
    # World ending
    - if <context.message.contains[world<&sp>end]> || <context.message.contains[end<&sp>of<&sp>the<&sp>world]> inject locally Chatter_World_End
    # Penis
    - if <context.message.contains[penis]> inject locally Chatter_Penis
    # Dirty_Talk
    - if <context.message.contains[talk<&sp>dirty]> inject locally Chatter_dirty_Talk
    # Meaning of life
    - if <context.message.contains[meaning<&sp>of<&sp>life]> inject locally Chatter_Meaning_of_Life
    # Deal with it
    - if <context.message.contains[deal<&sp>with<&sp>it]> inject locally Chatter_Deal_With_it
    # Define What is
    - if <context.message.starts_with[Sarah,<&sp>define<&sp>]> || <context.message.starts_with[Sarah.<&sp>define<&sp>]> inject locally Define_What_Is
    # What is
    - if <context.message.starts_with[Sarah,<&sp>what<&sp>is<&sp>]> || <context.message.starts_with[Sarah.<&sp>what<&sp>is<&sp>]> inject locally What_Is


    # If the message, wasn't caught by any of the above. Save the message, so we can add it to Sarah, later.
    - define Number <yaml[Sarah_D].read[Statistics.Failed.Messages]>
    - narrate format:Sarah_F "Sorry I don't know that."
    - wait 1
    - narrate format:Sarah_F "I'm logging your message for self-improvement"
    - narrate format:Sarah_F "<red><player.name> <gray>logged a failed message<&co> <red><context.message>" targets:<server.list_online_ops>
    - yaml id:Sarah_D set Failed.Message:->:%Number%<&co><&sp><context.message>
    - yaml id:Sarah_D set Statistics.Failed.Messages:++
    - queue clear





# +----------------------------------
# |   Questions
# +----------------------------------

# |   Who is SARAH?
    Who_Am_I:
    - narrate format:Sarah_F "Hello, I am a" targets:%Targets%
    - wait 1
    - narrate "<gray><&sq><gold>S<yellow>elf <gold>A<yellow>ctuated <gold>R<yellow>eal-time <gold>A<yellow>utomated <gold>H<yellow>elper<gray><&sq> version 1.0, or <gold>Sarah <gray>for short" targets:%Targets%
    - wait 2
    - narrate format:Sarah_F "I am here to help you. If you need anything, you can always ask me." targets:%Targets%
    - wait 1
    - narrate format:Sarah_F "Even if I don't know the  answer, I will log your question and try to get the answer as soon as possible." targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Who_Am_I:++
    - queue clear


# |   What time is it?
    Current_Time:
    - narrate format:Sarah_F "It's currently <util.date.time.twentyfour_hour> <util.date>" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Current_Time:++
    - queue clear


# |   What am I looking at?
    Looking_at:
# Checking if you're looking at an entity
    - if <player.target.type> == Entity {
      - narrate format:Sarah_F "You're looking at a <player.target.entity_type.to_lowercase>" targets:%Targets%
# If you're not, it must be a material?
      } else {
      #- narrate format:Sarah_F "You're looking at a <player.location.cursor_on.material> id: <player.location.cursor_on.material.id>" targets:%Targets%
      }
    - yaml id:Sarah_D set Statistics.Requests.Looking_at:++
    - queue clear


# |   Where am I looking at?
    Looking_at_Location:
    - narrate format:Sarah_F "You're looking at <player.location.cursor_on.formatted>" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Looking_at_Location:++
    - queue clear


# |   How far away am I from this?
    How_Far:
    - narrate format:Sarah_F "You're <player.location.cursor_on.distance[<player.location>].as_int> blocks away from that" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.How_Far:++
    - queue clear


# |   Where am I?
    Location:
    - narrate format:Sarah_F "You're standing at <player.location.standing_on.formatted>" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Location:++
    - queue clear


# |   Who is ...?
    Who_Is:
    - define Player <context.message.regex[.*(\s)(who)(\s)(is)(\s)(\w+).*].group[6]>
# Check if we're looking into a player or a character 
    - if <server.list_online_players.contains[%Player%]> {
      - define Answer <server.match_player[%Player%].flag[Character]>
      - narrate format:Sarah_F "%Player% is currently playing as %Answer%" targets:%Targets%
      }
    - yaml id:Sarah_D set Statistics.Requests.Who_Is:++
    - queue clear


# |   Character Commands
    Character_Help:
    - narrate format:Sarah_F "Type <gold>/char help <gray>to see the character commands" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Character_Help:++
    - queue clear


# |   Commands
    Commands_Help:
    - narrate format:Sarah_F "You can find the commands on arithia at<&co> <aqua>http://www.arithia.com/commands" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Commands_Help:++
    - queue clear


# |   Switching Characters
    Switching_Characters:
    - narrate format:Sarah_F "You can use the following commands to switch between your different characters" targets:%Targets%
    - narrate format:Sarah_F "<gold>/char switch <red>(This only works if you have exactly 2 characters.)" targets:%Targets%
    - narrate format:Sarah_F "<gold>/char <&ns> <blue>(This will switch you to the character in a specific character slot number. e.g. /char 3)" targets:%Targets%
    - narrate format:Sarah_F "<gold>/char Character_Name <blue>(This will switch you to the character with that exact name.)" targets:%Targets%
    - narrate format:Sarah_F "type <gold>/char help <blue>to see more character commands" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Switching_Characters:++
    - queue clear


# |  Define What Is
    Define_What_Is:
    - inject locally Mod_Permission_Check
    - define Object <context.message.regex[.*(?i)(\s)(define)(\s)(\w+).*].group[4]>
    - define Definition <context.message.regex[.*(?i)(\s)(define)(\s)(\w+)(\s)(.*)].group[6]>
    - narrate format:Sarah_F "Defined a <&dq>%Object%<&dq> as<&co> %Definition%" targets:%Targets%
    - yaml id:Sarah_D set Definitions.%Object%:%Definition%
    - yaml id:Sarah_D set Statistics.Requests.Define_What_Is:++
    - queue clear


# |   What Is
    What_Is:
    - if '<context.message.regex[.*(?i)(\s)(what)(\s)(is)(\s)(\w+).*].group[6]>' == a {
      - define Object <context.message.regex[.*(?i)(\s)(what)(\s)(is)(\s)(a)(\s)(\w+).*].group[8]>
      } else if <context.message.regex[.*(?i)(\s)(what)(\s)(is)(\s)(\w+).*].group[6]> == an {
      - define Object <context.message.regex[.*(\s)(what)(\s)(is)(\s)(an)(\s)(\w+).*].group[8]>
      } else if <context.message.regex[.*(?i)(\s)(what)(\s)(is)(\s)(\w+).*].group[6]> == the {
      - define Object <context.message.regex[.*(?i)(\s)(what)(\s)(is)(\s)(the)(\s)(\w+).*].group[8]>
      } else {
      - define Object <context.message.regex[.*(?i)(\s)(what)(\s)(is)(\s)(\w+).*].group[6]>
      }
    - if !<yaml[Sarah_D].read[Definitions.%Object%]> {
      - narrate format:Sarah_F "Sorry, I don't know what that is."
      - wait 1
      - narrate format:Sarah_F "I'm logging a request for an answer."
      - narrate format:Sarah_F "<blue><player.name> <gray>logged a failed definition<&co> <blue><context.message>" targets:<server.list_online_ops>
      - yaml id:Sarah_D set Failed.Definition:->:<yaml[Sarah_D].read[Statistics.Failed.Definitions]><&co><&sp>%Object%
      - yaml id:Sarah_D set Statistics.Failed.Definitions:++
      - yaml id:Sarah_D set Statistics.Requests.What_Is:++
      - queue clear
      }
    - narrate format:Sarah_F "<yaml[Sarah_D].read[Definitions.%Object%]>" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.What_Is:++
    - queue clear


# |  1 or 2
    1_or_2:
    - random {
      - define Answer <context.message.regex[.*(?i)(\s)(\w+)(\s)(or)(\s)(\w+).*].group[2]>
      - define Answer <context.message.regex[.*(?i)(\w+)(\s)(or)(\s)(\w+).*].group[5]>
      }
    - narrate format:Sarah_F "%Answer%" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.1_or_2:++
    - queue clear

# |  Races
    Arithia_Races:
    - narrate format:Sarah_F "<green>Here are the races of Arithia."
    - foreach <yaml[Sarah_D].read[Arithia.Races]> {
      - narrate format:Sarah_F "%Value%"
      - wait 0.5
      }
    - yaml id:Sarah_D set Statistics.Requests.Arithia_Races:++
    - queue clear



# +----------------------------------
# |   Commands
# +----------------------------------

# |   Reload Sarah
    Sarah_Load:
    - run Load_Sarah
    - narrate format:Sarah_F "My systems have been reloaded."
    - yaml id:Sarah_D set Statistics.Requests.Sarah_reload:++
    - queue clear


# |   Reload Scripts
    Reload_Scripts:
    - execute as_player "denizen reload scripts"
    - narrate format:Sarah_F "Scripts have been reloaded."
    - yaml id:Sarah_D set Statistics.Requests.Reload_Scripts:++
    - queue clear


# |   Save Sarah
    Sarah_Save:
    - yaml "savefile:/Data/Sarah_Data.yml" id:Sarah_D
    - narrate format:Sarah_F "My systems have been saved."
    - yaml id:Sarah_D set Statistics.Requests.Sarah_Save:++
    - queue clear


# |   Failed Message handler
    Sarah_Failed:
    - if <yaml[Sarah_D].read[Failed.Message].size> == 0 && <yaml[Sarah_D].read[Failed.Definition].size> == 0 {
      - narrate format:Sarah_F "I don't have any Failed messages or definitions logged."
      - yaml id:Sarah_D set Statistics.Requests.Sarah_Failed_Messages:++
      - queue clear
      }
    - if <context.message.contains[message]> inject locally Sarah_Failed_Message
    - if <context.message.contains[definition]> inject locally Sarah_Failed_Definition
    - if !<context.message.contains[message]> && !<context.message.contains[definition]> {
      - inject locally Sarah_Failed_Message
      - inject locally Sarah_Failed_Definition
      }
    - queue clear

# |   Failed Messages
    Sarah_Failed_Message:
    - if <yaml[Sarah_D].read[Failed.Message].size> != 0 {
      - if <yaml[Sarah_D].read[Failed.Message].size> > 1 {
        - narrate Format:Sarah_F "I logged <yaml[Sarah_D].read[Failed.Message].size> Failed <red>Messages<gray><&co>"
        } else {
        - narrate Format:Sarah_F "I logged <yaml[Sarah_D].read[Failed.Message].size> Failed <red>Message<gray><&co>"
        }
      - flag player Failed_Number:1
      - wait 0.5
      - repeat <yaml[Sarah_D].read[Failed.Message].size> {
        - define Message <player.flag[Failed_Number].as_int>
        - narrate format:Sarah_F "<red><yaml[Sarah_D].read[Failed.Message].get[%Message%]>"
        - wait 1
        - flag player Failed_Number:++
        }
      } else {
      - narrate format:Sarah_F "I don't have any failed messages logged."
      }
    - flag player Failed_Number:!

# |   Failed Definitions
    Sarah_Failed_Definition:
    - if <yaml[Sarah_D].read[Failed.Definition].size> != 0 {
      - if <yaml[Sarah_D].read[Failed.Definition].size> > 1 {
        - narrate Format:Sarah_F "I logged <yaml[Sarah_D].read[Failed.Definition].size> Failed <blue>Definitions<gray><&co>"
        } else {
        - narrate Format:Sarah_F "I logged <yaml[Sarah_D].read[Failed.Definition].size> Failed <blue>Definition<gray><&co>"
        }
      - flag player Failed_Number:1
      - wait 0.5
      - repeat <yaml[Sarah_D].read[Failed.Definition].size> {
        - define Message <player.flag[Failed_Number].as_int>
        - narrate format:Sarah_F "<blue><yaml[Sarah_D].read[Failed.Definition].get[%Message%]>"
        - wait 1
        - flag player Failed_Number:++
        }
      } else {
      - narrate format:Sarah_F "I don't have any failed definitions logged."
      }
    - flag player Failed_Messsage:!
    - yaml id:Sarah_D set Statistics.Requests.Sarah_Failed_Messages:++


# |   Delete Messages
    Sarah_Remove_Failed:
# removing messages
    - if <context.message.contains[message]> {
      - if <context.message.regex[.*(?i)(\s)(\d+).*].group[2]> != null {
        - define Number <context.message.regex[.*(?i)(\s)(\d+).*].group[2]>
        - foreach <yaml[Sarah_D].read[Failed.Message]> {
          - if <def[value].starts_with[%Number%]> {
            - narrate format:Sarah_F "Removed Failed message<&co> %Number%"
            - yaml id:Sarah_D set Failed.Message:<-:%value%
            - yaml id:Sarah_D set Statistics.Requests.Sarah_Remove_Messages:++
            - queue clear
            }
          }
        } else {
        - narrate Format:Sarah_F "Cleared your <yaml[Sarah_D].read[Failed.Message].size> Failed messages."
        - yaml id:Sarah_D set Failed.Message:!
        - yaml id:Sarah_D set Failed.Message:->:Temp
        - yaml id:Sarah_D set Failed.Message:<-:Temp
        - yaml id:Sarah_D set Statistics.Requests.Sarah_Remove_Messages:++
        - queue clear
        }
      }
# removing definitions
    - if <context.message.contains[definition]> {
      - if <context.message.regex[.*(?i)(\s)(\d+).*].group[2]> != null {
        - define Number <context.message.regex[.*(?i)(\s)(\d+).*].group[2]>
        - foreach <yaml[Sarah_D].read[Failed.Definition]> {
          - if <def[value].starts_with[%Number%]> {
            - narrate format:Sarah_F "Removed Failed Definition<&co> %Number%"
            - yaml id:Sarah_D set Failed.Definition:<-:%value%
            - yaml id:Sarah_D set Statistics.Requests.Sarah_Remove_Messages:++
            - queue clear
            }
          }
        } else {
        - narrate Format:Sarah_F "Cleared your <yaml[Sarah_D].read[Failed.Definition].size> Failed Definitions."
        - yaml id:Sarah_D set Failed.Definition:!
        - yaml id:Sarah_D set Failed.Definition:->:Temp
        - yaml id:Sarah_D set Failed.Definition:<-:Temp
        - yaml id:Sarah_D set Statistics.Requests.Sarah_Remove_Messages:++
        - queue clear
        }
      }
    # if it doesn't contain message or defintions, we must assume you want to remove all.
    - narrate Format:Sarah_F "Cleared your <yaml[Sarah_D].read[Failed.Message].size> Failed messages."
    - wait 0.5
    - narrate Format:Sarah_F "Cleared your <yaml[Sarah_D].read[Failed.Definition].size> Failed Definitions."
    - yaml id:Sarah_D set Failed.Message:!
    - yaml id:Sarah_D set Failed.Message:->:Temp
    - yaml id:Sarah_D set Failed.Message:<-:Temp
    - yaml id:Sarah_D set Failed.Definition:!
    - yaml id:Sarah_D set Failed.Definition:->:Temp
    - yaml id:Sarah_D set Failed.Definition:<-:Temp
    - yaml id:Sarah_D set Statistics.Requests.Sarah_Remove_Messages:++
    - queue clear


# |   Add data manually
    Sarah_Add_Data:
    - define Path <context.message.regex[.*(add)(\s)([a-zA-Z.]+)(\s)(.*)].group[3]>
    - define Content <context.message.regex[.*(add)(\s)([a-zA-Z.]+)(\s)(.*)].group[5]>
    - narrate format:Sarah_F "Added %Content% to<&co> %Path%"
    - yaml id:Sarah_D set %Path%:->:%Content%
    - queue clear


# |   Remove data manually
    Sarah_Remove_Data:
    - define Path <context.message.regex[.*(remove)(\s)([a-zA-Z.]+)(\s)(.*)].group[3]>
    - define Content <context.message.regex[.*(remove)(\s)([a-zA-Z.]+)(\s)(.*)].group[5]>
    - narrate format:Sarah_F "Removed %Content% from<&co> %Path%"
    - yaml id:Sarah_D set %Path%:<-:%Content%
    - queue clear


# |   Set data manually
    Sarah_Set_Data:
    - define Path <context.message.regex[.*(set)(\s)([a-zA-Z.]+)(\s)(\w+).*].group[3]>
    - define Content <context.message.regex[.*(set)(\s)([a-zA-Z.]+)(\s)(\w+).*].group[5]>
    - narrate format:Sarah_F "%Path% to<&co> %Content%"
    - yaml id:Sarah_D set %Path%:%Content%
    - queue clear


# |   Website
    CMD_Website:
    - narrate format:Sarah_F "Our website is<&co> <gold>http://www.Arithia.com" targets:%Targets%
    - queue clear


# |   Kick
    CMD_Kick:
# Check permissions
    - inject locally Mod_Permission_Check
    - define Kicked_Player <context.message.regex[.*(?i)(\s)(kick)(\s)(\w+).*].group[4]>
    - define Kick_Reason <context.message.regex[.*(?i)(\s)(kick)(\s)(\w+)(\s)(.*)].group[6]>
    - execute as_server "kick %Kicked_Player% %Kick_Reason%"
    - narrate format:Sarah_F "You kicked %Kicked_Player% for %Kick_Reason%" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.CMD_Kick:++
    - queue clear


# |   Ban
    CMD_Ban:
# Check permissions
    - inject locally Mod_Permission_Check
    - define Banned_Player <context.message.regex[.*(?i)(\s)(ban)(\s)(\w+).*].group[3]>
    - define Ban_Reason <context.message.regex[.*(?i)(\s)(ban)(\s)(\w+)(\s)(.*)].group[5]>
    - execute as_server "ban %Banned_Player% %Ban_Reason%"
    - narrate format:Sarah_F "You kicked %Banned_Player% for %Ban_Reason%" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.CMD_Ban:++
    - queue clear


# |   Tell Player
    Tell_Player:
    - define Player <context.message.regex[.*(?i)(tell)(\s)(\w+).*].group[3]>
    - define Character <player.flag[Character]>
    - if <yaml[Players].read[Players.<player.name>.Characters.%Character%.Gender]> == Female {
      - define Gender she
      } else {
      - define Gender he
      }
    - if <context.message.starts_with[Sarah.<&sp>tell<&sp>%Player%<&sp>that<&sp>]> {
      - define Message <context.message.regex[.*(tell)(\s)(\w+)(\s)(\w+)(.*)].group[6].replace[<&sp>his<&sp>].with[<&sp>your<&sp>].replace[<&sp>him<&sp>].with[<&sp>you<&sp>].replace[<&sp>her<&sp>].with[<&sp>your<&sp>].replace[<&sp>he<&sp>is<&sp>].with[<&sp>you<&sp>are<&sp>].replace[<&sp>she<&sp>is<&sp>].with[<&sp>you<&sp>are<&sp>].replace[<&sp>he<&sp>has<&sp>].with[<&sp>you<&sp>have<&sp>].replace[<&sp>she<&sp>has<&sp>].with[<&sp>you<&sp>have<&sp>].replace[<&sp>he<&sq>s<&sp>].with[<&sp>you<&sq>re<&sp>].replace[<&sp>she<&sq>s<&sp>].with[<&sp>you<&sq>re<&sp>].replace[<&sp>he<&sp>].with[<&sp>you<&sp>].replace[<&sp>she<&sp>].with[<&sp>you<&sp>].replace[<&sp>I<&sp>don<&sq>t<&sp>].with[<&sp>he<&sp>doesn<&sq>t<&sp>].replace[<&sp>I<&sp>am<&sp>].with[<&sp>he<&sp>is<&sp>].replace[<&sp>I<&sq>m<&sp>].with[<&sp>%Gender%<&sq>s<&sp>].replace[<&sp>I<&sp>].with[<&sp>%Gender%<&sp>].replace[<&sp>takes<&sp>].with[<&sp>take<&sp>]>
      } else {
      - define Message <context.message.regex[.*(?i)(tell)(\s)(\w+)(.*)].group[4].replace[<&sp>his<&sp>].with[<&sp>your<&sp>].replace[<&sp>him<&sp>].with[<&sp>you<&sp>].replace[<&sp>her<&sp>].with[<&sp>your<&sp>].replace[<&sp>he<&sp>is<&sp>].with[<&sp>you<&sp>are<&sp>].replace[<&sp>she<&sp>is<&sp>].with[<&sp>you<&sp>are<&sp>].replace[<&sp>he<&sp>has<&sp>].with[<&sp>you<&sp>have<&sp>].replace[<&sp>she<&sp>has<&sp>].with[<&sp>you<&sp>have<&sp>].replace[<&sp>he<&sq>s<&sp>].with[<&sp>you<&sq>re<&sp>].replace[<&sp>she<&sq>s<&sp>].with[<&sp>you<&sq>re<&sp>].replace[<&sp>he<&sp>].with[<&sp>you<&sp>].replace[<&sp>she<&sp>].with[<&sp>you<&sp>].replace[<&sp>I<&sp>don<&sq>t<&sp>].with[<&sp>he<&sp>doesn<&sq>t<&sp>].replace[<&sp>I<&sp>am<&sp>].with[<&sp>he<&sp>is<&sp>].replace[<&sp>I<&sq>m<&sp>].with[<&sp>%Gender%<&sq>s<&sp>].replace[<&sp>I<&sp>].with[<&sp>%Gender%<&sp>].replace[<&sp>takes<&sp>].with[<&sp>take<&sp>]>
      }
    - narrate format:Sarah_F "%Player%, <player.name> told me that<&co> <green>%Message%" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Tell_Player:++
    - queue clear


# |   Say
    CMD_Say:
    - narrate format:Sarah_F "<context.message.regex[.*(?i)(say)(\s)(.*)].group[3]>"
    - yaml id:Sarah_D set Statistics.Requests.CMD_Say:++
    - queue clear


# |   Countdown
    CMD_Countdown:
    - define seconds <context.message.regex[.*(?i)(\s)(\d+).*].group[2]>
    - narrate format:Sarah_F "Counting down from<&co> <gold>%seconds%"
    - wait 1
    - repeat %seconds% {
      - narrate format:Sarah_F "%seconds%" targets:%Targets%
      - define seconds <def[seconds].sub[1]>
      - wait 1
      }
    - if <context.message.regex[.*(?i)(\s)(\d+)(\s)(\w+).*].group[4]> != 'null' {
      - define End_Text <context.message.regex[.*(?i)(\s)(\d+)(\s)(\w+).*].group[4]>
      - narrate format:Sarah_F "<green>%End_Text%"
      } else {
      - narrate format:Sarah_F "<green>Done"
      }
    - yaml id:Sarah_D set Statistics.Requests.CMD_Countdown:++
    - queue clear


# |   Weather sun
    CMD_Weather_Sun:
    - execute as_server "weather sun"
    - narrate format:Sarah_F "Making it sunny" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.CMD_Weather_Sun:++
    - queue clear


# |   Weather Storm
    CMD_Weather_Storm:
    - execute as_server "weather storm"
    - narrate format:Sarah_F "Making it stormy" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.CMD_Weather_Storm:++
    - queue clear


# |   Time Day
    CMD_Time_Day:
    - execute as_server "time set day"
    - narrate format:Sarah_F "Making it daytime" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.CMD_Time_Day:++
    - queue clear


# |   Time Night
    CMD_Time_Night:
    - execute as_server "time set night"
    - narrate format:Sarah_F "Making it night time" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.CMD_Time_Night:++
    - queue clear


# |   Time Dawn
    CMD_Time_Dawn:
    - execute as_server "time set dawn"
    - narrate format:Sarah_F "Making it morning" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.CMD_Time_Dawn:++
    - queue clear





# +----------------------------------
# |   Fun
# +----------------------------------

# |   Random Quote
    FUN_Random_Quote:
    - define Player <yaml[Sarah_D].list_keys[Fun.Quotes].random>
    - define Quote <yaml[Sarah_D].read[Fun.Quotes.%Player%].random>
    - narrate format:Sarah_F "<red>%Player%<&co> <gray><&dq>%Quote%<&dq>" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.FUN_Random_Quote:++
    - queue clear


# |   Quote by Player
    FUN_Quote_By:
    - define Player <context.message.regex[.*(?i)(\s)(quote)(\s)(by)(\s)(\w+).*].group[6]>
# Check if a keyword was specified
    - if <context.message.regex[.*(?i)(\s)(quote)(\s)(by)(\s)(\w+)(\s)(\w+).*].group[8]> != 'null' {
      - define Keyword <context.message.regex[.*(?i)(\s)(quote)(\s)(by)(\s)(\w+)(\s)(\w+).*].group[8]>
# for each value, check if it contains the keyword.
      - foreach <yaml[Sarah_D].read[Fun.Quotes.%Player%]> {
        - if %value% contains %Keyword% {
# if it does narrate them, 1 by 1
          - narrate format:Sarah_F "<red>%Player%<&co> <gray><&dq>%value%<&dq>" targets:%Targets%
          }
        }
      - yaml id:Sarah_D set Statistics.Requests.FUN_Quote_By:++
      - queue clear
      }
    - define quote <yaml[Sarah_D].read[Fun.Quotes.%Player%].random>
    - narrate format:Sarah_F "<red>%Player%<&co> <gray><&dq>%quote%<&dq>" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.FUN_Quote_By:++
    - queue clear


# |   Add quote
    Fun_Add_Quote:
    - narrate "<red>Attempting to add quote"
    - inject locally Mod_Permission_Check
    - define Player <context.message.regex[.*(?i)(\s)(add)(\s)(quote)(\s)(by)(\s)(\w+).*].group[8]>
    - define quote <context.message.regex[.*(?i)(\s)(add)(\s)(quote)(\s)(by)(\s)(\w+)(\s)(.*)].group[10]>
    - if %quote% == "null" || %Player% == "null" {
      - narrate format:Sarah_F "<red>Failed to add quote %Player% no quote or no Player found." targets:%Targets%
      - yaml id:Sarah_D set Statistics.Requests.Fun_Add_Quote:++
      - queue clear
      }
    - yaml id:Sarah_D set Fun.Quotes.%Player%:->:%quote%
    - narrate format:Sarah_F "Succesfully added quote by<&co> %Player% <&dq>%quote%<&dq>" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Fun_Add_Quote:++
    - queue clear


# |   Slap
    Fun_Slap:
    - inject locally Mod_Permission_Check
    - define Target <context.message.regex[.*(?i)(\s)(slap)(\s)(\w+).*].group[4]>
    - narrate format:Sarah_F "slapping<&co> <gold>%Target%" Targets:%Targets%
    - shoot <server.match_player[%Target%]> origin:<server.match_player[%Target%].location> destination:<server.match_player[%Target%].location.add[0,1.5,0]>
    - narrate format:Sarah_F "You've been slapped." Targets:<server.match_player[%Target%]>
    - narrate format:Sarah_F "You bad boy!" Targets:<server.match_player[%Target%]>
    - yaml id:Sarah_D set Statistics.Requests.Fun_Slap:++
    - queue clear


 # |   Swag / Yolo
    Fun_bad_word:
    - if <context.message.contains[swag]> {
      - define Bad_Word Swag
      } else {
      - define Bad_Word Yolo
      }
    - execute as_server "kick <player.name> saying %Bad_Word% to Sarah"
    - narrate format:Sarah_F "Kicked <player.name> for saying %Bad_Word%" targets:%Targets%
    - queue clear

 # |   I love you
    Fun_love_you:
    - if <player.name> == wonderdude {
      - narrate format:Sarah_F "I love you to master."
      } else {
      - narrate format:Sarah_F "I'm sorry <player.name> I'm not capable of loving anyone other than wonderdude" targets:%Targets%
      }
    - queue clear



# +----------------------------------
# |   Chatter
# +----------------------------------

# |   Thank you Sarah
    Chatter_Thank_You:
    - define Player <player.name>
    - random {
      - narrate format:Sarah_F "The pleasure was mine, %Player%" targets:%Targets%
      - narrate format:Sarah_F "The honour was mine, %Player%" targets:%Targets%
      }
    - yaml id:Sarah_D set Statistics.Requests.Chatter_Thank_You:++
    - queue clear


 # |   World end
    Chatter_World_End:
    - narrate format:Sarah_F "I don't know, but maybe we should put paper bags over our heads or something." targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Chatter_World_End:++
    - queue clear


 # |   Penis
    Chatter_Penis:
    - define Player <player.name>
    - narrate format:Sarah_F "I can't provide the sort of assistance I think you're asking for, %Player%" targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Chatter_Penis:++
    - queue clear


 # |   Dirty Talk
    Chatter_dirty_Talk:
    - narrate format:Sarah_F "Humus." targets:%Targets%
    - wait 1
    - narrate format:Sarah_F "Compost." targets:%Targets%
    - wait 1
    - narrate format:Sarah_F "Pomice." targets:%Targets%
    - wait 1
    - narrate format:Sarah_F "Slit." targets:%Targets%
    - wait 1
    - narrate format:Sarah_F "Gravel." targets:%Targets%
    - yaml id:Sarah_D set Statistics.Requests.Chatter_dirty_Talk:++
    - queue clear


 # |   Meaning of Life
    Chatter_Meaning_of_Life:
    - random {
      - narrate format:Sarah_F "A movie." targets:%Targets%
      - narrate format:Sarah_F "I can't answer that now, but give me some time to write a very long play in which nothing happens." targets:%Targets%
      - narrate format:Sarah_F "I give up." targets:%Targets%
      - narrate format:Sarah_F "That's easy... It's a philosophical question concerning the purpose and significance of life or existance in general." targets:%Targets%
      - narrate format:Sarah_F "I give up." targets:%Targets%
      - narrate format:Sarah_F "42." targets:%Targets%
      - narrate format:Sarah_F "To think about questions like this." targets:%Targets%
      - narrate format:Sarah_F "I find it odd that you would ask this of an inanimate object." targets:%Targets%
      - narrate format:Sarah_F "To serve Mark's bidding, or at least... that's what he told me." targets:%Targets%
      }
    - yaml id:Sarah_D set Statistics.Requests.Chatter_Meaning_of_Life:++
    - queue clear


 # |   Deal with it
    Chatter_Deal_With_it:
    - narrate format:Sarah_F "Dealt with..." targets:%Targets%
    - queue clear





# +----------------------------------
# |   Other
# +----------------------------------

# |   Mod_Permissions or above
    Mod_Permission_Check:
    - if <player.is_op> || <player.in_group[Mod]> || <player.in_group[Admin]> || <player.in_group[Owner]> {
# Do nothing and let it continue. Otherwise, stop the script
      } else {
      - narrate format:Sarah_F "<red>You don't have permission to use this. Your attempt has been recorded." targets:%Targets%
      - queue clear
      }





# +----------------------------------
# |   Sarah's formatting
# +----------------------------------

Sarah_F:
  type: format
  format: <dark_red>[<gold><bold>Sarah<&l><dark_red>]<gray> <text>