Tutorial: Rotating Brush Models for QuakeWorld

[avirox]

Have you ever wondered how to get entities like this:


.. to become like THIS:


No? Well neither have I until now!

Here is a little tutorial on implementing rotating brush support to QuakeWorld. What are rotating brush models? Well, they're basically things like spinning fans, rotating trains and rotating doors. Basically the stuff you see in quake 2/half-life/every game made after those two. Interestingly, most of this functionality is actually already present within winquake. However, quakeworld lacks the quake 2 references that WQ has, and also QW player traces needs to be accounted for.

First I'd like to credit the sources for this code. Namely: id software, MrG, LordHavoc, Spike, and the little leprechaun that sits on my shoulder and tells me to burn things.

Begin the beguine
Open up sv_phys.c and prepare to make it your bitch. Find SV_Physics_Pusher and add the following function right above it:

Code: Select all

/*
============
SV_PushRotate

============
*/
void SV_PushRotate (edict_t *pusher, float movetime)
{
   int         i, e;
   edict_t      *check, *block;
   vec3_t      move, a, amove;
   vec3_t      entorig, pushorig;
   int         num_moved;
   edict_t      *moved_edict[MAX_EDICTS];
   vec3_t      moved_from[MAX_EDICTS];
   vec3_t      org, org2;
   vec3_t      forward, right, up;

   if (!pusher->v.avelocity[0] && !pusher->v.avelocity[1] && !pusher->v.avelocity[2])
   {
      pusher->v.ltime += movetime;
      return;
   }

   for (i=0 ; i<3 ; i++)
      amove[i] = pusher->v.avelocity[i] * movetime;

   VectorSubtract (vec3_origin, amove, a);
   AngleVectors (a, forward, right, up);

   VectorCopy (pusher->v.angles, pushorig);
   
// move the pusher to it's final position

   VectorAdd (pusher->v.angles, amove, pusher->v.angles);
   pusher->v.ltime += movetime;
   SV_LinkEdict (pusher, false);


// see if any solid entities are inside the final position
   num_moved = 0;
   check = NEXT_EDICT(sv.edicts);
   for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check))
   {
      if (check->free)
         continue;
      if (check->v.movetype == MOVETYPE_PUSH
      || check->v.movetype == MOVETYPE_NONE
      || check->v.movetype == MOVETYPE_FOLLOW
      || check->v.movetype == MOVETYPE_NOCLIP)
         continue;

   // if the entity is standing on the pusher, it will definately be moved
      if ( ! ( ((int)check->v.flags & FL_ONGROUND)
      && PROG_TO_EDICT(check->v.groundentity) == pusher) )
      {
         if ( check->v.absmin[0] >= pusher->v.absmax[0]
         || check->v.absmin[1] >= pusher->v.absmax[1]
         || check->v.absmin[2] >= pusher->v.absmax[2]
         || check->v.absmax[0] <= pusher->v.absmin[0]
         || check->v.absmax[1] <= pusher->v.absmin[1]
         || check->v.absmax[2] <= pusher->v.absmin[2] )
            continue;

      // see if the ent's bbox is inside the pusher's final position
         if (!SV_TestEntityPosition (check))
            continue;
      }

   // remove the onground flag for non-players
      if (check->v.movetype != MOVETYPE_WALK)
         check->v.flags = (int)check->v.flags & ~FL_ONGROUND;
      
      VectorCopy (check->v.origin, entorig);
      VectorCopy (check->v.origin, moved_from[num_moved]);
      moved_edict[num_moved] = check;
      num_moved++;

      // calculate destination position
      VectorSubtract (check->v.origin, pusher->v.origin, org);
      org2[0] = DotProduct (org, forward);
      org2[1] = -DotProduct (org, right);
      org2[2] = DotProduct (org, up);
      VectorSubtract (org2, org, move);

      // try moving the contacted entity
      pusher->v.solid = SOLID_NOT;
      SV_PushEntity (check, move);
      pusher->v.solid = SOLID_BSP;

   // if it is still inside the pusher, block
      block = SV_TestEntityPosition (check);
      if (block)
      {   // fail the move
         if (check->v.mins[0] == check->v.maxs[0])
            continue;
         if (check->v.solid == SOLID_NOT || check->v.solid == SOLID_TRIGGER)
         {   // corpse
            check->v.mins[0] = check->v.mins[1] = 0;
            VectorCopy (check->v.mins, check->v.maxs);
            continue;
         }
         
         VectorCopy (entorig, check->v.origin);
         SV_LinkEdict (check, true);

         VectorCopy (pushorig, pusher->v.angles);
         SV_LinkEdict (pusher, false);
         pusher->v.ltime -= movetime;

         // if the pusher has a "blocked" function, call it
         // otherwise, just stay in place until the obstacle is gone
         if (pusher->v.blocked)
         {
            pr_global_struct->self = EDICT_TO_PROG(pusher);
            pr_global_struct->other = EDICT_TO_PROG(check);
            PR_ExecuteProgram (pusher->v.blocked);
         }
         
      // move back any entities we already moved
         for (i=0 ; i<num_moved ; i++)
         {
            VectorCopy (moved_from[i], moved_edict[i]->v.origin);
            VectorSubtract (moved_edict[i]->v.angles, amove, moved_edict[i]->v.angles);
            SV_LinkEdict (moved_edict[i], false);
         }
         return;
      }
      else
      {
         VectorAdd (check->v.angles, amove, check->v.angles);
      }
   }

   
}


