qcsrc/common/triggers/trigger/keylock.qc

   1 /**
   2  * trigger given targets
   3  */
   4 void trigger_keylock_trigger(string s)
   5 {SELFPARAM();
   6         entity otemp = other;
   7         entity atemp = activator;
   8
   9         entity t;
  10         for(t = world; (t = find(t, targetname, s)); )
  11                 if(t.use)
  12                 {
  13                         setself(t);
  14                         other = this;
  15                         activator = atemp;
  16                         self.use();
  17                 }
  18
  19         setself(this);
  20         other = otemp;
  21         activator = atemp;
  22 }
  23
  24 /**
  25  * kill killtarget of trigger keylock.
  26  */
  27 void trigger_keylock_kill(string s)
  28 {
  29         entity t;
  30         for(t = world; (t = find(t, targetname, s)); )
  31                 remove(t);
  32 }
  33
  34 void trigger_keylock_touch()
  35 {SELFPARAM();
  36         bool key_used = false;
  37         bool started_delay = false;
  38
  39         // only player may trigger the lock
  40         if(!IS_PLAYER(other))
  41                 return;
  42
  43         // check silver key
  44         if(self.itemkeys)
  45                 key_used = item_keys_usekey(self, other);
  46
  47         activator = other;
  48
  49         if(self.itemkeys)
  50         {
  51 #ifdef SVQC
  52                 // at least one of the keys is missing
  53                 if(key_used)
  54                 {
  55                         // one or more keys were given, but others are still missing!
  56                         play2(other, self.noise1);
  57                         Send_Notification(NOTIF_ONE, other, MSG_CENTER, CENTER_DOOR_LOCKED_ALSONEED, item_keys_keylist(self.itemkeys));
  58                         other.key_door_messagetime = time + 2;
  59                 }
  60                 else if(other.key_door_messagetime <= time)
  61                 {
  62                         // no keys were given
  63                         play2(other, self.noise2);
  64                         Send_Notification(NOTIF_ONE, other, MSG_CENTER, CENTER_DOOR_LOCKED_NEED, item_keys_keylist(self.itemkeys));
  65                         other.key_door_messagetime = time + 2;
  66                 }
  67 #endif
  68
  69                 // trigger target2
  70                 if(self.delay <= time || started_delay == true)
  71                 if(self.target2)
  72                 {
  73                         trigger_keylock_trigger(self.target2);
  74                         started_delay = true;
  75                         self.delay = time + self.wait;
  76                 }
  77         }
  78         else
  79         {
  80 #ifdef SVQC
  81                 // all keys were given!
  82                 play2(other, self.noise);
  83                 centerprint(other, self.message);
  84 #endif
  85
  86                 if(self.target)
  87                         trigger_keylock_trigger(self.target);
  88
  89                 if(self.killtarget)
  90                         trigger_keylock_kill(self.killtarget);
  91
  92                 remove(self);
  93         }
  94
  95 }
  96
  97 REGISTER_NET_LINKED(ENT_CLIENT_KEYLOCK)
  98
  99 #ifdef SVQC
 100 bool trigger_keylock_send(entity to, int sf)
 101 {SELFPARAM();
 102         WriteHeader(MSG_ENTITY, ENT_CLIENT_KEYLOCK);
 103
 104         WriteInt24_t(MSG_ENTITY, self.itemkeys);
 105         WriteByte(MSG_ENTITY, self.height);
 106
 107         trigger_common_write(self, true);
 108
 109         return true;
 110 }
 111
 112 void trigger_keylock_link()
 113 {
 114         // uncomment to network keylocks
 115         //Net_LinkEntity(self, false, 0, trigger_keylock_send);
 116 }
 117
 118 /*QUAKED trigger_keylock (.0 .5 .8) ?
 119 Keylock trigger.  Must target other entities.
 120 This trigger will trigger target entities when all required keys are provided.
 121 -------- KEYS --------
 122 itemkeys: A bit field with key IDs that are needed to open this lock.
 123 sounds: 1 to play misc/secret.wav, 2 to play misc/talk.wav, 3 to play misc/trigger1.wav (3 is default)
 124 target: trigger all entities with this targetname when triggered and all keys have been given to it, then remove this trigger
 125 target2: trigger all entities with this targetname when triggered without giving it all the required keys.
 126 killtarget: remove all entities with this targetname when triggered with all the needed keys.
 127 message: print this message to the player who activated the trigger when all needed keys have been given.
 128 message2: print this message to the player who activated the trigger when not all of the needed keys have been given.
 129 noise: sound to play when lock gets unlocked (default: see sounds)
 130 noise1: sound to play when only some of the needed key were used but not all (default: misc/decreasevalue.wav)
 131 noise2: sound to play when a key is missing (default: misc/talk.wav)
 132 wait: prevent triggering again for this amount of time (default: 5) - applies to target2, target3, target4.
 133 ---------NOTES----------
 134 If spawned without any key specified in itemkeys, this trigger will display an error and remove itself.
 135 message2 and noise2 will be resent to the player every 2 seconds while he is in the trigger zone.
 136 */
 137 spawnfunc(trigger_keylock)
 138 {
 139         if(!self.itemkeys) { remove(self); return; }
 140
 141         // set unlocked message
 142         if(self.message == "")
 143                 self.message = "Unlocked!";
 144
 145         // set default unlock noise
 146         if(self.noise == "")
 147         {
 148                 if(self.sounds == 1)
 149                         self.noise = "misc/secret.wav";
 150                 else if(self.sounds == 2)
 151                         self.noise = strzone(SND(TALK));
 152                 else //if (self.sounds == 3) {
 153                         self.noise = "misc/trigger1.wav";
 154         }
 155
 156         // set default use key sound
 157         if(self.noise1 == "")
 158                 self.noise1 = "misc/decreasevalue.wav";
 159
 160         // set closed sourd
 161         if(self.noise2 == "")
 162                 self.noise2 = SND(TALK);
 163
 164         // delay between triggering message2 and trigger2
 165         if(!self.wait) { self.wait = 5; }
 166
 167         // precache sounds
 168         precache_sound(self.noise);
 169         precache_sound(self.noise1);
 170         precache_sound(self.noise2);
 171
 172         EXACTTRIGGER_INIT;
 173
 174         self.touch = trigger_keylock_touch;
 175
 176         trigger_keylock_link();
 177 }
 178 #elif defined(CSQC)
 179 void keylock_remove()
 180 {SELFPARAM();
 181         if(self.target) { strunzone(self.target); }
 182         self.target = string_null;
 183
 184         if(self.target2) { strunzone(self.target2); }
 185         self.target2 = string_null;
 186
 187         if(self.target3) { strunzone(self.target3); }
 188         self.target3 = string_null;
 189
 190         if(self.target4) { strunzone(self.target4); }
 191         self.target4 = string_null;
 192
 193         if(self.killtarget) { strunzone(self.killtarget); }
 194         self.killtarget = string_null;
 195
 196         if(self.targetname) { strunzone(self.targetname); }
 197         self.targetname = string_null;
 198 }
 199
 200 NET_HANDLE(ENT_CLIENT_KEYLOCK, bool isnew)
 201 {
 202         self.itemkeys = ReadInt24_t();
 203         self.height = ReadByte();
 204
 205         trigger_common_read(true);
 206
 207         return = true;
 208
 209         self.classname = "trigger_keylock";
 210         self.drawmask = MASK_NORMAL;
 211         self.draw = trigger_draw_generic;
 212         self.trigger_touch = trigger_keylock_touch;
 213         self.entremove = keylock_remove;
 214 }
 215 #endif