qcsrc/common/triggers/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 & 1) && 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 & 4)
  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 & 1)
  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                 WriteAngle(MSG_ENTITY, this.mangle_x);
 168                 WriteAngle(MSG_ENTITY, this.mangle_y);
 169                 WriteAngle(MSG_ENTITY, this.mangle_z);
 170
 171                 WriteShort(MSG_ENTITY, this.speed);
 172                 WriteShort(MSG_ENTITY, this.height);
 173                 WriteByte(MSG_ENTITY, this.lip);
 174                 WriteByte(MSG_ENTITY, this.state);
 175                 WriteByte(MSG_ENTITY, this.wait);
 176
 177                 WriteShort(MSG_ENTITY, this.dmg);
 178                 WriteByte(MSG_ENTITY, this.dmgtime);
 179         }
 180
 181         if(sf & SF_TRIGGER_RESET)
 182         {
 183                 // used on client
 184         }
 185
 186         return true;
 187 }
 188
 189 void train_link(entity this)
 190 {
 191         //Net_LinkEntity(this, 0, false, train_send);
 192 }
 193
 194 void train_use(entity this, entity actor, entity trigger)
 195 {
 196         this.nextthink = this.ltime + 1;
 197         setthink(this, train_next);
 198         this.use = func_null; // not again
 199         if(trigger.target2 && trigger.target2 != "")
 200                 this.future_target = find(NULL, targetname, trigger.target2);
 201 }
 202
 203 void func_train_find(entity this)
 204 {
 205         entity targ = train_next_find(this);
 206         this.target = targ.target;
 207         this.target_random = targ.target_random;
 208         // save the future target for later
 209         this.future_target = train_next_find(targ);
 210         if (this.target == "")
 211                 objerror(this, "func_train_find: no next target");
 212         setorigin(this, targ.origin - this.view_ofs);
 213
 214         if(!(this.spawnflags & 4))
 215         {
 216                 this.nextthink = this.ltime + 1;
 217                 setthink(this, train_next);
 218         }
 219
 220         train_link(this);
 221 }
 222
 223 #endif
 224
 225 /*QUAKED spawnfunc_func_train (0 .5 .8) ?
 226 Ridable platform, targets spawnfunc_path_corner path to follow.
 227 speed : speed the train moves (can be overridden by each spawnfunc_path_corner)
 228 target : targetname of first spawnfunc_path_corner (starts here)
 229 */
 230 #ifdef SVQC
 231 spawnfunc(func_train)
 232 {
 233         if (this.noise != "")
 234                 precache_sound(this.noise);
 235
 236         if (this.target == "")
 237                 objerror(this, "func_train without a target");
 238         if (!this.speed)
 239                 this.speed = 100;
 240
 241         if (!InitMovingBrushTrigger(this))
 242                 return;
 243         this.effects |= EF_LOWPRECISION;
 244
 245         if(this.spawnflags & 4)
 246                 this.use = train_use;
 247
 248         if (this.spawnflags & 2)
 249         {
 250                 this.platmovetype_turn = true;
 251                 this.view_ofs = '0 0 0'; // don't offset a rotating train, origin works differently now
 252         }
 253         else
 254                 this.view_ofs = this.mins;
 255
 256         // wait for targets to spawn
 257         InitializeEntity(this, func_train_find, INITPRIO_FINDTARGET);
 258
 259         setblocked(this, generic_plat_blocked);
 260         if(this.dmg && (this.message == ""))
 261                 this.message = " was squished";
 262     if(this.dmg && (this.message2 == ""))
 263                 this.message2 = "was squished by";
 264         if(this.dmg && (!this.dmgtime))
 265                 this.dmgtime = 0.25;
 266         this.dmgtime2 = time;
 267
 268         if(!set_platmovetype(this, this.platmovetype))
 269                 return;
 270         this.platmovetype_start_default = this.platmovetype_start;
 271         this.platmovetype_end_default = this.platmovetype_end;
 272
 273         // TODO make a reset function for this one
 274 }
 275 #elif defined(CSQC)
 276 void train_draw(entity this)
 277 {
 278         //Movetype_Physics_NoMatchServer();
 279         Movetype_Physics_MatchServer(this, autocvar_cl_projectiles_sloppy);
 280 }
 281
 282 NET_HANDLE(ENT_CLIENT_TRAIN, bool isnew)
 283 {
 284         float sf = ReadByte();
 285
 286         if(sf & SF_TRIGGER_INIT)
 287         {
 288                 this.platmovetype = strzone(ReadString());
 289                 this.platmovetype_turn = ReadByte();
 290                 this.spawnflags = ReadByte();
 291
 292                 this.model = strzone(ReadString());
 293                 _setmodel(this, this.model);
 294
 295                 trigger_common_read(this, true);
 296
 297                 this.curvetarget = strzone(ReadString());
 298
 299                 this.pos1 = ReadVector();
 300                 this.pos2 = ReadVector();
 301
 302                 this.size = ReadVector();
 303
 304                 this.view_ofs = ReadVector();
 305
 306                 this.mangle_x = ReadAngle();
 307                 this.mangle_y = ReadAngle();
 308                 this.mangle_z = ReadAngle();
 309
 310                 this.speed = ReadShort();
 311                 this.height = ReadShort();
 312                 this.lip = ReadByte();
 313                 this.state = ReadByte();
 314                 this.wait = ReadByte();
 315
 316                 this.dmg = ReadShort();
 317                 this.dmgtime = ReadByte();
 318
 319                 this.classname = "func_train";
 320                 this.solid = SOLID_BSP;
 321                 set_movetype(this, MOVETYPE_PUSH);
 322                 this.drawmask = MASK_NORMAL;
 323                 this.draw = train_draw;
 324                 if (isnew) IL_PUSH(g_drawables, this);
 325                 this.entremove = trigger_remove_generic;
 326
 327                 if(set_platmovetype(this, this.platmovetype))
 328                 {
 329                         this.platmovetype_start_default = this.platmovetype_start;
 330                         this.platmovetype_end_default = this.platmovetype_end;
 331                 }
 332
 333                 // everything is set up by the time the train is linked, we shouldn't need this
 334                 //func_train_find();
 335
 336                 // but we will need these
 337                 train_next(this);
 338
 339                 set_movetype(this, MOVETYPE_PUSH);
 340                 this.move_time = time;
 341         }
 342
 343         if(sf & SF_TRIGGER_RESET)
 344         {
 345                 // TODO: make a reset function for trains
 346         }
 347
 348         return true;
 349 }
 350
 351 #endif