TeamNexuiz/game/gamec/t_plats.c

   1 /*void() plat_center_touch;\r
   2 void() plat_outside_touch;\r
   3 void() plat_trigger_use;\r
   4 void() plat_go_up;\r
   5 void() plat_go_down;\r
   6 void() plat_crush;\r
   7 float PLAT_LOW_TRIGGER = 1;\r
   8 \r
   9 void() plat_spawn_inside_trigger =\r
  10 {\r
  11         local entity trigger;\r
  12         local vector tmin, tmax;\r
  13 \r
  14         trigger = spawn();\r
  15         trigger.touch = plat_center_touch;\r
  16         trigger.movetype = MOVETYPE_NONE;\r
  17         trigger.solid = SOLID_TRIGGER;\r
  18         trigger.enemy = self;\r
  19 \r
  20         tmin = self.mins + '25 25 0';\r
  21         tmax = self.maxs - '25 25 -8';\r
  22         tmin_z = tmax_z - (self.pos1_z - self.pos2_z + 8);\r
  23         if (self.spawnflags & PLAT_LOW_TRIGGER)\r
  24                 tmax_z = tmin_z + 8;\r
  25 \r
  26         if (self.size_x <= 50)\r
  27         {\r
  28                 tmin_x = (self.mins_x + self.maxs_x) / 2;\r
  29                 tmax_x = tmin_x + 1;\r
  30         }\r
  31         if (self.size_y <= 50)\r
  32         {\r
  33                 tmin_y = (self.mins_y + self.maxs_y) / 2;\r
  34                 tmax_y = tmin_y + 1;\r
  35         }\r
  36 \r
  37         setsize (trigger, tmin, tmax);\r
  38 };\r
  39 \r
  40 void() plat_hit_top =\r
  41 {\r
  42         sound (self, CHAN_VOICE, self.noise1, 1, ATTN_NORM);\r
  43         self.state = 1;\r
  44         self.think = plat_go_down;\r
  45         self.nextthink = self.ltime + 3;\r
  46 };\r
  47 \r
  48 void() plat_hit_bottom =\r
  49 {\r
  50         sound (self, CHAN_VOICE, self.noise1, 1, ATTN_NORM);\r
  51         self.state = 2;\r
  52 };\r
  53 \r
  54 void() plat_go_down =\r
  55 {\r
  56         sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);\r
  57         self.state = 3;\r
  58         SUB_CalcMove (self.pos2, self.speed, plat_hit_bottom);\r
  59 };\r
  60 \r
  61 void() plat_go_up =\r
  62 {\r
  63         sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);\r
  64         self.state = 4;\r
  65         SUB_CalcMove (self.pos1, self.speed, plat_hit_top);\r
  66 };\r
  67 \r
  68 void() plat_center_touch =\r
  69 {\r
  70         if (other.classname != "player")\r
  71                 return;\r
  72 \r
  73         if (other.health <= 0)\r
  74                 return;\r
  75 \r
  76         self = self.enemy;\r
  77         if (self.state == 2)\r
  78                 plat_go_up ();\r
  79         else if (self.state == 1)\r
  80                 self.nextthink = self.ltime + 1;        // delay going down\r
  81 };\r
  82 \r
  83 void() plat_outside_touch =\r
  84 {\r
  85         if (other.classname != "player")\r
  86                 return;\r
  87 \r
  88         if (other.health <= 0)\r
  89                 return;\r
  90 \r
  91         self = self.enemy;\r
  92         if (self.state == 1)\r
  93                 plat_go_down ();\r
  94 };\r
  95 \r
  96 void() plat_trigger_use =\r
  97 {\r
  98         if (self.think)\r
  99                 return;         // allready activated\r
 100         plat_go_down();\r
 101 };\r
 102 \r
 103 \r
 104 void() plat_crush =\r
 105 {\r
 106         if (self.state == 4)\r
 107                 plat_go_down ();\r
 108         else if (self.state == 3)\r
 109                 plat_go_up ();\r
 110         else\r
 111                 objerror ("plat_crush: bad self.state\n");\r
 112 };\r
 113 \r
 114 void() plat_use =\r
 115 {\r
 116         self.use = SUB_Null;\r
 117         if (self.state != 4)\r
 118                 objerror ("plat_use: not in up state");\r
 119         plat_go_down();\r
 120 };\r
 121 \r
 122 \r
 123 .string sound1, sound2;\r
 124 \r
 125 void() func_plat =\r
 126 {\r
 127         if (!self.t_length)\r
 128                 self.t_length = 80;\r
 129         if (!self.t_width)\r
 130                 self.t_width = 10;\r
 131 \r
 132         if (self.sounds == 0)\r
 133                 self.sounds = 2;\r
 134 \r
 135         if (self.sounds == 1)\r
 136         {\r
 137                 precache_sound ("plats/plat1.wav");\r
 138                 precache_sound ("plats/plat2.wav");\r
 139                 self.noise = "plats/plat1.wav";\r
 140                 self.noise1 = "plats/plat2.wav";\r
 141         }\r
 142 \r
 143         if (self.sounds == 2)\r
 144         {\r
 145                 precache_sound ("plats/medplat1.wav");\r
 146                 precache_sound ("plats/medplat2.wav");\r
 147                 self.noise = "plats/medplat1.wav";\r
 148                 self.noise1 = "plats/medplat2.wav";\r
 149         }\r
 150 \r
 151         if (self.sound1)\r
 152         {\r
 153                 precache_sound (self.sound1);\r
 154                 self.noise = self.sound1;\r
 155         }\r
 156         if (self.sound2)\r
 157         {\r
 158                 precache_sound (self.sound2);\r
 159                 self.noise1 = self.sound2;\r
 160         }\r
 161 \r
 162         self.mangle = self.angles;\r
 163         self.angles = '0 0 0';\r
 164 \r
 165         self.classname = "plat";\r
 166         self.solid = SOLID_BSP;\r
 167         self.movetype = MOVETYPE_PUSH;\r
 168         setorigin (self, self.origin);\r
 169         setmodel (self, self.model);\r
 170         setsize (self, self.mins , self.maxs);\r
 171 \r
 172         self.blocked = plat_crush;\r
 173         if (!self.speed)\r
 174                 self.speed = 150;\r
 175         self.pos1 = self.origin;\r
 176         self.pos2 = self.origin;\r
 177         self.pos2_z = self.origin_z - self.size_z + 8;\r
 178 \r
 179         self.use = plat_trigger_use;\r
 180 \r
 181         plat_spawn_inside_trigger ();   // the "start moving" trigger\r
 182 \r
 183         if (self.targetname)\r
 184         {\r
 185                 self.state = 4;\r
 186                 self.use = plat_use;\r
 187         }\r
 188         else\r
 189         {\r
 190                 setorigin (self, self.pos2);\r
 191                 self.state = 2;\r
 192         }\r
 193 };\r
 194 \r
 195 \r
 196 /*\r
 197 void() train_next;\r
 198 void() func_train_find;\r
 199 \r
 200 void() train_blocked =\r
 201 {\r
 202         if (time < self.attack_finished)\r
 203                 return;\r
 204         self.attack_finished = time + 0.5;\r
 205 };\r
 206 void() train_use =\r
 207 {\r
 208         if (self.think != func_train_find)\r
 209                 return;\r
 210         train_next();\r
 211 };\r
 212 \r
 213 void() train_wait =\r
 214 {\r
 215         if (self.wait)\r
 216         {\r
 217                 self.nextthink = self.ltime + self.wait;\r
 218                 sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);\r
 219         }\r
 220         else\r
 221                 self.nextthink = self.ltime + 0.1;\r
 222 \r
 223         self.think = train_next;\r
 224 };\r
 225 \r
 226 void() train_next =\r
 227 {\r
 228         local entity targ;\r
 229 \r
 230         targ = find (world, targetname, self.target);\r
 231         self.target = targ.target;\r
 232         if (!self.target)\r
 233                 objerror ("train_next: no next target");\r
 234         if (targ.wait)\r
 235                 self.wait = targ.wait;\r
 236         else\r
 237                 self.wait = 0;\r
 238         sound (self, CHAN_VOICE, self.noise1, 1, ATTN_NORM);\r
 239         SUB_CalcMove (targ.origin - self.mins, self.speed, train_wait);\r
 240 };\r
 241 \r
 242 void() func_train_find =\r
 243 {\r
 244         local entity targ;\r
 245 \r
 246         targ = find (world, targetname, self.target);\r
 247         self.target = targ.target;\r
 248         setorigin (self, targ.origin - self.mins);\r
 249         if (!self.targetname)\r
 250         {       // not triggered, so start immediately\r
 251                 self.nextthink = self.ltime + 0.1;\r
 252                 self.think = train_next;\r
 253         }\r
 254 };\r
 255 \r
 256 \r
 257 void() func_train =\r
 258 {\r
 259         if (!self.speed)\r
 260                 self.speed = 100;\r
 261         if (!self.target)\r
 262                 objerror ("func_train without a target");\r
 263 \r
 264         if (self.sounds == 0)\r
 265         {\r
 266                 self.noise = ("misc/null.wav");\r
 267                 precache_sound ("misc/null.wav");\r
 268                 self.noise1 = ("misc/null.wav");\r
 269                 precache_sound ("misc/null.wav");\r
 270         }\r
 271 \r
 272         if (self.sounds == 1)\r
 273         {\r
 274                 self.noise = ("plats/train2.wav");\r
 275                 precache_sound ("plats/train2.wav");\r
 276                 self.noise1 = ("plats/train1.wav");\r
 277                 precache_sound ("plats/train1.wav");\r
 278         }\r
 279 \r
 280         self.solid = SOLID_BSP;\r
 281         self.movetype = MOVETYPE_PUSH;\r
 282         self.blocked = train_blocked;\r
 283         self.use = train_use;\r
 284         self.classname = "train";\r
 285 \r
 286         setmodel (self, self.model);\r
 287         setsize (self, self.mins , self.maxs);\r
 288         setorigin (self, self.origin);\r
 289         self.nextthink = self.ltime + 0.1;\r
 290         self.think = func_train_find;\r
 291 };\r
 292 */\r
 293 \r
 294 void() train_next;                      // temp\r
 295 /*void() train_wait =\r
 296 {\r
 297         self.think = train_next;\r
 298         self.nextthink = self.ltime + self.wait;\r
 299 };\r
 300 \r
 301 /*void() train_next =\r
 302 {\r
 303         local entity targ;\r
 304         targ = find(world, targetname, self.target);\r
 305         self.target = targ.target;\r
 306         if (!self.target)\r
 307                 objerror("train_next: no next target");\r
 308         self.wait = targ.wait;\r
 309         if (!self.wait)\r
 310                 self.wait = 0.1;\r
 311         if (targ.speed)\r
 312                 SUB_CalcMove(targ.origin - self.mins, targ.speed, train_wait);\r
 313         else\r
 314                 SUB_CalcMove(targ.origin - self.mins, self.speed, train_wait);\r
 315 };*/\r
 316 /*                                              //temp\r
 317 void() func_train_find =\r
 318 {\r
 319         local entity targ;\r
 320         targ = find(world, targetname, self.target);\r
 321         self.target = targ.target;\r
 322         setorigin(self, targ.origin - self.mins);\r
 323         self.nextthink = self.ltime + 1;\r
 324         self.think = train_next;\r
 325 };\r
 326 \r
 327 /*QUAKED func_train (0 .5 .8) ?\r
 328 Ridable platform, targets path_corner path to follow.\r
 329 speed : speed the train moves (can be overridden by each path_corner)\r
 330 target : targetname of first path_corner (starts here)\r
 331 */\r
 332 /*void() func_train =\r
 333 {\r
 334         if (!self.target)\r
 335                 objerror("func_train without a target");\r
 336         if (!self.speed)\r
 337                 self.speed = 100;\r
 338 \r
 339         self.solid = SOLID_BSP;\r
 340         self.movetype = MOVETYPE_PUSH;\r
 341 \r
 342         setmodel(self, self.model);\r
 343         setsize(self, self.mins, self.maxs);\r
 344         setorigin(self, self.origin);\r
 345 \r
 346         // wait for targets to spawn\r
 347         self.nextthink = self.ltime + 0.1;\r
 348         self.think = func_train_find;\r
 349 };\r
 350 \r
 351 /*QUAKED func_rotating (0 .5 .8) ? - - X_AXIS Y_AXIS\r
 352 Brush model that spins in place on one axis (default Z).\r
 353 speed : speed to rotate (in degrees per second)\r
 354 noise : path/name of looping .wav file to play.\r
 355 */\r
 356 void() func_rotating =\r
 357 {\r
 358         if (self.noise)\r
 359         {\r
 360                 precache_sound(self.noise);\r
 361                 ambientsound(self.origin, self.noise, 1, ATTN_IDLE);\r
 362         }\r
 363         if (!self.speed)\r
 364                 self.speed = 100;\r
 365         // FIXME: test if this turns the right way, then remove this comment (negate as needed)\r
 366         if (self.spawnflags & 4) // X (untested)\r
 367                 self.avelocity = '0 0 1' * self.speed;\r
 368         // FIXME: test if this turns the right way, then remove this comment (negate as needed)\r
 369         else if (self.spawnflags & 8) // Y (untested)\r
 370                 self.avelocity = '1 0 0' * self.speed;\r
 371         // FIXME: test if this turns the right way, then remove this comment (negate as needed)\r
 372         else // Z\r
 373                 self.avelocity = '0 1 0' * self.speed;\r
 374 \r
 375         self.solid = SOLID_BSP;\r
 376         self.movetype = MOVETYPE_PUSH;\r
 377 \r
 378         setmodel(self, self.model);\r
 379         setsize(self, self.mins, self.maxs);\r
 380         setorigin(self, self.origin);\r
 381 \r
 382         // wait for targets to spawn\r
 383         self.nextthink = self.ltime + 999999999;\r
 384         self.think = SUB_Null;\r
 385 };\r
 386 \r
 387 .float height;\r
 388 .float phase;\r
 389 void() func_bobbing_controller_think =\r
 390 {\r
 391         local vector v;\r
 392         self.nextthink = time + 0.1;\r
 393         // calculate sinewave using makevectors\r
 394         makevectors((time * self.owner.cnt + self.owner.phase) * '0 1 0');\r
 395         v = self.owner.destvec + self.owner.movedir * v_forward_y;\r
 396         // * 10 so it will arrive in 0.1 sec\r
 397         self.owner.velocity = (v - self.owner.origin) * 10;\r
 398 };\r
 399 \r
 400 /*QUAKED func_bobbing (0 .5 .8) ? X_AXIS Y_AXIS\r
 401 Brush model that moves back and forth on one axis (default Z).\r
 402 speed : how long one cycle takes in seconds (default 4)\r
 403 height : how far the cycle moves (default 32)\r
 404 phase : cycle timing adjustment (0-1 as a fraction of the cycle, default 0)\r
 405 noise : path/name of looping .wav file to play.\r
 406 */\r
 407 void() func_bobbing =\r
 408 {\r
 409         local entity controller;\r
 410         if (self.noise)\r
 411         {\r
 412                 precache_sound(self.noise);\r
 413                 ambientsound(self.origin, self.noise, 1, ATTN_IDLE);\r
 414         }\r
 415         if (!self.speed)\r
 416                 self.speed = 4;\r
 417         if (!self.height)\r
 418                 self.height = 32;\r
 419         // center of bobbing motion\r
 420         self.destvec = self.origin;\r
 421         // time scale to get degrees\r
 422         self.cnt = 360 / self.speed;\r
 423         // how far to bob\r
 424         if (self.spawnflags & 1) // X\r
 425                 self.movedir = '1 0 0' * self.height;\r
 426         else if (self.spawnflags & 2) // Y\r
 427                 self.movedir = '0 1 0' * self.height;\r
 428         else // Z\r
 429                 self.movedir = '0 0 1' * self.height;\r
 430 \r
 431         self.solid = SOLID_BSP;\r
 432         self.movetype = MOVETYPE_PUSH;\r
 433 \r
 434         setmodel(self, self.model);\r
 435         setsize(self, self.mins, self.maxs);\r
 436         setorigin(self, self.origin);\r
 437 \r
 438         // wait for targets to spawn\r
 439         controller = spawn();\r
 440         controller.classname = "func_bobbing_controller";\r
 441         controller.owner = self;\r
 442         controller.nextthink = time + 1;\r
 443         controller.think = func_bobbing_controller_think;\r
 444         self.nextthink = self.ltime + 999999999;\r
 445         self.think = SUB_Null;\r
 446 };\r