data/qcsrc/warpzonelib/server.qc

   1 .vector warpzone_oldorigin, warpzone_oldvelocity, warpzone_oldangles;
   2 .float warpzone_teleport_time;
   3
   4 void WarpZone_StoreProjectileData(entity e)
   5 {
   6         e.warpzone_oldorigin = e.origin;
   7         e.warpzone_oldvelocity = e.velocity;
   8         e.warpzone_oldangles = e.angles;
   9 }
  10
  11 void WarpZone_TeleportPlayer(entity teleporter, entity player, vector to, vector to_angles, vector to_velocity)
  12 {
  13         vector from;
  14
  15         makevectors (to_angles);
  16
  17         from = player.origin;
  18         setorigin (player, to);
  19         player.oldorigin = to; // for DP's unsticking
  20         player.angles = to_angles;
  21         player.fixangle = TRUE;
  22         player.velocity = to_velocity;
  23
  24         if(player.effects & EF_TELEPORT_BIT)
  25                 player.effects &~= EF_TELEPORT_BIT;
  26         else
  27                 player.effects |= EF_TELEPORT_BIT;
  28
  29         if(player.classname == "player")
  30                 player.flags &~= FL_ONGROUND;
  31
  32         WarpZone_PostTeleportPlayer_Callback(player);
  33 }
  34
  35 float WarpZone_Teleport(entity player)
  36 {
  37         vector o0, a0, v0, o1, a1, v1;
  38
  39         o0 = player.origin + player.view_ofs;
  40         v0 = player.velocity;
  41         a0 = player.angles;
  42
  43         if(WarpZone_PlaneDist(self, o0) >= 0) // wrong side of the portal
  44                 return 2;
  45         // no failure, we simply don't want to teleport yet; TODO in
  46         // this situation we may want to create a temporary clone
  47         // entity of the player to fix graphics glitch
  48
  49         o1 = WarpZone_TransformOrigin(self, o0);
  50         v1 = WarpZone_TransformVelocity(self, v0);
  51         if(player.classname == "player")
  52                 a1 = WarpZone_TransformVAngles(self, player.v_angle);
  53         else
  54                 a1 = WarpZone_TransformAngles(self, a0);
  55
  56         // put him inside solid
  57         tracebox(o1 - player.view_ofs, player.mins, player.maxs, o1 - player.view_ofs, MOVE_NOMONSTERS, player);
  58         if(trace_startsolid)
  59         {
  60                 vector mi, ma;
  61                 mi = player.mins;
  62                 ma = player.maxs;
  63                 setsize(player, mi - player.view_ofs, ma - player.view_ofs);
  64                 setorigin(player, o1);
  65                 if(WarpZoneLib_MoveOutOfSolid(player))
  66                 {
  67                         o1 = player.origin;
  68                         setsize(player, mi, ma);
  69                         setorigin(player, o0);
  70                 }
  71                 else
  72                 {
  73                         print("would have to put player in solid, won't do that\n");
  74                         setsize(player, mi, ma);
  75                         setorigin(player, o0 - player.view_ofs);
  76                         return 0; // cannot fix
  77                 }
  78         }
  79
  80         if(WarpZone_TargetPlaneDist(self, o1) <= 0)
  81         {
  82                 print("inconsistent warp zones or evil roundoff error\n");
  83                 return 0;
  84         }
  85
  86         //print(sprintf("warpzone: %f %f %f -> %f %f %f\n", o0_x, o0_y, o0_z, o1_x, o1_y, o1_z));
  87
  88         //o1 = trace_endpos;
  89         WarpZone_TeleportPlayer(self, other, o1 - player.view_ofs, a1, v1);
  90         WarpZone_StoreProjectileData(player);
  91         player.warpzone_teleport_time = time;
  92
  93         return 1;
  94 }
  95
  96 void WarpZone_Touch (void)
  97 {
  98         entity oldself, e;
  99
 100         if(other.classname == "trigger_warpzone")
 101                 return;
 102
 103         // FIXME needs a better check to know what is safe to teleport and what not
 104         if(other.movetype == MOVETYPE_NONE)
 105                 return;
 106
 107         if(WarpZoneLib_ExactTrigger_Touch())
 108                 return;
 109
 110         e = self.enemy;
 111         if(WarpZone_Teleport(other))
 112         {
 113                 if(self.aiment.target)
 114                 {
 115                         oldself = self;
 116                         activator = other;
 117                         self = self.aiment;
 118                         SUB_UseTargets();
 119                         self = oldself;
 120                 }
 121         }
 122         else
 123         {
 124                 dprint("WARPZONE FAIL AHAHAHAHAH))\n");
 125         }
 126 }
 127
 128 float WarpZone_Send(entity to, float sendflags)
 129 {
 130         WriteByte(MSG_ENTITY, ENT_CLIENT_WARPZONE);
 131
 132         // we need THESE to render the warpzone (and cull properly)...
 133         WriteCoord(MSG_ENTITY, self.origin_x);
 134         WriteCoord(MSG_ENTITY, self.origin_y);
 135         WriteCoord(MSG_ENTITY, self.origin_z);
 136
 137         WriteShort(MSG_ENTITY, self.modelindex);
 138         WriteCoord(MSG_ENTITY, self.mins_x);
 139         WriteCoord(MSG_ENTITY, self.mins_y);
 140         WriteCoord(MSG_ENTITY, self.mins_z);
 141         WriteCoord(MSG_ENTITY, self.maxs_x);
 142         WriteCoord(MSG_ENTITY, self.maxs_y);
 143         WriteCoord(MSG_ENTITY, self.maxs_z);
 144
 145         // we need THESE to calculate the proper transform
 146         WriteCoord(MSG_ENTITY, self.warpzone_origin_x);
 147         WriteCoord(MSG_ENTITY, self.warpzone_origin_y);
 148         WriteCoord(MSG_ENTITY, self.warpzone_origin_z);
 149         WriteCoord(MSG_ENTITY, self.warpzone_angles_x);
 150         WriteCoord(MSG_ENTITY, self.warpzone_angles_y);
 151         WriteCoord(MSG_ENTITY, self.warpzone_angles_z);
 152         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_x);
 153         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_y);
 154         WriteCoord(MSG_ENTITY, self.warpzone_targetorigin_z);
 155         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_x);
 156         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_y);
 157         WriteCoord(MSG_ENTITY, self.warpzone_targetangles_z);
 158
 159         return TRUE;
 160 }
 161
 162 void WarpZone_InitStep_SpawnFunc()
 163 {
 164         // warp zone entities must have:
 165         // "killtarget" pointing to a target_position with a direction arrow
 166         //              that points AWAY from the warp zone, and that is inside
 167         //              the warp zone trigger
 168         // "target"     pointing to an identical warp zone at another place in
 169         //              the map, with another killtarget to designate its
 170         //              orientation
 171
 172         string m;
 173         m = self.model;
 174         WarpZoneLib_ExactTrigger_Init();
 175         setmodel(self, m);
 176         self.SendEntity = WarpZone_Send;
 177         self.SendFlags = 0xFFFFFF;
 178         self.effects |= EF_NODEPTHTEST;
 179 }
 180
 181 void WarpZone_InitStep_FindTarget()
 182 {
 183         entity e;
 184
 185         if(self.killtarget == "")
 186         {
 187                 objerror("Warp zone with no killtarget");
 188                 return;
 189         }
 190         self.aiment = find(world, targetname, self.killtarget);
 191         if(self.aiment == world)
 192         {
 193                 objerror("Warp zone with nonexisting killtarget");
 194                 return;
 195         }
 196
 197         // this way only one of the two ents needs to target
 198         if(self.target != "")
 199         {
 200                 e = find(world, targetname, self.target);
 201                 if(e)
 202                 {
 203                         self.enemy = e;
 204                         self.enemy.enemy = self;
 205                 }
 206         }
 207 }
 208
 209 void WarpZone_InitStep_UpdateTransform()
 210 {
 211         if(!self.enemy || self.enemy.enemy != self)
 212         {
 213                 objerror("Invalid warp zone detected. Killed.");
 214                 return;
 215         }
 216
 217         WarpZone_SetUp(self, self.aiment.origin, self.aiment.angles, self.enemy.aiment.origin, self.enemy.aiment.angles);
 218
 219         // now enable touch
 220         self.touch = WarpZone_Touch;
 221
 222         // our mins/maxs are set to the warpzone... so all we need:
 223         self.flags |= FL_CAMERA;
 224         self.view_ofs = self.warpzone_targetorigin;
 225 }
 226
 227 float WarpZone_CheckProjectileImpact()
 228 {
 229         // if self hit a warpzone, abort
 230         vector o0, v0, a0;
 231         float mpd, pd, dpd;
 232         entity wz;
 233         wz = WarpZone_Find(self.origin + self.mins, self.origin + self.maxs);
 234         if(!wz)
 235                 return FALSE;
 236         o0 = self.origin;
 237         v0 = self.velocity;
 238         a0 = self.angles;
 239
 240         // this approach transports the projectile at its full speed, but does
 241         // not properly retain the projectile trail (but we can't retain it
 242         // easily anyway without delaying the projectile by two frames, so who
 243         // cares)
 244         WarpZone_trace_angles = self.angles;
 245         WarpZone_trace_velocity = self.velocity;
 246         WarpZone_TraceBox(self.warpzone_oldorigin, self.mins, self.maxs, self.warpzone_oldorigin + self.warpzone_oldvelocity * frametime, MOVE_NORMAL, self); // this will get us through the warpzone
 247         setorigin(self, trace_endpos);
 248         self.angles = WarpZone_trace_angles;
 249         self.velocity = WarpZone_trace_velocity;
 250
 251         // in case we are in our warp zone post-teleport, shift the projectile forward a bit
 252         mpd = max(vlen(self.mins), vlen(self.maxs));
 253         pd = WarpZone_TargetPlaneDist(wz, self.origin);
 254         if(pd < mpd)
 255         {
 256                 dpd = normalize(self.velocity) * self.warpzone_targetforward;
 257                 setorigin(self, self.origin + normalize(self.velocity) * ((mpd - pd) / dpd));
 258                 if(!WarpZoneLib_MoveOutOfSolid(self))
 259                 {
 260                         setorigin(self, o0);
 261                         self.angles = a0;
 262                         self.velocity = v0;
 263                         return FALSE;
 264                 }
 265         }
 266         WarpZone_StoreProjectileData(self);
 267         self.warpzone_teleport_time = time;
 268
 269         return TRUE;
 270 }
 271 void WarpZone_StartFrame()
 272 {
 273         entity e;
 274         for(e = world; (e = nextent(e)); )
 275                 WarpZone_StoreProjectileData(e);
 276 }
 277 float WarpZone_Projectile_Touch()
 278 {
 279         if(other.classname == "trigger_warpzone")
 280                 return TRUE;
 281         if(WarpZone_Projectile_Touch_ImpactFilter_Callback())
 282                 return TRUE;
 283         if(WarpZone_CheckProjectileImpact())
 284                 return TRUE;
 285         if(self.warpzone_teleport_time == time) // already got teleported this frame? no collision then please
 286         {
 287                 setorigin(self, self.warpzone_oldorigin);
 288                 self.velocity = self.warpzone_oldvelocity;
 289                 self.angles = self.warpzone_oldangles;
 290                 return TRUE;
 291         }
 292
 293         return FALSE;
 294 }