data/qcsrc/server/t_plats.qc

   1
   2 float   STATE_TOP               = 0;
   3 float   STATE_BOTTOM    = 1;
   4 float   STATE_UP                = 2;
   5 float   STATE_DOWN              = 3;
   6
   7 .entity trigger_field;
   8 //.float dmgtime;
   9 .float dmgtime2;
  10
  11 void() plat_center_touch;
  12 void() plat_outside_touch;
  13 void() plat_trigger_use;
  14 void() plat_go_up;
  15 void() plat_go_down;
  16 void() plat_crush;
  17 float PLAT_LOW_TRIGGER = 1;
  18
  19 void plat_spawn_inside_trigger()
  20 {
  21         local entity trigger;
  22         local vector tmin, tmax;
  23
  24         trigger = spawn();
  25         trigger.touch = plat_center_touch;
  26         trigger.movetype = MOVETYPE_NONE;
  27         trigger.solid = SOLID_TRIGGER;
  28         trigger.enemy = self;
  29
  30         tmin = self.mins + '25 25 0';
  31         tmax = self.maxs - '25 25 -8';
  32         tmin_z = tmax_z - (self.pos1_z - self.pos2_z + 8);
  33         if (self.spawnflags & PLAT_LOW_TRIGGER)
  34                 tmax_z = tmin_z + 8;
  35
  36         if (self.size_x <= 50)
  37         {
  38                 tmin_x = (self.mins_x + self.maxs_x) / 2;
  39                 tmax_x = tmin_x + 1;
  40         }
  41         if (self.size_y <= 50)
  42         {
  43                 tmin_y = (self.mins_y + self.maxs_y) / 2;
  44                 tmax_y = tmin_y + 1;
  45         }
  46
  47         setsize (trigger, tmin, tmax);
  48 };
  49
  50 void plat_hit_top()
  51 {
  52         sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
  53         self.state = 1;
  54         self.think = plat_go_down;
  55         self.nextthink = self.ltime + 3;
  56 };
  57
  58 void plat_hit_bottom()
  59 {
  60         sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
  61         self.state = 2;
  62 };
  63
  64 void plat_go_down()
  65 {
  66         sound (self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_NORM);
  67         self.state = 3;
  68         SUB_CalcMove (self.pos2, self.speed, plat_hit_bottom);
  69 };
  70
  71 void plat_go_up()
  72 {
  73         sound (self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_NORM);
  74         self.state = 4;
  75         SUB_CalcMove (self.pos1, self.speed, plat_hit_top);
  76 };
  77
  78 void plat_center_touch()
  79 {
  80         if (other.classname != "player")
  81                 return;
  82
  83         if (other.health <= 0)
  84                 return;
  85
  86         self = self.enemy;
  87         if (self.state == 2)
  88                 plat_go_up ();
  89         else if (self.state == 1)
  90                 self.nextthink = self.ltime + 1;        // delay going down
  91 };
  92
  93 void plat_outside_touch()
  94 {
  95         if (other.classname != "player")
  96                 return;
  97
  98         if (other.health <= 0)
  99                 return;
 100
 101         self = self.enemy;
 102         if (self.state == 1)
 103                 plat_go_down ();
 104 };
 105
 106 void plat_trigger_use()
 107 {
 108         if (self.think)
 109                 return;         // allready activated
 110         plat_go_down();
 111 };
 112
 113
 114 void plat_crush()
 115 {
 116     if((self.spawnflags & 4) && (other.takedamage != DAMAGE_NO)) { // KIll Kill Kill!!
 117         Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 118     } else {
 119         if((self.dmg) && (other.takedamage != DAMAGE_NO)) {   // Shall we bite?
 120             Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 121             // Gib dead/dying stuff
 122             if(other.deadflag != DEAD_NO)
 123                 Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 124         }
 125
 126         if (self.state == 4)
 127             plat_go_down ();
 128         else if (self.state == 3)
 129             plat_go_up ();
 130         else
 131             objerror ("plat_crush: bad self.state\n");
 132     }
 133 };
 134
 135 void plat_use()
 136 {
 137         self.use = SUB_Null;
 138         if (self.state != 4)
 139                 objerror ("plat_use: not in up state");
 140         plat_go_down();
 141 };
 142
 143 void plat_init_movedown()
 144 {
 145         setorigin (self, self.pos2);
 146         self.state = 2;
 147 }
 148
 149 .string sound1, sound2;
 150
 151 void spawnfunc_path_corner() { };
 152 void spawnfunc_func_plat()
 153 {
 154         if (!self.t_length)
 155                 self.t_length = 80;
 156         if (!self.t_width)
 157                 self.t_width = 10;
 158
 159         if (self.sounds == 0)
 160                 self.sounds = 2;
 161
 162     if(self.spawnflags & 4)
 163         self.dmg = 10000;
 164
 165     if(self.dmg && (!self.message))
 166                 self.message = "was in the wrong place.";
 167
 168         if (self.sounds == 1)
 169         {
 170                 precache_sound ("plats/plat1.wav");
 171                 precache_sound ("plats/plat2.wav");
 172                 self.noise = "plats/plat1.wav";
 173                 self.noise1 = "plats/plat2.wav";
 174         }
 175
 176         if (self.sounds == 2)
 177         {
 178                 precache_sound ("plats/medplat1.wav");
 179                 precache_sound ("plats/medplat2.wav");
 180                 self.noise = "plats/medplat1.wav";
 181                 self.noise1 = "plats/medplat2.wav";
 182         }
 183
 184         if (self.sound1)
 185         {
 186                 precache_sound (self.sound1);
 187                 self.noise = self.sound1;
 188         }
 189         if (self.sound2)
 190         {
 191                 precache_sound (self.sound2);
 192                 self.noise1 = self.sound2;
 193         }
 194
 195         self.mangle = self.angles;
 196         self.angles = '0 0 0';
 197
 198         self.classname = "plat";
 199         InitMovingBrushTrigger();
 200         self.effects |= EF_LOWPRECISION;
 201         setsize (self, self.mins , self.maxs);
 202
 203         self.blocked = plat_crush;
 204
 205         if (!self.speed)
 206                 self.speed = 150;
 207
 208         self.pos1 = self.origin;
 209         self.pos2 = self.origin;
 210         self.pos2_z = self.origin_z - self.size_z + 8;
 211
 212         self.use = plat_trigger_use;
 213
 214         plat_spawn_inside_trigger ();   // the "start moving" trigger
 215
 216         IFTARGETED
 217         {
 218                 self.state = 4;
 219                 self.use = plat_use;
 220         }
 221         else
 222                 InitializeEntity(self, plat_init_movedown, INITPRIO_SETLOCATION);
 223 };
 224
 225
 226 void() train_next;
 227 void train_wait()
 228 {
 229         self.think = train_next;
 230         self.nextthink = self.ltime + self.wait;
 231 };
 232
 233 void train_next()
 234 {
 235         local entity targ;
 236         targ = find(world, targetname, self.target);
 237         self.target = targ.target;
 238         if (!self.target)
 239                 objerror("train_next: no next target");
 240         self.wait = targ.wait;
 241         if (!self.wait)
 242                 self.wait = 0.1;
 243         if(self.wait < 0)
 244         {
 245                 if (targ.speed)
 246                         SUB_CalcMove(targ.origin - self.mins, targ.speed, train_next);
 247                 else
 248                         SUB_CalcMove(targ.origin - self.mins, self.speed, train_next);
 249         }
 250         else
 251         {
 252                 if (targ.speed)
 253                         SUB_CalcMove(targ.origin - self.mins, targ.speed, train_wait);
 254                 else
 255                         SUB_CalcMove(targ.origin - self.mins, self.speed, train_wait);
 256         }
 257 };
 258
 259 void func_train_find()
 260 {
 261         local entity targ;
 262         targ = find(world, targetname, self.target);
 263         self.target = targ.target;
 264         if (!self.target)
 265                 objerror("func_train_find: no next target");
 266         setorigin(self, targ.origin - self.mins);
 267         self.nextthink = self.ltime + 1;
 268         self.think = train_next;
 269 };
 270
 271 /*QUAKED spawnfunc_func_train (0 .5 .8) ?
 272 Ridable platform, targets spawnfunc_path_corner path to follow.
 273 speed : speed the train moves (can be overridden by each spawnfunc_path_corner)
 274 target : targetname of first spawnfunc_path_corner (starts here)
 275 */
 276 void spawnfunc_func_train()
 277 {
 278         if (!self.target)
 279                 objerror("func_train without a target");
 280         if (!self.speed)
 281                 self.speed = 100;
 282
 283         InitMovingBrushTrigger();
 284         self.effects |= EF_LOWPRECISION;
 285
 286         // wait for targets to spawn
 287         InitializeEntity(self, func_train_find, INITPRIO_SETLOCATION);
 288 };
 289
 290
 291
 292 void rotating_blocked()
 293 {
 294
 295     if(self.dmg && other.takedamage != DAMAGE_NO) {
 296         if(self.dmgtime2 < time) {
 297             Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 298             self.dmgtime2 = time + self.dmgtime;
 299         }
 300
 301         // Gib dead/dying stuff
 302         if(other.deadflag != DEAD_NO)
 303             Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 304     }
 305
 306
 307 }
 308
 309 /*QUAKED spawnfunc_func_rotating (0 .5 .8) ? - - X_AXIS Y_AXIS
 310 Brush model that spins in place on one axis (default Z).
 311 speed   : speed to rotate (in degrees per second)
 312 noise   : path/name of looping .wav file to play.
 313 dmg     : Do this mutch dmg every .dmgtime intervall when blocked
 314 dmgtime : See above.
 315 */
 316
 317 void spawnfunc_func_rotating()
 318 {
 319         if (self.noise)
 320         {
 321                 precache_sound(self.noise);
 322                 ambientsound(self.origin, self.noise, VOL_BASE, ATTN_IDLE);
 323         }
 324         if (!self.speed)
 325                 self.speed = 100;
 326         // FIXME: test if this turns the right way, then remove this comment (negate as needed)
 327         if (self.spawnflags & 4) // X (untested)
 328                 self.avelocity = '0 0 1' * self.speed;
 329         // FIXME: test if this turns the right way, then remove this comment (negate as needed)
 330         else if (self.spawnflags & 8) // Y (untested)
 331                 self.avelocity = '1 0 0' * self.speed;
 332         // FIXME: test if this turns the right way, then remove this comment (negate as needed)
 333         else // Z
 334                 self.avelocity = '0 1 0' * self.speed;
 335
 336     if(self.dmg & (!self.message))
 337         self.message = " was in the wrong place.";
 338
 339
 340     if(self.dmg && (!self.dmgtime))
 341         self.dmgtime = 0.25;
 342
 343     self.dmgtime2 = time;
 344
 345         InitMovingBrushTrigger();
 346         // no EF_LOWPRECISION here, as rounding angles is bad
 347
 348     self.blocked = rotating_blocked;
 349
 350         // wait for targets to spawn
 351         self.nextthink = self.ltime + 999999999;
 352         self.think = SUB_Null;
 353 };
 354
 355 .float height;
 356 void func_bobbing_controller_think()
 357 {
 358         local vector v;
 359         self.nextthink = time + 0.1;
 360         // calculate sinewave using makevectors
 361         makevectors((time * self.owner.cnt + self.owner.phase) * '0 1 0');
 362         v = self.owner.destvec + self.owner.movedir * v_forward_y;
 363         // * 10 so it will arrive in 0.1 sec
 364         self.owner.velocity = (v - self.owner.origin) * 10;
 365 };
 366
 367 void bobbing_blocked()
 368 {
 369         // no need to duplicate code
 370         rotating_blocked();
 371 }
 372
 373 /*QUAKED spawnfunc_func_bobbing (0 .5 .8) ? X_AXIS Y_AXIS
 374 Brush model that moves back and forth on one axis (default Z).
 375 speed : how long one cycle takes in seconds (default 4)
 376 height : how far the cycle moves (default 32)
 377 phase : cycle timing adjustment (0-1 as a fraction of the cycle, default 0)
 378 noise : path/name of looping .wav file to play.
 379 dmg : Do this mutch dmg every .dmgtime intervall when blocked
 380 dmgtime : See above.
 381 */
 382 void spawnfunc_func_bobbing()
 383 {
 384         local entity controller;
 385         if (self.noise)
 386         {
 387                 precache_sound(self.noise);
 388                 ambientsound(self.origin, self.noise, VOL_BASE, ATTN_IDLE);
 389         }
 390         if (!self.speed)
 391                 self.speed = 4;
 392         if (!self.height)
 393                 self.height = 32;
 394         // center of bobbing motion
 395         self.destvec = self.origin;
 396         // time scale to get degrees
 397         self.cnt = 360 / self.speed;
 398
 399         // damage when blocked
 400         self.blocked = bobbing_blocked;
 401         if(self.dmg & (!self.message))
 402                 self.message = " was in the wrong place.";
 403         if(self.dmg && (!self.dmgtime))
 404                 self.dmgtime = 0.25;
 405         self.dmgtime2 = time;
 406
 407         // how far to bob
 408         if (self.spawnflags & 1) // X
 409                 self.movedir = '1 0 0' * self.height;
 410         else if (self.spawnflags & 2) // Y
 411                 self.movedir = '0 1 0' * self.height;
 412         else // Z
 413                 self.movedir = '0 0 1' * self.height;
 414
 415         InitMovingBrushTrigger();
 416
 417         // wait for targets to spawn
 418         controller = spawn();
 419         controller.classname = "func_bobbing_controller";
 420         controller.owner = self;
 421         controller.nextthink = time + 1;
 422         controller.think = func_bobbing_controller_think;
 423         self.nextthink = self.ltime + 999999999;
 424         self.think = SUB_Null;
 425
 426         // Savage: Reduce bandwith, critical on e.g. nexdm02
 427         self.effects |= EF_LOWPRECISION;
 428 };
 429
 430 // button and multiple button
 431
 432 void() button_wait;
 433 void() button_return;
 434
 435 void button_wait()
 436 {
 437         self.state = STATE_TOP;
 438         self.nextthink = self.ltime + self.wait;
 439         self.think = button_return;
 440         activator = self.enemy;
 441         SUB_UseTargets();
 442         self.frame = 1;                 // use alternate textures
 443 };
 444
 445 void button_done()
 446 {
 447         self.state = STATE_BOTTOM;
 448 };
 449
 450 void button_return()
 451 {
 452         self.state = STATE_DOWN;
 453         SUB_CalcMove (self.pos1, self.speed, button_done);
 454         self.frame = 0;                 // use normal textures
 455         if (self.health)
 456                 self.takedamage = DAMAGE_YES;   // can be shot again
 457 };
 458
 459
 460 void button_blocked()
 461 {
 462         // do nothing, just don't come all the way back out
 463 };
 464
 465
 466 void button_fire()
 467 {
 468         self.health = self.max_health;
 469         self.takedamage = DAMAGE_NO;    // will be reset upon return
 470
 471         if (self.state == STATE_UP || self.state == STATE_TOP)
 472                 return;
 473
 474         if (self.noise != "")
 475                 sound (self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_NORM);
 476
 477         self.state = STATE_UP;
 478         SUB_CalcMove (self.pos2, self.speed, button_wait);
 479 };
 480
 481
 482 void button_use()
 483 {
 484 //      if (activator.classname != "player")
 485 //      {
 486 //              dprint(activator.classname);
 487 //              dprint(" triggered a button\n");
 488 //      }
 489         self.enemy = activator;
 490         button_fire ();
 491 };
 492
 493 void button_touch()
 494 {
 495 //      if (activator.classname != "player")
 496 //      {
 497 //              dprint(activator.classname);
 498 //              dprint(" touched a button\n");
 499 //      }
 500         if (!other)
 501                 return;
 502         if (other.classname != "player")
 503                 return;
 504         self.enemy = other;
 505         if (other.owner)
 506                 self.enemy = other.owner;
 507         button_fire ();
 508 };
 509
 510 void button_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 511 {
 512         self.health = self.health - damage;
 513         if (self.health <= 0)
 514         {
 515         //      if (activator.classname != "player")
 516         //      {
 517         //              dprint(activator.classname);
 518         //              dprint(" killed a button\n");
 519         //      }
 520                 self.enemy = damage_attacker;
 521                 button_fire ();
 522         }
 523 };
 524
 525
 526 /*QUAKED spawnfunc_func_button (0 .5 .8) ?
 527 When a button is touched, it moves some distance in the direction of it's angle, triggers all of it's targets, waits some time, then returns to it's original position where it can be triggered again.
 528
 529 "angle"         determines the opening direction
 530 "target"        all entities with a matching targetname will be used
 531 "speed"         override the default 40 speed
 532 "wait"          override the default 1 second wait (-1 = never return)
 533 "lip"           override the default 4 pixel lip remaining at end of move
 534 "health"        if set, the button must be killed instead of touched. If set to -1, the button will fire on ANY attack, even damageless ones like the MinstaGib laser
 535 "sounds"
 536 0) steam metal
 537 1) wooden clunk
 538 2) metallic click
 539 3) in-out
 540 */
 541 void spawnfunc_func_button()
 542 {
 543         SetMovedir ();
 544
 545         InitMovingBrushTrigger();
 546         self.effects |= EF_LOWPRECISION;
 547
 548         self.blocked = button_blocked;
 549         self.use = button_use;
 550
 551 //      if (self.health == 0) // all buttons are now shootable
 552 //              self.health = 10;
 553         if (self.health)
 554         {
 555                 self.max_health = self.health;
 556                 self.event_damage = button_damage;
 557                 self.takedamage = DAMAGE_YES;
 558         }
 559         else
 560                 self.touch = button_touch;
 561
 562         if (!self.speed)
 563                 self.speed = 40;
 564         if (!self.wait)
 565                 self.wait = 1;
 566         if (!self.lip)
 567                 self.lip = 4;
 568
 569     if(self.noise != "")
 570         precache_sound(self.noise);
 571
 572         self.state = STATE_BOTTOM;
 573
 574         self.pos1 = self.origin;
 575         self.pos2 = self.pos1 + self.movedir*(fabs(self.movedir*self.size) - self.lip);
 576 };
 577
 578
 579 float DOOR_START_OPEN = 1;
 580 float DOOR_DONT_LINK = 4;
 581 float DOOR_TOGGLE = 32;
 582
 583 /*
 584
 585 Doors are similar to buttons, but can spawn a fat trigger field around them
 586 to open without a touch, and they link together to form simultanious
 587 double/quad doors.
 588
 589 Door.owner is the master door.  If there is only one door, it points to itself.
 590 If multiple doors, all will point to a single one.
 591
 592 Door.enemy chains from the master door through all doors linked in the chain.
 593
 594 */
 595
 596 /*
 597 =============================================================================
 598
 599 THINK FUNCTIONS
 600
 601 =============================================================================
 602 */
 603
 604 void() door_go_down;
 605 void() door_go_up;
 606
 607 void door_blocked()
 608 {
 609
 610     if((self.spawnflags & 8) && (other.takedamage != DAMAGE_NO)) { // KIll Kill Kill!!
 611         Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 612     } else {
 613
 614         if((self.dmg) && (other.takedamage == DAMAGE_YES))    // Shall we bite?
 615             Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 616
 617          //Dont chamge direction for dead or dying stuff
 618         if(other.deadflag != DEAD_NO && (other.takedamage == DAMAGE_NO)) {
 619             if (self.wait >= 0)
 620             {
 621                 if (self.state == STATE_DOWN)
 622                     door_go_up ();
 623                 else
 624                     door_go_down ();
 625             }
 626         } else {
 627             //gib dying stuff just to make sure
 628             if((self.dmg) && (other.takedamage != DAMAGE_NO))    // Shall we bite?
 629                 Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
 630         }
 631     }
 632
 633         //T_Damage (other, self, self, self.dmg, self.dmg, self.deathtype, DT_IMPACT, (self.absmin + self.absmax) * 0.5, '0 0 0', Obituary_Generic);
 634 // if a door has a negative wait, it would never come back if blocked,
 635 // so let it just squash the object to death real fast
 636 /*      if (self.wait >= 0)
 637         {
 638                 if (self.state == STATE_DOWN)
 639                         door_go_up ();
 640                 else
 641                         door_go_down ();
 642         }
 643 */
 644 };
 645
 646
 647 void door_hit_top()
 648 {
 649         if (self.noise1 != "")
 650                 sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
 651         self.state = STATE_TOP;
 652         if (self.spawnflags & DOOR_TOGGLE)
 653                 return;         // don't come down automatically
 654         self.think = door_go_down;
 655         self.nextthink = self.ltime + self.wait;
 656 };
 657
 658 void door_hit_bottom()
 659 {
 660         if (self.noise1 != "")
 661                 sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
 662         self.state = STATE_BOTTOM;
 663 };
 664
 665 void door_go_down()
 666 {
 667         if (self.noise2 != "")
 668                 sound (self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
 669         if (self.max_health)
 670         {
 671                 self.takedamage = DAMAGE_YES;
 672                 self.health = self.max_health;
 673         }
 674
 675         self.state = STATE_DOWN;
 676         SUB_CalcMove (self.pos1, self.speed, door_hit_bottom);
 677 };
 678
 679 void door_go_up()
 680 {
 681         if (self.state == STATE_UP)
 682                 return;         // allready going up
 683
 684         if (self.state == STATE_TOP)
 685         {       // reset top wait time
 686                 self.nextthink = self.ltime + self.wait;
 687                 return;
 688         }
 689
 690         if (self.noise2 != "")
 691                 sound (self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
 692         self.state = STATE_UP;
 693         SUB_CalcMove (self.pos2, self.speed, door_hit_top);
 694
 695         SUB_UseTargets();
 696 };
 697
 698
 699 /*
 700 =============================================================================
 701
 702 ACTIVATION FUNCTIONS
 703
 704 =============================================================================
 705 */
 706
 707 void door_fire()
 708 {
 709         local entity    oself;
 710         local entity    starte;
 711         string oldmessage;
 712
 713         if (self.owner != self)
 714                 objerror ("door_fire: self.owner != self");
 715
 716         oldmessage = self.message;
 717         self.message = ""; // no more message
 718         oself = self;
 719
 720         if (self.spawnflags & DOOR_TOGGLE)
 721         {
 722                 if (self.state == STATE_UP || self.state == STATE_TOP)
 723                 {
 724                         starte = self;
 725                         do
 726                         {
 727                                 door_go_down ();
 728                                 self = self.enemy;
 729                         } while ( (self != starte) && (self != world) );
 730                         self = oself;
 731                         return;
 732                 }
 733         }
 734
 735 // trigger all paired doors
 736         starte = self;
 737         do
 738         {
 739                 door_go_up ();
 740                 self = self.enemy;
 741         } while ( (self != starte) && (self != world) );
 742         self = oself;
 743
 744         self.message = oldmessage;
 745 };
 746
 747
 748 void door_use()
 749 {
 750         local entity oself;
 751
 752         //dprint("door_use (model: ");dprint(self.model);dprint(")\n");
 753         if (self.owner)
 754         {
 755                 oself = self;
 756                 self = self.owner;
 757                 door_fire ();
 758                 self = oself;
 759         }
 760 };
 761
 762
 763 void door_trigger_touch()
 764 {
 765         if (other.health < 1)
 766                 return;
 767
 768         if (time < self.attack_finished_single)
 769                 return;
 770         self.attack_finished_single = time + 1;
 771
 772         activator = other;
 773
 774         self = self.owner;
 775         door_use ();
 776 };
 777
 778
 779 void door_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 780 {
 781         local entity oself;
 782         self.health = self.health - damage;
 783         if (self.health <= 0)
 784         {
 785                 oself = self;
 786                 self = self.owner;
 787                 self.health = self.max_health;
 788                 self.takedamage = DAMAGE_NO;    // wil be reset upon return
 789                 door_use ();
 790                 self = oself;
 791         }
 792 };
 793
 794
 795 /*
 796 ================
 797 door_touch
 798
 799 Prints messages
 800 ================
 801 */
 802 void door_touch()
 803 {
 804         if (other.classname != "player")
 805                 return;
 806         if (self.owner.attack_finished_single > time)
 807                 return;
 808
 809         self.owner.attack_finished_single = time + 2;
 810
 811         if (self.owner.message != "")
 812         {
 813                 if (other.flags & FL_CLIENT)
 814                         centerprint (other, self.owner.message);
 815                 play2(other, "misc/talk.wav");
 816         }
 817 };
 818
 819 /*
 820 =============================================================================
 821
 822 SPAWNING FUNCTIONS
 823
 824 =============================================================================
 825 */
 826
 827
 828 entity spawn_field(vector fmins, vector fmaxs)
 829 {
 830         local entity    trigger;
 831         local   vector  t1, t2;
 832
 833         trigger = spawn();
 834         trigger.classname = "doortriggerfield";
 835         trigger.movetype = MOVETYPE_NONE;
 836         trigger.solid = SOLID_TRIGGER;
 837         trigger.owner = self;
 838         trigger.touch = door_trigger_touch;
 839
 840         t1 = fmins;
 841         t2 = fmaxs;
 842         setsize (trigger, t1 - '60 60 8', t2 + '60 60 8');
 843         return (trigger);
 844 };
 845
 846
 847 float EntitiesTouching(entity e1, entity e2)
 848 {
 849         if (e1.mins_x > e2.maxs_x)
 850                 return FALSE;
 851         if (e1.mins_y > e2.maxs_y)
 852                 return FALSE;
 853         if (e1.mins_z > e2.maxs_z)
 854                 return FALSE;
 855         if (e1.maxs_x < e2.mins_x)
 856                 return FALSE;
 857         if (e1.maxs_y < e2.mins_y)
 858                 return FALSE;
 859         if (e1.maxs_z < e2.mins_z)
 860                 return FALSE;
 861         return TRUE;
 862 };
 863
 864
 865 /*
 866 =============
 867 LinkDoors
 868
 869
 870 =============
 871 */
 872 void LinkDoors()
 873 {
 874         local entity    t, starte;
 875         local vector    cmins, cmaxs;
 876
 877         if (self.enemy)
 878                 return;         // already linked by another door
 879         if (self.spawnflags & 4)
 880         {
 881                 self.owner = self.enemy = self;
 882                 return;         // don't want to link this door
 883         }
 884
 885         cmins = self.mins;
 886         cmaxs = self.maxs;
 887
 888         starte = self;
 889         t = self;
 890
 891         do
 892         {
 893                 self.owner = starte;                    // master door
 894
 895                 if (self.health)
 896                         starte.health = self.health;
 897                 IFTARGETED
 898                         starte.targetname = self.targetname;
 899                 if (self.message != "")
 900                         starte.message = self.message;
 901
 902                 t = find(t, classname, self.classname);
 903                 if (!t)
 904                 {
 905                         self.enemy = starte;            // make the chain a loop
 906
 907                 // shootable, or triggered doors just needed the owner/enemy links,
 908                 // they don't spawn a field
 909
 910                         self = self.owner;
 911
 912                         if (self.health)
 913                                 return;
 914                         IFTARGETED
 915                                 return;
 916                         if (self.items)
 917                                 return;
 918
 919                         self.owner.trigger_field = spawn_field(cmins, cmaxs);
 920
 921                         return;
 922                 }
 923
 924                 if (EntitiesTouching(self,t))
 925                 {
 926                         if (t.enemy)
 927                                 objerror ("cross connected doors");
 928
 929                         self.enemy = t;
 930                         self = t;
 931
 932                         if (t.mins_x < cmins_x)
 933                                 cmins_x = t.mins_x;
 934                         if (t.mins_y < cmins_y)
 935                                 cmins_y = t.mins_y;
 936                         if (t.mins_z < cmins_z)
 937                                 cmins_z = t.mins_z;
 938                         if (t.maxs_x > cmaxs_x)
 939                                 cmaxs_x = t.maxs_x;
 940                         if (t.maxs_y > cmaxs_y)
 941                                 cmaxs_y = t.maxs_y;
 942                         if (t.maxs_z > cmaxs_z)
 943                                 cmaxs_z = t.maxs_z;
 944                 }
 945         } while (1 );
 946
 947 };
 948
 949
 950 /*QUAKED spawnfunc_func_door (0 .5 .8) ? START_OPEN x DOOR_DONT_LINK x x TOGGLE
 951 if two doors touch, they are assumed to be connected and operate as a unit.
 952
 953 TOGGLE causes the door to wait in both the start and end states for a trigger event.
 954
 955 START_OPEN causes the door to move to its destination when spawned, and operate in reverse.  It is used to temporarily or permanently close off an area when triggered (not usefull for touch or takedamage doors).
 956
 957 "message"       is printed when the door is touched if it is a trigger door and it hasn't been fired yet
 958 "angle"         determines the opening direction
 959 "targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
 960 "health"        if set, door must be shot open
 961 "speed"         movement speed (100 default)
 962 "wait"          wait before returning (3 default, -1 = never return)
 963 "lip"           lip remaining at end of move (8 default)
 964 "dmg"           damage to inflict when blocked (2 default)
 965 "sounds"
 966 0)      no sound
 967 1)      stone
 968 2)      base
 969 3)      stone chain
 970 4)      screechy metal
 971 FIXME: only one sound set available at the time being
 972
 973 */
 974
 975 void door_init_startopen()
 976 {
 977         setorigin (self, self.pos2);
 978         self.pos2 = self.pos1;
 979         self.pos1 = self.origin;
 980 }
 981
 982 void spawnfunc_func_door()
 983 {
 984         //if (!self.deathtype) // map makers can override this
 985         //      self.deathtype = " got in the way";
 986         SetMovedir ();
 987
 988         self.max_health = self.health;
 989         InitMovingBrushTrigger();
 990         self.effects |= EF_LOWPRECISION;
 991         self.classname = "door";
 992
 993         self.blocked = door_blocked;
 994         self.use = door_use;
 995
 996     if(self.spawnflags & 8)
 997         self.dmg = 10000;
 998
 999     if(self.dmg & (!self.message))
1000                 self.message = "was in the wrong place.";
1001
1002
1003
1004         if (self.sounds > 0)
1005         {
1006                 precache_sound ("plats/medplat1.wav");
1007                 precache_sound ("plats/medplat2.wav");
1008                 self.noise2 = "plats/medplat1.wav";
1009                 self.noise1 = "plats/medplat2.wav";
1010         }
1011
1012         if (!self.speed)
1013                 self.speed = 100;
1014         if (!self.wait)
1015                 self.wait = 3;
1016         if (!self.lip)
1017                 self.lip = 8;
1018         if (!self.dmg)
1019                 self.dmg = 2;
1020
1021         self.pos1 = self.origin;
1022         self.pos2 = self.pos1 + self.movedir*(fabs(self.movedir*self.size) - self.lip);
1023
1024 // DOOR_START_OPEN is to allow an entity to be lighted in the closed position
1025 // but spawn in the open position
1026         if (self.spawnflags & DOOR_START_OPEN)
1027                 InitializeEntity(self, door_init_startopen, INITPRIO_SETLOCATION);
1028
1029         self.state = STATE_BOTTOM;
1030
1031         if (self.health)
1032         {
1033                 self.takedamage = DAMAGE_YES;
1034                 self.event_damage = door_damage;
1035         }
1036
1037         if (self.items)
1038                 self.wait = -1;
1039
1040         self.touch = door_touch;
1041
1042 // LinkDoors can't be done until all of the doors have been spawned, so
1043 // the sizes can be detected properly.
1044         InitializeEntity(self, LinkDoors, INITPRIO_LINKDOORS);
1045 };
1046
1047 /*
1048 =============================================================================
1049
1050 SECRET DOORS
1051
1052 =============================================================================
1053 */
1054
1055 void() fd_secret_move1;
1056 void() fd_secret_move2;
1057 void() fd_secret_move3;
1058 void() fd_secret_move4;
1059 void() fd_secret_move5;
1060 void() fd_secret_move6;
1061 void() fd_secret_done;
1062
1063 float SECRET_OPEN_ONCE = 1;             // stays open
1064 float SECRET_1ST_LEFT = 2;              // 1st move is left of arrow
1065 float SECRET_1ST_DOWN = 4;              // 1st move is down from arrow
1066 float SECRET_NO_SHOOT = 8;              // only opened by trigger
1067 float SECRET_YES_SHOOT = 16;    // shootable even if targeted
1068
1069
1070 void fd_secret_use()
1071 {
1072         local float temp;
1073         string message_save;
1074
1075         self.health = 10000;
1076         self.bot_attack = TRUE;
1077
1078         // exit if still moving around...
1079         if (self.origin != self.oldorigin)
1080                 return;
1081
1082         message_save = self.message;
1083         self.message = ""; // no more message
1084         SUB_UseTargets();                               // fire all targets / killtargets
1085         self.message = message_save;
1086
1087         self.velocity = '0 0 0';
1088
1089         // Make a sound, wait a little...
1090
1091         if (self.noise1 != "")
1092                 sound(self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
1093         self.nextthink = self.ltime + 0.1;
1094
1095         temp = 1 - (self.spawnflags & SECRET_1ST_LEFT); // 1 or -1
1096         makevectors(self.mangle);
1097
1098         if (!self.t_width)
1099         {
1100                 if (self.spawnflags & SECRET_1ST_DOWN)
1101                         self.t_width = fabs(v_up * self.size);
1102                 else
1103                         self.t_width = fabs(v_right * self.size);
1104         }
1105
1106         if (!self.t_length)
1107                 self.t_length = fabs(v_forward * self.size);
1108
1109         if (self.spawnflags & SECRET_1ST_DOWN)
1110                 self.dest1 = self.origin - v_up * self.t_width;
1111         else
1112                 self.dest1 = self.origin + v_right * (self.t_width * temp);
1113
1114         self.dest2 = self.dest1 + v_forward * self.t_length;
1115         SUB_CalcMove(self.dest1, self.speed, fd_secret_move1);
1116         if (self.noise2 != "")
1117                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1118 };
1119
1120 // Wait after first movement...
1121 void fd_secret_move1()
1122 {
1123         self.nextthink = self.ltime + 1.0;
1124         self.think = fd_secret_move2;
1125         if (self.noise3 != "")
1126                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1127 };
1128
1129 // Start moving sideways w/sound...
1130 void fd_secret_move2()
1131 {
1132         if (self.noise2 != "")
1133                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1134         SUB_CalcMove(self.dest2, self.speed, fd_secret_move3);
1135 };
1136
1137 // Wait here until time to go back...
1138 void fd_secret_move3()
1139 {
1140         if (self.noise3 != "")
1141                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1142         if (!(self.spawnflags & SECRET_OPEN_ONCE))
1143         {
1144                 self.nextthink = self.ltime + self.wait;
1145                 self.think = fd_secret_move4;
1146         }
1147 };
1148
1149 // Move backward...
1150 void fd_secret_move4()
1151 {
1152         if (self.noise2 != "")
1153                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1154         SUB_CalcMove(self.dest1, self.speed, fd_secret_move5);
1155 };
1156
1157 // Wait 1 second...
1158 void fd_secret_move5()
1159 {
1160         self.nextthink = self.ltime + 1.0;
1161         self.think = fd_secret_move6;
1162         if (self.noise3 != "")
1163                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1164 };
1165
1166 void fd_secret_move6()
1167 {
1168         if (self.noise2 != "")
1169                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1170         SUB_CalcMove(self.oldorigin, self.speed, fd_secret_done);
1171 };
1172
1173 void fd_secret_done()
1174 {
1175         if (self.spawnflags&SECRET_YES_SHOOT)
1176         {
1177                 self.health = 10000;
1178                 self.takedamage = DAMAGE_YES;
1179                 //self.th_pain = fd_secret_use;
1180         }
1181         if (self.noise3 != "")
1182                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1183 };
1184
1185 void secret_blocked()
1186 {
1187         if (time < self.attack_finished_single)
1188                 return;
1189         self.attack_finished_single = time + 0.5;
1190         //T_Damage (other, self, self, self.dmg, self.dmg, self.deathtype, DT_IMPACT, (self.absmin + self.absmax) * 0.5, '0 0 0', Obituary_Generic);
1191 };
1192
1193 /*
1194 ==============
1195 secret_touch
1196
1197 Prints messages
1198 ================
1199 */
1200 void secret_touch()
1201 {
1202         if (activator.classname != "player")
1203                 return;
1204         if (self.attack_finished_single > time)
1205                 return;
1206
1207         self.attack_finished_single = time + 2;
1208
1209         if (self.message)
1210         {
1211                 if (other.flags & FL_CLIENT)
1212                         centerprint (other, self.message);
1213                 play2(other, "misc/talk.wav");
1214         }
1215 };
1216
1217
1218 /*QUAKED spawnfunc_func_door_secret (0 .5 .8) ? open_once 1st_left 1st_down no_shoot always_shoot
1219 Basic secret door. Slides back, then to the side. Angle determines direction.
1220 wait  = # of seconds before coming back
1221 1st_left = 1st move is left of arrow
1222 1st_down = 1st move is down from arrow
1223 always_shoot = even if targeted, keep shootable
1224 t_width = override WIDTH to move back (or height if going down)
1225 t_length = override LENGTH to move sideways
1226 "dmg"           damage to inflict when blocked (2 default)
1227
1228 If a secret door has a targetname, it will only be opened by it's botton or trigger, not by damage.
1229 "sounds"
1230 1) medieval
1231 2) metal
1232 3) base
1233 */
1234
1235 void spawnfunc_func_door_secret()
1236 {
1237         /*if (!self.deathtype) // map makers can override this
1238                 self.deathtype = " got in the way";*/
1239
1240         if (!self.dmg)
1241                 self.dmg = 2;
1242
1243         // Magic formula...
1244         self.mangle = self.angles;
1245         self.angles = '0 0 0';
1246         self.classname = "door";
1247         InitMovingBrushTrigger();
1248         self.effects |= EF_LOWPRECISION;
1249
1250         self.touch = secret_touch;
1251         self.blocked = secret_blocked;
1252         self.speed = 50;
1253         self.use = fd_secret_use;
1254         IFTARGETED
1255         {
1256         }
1257         else
1258                 self.spawnflags |= SECRET_YES_SHOOT;
1259
1260         if(self.spawnflags&SECRET_YES_SHOOT)
1261         {
1262                 self.health = 10000;
1263                 self.takedamage = DAMAGE_YES;
1264                 self.event_damage = fd_secret_use;
1265         }
1266         self.oldorigin = self.origin;
1267         if (!self.wait)
1268                 self.wait = 5;          // 5 seconds before closing
1269 };
1270