raven/hexen2
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
hexen2/H2W/HCode/Doors.hc

1986 lines
48 KiB
C++
Raw Normal View History

as released 2000-11-10
2000-11-10 00:00:00 +00:00
/*
* $Header: /HexenWorld/HCode/Doors.hc 5 4/23/98 5:15p Mgummelt $
*/
float DOOR_START_OPEN = 1;
float REVERSE = 2;
float DOOR_DONT_LINK = 4;
float DOOR_TOGGLE = 8;
float DOOR_SLIDE = 16;
float DOOR_NORMAL = 32;
float DOOR_REMOVE_PP = 64;
float DOOR_NO_PP = 128;
/*
Doors are similar to buttons, but can spawn a fat trigger field around them
to open without a touch, and they link together to form simultanious
double/quad doors.
Door.owner is the master door. If there is only one door, it points to itself.
If multiple doors, all will point to a single one.
Door.enemy chains from the master door through all doors linked in the chain.
*/
void door_hit_bottom();
void door_hit_top();
/*
===========================================================================
door_slide
===========================================================================
*/
void door_slide_next()
{
local vector vdestdelta, odelta;
local float len, tspeed;//, len2;
tspeed = self.speed;
if(!tspeed)
objerror("No speed is defined!");
// Make sure we're not already at the destination
if(self.finaldest == self.origin)
{
self.velocity = '0 0 0';
if(self.state == STATE_DOWN)
self.think = door_hit_bottom;
else if(self.state == STATE_UP)
self.think = door_hit_top;
self.nextthink = self.ltime + 0.1;
return;
}
vdestdelta = self.finaldest - self.origin; // Set destdelta to the vector needed to move
odelta = self.origin - self.pos1;
len = vlen(odelta); // Get the length of the vector
// If the length is this small, just stop
if(vlen(vdestdelta) < 0.1)
{
if(self.state == STATE_DOWN)
door_hit_bottom();
else if(self.state == STATE_UP)
door_hit_top();
else
dprint("Bad door state!\n");
return;
}
self.nextthink = self.ltime + 0.1;
self.think = door_slide_next;
tspeed = ((self.speed - (len / 10)) / 20);
if(tspeed < 2)
{
if(self.state == STATE_DOWN)
SUB_CalcMove(self.finaldest, self.speed, door_hit_bottom);
else if(self.state == STATE_UP)
SUB_CalcMove(self.finaldest, self.speed, door_hit_top);
else
dprint("Bad door state!\n");
return;
}
self.velocity = vdestdelta * tspeed;
}
void door_slide(vector tdest)
{
self.finaldest = tdest;
door_slide_next();
}
/*
===========================================================================
door_crash
===========================================================================
*/
void door_crash_next()
{
local vector vdestdelta, nextvect, testvect;
local vector tdest;
local float len, nextlen, testlen;
local float tspeed;
tdest = self.finaldest;
tspeed = self.speed;
if(!tspeed)
objerror("No speed is defined!");
if(tdest == self.origin)
{
self.velocity = '0 0 0';
if(self.state == STATE_DOWN)
self.think = door_hit_bottom;
else if(self.state == STATE_UP)
self.think = door_hit_top;
else
dprint("Bad door state!\n");
self.nextthink = self.ltime + 0.1;
return;
}
// set destdelta to the vector needed to move
vdestdelta = self.finaldest - self.origin;
nextvect = self.pos2 - self.origin;
testvect = self.pos2 - self.finaldest;
// calculate length of vector
len = vlen (vdestdelta);
nextlen = vlen(nextvect) + 1;
testlen = vlen(testvect);
if(len < 0.1 || nextlen > testlen)
{
door_hit_bottom;
return;
}
else
{
self.velocity = vdestdelta * (nextlen / len) * 4;
nextvect = self.origin + self.velocity;
nextlen = vlen(nextvect);
if(nextlen >= testlen * 2)
{
SUB_CalcMove(self.finaldest, self.speed * (len / (len / 3)), door_hit_bottom);
return;
}
}
self.nextthink = self.ltime + 0.1;
self.think = door_crash_next;
}
void door_crash(vector tdest)
{
self.finaldest = tdest;
door_crash_next();
}
/*
=============================================================================
THINK FUNCTIONS
=============================================================================
*/
void door_go_down();
void door_go_up();
void door_damage()
{
T_Damage (other, self, self, self.dmg);
}
void door_blocked()
{
//FIXME: Rotating doors sem to think they're being blocked
// even if they're rotating down and the object is above them
if(self.wait>-2&&self.strength<=0)
if(self.dmg==666)
{
if(other.classname=="player"&&other.flags2&FL_ALIVE)
{
other.decap=TRUE;
T_Damage (other, self, self, other.health+300);
}
else
T_Damage (other, self, self, other.health+50);
}
else
{
T_Damage (other, self, self, self.dmg);
}
//Rotating doors rotating around a x or z axis push you up and in the direction they're turning
/* if(self.strength==2)
{
other.flags(-)FL_ONGROUND;
other.velocity=normalize(self.origin-(other.absmin+other.absmax)*0.5)*100;
}
else*/ if(other.flags&FL_ONGROUND&&(self.movedir_x||self.movedir_z)&&self.strength==1)//&&other.origin_z>self.origin_z
{
other.flags(-)FL_ONGROUND;
other.velocity_z+=self.speed*2;
other.velocity_x-=self.speed*self.movedir_x;
other.velocity_y-=self.speed*self.movedir_z;
}
else
{
other.flags(-)FL_ONGROUND;
other.velocity_z+=10;
}
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (other.health>0)
if (self.wait >= 0)
{
if (self.state == STATE_DOWN)
door_go_up ();
else
door_go_down ();
}
}
void door_blocked_mp()
{
float do_dmg;
/*
dprint("Blocked Door: \n");
dprint(other.classname);
dprint("\n");
dprintv("Velocity: %s\n",self.velocity);
dprintv("Avelocity: %s\n",self.avelocity);
*/
//FIXME: Rotating doors seem to think they're being blocked
// even if they're rotating down and the object is above them
// if(self.classname=="door_rotating")
// self.nextthink+=HX_FRAME_TIME;//self.wait?
/* dprint("door blocked\n");
dprintf("dmg = %s\n",self.dmg);
dprintf("strength = %s\n",self.strength);
dprintf("wait = %s\n",self.wait);
dprint("other = ");
dprint(other.classname);
dprint("\n");*/
if(self.dmg==-1)
{
if(other.classname=="player" && other.flags2&FL_ALIVE)
{
if (self.wait >= 0)
{
if (self.state == STATE_DOWN)
door_go_up ();
else
door_go_down ();
}
return;
}
else
do_dmg=2;
}
else
do_dmg=self.dmg;
// dprintf("Door dmg = %s\n",do_dmg);
if(self.wait>-2)//&&self.strength<=0)
{
if(do_dmg==666)
{
if(other.classname=="player"&&other.flags2&FL_ALIVE)
{
other.decap=TRUE;
T_Damage (other, self, self, other.health+300);
}
else
T_Damage (other, self, self, other.health+50);
}
else
{
// dprintf("crushing- %s\n",do_dmg);
T_Damage (other, self, self, do_dmg);//FIXME: Rotating doors get stuck open and never try to return
}
}
// else
// dprint("Door wait <= -2\n");
//Rotating doors rotating around a x or z axis push you up and in the direction they're turning
/* if(self.strength==2)
{
other.flags(-)FL_ONGROUND;
other.velocity=normalize(self.origin-(other.absmin+other.absmax)*0.5)*100;
}
else*/
/*NOT in MP maps?
if(other.flags&FL_ONGROUND&&(self.movedir_x||self.movedir_z)&&self.strength==1)//&&other.origin_z>self.origin_z
{//This is not neccessary anymore
other.flags(-)FL_ONGROUND;
other.velocity_z+=self.speed*2;
other.velocity_x-=self.speed*self.movedir_x;
other.velocity_y-=self.speed*self.movedir_z;
}
else
{
other.flags(-)FL_ONGROUND;
other.velocity_z+=10;
}
*/
// if a door has a negative wait, it would never come back if blocked,
// so let it just squash the object to death real fast
if (other.health>0)
if (self.wait >= 0)//&&self.wait!=1.5)
{
if (self.state == STATE_DOWN)
{
// dprint("Going up...\n");
door_go_up ();
}
else
{
// dprint("Going down...\n");
door_go_down ();
}
}
}
void door_hit_top()
{
self.velocity = '0 0 0';
sound (self,CHAN_UPDATE+PHS_OVERRIDE_R, self.noise1, 1, ATTN_NORM);
self.effects(-)EF_UPDATESOUND;
self.state = STATE_TOP;
if (self.spawnflags & DOOR_TOGGLE)
return; // don't come down automatically
if(self.wait== -2)
self.th_die();
else if(self.wait== -1)
self.nextthink = -1;
else
{
self.think = door_go_down;
self.nextthink = self.ltime + self.wait;
}
}
void door_hit_bottom()
{
self.velocity = '0 0 0';
sound (self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise1, 1, ATTN_NORM);
self.effects(-)EF_UPDATESOUND;
self.state = STATE_BOTTOM;
}
void door_go_down()
{
string hold_target;
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise2, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
if(!self.thingtype && self.max_health)
{
self.takedamage = DAMAGE_YES;
self.health = self.max_health;
}
self.state = STATE_DOWN;
if(self.classname == "door")
{
// dprintv("rotation: %s\n",self.v_angle);
if(self.spawnflags & DOOR_SLIDE)
door_slide(self.pos1);
else if(self.spawnflags & DOOR_NORMAL)
if(self.v_angle!='0 0 0')
if(self.speed)
if(self.anglespeed)
SUB_CalcMoveAndAngleInit (self.pos1, self.speed, self.o_angle, self.anglespeed, door_hit_bottom,FALSE);
else
SUB_CalcMoveAndAngleInit (self.pos1, self.speed, self.o_angle, self.anglespeed, door_hit_bottom,TRUE);
else
SUB_CalcAngleMove(self.o_angle, self.anglespeed, door_hit_bottom);
else
SUB_CalcMove(self.pos1, self.speed, door_hit_bottom);
else
door_crash(self.pos1);
}
else if (self.classname == "door_rotating")
SUB_CalcAngleMove(self.pos1, self.speed, door_hit_bottom);
if(self.close_target!="")
{//Use second target when closing
hold_target=self.target;
self.target=self.close_target;
SUB_UseTargets();
self.target=hold_target;
}
}
void new_movedir (vector movin,float dir)
{
self.movedir = movin;
// check for clockwise rotation
if (dir<0)
self.movedir = self.movedir * -1;
self.pos1 = self.angles;
self.pos2 = self.angles + self.movedir * self.dflags;
}
void door_go_up()
{
if(self.state == STATE_UP) /* Already going up */
{
// dprint("UP: Tried to go up while already going up\n");
return;
}
if(self.state == STATE_TOP) /* Reset top wait time */
{
self.nextthink = self.ltime + self.wait;
// dprint("TOP: Tried to go up while already at top\n");
return;
}
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise2, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
self.state = STATE_UP;
if(self.classname == "door")
{
if(self.spawnflags & DOOR_NORMAL)
{
if(self.v_angle!='0 0 0')
{
if(self.speed)
{
if(self.anglespeed)
SUB_CalcMoveAndAngleInit (self.pos2, self.speed, self.v_angle, self.anglespeed, door_hit_top,FALSE);
else
SUB_CalcMoveAndAngleInit (self.pos2, self.speed, self.v_angle, self.anglespeed, door_hit_top,TRUE);
}
else
SUB_CalcAngleMove(self.v_angle, self.anglespeed, door_hit_top);
}
else
SUB_CalcMove(self.pos2, self.speed, door_hit_top);
}
else
door_slide(self.pos2);
}
else if(self.classname == "door_rotating")
SUB_CalcAngleMove(self.pos2, self.speed, door_hit_top);
SUB_UseTargets();
}
/*
=============================================================================
ACTIVATION FUNCTIONS
=============================================================================
*/
void door_fire()
{
entity oself;
entity starte;
// if(self.wait<=-1 || self.wait==1.5)//not supposed to return
// if(self.velocity!='0 0 0'||self.avelocity!='0 0 0')//Moving
// return;
if (self.owner != self)
objerror ("door_fire: self.owner != self");
self.no_puzzle_msg = 0;
// play use key sound
self.message = 0; // no more message
oself = self;
if (self.spawnflags & DOOR_TOGGLE)
{
if (self.state == STATE_UP || self.state == STATE_TOP)
{
starte = self;
do
{
door_go_down ();
self = self.enemy;
} while ( (self != starte) && (self != world) );
self = oself;
return;
}
}
// trigger all paired doors
starte = self;
do
{
door_go_up ();
self = self.enemy;
} while ( (self != starte) && (self != world) );
self = oself;
}
/*
* door_use() -- Called whenever a door is opened.
*/
void door_use()
{
entity oself;
/*
dprint("Door Used by: ");
dprint(other.classname);
dprint("\n");
dprint("Door's Activator: ");
dprint(activator.classname);
dprint("\n");
*/
if(self.inactive)
{
// dprint("Door not active\n");
return;
}
self.message = 0; // door messages are for touch only
self.owner.message = 0;
self.enemy.message = 0;
oself = self;
self = self.owner;
door_fire ();
self = oself;
}
// defined in triggers.hc
float check_puzzle_pieces(entity client, float remove_pieces, float inverse);
/*
* door_trigger_touch() -- Called when someone touches a door.
*/
void door_trigger_touch()
{
entity door;
string temp;
float removepp, inversepp;
// if(!other.flags2&FL_ALIVE)
// return;
if(!other.flags&FL_CLIENT&&!other.flags&FL_MONSTER)
return;
if(other.flags&FL_MONSTER&&world.spawnflags&MISSIONPACK)
return;
if(time < self.attack_finished)
return;
door = self;
self = self.owner;
if(!deathmatch)
{
removepp = (self.spawnflags & DOOR_REMOVE_PP);
inversepp = (self.spawnflags & DOOR_NO_PP);
if (!check_puzzle_pieces(other,removepp,inversepp))
{
if (self.no_puzzle_msg && !deathmatch)
{
temp = getstring(self.no_puzzle_msg);
centerprint (other, temp);
door.attack_finished = time + 2;
}
return;
}
}
self.attack_finished = time + 1;
activator = other;
door_use();
}
/*
* door_killed() -- Used to open doors that open when shot.
*/
void door_killed()
{
local entity oself;
oself = self;
self = self.owner;
self.health = self.max_health;
self.takedamage = DAMAGE_NO; // wil be reset upon return
door_use();
self = oself;
}
/*
* door_touch() -- Prints messages and opens key doors.
*/
void door_touch()
{
string temp;
float removepp, inversepp;
// dprint("Door hit!\n");
// if(!other.flags2&FL_ALIVE)
// return;
if(!other.flags&FL_CLIENT&&!other.flags&FL_MONSTER)
return;
if(other.flags&FL_MONSTER&&world.spawnflags&MISSIONPACK)
return;
if(self.dmg==666&&(self.velocity!='0 0 0'||self.avelocity!='0 0 0'))
{
if(other.classname=="player"&&other.flags2&FL_ALIVE)
{
other.decap=TRUE;
T_Damage (other, self, self, other.health+300);
}
else
T_Damage (other, self, self, other.health+50);
}
if(self.owner.attack_finished > time)
return;
if (self.owner)
self.owner.attack_finished = time + 2;
if(self.owner.message != 0 && !deathmatch && self.owner != world)
{
temp = getstring(self.owner.message);
centerprint (other, temp);
sound (other, CHAN_UPDATE+PHS_OVERRIDE_R, "misc/comm.wav", 1, ATTN_NORM);
}
// key door stuff
if (!self.puzzle_piece_1 && !self.puzzle_piece_2 && !self.puzzle_piece_3 && !self.puzzle_piece_4)
return;
// FIXME: blink key on player's status bar
removepp = (self.spawnflags & DOOR_REMOVE_PP);
inversepp = (self.spawnflags & DOOR_NO_PP);
if (!check_puzzle_pieces(other,removepp,inversepp))
{
if (self.no_puzzle_msg && !deathmatch)
{
temp = getstring(self.no_puzzle_msg);
centerprint (other, temp);
}
return;
}
self.touch = SUB_Null;
if (self.enemy)
self.enemy.touch = SUB_Null; // get paired door
door_use ();
}
/*
=============================================================================
SPAWNING FUNCTIONS
=============================================================================
*/
entity spawn_field(vector fmins, vector fmaxs, entity door)
{//FIXME: THIS ENTITY NEEDS TO REMOVE ITSELF IF IT'S OWNER IS
//REMOVED!
entity trigger;
vector t1, t2;
trigger = spawn();
trigger.movetype = MOVETYPE_NONE;
trigger.solid = SOLID_TRIGGER;
trigger.owner = door;
trigger.touch = door_trigger_touch;
t1 = fmins;
t2 = fmaxs;
// if (door.classname == "door")
// {
// if(self.v_angle!='0 0 0')
// {
t1 += door.origin;
t2 += door.origin;
setsize (trigger, t1 - '60 60 8', t2 + '60 60 8');
/* }
else
setsize (trigger, t1 - '60 60 8', t2 + '60 60 8');
}
else if (door.classname == "door_rotating")
{
t1 += door.origin;
t2 += door.origin;
setsize (trigger, t1 - '60 60 8', t2 + '60 60 8');
}
*/ return (trigger);
}
float EntitiesTouching(entity e1, entity e2)
{
local vector e1max, e1min, e2max, e2min;
//Rotating door's mins and maxs aren't based on their world positions,
//so the origin needs to be applied to make sure they are checking their
//real positions
if (e1.classname == "door_rotating"||(e1.classname=="door"&&e1.v_angle!='0 0 0'))
{
e1max = e1.maxs + e1.origin;
e1min = e1.mins + e1.origin;
e2max = e2.maxs + e2.origin;
e2min = e2.mins + e2.origin;
}
else
{
e1max = e1.maxs;
e1min = e1.mins;
e2max = e2.maxs;
e2min = e2.mins;
}
if (e1min_x > e2max_x)
return FALSE;
if (e1min_y > e2max_y)
return FALSE;
if (e1min_z > e2max_z)
return FALSE;
if (e1max_x < e2min_x)
return FALSE;
if (e1max_y < e2min_y)
return FALSE;
if (e1max_z < e2min_z)
return FALSE;
return TRUE;
}
/*
* LinkDoors()
*/
void LinkDoors()
{
entity t, starte;
vector cmins, cmaxs;
if (self.enemy)
return; // already linked by another door
if (self.spawnflags & 4)
{
self.owner = self.enemy = self;
return; // don't want to link this door
}
cmins = self.mins;
cmaxs = self.maxs;
starte = self;
t = self;
do
{
self.owner = starte; // master door
if (!self.thingtype && self.health)
starte.health = self.health;
if (self.targetname)
starte.targetname = self.targetname;
if (self.message != 0)
starte.message = self.message;
t = find (t, classname, self.classname);
if (!t)
{
self.enemy = starte; // make the chain a loop
// shootable, fired, or key doors just needed the owner/enemy links,
// they don't spawn a field
self = self.owner;
if (!self.thingtype && self.health)
return;
if (self.targetname)
return;
if (self.puzzle_piece_1 != string_null ||
self.puzzle_piece_2 != string_null ||
self.puzzle_piece_3 != string_null ||
self.puzzle_piece_4 != string_null)
return;
self.owner.trigger_field = spawn_field(cmins, cmaxs, self.owner);
return;
}
if (EntitiesTouching(self,t))
{
if (t.enemy)
objerror ("cross connected doors");
self.enemy = t;
self = t;
if (t.mins_x < cmins_x)
cmins_x = t.mins_x;
if (t.mins_y < cmins_y)
cmins_y = t.mins_y;
if (t.mins_z < cmins_z)
cmins_z = t.mins_z;
if (t.maxs_x > cmaxs_x)
cmaxs_x = t.maxs_x;
if (t.maxs_y > cmaxs_y)
cmaxs_y = t.maxs_y;
if (t.maxs_z > cmaxs_z)
cmaxs_z = t.maxs_z;
}
} while (1);
}
void door_sounds(void)
{
self.noise3 = "doors/baddoor.wav";
if (self.soundtype == 0) // No sound
{
self.noise1 = "misc/null.wav";
self.noise2 = "misc/null.wav";
self.noise4 = "misc/null.wav";
}
else if (self.soundtype == 1) // Big Metal door, swinging
{
precache_sound ("doors/gatestop.wav");
precache_sound ("doors/gateswng.wav");
precache_sound ("doors/gatestrt.wav");
self.noise1 = "doors/gatestop.wav";
self.noise2 = "doors/gateswng.wav";
self.noise4 = "doors/gatestrt.wav";
}
else if (self.soundtype == 2) // Big Stone Door, sliding
{
precache_sound ("doors/doorstop.wav");
precache_sound ("doors/stonslid.wav");
precache_sound ("doors/dorstart.wav");
self.noise1 = "doors/doorstop.wav";
self.noise2 = "doors/stonslid.wav";
self.noise4 = "doors/dorstart.wav";
}
else if (self.soundtype == 3) // Big Wood Door, Swinging
{
precache_sound ("doors/swngstop.wav");
precache_sound ("doors/wdswngbg.wav");
precache_sound ("doors/dorstart.wav");
self.noise1 = "doors/swngstop.wav";
self.noise2 = "doors/wdswngbg.wav";
self.noise4 = "doors/dorstart.wav";
}
else if (self.soundtype == 4) // Normal Wood Door, Swinging
{
precache_sound ("doors/swngstop.wav");
precache_sound ("doors/wdswngsm.wav");
precache_sound ("doors/dorstart.wav");
self.noise1 = "doors/swngstop.wav";
self.noise2 = "doors/wdswngsm.wav";
self.noise4 = "doors/dorstart.wav";
}
else if (self.soundtype == 5) // Big Wood Door, Sliding
{
precache_sound ("doors/swngstop.wav");
precache_sound ("doors/woodslid.wav");
precache_sound ("doors/dorstart.wav");
self.noise1 = "doors/swngstop.wav";
self.noise2 = "doors/woodslid.wav";
self.noise4 = "doors/dorstart.wav";
}
else if (self.soundtype == 6) // Drawbridge, Falling and crushing innocent peasants who are
// basically slave labor, who toil away their lives so that the rich upperclass
// can keep busy inbreeding with each other. Damn the aristocracy! Freedom to
// the common man! Burn the castle! Death to the tyrants!
{
precache_sound ("doors/doorstop.wav");
precache_sound ("doors/drawmove.wav");
precache_sound ("doors/drawstrt.wav");
self.noise1 = "doors/doorstop.wav";
self.noise2 = "doors/drawmove.wav";
self.noise4 = "doors/dorstart.wav";
}
else if (self.soundtype == 7) // Rotating Walkway
{
precache_sound ("doors/doorstop.wav");
precache_sound ("doors/stonslid.wav");
precache_sound ("doors/dorstart.wav");
self.noise1 = "doors/doorstop.wav";
self.noise2 = "doors/stonslid.wav";
self.noise4 = "doors/dorstart.wav";
}
else if (self.soundtype == 8) // Big Metal door, sliding
{
precache_sound ("doors/mtlstop.wav");
precache_sound ("doors/mtlslide.wav");
precache_sound ("doors/mtlstart.wav");
self.noise1 = "doors/mtlstop.wav";
self.noise2 = "doors/mtlslide.wav";
self.noise4 = "doors/mtlstart.wav";
}
else if (self.soundtype == 9) // Pendulum
{
precache_sound2 ("doors/penstop.wav");
precache_sound2 ("doors/penswing.wav");
precache_sound2 ("doors/penstart.wav");
self.noise1 = "doors/penstop.wav";
self.noise2 = "doors/penswing.wav";
self.noise4 = "doors/penstart.wav";
}
}
void door_rotate_incr_done()
{
// if(self.strength==2)
// cvar_set ("sv_gravity", "800");
}
void() door_rotate_incr =
{
vector newvect;
if(self.strength==2)
cvar_set ("sv_gravity", "100");
self.dflags=self.flags;
self.flags=0;
if(self.v_angle!='0 0 0')
{
if(random()>0.5&&self.v_angle_x!=0)
{
self.cnt=self.dflags=self.v_angle_x;
new_movedir('1 0 0',self.cnt);
}
else if(random()>0.5&&self.v_angle_y!=0)
{
self.cnt=self.dflags=self.v_angle_y;
new_movedir('0 1 0',self.cnt);
}
else if(self.v_angle_z!=0)
{
self.cnt=self.dflags=self.v_angle_z;
new_movedir('0 0 1',self.cnt);
}
}
newvect = self.movedir * self.cnt;
SUB_CalcAngleMove(self.angles + newvect, self.speed, door_rotate_incr_done);
};
/*QUAKED func_door (0 .5 .8) ? START_OPEN REVERSE DOOR_DONT_LINK TOGGLE SLIDE NORMAL_MOVE remove_pp no_pp
NOTE: Doors can now be activated and deactivated with the appropriate triggers.
"inactive" set to 1 to start the door deactivated.
if two doors touch, they are assumed to be connected and operate as a unit.
-----------------------FIELDS-------------------------
TOGGLE causes the door to wait in both the start and end states for a trigger event.
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).
Key doors are allways wait -1.
"message" is printed when the door is touched if it is a trigger door and it hasn't been fired yet
"angle" determines the opening direction
"level" how far (in map units) to move in the specified angle- overrides default movement that is size of door
"targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
"health" if set, door must be shot open
"speed" movement speed (100 default), -1 will not move, just rotate
"wait" wait before returning (3 default, -1 = never return)
"lip" lip remaining at end of move (8 default)
"dmg" damage to inflict when blocked (2 default) If you make it
666, it will gib anything it touches, and behead players.
-1 it will hurt other things, but not players
"close_target" secondary target to fire when door closes
ROTATING DOORS: MUST HAVE AN ORIGIN BRUSH
"v_angle" Angle to turn, in: pitch yaw roll, '0 0 0' will not rotate, just move (default = '0 0 0')
"anglespeed" how quickly to turn in that direction. no anglespeed will force it to choose one that will synch the completion of the rotation iwth the completion of the move. (default = 0)
"strength" When set to 1, it will throw something if it gets in the way
"soundtype"
0) no sound
1) Big metal door, swinging
2) Big stone door, sliding
3) Big wood door, swinging
4) Normal wood door, swinging
5) Big wood door, sliding
6) Drawbridge
7) Rotating walkway
8) Big metal door, sliding
9) Pendulum swinging
Puzzle Pieces (use the puzzle_id value from the pieces)
puzzle_piece_1
puzzle_piece_2
puzzle_piece_3
puzzle_piece_4
no_puzzle_msg: message when player doesn't have the right pieces
--------------------------------------------------------
*/
void func_door()
{
float movedist, num_axes;
door_sounds();
SetMovedir ();
// check for clockwise rotation
if (self.spawnflags & REVERSE)
{
self.movedir = self.movedir * -1;
self.v_angle = self.v_angle * -1;
}
self.max_health = self.health;
self.solid = SOLID_BSP;
self.movetype = MOVETYPE_PUSH;
setorigin (self, self.origin);
setmodel (self, self.model);
self.classname = "door";
self.use = door_use;
if (self.abslight)
self.drawflags = self.drawflags | MLS_ABSLIGHT;
if (self.speed==-1)
self.speed=0;
else if(!self.speed)
self.speed = 100;
if (!self.wait)
self.wait = 3;
if (!self.lip)
self.lip = 8;
if(world.spawnflags&MISSIONPACK)
self.blocked = door_blocked_mp;
else
self.blocked = door_blocked;
if (!self.dmg)
// self.dmg = -1;
self.dmg = 2;
self.pos1 = self.origin;
// dprintf("Worldspawn.spawnflags = %s\n",world.spawnflags);
if(world.spawnflags&MISSIONPACK)
{
// dprint("Using new door code\n");
if(self.level)
movedist = self.level - self.lip;
else
{
//was: movedist=fabs(self.movedir*self.size) - self.lip;
// dprintv("Door movedir = %s\n",self.movedir);
// dprintv("Door size = %s\n",self.size);
num_axes=0;
movedist=0;
if(fabs(self.movedir_x)>0.001)
{
// dprint("X axis\n");
movedist+=fabs(self.movedir_x*self.size_x);
num_axes+=1;
}
if(fabs(self.movedir_y)>0.001)
{
// dprint("Y axis\n");
movedist+=fabs(self.movedir_y*self.size_y);
num_axes+=1;
}
if(fabs(self.movedir_z)>0.001)
{
// dprint("Z axis\n");
movedist+=fabs(self.movedir_z*self.size_z);
num_axes+=1;
}
movedist=movedist/num_axes - self.lip;
// dprintf("Door movedist = %s\n",movedist);
}
self.pos2 = self.pos1 + self.movedir*movedist;
}
else
{
// dprint("Using old door code\n");
if(self.level)
self.pos2 = self.pos1 + self.movedir*(self.level - self.lip);
else
self.pos2 = self.pos1 + self.movedir*(fabs(self.movedir*self.size) - self.lip);
}
// dprintv("Pos1: %s\n",self.pos1);
// dprintv("Pos2: %s\n",self.pos2);
if(self.v_angle!='0 0 0')
{
self.o_angle=self.angles;
self.v_angle+=self.angles;
}
if(self.wait== -2)
{
self.th_die = chunk_death;
// self.takedamage = DAMAGE_YES;
if (!self.health)
{
if ((self.thingtype == THINGTYPE_GLASS) || (self.thingtype == THINGTYPE_CLEARGLASS))
self.max_health = self.health = 25;
else if ((self.thingtype == THINGTYPE_GREYSTONE) || (self.thingtype == THINGTYPE_BROWNSTONE)||self.thingtype == THINGTYPE_DIRT)
self.max_health = self.health = 75;
else if (self.thingtype == THINGTYPE_WOOD)
self.max_health = self.health = 50;
else if (self.thingtype == THINGTYPE_METAL)
self.max_health = self.health = 100;
else if (self.thingtype == THINGTYPE_FLESH)
self.max_health = self.health = 30;
else
self.max_health = self.health = 25;
}
}
// DOOR_START_OPEN is to allow an entity to be lighted in the closed position
// but spawn in the open position
if (self.spawnflags & DOOR_START_OPEN)
{
if(self.v_angle!='0 0 0')
{
self.angles = self.v_angle;
self.v_angle = self.o_angle;
self.o_angle = self.angles;
}
setorigin (self, self.pos2);
self.pos2 = self.pos1;
self.pos1 = self.origin;
}
self.state = STATE_BOTTOM;
if (self.health)
{
self.takedamage = DAMAGE_YES;
self.th_die =self.th_pain= door_killed;
}
if (self.puzzle_piece_1 != string_null ||
self.puzzle_piece_2 != string_null ||
self.puzzle_piece_3 != string_null ||
self.puzzle_piece_4 != string_null)
self.wait = -1;
self.touch = door_touch;
// LinkDoors can't be done until all of the doors have been spawned, so
// the sizes can be detected properly.
self.think = LinkDoors;
self.nextthink = self.ltime + 0.1;
if (self.cnt)
{
self.touch = SUB_Null;
self.use = door_rotate_incr;
}
}
/*QUAKED func_door_smashing (0 .5 .8) ? START_OPEN x DOOR_DONT_LINK TOGGLE SLIDE NORMAL_MOVE remove_pp no_pp
NOTE: Doors can now be activated and deactivated with the appropriate triggers.
"inactive" set to 1 to start the door deactivated.
if two doors touch, they are assumed to be connected and operate as a unit.
-----------------------FIELDS-------------------------
TOGGLE causes the door to wait in both the start and end states for a trigger event.
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).
Key doors are allways wait -1.
"message" is printed when the door is touched if it is a trigger door and it hasn't been fired yet
"angle" determines the opening direction
"targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
"speed" movement speed (100 default)
"wait" wait before returning (3 default, -1 = never return)
"lip" lip remaining at end of move (8 default)
"dmg" damage to inflict when blocked (2 default)
"close_target" secondary target to fire when door closes
"soundtype"
0) no sound
1) Big metal door, swinging
2) Big stone door, sliding
3) Big wood door, swinging
4) Normal wood door, swinging
5) Big wood door, sliding
6) Drawbridge
7) Rotating walkway
8) Big metal door, sliding
9) Pendulum swinging
Puzzle Pieces (use the puzzle_id value from the pieces)
puzzle_piece_1
puzzle_piece_2
puzzle_piece_3
puzzle_piece_4
no_puzzle_msg: message when player doesn't have the right pieces
--------------------------------------------------------
void func_door_smashing()
{
door_sounds();
SetMovedir ();
self.solid = SOLID_BSP;
self.movetype = MOVETYPE_PUSH;
setorigin (self, self.origin);
setmodel (self, self.model);
self.classname = "door";
if(world.spawnflags&MISSIONPACK)
self.blocked = door_blocked_mp;
else
self.blocked = door_blocked;
self.use = door_use;
if (!self.speed)
self.speed = 100;
if (!self.wait)
self.wait = 3;
if (!self.lip)
self.lip = 8;
if (!self.dmg)
self.dmg = 2;
self.pos1 = self.origin;
self.pos2 = self.pos1 + self.movedir*(fabs(self.movedir*self.size) - self.lip);
// DOOR_START_OPEN is to allow an entity to be lighted in the closed position
// but spawn in the open position
if (self.spawnflags & DOOR_START_OPEN)
{
setorigin (self, self.pos2);
self.pos2 = self.pos1;
self.pos1 = self.origin;
}
self.state = STATE_BOTTOM;
self.takedamage = DAMAGE_YES;
self.th_die = chunk_death;
if(self.soundtype == 1)
{
self.thingtype = THINGTYPE_GREYSTONE;
self.max_health = self.health = 75;
}
else if(self.soundtype == 4)
{
self.thingtype = THINGTYPE_METAL;
self.max_health = self.health = 100;
}
else {
self.thingtype = THINGTYPE_WOOD;
self.max_health = self.health = 50;
}
self.touch = door_touch;
// LinkDoors can't be done until all of the doors have been spawned, so
// the sizes can be detected properly.
self.think = LinkDoors;
self.nextthink = self.ltime + 0.1;
}*/
/*
=============================================================================
SECRET DOORS
=============================================================================
*/
void fd_secret_move1();
void fd_secret_move2();
void fd_secret_move3();
void fd_secret_move4();
void fd_secret_move5();
void fd_secret_move6();
void fd_secret_done();
float SECRET_OPEN_ONCE = 1; // stays open
float SECRET_1ST_LEFT = 2; // 1st move is left of arrow
float SECRET_1ST_DOWN = 4; // 1st move is down from arrow
float SECRET_NO_SHOOT = 8; // only opened by trigger
float SECRET_YES_SHOOT = 16; // shootable even if targeted
void fd_secret_use()
{
local float temp;
self.health = 10000;
// exit if still moving around...
if(self.origin != self.oldorigin)
return;
if(self.inactive)
return;
self.message = 0; // no more message
SUB_UseTargets(); // fire all targets / killtargets
if(!self.spawnflags & SECRET_NO_SHOOT)
{
self.th_pain = SUB_Null;
self.takedamage = DAMAGE_NO;
}
self.velocity = '0 0 0';
// Make a sound, wait a little...
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise1, 1, ATTN_NORM);
self.effects(-)EF_UPDATESOUND;
self.nextthink = self.ltime + 0.1;
temp = 1 - (self.spawnflags & SECRET_1ST_LEFT); // 1 or -1
makevectors(self.mangle);
if(!self.t_width)
{
if (self.spawnflags & SECRET_1ST_DOWN)
self. t_width = fabs(v_up * self.size);
else
self. t_width = fabs(v_right * self.size);
}
if (!self.t_length)
self. t_length = fabs(v_forward * self.size);
if (self.spawnflags & SECRET_1ST_DOWN)
self.dest1 = self.origin - v_up * self.t_width;
else
self.dest1 = self.origin + v_right * (self.t_width * temp);
self.dest2 = self.dest1 + v_forward * self.t_length;
SUB_CalcMove(self.dest1, self.speed, fd_secret_move1);
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise2, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
}
/* Wait after the first movement... */
void fd_secret_move1()
{
self.nextthink = self.ltime + 1;
self.think = fd_secret_move2;
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise3, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
}
/* Start moving sideways with sound... */
void fd_secret_move2()
{
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise2, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
SUB_CalcMove(self.dest2, self.speed, fd_secret_move3);
}
/* Wait here until it's time to go back... */
void fd_secret_move3()
{
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise3, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
if(!self.spawnflags & SECRET_OPEN_ONCE)
{
self.nextthink = self.ltime + self.wait;
self.think = fd_secret_move4;
}
}
/* Move backward... */
void fd_secret_move4()
{
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise2, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
SUB_CalcMove(self.dest1, self.speed, fd_secret_move5);
}
/* Wait for one second... */
void fd_secret_move5()
{
self.nextthink = self.ltime + 1;
self.think = fd_secret_move6;
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise3, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
}
void fd_secret_move6()
{
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise2, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
SUB_CalcMove(self.oldorigin, self.speed, fd_secret_done);
}
void fd_secret_done()
{
if (!self.targetname || self.spawnflags&SECRET_YES_SHOOT)
{
self.health = 10000;
self.takedamage = DAMAGE_YES;
self.th_pain = fd_secret_use;
}
sound(self, CHAN_UPDATE+PHS_OVERRIDE_R, self.noise3, 1, ATTN_LOOP);
self.effects(+)EF_UPDATESOUND;
}
void secret_blocked()
{
if (time < self.attack_finished)
return;
self.attack_finished = time + 0.5;
T_Damage (other, self, self, self.dmg);
}
/*
* secret_touch() -- Prints messages.
*/
void secret_touch()
{
string s;
if (other.classname != "player")
return;
if (self.attack_finished > time)
return;
self.attack_finished = time + 2;
if (self.message)
{
s = getstring(self.message);
centerprint (other, s);
sound (other, CHAN_BODY, "misc/comm.wav", 1, ATTN_NORM);
}
}
/*QUAKED func_door_secret (0 .5 .8) ? open_once 1st_left 1st_down no_shoot always_shoot x remove_pp no_pp
NOTE: Doors can now be activated and deactivated with the appropriate triggers.
"inactive" set to 1 to start the door deactivated.
Basic secret door. Slides back, then to the side. Angle determines direction.
-----------------------FIELDS-------------------------
wait = # of seconds before coming back
1st_left = 1st move is left of arrow
1st_down = 1st move is down from arrow
always_shoot = even if targeted, keep shootable
t_width = override WIDTH to move back (or height if going down)
t_length = override LENGTH to move sideways
"dmg" damage to inflict when blocked (2 default)
"close_target" secondary target to fire when door closes
If a secret door has a targetname, it will only be opened by it's botton or trigger, not by damage.
"soundtype"
0) no sound
1) Big metal door, swinging
2) Big stone door, sliding
3) Big wood door, swinging
4) Normal wood door, swinging
5) Big wood door, sliding
6) Drawbridge
7) Rotating walkway
8) Big metal door, sliding
9) Pendulum swinging
Puzzle Pieces (use the puzzle_id value from the pieces)
puzzle_piece_1
puzzle_piece_2
puzzle_piece_3
puzzle_piece_4
no_puzzle_msg: message when player doesn't have the right pieces
--------------------------------------------------------
*/
void func_door_secret()
{
door_sounds();
if (!self.dmg)
self.dmg = 2;
// Magic formula...
self.mangle = self.angles;
self.angles = '0 0 0';
if(world.spawnflags&MISSIONPACK)
{
if(self.mangle=='0 -1 0')
{
self.mangle='-90 0 0';
}
else if(self.mangle=='0 -2 0')
{
self.mangle='90 0 0';
}
}
self.solid = SOLID_BSP;
self.movetype = MOVETYPE_PUSH;
self.classname = "door";
setmodel (self, self.model);
setorigin (self, self.origin);
self.touch = secret_touch;
self.blocked = secret_blocked;
self.speed = 50;
self.use = fd_secret_use;
if ( !self.targetname || self.spawnflags&SECRET_YES_SHOOT)
{
self.health = 10000;
self.takedamage = DAMAGE_YES;
self.th_pain = fd_secret_use;
self.th_die = fd_secret_use;
}
self.oldorigin = self.origin;
if (!self.wait)
self.wait = 5; // 5 seconds before closing
}
/*QUAKED func_door_rotating (0 .5 .8) ? START_OPEN REVERSE DOOR_DONT_LINK remove_pp no_pp TOGGLE X_AXIS Y_AXIS
NOTE: Doors can now be activated and deactivated with the appropriate triggers.
"inactive" set to 1 to start the door deactivated.
if two doors touch, they are assumed to be connected and operate as
a unit.
TOGGLE causes the door to wait in both the start and end states for
a trigger event.
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).
Key doors are allways wait -1.
You need to have an origin brush as part of this entity. The
center of that brush will be
the point around which it is rotated. It will rotate around the Z
axis by default. You can
check either the X_AXIS or Y_AXIS box to change that.
REVERSE will cause the door to rotate in the opposite direction.
"flags" is how many degrees the door will be rotated.
"message" is printed when the door is touched if it is a trigger door and it hasn't been fired yet
"targetname" if set, no touch field will be spawned and a remote button or trigger field activates the door.
"health" if set, door must be shot open
"speed" movement speed (100 default)
"wait" wait before returning (3 default, -1 = never return)
"dmg" damage to inflict when blocked (2 default)
a "dmg" of -1 will make it only hurt non-players
"flags2" will damage the object that touches it
"strength" When set to 1, it will throw something if it gets in the way
"close_target" secondary target to fire when door closes
"soundtype"
0) no sound
1) Big metal door, swinging
2) Big stone door, sliding
3) Big wood door, swinging
4) Normal wood door, swinging
5) Big wood door, sliding
6) Drawbridge
7) Rotating walkway
8) Big metal door, sliding
9) Pendulum swinging
"abslight" - to set the absolute light level
Puzzle Pieces (use the puzzle_id value from the pieces)
puzzle_piece_1
puzzle_piece_2
puzzle_piece_3
puzzle_piece_4
no_puzzle_msg: message when player doesn't have the right pieces
*/
void func_door_rotating()
{
vector vec;
self.dflags=self.flags;//don't ask
self.flags=0;
// set the axis of rotation
if (self.spawnflags & 64)
self.movedir = '0 0 1';
else if (self.spawnflags & 128)
self.movedir = '1 0 0';
else
self.movedir = '0 1 0';
// check for clockwise rotation
if (self.spawnflags & 2)
self.movedir = self.movedir * -1;
// CHEAT hack to get the puzzle piece flags stored in the
// same area, without re-arranging the fields so that the
// designers don't complain
self.spawnflags (-) 192;
if (self.spawnflags & 8)
self.spawnflags (+) DOOR_REMOVE_PP;
if (self.spawnflags & 16)
self.spawnflags (+) DOOR_NO_PP;
if (self.spawnflags & 32)
self.spawnflags (+) DOOR_TOGGLE;
self.pos1 = self.angles;
self.pos2 = self.angles + self.movedir * self.dflags;
self.max_health = self.health;
self.solid = SOLID_BSP;
self.movetype = MOVETYPE_PUSH;
setorigin (self, self.origin);
setmodel (self, self.model);
self.classname = "door_rotating";
if (self.abslight)
self.drawflags (+) MLS_ABSLIGHT;
if (!self.speed)
self.speed = 100;
if (self.wait==0)
self.wait = 3;
if (!self.dmg)
// self.dmg = -1;
self.dmg = 2;
if(self.wait== -2)
{
self.th_die = chunk_death;
// self.takedamage = DAMAGE_YES;
if (!self.health)
{
if ((self.thingtype == THINGTYPE_GLASS) || (self.thingtype == THINGTYPE_CLEARGLASS))
self.max_health = self.health = 25;
else if ((self.thingtype == THINGTYPE_GREYSTONE) || (self.thingtype == THINGTYPE_BROWNSTONE)||self.thingtype == THINGTYPE_DIRT)
self.max_health = self.health = 75;
else if (self.thingtype == THINGTYPE_WOOD)
self.max_health = self.health = 50;
else if (self.thingtype == THINGTYPE_METAL)
self.max_health = self.health = 100;
else if (self.thingtype == THINGTYPE_FLESH)
self.max_health = self.health = 30;
else
self.max_health = self.health = 25;
}
}
door_sounds();
// DOOR_START_OPEN is to allow an entity to be lighted in the closed position
// but spawn in the open position
if (self.spawnflags & DOOR_START_OPEN)
{
self.angles = self.pos2;
vec = self.pos2;
self.pos2 = self.pos1;
self.pos1 = vec;
self.movedir = self.movedir * -1;
}
self.state = STATE_BOTTOM;
self.touch = door_touch;
if(world.spawnflags&MISSIONPACK)
self.blocked = door_blocked_mp;
else
self.blocked = door_blocked;
self.use = door_use;
if (self.puzzle_piece_1 != string_null ||
self.puzzle_piece_2 != string_null ||
self.puzzle_piece_3 != string_null ||
self.puzzle_piece_4 != string_null)
self.wait = -1;
// LinkDoors can't be done until all of the doors have been spawned, so
// the sizes can be detected properly.
self.think = LinkDoors;
self.nextthink = self.ltime + 0.1;
if (self.cnt)
{
self.touch = SUB_Null;
self.use = door_rotate_incr;
}
if (self.flags2)
{
self.touch = door_damage;
self.flags2=FALSE;
}
}
/*
* $Log: /HexenWorld/HCode/Doors.hc $
*
* 5 4/23/98 5:15p Mgummelt
*
* 4 4/01/98 5:49p Mgummelt
*
* 3 3/29/98 9:56p Rmidthun
* Added MP door code
*
* 2 3/27/98 1:34p Mgummelt
* Adding PHS_OVERRIDE_R channel flag and ATTN_LOOP to all door and plat
* sounds, replacing all "null.wav" sounds with stopSound.
*
* 1 2/04/98 1:59p Rjohnson
*
* 79 8/30/97 6:58p Mgummelt
*
* 78 8/28/97 1:54p Rjohnson
* Puzzle piece update
*
* 77 8/20/97 7:54p Rjohnson
* Removed message for deathmatch
*
* 76 8/15/97 3:35p Bgokey
*
* 75 8/12/97 6:10p Mgummelt
*
* 74 8/05/97 11:13a Mgummelt
*
* 73 8/05/97 11:12a Mgummelt
*
* 72 7/25/97 3:59p Mgummelt
*
* 71 7/21/97 4:03p Mgummelt
*
* 70 7/21/97 4:02p Mgummelt
*
* 69 7/17/97 4:16p Rlove
*
* 68 7/16/97 8:47p Mgummelt
*
* 67 7/14/97 4:43p Mgummelt
*
* 66 7/14/97 2:11p Mgummelt
*
* 65 7/14/97 2:11p Mgummelt
*
* 64 7/10/97 7:09p Rlove
*
* 63 7/09/97 7:35a Rlove
* New thingtype of CLEARGLASS
*
* 62 7/08/97 4:46p Rlove
*
* 61 7/08/97 4:37p Rlove
*
* 60 7/08/97 3:23p Rjohnson
* Switched messages to using a string index
*
* 59 7/08/97 8:00a Rlove
*
* 58 7/03/97 3:24p Mgummelt
*
* 57 7/03/97 11:43a Mgummelt
*
* 56 7/03/97 11:20a Mgummelt
*
* 55 7/03/97 10:47a Mgummelt
*
* 54 7/01/97 4:55p Mgummelt
*
* 53 6/26/97 11:16a Rjohnson
* Global text for puzzle messages
*
* 52 6/18/97 5:31p Jweier
*
* 51 6/18/97 2:33p Jweier
*
* 50 6/18/97 12:59p Mgummelt
*
* 49 6/17/97 3:35p Mgummelt
*
* 48 6/16/97 2:18p Jweier
* Fixed rotating door spawnflag problem
*
* 47 6/16/97 9:14a Jweier
*
* 46 6/01/97 5:08a Mgummelt
*
* 45 5/27/97 8:22p Mgummelt
*
* 43 5/27/97 7:58a Rlove
* New thingtypes of GreyStone,BrownStone, and Cloth.
*
* 42 5/24/97 2:48p Rlove
* Taking out old Id sounds
*
* 41 5/23/97 11:51p Mgummelt
*
* 40 5/23/97 5:03p Jweier
*
* 39 5/22/97 6:23p Jweier
*
* 38 5/22/97 5:18p Rlove
* New door sounds
*
* 37 5/19/97 11:36p Mgummelt
*
* 36 5/11/97 7:30a Mgummelt
*
* 35 5/06/97 4:27p Rjohnson
* Added absolute light level
*
* 34 5/06/97 4:24p Rjohnson
* Added abslight to rotating doors
*
* 33 4/30/97 5:03p Mgummelt
*
* 32 4/29/97 1:09p Mgummelt
*
* 31 4/29/97 12:34p Mgummelt
*
* 30 4/26/97 1:34p Jweier
*
* 29 4/22/97 5:55p Mgummelt
*
* 28 4/22/97 4:42p Rjohnson
* Fixed a problem with doors
*
* 27 4/19/97 1:01p Rjohnson
* Fixed a problem with the doors and puzzle pieces
*
* 26 4/18/97 4:46p Rjohnson
* Added messages for when you don't have the puzzle pieces
*
* 25 4/16/97 4:53p Rjohnson
* Added info for quake-ed
*
* 24 4/16/97 4:45p Rjohnson
* Doors now work with puzzle pieces
*
* 23 4/05/97 9:49a Rlove
* Uncommented out line 387 - linked buttons appear to be the culprit.
*
* 22 4/04/97 6:49p Jweier
* fixed breakable brush problem (in EntitiesTouching)
*
* 21 4/03/97 6:55a Rlove
* Had to comment out line 384 - it was crashing the game
*
* 20 3/29/97 12:41p Aleggett
*
* 19 3/27/97 12:23p Jweier
* Fixed up some linking problems with the rotating doors
*
* 18 3/25/97 9:41a Jweier
*
* 17 3/24/97 11:00a Jweier
*
* 16 3/24/97 10:49a Jweier
* func_door_rotating !!!
*
* 15 3/21/97 5:44p Jweier
*
* 14 3/21/97 10:06a Rlove
* Changed break_die to chunk_death
*
* 13 3/18/97 5:27p Aleggett
* Added smashable door...
*
* 12 3/13/97 4:06p Jweier
*
* 11 3/13/97 9:57a Rlove
* Changed constant DAMAGE_AIM to DAMAGE_YES and the old DAMAGE_YES to
* DAMAGE_YES
*
* 10 3/12/97 6:46p Jweier
*
* 9 3/12/97 6:19p Jweier
* De-kludged the door slide, works better now
*
* 8 3/07/97 5:25p Jweier
* More door slidin' madness! (read: fixed odd door slide problem)
*
* 7 3/06/97 5:50p Jweier
*
* 6 3/06/97 5:41p Jweier
* Doors now crash down and slide up by default
*
* 5 2/26/97 5:45p Jweier
* Doors can slide into place or crash into it (still no bounce though..)
*
* 4 11/19/96 8:49a Rlove
* func_door is back in
*
* 3 11/18/96 3:29p Rlove
* Changed sounds variable to soundtype
*
* 2 11/11/96 1:12p Rlove
* Added Source Safe stuff
*/
Reference in a new issue Copy permalink