Now we must edit SV_Physics_Pusher. Compare your SV_Physics_Pusher function with the one below, and add the code in //ROTATE START and //ROTATE END to yours (PS. in some engines it may be possible to just replace your whole function altogether with the one below):

Code: Select all

void SV_Physics_Pusher (edict_t *ent)
{
   float   thinktime;
   float   oldltime;
   float   movetime;

   oldltime = ent->v.ltime;
   
   thinktime = ent->v.nextthink;
   if (thinktime < ent->v.ltime + sv_frametime)
   {
      movetime = thinktime - ent->v.ltime;
      if (movetime < 0)
         movetime = 0;
   }
   else
      movetime = sv_frametime;

   if (movetime)
   {
//ROTATE START
      if (ent->v.avelocity[0] || ent->v.avelocity[1] || ent->v.avelocity[2])
         SV_PushRotate (ent, sv_frametime);
      else
//ROTATE END
         SV_PushMove (ent, movetime);   // advances ent->v.ltime if not blocked
   }
      
   if (thinktime > oldltime && thinktime <= ent->v.ltime)
   {
      ent->v.nextthink = 0;
      pr_global_struct->time = sv.time;
      pr_global_struct->self = EDICT_TO_PROG(ent);
      pr_global_struct->other = EDICT_TO_PROG(sv.edicts);
      PR_ExecuteProgram (ent->v.think);
      if (ent->free)
         return;
   }
}


We're done with that file. Now on to world.c

