qcsrc/common/mapobjects/func/train.qc

   1 #include "train.qh"
   2 .float train_wait_turning;
   3 .entity future_target;
   4 void train_next(entity this);
   5 #ifdef SVQC
   6 void train_use(entity this, entity actor, entity trigger);
   7 #endif
   8 void train_wait(entity this)
   9 {
  10         SUB_UseTargets(this.enemy, NULL, NULL);
  11         this.enemy = NULL;
  12
  13         // if turning is enabled, the train will turn toward the next point while waiting
  14         if(this.platmovetype_turn && !this.train_wait_turning)
  15         {
  16                 entity targ, cp;
  17                 vector ang;
  18                 targ = this.future_target;
  19                 if((this.spawnflags & TRAIN_CURVE) && targ.curvetarget)
  20                         cp = find(NULL, targetname, targ.curvetarget);
  21                 else
  22                         cp = NULL;
  23
  24                 if(cp) // bezier curves movement
  25                         ang = cp.origin - (this.origin - this.view_ofs); // use the origin of the control point of the next path_corner
  26                 else // linear movement
  27                         ang = targ.origin - (this.origin - this.view_ofs); // use the origin of the next path_corner
  28                 ang = vectoangles(ang);
  29                 ang_x = -ang_x; // flip up / down orientation
  30
  31                 if(this.wait > 0) // slow turning
  32                         SUB_CalcAngleMove(this, ang, TSPEED_TIME, this.ltime - time + this.wait, train_wait);
  33                 else // instant turning
  34                         SUB_CalcAngleMove(this, ang, TSPEED_TIME, 0.0000001, train_wait);
  35                 this.train_wait_turning = true;
  36                 return;
  37         }
  38
  39 #ifdef SVQC
  40         if(this.noise != "")
  41                 stopsoundto(MSG_BROADCAST, this, CH_TRIGGER_SINGLE); // send this as unreliable only, as the train will resume operation shortly anyway
  42 #endif
  43
  44 #ifdef SVQC
  45         entity tg = this.future_target;
  46         if(tg.spawnflags & TRAIN_NEEDACTIVATION)
  47         {
  48                 this.use = train_use;
  49                 setthink(this, func_null);
  50                 this.nextthink = 0;
  51         }
  52         else
  53 #endif
  54              if(this.wait < 0 || this.train_wait_turning) // no waiting or we already waited while turning
  55         {
  56                 this.train_wait_turning = false;
  57                 train_next(this);
  58         }
  59         else
  60         {
  61                 setthink(this, train_next);
  62                 this.nextthink = this.ltime + this.wait;
  63         }
  64 }
  65
  66 entity train_next_find(entity this)
  67 {
  68         if(this.target_random)
  69         {
  70                 RandomSelection_Init();
  71                 for(entity t = NULL; (t = find(t, targetname, this.target));)
  72                 {
  73                         RandomSelection_AddEnt(t, 1, 0);
  74                 }
  75                 return RandomSelection_chosen_ent;
  76         }
  77         else
  78         {
  79                 return find(NULL, targetname, this.target);
  80         }
  81 }
  82
  83 void train_next(entity this)
  84 {
  85         entity targ = NULL, cp = NULL;
  86         vector cp_org = '0 0 0';
  87
  88         targ = this.future_target;
  89
  90         this.target = targ.target;
  91         this.target_random = targ.target_random;
  92         this.future_target = train_next_find(targ);
  93
  94         if (this.spawnflags & TRAIN_CURVE)
  95         {
  96                 if(targ.curvetarget)
  97                 {
  98                         cp = find(NULL, targetname, targ.curvetarget); // get its second target (the control point)
  99                         cp_org = cp.origin - this.view_ofs; // no control point found, assume a straight line to the destination
 100                 }
 101         }
 102         if (this.target == "")
 103                 objerror(this, "train_next: no next target");
 104         this.wait = targ.wait;
 105         if (!this.wait)
 106                 this.wait = 0.1;
 107
 108         if(targ.platmovetype)
 109         {
 110                 // this path_corner contains a movetype overrider, apply it
 111                 this.platmovetype_start = targ.platmovetype_start;
 112                 this.platmovetype_end = targ.platmovetype_end;
 113         }
 114         else
 115         {
 116                 // this path_corner doesn't contain a movetype overrider, use the train's defaults
 117                 this.platmovetype_start = this.platmovetype_start_default;
 118                 this.platmovetype_end = this.platmovetype_end_default;
 119         }
 120
 121         if (targ.speed)
 122         {
 123                 if (cp)
 124                         SUB_CalcMove_Bezier(this, cp_org, targ.origin - this.view_ofs, TSPEED_LINEAR, targ.speed, train_wait);
 125                 else
 126                         SUB_CalcMove(this, targ.origin - this.view_ofs, TSPEED_LINEAR, targ.speed, train_wait);
 127         }
 128         else
 129         {
 130                 if (cp)
 131                         SUB_CalcMove_Bezier(this, cp_org, targ.origin - this.view_ofs, TSPEED_LINEAR, this.speed, train_wait);
 132                 else
 133                         SUB_CalcMove(this, targ.origin - this.view_ofs, TSPEED_LINEAR, this.speed, train_wait);
 134         }
 135
 136         if(this.noise != "")
 137                 _sound(this, CH_TRIGGER_SINGLE, this.noise, VOL_BASE, ATTEN_IDLE);
 138 }
 139
 140 REGISTER_NET_LINKED(ENT_CLIENT_TRAIN)
 141
 142 #ifdef SVQC
 143 float train_send(entity this, entity to, float sf)
 144 {
 145         WriteHeader(MSG_ENTITY, ENT_CLIENT_TRAIN);
 146         WriteByte(MSG_ENTITY, sf);
 147
 148         if(sf & SF_TRIGGER_INIT)
 149         {
 150                 WriteString(MSG_ENTITY, this.platmovetype);
 151                 WriteByte(MSG_ENTITY, this.platmovetype_turn);
 152                 WriteByte(MSG_ENTITY, this.spawnflags);
 153
 154                 WriteString(MSG_ENTITY, this.model);
 155
 156                 trigger_common_write(this, true);
 157
 158                 WriteString(MSG_ENTITY, this.curvetarget);
 159
 160                 WriteVector(MSG_ENTITY, this.pos1);
 161                 WriteVector(MSG_ENTITY, this.pos2);
 162
 163                 WriteVector(MSG_ENTITY, this.size);
 164
 165                 WriteVector(MSG_ENTITY, this.view_ofs);
 166
 167                 WriteAngleVector(MSG_ENTITY, this.mangle);
 168
 169                 WriteShort(MSG_ENTITY, this.speed);
 170                 WriteShort(MSG_ENTITY, this.height);
 171                 WriteByte(MSG_ENTITY, this.lip);
 172                 WriteByte(MSG_ENTITY, this.state);
 173                 WriteByte(MSG_ENTITY, this.wait);
 174
 175                 WriteShort(MSG_ENTITY, this.dmg);
 176                 WriteByte(MSG_ENTITY, this.dmgtime);
 177         }
 178
 179         if(sf & SF_TRIGGER_RESET)
 180         {
 181                 // used on client
 182         }
 183
 184         return true;
 185 }
 186
 187 void train_link(entity this)
 188 {
 189         //Net_LinkEntity(this, 0, false, train_send);
 190 }
 191
 192 void train_use(entity this, entity actor, entity trigger)
 193 {
 194         this.nextthink = this.ltime + 1;
 195         setthink(this, train_next);
 196         this.use = func_null; // not again, next target can set it again if needed
 197         if(trigger.target2 && trigger.target2 != "")
 198                 this.future_target = find(NULL, targetname, trigger.target2);
 199 }
 200
 201 void func_train_find(entity this)
 202 {
 203         entity targ = train_next_find(this);
 204         this.target = targ.target;
 205         this.target_random = targ.target_random;
 206         // save the future target for later
 207         this.future_target = train_next_find(targ);
 208         if (this.target == "")
 209                 objerror(this, "func_train_find: no next target");
 210         setorigin(this, targ.origin - this.view_ofs);
 211
 212         if(!(this.spawnflags & TRAIN_NEEDACTIVATION))
 213         {
 214                 this.nextthink = this.ltime + 1;
 215                 setthink(this, train_next);
 216         }
 217
 218         train_link(this);
 219 }
 220
 221 #endif
 222
 223 /*QUAKED spawnfunc_func_train (0 .5 .8) ?
 224 Ridable platform, targets spawnfunc_path_corner path to follow.
 225 speed : speed the train moves (can be overridden by each spawnfunc_path_corner)
 226 target : targetname of first spawnfunc_path_corner (starts here)
 227 */
 228 #ifdef SVQC
 229 spawnfunc(func_train)
 230 {
 231         if (this.noise != "")
 232                 precache_sound(this.noise);
 233
 234         if (this.target == "")
 235                 objerror(this, "func_train without a target");
 236         if (!this.speed)
 237                 this.speed = 100;
 238
 239         if (!InitMovingBrushTrigger(this))
 240                 return;
 241         this.effects |= EF_LOWPRECISION;
 242
 243         if(this.spawnflags & TRAIN_NEEDACTIVATION)
 244                 this.use = train_use;
 245
 246         if (this.spawnflags & TRAIN_TURN)
 247         {
 248                 this.platmovetype_turn = true;
 249                 this.view_ofs = '0 0 0'; // don't offset a rotating train, origin works differently now
 250         }
 251         else
 252                 this.view_ofs = this.mins;
 253
 254         // wait for targets to spawn
 255         InitializeEntity(this, func_train_find, INITPRIO_FINDTARGET);
 256
 257         setblocked(this, generic_plat_blocked);
 258         if(this.dmg && (this.message == ""))
 259                 this.message = " was squished";
 260     if(this.dmg && (this.message2 == ""))
 261                 this.message2 = "was squished by";
 262         if(this.dmg && (!this.dmgtime))
 263                 this.dmgtime = 0.25;
 264         this.dmgtime2 = time;
 265
 266         if(!set_platmovetype(this, this.platmovetype))
 267                 return;
 268         this.platmovetype_start_default = this.platmovetype_start;
 269         this.platmovetype_end_default = this.platmovetype_end;
 270
 271         // TODO make a reset function for this one
 272 }
 273 #elif defined(CSQC)
 274 void train_draw(entity this)
 275 {
 276         //Movetype_Physics_NoMatchServer();
 277         Movetype_Physics_MatchServer(this, autocvar_cl_projectiles_sloppy);
 278 }
 279
 280 NET_HANDLE(ENT_CLIENT_TRAIN, bool isnew)
 281 {
 282         float sf = ReadByte();
 283
 284         if(sf & SF_TRIGGER_INIT)
 285         {
 286                 this.platmovetype = strzone(ReadString());
 287                 this.platmovetype_turn = ReadByte();
 288                 this.spawnflags = ReadByte();
 289
 290                 this.model = strzone(ReadString());
 291                 _setmodel(this, this.model);
 292
 293                 trigger_common_read(this, true);
 294
 295                 this.curvetarget = strzone(ReadString());
 296
 297                 this.pos1 = ReadVector();
 298                 this.pos2 = ReadVector();
 299
 300                 this.size = ReadVector();
 301
 302                 this.view_ofs = ReadVector();
 303
 304                 this.mangle = ReadAngleVector();
 305
 306                 this.speed = ReadShort();
 307                 this.height = ReadShort();
 308                 this.lip = ReadByte();
 309                 this.state = ReadByte();
 310                 this.wait = ReadByte();
 311
 312                 this.dmg = ReadShort();
 313                 this.dmgtime = ReadByte();
 314
 315                 this.classname = "func_train";
 316                 this.solid = SOLID_BSP;
 317                 set_movetype(this, MOVETYPE_PUSH);
 318                 this.drawmask = MASK_NORMAL;
 319                 this.draw = train_draw;
 320                 if (isnew) IL_PUSH(g_drawables, this);
 321                 this.entremove = trigger_remove_generic;
 322
 323                 if(set_platmovetype(this, this.platmovetype))
 324                 {
 325                         this.platmovetype_start_default = this.platmovetype_start;
 326                         this.platmovetype_end_default = this.platmovetype_end;
 327                 }
 328
 329                 // everything is set up by the time the train is linked, we shouldn't need this
 330                 //func_train_find();
 331
 332                 // but we will need these
 333                 train_next(this);
 334
 335                 set_movetype(this, MOVETYPE_PUSH);
 336                 this.move_time = time;
 337         }
 338
 339         if(sf & SF_TRIGGER_RESET)
 340         {
 341                 // TODO: make a reset function for trains
 342         }
 343
 344         return true;
 345 }
 346
 347 #endif