<triggers>
  <trigger
   enabled="y"
   group="Tests"
   keep_evaluating="y"
   match="^M - (.*)"
   regexp="y"
   send_to="12"
   sequence="100"
  >
  <send>
local monsters = utils.split ("%1", ",")

for k, v in ipairs (monsters) do
  Execute ("autokill " .. Trim (v))
end -- for

</send>
  </trigger>
</triggers>

M - wolf, adder, adder
autokill wolf
autokill adder
autokill adder
M - werewolf, zombie
autokill werewolf
autokill zombie
M - wolf, wolf, troglodyte
autokill wolf
autokill wolf
autokill troglodyte
M - troll
autokill troll

<triggers>
  <trigger
   enabled="y"
   group="Tests"
   match="M - *"
   send_to="12"
   sequence="100"
  >
  <send>

for k, v in ipairs (utils.split ("%1", ",")) do
  Execute ("autokill " .. Trim (v))
end -- for

</send>
  </trigger>
</triggers>

moblist = wait.regexp ("^M\ -\ (.*)", 1)
local mob = nil    
roomcleared = false
for mob in string.gmatch (moblist, "%a+") do

  local x = nil

  if not (mob == "M") then
    while not (x or giveup) do
      Send ("kill ", mob)
      x = wait.regexp ("^The .* (is slain!)|(flees in panic!)|(^There is no .* here\.)|(^You can\'t attack yourself!)", 1.2)
    end -- while

    -- After a kill, we send a short wait to
    -- prevent a "One moment please" message
    -- from coming up.
    wait.time (0.5)

  end -- end if
end -- for

ou have come to an intersection in the trail. To the south is a small cave,
with a sign over the opening that reads:"Scariton".

............
-----dn-----
 M   x    
[][]    [][]
  [] $  []
  []    []

M - frostbat

>kill M - frostbat
There is no M here.

You are at another bend in the trail. The makers of this path appear to have
been uncertain as to which way they wanted to go.

[]  |.......
[]  |.......
[]M |.......
[]  --------
[] x   $      
[][][][][][]

M - brigand, icetoad

>kill M - brigand
There is no M here.
>kill icetoad
You missed!

if (readytokill) then

  readytokill = false
 
  require "wait"

  wait.make (function ()
    
    -- This is our failsafe. With enough logic,
    -- this should never be needed. But just in
    -- case something goes sideways, we can type
    -- giveup to force our kill loop to stop.
    giveup = false

    -- Initialize moblist to nil
    local moblist = nil
 
    -- Have a look at the room to see if there is
    -- a line that starts with "M - ".
    Send ("look")

    -- If there is, that will become our list of
    -- mobs to kill.
    moblist = wait.regexp ("^M\ -\ (.*)", 1)

    moblist = utils.split (moblist, ",")
    
    if (moblist) then

    -- The ColourNote below is useful for following
    -- the logic. But it should be disabled for
    -- normal use.
    -- ColourNote ("white", "blue", moblist)


      -- Initialize mob variable to nil
      local mob = nil    
      roomcleared = false

      for k, mob in ipairs (moblist) do
      
        -- Initialize x variable to nil
        local x = nil

        -- The ColourNote below is useful for following
        -- the logic. But it should be disabled for
        -- normal use.
        ColourNote ("white", "blue", Trim (mob))
 
        -- Our main kill loop
        while not (x or giveup) do
          
          -- Keep hitting until the mob is
          -- dead or until the mob runs away.
          Send ("kill ", Trim (mob))

          -- So far we have 4 known reasons to
          -- quit hitting.
          -- 1.) Mob is slain!
          -- 2.) Mob has run away.
          -- 3.) We have stupidly tried to hit
          --     something that isn't there.
          -- 4.) We are trying to attack ourself!
          x = wait.regexp ("^The .* (is slain!)|(flees in panic!)|(^There is no .* here\.)|(^You can\'t attack yourself!)", 1.2)
          
        end -- while
        
        -- After a kill, we send a short wait to
        -- prevent a "One moment please" message
        -- from coming up.
        wait.time (0.5)

      
      end -- for

    else
      -- There was no "M - " line in the room, so 
      -- we'll just set the roomcleared variable to
      -- true and exit.
      roomcleared = true
      ColourNote ("white", "blue", "No mobs detected")
    end -- if (moblist)

     
    -- One of our conditions has been met.
    -- The mob was killed or it ran away.
    -- In either case, we are ready to kill
    -- again. So we set the readytokill
    -- variable back to true so this routine
    -- can be called again.
    readytokill = true
  
  end) -- end wait function

end -- end main if statement

 -- If there is, that will become our list of
    -- mobs to kill.
    moblist = wait.regexp ("^M\ -\ (.*)", 1)

    line, wildcards = wait.regexp ("^M\ -\ (.*)", 1)
    if line then
      moblist = wildcards [1]

      ...

    end -- if

