spawnflag 256 on most damageable entities = ignore splash damage
[divverent/nexuiz.git] / data / qcsrc / server / t_plats.qc
1 .float dmgtime2;
2 void generic_plat_blocked()
3 {
4     if(self.dmg && other.takedamage != DAMAGE_NO) {
5         if(self.dmgtime2 < time) {
6             Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
7             self.dmgtime2 = time + self.dmgtime;
8         }
9
10         // Gib dead/dying stuff
11         if(other.deadflag != DEAD_NO)
12             Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
13     }
14 }
15
16
17 float   STATE_TOP               = 0;
18 float   STATE_BOTTOM    = 1;
19 float   STATE_UP                = 2;
20 float   STATE_DOWN              = 3;
21
22 .entity trigger_field;
23
24 void() plat_center_touch;
25 void() plat_outside_touch;
26 void() plat_trigger_use;
27 void() plat_go_up;
28 void() plat_go_down;
29 void() plat_crush;
30 float PLAT_LOW_TRIGGER = 1;
31
32 void plat_spawn_inside_trigger()
33 {
34         local entity trigger;
35         local vector tmin, tmax;
36
37         trigger = spawn();
38         trigger.touch = plat_center_touch;
39         trigger.movetype = MOVETYPE_NONE;
40         trigger.solid = SOLID_TRIGGER;
41         trigger.enemy = self;
42
43         tmin = self.absmin + '25 25 0';
44         tmax = self.absmax - '25 25 -8';
45         tmin_z = tmax_z - (self.pos1_z - self.pos2_z + 8);
46         if (self.spawnflags & PLAT_LOW_TRIGGER)
47                 tmax_z = tmin_z + 8;
48
49         if (self.size_x <= 50)
50         {
51                 tmin_x = (self.mins_x + self.maxs_x) / 2;
52                 tmax_x = tmin_x + 1;
53         }
54         if (self.size_y <= 50)
55         {
56                 tmin_y = (self.mins_y + self.maxs_y) / 2;
57                 tmax_y = tmin_y + 1;
58         }
59
60         setsize (trigger, tmin, tmax);
61 };
62
63 void plat_hit_top()
64 {
65         sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
66         self.state = 1;
67         self.think = plat_go_down;
68         self.nextthink = self.ltime + 3;
69 };
70
71 void plat_hit_bottom()
72 {
73         sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
74         self.state = 2;
75 };
76
77 void plat_go_down()
78 {
79         sound (self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_NORM);
80         self.state = 3;
81         SUB_CalcMove (self.pos2, self.speed, plat_hit_bottom);
82 };
83
84 void plat_go_up()
85 {
86         sound (self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_NORM);
87         self.state = 4;
88         SUB_CalcMove (self.pos1, self.speed, plat_hit_top);
89 };
90
91 void plat_center_touch()
92 {
93         if not(other.iscreature)
94                 return;
95
96         if (other.health <= 0)
97                 return;
98
99         self = self.enemy;
100         if (self.state == 2)
101                 plat_go_up ();
102         else if (self.state == 1)
103                 self.nextthink = self.ltime + 1;        // delay going down
104 };
105
106 void plat_outside_touch()
107 {
108         if not(other.iscreature)
109                 return;
110
111         if (other.health <= 0)
112                 return;
113
114         self = self.enemy;
115         if (self.state == 1)
116                 plat_go_down ();
117 };
118
119 void plat_trigger_use()
120 {
121         if (self.think)
122                 return;         // already activated
123         plat_go_down();
124 };
125
126
127 void plat_crush()
128 {
129     if((self.spawnflags & 4) && (other.takedamage != DAMAGE_NO)) { // KIll Kill Kill!!
130         Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
131     } else {
132         if((self.dmg) && (other.takedamage != DAMAGE_NO)) {   // Shall we bite?
133             Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
134             // Gib dead/dying stuff
135             if(other.deadflag != DEAD_NO)
136                 Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
137         }
138
139         if (self.state == 4)
140             plat_go_down ();
141         else if (self.state == 3)
142             plat_go_up ();
143         else
144             objerror ("plat_crush: bad self.state\n");
145     }
146 };
147
148 void plat_use()
149 {
150         self.use = SUB_Null;
151         if (self.state != 4)
152                 objerror ("plat_use: not in up state");
153         plat_go_down();
154 };
155
156 .string sound1, sound2;
157
158 void plat_reset()
159 {
160         IFTARGETED
161         {
162                 setorigin (self, self.pos1);
163                 self.state = 4;
164                 self.use = plat_use;
165         }
166         else
167         {
168                 setorigin (self, self.pos2);
169                 self.state = 2;
170                 self.use = plat_trigger_use;
171         }
172 }
173
174 void spawnfunc_path_corner() { };
175 void spawnfunc_func_plat()
176 {
177         if (!self.t_length)
178                 self.t_length = 80;
179         if (!self.t_width)
180                 self.t_width = 10;
181
182         if (self.sounds == 0)
183                 self.sounds = 2;
184
185     if(self.spawnflags & 4)
186         self.dmg = 10000;
187
188     if(self.dmg && (!self.message))
189                 self.message = "was squished";
190     if(self.dmg && (!self.message2))
191                 self.message2 = "was squished by";
192
193         if (self.sounds == 1)
194         {
195                 precache_sound ("plats/plat1.wav");
196                 precache_sound ("plats/plat2.wav");
197                 self.noise = "plats/plat1.wav";
198                 self.noise1 = "plats/plat2.wav";
199         }
200
201         if (self.sounds == 2)
202         {
203                 precache_sound ("plats/medplat1.wav");
204                 precache_sound ("plats/medplat2.wav");
205                 self.noise = "plats/medplat1.wav";
206                 self.noise1 = "plats/medplat2.wav";
207         }
208
209         if (self.sound1)
210         {
211                 precache_sound (self.sound1);
212                 self.noise = self.sound1;
213         }
214         if (self.sound2)
215         {
216                 precache_sound (self.sound2);
217                 self.noise1 = self.sound2;
218         }
219
220         self.mangle = self.angles;
221         self.angles = '0 0 0';
222
223         self.classname = "plat";
224         if not(InitMovingBrushTrigger())
225                 return;
226         self.effects |= EF_LOWPRECISION;
227         setsize (self, self.mins , self.maxs);
228
229         self.blocked = plat_crush;
230
231         if (!self.speed)
232                 self.speed = 150;
233
234         self.pos1 = self.origin;
235         self.pos2 = self.origin;
236         self.pos2_z = self.origin_z - self.size_z + 8;
237
238         plat_spawn_inside_trigger ();   // the "start moving" trigger
239
240         self.reset = plat_reset;
241         plat_reset();
242 };
243
244
245 void() train_next;
246 void train_wait()
247 {
248         self.think = train_next;
249         self.nextthink = self.ltime + self.wait;
250
251         if(self.noise != "")
252                 stopsoundto(MSG_BROADCAST, self, CHAN_TRIGGER); // send this as unreliable only, as the train will resume operation shortly anyway
253 };
254
255 void train_next()
256 {
257         local entity targ;
258         targ = find(world, targetname, self.target);
259         self.target = targ.target;
260         if (!self.target)
261                 objerror("train_next: no next target");
262         self.wait = targ.wait;
263         if (!self.wait)
264                 self.wait = 0.1;
265         if(self.wait < 0)
266         {
267                 if (targ.speed)
268                         SUB_CalcMove(targ.origin - self.mins, targ.speed, train_next);
269                 else
270                         SUB_CalcMove(targ.origin - self.mins, self.speed, train_next);
271         }
272         else
273         {
274                 if (targ.speed)
275                         SUB_CalcMove(targ.origin - self.mins, targ.speed, train_wait);
276                 else
277                         SUB_CalcMove(targ.origin - self.mins, self.speed, train_wait);
278         }
279
280         if(self.noise != "")
281                 sound(self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_IDLE);
282 };
283
284 void func_train_find()
285 {
286         local entity targ;
287         targ = find(world, targetname, self.target);
288         self.target = targ.target;
289         if (!self.target)
290                 objerror("func_train_find: no next target");
291         setorigin(self, targ.origin - self.mins);
292         self.nextthink = self.ltime + 1;
293         self.think = train_next;
294 };
295
296 /*QUAKED spawnfunc_func_train (0 .5 .8) ?
297 Ridable platform, targets spawnfunc_path_corner path to follow.
298 speed : speed the train moves (can be overridden by each spawnfunc_path_corner)
299 target : targetname of first spawnfunc_path_corner (starts here)
300 */
301 void spawnfunc_func_train()
302 {
303         if (self.noise != "")
304                 precache_sound(self.noise);
305
306         if (!self.target)
307                 objerror("func_train without a target");
308         if (!self.speed)
309                 self.speed = 100;
310
311         if not(InitMovingBrushTrigger())
312                 return;
313         self.effects |= EF_LOWPRECISION;
314
315         // wait for targets to spawn
316         InitializeEntity(self, func_train_find, INITPRIO_SETLOCATION);
317
318         self.blocked = generic_plat_blocked;
319         if(self.dmg & (!self.message))
320                 self.message = " was squished";
321     if(self.dmg && (!self.message2))
322                 self.message2 = "was squished by";
323         if(self.dmg && (!self.dmgtime))
324                 self.dmgtime = 0.25;
325         self.dmgtime2 = time;
326
327         // TODO make a reset function for this one
328 };
329
330 /*QUAKED spawnfunc_func_rotating (0 .5 .8) ? - - X_AXIS Y_AXIS
331 Brush model that spins in place on one axis (default Z).
332 speed   : speed to rotate (in degrees per second)
333 noise   : path/name of looping .wav file to play.
334 dmg     : Do this mutch dmg every .dmgtime intervall when blocked
335 dmgtime : See above.
336 */
337
338 void spawnfunc_func_rotating()
339 {
340         if (self.noise != "")
341         {
342                 precache_sound(self.noise);
343                 ambientsound(self.origin, self.noise, VOL_BASE, ATTN_IDLE);
344         }
345         if (!self.speed)
346                 self.speed = 100;
347         // FIXME: test if this turns the right way, then remove this comment (negate as needed)
348         if (self.spawnflags & 4) // X (untested)
349                 self.avelocity = '0 0 1' * self.speed;
350         // FIXME: test if this turns the right way, then remove this comment (negate as needed)
351         else if (self.spawnflags & 8) // Y (untested)
352                 self.avelocity = '1 0 0' * self.speed;
353         // FIXME: test if this turns the right way, then remove this comment (negate as needed)
354         else // Z
355                 self.avelocity = '0 1 0' * self.speed;
356
357     if(self.dmg & (!self.message))
358         self.message = " was squished";
359     if(self.dmg && (!self.message2))
360                 self.message2 = "was squished by";
361
362
363     if(self.dmg && (!self.dmgtime))
364         self.dmgtime = 0.25;
365
366     self.dmgtime2 = time;
367
368         if not(InitMovingBrushTrigger())
369                 return;
370         // no EF_LOWPRECISION here, as rounding angles is bad
371
372     self.blocked = generic_plat_blocked;
373
374         // wait for targets to spawn
375         self.nextthink = self.ltime + 999999999;
376         self.think = SUB_Null;
377
378         // TODO make a reset function for this one
379 };
380
381 .float height;
382 void func_bobbing_controller_think()
383 {
384         local vector v;
385         self.nextthink = time + 0.1;
386         // calculate sinewave using makevectors
387         makevectors((self.nextthink * self.owner.cnt + self.owner.phase * 360) * '0 1 0');
388         v = self.owner.destvec + self.owner.movedir * v_forward_y;
389         // * 10 so it will arrive in 0.1 sec
390         self.owner.velocity = (v - self.owner.origin) * 10;
391 };
392
393 void bobbing_blocked()
394 {
395         // no need to duplicate code
396         generic_plat_blocked();
397 }
398
399 /*QUAKED spawnfunc_func_bobbing (0 .5 .8) ? X_AXIS Y_AXIS
400 Brush model that moves back and forth on one axis (default Z).
401 speed : how long one cycle takes in seconds (default 4)
402 height : how far the cycle moves (default 32)
403 phase : cycle timing adjustment (0-1 as a fraction of the cycle, default 0)
404 noise : path/name of looping .wav file to play.
405 dmg : Do this mutch dmg every .dmgtime intervall when blocked
406 dmgtime : See above.
407 */
408 void spawnfunc_func_bobbing()
409 {
410         local entity controller;
411         if (self.noise != "")
412         {
413                 precache_sound(self.noise);
414                 soundto(MSG_INIT, self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_IDLE);
415         }
416         if (!self.speed)
417                 self.speed = 4;
418         if (!self.height)
419                 self.height = 32;
420         // center of bobbing motion
421         self.destvec = self.origin;
422         // time scale to get degrees
423         self.cnt = 360 / self.speed;
424
425         // damage when blocked
426         self.blocked = bobbing_blocked;
427         if(self.dmg & (!self.message))
428                 self.message = " was squished";
429     if(self.dmg && (!self.message2))
430                 self.message2 = "was squished by";
431         if(self.dmg && (!self.dmgtime))
432                 self.dmgtime = 0.25;
433         self.dmgtime2 = time;
434
435         // how far to bob
436         if (self.spawnflags & 1) // X
437                 self.movedir = '1 0 0' * self.height;
438         else if (self.spawnflags & 2) // Y
439                 self.movedir = '0 1 0' * self.height;
440         else // Z
441                 self.movedir = '0 0 1' * self.height;
442
443         if not(InitMovingBrushTrigger())
444                 return;
445
446         // wait for targets to spawn
447         controller = spawn();
448         controller.classname = "func_bobbing_controller";
449         controller.owner = self;
450         controller.nextthink = time + 1;
451         controller.think = func_bobbing_controller_think;
452         self.nextthink = self.ltime + 999999999;
453         self.think = SUB_Null;
454
455         // Savage: Reduce bandwith, critical on e.g. nexdm02
456         self.effects |= EF_LOWPRECISION;
457
458         // TODO make a reset function for this one
459 };
460
461 // button and multiple button
462
463 void() button_wait;
464 void() button_return;
465
466 void button_wait()
467 {
468         self.state = STATE_TOP;
469         self.nextthink = self.ltime + self.wait;
470         self.think = button_return;
471         activator = self.enemy;
472         SUB_UseTargets();
473         self.frame = 1;                 // use alternate textures
474 };
475
476 void button_done()
477 {
478         self.state = STATE_BOTTOM;
479 };
480
481 void button_return()
482 {
483         self.state = STATE_DOWN;
484         SUB_CalcMove (self.pos1, self.speed, button_done);
485         self.frame = 0;                 // use normal textures
486         if (self.health)
487                 self.takedamage = DAMAGE_YES;   // can be shot again
488 };
489
490
491 void button_blocked()
492 {
493         // do nothing, just don't come all the way back out
494 };
495
496
497 void button_fire()
498 {
499         self.health = self.max_health;
500         self.takedamage = DAMAGE_NO;    // will be reset upon return
501
502         if (self.state == STATE_UP || self.state == STATE_TOP)
503                 return;
504
505         if (self.noise != "")
506                 sound (self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_NORM);
507
508         self.state = STATE_UP;
509         SUB_CalcMove (self.pos2, self.speed, button_wait);
510 };
511
512 void button_reset()
513 {
514         self.health = self.max_health;
515         setorigin(self, self.pos1);
516         self.frame = 0;                 // use normal textures
517         self.state = STATE_BOTTOM;
518         if (self.health)
519                 self.takedamage = DAMAGE_YES;   // can be shot again
520 }
521
522 void button_use()
523 {
524 //      if (activator.classname != "player")
525 //      {
526 //              dprint(activator.classname);
527 //              dprint(" triggered a button\n");
528 //      }
529         self.enemy = activator;
530         button_fire ();
531 };
532
533 void button_touch()
534 {
535 //      if (activator.classname != "player")
536 //      {
537 //              dprint(activator.classname);
538 //              dprint(" touched a button\n");
539 //      }
540         if (!other)
541                 return;
542         if not(other.iscreature)
543                 return;
544         if(other.velocity * self.movedir < 0)
545                 return;
546         self.enemy = other;
547         if (other.owner)
548                 self.enemy = other.owner;
549         button_fire ();
550 };
551
552 void button_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
553 {
554         if(self.spawnflags & DOOR_NOSPLASH)
555                 if(!(DEATH_ISSPECIAL(deathtype)) && (deathtype & HITTYPE_SPLASH))
556                         return;
557         self.health = self.health - damage;
558         if (self.health <= 0)
559         {
560         //      if (activator.classname != "player")
561         //      {
562         //              dprint(activator.classname);
563         //              dprint(" killed a button\n");
564         //      }
565                 self.enemy = damage_attacker;
566                 button_fire ();
567         }
568 };
569
570
571 /*QUAKED spawnfunc_func_button (0 .5 .8) ?
572 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.
573
574 "angle"         determines the opening direction
575 "target"        all entities with a matching targetname will be used
576 "speed"         override the default 40 speed
577 "wait"          override the default 1 second wait (-1 = never return)
578 "lip"           override the default 4 pixel lip remaining at end of move
579 "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
580 "sounds"
581 0) steam metal
582 1) wooden clunk
583 2) metallic click
584 3) in-out
585 */
586 void spawnfunc_func_button()
587 {
588         SetMovedir ();
589
590         if not(InitMovingBrushTrigger())
591                 return;
592         self.effects |= EF_LOWPRECISION;
593
594         self.blocked = button_blocked;
595         self.use = button_use;
596
597 //      if (self.health == 0) // all buttons are now shootable
598 //              self.health = 10;
599         if (self.health)
600         {
601                 self.max_health = self.health;
602                 self.event_damage = button_damage;
603                 self.takedamage = DAMAGE_YES;
604         }
605         else
606                 self.touch = button_touch;
607
608         if (!self.speed)
609                 self.speed = 40;
610         if (!self.wait)
611                 self.wait = 1;
612         if (!self.lip)
613                 self.lip = 4;
614
615     if(self.noise != "")
616         precache_sound(self.noise);
617
618         self.pos1 = self.origin;
619         self.pos2 = self.pos1 + self.movedir*(fabs(self.movedir*self.size) - self.lip);
620     self.flags |= FL_NOTARGET;
621
622         button_reset();
623 };
624
625
626 float DOOR_START_OPEN = 1;
627 float DOOR_DONT_LINK = 4;
628 float DOOR_TOGGLE = 32;
629
630 /*
631
632 Doors are similar to buttons, but can spawn a fat trigger field around them
633 to open without a touch, and they link together to form simultanious
634 double/quad doors.
635
636 Door.owner is the master door.  If there is only one door, it points to itself.
637 If multiple doors, all will point to a single one.
638
639 Door.enemy chains from the master door through all doors linked in the chain.
640
641 */
642
643 /*
644 =============================================================================
645
646 THINK FUNCTIONS
647
648 =============================================================================
649 */
650
651 void() door_go_down;
652 void() door_go_up;
653 void() door_rotating_go_down;
654 void() door_rotating_go_up;
655
656 void door_blocked()
657 {
658
659     if((self.spawnflags & 8) && (other.takedamage != DAMAGE_NO)) { // KIll Kill Kill!!
660         Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
661     } else {
662
663         if((self.dmg) && (other.takedamage == DAMAGE_YES))    // Shall we bite?
664             Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
665
666          //Dont chamge direction for dead or dying stuff
667         if(other.deadflag != DEAD_NO && (other.takedamage == DAMAGE_NO)) {
668             if (self.wait >= 0)
669             {
670                 if (self.state == STATE_DOWN)
671                         if (self.classname == "door")
672                         {
673                                 door_go_up ();
674                         } else
675                         {
676                                 door_rotating_go_up ();
677                         }
678                 else
679                         if (self.classname == "door")
680                         {
681                                 door_go_down ();
682                         } else
683                         {
684                                 door_rotating_go_down ();
685                         }
686             }
687         } else {
688             //gib dying stuff just to make sure
689             if((self.dmg) && (other.takedamage != DAMAGE_NO))    // Shall we bite?
690                 Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
691         }
692     }
693
694         //T_Damage (other, self, self, self.dmg, self.dmg, self.deathtype, DT_IMPACT, (self.absmin + self.absmax) * 0.5, '0 0 0', Obituary_Generic);
695 // if a door has a negative wait, it would never come back if blocked,
696 // so let it just squash the object to death real fast
697 /*      if (self.wait >= 0)
698         {
699                 if (self.state == STATE_DOWN)
700                         door_go_up ();
701                 else
702                         door_go_down ();
703         }
704 */
705 };
706
707
708 void door_hit_top()
709 {
710         if (self.noise1 != "")
711                 sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
712         self.state = STATE_TOP;
713         if (self.spawnflags & DOOR_TOGGLE)
714                 return;         // don't come down automatically
715         if (self.classname == "door")
716         {
717                 self.think = door_go_down;
718         } else
719         {
720                 self.think = door_rotating_go_down;
721         }
722         self.nextthink = self.ltime + self.wait;
723 };
724
725 void door_hit_bottom()
726 {
727         if (self.noise1 != "")
728                 sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
729         self.state = STATE_BOTTOM;
730 };
731
732 void door_go_down()
733 {
734         if (self.noise2 != "")
735                 sound (self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
736         if (self.max_health)
737         {
738                 self.takedamage = DAMAGE_YES;
739                 self.health = self.max_health;
740         }
741
742         self.state = STATE_DOWN;
743         SUB_CalcMove (self.pos1, self.speed, door_hit_bottom);
744 };
745
746 void door_go_up()
747 {
748         if (self.state == STATE_UP)
749                 return;         // already going up
750
751         if (self.state == STATE_TOP)
752         {       // reset top wait time
753                 self.nextthink = self.ltime + self.wait;
754                 return;
755         }
756
757         if (self.noise2 != "")
758                 sound (self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
759         self.state = STATE_UP;
760         SUB_CalcMove (self.pos2, self.speed, door_hit_top);
761
762         string oldmessage;
763         oldmessage = self.message;
764         self.message = "";
765         SUB_UseTargets();
766         self.message = oldmessage;
767 };
768
769
770 /*
771 =============================================================================
772
773 ACTIVATION FUNCTIONS
774
775 =============================================================================
776 */
777
778 void door_fire()
779 {
780         local entity    oself;
781         local entity    starte;
782
783         if (self.owner != self)
784                 objerror ("door_fire: self.owner != self");
785
786         oself = self;
787
788         if (self.spawnflags & DOOR_TOGGLE)
789         {
790                 if (self.state == STATE_UP || self.state == STATE_TOP)
791                 {
792                         starte = self;
793                         do
794                         {
795                                 if (self.classname == "door")
796                                 {
797                                         door_go_down ();
798                                 }
799                                 else
800                                 {
801                                         door_rotating_go_down ();
802                                 }
803                                 self = self.enemy;
804                         } while ( (self != starte) && (self != world) );
805                         self = oself;
806                         return;
807                 }
808         }
809
810 // trigger all paired doors
811         starte = self;
812         do
813         {
814                 if (self.classname == "door")
815                 {
816                         door_go_up ();
817                 } else
818                 {
819                         // if the BIDIR spawnflag (==2) is set and the trigger has set trigger_reverse, reverse the opening direction
820                         if ((self.spawnflags & 2) && other.trigger_reverse!=0 && self.lip!=666 && self.state == STATE_BOTTOM)
821                         {
822                                 self.lip = 666; // self.lip is used to remember reverse opening direction for door_rotating
823                                 self.pos2 = '0 0 0' - self.pos2;
824                         }
825                         // if BIDIR_IN_DOWN (==8) is set, prevent the door from reoping during closing if it is triggered from the wrong side
826                         if (!((self.spawnflags & 2) &&  (self.spawnflags & 8) && self.state == STATE_DOWN
827                             && (((self.lip==666) && (other.trigger_reverse==0)) || ((self.lip!=666) && (other.trigger_reverse!=0)))))
828                         {
829                                 door_rotating_go_up ();
830                         }
831                 }
832                 self = self.enemy;
833         } while ( (self != starte) && (self != world) );
834         self = oself;
835 };
836
837
838 void door_use()
839 {
840         local entity oself;
841
842         //dprint("door_use (model: ");dprint(self.model);dprint(")\n");
843         if (self.owner)
844         {
845                 oself = self;
846                 self = self.owner;
847                 door_fire ();
848                 self = oself;
849         }
850 };
851
852
853 void door_trigger_touch()
854 {
855         if (other.health < 1)
856         if not(other.iscreature && other.deadflag == DEAD_NO)
857                 return;
858
859         if (time < self.attack_finished_single)
860                 return;
861         self.attack_finished_single = time + 1;
862
863         activator = other;
864
865         self = self.owner;
866         door_use ();
867 };
868
869
870 void door_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
871 {
872         local entity oself;
873         if(self.spawnflags & DOOR_NOSPLASH)
874                 if(!(DEATH_ISSPECIAL(deathtype)) && (deathtype & HITTYPE_SPLASH))
875                         return;
876         self.health = self.health - damage;
877         if (self.health <= 0)
878         {
879                 oself = self;
880                 self = self.owner;
881                 self.health = self.max_health;
882                 self.takedamage = DAMAGE_NO;    // wil be reset upon return
883                 door_use ();
884                 self = oself;
885         }
886 };
887
888
889 /*
890 ================
891 door_touch
892
893 Prints messages
894 ================
895 */
896 void door_touch()
897 {
898         if(other.classname != "player")
899                 return;
900         if (self.owner.attack_finished_single > time)
901                 return;
902
903         self.owner.attack_finished_single = time + 2;
904
905         if (!(self.owner.dmg) && (self.owner.message != ""))
906         {
907                 if (other.flags & FL_CLIENT)
908                         centerprint (other, self.owner.message);
909                 play2(other, "misc/talk.wav");
910         }
911 };
912
913
914 void door_generic_plat_blocked()
915 {
916
917     if((self.spawnflags & 8) && (other.takedamage != DAMAGE_NO)) { // KIll Kill Kill!!
918         Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
919     } else {
920
921         if((self.dmg) && (other.takedamage == DAMAGE_YES))    // Shall we bite?
922             Damage (other, self, self, self.dmg, DEATH_HURTTRIGGER, other.origin, '0 0 0');
923
924          //Dont chamge direction for dead or dying stuff
925         if(other.deadflag != DEAD_NO && (other.takedamage == DAMAGE_NO)) {
926             if (self.wait >= 0)
927             {
928                 if (self.state == STATE_DOWN)
929                     door_rotating_go_up ();
930                 else
931                     door_rotating_go_down ();
932             }
933         } else {
934             //gib dying stuff just to make sure
935             if((self.dmg) && (other.takedamage != DAMAGE_NO))    // Shall we bite?
936                 Damage (other, self, self, 10000, DEATH_HURTTRIGGER, other.origin, '0 0 0');
937         }
938     }
939
940         //T_Damage (other, self, self, self.dmg, self.dmg, self.deathtype, DT_IMPACT, (self.absmin + self.absmax) * 0.5, '0 0 0', Obituary_Generic);
941 // if a door has a negative wait, it would never come back if blocked,
942 // so let it just squash the object to death real fast
943 /*      if (self.wait >= 0)
944         {
945                 if (self.state == STATE_DOWN)
946                         door_rotating_go_up ();
947                 else
948                         door_rotating_go_down ();
949         }
950 */
951 };
952
953
954 void door_rotating_hit_top()
955 {
956         if (self.noise1 != "")
957                 sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
958         self.state = STATE_TOP;
959         if (self.spawnflags & DOOR_TOGGLE)
960                 return;         // don't come down automatically
961         self.think = door_rotating_go_down;
962         self.nextthink = self.ltime + self.wait;
963 };
964
965 void door_rotating_hit_bottom()
966 {
967         if (self.noise1 != "")
968                 sound (self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
969         if (self.lip==666) // self.lip is used to remember reverse opening direction for door_rotating
970         {
971                 self.pos2 = '0 0 0' - self.pos2;
972                 self.lip = 0;
973         }
974         self.state = STATE_BOTTOM;
975 };
976
977 void door_rotating_go_down()
978 {
979         if (self.noise2 != "")
980                 sound (self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
981         if (self.max_health)
982         {
983                 self.takedamage = DAMAGE_YES;
984                 self.health = self.max_health;
985         }
986
987         self.state = STATE_DOWN;
988         SUB_CalcAngleMove (self.pos1, self.speed, door_rotating_hit_bottom);
989 };
990
991 void door_rotating_go_up()
992 {
993         if (self.state == STATE_UP)
994                 return;         // already going up
995
996         if (self.state == STATE_TOP)
997         {       // reset top wait time
998                 self.nextthink = self.ltime + self.wait;
999                 return;
1000         }
1001         if (self.noise2 != "")
1002                 sound (self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1003         self.state = STATE_UP;
1004         SUB_CalcAngleMove (self.pos2, self.speed, door_rotating_hit_top);
1005
1006         string oldmessage;
1007         oldmessage = self.message;
1008         self.message = "";
1009         SUB_UseTargets();
1010         self.message = oldmessage;
1011 };
1012
1013
1014
1015
1016 /*
1017 =============================================================================
1018
1019 SPAWNING FUNCTIONS
1020
1021 =============================================================================
1022 */
1023
1024
1025 entity spawn_field(vector fmins, vector fmaxs)
1026 {
1027         local entity    trigger;
1028         local   vector  t1, t2;
1029
1030         trigger = spawn();
1031         trigger.classname = "doortriggerfield";
1032         trigger.movetype = MOVETYPE_NONE;
1033         trigger.solid = SOLID_TRIGGER;
1034         trigger.owner = self;
1035         trigger.touch = door_trigger_touch;
1036
1037         t1 = fmins;
1038         t2 = fmaxs;
1039         setsize (trigger, t1 - '60 60 8', t2 + '60 60 8');
1040         return (trigger);
1041 };
1042
1043
1044 float EntitiesTouching(entity e1, entity e2)
1045 {
1046         if (e1.absmin_x > e2.absmax_x)
1047                 return FALSE;
1048         if (e1.absmin_y > e2.absmax_y)
1049                 return FALSE;
1050         if (e1.absmin_z > e2.absmax_z)
1051                 return FALSE;
1052         if (e1.absmax_x < e2.absmin_x)
1053                 return FALSE;
1054         if (e1.absmax_y < e2.absmin_y)
1055                 return FALSE;
1056         if (e1.absmax_z < e2.absmin_z)
1057                 return FALSE;
1058         return TRUE;
1059 };
1060
1061
1062 /*
1063 =============
1064 LinkDoors
1065
1066
1067 =============
1068 */
1069 void LinkDoors()
1070 {
1071         local entity    t, starte;
1072         local vector    cmins, cmaxs;
1073
1074         if (self.enemy)
1075                 return;         // already linked by another door
1076         if (self.spawnflags & 4)
1077         {
1078                 self.owner = self.enemy = self;
1079
1080                 if (self.health)
1081                         return;
1082                 IFTARGETED
1083                         return;
1084                 if (self.items)
1085                         return;
1086                 self.trigger_field = spawn_field(self.absmin, self.absmax);
1087
1088                 return;         // don't want to link this door
1089         }
1090
1091         cmins = self.absmin;
1092         cmaxs = self.absmax;
1093
1094         starte = self;
1095         t = self;
1096
1097         do
1098         {
1099                 self.owner = starte;                    // master door
1100
1101                 if (self.health)
1102                         starte.health = self.health;
1103                 IFTARGETED
1104                         starte.targetname = self.targetname;
1105                 if (self.message != "")
1106                         starte.message = self.message;
1107
1108                 t = find(t, classname, self.classname);
1109                 if (!t)
1110                 {
1111                         self.enemy = starte;            // make the chain a loop
1112
1113                 // shootable, or triggered doors just needed the owner/enemy links,
1114                 // they don't spawn a field
1115
1116                         self = self.owner;
1117
1118                         if (self.health)
1119                                 return;
1120                         IFTARGETED
1121                                 return;
1122                         if (self.items)
1123                                 return;
1124
1125                         self.owner.trigger_field = spawn_field(cmins, cmaxs);
1126
1127                         return;
1128                 }
1129
1130                 if (EntitiesTouching(self,t))
1131                 {
1132                         if (t.enemy)
1133                                 objerror ("cross connected doors");
1134
1135                         self.enemy = t;
1136                         self = t;
1137
1138                         if (t.absmin_x < cmins_x)
1139                                 cmins_x = t.absmin_x;
1140                         if (t.absmin_y < cmins_y)
1141                                 cmins_y = t.absmin_y;
1142                         if (t.absmin_z < cmins_z)
1143                                 cmins_z = t.absmin_z;
1144                         if (t.absmax_x > cmaxs_x)
1145                                 cmaxs_x = t.absmax_x;
1146                         if (t.absmax_y > cmaxs_y)
1147                                 cmaxs_y = t.absmax_y;
1148                         if (t.absmax_z > cmaxs_z)
1149                                 cmaxs_z = t.absmax_z;
1150                 }
1151         } while (1 );
1152
1153 };
1154
1155
1156 /*QUAKED spawnfunc_func_door (0 .5 .8) ? START_OPEN x DOOR_DONT_LINK x x TOGGLE
1157 if two doors touch, they are assumed to be connected and operate as a unit.
1158
1159 TOGGLE causes the door to wait in both the start and end states for a trigger event.
1160
1161 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 useful for touch or takedamage doors).
1162
1163 "message"       is printed when the door is touched if it is a trigger door and it hasn't been fired yet
1164 "angle"         determines the opening direction
1165 "targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
1166 "health"        if set, door must be shot open
1167 "speed"         movement speed (100 default)
1168 "wait"          wait before returning (3 default, -1 = never return)
1169 "lip"           lip remaining at end of move (8 default)
1170 "dmg"           damage to inflict when blocked (2 default)
1171 "sounds"
1172 0)      no sound
1173 1)      stone
1174 2)      base
1175 3)      stone chain
1176 4)      screechy metal
1177 FIXME: only one sound set available at the time being
1178
1179 */
1180
1181 void door_init_startopen()
1182 {
1183         setorigin (self, self.pos2);
1184         self.pos2 = self.pos1;
1185         self.pos1 = self.origin;
1186 }
1187
1188 void door_reset()
1189 {
1190         setorigin(self, self.pos1);
1191         self.velocity = '0 0 0';
1192         self.state = STATE_BOTTOM;
1193         self.think = SUB_Null;
1194 }
1195
1196 void spawnfunc_func_door()
1197 {
1198         //if (!self.deathtype) // map makers can override this
1199         //      self.deathtype = " got in the way";
1200         SetMovedir ();
1201
1202         self.max_health = self.health;
1203         if not(InitMovingBrushTrigger())
1204                 return;
1205         self.effects |= EF_LOWPRECISION;
1206         self.classname = "door";
1207
1208         self.blocked = door_blocked;
1209         self.use = door_use;
1210
1211     if(self.spawnflags & 8)
1212         self.dmg = 10000;
1213
1214     if(self.dmg && (!self.message))
1215                 self.message = "was squished";
1216     if(self.dmg && (!self.message2))
1217                 self.message2 = "was squished by";
1218
1219         if (self.sounds > 0)
1220         {
1221                 precache_sound ("plats/medplat1.wav");
1222                 precache_sound ("plats/medplat2.wav");
1223                 self.noise2 = "plats/medplat1.wav";
1224                 self.noise1 = "plats/medplat2.wav";
1225         }
1226
1227         if (!self.speed)
1228                 self.speed = 100;
1229         if (!self.wait)
1230                 self.wait = 3;
1231         if (!self.lip)
1232                 self.lip = 8;
1233
1234         self.pos1 = self.origin;
1235         self.pos2 = self.pos1 + self.movedir*(fabs(self.movedir*self.size) - self.lip);
1236
1237 // DOOR_START_OPEN is to allow an entity to be lighted in the closed position
1238 // but spawn in the open position
1239         if (self.spawnflags & DOOR_START_OPEN)
1240                 InitializeEntity(self, door_init_startopen, INITPRIO_SETLOCATION);
1241
1242         self.state = STATE_BOTTOM;
1243
1244         if (self.health)
1245         {
1246                 self.takedamage = DAMAGE_YES;
1247                 self.event_damage = door_damage;
1248         }
1249
1250         if (self.items)
1251                 self.wait = -1;
1252
1253         self.touch = door_touch;
1254
1255 // LinkDoors can't be done until all of the doors have been spawned, so
1256 // the sizes can be detected properly.
1257         InitializeEntity(self, LinkDoors, INITPRIO_LINKDOORS);
1258
1259         self.reset = door_reset;
1260 };
1261
1262 /*QUAKED spawnfunc_func_door_rotating (0 .5 .8) ? START_OPEN BIDIR DOOR_DONT_LINK BIDIR_IN_DOWN x TOGGLE X_AXIS Y_AXIS
1263 if two doors touch, they are assumed to be connected and operate as a unit.
1264
1265 TOGGLE causes the door to wait in both the start and end states for a trigger event.
1266
1267 BIDIR makes the door work bidirectional, so that the opening direction is always away from the requestor.
1268 The usage of bidirectional doors requires two manually instantiated triggers (trigger_multiple), the one to open it in the other direction
1269 must have set trigger_reverse to 1.
1270 BIDIR_IN_DOWN will the door prevent from reopening while closing if it is triggered from the other side.
1271
1272 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).
1273
1274 "message"       is printed when the door is touched if it is a trigger door and it hasn't been fired yet
1275 "angle"         determines the destination angle for opening. negative values reverse the direction.
1276 "targetname"    if set, no touch field will be spawned and a remote button or trigger field activates the door.
1277 "health"        if set, door must be shot open
1278 "speed"         movement speed (100 default)
1279 "wait"          wait before returning (3 default, -1 = never return)
1280 "dmg"           damage to inflict when blocked (2 default)
1281 "sounds"
1282 0)      no sound
1283 1)      stone
1284 2)      base
1285 3)      stone chain
1286 4)      screechy metal
1287 FIXME: only one sound set available at the time being
1288 */
1289
1290 void door_rotating_reset()
1291 {
1292         self.angles = self.pos1;
1293         self.avelocity = '0 0 0';
1294         self.state = STATE_BOTTOM;
1295         self.think = SUB_Null;
1296 }
1297
1298 void door_rotating_init_startopen()
1299 {
1300         self.angles = self.movedir;
1301         self.pos2 = '0 0 0';
1302         self.pos1 = self.movedir;
1303 }
1304
1305
1306 void spawnfunc_func_door_rotating()
1307 {
1308
1309         //if (!self.deathtype) // map makers can override this
1310         //      self.deathtype = " got in the way";
1311
1312         // I abuse "movedir" for denoting the axis for now
1313         if (self.spawnflags & 64) // X (untested)
1314                 self.movedir = '0 0 1';
1315         else if (self.spawnflags & 128) // Y (untested)
1316                 self.movedir = '1 0 0';
1317         else // Z
1318                 self.movedir = '0 1 0';
1319
1320         if (self.angles_y==0) self.angles_y = 90;
1321
1322         self.movedir = self.movedir * self.angles_y;
1323         self.angles = '0 0 0';
1324
1325         self.max_health = self.health;
1326         if not(InitMovingBrushTrigger())
1327                 return;
1328         //self.effects |= EF_LOWPRECISION;
1329         self.classname = "door_rotating";
1330
1331         self.blocked = door_blocked;
1332         self.use = door_use;
1333
1334     if(self.spawnflags & 8)
1335         self.dmg = 10000;
1336
1337     if(self.dmg && (!self.message))
1338                 self.message = "was squished";
1339     if(self.dmg && (!self.message2))
1340                 self.message2 = "was squished by";
1341
1342     if (self.sounds > 0)
1343         {
1344                 precache_sound ("plats/medplat1.wav");
1345                 precache_sound ("plats/medplat2.wav");
1346                 self.noise2 = "plats/medplat1.wav";
1347                 self.noise1 = "plats/medplat2.wav";
1348         }
1349
1350         if (!self.speed)
1351                 self.speed = 50;
1352         if (!self.wait)
1353                 self.wait = 1;
1354         self.lip = 0; // self.lip is used to remember reverse opening direction for door_rotating
1355
1356         self.pos1 = '0 0 0';
1357         self.pos2 = self.movedir;
1358
1359 // DOOR_START_OPEN is to allow an entity to be lighted in the closed position
1360 // but spawn in the open position
1361         if (self.spawnflags & DOOR_START_OPEN)
1362                 InitializeEntity(self, door_rotating_init_startopen, INITPRIO_SETLOCATION);
1363
1364         self.state = STATE_BOTTOM;
1365
1366         if (self.health)
1367         {
1368                 self.takedamage = DAMAGE_YES;
1369                 self.event_damage = door_damage;
1370         }
1371
1372         if (self.items)
1373                 self.wait = -1;
1374
1375         self.touch = door_touch;
1376
1377 // LinkDoors can't be done until all of the doors have been spawned, so
1378 // the sizes can be detected properly.
1379         InitializeEntity(self, LinkDoors, INITPRIO_LINKDOORS);
1380
1381         self.reset = door_rotating_reset;
1382 };
1383
1384 /*
1385 =============================================================================
1386
1387 SECRET DOORS
1388
1389 =============================================================================
1390 */
1391
1392 void() fd_secret_move1;
1393 void() fd_secret_move2;
1394 void() fd_secret_move3;
1395 void() fd_secret_move4;
1396 void() fd_secret_move5;
1397 void() fd_secret_move6;
1398 void() fd_secret_done;
1399
1400 float SECRET_OPEN_ONCE = 1;             // stays open
1401 float SECRET_1ST_LEFT = 2;              // 1st move is left of arrow
1402 float SECRET_1ST_DOWN = 4;              // 1st move is down from arrow
1403 float SECRET_NO_SHOOT = 8;              // only opened by trigger
1404 float SECRET_YES_SHOOT = 16;    // shootable even if targeted
1405
1406
1407 void fd_secret_use()
1408 {
1409         local float temp;
1410         string message_save;
1411
1412         self.health = 10000;
1413         self.bot_attack = TRUE;
1414
1415         // exit if still moving around...
1416         if (self.origin != self.oldorigin)
1417                 return;
1418
1419         message_save = self.message;
1420         self.message = ""; // no more message
1421         SUB_UseTargets();                               // fire all targets / killtargets
1422         self.message = message_save;
1423
1424         self.velocity = '0 0 0';
1425
1426         // Make a sound, wait a little...
1427
1428         if (self.noise1 != "")
1429                 sound(self, CHAN_TRIGGER, self.noise1, VOL_BASE, ATTN_NORM);
1430         self.nextthink = self.ltime + 0.1;
1431
1432         temp = 1 - (self.spawnflags & SECRET_1ST_LEFT); // 1 or -1
1433         makevectors(self.mangle);
1434
1435         if (!self.t_width)
1436         {
1437                 if (self.spawnflags & SECRET_1ST_DOWN)
1438                         self.t_width = fabs(v_up * self.size);
1439                 else
1440                         self.t_width = fabs(v_right * self.size);
1441         }
1442
1443         if (!self.t_length)
1444                 self.t_length = fabs(v_forward * self.size);
1445
1446         if (self.spawnflags & SECRET_1ST_DOWN)
1447                 self.dest1 = self.origin - v_up * self.t_width;
1448         else
1449                 self.dest1 = self.origin + v_right * (self.t_width * temp);
1450
1451         self.dest2 = self.dest1 + v_forward * self.t_length;
1452         SUB_CalcMove(self.dest1, self.speed, fd_secret_move1);
1453         if (self.noise2 != "")
1454                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1455 };
1456
1457 // Wait after first movement...
1458 void fd_secret_move1()
1459 {
1460         self.nextthink = self.ltime + 1.0;
1461         self.think = fd_secret_move2;
1462         if (self.noise3 != "")
1463                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1464 };
1465
1466 // Start moving sideways w/sound...
1467 void fd_secret_move2()
1468 {
1469         if (self.noise2 != "")
1470                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1471         SUB_CalcMove(self.dest2, self.speed, fd_secret_move3);
1472 };
1473
1474 // Wait here until time to go back...
1475 void fd_secret_move3()
1476 {
1477         if (self.noise3 != "")
1478                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1479         if (!(self.spawnflags & SECRET_OPEN_ONCE))
1480         {
1481                 self.nextthink = self.ltime + self.wait;
1482                 self.think = fd_secret_move4;
1483         }
1484 };
1485
1486 // Move backward...
1487 void fd_secret_move4()
1488 {
1489         if (self.noise2 != "")
1490                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1491         SUB_CalcMove(self.dest1, self.speed, fd_secret_move5);
1492 };
1493
1494 // Wait 1 second...
1495 void fd_secret_move5()
1496 {
1497         self.nextthink = self.ltime + 1.0;
1498         self.think = fd_secret_move6;
1499         if (self.noise3 != "")
1500                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1501 };
1502
1503 void fd_secret_move6()
1504 {
1505         if (self.noise2 != "")
1506                 sound(self, CHAN_TRIGGER, self.noise2, VOL_BASE, ATTN_NORM);
1507         SUB_CalcMove(self.oldorigin, self.speed, fd_secret_done);
1508 };
1509
1510 void fd_secret_done()
1511 {
1512         if (self.spawnflags&SECRET_YES_SHOOT)
1513         {
1514                 self.health = 10000;
1515                 self.takedamage = DAMAGE_YES;
1516                 //self.th_pain = fd_secret_use;
1517         }
1518         if (self.noise3 != "")
1519                 sound(self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NORM);
1520 };
1521
1522 void secret_blocked()
1523 {
1524         if (time < self.attack_finished_single)
1525                 return;
1526         self.attack_finished_single = time + 0.5;
1527         //T_Damage (other, self, self, self.dmg, self.dmg, self.deathtype, DT_IMPACT, (self.absmin + self.absmax) * 0.5, '0 0 0', Obituary_Generic);
1528 };
1529
1530 /*
1531 ==============
1532 secret_touch
1533
1534 Prints messages
1535 ================
1536 */
1537 void secret_touch()
1538 {
1539         if not(other.iscreature)
1540                 return;
1541         if (self.attack_finished_single > time)
1542                 return;
1543
1544         self.attack_finished_single = time + 2;
1545
1546         if (self.message)
1547         {
1548                 if (other.flags & FL_CLIENT)
1549                         centerprint (other, self.message);
1550                 play2(other, "misc/talk.wav");
1551         }
1552 };
1553
1554 void secret_reset()
1555 {
1556         if (self.spawnflags&SECRET_YES_SHOOT)
1557         {
1558                 self.health = 10000;
1559                 self.takedamage = DAMAGE_YES;
1560         }
1561         setorigin(self, self.oldorigin);
1562         self.think = SUB_Null;
1563 }
1564
1565 /*QUAKED spawnfunc_func_door_secret (0 .5 .8) ? open_once 1st_left 1st_down no_shoot always_shoot
1566 Basic secret door. Slides back, then to the side. Angle determines direction.
1567 wait  = # of seconds before coming back
1568 1st_left = 1st move is left of arrow
1569 1st_down = 1st move is down from arrow
1570 always_shoot = even if targeted, keep shootable
1571 t_width = override WIDTH to move back (or height if going down)
1572 t_length = override LENGTH to move sideways
1573 "dmg"           damage to inflict when blocked (2 default)
1574
1575 If a secret door has a targetname, it will only be opened by it's botton or trigger, not by damage.
1576 "sounds"
1577 1) medieval
1578 2) metal
1579 3) base
1580 */
1581
1582 void spawnfunc_func_door_secret()
1583 {
1584         /*if (!self.deathtype) // map makers can override this
1585                 self.deathtype = " got in the way";*/
1586
1587         if (!self.dmg)
1588                 self.dmg = 2;
1589
1590         // Magic formula...
1591         self.mangle = self.angles;
1592         self.angles = '0 0 0';
1593         self.classname = "door";
1594         if not(InitMovingBrushTrigger())
1595                 return;
1596         self.effects |= EF_LOWPRECISION;
1597
1598         self.touch = secret_touch;
1599         self.blocked = secret_blocked;
1600         self.speed = 50;
1601         self.use = fd_secret_use;
1602         IFTARGETED
1603         {
1604         }
1605         else
1606                 self.spawnflags |= SECRET_YES_SHOOT;
1607
1608         if(self.spawnflags&SECRET_YES_SHOOT)
1609         {
1610                 self.health = 10000;
1611                 self.takedamage = DAMAGE_YES;
1612                 self.event_damage = fd_secret_use;
1613         }
1614         self.oldorigin = self.origin;
1615         if (!self.wait)
1616                 self.wait = 5;          // 5 seconds before closing
1617
1618         self.reset = secret_reset;
1619         secret_reset();
1620 };
1621
1622 /*QUAKED spawnfunc_func_fourier (0 .5 .8) ?
1623 Brush model that moves in a pattern of added up sine waves, can be used e.g. for circular motions.
1624 netname: list of <frequencymultiplier> <phase> <x> <y> <z> quadruples, separated by spaces; note that phase 0 represents a sine wave, and phase 0.25 a cosine wave (by default, it uses 1 0 0 0 1, to match func_bobbing's defaults
1625 speed: how long one cycle of frequency multiplier 1 in seconds (default 4)
1626 height: amplitude modifier (default 32)
1627 phase: cycle timing adjustment (0-1 as a fraction of the cycle, default 0)
1628 noise: path/name of looping .wav file to play.
1629 dmg: Do this mutch dmg every .dmgtime intervall when blocked
1630 dmgtime: See above.
1631 */
1632
1633 void func_fourier_controller_think()
1634 {
1635         local vector v;
1636         float n, i, t;
1637
1638         self.nextthink = time + 0.1;
1639
1640         n = floor((tokenize_console(self.owner.netname)) / 5);
1641         t = self.nextthink * self.owner.cnt + self.owner.phase * 360;
1642
1643         v = self.owner.destvec;
1644
1645         for(i = 0; i < n; ++i)
1646         {
1647                 makevectors((t * stof(argv(i*5)) + stof(argv(i*5+1)) * 360) * '0 1 0');
1648                 v = v + ('1 0 0' * stof(argv(i*5+2)) + '0 1 0' * stof(argv(i*5+3)) + '0 0 1' * stof(argv(i*5+4))) * self.owner.height * v_forward_y;
1649         }
1650
1651         // * 10 so it will arrive in 0.1 sec
1652         self.owner.velocity = (v - self.owner.origin) * 10;
1653 };
1654
1655 void spawnfunc_func_fourier()
1656 {
1657         local entity controller;
1658         if (self.noise != "")
1659         {
1660                 precache_sound(self.noise);
1661                 soundto(MSG_INIT, self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_IDLE);
1662         }
1663
1664         if (!self.speed)
1665                 self.speed = 4;
1666         if (!self.height)
1667                 self.height = 32;
1668         self.destvec = self.origin;
1669         self.cnt = 360 / self.speed;
1670
1671         self.blocked = generic_plat_blocked;
1672         if(self.dmg & (!self.message))
1673                 self.message = " was squished";
1674     if(self.dmg && (!self.message2))
1675                 self.message2 = "was squished by";
1676         if(self.dmg && (!self.dmgtime))
1677                 self.dmgtime = 0.25;
1678         self.dmgtime2 = time;
1679
1680         if(self.netname == "")
1681                 self.netname = "1 0 0 0 1";
1682
1683         if not(InitMovingBrushTrigger())
1684                 return;
1685
1686         // wait for targets to spawn
1687         controller = spawn();
1688         controller.classname = "func_fourier_controller";
1689         controller.owner = self;
1690         controller.nextthink = time + 1;
1691         controller.think = func_fourier_controller_think;
1692         self.nextthink = self.ltime + 999999999;
1693         self.think = SUB_Null;
1694
1695         // Savage: Reduce bandwith, critical on e.g. nexdm02
1696         self.effects |= EF_LOWPRECISION;
1697
1698         // TODO make a reset function for this one
1699 };
1700
1701 // reusing some fields havocbots declared
1702 .entity wp00, wp01, wp02, wp03;
1703
1704 .float targetfactor, target2factor, target3factor, target4factor;
1705 .vector targetnormal, target2normal, target3normal, target4normal;
1706
1707 vector func_vectormamamam_origin(entity o, float t)
1708 {
1709         vector v, p;
1710         float f;
1711         entity e;
1712
1713         f = o.spawnflags;
1714         v = '0 0 0';
1715
1716         e = o.wp00;
1717         if(e)
1718         {
1719                 p = e.origin + t * e.velocity;
1720                 if(f & 1)
1721                         v = v + (p * o.targetnormal) * o.targetnormal * o.targetfactor;
1722                 else
1723                         v = v + (p - (p * o.targetnormal) * o.targetnormal) * o.targetfactor;
1724         }
1725
1726         e = o.wp01;
1727         if(e)
1728         {
1729                 p = e.origin + t * e.velocity;
1730                 if(f & 2)
1731                         v = v + (p * o.target2normal) * o.target2normal * o.target2factor;
1732                 else
1733                         v = v + (p - (p * o.target2normal) * o.target2normal) * o.target2factor;
1734         }
1735
1736         e = o.wp02;
1737         if(e)
1738         {
1739                 p = e.origin + t * e.velocity;
1740                 if(f & 4)
1741                         v = v + (p * o.target3normal) * o.target3normal * o.target3factor;
1742                 else
1743                         v = v + (p - (p * o.target3normal) * o.target3normal) * o.target3factor;
1744         }
1745
1746         e = o.wp03;
1747         if(e)
1748         {
1749                 p = e.origin + t * e.velocity;
1750                 if(f & 8)
1751                         v = v + (p * o.target4normal) * o.target4normal * o.target4factor;
1752                 else
1753                         v = v + (p - (p * o.target4normal) * o.target4normal) * o.target4factor;
1754         }
1755
1756         return v;
1757 }
1758
1759 void func_vectormamamam_controller_think()
1760 {
1761         self.nextthink = time + 0.1;
1762         self.owner.velocity = (self.owner.destvec + func_vectormamamam_origin(self.owner, 0.1) - self.owner.origin) * 10;
1763 }
1764
1765 void func_vectormamamam_findtarget()
1766 {
1767         if(self.target != "")
1768                 self.wp00 = find(world, targetname, self.target);
1769
1770         if(self.target2 != "")
1771                 self.wp01 = find(world, targetname, self.target2);
1772
1773         if(self.target3 != "")
1774                 self.wp02 = find(world, targetname, self.target3);
1775
1776         if(self.target4 != "")
1777                 self.wp03 = find(world, targetname, self.target4);
1778
1779         if(!self.wp00 && !self.wp01 && !self.wp02 && !self.wp03)
1780                 objerror("No reference entity found, so there is nothing to move. Aborting.");
1781
1782         self.destvec = self.origin - func_vectormamamam_origin(self.owner, 0);
1783
1784         local entity controller;
1785         controller = spawn();
1786         controller.classname = "func_vectormamamam_controller";
1787         controller.owner = self;
1788         controller.nextthink = time + 1;
1789         controller.think = func_vectormamamam_controller_think;
1790 }
1791
1792 void spawnfunc_func_vectormamamam()
1793 {
1794         if (self.noise != "")
1795         {
1796                 precache_sound(self.noise);
1797                 soundto(MSG_INIT, self, CHAN_TRIGGER, self.noise, VOL_BASE, ATTN_IDLE);
1798         }
1799
1800         if(!self.targetfactor)
1801                 self.targetfactor = 1;
1802
1803         if(!self.target2factor)
1804                 self.target2factor = 1;
1805
1806         if(!self.target3factor)
1807                 self.target3factor = 1;
1808
1809         if(!self.target4factor)
1810                 self.target4factor = 1;
1811
1812         if(vlen(self.targetnormal))
1813                 self.targetnormal = normalize(self.targetnormal);
1814
1815         if(vlen(self.target2normal))
1816                 self.target2normal = normalize(self.target2normal);
1817
1818         if(vlen(self.target3normal))
1819                 self.target3normal = normalize(self.target3normal);
1820
1821         if(vlen(self.target4normal))
1822                 self.target4normal = normalize(self.target4normal);
1823
1824         self.blocked = generic_plat_blocked;
1825         if(self.dmg & (!self.message))
1826                 self.message = " was squished";
1827     if(self.dmg && (!self.message2))
1828                 self.message2 = "was squished by";
1829         if(self.dmg && (!self.dmgtime))
1830                 self.dmgtime = 0.25;
1831         self.dmgtime2 = time;
1832
1833         if(self.netname == "")
1834                 self.netname = "1 0 0 0 1";
1835
1836         if not(InitMovingBrushTrigger())
1837                 return;
1838
1839         // wait for targets to spawn
1840         self.nextthink = self.ltime + 999999999;
1841         self.think = SUB_Null;
1842
1843         // Savage: Reduce bandwith, critical on e.g. nexdm02
1844         self.effects |= EF_LOWPRECISION;
1845
1846         InitializeEntity(self, func_vectormamamam_findtarget, INITPRIO_FINDTARGET);
1847 }