1 // MegaTF Ball and Goal
\r
2 // By: Ambush (and DyerMaker?)
\r
3 // Implemented into Team:Nexuiz by avirox
\r
5 float () CheckExistence;
\r
11 if (other.classname == "player" && self.last_used <= time)
\r
13 sound(self, 3, "ball/bounce_fall.wav", 0.8, TRUE);
\r
14 self.last_used = time + 0.3;
\r
16 if (other.classname != "player")
\r
18 sound(self, TRUE, "ball/bounce_hit.wav", TRUE, TRUE);
\r
20 if (other.classname == "player")
\r
22 makevectors(other.v_angle);
\r
23 self.velocity = other.velocity + v_forward * 100 + v_up * 200;
\r
24 //self.angles = -1 * (vectoangles (self.velocity));
\r
27 self.avelocity = -1 * ((v_forward * 250)/* + crandom() * v_right*/);
\r
28 self.lastplayer = other;
\r
35 self.nextthink = time + 15;
\r
36 self.effects = FALSE;
\r
37 // self.angles = vectoangles (self.velocity);
\r
42 if (CheckExistence() == FALSE)
\r
52 sound(self, 3, "ball/whistle.wav", TRUE, FALSE);
\r
53 te = find(world, classname, "ballstart");
\r
56 setorigin(self, te.origin);
\r
57 te = find(te, classname, "ballstart");
\r
59 self.nextthink = time + 5;
\r
60 self.think = BallCheck;
\r
62 self.velocity_z = 40;
\r
67 if (CheckExistence() == FALSE)
\r
72 precache_model("models/ball/ball.md3");
\r
73 setmodel(self, "models/ball/ball.md3");
\r
74 self.movetype = FALSE;
\r
75 setsize(self, '-16 -16 -14', '16 16 10');
\r
77 self.touch = BallTouch;
\r
78 self.classname = "ball";
\r
79 self.think = BallCheck;
\r
80 self.nextthink = time + 15;
\r
81 self.oldorigin = self.origin;
\r
82 // self.angles = vectoangles (self.velocity);
\r
88 if (other.classname != "ball")
\r
92 if (self.last_used > time)
\r
96 sound(self, 3, "ball/goal.wav", TRUE, FALSE);
\r
97 self.last_used = time + 10;
\r
98 te = find(world, classname, "player");
\r
101 if (self.team_no == 2)
\r
103 CenterPrint2(te, " ^3Score^7 for ^1Reds^7 by ", other.lastplayer.netname);
\r
107 CenterPrint2(te, " ^3Score^7 for ^4Blues^7 by ", other.lastplayer.netname);
\r
109 if (te.team_no == self.team_no && self.team_no != FALSE)
\r
111 te.real_frags = te.real_frags + self.frags;
\r
112 te.frags = te.frags + self.frags;
\r
113 te.health = te.max_health;
\r
115 te = find(te, classname, "player");
\r
117 other.nextthink = time + 10;
\r
118 other.think = BallStart;
\r
119 other.movetype = 9;
\r
120 other.velocity_z = 40;
\r
121 other.effects = self.team_no * 64;
\r
124 void() sandball_goal =
\r
126 if (CheckExistence() == FALSE)
\r
131 precache_model("progs/null.mdl");
\r
132 precache_sound("ball/goal.wav");
\r
133 precache_sound("ball/whistle.wav");
\r
134 precache_sound("ball/bounce_fall.wav");
\r
135 precache_sound("ball/bounce_hit.wav");
\r
136 setmodel(self, "progs/null.mdl");
\r
137 self.movetype = FALSE;
\r
138 self.skin = self.team_no;
\r
140 setsize(self, '-35 -35 -14', '35 35 50');
\r
141 self.effects = FALSE;
\r
142 self.touch = GoalTouch;
\r
145 void() PuckTouch =
\r
147 if (other.classname == "player" && self.last_used <= time)
\r
149 sound(self, 3, "ball/bounce_fall.wav", 0.8, TRUE);
\r
150 self.last_used = time + 0.3;
\r
152 if (other.classname != "player")
\r
154 sound(self, TRUE, "ball/bounce_hit.wav", TRUE, TRUE);
\r
156 if (other.classname == "player")
\r
158 makevectors(other.v_angle);
\r
159 self.velocity = other.velocity + v_forward * 100/* + v_up * 200*/;
\r
160 //self.angles = -1 * (vectoangles (self.velocity));
\r
163 self.avelocity = -1 * ((v_forward * 250) + crandom() * v_right);
\r
164 self.lastplayer = other;
\r
168 void() PuckCheck =
\r
170 self.movetype = 10;
\r
171 self.nextthink = time + 15;
\r
172 self.effects = FALSE;
\r
177 if (CheckExistence() == FALSE)
\r
182 precache_model("models/puck/puck.md3");
\r
183 setmodel(self, "models/puck/puck.md3");
\r
184 self.movetype = MOVETYPE_WALK;
\r
185 setsize(self, '-16 -16 -14', '16 16 10');
\r
187 self.touch = PuckTouch;
\r
188 self.classname = "ball";
\r
189 self.think = PuckCheck;
\r
190 self.nextthink = time + 15;
\r
191 self.oldorigin = self.origin;
\r
195 vector(vector ang) SUB_NormalizeAngles =
\r
197 while (ang_x > 360)
\r
199 ang_x = ang_x - 360;
\r
201 while (ang_x < FALSE)
\r
203 ang_x = ang_x + 360;
\r
205 while (ang_y > 360)
\r
207 ang_y = ang_y - 360;
\r
209 while (ang_y < FALSE)
\r
211 ang_y = ang_y + 360;
\r
213 while (ang_z > 360)
\r
215 ang_z = ang_z - 360;
\r
217 while (ang_z < FALSE)
\r
219 ang_z = ang_z + 360;
\r
224 /*=======================================
\r
225 Rotate function for QuakeC
\r
226 by Hipnotic Interactive
\r
227 ===================================*/
\r
229 .float rotate_type;
\r
238 float START_ON = 1; // flag. abe thinks right.
\r
239 float TOGGLE = 1; // flag. abe thinks right.
\r
241 float ROTATION = 1;
\r
242 float ANGLES = 2; // flag. from abe.
\r
244 float NO_ROTATE = 8;
\r
248 float TOUCH = 2; // this one too.
\r
249 float SET_DAMAGE = 4; // i made this one up.
\r
251 float NONBLOCKING = 4;
\r
253 float STAYOPEN = 4;
\r
255 float OBJECT_MOVEWALL = 2;
\r
256 float OBJECT_ROTATE = 3;
\r
257 float STATE_SPEEDINGUP = 4;
\r
258 float STATE_ACTIVE = 5;
\r
259 float OBJECT_SETORIGIN = 6;
\r
260 float STATE_WAIT = 7;
\r
261 float STATE_SLOWINGDOWN = 8;
\r
262 float STATE_INACTIVE = 9;
\r
263 float STATE_OPENING = 10;
\r
264 float STATE_CLOSING = 11;
\r
265 float STATE_MOVE = 12;
\r
266 float STATE_STOP = 13;
\r
267 float STATE_NEXT = 14;
\r
268 float STATE_FIND = 15;
\r
269 float STATE_OPEN = 16;
\r
270 float STATE_CLOSED = 17;
\r
274 void() rotate_train_find;
\r
275 void() rotate_door_group_reversedirection;
\r
276 void() rotate_train_next;
\r
278 void() info_rotate =
\r
280 self.nextthink = time + 2;
\r
281 self.think = SUB_Remove;
\r
284 void() RotateTargets =
\r
291 makevectors(self.angles);
\r
292 ent = find(world, targetname, self.target);
\r
295 if (ent.rotate_type == OBJECT_SETORIGIN)
\r
297 org = ent.oldorigin;
\r
298 vx = v_forward * org_x;
\r
299 vy = v_right * org_y;
\r
302 ent.neworigin = vx + vy + vz;
\r
303 setorigin(ent, ent.neworigin + self.origin);
\r
307 if (ent.rotate_type == OBJECT_ROTATE)
\r
309 ent.angles = self.angles;
\r
310 org = ent.oldorigin;
\r
311 vx = v_forward * org_x;
\r
312 vy = v_right * org_y;
\r
315 ent.neworigin = vx + vy + vz;
\r
316 setorigin(ent, ent.neworigin + self.origin);
\r
320 org = ent.oldorigin;
\r
321 vx = v_forward * org_x;
\r
322 vy = v_right * org_y;
\r
325 ent.neworigin = vx + vy + vz;
\r
326 ent.neworigin = self.origin - self.oldorigin + (ent.neworigin - ent.oldorigin);
\r
327 ent.velocity = (ent.neworigin - ent.origin) * 25;
\r
330 ent = find(ent, targetname, self.target);
\r
334 void() RotateTargetsFinal =
\r
337 ent = find(world, targetname, self.target);
\r
340 ent.velocity = '0 0 0';
\r
341 if (ent.rotate_type == OBJECT_ROTATE)
\r
343 ent.angles = self.angles;
\r
345 ent = find(ent, targetname, self.target);
\r
349 void() SetTargetOrigin =
\r
352 ent = find(world, targetname, self.target);
\r
355 if (ent.rotate_type == OBJECT_MOVEWALL)
\r
357 setorigin(ent, self.origin - self.oldorigin + (ent.neworigin - ent.oldorigin));
\r
361 setorigin(ent, ent.neworigin + self.origin);
\r
363 ent = find(ent, targetname, self.target);
\r
367 void() LinkRotateTargets =
\r
370 local vector tempvec;
\r
371 self.oldorigin = self.origin;
\r
372 ent = find(world, targetname, self.target);
\r
375 if (ent.classname == "rotate_object")
\r
377 ent.rotate_type = OBJECT_ROTATE;
\r
378 ent.oldorigin = ent.origin - self.oldorigin;
\r
379 ent.neworigin = ent.origin - self.oldorigin;
\r
384 if (ent.classname == "func_movewall")
\r
386 ent.rotate_type = OBJECT_MOVEWALL;
\r
387 tempvec = (ent.absmin + ent.absmax) * 0.5;
\r
388 ent.oldorigin = tempvec - self.oldorigin;
\r
389 ent.neworigin = ent.oldorigin;
\r
394 ent.rotate_type = OBJECT_SETORIGIN;
\r
395 ent.oldorigin = ent.origin - self.oldorigin;
\r
396 ent.neworigin = ent.origin - self.oldorigin;
\r
399 ent = find(ent, targetname, self.target);
\r
403 void(float amount) SetDamageOnTargets =
\r
406 ent = find(world, targetname, self.target);
\r
409 if (ent.classname == "func_movewall")
\r
413 ent = find(ent, targetname, self.target);
\r
417 void() rotate_entity_think =
\r
420 t = time - self.ltime;
\r
422 if (self.state == STATE_SPEEDINGUP)
\r
424 self.count = self.count + self.cnt * t;
\r
425 if (self.count > TRUE)
\r
429 t = t * self.count;
\r
433 if (self.state == STATE_SLOWINGDOWN)
\r
435 self.count = self.count - self.cnt * t;
\r
436 if (self.count < FALSE)
\r
438 RotateTargetsFinal();
\r
439 self.state = STATE_INACTIVE;
\r
440 self.think = SUB_Null;
\r
443 t = t * self.count;
\r
446 self.angles = self.angles + self.rotate * t;
\r
447 self.angles = SUB_NormalizeAngles(self.angles);
\r
449 self.nextthink = time + 0.020000;
\r
452 void() rotate_entity_use =
\r
454 self.frame = TRUE - self.frame;
\r
455 if (self.state == STATE_ACTIVE)
\r
457 if (self.spawnflags & TOGGLE)
\r
462 self.state = STATE_SLOWINGDOWN;
\r
466 self.state = STATE_INACTIVE;
\r
467 self.think = SUB_Null;
\r
473 if (self.state == STATE_INACTIVE)
\r
475 self.think = rotate_entity_think;
\r
476 self.nextthink = time + 0.020000;
\r
480 self.count = FALSE;
\r
481 self.state = STATE_SPEEDINGUP;
\r
485 self.state = STATE_ACTIVE;
\r
490 if (self.state == STATE_SPEEDINGUP)
\r
492 if (self.spawnflags & TOGGLE)
\r
494 self.state = STATE_SLOWINGDOWN;
\r
499 self.state = STATE_SPEEDINGUP;
\r
505 void() rotate_entity_firstthink =
\r
507 LinkRotateTargets();
\r
508 if (self.spawnflags & START_ON)
\r
510 self.state = STATE_ACTIVE;
\r
511 self.think = rotate_entity_think;
\r
512 self.nextthink = time + 0.020000;
\r
517 self.state = STATE_INACTIVE;
\r
518 self.think = SUB_Null;
\r
520 self.use = rotate_entity_use;
\r
523 /*QUAKED func_rotate_entity (0 .5 .8) (-8 -8 -8) (8 8 8) TOGGLE START_ON
\r
524 Creates an entity that continually rotates. Can be toggled on and
\r
527 TOGGLE = allows the rotation to be toggled on/off
\r
529 START_ON = wether the entity is spinning when spawned. If TOGGLE is 0, entity can be turned on, but not off.
\r
531 If "deathtype" is set with a string, this is the message that will appear when a player is killed by the train.
\r
533 "rotate" is the rate to rotate.
\r
534 "target" is the center of rotation.
\r
535 "speed" is how long the entity takes to go from standing still to full speed and vice-versa.
\r
538 void() func_rotate_entity =
\r
540 self.solid = FALSE;
\r
541 self.movetype = FALSE;
\r
542 setmodel(self, self.model);
\r
543 setsize(self, self.mins, self.maxs);
\r
544 if (self.speed != FALSE)
\r
546 self.cnt = TRUE / self.speed;
\r
548 self.think = rotate_entity_firstthink;
\r
549 self.nextthink = time + 0.1;
\r
553 /*QUAKED path_rotate (0.5 0.3 0) (-8 -8 -8) (8 8 8) ROTATION ANGLES STOP NO_ROTATE DAMAGE MOVETIME SET_DAMAGE
\r
554 Path for rotate_train.
\r
556 ROTATION tells train to rotate at rate specified by "rotate". Use '0 0 0' to stop rotation.
\r
558 ANGLES tells train to rotate to the angles specified by "angles" while traveling to this path_rotate. Use values < 0 or > 360 to guarantee that it turns in a certain direction. Having this flag set automatically clears any rotation.
\r
560 STOP tells the train to stop and wait to be retriggered.
\r
562 NO_ROTATE tells the train to stop rotating when waiting to be triggered.
\r
564 DAMAGE tells the train to cause damage based on "dmg".
\r
566 MOVETIME tells the train to interpret "speed" as the length of time to take moving from one corner to another.
\r
568 SET_DAMAGE tells the train to set all targets damage to "dmg"
\r
570 "noise" contains the name of the sound to play when train stops.
\r
571 "noise1" contains the name of the sound to play when train moves.
\r
572 "event" is a target to trigger when train arrives at path_rotate.
\r
575 void() path_rotate =
\r
579 precache_sound(self.noise);
\r
583 precache_sound(self.noise1);
\r
587 void() rotate_train_think =
\r
590 local float timeelapsed;
\r
591 t = time - self.ltime;
\r
593 if (self.endtime && time >= self.endtime)
\r
595 self.endtime = FALSE;
\r
596 if (self.state == STATE_MOVE)
\r
598 setorigin(self, self.finaldest);
\r
599 self.velocity = '0 0 0';
\r
608 timeelapsed = (time - self.cnt) * self.duration;
\r
609 if (timeelapsed > TRUE)
\r
611 timeelapsed = TRUE;
\r
613 setorigin(self, self.dest1 + self.dest2 * timeelapsed);
\r
615 self.angles = self.angles + self.rotate * t;
\r
616 self.angles = SUB_NormalizeAngles(self.angles);
\r
618 self.nextthink = time + 0.020000;
\r
621 void() rotate_train_use =
\r
623 if (self.think1 != rotate_train_find)
\r
625 if (self.velocity != '0 0 0')
\r
636 void() rotate_train_wait =
\r
638 self.state = STATE_WAIT;
\r
639 if (self.goalentity.noise)
\r
641 if (self.goalentity.noise == "ambience/chopper.wav")
\r
643 sound(self, 2, self.goalentity.noise, TRUE, FALSE);
\r
647 sound(self, 2, self.goalentity.noise, TRUE, TRUE);
\r
652 sound(self, 2, self.noise, TRUE, TRUE);
\r
654 if (self.goalentity.spawnflags & ANGLES)
\r
656 self.rotate = '0 0 0';
\r
657 self.angles = self.finalangle;
\r
659 if (self.goalentity.spawnflags & NO_ROTATE)
\r
661 self.rotate = '0 0 0';
\r
663 self.endtime = self.ltime + self.goalentity.wait;
\r
664 self.think1 = rotate_train_next;
\r
667 void() rotate_train_stop =
\r
669 self.state = STATE_STOP;
\r
670 if (self.goalentity.noise)
\r
672 if (self.goalentity.noise == "ambience/chopper.wav")
\r
674 sound(self, 2, self.goalentity.noise, TRUE, FALSE);
\r
678 sound(self, 2, self.goalentity.noise, TRUE, TRUE);
\r
683 sound(self, 2, self.noise, TRUE, TRUE);
\r
685 if (self.goalentity.spawnflags & ANGLES)
\r
687 self.rotate = '0 0 0';
\r
688 self.angles = self.finalangle;
\r
690 if (self.goalentity.spawnflags & NO_ROTATE)
\r
692 self.rotate = '0 0 0';
\r
695 self.think1 = rotate_train_next;
\r
698 void() rotate_train_next =
\r
701 local entity current;
\r
702 local vector vdestdelta;
\r
704 local float traveltime;
\r
707 self.state = STATE_NEXT;
\r
708 current = self.goalentity;
\r
709 targ = find(world, targetname, self.path);
\r
710 if (targ.classname != "path_rotate")
\r
712 objerror("Next target is not path_rotate");
\r
714 if (self.goalentity.noise1)
\r
716 self.noise1 = self.goalentity.noise1;
\r
718 if (self.noise1 == "ambience/chopper.wav")
\r
720 sound(self, 2, self.noise1, TRUE, FALSE);
\r
724 sound(self, 2, self.noise1, TRUE, TRUE);
\r
726 self.goalentity = targ;
\r
727 self.path = targ.target;
\r
730 objerror("rotate_train_next: no next target");
\r
732 if (targ.spawnflags & STOP)
\r
734 self.think1 = rotate_train_stop;
\r
740 self.think1 = rotate_train_wait;
\r
744 self.think1 = rotate_train_next;
\r
749 temp = self.target;
\r
750 self.target = current.event;
\r
751 self.message = current.message;
\r
753 self.target = temp;
\r
754 self.message = string_null;
\r
756 if (current.spawnflags & ANGLES)
\r
758 self.rotate = '0 0 0';
\r
759 self.angles = self.finalangle;
\r
761 if (current.spawnflags & ROTATION)
\r
763 self.rotate = current.rotate;
\r
765 if (current.spawnflags & DAMAGE)
\r
767 self.dmg = current.dmg;
\r
769 if (current.spawnflags & SET_DAMAGE)
\r
771 SetDamageOnTargets(current.dmg);
\r
773 if (current.speed == -1)
\r
775 setorigin(self, targ.origin);
\r
776 self.endtime = self.ltime + 0.010000;
\r
778 if (targ.spawnflags & ANGLES)
\r
780 self.angles = targ.angles;
\r
782 self.duration = TRUE;
\r
784 self.dest2 = '0 0 0';
\r
785 self.dest1 = self.origin;
\r
786 self.finaldest = self.origin;
\r
790 self.state = STATE_MOVE;
\r
791 self.finaldest = targ.origin;
\r
792 if (self.finaldest == self.origin)
\r
794 self.velocity = '0 0 0';
\r
795 self.endtime = self.ltime + 0.1;
\r
796 self.duration = TRUE;
\r
798 self.dest2 = '0 0 0';
\r
799 self.dest1 = self.origin;
\r
800 self.finaldest = self.origin;
\r
803 vdestdelta = self.finaldest - self.origin;
\r
804 len = vlen(vdestdelta);
\r
805 // if (current.spawnflags & MOVETIME)
\r
807 // traveltime = current.speed;
\r
811 if (current.speed > FALSE)
\r
813 self.speed = current.speed;
\r
817 objerror("No speed is defined!");
\r
819 traveltime = len / self.speed;
\r
821 if (traveltime < 0.1)
\r
823 self.velocity = '0 0 0';
\r
824 self.endtime = self.ltime + 0.1;
\r
825 if (targ.spawnflags & ANGLES)
\r
827 self.angles = targ.angles;
\r
831 div = TRUE / traveltime;
\r
832 if (targ.spawnflags & ANGLES)
\r
834 self.finalangle = SUB_NormalizeAngles(targ.angles);
\r
835 self.rotate = (targ.angles - self.angles) * div;
\r
837 self.endtime = self.ltime + traveltime;
\r
838 self.velocity = vdestdelta * div;
\r
839 self.duration = div;
\r
841 self.dest2 = vdestdelta;
\r
842 self.dest1 = self.origin;
\r
846 void() rotate_train_find =
\r
849 self.state = STATE_FIND;
\r
850 LinkRotateTargets();
\r
851 targ = find(world, targetname, self.path);
\r
852 if (targ.classname != "path_rotate")
\r
854 objerror("Next target is not path_rotate");
\r
856 self.goalentity = targ;
\r
857 if (targ.spawnflags & ANGLES)
\r
859 self.angles = targ.angles;
\r
860 self.finalangle = SUB_NormalizeAngles(targ.angles);
\r
862 self.path = targ.target;
\r
863 setorigin(self, targ.origin);
\r
865 RotateTargetsFinal();
\r
866 self.think1 = rotate_train_next;
\r
867 if (!(self.targetname))
\r
869 self.endtime = self.ltime + 0.1;
\r
873 self.endtime = FALSE;
\r
875 self.duration = TRUE;
\r
877 self.dest2 = '0 0 0';
\r
878 self.dest1 = self.origin;
\r
881 void() func_rotate_train =
\r
887 if (!(self.target))
\r
889 objerror("rotate_train without a target");
\r
893 if (self.sounds == FALSE)
\r
895 self.noise = "misc/null.wav";
\r
897 if (self.sounds == TRUE)
\r
899 self.noise = "plats/train2.wav";
\r
902 if (!(self.noise1))
\r
904 if (self.sounds == FALSE)
\r
906 self.noise1 = "misc/null.wav";
\r
908 if (self.sounds == TRUE)
\r
910 self.noise1 = "plats/train1.wav";
\r
913 precache_sound(self.noise);
\r
914 precache_sound(self.noise1);
\r
916 self.solid = FALSE;
\r
918 self.use = rotate_train_use;
\r
919 setmodel(self, self.model);
\r
920 setsize(self, self.mins, self.maxs);
\r
921 setorigin(self, self.origin);
\r
923 self.nextthink = self.ltime + 0.1;
\r
924 self.endtime = self.ltime + 0.1;
\r
925 self.think = rotate_train_think;
\r
926 self.think1 = rotate_train_find;
\r
927 self.state = STATE_FIND;
\r
928 self.duration = TRUE;
\r
930 self.dest2 = '0 0 0';
\r
931 self.dest1 = self.origin;
\r
932 self.flags = self.flags | 512;
\r
935 void() movewall_touch =
\r
937 if (time < self.owner.attack_finished)
\r
943 T_Damage(other, self, self.owner, self.dmg);
\r
944 self.owner.attack_finished = time + 0.5;
\r
948 if (self.owner.dmg)
\r
950 T_Damage(other, self, self.owner, self.owner.dmg);
\r
951 self.owner.attack_finished = time + 0.5;
\r
956 void() movewall_blocked =
\r
959 if (time < self.owner.attack_finished)
\r
963 self.owner.attack_finished = time + 0.5;
\r
964 if (self.owner.classname == "func_rotate_door")
\r
968 rotate_door_group_reversedirection();
\r
973 T_Damage(other, self, self.owner, self.dmg);
\r
974 self.owner.attack_finished = time + 0.5;
\r
978 if (self.owner.dmg)
\r
980 T_Damage(other, self, self.owner, self.owner.dmg);
\r
981 self.owner.attack_finished = time + 0.5;
\r
986 void() movewall_think =
\r
989 self.nextthink = time + 0.020000;
\r
992 void() func_movewall =
\r
994 self.angles = '0 0 0';
\r
996 if (self.spawnflags & NONBLOCKING)
\r
998 self.solid = FALSE;
\r
1003 self.blocked = movewall_blocked;
\r
1005 if (self.spawnflags & TOUCH)
\r
1007 self.touch = movewall_touch;
\r
1009 setmodel(self, self.model);
\r
1010 if (!(self.spawnflags & VISIBLE))
\r
1012 self.model = string_null;
\r
1014 self.think = movewall_think;
\r
1015 self.nextthink = time + 0.020000;
\r
1016 self.ltime = time;
\r
1019 void() rotate_object =
\r
1021 self.classname = "rotate_object";
\r
1022 self.solid = FALSE;
\r
1023 self.movetype = FALSE;
\r
1024 setmodel(self, self.model);
\r
1025 setsize(self, self.mins, self.maxs);
\r
1026 self.think = SUB_Null;
\r
1029 void() rotate_door_think2 =
\r
1032 t = time - self.ltime;
\r
1033 self.ltime = time;
\r
1034 self.frame = TRUE - self.frame;
\r
1035 self.angles = self.dest;
\r
1036 if (self.state == STATE_OPENING)
\r
1038 self.state = STATE_OPEN;
\r
1042 if (self.spawnflags & STAYOPEN)
\r
1044 rotate_door_group_reversedirection();
\r
1047 self.state = STATE_CLOSED;
\r
1049 sound(self, 2, self.noise3, TRUE, TRUE);
\r
1050 self.think = SUB_Null;
\r
1051 RotateTargetsFinal();
\r
1054 void() rotate_door_think =
\r
1057 t = time - self.ltime;
\r
1058 self.ltime = time;
\r
1059 if (time < self.endtime)
\r
1061 self.angles = self.angles + self.rotate * t;//self.angles = self.angles + self.rotate * t;
\r
1066 self.angles = self.dest;
\r
1068 self.think = rotate_door_think2;
\r
1070 self.nextthink = time + 0.010000;
\r
1073 void() rotate_door_reversedirection =
\r
1075 local vector start;
\r
1076 self.frame = TRUE - self.frame;
\r
1077 if (self.state == STATE_CLOSING)
\r
1079 start = self.dest1;
\r
1080 self.dest = self.dest2;
\r
1081 self.state = STATE_OPENING;
\r
1085 start = self.dest2;
\r
1086 self.dest = self.dest1;
\r
1087 self.state = STATE_CLOSING;
\r
1089 sound(self, 2, self.noise2, TRUE, TRUE);
\r
1090 self.rotate = (self.dest - start) * (TRUE / self.speed);
\r
1091 self.think = rotate_door_think;
\r
1092 self.nextthink = time + 0.020000;
\r
1093 self.endtime = time + self.speed - (self.endtime - time);
\r
1094 self.ltime = time;
\r
1097 void() rotate_door_group_reversedirection =
\r
1099 local string name;
\r
1102 name = self.group;
\r
1103 self = find(world, group, name);
\r
1106 rotate_door_reversedirection();
\r
1107 self = find(self, group, name);
\r
1112 rotate_door_reversedirection();
\r
1116 void() rotate_door_use =
\r
1118 local vector start;
\r
1119 if (self.state != STATE_OPEN && self.state != STATE_CLOSED)
\r
1126 LinkRotateTargets();
\r
1128 self.frame = TRUE - self.frame;
\r
1129 if (self.state == STATE_CLOSED)
\r
1131 start = self.dest1;
\r
1132 self.dest = self.dest2;
\r
1133 self.state = STATE_OPENING;
\r
1137 start = self.dest2;
\r
1138 self.dest = self.dest1;
\r
1139 self.state = STATE_CLOSING;
\r
1141 sound(self, 2, self.noise2, TRUE, TRUE);
\r
1142 self.rotate = (self.dest - start) * (TRUE / self.speed);
\r
1143 self.think = rotate_door_think;
\r
1144 self.nextthink = time + 0.010000;
\r
1145 self.endtime = time + self.speed;
\r
1146 self.ltime = time;
\r
1149 void() func_rotate_door =
\r
1151 if (!(self.target))
\r
1153 objerror("rotate_door without target.");
\r
1155 self.dest1 = '0 0 0';
\r
1156 self.dest2 = self.angles;
\r
1157 self.angles = self.dest1;
\r
1158 if (!(self.speed))
\r
1169 if (self.dmg < FALSE)
\r
1174 if (self.sounds == FALSE)
\r
1176 precache_sound("misc/null.wav");
\r
1179 precache_sound(self.noise1);
\r
1183 self.noise1 = "misc/null.wav";
\r
1187 precache_sound(self.noise2);
\r
1191 self.noise2 = "misc/null.wav";
\r
1195 precache_sound(self.noise3);
\r
1199 self.noise3 = "misc/null.wav";
\r
1202 if (self.sounds == TRUE)
\r
1204 precache_sound("doors/latch2.wav");
\r
1205 precache_sound("doors/winch2.wav");
\r
1206 precache_sound("doors/drclos4.wav");
\r
1207 self.noise1 = "doors/latch2.wav";
\r
1208 self.noise2 = "doors/winch2.wav";
\r
1209 self.noise3 = "doors/drclos4.wav";
\r
1211 if (self.sounds == 2)
\r
1213 precache_sound("doors/airdoor1.wav");
\r
1214 precache_sound("doors/airdoor2.wav");
\r
1215 self.noise2 = "doors/airdoor1.wav";
\r
1216 self.noise1 = "doors/airdoor2.wav";
\r
1217 self.noise3 = "doors/airdoor2.wav";
\r
1219 if (self.sounds == 3)
\r
1221 precache_sound("doors/basesec1.wav");
\r
1222 precache_sound("doors/basesec2.wav");
\r
1223 self.noise2 = "doors/basesec1.wav";
\r
1224 self.noise1 = "doors/basesec2.wav";
\r
1225 self.noise3 = "doors/basesec2.wav";
\r
1227 self.solid = FALSE;
\r
1228 self.movetype = FALSE;
\r
1229 setmodel(self, self.model);
\r
1230 setorigin(self, self.origin);
\r
1231 setsize(self, self.mins, self.maxs);
\r
1232 self.state = STATE_CLOSED;
\r
1233 self.use = rotate_door_use;
\r
1234 self.think = SUB_Null;
\r