}
static dgn_event_type dgn_param_to_event_type(lua_State *ls, int n)
{
    if (lua_isnumber(ls, n))
        return (static_cast<dgn_event_type>(luaL_checkint(ls, n)));
    else if (lua_isstring(ls, n))
        return dgn_event_type_by_name(lua_tostring(ls, n));
    else
        return (DET_NONE);
}
static int dgn_dgn_event_is_global(lua_State *ls)
{
    lua_pushboolean(ls, dgn_param_to_event_type(ls, 1) & DET_GLOBAL_MASK);
    return (1);

static int dgn_dgn_event_is_position(lua_State *ls)
{
    lua_pushboolean(ls, dgn_param_to_event_type(ls, 1) & DET_POSITION_MASK);
    return (1);
}

{ "dgn_event_type", dgn_dgn_event },

{ "dgn_event_type",        dgn_dgn_event },
{ "dgn_event_is_global",   dgn_dgn_event_is_global },
{ "dgn_event_is_position", dgn_dgn_event_is_position},

    DET_WALL_HIT        = 0x1000

    DET_WALL_HIT        = 0x1000,
    DET_GLOBAL_MASK     = DET_TURN_ELAPSED | DET_LEAVING_LEVEL
                        | DET_ENTERING_LEVEL | DET_ENTERED_LEVEL
                        | DET_MONSTER_DIED,
    DET_POSITION_MASK   = DET_MONSTER_MOVED | DET_PLAYER_MOVED
                        | DET_PLAYER_IN_LOS | DET_ITEM_PICKUP
                        | DET_ITEM_MOVED | DET_FEAT_CHANGE | DET_WALL_HIT

MARKER:  o = lua:monster_on_trigger { \

MARKER:  o = lua:monster_on_death { \

end
-- Copied from http://lua-users.org/wiki/CopyTable
function util.copy_table(object)
  local lookup_table = {}
  local function _copy(object)
    if type(object) ~= "table" then
      return object
    elseif lookup_table[object] then
      return lookup_table[object]
    end
    local new_table = {}
    lookup_table[object] = new_table
    for index, value in pairs(object) do
      new_table[_copy(index)] = _copy(value)
    end
    return setmetatable(new_table, getmetatable(object))
  end
  return _copy(object)

require('clua/lm_trig.lua')

------------------------------------------------------------------------------
-- dungeon.lua:
-- DgnTriggerers and triggerables:
--
-- This is similar to the overvable/observer design pattern: a triggerable
-- class which does something and a triggerrer which sets it off.  As an
-- example, the ChangeFlags class (clua/lm_flags.lua), rather than having
-- three subclasses (for monster death, feature change and item pickup)
-- needs no subclasses, but is just one class which is given triggerers
-- which listen for different events.  Additionally, new types of triggerers
-- can be developed and used without have to update the ChangeFlags code.
--
-- Unlike with the overvable/observer design pattern, each triggerer is
-- associated with a signle triggerable, rather than there being one observable
-- and multiple observers, since each triggerer might have a data payload which
-- is meant to be different for each triggerable.
--
-- A triggerable class just needs to subclass Triggerable and define an
-- "on_trigger" method.
------------------------------------------------------------------------------
Triggerable = { CLASS = "Triggerable" }
Triggerable.__index = Triggerable
function Triggerable:new()
  local tr = { }
  setmetatable(tr, self)
  self.__index = self
  tr.triggerers        = { }
  tr.dgn_trigs_by_type = { }
  return tr
end
function Triggerable:add_triggerer(triggerer)
  if not triggerer.type then
    error("triggerer has no type")
  end
  table.insert(self.triggerers, triggerer)
  if (triggerer.method == "dgn_event") then
    local et = dgn.dgn_event_type(triggerer.type)
    if not self.dgn_trigs_by_type[et] then
      self.dgn_trigs_by_type[et] = {}
    end
    table.insert(self.dgn_trigs_by_type[et], #self.triggerers)
  else
    local method = triggerer.method or "(nil)"
    local class
    local meta = getmetatable(triggerer)
    if not meta then
      class = "(no meta table)"
    elseif not meta.CLASS then
      class = "(no class name)"
    end
    error("Unknown triggerer method '" .. method .. "' for trigger class '"
          .. class .. "'")
  end
  triggerer:added(self)
end
function Triggerable:move(marker, dest, y)
  local was_activated = self.activated
  self:remove_all_triggerers(marker)
  -- XXX: Are coordinated passed around as single objects?
  if y then
    marker:move(dest, y)
  else
    marker:move(dest)
  end
  if was_activated then
    self.activated = false
    self:activate(marker)
  end
end
function Triggerable:remove(marker)
  if self.removed then
    error("Trigerrable already removed")
  end
  self:remove_all_triggerers(marker)
  dgn.remove_marker(marker)
  self.removed = true
end
function Triggerable:remove_all_triggerers(marker)
  for _, trig in ipairs(self.triggerers) do
    trig:remove(self, marker)
  end
end
function Triggerable:activate(marker)
  if self.removed then
    error("Can't activate, trigerrable removed")
  end
  if self.activating then
    error("Triggerable already activating")
  end
  if self.activated then
    error("Triggerable already activated")
  end
  self.activating = true
  for _, trig in ipairs(self.triggerers) do
    trig:activate(self, marker)
  end
  self.activating = false
  self.activated  = true
end
function Triggerable:event(marker, ev)
  local et = ev:type()
  local trig_list = self.dgn_trigs_by_type[et]
  if not trig_list then
    local class  = getmetatable(self).CLASS
    local x, y   = marker:pos()
    local e_type = dgn.dgn_event_type(et)
    error("Triggerable type " .. class .. " at (" ..x .. ", " .. y .. ") " ..
           "has no triggerers for dgn_event " .. e_type )
  end
  for _, trig_idx in ipairs(trig_list) do
    self.triggerers[trig_idx]:event(self, marker, ev)
    if self.removed then
      return
    end
  end
end
function Triggerable:write(marker, th)
  file.marshall(th, #self.triggerers)
  for _, trig in ipairs(self.triggerers) do
    -- We'll be handling the de-serialization of the triggerer, so we need to
    -- save the class name.
    file.marshall(th, getmetatable(trig).CLASS)
    trig:write(marker, th)
  end
  lmark.marshall_table(th, self.dgn_trigs_by_type)
end
function Triggerable:read(marker, th)
  self.triggerers = {}
  local num_trigs = file.unmarshall_number(th)
  for i = 1, num_trigs do
    -- Hack to let triggerer classes de-serialize themselves.
    local trig_class    = file.unmarshall_string(th)
    -- _G is the global symbol table, and the class name of the triggerer is
    -- the name of that class's class object
    local trig_table = _G[trig_class].read(nil, marker, th)
    table.insert(self.triggerers, trig_table)
  end
  self.dgn_trigs_by_type = lmark.unmarshall_table(th)
  setmetatable(self, Triggerable)
  return self
end
-------------------------------------------------------------------------------
-- NOTE: The CLASS string of a triggerer class *MUST* be exactly the same as
-- the triggerer class name, or it won't be able to deserialize properly.
--
-- NOTE: A triggerer shouldn't store a reference to the triggerable it
-- belongs to, and if it does then it must not save/restore that reference.
-------------------------------------------------------------------------------
-- DgnTriggerer listens for dungeon events of these types:
--
-- * monster_dies: Waits for a monster to die.  Needs the parameter
--       "target", who's value is the name of the monster who's death
--       we're wating for.  Doesn't matter where the triggerable/marker
--       is placed.
--
-- * feat_change: Waits for a cell's feature to change.  Accepts the
--       optional parameter "target", which if set delays the trigger
--       until the feature the cell turns into contains the target as a
--       substring.  The triggerable/marker must be placed on top of the
--       cell who's feature you wish to monitor.
--
-- * item_moved: Wait for an item to move from one cell to another.
--      Needs the parameter "target", who's value is the name of the
--      item that is being tracked.  The triggerable/marker must be placed
--      on top of the cell containing the item.
--
-- * item_pickup: Wait for an item to be picked up.  Needs the parameter
--      "target", who's value is the name of the item that is being tracked.
--      The triggerable/marker must be placed on top of the cell containing
--      the item.  Automatically takes care of the item moving from one
--      square to another without being picked up.
DgnTriggerer = { CLASS = "DgnTriggerer" }
DgnTriggerer.__index = DgnTriggerer
function DgnTriggerer:new(pars)
  pars = pars or {}
  if not pars.type then
    error("DgnTriggerer must have a type")
  end
  if pars.type == "monster_dies" or pars.type == "item_moved"
     or pars.type == "item_pickup"
  then
    if not pars.target then
      error(pars.type .. " DgnTriggerer must have parameter 'target'")
    end
  end
  local tr = util.copy_table(pars)
  setmetatable(tr, self)
  self.__index = self
  tr:setup()
  return tr
end
function DgnTriggerer:setup()
  self.method = "dgn_event"
end
function DgnTriggerer:added(triggerable)
  if self.type == "item_pickup" then
    -- Automatically move the triggerable if the item we're watching is moved
    -- before it it's picked up.
    local mover = util.copy_table(self)
    mover.type         = "item_moved"
    mover.marker_mover = true
    triggerable:add_triggerer( DgnTriggerer:new(mover) )
  end
end
function DgnTriggerer:activate(triggerable, marker)
  if not (triggerable.activated or triggerable.activating) then
    error("DgnTriggerer:activate(): triggerable is not activated")
  end
  local et = dgn.dgn_event_type(self.type)
  if (dgn.dgn_event_is_position(et)) then
    dgn.register_listener(et, marker, marker:pos())
  else
    dgn.register_listener(et, marker)
  end
end
function DgnTriggerer:remove(triggerable, marker)
  if not triggerable.activated then
    return
  end
  local et = dgn.dgn_event_type(self.type)
  if (dgn.dgn_event_is_position(et)) then
    dgn.remove_listener(marker, marker:pos())
  else
    dgn.remove_listener(marker)
  end
end
function DgnTriggerer:event(triggerable, marker, ev)
  if self.type == "monster_dies" then
    local midx = ev:arg1()
    local mons = dgn.mons_from_index(midx)
    if not mons then
      error("DgnTriggerer:event() didn't get a valid monster index")
    end
    if mons.name == self.target then
      triggerable:on_trigger(self, marker, ev)
    end
  elseif self.type == "feat_change" then
    if self.target and self.target ~= "" then
      local feat = dgn.feature_name(dgn.grid(ev:pos()))
      if not string.find(feat, self.target) then
        return
      end
    end
    triggerable:on_trigger(self, marker, ev)
  elseif self.type == "item_moved" then
    local obj_idx = ev:arg1()
    local it      = dgn.item_from_index(obj_idx)
    if not it then
      error("DgnTriggerer:event() didn't get a valid item index")
    end
    if item.name(it) == self.target then
      if self.marker_mover then
        -- We only exist to move the triggerable if the item moves
        triggerable:move(marker, ev:dest())
      else
        triggerable:on_trigger(self, marker, ev)
      end
    end
  elseif self.type == "item_pickup" then
    local obj_idx = ev:arg1()
    local it      = dgn.item_from_index(obj_idx)
    if not it then
      error("DgnTriggerer:event() didn't get a valid item index")
    end
    if item.name(it) == self.target then
      triggerable:on_trigger(self, marker, ev)
    end
  else
    local e_type = dgn.dgn_event_type(et)
    error("DgnTriggerer can't handle events of type " .. e_type)
  end
end
function DgnTriggerer:write(marker, th)
  -- Will always be "dgn_event", so we don't need to save it.
  self.method = nil
  lmark.marshall_table(th, self)
end
function DgnTriggerer:read(marker, th)
  local tr = lmark.unmarshall_table(th)
  setmetatable(tr, DgnTriggerer)
  tr:setup()
  return tr
end

--------------------------------------------------------------------------------------
-- This marker creates a monster on certain events.  It uses the following parameters:

-------------------------------------------------------------------------------
-- This marker creates a monster on certain events.  It uses the following
-- parameters:

-- * death_monster: The name of the monster who's death triggers the creation of
--       the new monster.

-- * death_monster: The name of the monster who's death triggers the creation
--       of the new monster.

--------------------------------------------------------------------------------------

-------------------------------------------------------------------------------

--  * Be triggered more than once.

MonsterOnTrigger = { CLASS = "MonsterOnTrigger" }
MonsterOnTrigger.__index = MonsterOnTrigger

require('clua/lm_trig.lua')

function MonsterOnTrigger:_new()
  local pm = { }
  setmetatable(pm, self)
  self.__index = self
  return pm
end

MonsterOnTrigger       = util.subclass(Triggerable)
MonsterOnTrigger.CLASS = "MonsterOnTrigger"

  if not pars.death_monster or pars.death_monster == "" then
    error("Must provide death_monster")
  end

  local pm = self:_new()
  pm.message_seen    = pars.message_seen
  pm.message_unseen  = pars.message_unseen
  pm.death_monster   = pars.death_monster
  pm.new_monster     = pars.new_monster
  pm.props           = pars

  local mot = self.super.new(self)
  mot.message_seen    = pars.message_seen
  mot.message_unseen  = pars.message_unseen
  mot.death_monster   = pars.death_monster
  mot.new_monster     = pars.new_monster
  mot.props           = pars

  return pm

  return mot

  lmark.marshall_table(th, self)

  MonsterOnTrigger.super.write(self, marker, th)
  file.marshall(th, self.message_seen)
  file.marshall(th, self.message_unseen)
  file.marshall(th, self.new_monster)
  lmark.marshall_table(th, self.props)

  return MonsterOnTrigger:new(lmark.unmarshall_table(th))

  MonsterOnTrigger.super.read(self, marker, th)
  self.message_seen   = file.unmarshall_string(th)
  self.message_unseen = file.unmarshall_string(th)
  self.new_monster    = file.unmarshall_string(th)
  self.props          = lmark.unmarshall_table(th)
  setmetatable(self, MonsterOnTrigger) 
  return self

function MonsterOnTrigger:on_trigger(triggerer, marker, ev)
  local x,     y     = marker:pos()
  local you_x, you_y = you.pos()

function MonsterOnTrigger:activate(marker)
  dgn.register_listener(dgn.dgn_event_type('monster_dies'), marker)
end

  if x == you_x and y == you_y then
    return
  end
  if dgn.mons_at(x, y) then
    return
  end

function MonsterOnTrigger:event(marker, ev)
  local midx = ev:arg1()
  local mons = dgn.mons_from_index(midx)

  -- you.losight() seems to be necessary if the player has been moved by
  -- a wizard command and then the marker triggered by another wizard
  -- command, since then no turns will have been taken and the LOS info
  -- won't have been updated.
  you.losight()
  local see_cell = you.see_cell(x, y)

  if not mons then
    error("MonsterOnTrigger:event() didn't get a valid monster index")

  if (not dgn.create_monster(x, y, self.new_monster)) then
    return
  elseif self.message_seen ~= "" and see_cell then
    crawl.mpr(self.message_seen)
  elseif self.message_unseen ~= "" and not see_cell then
    crawl.mpr(self.message_unseen)

  if mons.name == self.death_monster then
    local x,     y     = marker:pos()
    local you_x, you_y = you.pos()

  self:remove(marker)
end

    if x == you_x and y == you_y then
      return
    end

function monster_on_death(pars)
  local death_monster = pars.death_monster or pars.target

    -- you.losight() seems to be necessary if the player has been moved by
    -- a wizard command and then the marker triggered by another wizard
    -- command, since then no turns will have been taken and the LOS info
    -- won't have been updated.
    you.losight()
    local see_cell = you.see_cell(x, y)

  pars.death_monster = nil
  pars.target        = nil

    if (not dgn.create_monster(x, y, self.new_monster)) then
      return
    elseif self.message_seen ~= "" and see_cell then
      crawl.mpr(self.message_seen)
    elseif self.message_unseen ~= "" and not see_cell then
      crawl.mpr(self.message_unseen)
    end

  local mod = MonsterOnTrigger:new(pars)

    dgn.remove_listener(marker)
    dgn.remove_marker(marker)
  end
end

  mod:add_triggerer(
                     DgnTriggerer:new {
                       type   = "monster_dies",
                       target = death_monster
                     }
                   )

function monster_on_trigger(pars)
  return MonsterOnTrigger:new(pars)

  return mod

--
-- ChangeFlags is a Triggerable subclass, and the above three functions
-- are just convenience functions which add a single triggerer.  Other
-- triggerers (or more than one) can be added.

 
ChangeFlags = { CLASS = "ChangeFlags" }
ChangeFlags.__index = ChangeFlags

function ChangeFlags:_new()
  local cf = { }
  setmetatable(cf, self)
  self.__index = self

require('clua/lm_trig.lua')

  return cf
end

ChangeFlags       = util.subclass(Triggerable)
ChangeFlags.CLASS = "ChangeFlags"

  local cf = self.super.new(self)

  if pars.level_flags == "" and pars.branch_flags == ""
    and not pars.trigger
  then
    error("Must provide at least one of level_flags, branch_flags, or trigger.")

  if pars.level_flags == "" and pars.branch_flags == "" then
    error("Must provide at least one of level_flags or branch_flags.")

  local cf = self:_new()

  cf.trigger      = pars.trigger

function ChangeFlags:do_change(marker)

function ChangeFlags:on_trigger(triggerer, marker, ev)

  if self.trigger then
    self.trigger(marker)
  end

  self:remove(marker)

  ChangeFlags.super.write(self, marker, th)

  file.marshall_meta(th, self.trigger)

  ChangeFlags.super.read(self, marker, th)

  self.trigger      = file.unmarshall_meta(th)

MonDiesChangeFlags = ChangeFlags:_new()
MonDiesChangeFlags.__index = MonDiesChangeFlags
function MonDiesChangeFlags:_new(pars)
  local mdcf
  if pars then
    mdcf = ChangeFlags:new(pars)
  else
    mdcf = ChangeFlags:_new()
  end
    
  setmetatable(mdcf, self)
  self.__index = self
  return mdcf
end
function MonDiesChangeFlags:new(pars)
  pars = pars or { }
  if not pars.mon_name then
    error("No monster name provided.")
  end
  local mdcf = self:_new(pars)
  mdcf.mon_name = pars.mon_name
  return mdcf
end
function MonDiesChangeFlags:activate(marker)
  dgn.register_listener(dgn.dgn_event_type('monster_dies'), marker)
end
function MonDiesChangeFlags:event(marker, ev)
  local midx = ev:arg1()
  local mons = dgn.mons_from_index(midx)
  if not mons then
    error("MonDiesChangeFlags:event() didn't get a valid monster index")
  end

  if mons.name == self.mon_name then
    ChangeFlags.do_change(self, marker)
    dgn.remove_listener(marker)
    dgn.remove_marker(marker)
  end
end
function MonDiesChangeFlags:write(marker, th)
  ChangeFlags.write(self, marker, th)
  file.marshall(th, self.mon_name)
end
function MonDiesChangeFlags:read(marker, th)
  ChangeFlags.read(self, marker, th)
  self.mon_name  = file.unmarshall_string(th)
  setmetatable(self, MonDiesChangeFlags) 
  return self
end

  return MonDiesChangeFlags:new(pars)
end

  local mon_name = pars.mon_name or pars.target

-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
FeatChangeChangeFlags = ChangeFlags:_new()
FeatChangeChangeFlags.__index = FeatChangeChangeFlags

  pars.mon_name = nil
  pars.target   = nil

function FeatChangeChangeFlags:_new(pars)
  local fccf

  local cf = ChangeFlags:new(pars)

  if pars then
    fccf = ChangeFlags:new(pars)
  else
    fccf = ChangeFlags:_new()
  end
    
  setmetatable(fccf, self)
  self.__index = self

  cf:add_triggerer(
                    DgnTriggerer:new {
                      type   = "monster_dies",
                      target = mon_name
                    }
                  )

  return fccf

  return cf

function FeatChangeChangeFlags:new(pars)
  pars = pars or { }
  local fccf = self:_new(pars)
  fccf.final_feat = pars.final_feat
  return fccf
end
function FeatChangeChangeFlags:activate(marker)
  dgn.register_listener(dgn.dgn_event_type('feat_change'), marker,
                        marker:pos())
end
function FeatChangeChangeFlags:event(marker, ev)
  if self.final_feat and self.final_feat ~= "" then
    local feat = dgn.feature_name(dgn.grid(ev:pos()))
    if not string.find(feat, self.final_feat) then
      return
    end
  end
  ChangeFlags.do_change(self, marker)
  dgn.remove_listener(marker, marker:pos())
  dgn.remove_marker(marker)
end
function FeatChangeChangeFlags:write(marker, th)
  ChangeFlags.write(self, marker, th)
  file.marshall(th, self.final_feat)
end
function FeatChangeChangeFlags:read(marker, th)
  ChangeFlags.read(self, marker, th)
  self.final_feat = file.unmarshall_string(th)
  setmetatable(self, FeatChangeChangeFlags) 
  return self
end

  return FeatChangeChangeFlags:new(pars)
end

  local final_feat = pars.final_feat or pars.target

--------------------------------------------------------------------------
--------------------------------------------------------------------------

  pars.final_feat = nil
  pars.target     = nil

ItemPickupChangeFlags = ChangeFlags:_new()
ItemPickupChangeFlags.__index = ItemPickupChangeFlags

  local cf = ChangeFlags:new(pars)

function ItemPickupChangeFlags:_new(pars)
  local ipcf
  if pars then
    ipcf = ChangeFlags:new(pars)
  else
    ipcf = ChangeFlags:_new()
  end
    
  setmetatable(ipcf, self)
  self.__index = self

  cf:add_triggerer(
                    DgnTriggerer:new {
                      type   = "feat_change",
                      target = final_feat
                    }
                  )

  return ipcf

  return cf

function ItemPickupChangeFlags:new(pars)
  pars = pars or { }
  if not pars.item then
    error("No item name provided.")
  end
  local ipcf = self:_new(pars)
  ipcf.item = pars.item
  return ipcf
end
function ItemPickupChangeFlags:activate(marker)
  dgn.register_listener(dgn.dgn_event_type('item_pickup'), marker,
                        marker:pos())
  dgn.register_listener(dgn.dgn_event_type('item_moved'), marker,
                        marker:pos())
end
function ItemPickupChangeFlags:event(marker, ev)
  local obj_idx  = ev:arg1()
  local it       = dgn.item_from_index(obj_idx)
  if not it then
    error("ItemPickupChangeFlags:event() didn't get a valid item index")
  end
  if item.name(it) == self.item then
    local picked_up = ev:type() == dgn.dgn_event_type('item_pickup')
    if picked_up then
      ChangeFlags.do_change(self, marker)
      dgn.remove_listener(marker, marker:pos())
      dgn.remove_marker(marker)
    else
      dgn.remove_listener(marker, marker:pos())
      marker:move(ev:dest())
      self:activate(marker)
    end
  end
end

function item_pickup_change_flags(pars)
  local item = pars.item or pars.target

function ItemPickupChangeFlags:write(marker, th)
  ChangeFlags.write(self, marker, th)
  file.marshall(th, self.item)
end

  pars.item   = nil
  pars.target = nil

function ItemPickupChangeFlags:read(marker, th)
  ChangeFlags.read(self, marker, th)
  self.item  = file.unmarshall_string(th)
  setmetatable(self, ItemPickupChangeFlags) 

  local cf = ChangeFlags:new(pars)

  return self
end

  cf:add_triggerer(
                    DgnTriggerer:new {
                      type   = "item_pickup",
                      target = item
                    }
                  )

function item_pickup_change_flags(pars)
  return ItemPickupChangeFlags:new(pars)

  return cf