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