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