-- General purpose on/off switch for
-- the whole routine.
if (readytokill) then
  
  require "wait"

  wait.make (function ()
    
    -- This is our failsafe. With enough logic,
    -- this should never be needed. But just in
    -- case something goes sideways, we can type
    -- giveup to force our kill loop to stop.
    giveup = false

    -- Initialize moblist to nil
    local moblist = nil
 
    -- Have a look at the room to see if there is
    -- a line that starts with "M - ".
    Send ("look")

    -- If there is, that will become our list of
    -- mobs to kill.
    -- The line variable is returned by wait.regexp
    -- and will have the entire line, including the
    -- "M - " part. The wildcards variable will only
    -- include the wildcard part of our line, which
    -- in this case will be a comma separated string
    -- of monster names. (e.g. owl, wolf, icetoad)
    line, wildcards = wait.regexp ("^M\ -\ (.*)", 1)

    -- If wait.regexp didn't return a line, then there
    -- was no "M - " line in this room. Presumably,
    -- this would mean the room is clear of mobs.
    if (line) then

      -- If wait.regexp does return a line, then we
      -- set the moblist equal to the wildcards.
      moblist = wildcards [1]

      -- Initialize mob variable to nil. This is our
      -- general purpose variable name that we'll use
      -- as we step through the list of mob names.
      local mob = nil    

      -- Tells other triggers that may be
      -- watching that the room is not
      -- clear. There is killing to be done.
      roomcleared = false

      -- Split the monster list into a table
      moblist = utils.split (moblist, ",")

      -- Cycle through our monster table one
      -- mob at a time.
      for k, mob in ipairs (moblist) do
      
        -- Initialize x variable to nil
        local x = nil

        -- Our main kill loop
        while not (x or giveup) do
          
          -- Keep hitting until the mob is
          -- dead or until the mob runs away.
          -- The Trim function removes white space
          -- around the monster name. So we will
          -- "kill owl" as opposed to "kill  owl "
          Send ("kill ", Trim (mob))

          -- So far we have 6 known reasons to
          -- quit hitting.
          -- 1.) Mob is slain!
          -- 2.) Mob has run away.
          -- 3.) We have specified an invalid target.
          -- 4.) We are trying to attack ourself!
          -- 5.) We are trying to attack inside a town.
          -- 6.) We did not specify a target.
          x = wait.regexp ("^The .* (is slain!)|(flees in panic!)|(^There is no .* here\.$)|(^You can\'t attack yourself!$)|(^A being clothed in white appears before you\.$)|(^Do what\.?$)", 1.5)
          
        end -- while
        
        -- After a kill, we send a short wait to
        -- prevent a "One moment please" message
        -- from coming up.
        wait.time (0.75)

      end -- for

    else
      -- There was no "M - " line in the room
      -- ColourNote here for troubleshooting only
      -- ColourNote ("white", "blue", "No mobs detected")
    end -- if (moblist)

     
    -- One of our conditions has been met.
    -- The mob was killed or it ran away.
    -- In either case, we are ready to kill
    -- again. So we set the readytokill
    -- variable back to true so this routine
    -- can be called again.
    readytokill = true
  
  end) -- end wait function

end -- end main if statement

>A wererat appears suddenly and attacks!

^\>?A (.*?) appears suddenly and attacks\!$

require "wait"

wait.make (function ()
  moblist = nil
  Send ("look")

  line, wildcards = wait.regexp ("^M\ -\ (.*)", 1)

  if (line) then
    moblist = wildcards [1]
    mob = nil
    roomcleared = false
    moblist = utils.split (moblist, ",")

    for k, mob in ipairs (moblist) do
      Execute ("autokill " .. Trim (mob))
    end

    roomcleared = true

  end -- if (line)
end) -- wait

if (readytokill) then

  readytokill = false
 
  require "wait"
  wait.make (function ()
    giveup = false
    local x = nil
    while not (x or giveup) do
      Send ("kill %1")

      -- So far we have 6 known reasons to
      -- quit hitting.
      -- 1.) Mob is slain!
      -- 2.) Mob has run away.
      -- 3.) We have specified an invalid target.
      -- 4.) We are trying to attack ourself!
      -- 5.) We are trying to attack inside a town.
      -- 6.) We did not specify a target.
      x = wait.regexp ("^The .* (is slain!)|(flees in panic!)|(^There is no .* here\.$)|(^You can\'t attack yourself!$)|(^A being clothed in white appears before you\.$)|(^Do what\.?$)", 1.2)
          
    end -- while
        
    wait.time (0.5)
    readytokill = true
  
  end) -- end wait function

end -- end main if statement

^\>?A (.*?) appears suddenly and attacks\!$

.*

.*?

(.*)

.*?

for k, mob in ipairs (moblist) do
  Execute ("autokill " .. Trim (mob))
end

M - wolf, adder, adder
M - werewolf, zombie
M - wolf, wolf, troglodyte
M - troll

<aliases>
  <alias
   name="GetMobList"
   match="getmoblist"
   enabled="y"
   group="Get Monster List"
   send_to="12"
   sequence="100"
  >
  <send>require "wait"

