qf/prozac-qfcc
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/prozac-qfcc synced 2024-11-27 06:22:23 +00:00
Code Issues Projects Releases Packages Wiki Activity
prozac-qfcc/rotate.qc
Bill Currie f0a37abbd1 the server doesn't like think being NIL :/
2001-11-10 06:35:43 +00:00

1196 lines
28 KiB
C++
Raw Blame History

#include "defs.qh"
/*=======================================================//
// mtfents.QC - CustomTF 3.2.OfN - 30/1/2001 - //
// by Sergio Fumaña Grunwaldt - OfteN aka superCOCK2000 //
=========================================================//
I'll add rotate map entities support here
(some megatf maps use them like frontlin)
_________________________________________________________
This is the code of the hypnotic mission pack slighly
modified, it seems to work ok. I tested these entities
in frontlin and dyerfort.
=========================================================*/
#define STATE_ACTIVE 0
#define STATE_INACTIVE 1
#define STATE_SPEEDINGUP 2
#define STATE_SLOWINGDOWN 3
#define STATE_CLOSED 4
#define STATE_OPEN 5
#define STATE_OPENING 6
#define STATE_CLOSING 7
#define STATE_WAIT 0
#define STATE_MOVE 1
#define STATE_STOP 2
#define STATE_FIND 3
#define STATE_NEXT 4
#define OBJECT_ROTATE 0
#define OBJECT_MOVEWALL 1
#define OBJECT_SETORIGIN 2
#define TOGGLE 1
#define START_ON 2
#define ROTATION 1
#define ANGLES 2
#define STOP 4
#define NO_ROTATE 8
#define DAMAGE 16
#define MOVETIME 32
#define SET_DAMAGE 64
#define VISIBLE 1
#define TOUCH 2
#define NONBLOCKING 4
#define STAYOPEN 1
//=========================
//
// SUB_NormalizeAngles
// from hipsubs.qc
//=========================
vector ( vector ang ) SUB_NormalizeAngles =
{
while( ang_x > 360 )
{
ang_x = ang_x - 360;
}
while( ang_x < 0 )
{
ang_x = ang_x + 360;
}
while( ang_y > 360 )
{
ang_y = ang_y - 360;
}
while( ang_y < 0 )
{
ang_y = ang_y + 360;
}
while( ang_z > 360 )
{
ang_z = ang_z - 360;
}
while( ang_z < 0 )
{
ang_z = ang_z + 360;
}
return ang;
};
//- ofn from triggers.qc of hip
void( entity ent, float amount ) hurt_setdamage =
{
ent.dmg = amount;
if ( !amount )
{
ent.solid = SOLID_NOT;
}
else
{
ent.solid = SOLID_TRIGGER;
}
ent.nextthink = -1;
};
/*QUAKED info_rotate (0 0.5 0) (-4 -4 -4) (4 4 4)
Used as the point of rotation for rotatable objects.
*/
void() info_rotate =
{
// remove self after a little while, to make sure that entities that
// have targeted it have had a chance to spawn
self.nextthink = time + 2;
self.think = SUB_Remove;
};
void() RotateTargets =
{
local entity ent;
local vector vx;
local vector vy;
local vector vz;
local vector org;
makevectors (self.angles);
ent = find( NIL, targetname, self.target);
while( ent )
{
if ( ent.rotate_type == OBJECT_SETORIGIN )
{
org = ent.oldorigin;
vx = ( v_forward * org_x );
vy = ( v_right * org_y );
vy = vy * -1;
vz = ( v_up * org_z );
ent.neworigin = vx + vy + vz;
setorigin( ent, ent.neworigin + self.origin );
}
else if ( ent.rotate_type == OBJECT_ROTATE )
{
ent.angles = self.angles;
org = ent.oldorigin;
vx = ( v_forward * org_x );
vy = ( v_right * org_y );
vy = vy * -1;
vz = ( v_up * org_z );
ent.neworigin = vx + vy + vz;
setorigin( ent, ent.neworigin + self.origin );
}
else
{
org = ent.oldorigin;
vx = ( v_forward * org_x );
vy = ( v_right * org_y );
vy = vy * -1;
vz = ( v_up * org_z );
ent.neworigin = vx + vy + vz;
ent.neworigin = self.origin - self.oldorigin + (ent.neworigin - ent.oldorigin);
ent.velocity = (ent.neworigin-ent.origin)*25;
}
ent = find( ent, targetname, self.target);
}
};
void() RotateTargetsFinal =
{
local entity ent;
ent = find( NIL, targetname, self.target);
while( ent )
{
ent.velocity = '0 0 0';
if ( ent.rotate_type == OBJECT_ROTATE )
{
ent.angles = self.angles;
}
ent = find( ent, targetname, self.target);
}
};
void() SetTargetOrigin =
{
local entity ent;
ent = find( NIL, targetname, self.target);
while( ent )
{
if ( ent.rotate_type == OBJECT_MOVEWALL )
{
setorigin( ent, self.origin - self.oldorigin +
(ent.neworigin - ent.oldorigin) );
}
else
{
setorigin( ent, ent.neworigin + self.origin );
}
ent = find( ent, targetname, self.target);
}
};
void() LinkRotateTargets =
{
local entity ent;
local vector tempvec;
self.oldorigin = self.origin;
ent = find( NIL, targetname, self.target);
while( ent )
{
if ( ent.classname == "rotate_object" )
{
ent.rotate_type = OBJECT_ROTATE;
ent.oldorigin = ent.origin - self.oldorigin;
ent.neworigin = ent.origin - self.oldorigin;
ent.owner = self;
}
else if ( ent.classname == "func_movewall" )
{
ent.rotate_type = OBJECT_MOVEWALL;
tempvec = ( ent.absmin + ent.absmax ) * 0.5;
ent.oldorigin = tempvec - self.oldorigin;
ent.neworigin = ent.oldorigin;
ent.owner = self;
}
else
{
ent.rotate_type = OBJECT_SETORIGIN;
ent.oldorigin = ent.origin - self.oldorigin;
ent.neworigin = ent.origin - self.oldorigin;
}
ent = find (ent, targetname, self.target);
}
};
void( float amount ) SetDamageOnTargets =
{
local entity ent;
ent = find( NIL, targetname, self.target);
while( ent )
{
if ( ent.classname == "trigger_hurt" )
{
hurt_setdamage( ent, amount );
}
else if ( ent.classname == "func_movewall" )
{
ent.dmg = amount;
}
ent = find( ent, targetname, self.target);
}
};
//************************************************
//
// Simple continual rotatation
//
//************************************************
void() rotate_entity_think =
{
local float t;
t = time - self.ltime;
self.ltime = time;
if ( self.state == STATE_SPEEDINGUP )
{
self.count = self.count + self.cnt * t;
if ( self.count > 1 )
{
self.count = 1;
}
// get rate of rotation
t = t * self.count;
}
else if ( self.state == STATE_SLOWINGDOWN )
{
self.count = self.count - self.cnt * t;
if ( self.count < 0 )
{
RotateTargetsFinal();
self.state = STATE_INACTIVE;
self.think = dont_think;
return;
}
// get rate of rotation
t = t * self.count;
}
self.angles = self.angles + ( self.rotate * t );
self.angles = SUB_NormalizeAngles( self.angles );
RotateTargets();
self.nextthink = time + 0.02;
};
void() rotate_entity_use =
{
// change to alternate textures
self.frame = 1 - self.frame;
if ( self.state == STATE_ACTIVE )
{
if ( self.spawnflags & TOGGLE )
{
if ( self.speed )
{
self.count = 1;
self.state = STATE_SLOWINGDOWN;
}
else
{
self.state = STATE_INACTIVE;
self.think = dont_think;
}
}
}
else if ( self.state == STATE_INACTIVE )
{
self.think = rotate_entity_think;
self.nextthink = time + 0.02;
self.ltime = time;
if ( self.speed )
{
self.count = 0;
self.state = STATE_SPEEDINGUP;
}
else
{
self.state = STATE_ACTIVE;
}
}
else if ( self.state == STATE_SPEEDINGUP )
{
if ( self.spawnflags & TOGGLE )
{
self.state = STATE_SLOWINGDOWN;
}
}
else
{
self.state = STATE_SPEEDINGUP;
}
};
void() rotate_entity_firstthink =
{
LinkRotateTargets();
if ( self.spawnflags & START_ON )
{
self.state = STATE_ACTIVE;
self.think = rotate_entity_think;
self.nextthink = time + 0.02;
self.ltime = time;
}
else
{
self.state = STATE_INACTIVE;
self.think = dont_think;
}
self.use = rotate_entity_use;
};
/*QUAKED func_rotate_entity (0 .5 .8) (-8 -8 -8) (8 8 8) TOGGLE START_ON
Creates an entity that continually rotates. Can be toggled on and
off if targeted.
TOGGLE = allows the rotation to be toggled on/off
START_ON = wether the entity is spinning when spawned. If TOGGLE is 0, entity can be turned on, but not off.
If "deathtype" is set with a string, this is the message that will appear when a player is killed by the train.
"rotate" is the rate to rotate.
"target" is the center of rotation.
"speed" is how long the entity takes to go from standing still to full speed and vice-versa.
*/
void() func_rotate_entity =
{
self.solid = SOLID_NOT;
self.movetype = MOVETYPE_NONE;
setmodel (self, self.model);
setsize( self, self.mins, self.maxs );
if ( self.speed != 0 )
{
self.cnt = 1 / self.speed;
}
self.think = rotate_entity_firstthink;
self.nextthink = time + 0.1;
self.ltime = time;
};
//************************************************
//
// Train with rotation functionality
//
//************************************************
/*QUAKED path_rotate (0.5 0.3 0) (-8 -8 -8) (8 8 8) ROTATION ANGLES STOP NO_ROTATE DAMAGE MOVETIME SET_DAMAGE
Path for rotate_train.
ROTATION tells train to rotate at rate specified by "rotate". Use '0 0 0' to stop rotation.
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.
STOP tells the train to stop and wait to be retriggered.
NO_ROTATE tells the train to stop rotating when waiting to be triggered.
DAMAGE tells the train to cause damage based on "dmg".
MOVETIME tells the train to interpret "speed" as the length of time to take moving from one corner to another.
SET_DAMAGE tells the train to set all targets damage to "dmg"
"noise" contains the name of the sound to play when train stops.
"noise1" contains the name of the sound to play when train moves.
"event" is a target to trigger when train arrives at path_rotate.
*/
void() path_rotate =
{
if ( self.noise )
{
precache_sound( self.noise );
}
if ( self.noise1 )
{
precache_sound( self.noise1 );
}
};
void() rotate_train;
void() rotate_train_next;
void() rotate_train_find;
void() rotate_train_think =
{
local float t;
local float timeelapsed;
t = time - self.ltime;
self.ltime = time;
if ( ( self.endtime ) && ( time >= self.endtime ) )
{
self.endtime = 0;
if ( self.state == STATE_MOVE )
{
setorigin(self, self.finaldest);
self.velocity = '0 0 0';
}
if (self.think1)
self.think1();
}
else
{
timeelapsed = (time - self.cnt) * self.duration;
if ( timeelapsed > 1 )
timeelapsed = 1;
setorigin( self, self.dest1 + ( self.dest2 * timeelapsed ) );
}
self.angles = self.angles + ( self.rotate * t );
self.angles = SUB_NormalizeAngles( self.angles );
RotateTargets();
self.nextthink = time + 0.02;
};
void() rotate_train_use =
{
if (self.think1 != rotate_train_find)
{
if ( self.velocity != '0 0 0' )
return; // already activated
if ( self.think1 )
{
self.think1();
}
}
};
void() rotate_train_wait =
{
self.state = STATE_WAIT;
if ( self.goalentity.noise )
{
sound (self, CHAN_VOICE, self.goalentity.noise, 1, ATTN_NORM);
}
else
{
sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
}
if ( self.goalentity.spawnflags & ANGLES )
{
self.rotate = '0 0 0';
self.angles = self.finalangle;
}
if ( self.goalentity.spawnflags & NO_ROTATE )
{
self.rotate = '0 0 0';
}
self.endtime = self.ltime + self.goalentity.wait;
self.think1 = rotate_train_next;
};
void() rotate_train_stop =
{
self.state = STATE_STOP;
if ( self.goalentity.noise )
{
sound (self, CHAN_VOICE, self.goalentity.noise, 1, ATTN_NORM);
}
else
{
sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);
}
if ( self.goalentity.spawnflags & ANGLES )
{
self.rotate = '0 0 0';
self.angles = self.finalangle;
}
if ( self.goalentity.spawnflags & NO_ROTATE )
{
self.rotate = '0 0 0';
}
self.dmg = 0;
self.think1 = rotate_train_next;
};
void() rotate_train_next =
{
local entity targ;
local entity current;
local vector vdestdelta;
local float len, traveltime, div;
local string temp;
self.state = STATE_NEXT;
current = self.goalentity;
targ = find (NIL, targetname, self.path );
if ( targ.classname != "path_rotate" )
objerror( "Next target is not path_rotate" );
if ( self.goalentity.noise1 )
{
self.noise1 = self.goalentity.noise1;
}
sound (self, CHAN_VOICE, self.noise1, 1, ATTN_NORM);
self.goalentity = targ;
self.path = targ.target;
if (!self.path )
objerror ("rotate_train_next: no next target");
if ( targ.spawnflags & STOP )
{
self.think1 = rotate_train_stop;
}
else if (targ.wait)
{
self.think1 = rotate_train_wait;
}
else
{
self.think1 = rotate_train_next;
}
if ( current.event )
{
// Trigger any events that should happen at the corner.
temp = self.target;
self.target = current.event;
self.message = current.message;
SUB_UseTargets();
self.target = temp;
self.message = "";
}
if ( current.spawnflags & ANGLES )
{
self.rotate = '0 0 0';
self.angles = self.finalangle;
}
if ( current.spawnflags & ROTATION )
{
self.rotate = current.rotate;
}
if ( current.spawnflags & DAMAGE )
{
self.dmg = current.dmg;
}
if ( current.spawnflags & SET_DAMAGE )
{
SetDamageOnTargets( current.dmg );
}
if ( current.speed == -1 )
{
// Warp to the next path_corner
setorigin( self, targ.origin );
self.endtime = self.ltime + 0.01;
SetTargetOrigin();
if ( targ.spawnflags & ANGLES )
{
self.angles = targ.angles;
}
self.duration = 1; // 1 / duration
self.cnt = time; // start time
self.dest2 = '0 0 0'; // delta
self.dest1 = self.origin; // original position
self.finaldest = self.origin;
}
else
{
self.state = STATE_MOVE;
self.finaldest = targ.origin;
if (self.finaldest == self.origin)
{
self.velocity = '0 0 0';
self.endtime = self.ltime + 0.1;
self.duration = 1; // 1 / duration
self.cnt = time; // start time
self.dest2 = '0 0 0'; // delta
self.dest1 = self.origin; // original position
self.finaldest = self.origin;
return;
}
// set destdelta to the vector needed to move
vdestdelta = self.finaldest - self.origin;
// calculate length of vector
len = vlen (vdestdelta);
if ( current.spawnflags & MOVETIME )
{
traveltime = current.speed;
}
else
{
// check if there's a speed change
if (current.speed>0)
self.speed = current.speed;
if (!self.speed)
objerror("No speed is defined!");
// divide by speed to get time to reach dest
traveltime = len / self.speed;
}
if (traveltime < 0.1)
{
self.velocity = '0 0 0';
self.endtime = self.ltime + 0.1;
if ( targ.spawnflags & ANGLES )
{
self.angles = targ.angles;
}
return;
}
// qcc won't take vec/float
div = 1 / traveltime;
if ( targ.spawnflags & ANGLES )
{
self.finalangle = SUB_NormalizeAngles( targ.angles );
self.rotate = ( targ.angles - self.angles ) * div;
}
// set endtime to trigger a think when dest is reached
self.endtime = self.ltime + traveltime;
// scale the destdelta vector by the time spent traveling to get velocity
self.velocity = vdestdelta * div;
self.duration = div; // 1 / duration
self.cnt = time; // start time
self.dest2 = vdestdelta; // delta
self.dest1 = self.origin; // original position
}
};
void() rotate_train_find =
{
local entity targ;
self.state = STATE_FIND;
LinkRotateTargets();
// the first target is the point of rotation.
// the second target is the path.
targ = find ( NIL, targetname, self.path);
if ( targ.classname != "path_rotate" )
objerror( "Next target is not path_rotate" );
// Save the current entity
self.goalentity = targ;
if ( targ.spawnflags & ANGLES )
{
self.angles = targ.angles;
self.finalangle = SUB_NormalizeAngles( targ.angles );
}
self.path = targ.target;
setorigin (self, targ.origin );
SetTargetOrigin();
RotateTargetsFinal();
self.think1 = rotate_train_next;
if (!self.targetname)
{
// not triggered, so start immediately
self.endtime = self.ltime + 0.1;
}
else
{
self.endtime = 0;
}
self.duration = 1; // 1 / duration
self.cnt = time; // start time
self.dest2 = '0 0 0'; // delta
self.dest1 = self.origin; // original position
};
/*QUAKED func_rotate_train (0 .5 .8) (-8 -8 -8) (8 8 8)
In path_rotate, set speed to be the new speed of the train after it reaches
the path change. If speed is -1, the train will warp directly to the next
path change after the specified wait time. If MOVETIME is set on the
path_rotate, the train to interprets "speed" as the length of time to
take moving from one corner to another.
"noise" contains the name of the sound to play when train stops.
"noise1" contains the name of the sound to play when train moves.
Both "noise" and "noise1" defaults depend upon "sounds" variable and
can be overridden by the "noise" and "noise1" variable in path_rotate.
Also in path_rotate, if STOP is set, the train will wait until it is
retriggered before moving on to the next goal.
Trains are moving platforms that players can ride.
"path" specifies the first path_rotate and is the starting position.
If the train is the target of a button or trigger, it will not begin moving until activated.
The func_rotate_train entity is the center of rotation of all objects targeted by it.
If "deathtype" is set with a string, this is the message that will appear when a player is killed by the train.
speed default 100
dmg default 0
sounds
1) ratchet metal
*/
void() rotate_train =
{
objerror ("rotate_train entities should be changed to rotate_object with\nfunc_rotate_train controllers\n");
};
void() func_rotate_train =
{
if (!self.speed)
self.speed = 100;
if (!self.target)
objerror ("rotate_train without a target");
if ( !self.noise )
{
if (self.sounds == 0)
{
self.noise = ("misc/null.wav");
}
if (self.sounds == 1)
{
self.noise = ("plats/train2.wav");
}
}
if ( !self.noise1 )
{
if (self.sounds == 0)
{
self.noise1 = ("misc/null.wav");
}
if (self.sounds == 1)
{
self.noise1 = ("plats/train1.wav");
}
}
precache_sound( self.noise );
precache_sound( self.noise1 );
self.cnt = 1;
self.solid = SOLID_NOT;
self.movetype = MOVETYPE_STEP;
self.use = rotate_train_use;
setmodel (self, self.model);
setsize (self, self.mins, self.maxs);
setorigin (self, self.origin);
// start trains on the second frame, to make sure their targets have had
// a chance to spawn
self.ltime = time;
self.nextthink = self.ltime + 0.1;
self.endtime = self.ltime + 0.1;
self.think = rotate_train_think;
self.think1 = rotate_train_find;
self.state = STATE_FIND;
self.duration = 1; // 1 / duration
self.cnt = 0.1; // start time
self.dest2 = '0 0 0'; // delta
self.dest1 = self.origin; // original position
self.flags = self.flags | FL_ONGROUND;
};
//************************************************
//
// Moving clip walls
//
//************************************************
void() rotate_door_reversedirection;
void() rotate_door_group_reversedirection;
void() movewall_touch =
{
if (time < self.owner.attack_finished)
return;
if ( self.dmg )
{
T_Damage (other, self, self.owner, self.dmg);
self.owner.attack_finished = time + 0.5;
}
else if ( self.owner.dmg )
{
T_Damage (other, self, self.owner, self.owner.dmg);
self.owner.attack_finished = time + 0.5;
}
};
void() movewall_blocked =
{
local entity temp;
if (time < self.owner.attack_finished)
return;
self.owner.attack_finished = time + 0.5;
if ( self.owner.classname == "func_rotate_door" )
{
temp = self;
self = self.owner;
rotate_door_group_reversedirection();
self = temp;
}
if ( self.dmg )
{
T_Damage (other, self, self.owner, self.dmg);
self.owner.attack_finished = time + 0.5;
}
else if ( self.owner.dmg )
{
T_Damage (other, self, self.owner, self.owner.dmg);
self.owner.attack_finished = time + 0.5;
}
};
void() movewall_think =
{
self.ltime = time;
self.nextthink = time + 0.02;
};
/*QUAKED func_movewall (0 .5 .8) ? VISIBLE TOUCH NONBLOCKING
Used to emulate collision on rotating objects.
VISIBLE causes brush to be displayed.
TOUCH specifies whether to cause damage when touched by player.
NONBLOCKING makes the brush non-solid. This is useless if VISIBLE is set.
"dmg" specifies the damage to cause when touched or blocked.
*/
void() func_movewall =
{
self.angles = '0 0 0';
self.movetype = MOVETYPE_PUSH;
if ( self.spawnflags & NONBLOCKING )
{
self.solid = SOLID_NOT;
}
else
{
self.solid = SOLID_BSP;
self.blocked = movewall_blocked;
}
if ( self.spawnflags & TOUCH )
{
self.touch = movewall_touch;
}
setmodel (self,self.model);
if ( !( self.spawnflags & VISIBLE ) )
{
self.model = "";
}
self.think = movewall_think;
self.nextthink = time + 0.02;
self.ltime = time;
};
/*QUAKED rotate_object (0 .5 .8) ?
This defines an object to be rotated. Used as the target of func_rotate_door.
*/
void() rotate_object =
{
self.classname = "rotate_object";
self.solid = SOLID_NOT;
self.movetype = MOVETYPE_NONE;
setmodel (self,self.model);
setsize( self, self.mins, self.maxs );
self.think = dont_think;
};
//************************************************
//
// Rotating doors
//
//************************************************
void() rotate_door_think2 =
{
local float t;
t = time - self.ltime;
self.ltime = time;
// change to alternate textures
self.frame = 1 - self.frame;
self.angles = self.dest;
if ( self.state == STATE_OPENING )
{
self.state = STATE_OPEN;
}
else
{
if ( self.spawnflags & STAYOPEN )
{
rotate_door_group_reversedirection();
return;
}
self.state = STATE_CLOSED;
}
sound(self, CHAN_VOICE, self.noise3, 1, ATTN_NORM);
self.think = dont_think;
RotateTargetsFinal();
};
void() rotate_door_think =
{
local float t;
t = time - self.ltime;
self.ltime = time;
if ( time < self.endtime )
{
self.angles = self.angles + ( self.rotate * t );
RotateTargets();
}
else
{
self.angles = self.dest;
RotateTargets();
self.think = rotate_door_think2;
}
self.nextthink = time + 0.01;
};
void() rotate_door_reversedirection =
{
local vector start;
// change to alternate textures
self.frame = 1 - self.frame;
if ( self.state == STATE_CLOSING )
{
start = self.dest1;
self.dest = self.dest2;
self.state = STATE_OPENING;
}
else
{
start = self.dest2;
self.dest = self.dest1;
self.state = STATE_CLOSING;
}
sound(self, CHAN_VOICE, self.noise2, 1, ATTN_NORM);
self.rotate = ( self.dest - start ) * ( 1 / self.speed );
self.think = rotate_door_think;
self.nextthink = time + 0.02;
self.endtime = time + self.speed - ( self.endtime - time );
self.ltime = time;
};
void() rotate_door_group_reversedirection =
{
local string name;
// tell all associated rotaters to reverse direction
if ( self.group )
{
name = self.group;
self = find( NIL, group, name);
while( self )
{
rotate_door_reversedirection();
self = find( self, group, name);
}
}
else
{
rotate_door_reversedirection();
}
};
void() rotate_door_use =
{
local vector start;
if ( ( self.state != STATE_OPEN ) && ( self.state != STATE_CLOSED ) )
return;
if ( !self.cnt )
{
self.cnt = 1;
LinkRotateTargets();
}
// change to alternate textures
self.frame = 1 - self.frame;
if ( self.state == STATE_CLOSED )
{
start = self.dest1;
self.dest = self.dest2;
self.state = STATE_OPENING;
}
else
{
start = self.dest2;
self.dest = self.dest1;
self.state = STATE_CLOSING;
}
sound(self, CHAN_VOICE, self.noise2, 1, ATTN_NORM);
self.rotate = ( self.dest - start ) * ( 1 / self.speed );
self.think = rotate_door_think;
self.nextthink = time + 0.01;
self.endtime = time + self.speed;
self.ltime = time;
};
/*QUAKED func_rotate_door (0 .5 .8) (-8 -8 -8) (8 8 8) STAYOPEN
Creates a door that rotates between two positions around a point of
rotation each time it's triggered.
STAYOPEN tells the door to reopen after closing. This prevents a trigger-
once door from closing again when it's blocked.
"dmg" specifies the damage to cause when blocked. Defaults to 2. Negative numbers indicate no damage.
"speed" specifies how the time it takes to rotate
"sounds"
1) medieval (default)
2) metal
3) base
*/
void() func_rotate_door =
{
if (!self.target)
{
objerror( "rotate_door without target." );
}
self.dest1 = '0 0 0';
self.dest2 = self.angles;
self.angles = self.dest1;
// default to 2 seconds
if ( !self.speed )
{
self.speed = 2;
}
self.cnt = 0;
if (!self.dmg)
self.dmg = 2;
else if ( self.dmg < 0 )
{
self.dmg = 0;
}
if (self.sounds == 0)
// self.sounds = 1; // OfN - allow custom sounds
{
precache_sound (self.noise1);
precache_sound (self.noise2);
precache_sound (self.noise3);
//self.noise1 = "doors/latch2.wav";
//self.noise2 = "doors/winch2.wav";
//self.noise3 = "doors/drclos4.wav";
}
if (self.sounds == 1)
{
precache_sound ("doors/latch2.wav");
precache_sound ("doors/winch2.wav");
precache_sound ("doors/drclos4.wav");
self.noise1 = "doors/latch2.wav";
self.noise2 = "doors/winch2.wav";
self.noise3 = "doors/drclos4.wav";
}
if (self.sounds == 2)
{
precache_sound ("doors/airdoor1.wav");
precache_sound ("doors/airdoor2.wav");
self.noise2 = "doors/airdoor1.wav";
self.noise1 = "doors/airdoor2.wav";
self.noise3 = "doors/airdoor2.wav";
}
if (self.sounds == 3)
{
precache_sound ("doors/basesec1.wav");
precache_sound ("doors/basesec2.wav");
self.noise2 = "doors/basesec1.wav";
self.noise1 = "doors/basesec2.wav";
self.noise3 = "doors/basesec2.wav";
}
self.solid = SOLID_NOT;
self.movetype = MOVETYPE_NONE;
setmodel (self, self.model);
setorigin( self, self.origin );
setsize( self, self.mins, self.maxs );
self.state = STATE_CLOSED;
self.use = rotate_door_use;
self.think = dont_think;
};
Reference in a new issue View git blame Copy permalink