qcsrc/gamec/cl_client.c

   1 void info_player_start (void)
   2 {
   3         self.classname = "info_player_deathmatch";
   4 }
   5
   6 void info_player_deathmatch (void)
   7 {
   8 }
   9
  10 /*
  11 =============
  12 SelectSpawnPoint
  13
  14 Finds a point to respawn
  15 =============
  16 */
  17 entity SelectSpawnPoint (void)
  18 {
  19         local entity spot, thing;
  20         local float pcount;
  21
  22         spot = find (world, classname, "testplayerstart");
  23         if (spot)
  24                 return spot;
  25
  26         spot = lastspawn;
  27         while (1)
  28         {
  29                 spot = find(spot, classname, "info_player_deathmatch");
  30                 if (spot != world)
  31                 {
  32                         if (spot == lastspawn)
  33                                 return lastspawn;
  34                         pcount = 0;
  35                         thing = findradius(spot.origin, 70);
  36                         while(thing)
  37                         {
  38                                 if (thing.classname == "player")
  39                                         pcount = pcount + 1;
  40                                 thing = thing.chain;
  41                         }
  42                         if (pcount == 0)
  43                         {
  44                                 lastspawn = spot;
  45                                 return spot;
  46                         }
  47                 }
  48         }
  49
  50         spot = find (world, classname, "info_player_start");
  51         if (!spot)
  52                 error ("PutClientInServer: no info_player_start on level");
  53
  54         return spot;
  55 }
  56
  57
  58 /*
  59 =============
  60 PutClientInServer
  61
  62 Called when a client spawns in the server
  63 =============
  64 */
  65 void PutClientInServer (void)
  66 {
  67         entity  spot;
  68         float mdlrandom;
  69
  70         spot = SelectSpawnPoint ();
  71
  72         self.classname = "player";
  73         self.movetype = MOVETYPE_WALK;
  74         self.solid = SOLID_SLIDEBOX;
  75         self.flags = FL_CLIENT;
  76         self.takedamage = DAMAGE_YES;
  77         self.effects = 0;
  78         self.health = cvar("g_balance_health");
  79         self.damageforcescale = 2;
  80         self.death_time = 0;
  81         self.dead_time = 0;
  82         self.dead_frame = 0;
  83         self.die_frame = 0;
  84         self.alpha = 0;
  85         self.scale = 0;
  86         self.fade_time = 0;
  87         self.pain_frame = 0;
  88         self.pain_finished = 0;
  89         self.strength_finished = 0;
  90         self.invincible_finished = 0;
  91         self.speed_finished = 0;
  92         self.slowmo_finished = 0;
  93         // players have no think function
  94         self.think = nullfunction;
  95         self.nextthink = 0;
  96
  97         self.deadflag = DEAD_NO;
  98
  99         self.angles = spot.angles;
 100         self.fixangle = TRUE; // turn this way immediately
 101         self.velocity = '0 0 0';
 102         self.avelocity = '0 0 0';
 103         self.punchangle = '0 0 0';
 104         self.punchvector = '0 0 0';
 105
 106         self.viewzoom = 0.6;
 107
 108         // Savage: Insufficient check for invalid playermodels
 109         if(strlen(self.playermodel) < 15) self.playermodel = "models/player/marine.zym";
 110
 111         setmodel (self, self.playermodel);
 112         self.skin = stof(self.playerskin);
 113         self.crouch = FALSE;
 114         self.view_ofs = PL_VIEW_OFS;
 115         setsize (self, PL_MIN, PL_MAX);
 116         setorigin (self, spot.origin + '0 0 1' * (1 - self.mins_z - 24));
 117         // don't reset back to last position, even if new position is stuck in solid
 118         self.oldorigin = self.origin;
 119
 120 //      self.items = IT_LASER | IT_UZI| IT_SHOTGUN | IT_GRENADE_LAUNCHER | IT_ELECTRO | IT_CRYLINK | IT_NEX | IT_HAGAR | IT_ROCKET_LAUNCHER;
 121 //      self.weapon = IT_UZI;
 122
 123         if (cvar("g_instagib") == 1)
 124         {
 125                 self.items = IT_NEX;
 126                 self.switchweapon = WEP_NEX;
 127                 self.ammo_shells = 0;
 128                 self.ammo_nails = 0;
 129                 self.ammo_rockets = 0;
 130                 self.ammo_cells = 999;
 131         }
 132         else if (cvar("g_rocketarena") == 1)
 133         {
 134                 self.items = IT_ROCKET_LAUNCHER;
 135                 self.switchweapon = WEP_ROCKET_LAUNCHER;
 136                 self.ammo_shells = 0;
 137                 self.ammo_nails = 0;
 138                 self.ammo_rockets = 999;
 139                 self.ammo_cells = 0;
 140         }
 141         else
 142         {
 143                 self.items = IT_LASER | IT_SHOTGUN;
 144                 self.switchweapon = WEP_SHOTGUN;
 145                 self.ammo_shells = 50;
 146                 self.ammo_nails = 0;
 147                 self.ammo_rockets = 0;
 148                 self.ammo_cells = 0;
 149         }
 150
 151         if (cvar("g_fullbrightplayers") == 1)
 152                 self.effects = EF_FULLBRIGHT;
 153
 154         self.event_damage = PlayerDamage;
 155
 156         self.statdraintime = time + 5;
 157         self.button0 = self.button1 = self.button2 = self.button3 = 0;
 158
 159         /*
 160         W_UpdateWeapon();
 161         W_UpdateAmmo();
 162         */
 163         CL_SpawnWeaponentity();
 164
 165         //stuffcmd(self, "chase_active 0");
 166 }
 167
 168 /*
 169 =============
 170 SetNewParms
 171 =============
 172 */
 173 void SetNewParms (void)
 174 {
 175
 176 }
 177
 178 /*
 179 =============
 180 SetChangeParms
 181 =============
 182 */
 183 void SetChangeParms (void)
 184 {
 185
 186 }
 187
 188 /*
 189 =============
 190 ClientKill
 191
 192 Called when a client types 'kill' in the console
 193 =============
 194 */
 195 void ClientKill (void)
 196 {
 197         Damage(self, self, self, 100000, DEATH_KILL, self.origin, '0 0 0');
 198 }
 199
 200 /*
 201 =============
 202 ClientConnect
 203
 204 Called when a client connects to the server
 205 =============
 206 */
 207 void ClientConnect (void)
 208 {
 209         ClientInRankings();
 210         bprint ("^4",self.netname);
 211         bprint (" connected\n");
 212         stuffcmd(self, "exec maps/");
 213         stuffcmd(self, mapname);
 214         stuffcmd(self, ".cfg\n");
 215 }
 216
 217 /*
 218 =============
 219 ClientDisconnect
 220
 221 Called when a client disconnects from the server
 222 =============
 223 */
 224 void ClientDisconnect (void)
 225 {
 226         ClientDisconnected();
 227         bprint ("^4",self.netname);
 228         bprint (" disconnected\n");
 229 }
 230
 231 .entity chatbubbleentity;
 232 .float buttonchat;
 233 void() ChatBubbleThink =
 234 {
 235         self.nextthink = time;
 236         if (!self.owner.modelindex || self.owner.chatbubbleentity != self)
 237         {
 238                 remove(self);
 239                 return;
 240         }
 241         setorigin(self, self.owner.origin + '0 0 15' + self.owner.maxs_z * '0 0 1');
 242         if (self.owner.buttonchat)
 243                 self.effects = 0;
 244         else
 245                 self.effects = EF_NODRAW;
 246 };
 247
 248 void() UpdateChatBubble =
 249 {
 250         if (!self.modelindex)
 251                 return;
 252         // spawn a chatbubble entity if needed
 253         if (!self.chatbubbleentity)
 254         {
 255                 self.chatbubbleentity = spawn();
 256                 self.chatbubbleentity.owner = self;
 257                 self.chatbubbleentity.think = ChatBubbleThink;
 258                 self.chatbubbleentity.nextthink = time;
 259                 setmodel(self.chatbubbleentity, "models/misc/chatbubble.spr");
 260                 setorigin(self.chatbubbleentity, self.origin + '0 0 15' + self.maxs_z * '0 0 1');
 261                 self.chatbubbleentity.effects = EF_NODRAW;
 262         }
 263 }
 264
 265 /*
 266 =============
 267 PlayerJump
 268
 269 When you press the jump key
 270 =============
 271 */
 272 void PlayerJump (void)
 273 {
 274         if (self.waterlevel >= 2)
 275         {
 276                 if (self.watertype == CONTENT_WATER)
 277                         self.velocity_z = 200;
 278                 else if (self.watertype == CONTENT_SLIME)
 279                         self.velocity_z = 80;
 280                 else
 281                         self.velocity_z = 50;
 282
 283                 return;
 284         }
 285
 286
 287         if (!(self.flags & FL_ONGROUND))
 288                 return;
 289
 290         if (!(self.flags & FL_JUMPRELEASED))
 291                 return;
 292
 293         self.velocity_z = self.velocity_z + cvar("g_balance_jumpheight");
 294
 295         self.flags = self.flags - FL_ONGROUND;
 296         self.flags = self.flags - FL_JUMPRELEASED;
 297 }
 298
 299 void() WaterMove =
 300 {
 301         if (self.movetype == MOVETYPE_NOCLIP)
 302                 return;
 303         if (self.health < 0)
 304                 return;
 305
 306         if (self.waterlevel != 3)
 307         {
 308                 self.air_finished = time + 12;
 309                 self.dmg = 2;
 310         }
 311         else if (self.air_finished < time)
 312         {       // drown!
 313                 if (self.pain_finished < time)
 314                 {
 315                         Damage (self, world, world, 5, DEATH_DROWN, '0 0 0', '0 0 0');
 316                         self.pain_finished = time + 0.5;
 317                 }
 318         }
 319
 320         if (!self.waterlevel)
 321         {
 322                 if (self.flags & FL_INWATER)
 323                 {
 324                         // play leave water sound
 325                         self.flags = self.flags - FL_INWATER;
 326                 }
 327                 return;
 328         }
 329
 330         if (self.watertype == CONTENT_LAVA)
 331         {       // do damage
 332                 if (self.dmgtime < time)
 333                 {
 334                         self.dmgtime = time + 0.1;
 335                         Damage (self, world, world, 3 * self.waterlevel, DEATH_LAVA, '0 0 0', '0 0 0');
 336                 }
 337         }
 338         else if (self.watertype == CONTENT_SLIME)
 339         {       // do damage
 340                 if (self.dmgtime < time)
 341                 {
 342                         self.dmgtime = time + 0.1;
 343                         Damage (self, world, world, 1 * self.waterlevel, DEATH_SLIME, '0 0 0', '0 0 0');
 344                 }
 345         }
 346
 347         if ( !(self.flags & FL_INWATER) )
 348         {
 349
 350                 //if (self.watertype == CONTENT_LAVA)
 351                 //      sound (self, CHAN_BODY, "player/inlava.wav", 1, ATTN_NORM);
 352                 //if (self.watertype == CONTENT_WATER)
 353                 //      sound (self, CHAN_BODY, "player/inh2o.wav", 1, ATTN_NORM);
 354                 //if (self.watertype == CONTENT_SLIME)
 355                 //      sound (self, CHAN_BODY, "player/slimbrn2.wav", 1, ATTN_NORM);
 356
 357                 self.flags = self.flags + FL_INWATER;
 358                 self.dmgtime = 0;
 359         }
 360 };
 361
 362 void() CheckWaterJump =
 363 {
 364         local vector start, end;
 365
 366 // check for a jump-out-of-water
 367         makevectors (self.angles);
 368         start = self.origin;
 369         start_z = start_z + 8;
 370         v_forward_z = 0;
 371         normalize(v_forward);
 372         end = start + v_forward*24;
 373         traceline (start, end, TRUE, self);
 374         if (trace_fraction < 1)
 375         {       // solid at waist
 376                 start_z = start_z + self.maxs_z - 8;
 377                 end = start + v_forward*24;
 378                 self.movedir = trace_plane_normal * -50;
 379                 traceline (start, end, TRUE, self);
 380                 if (trace_fraction == 1)
 381                 {       // open at eye level
 382                         self.flags = self.flags | FL_WATERJUMP;
 383                         self.velocity_z = 225;
 384                         self.flags = self.flags - (self.flags & FL_JUMPRELEASED);
 385                         self.teleport_time = time + 2;  // safety net
 386                         return;
 387                 }
 388         }
 389 };
 390
 391
 392 void respawn(void)
 393 {
 394         CopyBody(1);
 395         PutClientInServer();
 396 }
 397
 398 void player_powerups (void)
 399 {
 400         if (self.items & IT_STRENGTH)
 401         {
 402                 self.effects = self.effects | EF_BLUE;
 403                 self.effects = self.effects | EF_ADDITIVE;
 404                 if (time > self.strength_finished)
 405                 {
 406                         self.items = self.items - (self.items & IT_STRENGTH);
 407                         sprint(self, "^3Strength has worn off\n");
 408                 }
 409         }
 410         else
 411         {
 412                 self.effects = self.effects - (self.effects & EF_BLUE);
 413                 self.effects = self.effects - (self.effects & EF_ADDITIVE);
 414                 if (time < self.strength_finished)
 415                 {
 416                         self.items = self.items | IT_STRENGTH;
 417                         sprint(self, "^3Strength infuses your weapons with devestating power\n");
 418                 }
 419         }
 420         if (self.items & IT_INVINCIBLE)
 421         {
 422                 self.effects = self.effects | EF_RED;
 423                 self.effects = self.effects | EF_ADDITIVE;
 424                 if (time > self.invincible_finished)
 425                 {
 426                         self.items = self.items - (self.items & IT_INVINCIBLE);
 427                         sprint(self, "^3Invincible has worn off\n");
 428                 }
 429         }
 430         else
 431         {
 432                 self.effects = self.effects - (self.effects & EF_RED);
 433                 if (time < self.invincible_finished)
 434                 {
 435                         self.items = self.items | IT_INVINCIBLE;
 436                         sprint(self, "^3Invincible shielding surrounds you\n");
 437                 }
 438         }
 439 }
 440
 441 void player_regen (void)
 442 {
 443         if (self.health >= 100 || time > self.pain_finished)
 444                 self.health = bound(0, self.health + (100 - self.health) * cvar("g_balance_healthregen") * frametime, 1000);
 445         if (self.armorvalue > 100)
 446                 self.armorvalue = bound(100, self.armorvalue + (100 - self.armorvalue) * cvar("g_balance_armorrott") * frametime, 1000);
 447 }
 448
 449 /*
 450 =============
 451 PlayerPreThink
 452
 453 Called every frame for each client before the physics are run
 454 =============
 455 */
 456 .float attack_finished;
 457 void PlayerPreThink (void)
 458 {
 459         local vector m1, m2;
 460
 461         if (BotPreFrame())
 462                 return;
 463
 464         CheckRules();
 465
 466         if (intermission_running)
 467         {
 468                 IntermissionThink ();   // otherwise a button could be missed between
 469                 return;                                 // the think tics
 470         }
 471
 472         if (self.deadflag != DEAD_NO)
 473         {
 474                 player_anim();
 475                 weapon_freeze();
 476                 if (self.deadflag == DEAD_DYING)
 477                 {
 478                         if (time > self.dead_time)
 479                                 self.deadflag = DEAD_DEAD;
 480                 }
 481                 else if (self.deadflag == DEAD_DEAD)
 482                 {
 483                         if (!self.button0 && !self.button2 && !self.button3)
 484                                 self.deadflag = DEAD_RESPAWNABLE;
 485                 }
 486                 else if (self.deadflag == DEAD_RESPAWNABLE)
 487                 {
 488                         if (self.button0 || self.button2 || self.button3  || self.button4)
 489                                 respawn();
 490                 }
 491                 return;
 492         }
 493
 494         if (self.button5)
 495         {
 496                 if (!self.crouch)
 497                 {
 498                         self.crouch = TRUE;
 499                         self.view_ofs = PL_CROUCH_VIEW_OFS;
 500                         setsize (self, PL_CROUCH_MIN, PL_CROUCH_MAX);
 501                 }
 502         }
 503         else
 504         {
 505                 if (self.crouch)
 506                 {
 507                         tracebox(self.origin, PL_MIN, PL_MAX, self.origin, FALSE, self);
 508                         if (!trace_startsolid)
 509                         {
 510                                 self.crouch = FALSE;
 511                                 self.view_ofs = PL_VIEW_OFS;
 512                                 setsize (self, PL_MIN, PL_MAX);
 513                         }
 514                 }
 515         }
 516
 517         if (self.playermodel != self.model)
 518         {
 519                 m1 = self.mins;
 520                 m2 = self.maxs;
 521                 setmodel (self, self.playermodel);
 522                 setsize (self, m1, m2);
 523         }
 524
 525         if (self.skin != stof(self.playerskin))
 526                 self.skin = stof(self.playerskin);
 527
 528         W_WeaponFrame();
 529
 530         if (self.button4)
 531         {
 532                 if (self.viewzoom > 0.4)
 533                         self.viewzoom = max (0.4, self.viewzoom - frametime * 2);
 534         }
 535         else if (self.viewzoom < 1.0)
 536                 self.viewzoom = min (1.0, self.viewzoom + frametime);
 537
 538
 539         if (self.button2)
 540                 PlayerJump ();
 541         else
 542                 self.flags = self.flags | FL_JUMPRELEASED;
 543
 544
 545         player_powerups();
 546         player_regen();
 547         player_anim();
 548
 549         self.angles_y=self.v_angle_y + 90;   // temp
 550
 551         WaterMove ();
 552         if (self.waterlevel == 2)
 553                 CheckWaterJump ();
 554
 555         //if (TetrisPreFrame()) return;
 556 }
 557
 558 /*
 559 =============
 560 PlayerPostThink
 561
 562 Called every frame for each client after the physics are run
 563 =============
 564 */
 565 void PlayerPostThink (void)
 566 {
 567         float soundrandom;
 568         if (BotPostFrame())
 569                 return;
 570         CheckRules();
 571         UpdateChatBubble();
 572         if (self.deadflag == DEAD_NO)
 573         if (self.impulse)
 574                 ImpulseCommands ();
 575         if (intermission_running)
 576                 return;         // intermission or finale
 577
 578         // VorteX: landing on floor, landing damage etc.
 579         // LordHavoc: removed 'big fall' death code that VorteX added
 580         if (self.flags & FL_ONGROUND)
 581         {
 582                 if (self.jump_flag < -100 && !self.watertype == CONTENT_WATER) // HitGround
 583                 {
 584                         soundrandom = random() * 4;
 585                         if (soundrandom < 1)
 586                                 sound (self, CHAN_BODY, "misc/hitground1.wav", 1, ATTN_NORM);
 587                         else if (soundrandom < 2)
 588                                 sound (self, CHAN_BODY, "misc/hitground2.wav", 1, ATTN_NORM);
 589                         else if (soundrandom < 3)
 590                                 sound (self, CHAN_BODY, "misc/hitground3.wav", 1, ATTN_NORM);
 591                         else if (soundrandom < 4)
 592                                 sound (self, CHAN_BODY, "misc/hitground4.wav", 1, ATTN_NORM);
 593                         if (self.jump_flag < -650) // landing damage
 594                         {
 595                                 local float dm;
 596                                 dm = bound(0, 0.1*(fabs(self.jump_flag) - 600), 5);
 597                                 Damage (self, world, world, dm, DEATH_FALL, '0 0 0', '0 0 0');
 598                         }
 599                         self.jump_flag = 0;
 600                 }
 601         }
 602         else
 603                 self.jump_flag = self.velocity_z;
 604
 605         //if (TetrisPostFrame()) return;
 606 }