Go to SV_LinkEdict and edit it thusly (again, look at //ROTATE START and //ROTATE END references):

Code: Select all

void SV_LinkEdict (edict_t *ent, qbool touch_triggers)
{
   areanode_t   *node;
   
   if (ent->area.prev)
      SV_UnlinkEdict (ent);   // unlink from old position
      
   if (ent == sv.edicts)
      return;      // don't add the world

   if (ent->free)
      return;

// set the abs box
// ROTATE START
   if (ent->v.solid == SOLID_BSP &&
   (ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )
   {   // expand for rotation
      float      max, v;
      int         i;

max = DotProduct(ent->v.mins, ent->v.mins);

v = DotProduct(ent->v.maxs, ent->v.maxs);

if (max < v)

   max = v;

   max = sqrt(max);

   for (i=0 ; i<3 ; i++)

      {

      ent->v.absmin[i] = ent->v.origin[i] - max;

      ent->v.absmax[i] = ent->v.origin[i] + max;

      }

   }
   else
// ROTATE END
   {
      VectorAdd (ent->v.origin, ent->v.mins, ent->v.absmin);
      VectorAdd (ent->v.origin, ent->v.maxs, ent->v.absmax);
   }

   //
// to make items easier to pick up and allow them to be grabbed off
// of shelves, the abs sizes are expanded
   //
   if ((int)ent->v.flags & FL_ITEM)
   {
      ent->v.absmin[0] -= 15;
      ent->v.absmin[1] -= 15;
      ent->v.absmax[0] += 15;
      ent->v.absmax[1] += 15;
   }
   else
   {   // because movement is clipped an epsilon away from an actual edge,
      // we must fully check even when bounding boxes don't quite touch
      ent->v.absmin[0] -= 1;
      ent->v.absmin[1] -= 1;
      ent->v.absmin[2] -= 1;
      ent->v.absmax[0] += 1;
      ent->v.absmax[1] += 1;
      ent->v.absmax[2] += 1;
   }
   
// link to PVS leafs
   if (ent->v.modelindex)
      SV_LinkToLeafs (ent);
   else
      ent->num_leafs = 0;

   if (ent->v.solid == SOLID_NOT)
      return;

// find the first node that the ent's box crosses
   node = sv_areanodes;
   while (1)
   {
      if (node->axis == -1)
         break;
      if (ent->v.absmin[node->axis] > node->dist)
         node = node->children[0];
      else if (ent->v.absmax[node->axis] < node->dist)
         node = node->children[1];
      else
         break;      // crosses the node
   }
   
// link it in   

   if (ent->v.solid == SOLID_TRIGGER)
      InsertLinkBefore (&ent->area, &node->trigger_edicts);
   else
      InsertLinkBefore (&ent->area, &node->solid_edicts);
   
// if touch_triggers, touch all entities at this node and decend for more
   if (touch_triggers)
      SV_TouchLinks ( ent, sv_areanodes );
}


Next in world.c we need SV_ClipMoveToEntity. Find it and change it to look like the following:

Code: Select all

trace_t SV_ClipMoveToEntity (edict_t *ent, vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end)
{
      trace_t      trace;
   vec3_t      offset;
   vec3_t      start_l, end_l;
   hull_t      *hull;

// fill in a default trace
   memset (&trace, 0, sizeof(trace_t));
   trace.fraction = 1;
   trace.allsolid = true;
   VectorCopy (end, trace.endpos);

// get the clipping hull
   hull = SV_HullForEntity (ent, mins, maxs, offset);

   VectorSubtract (start, offset, start_l);
   VectorSubtract (end, offset, end_l);

// ROTATE START
   // rotate start and end into the models frame of reference
   if (ent->v.solid == SOLID_BSP &&
   (ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )
   {
      vec3_t   a;
      vec3_t   forward, right, up;
      vec3_t   temp;

      AngleVectors (ent->v.angles, forward, right, up);

      VectorCopy (start_l, temp);
      start_l[0] = DotProduct (temp, forward);
      start_l[1] = -DotProduct (temp, right);
      start_l[2] = DotProduct (temp, up);

      VectorCopy (end_l, temp);
      end_l[0] = DotProduct (temp, forward);
      end_l[1] = -DotProduct (temp, right);
      end_l[2] = DotProduct (temp, up);
   }
// ROTATE END

// trace a line through the apropriate clipping hull
   //SV_RecursiveHullCheck (hull, hull->firstclipnode, 0, 1, start_l, end_l, &trace);
   if (ent->v.solid != SOLID_BSP)
   {
      ent->v.angles[0]*=-1;   //carmack made bsp models rotate wrongly.
      trace = CM_HullTrace (hull, start_l, end_l);
      ent->v.angles[0]*=-1;
   }
   else
      trace = CM_HullTrace (hull, start_l, end_l);

// ROTATE START
   // rotate endpos back to world frame of reference
   if (ent->v.solid == SOLID_BSP &&
   (ent->v.angles[0] || ent->v.angles[1] || ent->v.angles[2]) )
   {
      vec3_t   a;
      vec3_t   forward, right, up;
      vec3_t   temp;

      if (trace.fraction != 1)
      {
         VectorSubtract (vec3_origin, ent->v.angles, a);
         AngleVectors (a, forward, right, up);

         VectorCopy (trace.endpos, temp);
         trace.endpos[0] = DotProduct (temp, forward);
         trace.endpos[1] = -DotProduct (temp, right);
         trace.endpos[2] = DotProduct (temp, up);

         VectorCopy (trace.plane.normal, temp);
         trace.plane.normal[0] = DotProduct (temp, forward);
         trace.plane.normal[1] = -DotProduct (temp, right);
         trace.plane.normal[2] = DotProduct (temp, up);
      }
   }
// ROTATE END

// fix trace up by the offset
   VectorAdd (trace.endpos, offset, trace.endpos);

// did we clip the move?
   if (trace.fraction < 1 || trace.startsolid )
      trace.e.ent = ent;

   return trace;
}


Lets add some ints to the physent_t struct. Add these two if they are not already present in the struct:

Code: Select all

   vec3_t      angles;
   int         solid;   // xavior hax


Now we need to work on player collision. Go to the function AddLinksToPmove in sv_user.c and add the following lines in the if (check->v.solid == SOLID_BSP) { } segment:

Code: Select all

            VectorCopy (check->v.angles, pe->angles);      // for rot brushes
            pe->solid = SOLID_BSP;


Finally we must fix up the player trace. Find PM_PlayerTrace and edit it accordingly:

Code: Select all

trace_t PM_PlayerTrace (vec3_t start, vec3_t end)
{
   trace_t      trace, total;
   vec3_t      offset;
   vec3_t      start_l, end_l;
   hull_t      *hull;
   int         i;
   physent_t   *pe;
   vec3_t      mins, maxs, tracemins, tracemaxs;

// fill in a default trace
   memset (&total, 0, sizeof(trace_t));
   total.fraction = 1;
   total.e.entnum = -1;
   VectorCopy (end, total.endpos);

   PM_TraceBounds(start, end, tracemins, tracemaxs);

   for (i=0 ; i< pmove.numphysent ; i++)
   {
      pe = &pmove.physents[i];

   // get the clipping hull
      if (pe->model)
      {
         if (sv_client->is_crouching == 1)
            hull = &pmove.physents[i].model->hulls[3];
         else
            hull = &pmove.physents[i].model->hulls[1];

         //if (i > 0 && PM_CullTraceBox(tracemins, tracemaxs, pe->origin, pe->model->mins, pe->model->maxs, hull->clip_mins, hull->clip_maxs))
         //   continue;

         VectorSubtract (hull->clip_mins, player_mins, offset);
         VectorAdd (offset, pe->origin, offset);
      }
      else
      {
         VectorSubtract (pe->mins, player_maxs, mins);
         VectorSubtract (pe->maxs, player_mins, maxs);

         if (PM_CullTraceBox(tracemins, tracemaxs, pe->origin, mins, maxs, vec3_origin, vec3_origin))
            continue;

         hull = CM_HullForBox (mins, maxs);
         VectorCopy (pe->origin, offset);
      }

      VectorSubtract (start, offset, start_l);
      VectorSubtract (end, offset, end_l);

// ROTATE START
   // rotate start and end into the models frame of reference
      if (pe->solid == SOLID_BSP &&
   (pe->angles[0] || pe->angles[1] || pe->angles[2]) )
   {
      vec3_t   a;
      vec3_t   forward, right, up;
      vec3_t   temp;

      AngleVectors (pe->angles, forward, right, up);

      VectorCopy (start_l, temp);
      start_l[0] = DotProduct (temp, forward);
      start_l[1] = -DotProduct (temp, right);
      start_l[2] = DotProduct (temp, up);

      VectorCopy (end_l, temp);
      end_l[0] = DotProduct (temp, forward);
      end_l[1] = -DotProduct (temp, right);
      end_l[2] = DotProduct (temp, up);
   }
// ROTATE END

      // trace a line through the apropriate clipping hull
      trace = CM_HullTrace (hull, start_l, end_l);
// ROTATE START
   // rotate endpos back to world frame of reference
   if (pe->solid == SOLID_BSP &&
   (pe->angles[0] || pe->angles[1] || pe->angles[2]) )
   {
      vec3_t   a;
      vec3_t   forward, right, up;
      vec3_t   temp;

      if (trace.fraction != 1)
      {
         VectorSubtract (vec3_origin, pe->angles, a);
         AngleVectors (a, forward, right, up);

         VectorCopy (trace.endpos, temp);
         trace.endpos[0] = DotProduct (temp, forward);
         trace.endpos[1] = -DotProduct (temp, right);
         trace.endpos[2] = DotProduct (temp, up);

         VectorCopy (trace.plane.normal, temp);
         trace.plane.normal[0] = DotProduct (temp, forward);
         trace.plane.normal[1] = -DotProduct (temp, right);
         trace.plane.normal[2] = DotProduct (temp, up);
      }
   }
// ROTATE END

      // fix trace up by the offset
      VectorAdd (trace.endpos, offset, trace.endpos);

      if (trace.allsolid)
         trace.startsolid = true;
      if (trace.startsolid)
         trace.fraction = 0;

      // did we clip the move?
      if (trace.fraction < total.fraction)
      {
         total = trace;
         total.e.entnum = i;
      }

   }

   return total;
}


And that's it! You should now have functional rotating brush support in your quakeworld server. If you want to make a test in your QC mod, follow the one at the bottom of this page. Feel free to leave comments/suggestions/death threats. If there is something that's not compiling, also let me know!

Enjoy, and happy new year!

[Baker]

Thanks!

Btw, your "modified FuhQuake" has vwep and alpha textures support right?

Future QW tutorial wish list: Animation interpolation tutorial for Quakeworld"(ezQuake has this feature, correct?)

After reading tutorials like this, part of me wants to focus on ripping and borrowing from your modified FuhQuake and ezQuake and up-strength the ZQuake engine's capabilities into a "clean total conversion oriented" all purpose Quake engine.

[avirox]

FuhQuake has interpolation similar to ezquake actually, but it's only applied to specified models (hard-coded, in fact. Why this is, I'm still not sure. I suppose one day I'll modify it to support everything and see how it looks..

[frag.machine]

Excellent tut, avirox.

[goldenboy]

And that's it! You should now have functional rotating brush support in your quakeworld server. If you want to make a test in your QC mod, follow the one at the bottom of this page. Feel free to leave comments/suggestions/death threats. If there is something that's not compiling, also let me know!

Which engines support this? I assume FTE should support self.avelocity_(x,y,z) based rotation right?

I put this

Code: Select all

void() func_rotating =

{

   self.solid = SOLID_BSP;

   self.movetype = MOVETYPE_PUSH;

   setorigin (self, self.origin);

   setmodel (self, self.model);

   self.classname = "func_rotating";

   setsize (self, self.mins, self.maxs);



   if (!self.speed)

      self.speed = 100;



   if (self.spawnflags & 2) // reverse direction

      self.speed = 0 - self.speed;



   if (self.spawnflags & 64) // not solid

      self.solid = SOLID_NOT;



   if (self.spawnflags & 4)

   {

      self.avelocity_z = self.speed;

      self.avelocity_x = 0;

      self.avelocity_y = 0;

   }

   else if (self.spawnflags & 8)

   {

      self.avelocity_z = 0;

      self.avelocity_x = self.speed;

      self.avelocity_y = 0;

   }

   else

   {

      self.avelocity_z = 0;

      self.avelocity_x = 0;

      self.avelocity_y = self.speed;

   }

};

into RMQ, and then I made a testmap with a func_rotating.

I then set the entity's "origin" to the bmodel's origin.

Tried the map in darkplaces and FTE - the bmodel was nowhere to be found, not even when I noclipped around.

Next, I moved the whole map so the func_rotating was centered at 0 0 0. I tried both setting "origin" to that, and settig no origin key.

The brush appeared in the map now, but wasn't rotating.

No spawnflags set.

This whole shit is SO frustrating. I've tried this a number of times now, first with the rotating door code from Quake Life, now with the simple func_rotating code from the tutorial, and NOTHING WORKS.

Edit: Closer investigation reveals that FTE doesn't have this code. Hmm, OK.

A case for a new standard...

[avirox]

FTE has rotating brush ents, actually, but it looks different in code Also, you need to compile your map's rotating entity with an origin brush.

[Spike]

velocity and thus avelocity only work on MOVETYPE_PUSH entities if they have a valid nextthink.

[goldenboy]

velocity and thus avelocity only work on MOVETYPE_PUSH entities if they have a valid nextthink.

OK. That seems to do something

Code: Select all

self.nextthink = time;

and it's rotating, yay - although DP dumps me back in the console with "QC function self.think is missing", which is kinda logical -

It works when I just point self.think at func_rotating. There must be a better way though...

And I just noticed that what I have now rotates in DP, but not in FTE :-/ aaargh.

xavior, there are no Q1 map compilers that support origin brushes, so I just put "origin" "x y z" manually in the map editor. That seems a little weird, too, because what I get in the engine is something else (64 units lower) than what I get in the editor...

Anyway, the qc from the quakesrc.org tutorial does not work - it works in DP when I add

Code: Select all

self.think = func_rotating;
self.nextthink = time;

but not in FTE.

Example code for a func_rotating that works in DP and FTE would be much appreciated.

[Baker]

2 questions:

1. Can someone upload a map sample that works with this or am I going to have to use a Half-Life map?

2. Does ANY existing map compiler for Q1 support origin brushes? Just wondering.

[goldenboy]

1. Yes, shortly, but only works in DP with the above QC code;

2. No.

[goldenboy]

Code: Select all

/*QUAKED func_rotating (0 .5 .8) ? x REVERSE Z_AXIS X_AXIS x x NONSOLID
Origin-rotating bmodel - experimental

"speed"         rotation speed (100 default)
"origin"        origin vector, x y z
*/

void() func_rotating =
{
        self.solid = SOLID_BSP;
        self.movetype = MOVETYPE_PUSH;
        self.think = func_rotating;
        setorigin (self, self.origin);
        setmodel (self, self.model);
        self.classname = "func_rotating";
        setsize (self, self.mins, self.maxs);

        if (!self.speed)
                self.speed = 100;

        if (self.spawnflags & 2) // reverse direction
                self.speed = 0 - self.speed;

        if (self.spawnflags & 64) // not solid
                self.solid = SOLID_NOT;

        if (self.spawnflags & 4)
        {
                self.avelocity_z = self.speed;
                self.avelocity_x = 0;
                self.avelocity_y = 0;
        }
        else if (self.spawnflags & 8)
        {
                self.avelocity_z = 0;
                self.avelocity_x = self.speed;
                self.avelocity_y = 0;
        }
        else
        {
                self.avelocity_z = 0;
                self.avelocity_x = 0;
                self.avelocity_y = self.speed;
        }

        self.nextthink = time;  // next frame;
};

http://www.quaketastic.com/upload/files ... origin.zip

The map contains a func_rotating in the form of a cube.

The qc and map combination works in DP (rotates).

"origin" was set manually.

http://www.4shared.com/file/187101836/6 ... rigin.html

Small vid of a happily spinning yellow block - in DP.

[r00k]

Nice!

[Spike]

at spawn, time = 0
self.nextthink = time = 0; does nothing.

use:

self.think = SUB_Null;
self.nextthink = self.ltime + 9999999;

(the self.ltime term is optional, yeah, okay, it'll be 0, but hey, it highlights the difference between movetype_push and any other ent).

[goldenboy]

No luck. With the new qc, it still spins in DP, but not in FTE.

It's drawn in the correct place, just doesn't start to rotate

I tried a bit of stuff like self.nextthink = time + 0.1 and similar, but no luck.

[r00k]

you dont need to .think back to the function. the physics code will rotate if the avelocity != 0. You DO need to set self.ltime = time + 0.1; maybe ?

Here's how Hipnotic is doing it....

Code: Select all


void () RotateTargets =
{
   local entity ent;
   local vector vx;
   local vector vy;
   local vector vz;
   local vector org;

   makevectors (self.angles);
   ent = find (world, 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 * CONTENT_EMPTY);
         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 * CONTENT_EMPTY);
            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 * CONTENT_EMPTY);
            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 (world, targetname, self.target);
   while (ent)
   {
      ent.velocity = VEC_ORIGIN;
      if ((ent.rotate_type == OBJECT_ROTATE))
      {
         ent.angles = self.angles;
      }
      ent = find (ent, targetname, self.target);
   }
};

void () SetTargetOrigin =
{
   local entity ent;

   ent = find (world, 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 (world, 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 () 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 = SUB_Null;
};

void () rotate_door_think2 =
{
   local float t;

   t = (time - self.ltime);
   self.ltime = time;
   self.frame = (TRUE - 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, TRUE, ATTN_NORM);
   self.think = SUB_Null;
   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;

   self.frame = (TRUE - 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, TRUE, ATTN_NORM);
   self.rotate = ((self.dest - start) * (TRUE / 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;

   if (self.group)
   {
      name = self.group;
      self = find (world, group, name);
      while (self)
      {
         rotate_door_reversedirection ();
         self = find (self, group, name);
      }
   }
   else
   {
      rotate_door_reversedirection ();
   }
};

void () rotate_door_use =
{
   local entity t;
   local vector start;

   if (((self.state != STATE_OPEN) && (self.state != STATE_CLOSED)))
   {
      return;
   }
   if (!self.cnt)
   {
      self.cnt = TRUE;
      LinkRotateTargets ();
   }
   self.frame = (TRUE - 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, TRUE, ATTN_NORM);
   self.rotate = ((self.dest - start) * (TRUE / self.speed));
   self.think = rotate_door_think;
   self.nextthink = (time + 0.01);
   self.endtime = (time + self.speed);
   self.ltime = time;
};

void () func_rotate_door =
{
   if (!self.target)
   {
      objerror ("rotate_door without target.");
   }
   self.dest1 = VEC_ORIGIN;
   self.dest2 = self.angles;
   self.angles = self.dest1;
   if (!self.speed)
   {
      self.speed = FL_SWIM;
   }
   self.cnt = FALSE;
   if (!self.dmg)
   {
      self.dmg = FL_SWIM;
   }
   else
   {
      if ((self.dmg < FALSE))
      {
         self.dmg = FALSE;
      }
   }
   if ((self.sounds == FALSE))
   {
      self.sounds = TRUE;
   }
   if ((self.sounds == TRUE))
   {
      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 == FL_SWIM))
   {
      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 == MOVETYPE_WALK))
   {
      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 = SUB_Null;
};