data/qcsrc/server/g_triggers.qc

   1
   2 void() SUB_UseTargets;
   3
   4 void() DelayThink =
   5 {
   6         activator = self.enemy;
   7         SUB_UseTargets ();
   8         remove(self);
   9 };
  10
  11 /*
  12 ==============================
  13 SUB_UseTargets
  14
  15 the global "activator" should be set to the entity that initiated the firing.
  16
  17 If self.delay is set, a DelayedUse entity will be created that will actually
  18 do the SUB_UseTargets after that many seconds have passed.
  19
  20 Centerprints any self.message to the activator.
  21
  22 Removes all entities with a targetname that match self.killtarget,
  23 and removes them, so some events can remove other triggers.
  24
  25 Search for (string)targetname in all entities that
  26 match (string)self.target and call their .use function
  27
  28 ==============================
  29 */
  30 void() SUB_UseTargets =
  31 {
  32         local entity t, stemp, otemp, act;
  33
  34 //
  35 // check for a delay
  36 //
  37         if (self.delay)
  38         {
  39         // create a temp object to fire at a later time
  40                 t = spawn();
  41                 t.classname = "DelayedUse";
  42                 t.nextthink = time + self.delay;
  43                 t.think = DelayThink;
  44                 t.enemy = activator;
  45                 t.message = self.message;
  46                 t.killtarget = self.killtarget;
  47                 t.target = self.target;
  48                 return;
  49         }
  50
  51
  52 //
  53 // print the message
  54 //
  55         if (activator.classname == "player" && self.message != "")
  56         {
  57                 centerprint (activator, self.message);
  58                 if (!self.noise)
  59                         sound (activator, CHAN_VOICE, "misc/talk.wav", 1, ATTN_NORM);
  60         }
  61
  62 //
  63 // kill the killtagets
  64 //
  65         if (self.killtarget)
  66         {
  67                 t = world;
  68                 do
  69                 {
  70                         t = find (t, targetname, self.killtarget);
  71                         if (!t)
  72                                 return;
  73                         remove (t);
  74                 } while ( 1 );
  75         }
  76
  77 //
  78 // fire targets
  79 //
  80         if (self.target)
  81         {
  82                 act = activator;
  83                 t = world;
  84                 do
  85                 {
  86                         t = find (t, targetname, self.target);
  87                         if (!t)
  88                         {
  89                                 return;
  90                         }
  91                         stemp = self;
  92                         otemp = other;
  93                         self = t;
  94                         other = stemp;
  95                         if (self.use)
  96                                 self.use ();
  97                         self = stemp;
  98                         other = otemp;
  99                         activator = act;
 100                 } while ( 1 );
 101         }
 102
 103
 104 };
 105
 106
 107
 108 void() spawnfunc_trigger_reactivate =
 109 {
 110         self.solid = SOLID_TRIGGER;
 111 };
 112
 113 //=============================================================================
 114
 115 float   SPAWNFLAG_NOMESSAGE = 1;
 116 float   SPAWNFLAG_NOTOUCH = 1;
 117
 118 // the wait time has passed, so set back up for another activation
 119 void() multi_wait =
 120 {
 121         if (self.max_health)
 122         {
 123                 self.health = self.max_health;
 124                 self.takedamage = DAMAGE_YES;
 125                 self.solid = SOLID_BBOX;
 126         }
 127 };
 128
 129
 130 // the trigger was just touched/killed/used
 131 // self.enemy should be set to the activator so it can be held through a delay
 132 // so wait for the delay time before firing
 133 void() multi_trigger =
 134 {
 135         if (self.nextthink > time)
 136         {
 137                 return;         // allready been triggered
 138         }
 139
 140         if (self.classname == "trigger_secret")
 141         {
 142                 if (self.enemy.classname != "player")
 143                         return;
 144                 found_secrets = found_secrets + 1;
 145                 WriteByte (MSG_ALL, SVC_FOUNDSECRET);
 146         }
 147
 148         if (self.noise)
 149                 sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
 150
 151 // don't trigger again until reset
 152         self.takedamage = DAMAGE_NO;
 153
 154         activator = self.enemy;
 155
 156         SUB_UseTargets();
 157
 158         if (self.wait > 0)
 159         {
 160                 self.think = multi_wait;
 161                 self.nextthink = time + self.wait;
 162         }
 163         else
 164         {       // we can't just remove (self) here, because this is a touch function
 165                 // called wheil C code is looping through area links...
 166                 self.touch = SUB_Null;
 167
 168                 self.nextthink = time + 0.1;
 169                 self.think = SUB_Remove;
 170         }
 171 };
 172
 173 void() multi_use =
 174 {
 175         self.enemy = activator;
 176         multi_trigger();
 177 };
 178
 179 void() multi_touch =
 180 {
 181         if (other.classname != "player")
 182                 return;
 183
 184     if(self.team)
 185     if(self.team == other.team)
 186         return;
 187
 188 // if the trigger has an angles field, check player's facing direction
 189         if (self.movedir != '0 0 0')
 190         {
 191                 makevectors (other.angles);
 192                 if (v_forward * self.movedir < 0)
 193                         return;         // not facing the right way
 194         }
 195
 196         self.enemy = other;
 197         multi_trigger ();
 198 };
 199
 200 void multi_eventdamage (vector hitloc, float damage, entity inflictor, entity attacker, float deathtype)
 201 {
 202         if (!self.takedamage)
 203                 return;
 204         self.health = self.health - damage;
 205         if (self.health <= 0)
 206         {
 207                 self.enemy = attacker;
 208                 multi_trigger();
 209         }
 210 }
 211
 212 /*QUAKED spawnfunc_trigger_multiple (.5 .5 .5) ? notouch
 213 Variable sized repeatable trigger.  Must be targeted at one or more entities.  If "health" is set, the trigger must be killed to activate each time.
 214 If "delay" is set, the trigger waits some time after activating before firing.
 215 "wait" : Seconds between triggerings. (.2 default)
 216 If notouch is set, the trigger is only fired by other entities, not by touching.
 217 NOTOUCH has been obsoleted by spawnfunc_trigger_relay!
 218 sounds
 219 1)      secret
 220 2)      beep beep
 221 3)      large switch
 222 4)
 223 set "message" to text string
 224 */
 225 void() spawnfunc_trigger_multiple =
 226 {
 227         if (self.sounds == 1)
 228         {
 229                 precache_sound ("misc/secret.wav");
 230                 self.noise = "misc/secret.wav";
 231         }
 232         else if (self.sounds == 2)
 233         {
 234                 precache_sound ("misc/talk.wav");
 235                 self.noise = "misc/talk.wav";
 236         }
 237         else if (self.sounds == 3)
 238         {
 239                 precache_sound ("misc/trigger1.wav");
 240                 self.noise = "misc/trigger1.wav";
 241         }
 242
 243         if (!self.wait)
 244                 self.wait = 0.2;
 245         self.use = multi_use;
 246
 247         InitTrigger ();
 248
 249         if (self.health)
 250         {
 251                 if (self.spawnflags & SPAWNFLAG_NOTOUCH)
 252                         objerror ("health and notouch don't make sense\n");
 253                 self.max_health = self.health;
 254                 self.event_damage = multi_eventdamage;
 255                 self.takedamage = DAMAGE_YES;
 256                 self.solid = SOLID_BBOX;
 257                 setorigin (self, self.origin);  // make sure it links into the world
 258         }
 259         else
 260         {
 261                 if ( !(self.spawnflags & SPAWNFLAG_NOTOUCH) )
 262                 {
 263                         self.touch = multi_touch;
 264                 }
 265         }
 266 };
 267
 268
 269 /*QUAKED spawnfunc_trigger_once (.5 .5 .5) ? notouch
 270 Variable sized trigger. Triggers once, then removes itself.  You must set the key "target" to the name of another object in the level that has a matching
 271 "targetname".  If "health" is set, the trigger must be killed to activate.
 272 If notouch is set, the trigger is only fired by other entities, not by touching.
 273 if "killtarget" is set, any objects that have a matching "target" will be removed when the trigger is fired.
 274 if "angle" is set, the trigger will only fire when someone is facing the direction of the angle.  Use "360" for an angle of 0.
 275 sounds
 276 1)      secret
 277 2)      beep beep
 278 3)      large switch
 279 4)
 280 set "message" to text string
 281 */
 282 void() spawnfunc_trigger_once =
 283 {
 284         self.wait = -1;
 285         spawnfunc_trigger_multiple();
 286 };
 287
 288 //=============================================================================
 289
 290 /*QUAKED spawnfunc_trigger_relay (.5 .5 .5) (-8 -8 -8) (8 8 8)
 291 This fixed size trigger cannot be touched, it can only be fired by other events.  It can contain killtargets, targets, delays, and messages.
 292 */
 293 void() spawnfunc_trigger_relay =
 294 {
 295         self.use = SUB_UseTargets;
 296 };
 297
 298 void() delay_use
 299 {
 300     self.think = SUB_UseTargets;
 301     self.nextthink = self.wait;
 302 }
 303
 304 void() spawnfunc_trigger_delay
 305 {
 306     if(!self.wait)
 307         self.wait = 1;
 308
 309     self.use = delay_use;
 310 }
 311
 312 //=============================================================================
 313
 314
 315 void() counter_use =
 316 {
 317         self.count = self.count - 1;
 318         if (self.count < 0)
 319                 return;
 320
 321         if (self.count != 0)
 322         {
 323                 if (activator.classname == "player"
 324                 && (self.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
 325                 {
 326                         if (self.count >= 4)
 327                                 centerprint (activator, "There are more to go...");
 328                         else if (self.count == 3)
 329                                 centerprint (activator, "Only 3 more to go...");
 330                         else if (self.count == 2)
 331                                 centerprint (activator, "Only 2 more to go...");
 332                         else
 333                                 centerprint (activator, "Only 1 more to go...");
 334                 }
 335                 return;
 336         }
 337
 338         if (activator.classname == "player"
 339         && (self.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
 340                 centerprint(activator, "Sequence completed!");
 341         self.enemy = activator;
 342         multi_trigger ();
 343 };
 344
 345 /*QUAKED spawnfunc_trigger_counter (.5 .5 .5) ? nomessage
 346 Acts as an intermediary for an action that takes multiple inputs.
 347
 348 If nomessage is not set, t will print "1 more.. " etc when triggered and "sequence complete" when finished.
 349
 350 After the counter has been triggered "count" times (default 2), it will fire all of it's targets and remove itself.
 351 */
 352 void() spawnfunc_trigger_counter =
 353 {
 354         self.wait = -1;
 355         if (!self.count)
 356                 self.count = 2;
 357
 358         self.use = counter_use;
 359 };
 360
 361 .float triggerhurttime;
 362 void() spawnfunc_hurt_touch =
 363 {
 364         if (!other.owner)
 365         {
 366                 if (other.items & IT_KEY1 || other.items & IT_KEY2)     // reset flag
 367                         other.pain_finished = min(other.pain_finished, time + 2);
 368                 else if (other.classname == "rune")                     // reset runes
 369                         other.nextthink = min(other.nextthink, time + 1);
 370         }
 371
 372         if (other.takedamage)
 373         if (other.triggerhurttime < time)
 374         {
 375                 other.triggerhurttime = time + 1;
 376                 Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 377         }
 378
 379         return;
 380 };
 381
 382 /*QUAKED spawnfunc_trigger_hurt (.5 .5 .5) ?
 383 Any object touching this will be hurt
 384 set dmg to damage amount
 385 defalt dmg = 5
 386 */
 387 void() spawnfunc_trigger_hurt =
 388 {
 389         InitTrigger ();
 390         self.touch = spawnfunc_hurt_touch;
 391         if (!self.dmg)
 392                 self.dmg = 1000;
 393         if (!self.message)
 394                 self.message = "was in the wrong place.";
 395 };
 396
 397 //void() target_speaker_use = {sound(self, CHAN_VOICE, self.noise, 1, 1);}
 398 //void() spawnfunc_target_speaker = {self.use = target_speaker_use;}
 399
 400 void() spawnfunc_target_speaker =
 401 {
 402 if(self.noise) {
 403  precache_sound (self.noise);
 404  ambientsound (self.origin, self.noise, 1, ATTN_STATIC);
 405 }
 406 //remove(self);
 407 };
 408
 409
 410 void() spawnfunc_func_stardust {
 411         self.effects = EF_STARDUST;
 412 }
 413
 414
 415 /*
 416 void() sparksthink =
 417 {
 418   self.nextthink = time + 0.1;
 419
 420   if(random() < self.wait) {
 421     te_spark(self.origin,'0 0 -1',self.cnt);
 422   }
 423 }
 424
 425
 426 void() func_sparks =
 427 {
 428   self.think = sparksthink;
 429   self.nextthink = time + 0.2;
 430
 431   // self.cnt is the amount of sparks that one burst will spawn
 432   if(self.cnt < 1) {
 433     self.cnt = 25.0; // nice default value
 434   }
 435
 436   // self.wait is the probability that a sparkthink will spawn a spark shower
 437   // range: 0 - 1, but 0 makes little sense, so...
 438   if(self.wait < 0.05) {
 439     self.wait = 0.25; // nice default value
 440   }
 441
 442   // sound
 443   if(self.noise) {
 444     precache_sound (self.noise);
 445     ambientsound (self.origin, self.noise, 1, ATTN_STATIC);
 446   }
 447 }
 448 */
 449 void() rain_think =
 450 {
 451         self.nextthink = time + 0.1;
 452         te_particlerain(self.absmin, self.absmax, self.dest, self.count, self.cnt);
 453 //      te_particlesnow(self.absmin, self.absmax, self.dest * 0.25, self.count, self.cnt);
 454 //      WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
 455 //      WriteByte (MSG_BROADCAST, TE_PARTICLERAIN);
 456 //      WriteVec (MSG_BROADCAST, self.absmin);
 457 //      WriteVec (MSG_BROADCAST, self.absmax);
 458 //      WriteVec (MSG_BROADCAST, self.dest);
 459 //      WriteShort (MSG_BROADCAST, self.count);
 460 //      WriteByte (MSG_BROADCAST, self.cnt);
 461 };
 462
 463 /*QUAKED spawnfunc_func_rain (0 .5 .8) ?
 464 This is an invisible area like a trigger, which rain falls inside of.
 465
 466 Keys:
 467 "velocity"
 468  falling direction (should be something like '0 0 -700', use the X and Y velocity for wind)
 469 "cnt"
 470  sets color of rain (default 12 - white)
 471 "count"
 472  adjusts density, this many particles fall every second for a 1024x1024 area, default is 2000
 473 */
 474 void() spawnfunc_func_rain =
 475 {
 476         self.dest = self.velocity;
 477         self.velocity = '0 0 0';
 478         if (!self.dest)
 479                 self.dest = '0 0 -700';
 480         self.angles = '0 0 0';
 481         self.movetype = MOVETYPE_NONE;
 482         self.solid = SOLID_NOT;
 483         if(self.model != "")
 484                 setmodel(self, self.model); // no precision needed
 485         setorigin(self, self.origin);
 486         setsize(self, self.mins, self.maxs);
 487         self.model = "";
 488         if (!self.cnt)
 489                 self.cnt = 12;
 490         if (!self.count)
 491                 self.count = 2000;
 492         self.count = 0.1 * self.count * (self.size_x / 1024) * (self.size_y / 1024);
 493         if (self.count < 1)
 494         {
 495                 remove(self);
 496                 return;
 497         }
 498         // convert from per second to per 0.1 sec,
 499         self.count = ceil(self.count * 0.1);
 500         self.think = rain_think;
 501         self.nextthink = time + 0.5;
 502 };
 503
 504
 505 void() snow_think =
 506 {
 507         self.nextthink = time + 0.1 + random() * 0.05;
 508         te_particlesnow(self.absmin, self.absmax, self.dest, self.count, self.cnt);
 509 //      WriteByte (MSG_BROADCAST, SVC_TEMPENTITY);
 510 //      WriteByte (MSG_BROADCAST, TE_PARTICLESNOW);
 511 //      WriteVec (MSG_BROADCAST, self.absmin);
 512 //      WriteVec (MSG_BROADCAST, self.absmax);
 513 //      WriteVec (MSG_BROADCAST, self.dest);
 514 //      WriteShort (MSG_BROADCAST, self.count);
 515 //      WriteByte (MSG_BROADCAST, self.cnt);
 516 };
 517
 518 /*QUAKED spawnfunc_func_snow (0 .5 .8) ?
 519 This is an invisible area like a trigger, which snow falls inside of.
 520
 521 Keys:
 522 "velocity"
 523  falling direction (should be something like '0 0 -300', use the X and Y velocity for wind)
 524 "cnt"
 525  sets color of rain (default 12 - white)
 526 "count"
 527  adjusts density, this many particles fall every second for a 1024x1024 area, default is 2000
 528 */
 529 void() spawnfunc_func_snow =
 530 {
 531         self.dest = self.velocity;
 532         self.velocity = '0 0 0';
 533         if (!self.dest)
 534                 self.dest = '0 0 -300';
 535         self.angles = '0 0 0';
 536         self.movetype = MOVETYPE_NONE;
 537         self.solid = SOLID_NOT;
 538         if(self.model != "")
 539                 setmodel(self, self.model); // no precision needed
 540         setorigin(self, self.origin);
 541         setsize(self, self.mins, self.maxs);
 542         self.model = "";
 543         if (!self.cnt)
 544                 self.cnt = 12;
 545         if (!self.count)
 546                 self.count = 2000;
 547         self.count = 0.1 * self.count * (self.size_x / 1024) * (self.size_y / 1024);
 548         if (self.count < 1)
 549         {
 550                 remove(self);
 551                 return;
 552         }
 553         // convert from per second to per 0.1 sec,
 554         self.count = ceil(self.count * 0.1);
 555         self.think = snow_think;
 556         self.nextthink = time + 0.5;
 557 };
 558
 559
 560 void FireRailgunBullet (vector start, vector end, float bdamage, float bforce, float deathtype);
 561 void() misc_laser_think =
 562 {
 563         vector o;
 564         if(!self.state)
 565         {
 566                 self.enemy = find(world, targetname, self.target);
 567                 self.state = 1;
 568         }
 569         if(self.enemy)
 570         {
 571                 o = self.enemy.origin;
 572         }
 573         else
 574         {
 575                 makevectors(self.angles);
 576                 o = self.origin + v_forward * MAX_SHOT_DISTANCE;
 577         }
 578
 579         if(self.dmg)
 580         {
 581                 if(self.dmg < 0)
 582                         FireRailgunBullet(self.origin, o, 100000, 0, DEATH_HURTTRIGGER);
 583                 else
 584                         FireRailgunBullet(self.origin, o, self.dmg * frametime, 0, DEATH_HURTTRIGGER);
 585         }
 586
 587         if(time > self.ltime)
 588         {
 589                 traceline(self.origin, o, MOVE_WORLDONLY, self);
 590                 trailparticles(self, self.cnt, self.origin, trace_endpos);
 591                 pointparticles(self.lip, trace_endpos, trace_plane_normal, 256 * frametime);
 592                 self.ltime = time + self.wait;
 593         }
 594         self.nextthink = time;
 595 }
 596 /*QUAKED spawnfunc_misc_laser (.5 .5 .5) ?
 597 Any object touching the beam will be hurt
 598 Keys:
 599 "target"
 600  spawnfunc_target_position where the laser ends
 601 "mdl"
 602  name of beam effect to use
 603 "dmg"
 604  damage per second (-1 for a laser that kills immediately)
 605 "wait"
 606  delay between sending the particle effect
 607 */
 608 void() spawnfunc_misc_laser =
 609 {
 610         if(self.mdl)
 611         {
 612                 self.cnt = particleeffectnum(self.mdl);
 613                 self.lip = particleeffectnum(strcat(self.mdl, "_end"));
 614         }
 615         else
 616         {
 617                 self.cnt = particleeffectnum("misc_laser_beam");
 618                 self.lip = particleeffectnum("misc_laser_beam_end");
 619         }
 620         if(!self.wait)
 621                 self.wait = 1;
 622         if(!self.message)
 623                 self.message = "saw the spawnfunc_light";
 624         self.think = misc_laser_think;
 625         self.nextthink = time;
 626 }
 627
 628 .float strength;
 629 .float lastpushtime;
 630 void trigger_impulse_touch1()
 631 {
 632         entity targ;
 633     float pushdeltatime;
 634
 635         // FIXME: Better checking for what to push and not.
 636         if (other.classname != "player")
 637         if (other.classname != "corpse")
 638         if (other.classname != "body")
 639         if (other.classname != "gib")
 640         if (other.classname != "missile")
 641         if (other.classname != "casing")
 642         if (other.classname != "grenade")
 643         if (other.classname != "plasma")
 644         if (other.classname != "plasma_prim")
 645         if (other.classname != "plasma_chain")
 646         if (other.classname != "droppedweapon")
 647                 return;
 648
 649         if (other.deadflag && other.classname == "player")
 650                 return;
 651
 652     targ = find(world, targetname, self.target);
 653     if(!targ)
 654     {
 655         objerror("trigger_force without a (valif) .target!\n");
 656         remove(self);
 657         return;
 658     }
 659
 660
 661     pushdeltatime = time - other.lastpushtime;
 662     if (pushdeltatime > 0.15) pushdeltatime = 0;
 663     other.lastpushtime = time;
 664     if(!pushdeltatime) return;
 665
 666     other.velocity = other.velocity + normalize(targ.origin - self.origin) * self.strength * pushdeltatime;
 667 }
 668
 669 void trigger_impulse_touch2()
 670 {
 671
 672         // FIXME: Better checking for what to push and not.
 673         if (other.classname != "player")
 674         if (other.classname != "corpse")
 675         if (other.classname != "body")
 676         if (other.classname != "gib")
 677         if (other.classname != "missile")
 678         if (other.classname != "casing")
 679         if (other.classname != "grenade")
 680         if (other.classname != "plasma")
 681         if (other.classname != "plasma_prim")
 682         if (other.classname != "plasma_chain")
 683         if (other.classname != "droppedweapon")
 684                 return;
 685
 686         if (other.deadflag && other.classname == "player")
 687                 return;
 688
 689     other.velocity = other.velocity * self.strength;
 690 }
 691
 692
 693 /*QUAKED spawnfunc_trigger_impulse (.5 .5 .5) ?
 694 -------- KEYS --------
 695 target : If this is set, this points to the spawnfunc_target_position to which the player will get pushed.
 696          If not, this trigger acts like a damper/accelerator field.
 697
 698 strength : This is how mutch force to add in the direction of .target each second
 699            when .target is set. If not, this is hoe mutch to slow down/accelerate
 700            someting cought inside this trigger. (1=no change, 0,5 half speed rougthly each tic, 2 = doubble)
 701
 702 -------- NOTES --------
 703 Use a brush textured with common/origin in the trigger entity to determine the origin of the force
 704 in directional push mode. For damper/accelerator mode this is no nessesary (and has no effect).
 705 */
 706
 707 void spawnfunc_trigger_impulse()
 708 {
 709     InitTrigger ();
 710     if(self.target)
 711     {
 712         if(!self.strength) self.strength = 950;
 713         self.touch = trigger_impulse_touch1;
 714     }
 715     else
 716     {
 717         if(!self.strength) self.strength = 0.9;
 718         self.touch = trigger_impulse_touch2;
 719     }
 720 }
 721