crawl-ref/source/dgnevent.cc

   1 /*
   2  *  File:       dgnevent.cc
   3  *  Summary:    General dungeon events.
   4  *  Created by: dshaligram on Sat Jul 21 12:17:29 2007 UTC
   5  */
   6
   7 #include "AppHdr.h"
   8
   9 #include "dgnevent.h"
  10
  11 #include "coord.h"
  12 #include <algorithm>
  13
  14 dgn_event_dispatcher dungeon_events;
  15
  16 void dgn_event_dispatcher::clear()
  17 {
  18     global_event_mask = 0;
  19     listeners.clear();
  20     for (int y = 0; y < GYM; ++y)
  21         for (int x = 0; x < GXM; ++x)
  22             grid_triggers[x][y].reset(NULL);
  23 }
  24
  25 void dgn_event_dispatcher::clear_listeners_at(const coord_def &pos)
  26 {
  27     grid_triggers[pos.x][pos.y].reset(NULL);
  28 }
  29
  30 void dgn_event_dispatcher::move_listeners(
  31     const coord_def &from, const coord_def &to)
  32 {
  33     // Any existing listeners at to will be discarded. YHBW.
  34     grid_triggers[to.x][to.y] = grid_triggers[from.x][from.y];
  35 }
  36
  37 bool dgn_event_dispatcher::has_listeners_at(const coord_def &pos) const
  38 {
  39     return (grid_triggers[pos.x][pos.y].get());
  40 }
  41
  42 bool dgn_event_dispatcher::fire_vetoable_position_event(
  43     dgn_event_type et, const coord_def &pos)
  44 {
  45     const dgn_event event(et, pos);
  46     return fire_vetoable_position_event(event, pos);
  47 }
  48
  49 bool dgn_event_dispatcher::fire_vetoable_position_event(
  50     const dgn_event &et, const coord_def &pos)
  51 {
  52     dgn_square_alarm *alarm = grid_triggers[pos.x][pos.y].get();
  53     if (alarm && (alarm->eventmask & et.type))
  54     {
  55         dgn_square_alarm alcopy(*alarm);
  56         for (std::list<dgn_event_listener*>::iterator
  57                  i = alcopy.listeners.begin();
  58              i != alcopy.listeners.end(); ++i)
  59         {
  60             if (!(*i)->notify_dgn_event(et))
  61                 return (false);
  62         }
  63     }
  64     return (true);
  65 }
  66
  67 void dgn_event_dispatcher::fire_position_event(
  68     dgn_event_type event, const coord_def &pos)
  69 {
  70     const dgn_event et(event, pos);
  71     fire_position_event(et, pos);
  72 }
  73
  74 void dgn_event_dispatcher::fire_position_event(
  75     const dgn_event &et, const coord_def &pos)
  76 {
  77     dgn_square_alarm *alarm = grid_triggers[pos.x][pos.y].get();
  78     if (alarm && (alarm->eventmask & et.type))
  79     {
  80         dgn_square_alarm alcopy = *alarm;
  81         for (std::list<dgn_event_listener*>::iterator
  82                  i = alcopy.listeners.begin();
  83              i != alcopy.listeners.end(); ++i)
  84         {
  85             (*i)->notify_dgn_event(et);
  86         }
  87     }
  88 }
  89
  90 void dgn_event_dispatcher::fire_event(const dgn_event &e)
  91 {
  92     if (global_event_mask & e.type)
  93     {
  94         std::list<dgn_listener_def> lcopy = listeners;
  95         for (std::list<dgn_listener_def>::iterator i = lcopy.begin();
  96              i != lcopy.end(); ++i)
  97         {
  98             if (i->eventmask & e.type)
  99                 i->listener->notify_dgn_event(e);
 100         }
 101     }
 102 }
 103
 104 void dgn_event_dispatcher::fire_event(dgn_event_type et)
 105 {
 106     fire_event(dgn_event(et));
 107 }
 108
 109 void dgn_event_dispatcher::register_listener(unsigned mask,
 110                                              dgn_event_listener *listener,
 111                                              const coord_def &pos)
 112 {
 113     if (in_bounds(pos))
 114         register_listener_at(mask, pos, listener);
 115     else
 116     {
 117         global_event_mask |= mask;
 118         for (std::list<dgn_listener_def>::iterator i = listeners.begin();
 119              i != listeners.end(); ++i)
 120         {
 121             if (i->listener == listener)
 122             {
 123                 i->eventmask |= mask;
 124                 return;
 125             }
 126         }
 127         listeners.push_back(dgn_listener_def(mask, listener));
 128     }
 129 }
 130
 131 void dgn_event_dispatcher::register_listener_at(unsigned mask,
 132                                                 const coord_def &c,
 133                                                 dgn_event_listener *listener)
 134 {
 135     if (!grid_triggers[c.x][c.y].get())
 136         grid_triggers[c.x][c.y].reset(new dgn_square_alarm);
 137
 138     dgn_square_alarm *alarm = grid_triggers[c.x][c.y].get();
 139     alarm->eventmask |= mask;
 140     if (std::find(alarm->listeners.begin(), alarm->listeners.end(),
 141                   listener) == alarm->listeners.end())
 142         alarm->listeners.push_back(listener);
 143 }
 144
 145 void dgn_event_dispatcher::remove_listener(dgn_event_listener *listener,
 146                                            const coord_def &pos)
 147 {
 148     if (in_bounds(pos))
 149         remove_listener_at(pos, listener);
 150     else
 151     {
 152         for (std::list<dgn_listener_def>::iterator i = listeners.begin();
 153              i != listeners.end(); ++i)
 154         {
 155             if (i->listener == listener)
 156             {
 157                 listeners.erase(i);
 158                 return;
 159             }
 160         }
 161     }
 162 }
 163
 164 void dgn_event_dispatcher::remove_listener_at(const coord_def &pos,
 165                                               dgn_event_listener *listener)
 166 {
 167     if (dgn_square_alarm *alarm = grid_triggers[pos.x][pos.y].get())
 168     {
 169         std::list<dgn_event_listener*>::iterator i =
 170             std::find(alarm->listeners.begin(), alarm->listeners.end(),
 171                       listener);
 172         if (i != alarm->listeners.end())
 173             alarm->listeners.erase(i);
 174     }
 175 }
 176
 177 /////////////////////////////////////////////////////////////////////////////
 178 // dgn_event_listener
 179
 180 dgn_event_listener::~dgn_event_listener()
 181 {
 182 }