wait.make (function ()
    
  -- Initialize moblist to nil
  moblist = nil
 
  -- Have a look at the room to see if there is
  -- a line that starts with "M - ".
  Send ("look")

  -- If there is, that will become our list of
  -- mobs to kill.
  -- The line variable is returned by wait.regexp
  -- and will have the entire line, including the
  -- "M - " part. The wildcards variable will only
  -- include the wildcard part of our line, which
  -- in this case will be a comma separated string
  -- of monster names. (e.g. owl, wolf, icetoad)
  line, wildcards = wait.regexp ("^M\ -\ (.*)", 1)

  -- If wait.regexp didn't return a line, then there
  -- was no "M - " line in this room. Presumably,
  -- this would mean the room is clear of mobs.
  if (line) then

    -- If wait.regexp does return a line, then we
    -- set the moblist equal to the wildcards.
    moblist = wildcards [1]

    -- Initialize mob variable to nil. This is our
    -- general purpose variable name that we'll use
    -- as we step through the list of mob names.
    mob = nil

    -- Tells other triggers that may be
    -- watching that the room is not
    -- clear. There is killing to be done.
    roomcleared = false

    -- Split the monster list into a table
    moblist = utils.split (moblist, ",")

    -- Cycle through our monster table one
    -- mob at a time.
    -- The Trim function removes white space
    -- around the monster name. So we will
    -- "kill owl" as opposed to "kill  owl "
    for k, mob in ipairs (moblist) do
      Execute ("mobkillengine " .. Trim (mob))
    end

    -- Room should be free of mobs by now.
    roomcleared = true

  end -- if (line)

end) -- wait</send>
  </alias>
</aliases>

<aliases>
  <alias
   name="MobKillEngine"
   match="mobkillengine *"
   enabled="y"
   group="Kill Routines"
   send_to="12"
   keep_evaluating="y"
   sequence="100"
  >
  <send>-- If autokill is disabled, then forget this
-- whole routine. Presumably, autokill was
-- disabled so we can walk around without the
-- constant interruption of killing.

-- Also, if readytokill is disabled, then we
-- forget the whole routine as well. The main
-- reason readytokill would be disabled would
-- be due to the fact that we are Already
-- killing some other mob. We don't want our
-- killing to overlap, so when we start this
-- routine, we set readytokill to off so that
-- if it gets called a second time, the second
-- instance will just ignore it until the first
-- instance is done killing.

if (readytokill) then
--if (autokill and readytokill) then

  -- Autokill is on, and we are ready to kill.
  -- The first thing we do is set readytokill
  -- to false so another instance can't overlap. 
  readytokill = false
 
  require "wait"

  wait.make (function ()
    
    -- This is our failsafe. With enough logic,
    -- this should never be needed. But just in
    -- case something goes sideways, we can type
    -- giveup to force our kill loop to stop.
    giveup = false

    -- Initialize x variable to nil
    local x = nil

    -- Our main kill loop
    while not (x or giveup) do
          
      -- Keep hitting until the mob is
      -- dead or until the mob runs away.
      Send ("kill %1")

      -- So far we have 6 known reasons to
      -- quit hitting.
      -- 1.) Mob is slain!
      -- 2.) Mob has run away.
      -- 3.) We have specified an invalid target.
      -- 4.) We are trying to attack ourself!
      -- 5.) We are trying to attack inside a town.
      -- 6.) We did not specify a target.
      x = wait.regexp ("^The .* (is slain!)|(flees in panic!)|(^There is no .* here\.$)|(^You can\'t attack yourself!$)|(^A being clothed in white appears before you\.$)|(^Do what\.?$)", 1.2)
          
    end -- while
        
    -- After a kill, we send a short wait to
    -- prevent a "One moment please" message
    -- from coming up.
    wait.time (0.5)

    -- One of our conditions has been met.
    -- The mob was killed or it ran away.
    -- In either case, we are ready to kill
    -- again. So we set the readytokill
    -- variable back to true so this routine
    -- can be called again.
    readytokill = true
  
  end) -- end wait function

end -- end main if statement</send>
  </alias>
</aliases>

<triggers>
  <trigger
   enabled="y"
   group="Monster List for Auto-Killing"
   match="^\&gt;?A (.*?) appears suddenly and attacks!$"
   name="MobAppearsSuddenly"
   regexp="y"
   send_to="12"
   sequence="100"
  >
  <send>Execute ("mobkillengine %1")</send>
  </trigger>
</triggers>

    -- Cycle through our monster table one
    -- mob at a time.
    -- The Trim function removes white space
    -- around the monster name. So we will
    -- "kill owl" as opposed to "kill  owl "
    for k, mob in ipairs (moblist) do
      Execute ("mobkillengine " .. Trim (mob))
    end

mobkillengine wolf
mobkillengine adder
mobkillengine adder

-- Also, if readytokill is disabled, then we
-- forget the whole routine as well. The main
-- reason readytokill would be disabled would
-- be due to the fact that we are Already
-- killing some other mob. We don't want our
-- killing to overlap, so when we start this
-- routine, we set readytokill to off so that
-- if it gets called a second time, the second
-- instance will just ignore it until the first
-- instance is done killing.