qcsrc/server/mutators/gamemode_keepaway.qc

   1 void ka_SpawnBall(void);
   2 void ka_TouchEvent(void);
   3 void ka_RespawnBall(void);
   4 void ka_DropEvent(entity);
   5 void ka_TimeScoring(void);
   6
   7 entity ka_ball;
   8
   9 float ka_ballcarrier_waypointsprite_visible_for_player(entity);
  10
  11 void ka_Initialize() // run at the start of a match, initiates game mode
  12 {
  13         if(!g_keepaway)
  14                 return;
  15
  16         precache_sound("keepaway/pickedup.wav");
  17         precache_sound("keepaway/dropped.wav");
  18         precache_sound("keepaway/respawn.wav");
  19         precache_sound("keepaway/touch.wav");
  20
  21         ScoreRules_keepaway();
  22         ka_SpawnBall();
  23 }
  24
  25 void ka_Reset() // used to clear the ballcarrier whenever the match switches from warmup to normal
  26 {
  27         if(self.owner)
  28                 if(self.owner.classname == "player")
  29                         ka_DropEvent(self.owner);
  30
  31         ka_RespawnBall();
  32 }
  33
  34 void ka_SpawnBall() // loads various values for the ball, runs only once at start of match
  35 {
  36         if(!g_keepaway) { return; }
  37
  38         entity e;
  39         e = spawn();
  40         e.model = "models/orbs/orbblue.md3";
  41         precache_model(e.model);
  42         setmodel(e, e.model);
  43         setsize(e, '-16 -16 -20', '16 16 20'); // 20 20 20 was too big, player is only 16 16 24... gotta cheat with the Z (20) axis so that the particle isn't cut off
  44         e.classname = "keepawayball";
  45         e.damageforcescale = autocvar_g_keepawayball_damageforcescale;
  46         e.takedamage = DAMAGE_YES;
  47         e.solid = SOLID_TRIGGER;
  48         e.movetype = MOVETYPE_BOUNCE;
  49         e.glow_color = autocvar_g_keepawayball_trail_color;
  50         e.glow_trail = TRUE;
  51         e.flags = FL_ITEM;
  52         e.reset = ka_Reset;
  53         e.touch = ka_TouchEvent;
  54         e.owner = world;
  55         ka_ball = e;
  56
  57         InitializeEntity(e, ka_RespawnBall, INITPRIO_SETLOCATION); // is this the right priority? Neh, I have no idea.. Well-- it works! So.
  58 }
  59
  60 void ka_RespawnBall() // runs whenever the ball needs to be relocated
  61 {
  62         if(gameover) { return; }
  63         vector oldballorigin = self.origin;
  64
  65         if(MoveToRandomMapLocation(self, DPCONTENTS_SOLID | DPCONTENTS_CORPSE | DPCONTENTS_PLAYERCLIP, DPCONTENTS_SLIME | DPCONTENTS_LAVA | DPCONTENTS_SKY | DPCONTENTS_BODY | DPCONTENTS_DONOTENTER, Q3SURFACEFLAG_SKY, 10, 1024, 256))
  66         {
  67                 makevectors(self.angles);
  68                 self.movetype = MOVETYPE_BOUNCE;
  69                 self.velocity = '0 0 200';
  70                 self.angles = '0 0 0';
  71                 self.effects = autocvar_g_keepawayball_effects;
  72                 self.think = ka_RespawnBall;
  73                 self.nextthink = time + autocvar_g_keepawayball_respawntime;
  74
  75                 pointparticles(particleeffectnum("electro_combo"), oldballorigin, '0 0 0', 1);
  76                 pointparticles(particleeffectnum("electro_combo"), self.origin, '0 0 0', 1);
  77
  78                 WaypointSprite_Spawn("ka-ball", 0, 0, self, '0 0 64', world, self.team, self, waypointsprite_attachedforcarrier, FALSE, RADARICON_FLAGCARRIER, '0 1 1');
  79                 WaypointSprite_Ping(self.waypointsprite_attachedforcarrier);
  80
  81                 sound(self, CH_TRIGGER_SINGLE, "keepaway/respawn.wav", VOL_BASE, ATTN_NONE); // ATTN_NONE (it's a sound intended to be heard anywhere)
  82         }
  83         else
  84         {
  85                 ka_RespawnBall(); // finding a location failed, retry
  86         }
  87 }
  88
  89 void ka_TouchEvent() // runs any time that the ball comes in contact with something
  90 {
  91         if(gameover) { return; }
  92         if(!self) { return; }
  93         if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
  94         { // The ball fell off the map, respawn it since players can't get to it
  95                 ka_RespawnBall();
  96                 return;
  97         }
  98         if(other.deadflag != DEAD_NO) { return; }
  99         if(other.classname != "player")
 100         {  // The ball just touched an object, most likely the world
 101                 pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
 102                 sound(self, CH_TRIGGER_SINGLE, "keepaway/touch.wav", VOL_BASE, ATTN_NORM);
 103                 return;
 104         }
 105         else if(self.wait > time) { return; }
 106
 107         // attach the ball to the player
 108         self.owner = other;
 109         other.ballcarried = self;
 110         setattachment(self, other, "");
 111         setorigin(self, '0 0 0');
 112
 113         // make the ball invisible/unable to do anything/set up time scoring
 114         self.velocity = '0 0 0';
 115         self.movetype = MOVETYPE_NONE;
 116         self.effects |= EF_NODRAW;
 117         self.touch = SUB_Null;
 118         self.think = ka_TimeScoring;
 119         self.nextthink = time + autocvar_g_keepaway_score_timeinterval;
 120         self.takedamage = DAMAGE_NO;
 121
 122         // apply effects to player
 123         other.glow_color = autocvar_g_keepawayball_trail_color;
 124         other.glow_trail = TRUE;
 125         other.effects |= autocvar_g_keepaway_ballcarrier_effects;
 126
 127         // messages and sounds
 128         Send_KillNotification(other.netname, "", "", KA_PICKUPBALL, MSG_KA);
 129         WriteByte(MSG_BROADCAST, SVC_CENTERPRINT);
 130         WriteString(MSG_BROADCAST, strcat(other.netname, "^7 has picked up the ball!"));
 131         sound(self.owner, CH_TRIGGER, "keepaway/pickedup.wav", VOL_BASE, ATTN_NONE); // ATTN_NONE (it's a sound intended to be heard anywhere)
 132
 133         // scoring
 134         PlayerScore_Add(other, SP_KEEPAWAY_PICKUPS, 1);
 135
 136         // waypoints
 137         WaypointSprite_AttachCarrier("ka-ballcarrier", other, RADARICON_FLAGCARRIER, '1 0 0');
 138         other.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = ka_ballcarrier_waypointsprite_visible_for_player;
 139         WaypointSprite_UpdateRule(other.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
 140         WaypointSprite_Ping(other.waypointsprite_attachedforcarrier);
 141         WaypointSprite_Kill(self.waypointsprite_attachedforcarrier);
 142 }
 143
 144 void ka_DropEvent(entity plyr) // runs any time that a player is supposed to lose the ball
 145 {
 146         entity ball;
 147         ball = plyr.ballcarried;
 148
 149         if(!ball) { return; }
 150
 151         // reset the ball
 152         setattachment(ball, world, "");
 153         ball.movetype = MOVETYPE_BOUNCE;
 154         ball.wait = time + 1;
 155         ball.touch = ka_TouchEvent;
 156         ball.think = ka_RespawnBall;
 157         ball.nextthink = time + autocvar_g_keepawayball_respawntime;
 158         ball.takedamage = DAMAGE_YES;
 159         ball.effects &~= EF_NODRAW;
 160         setorigin(ball, plyr.origin + '0 0 10');
 161         ball.velocity = '0 0 200' + '0 100 0'*crandom() + '100 0 0'*crandom();
 162         ball.owner.ballcarried = world; // I hope nothing checks to see if the world has the ball in the rest of my code :P
 163         ball.owner = world;
 164
 165         // reset the player effects
 166         plyr.glow_trail = FALSE;
 167         plyr.effects &~= autocvar_g_keepaway_ballcarrier_effects;
 168
 169         // messages and sounds
 170         Send_KillNotification(plyr.netname, "", "", KA_DROPBALL, MSG_KA);
 171         WriteByte(MSG_BROADCAST, SVC_CENTERPRINT);
 172 <<<<<<< HEAD
 173         WriteString(MSG_BROADCAST, strcat("\n\n", plyr.netname, "^7 has dropped the ball!\n"));
 174         sound(plyr, CH_TRIGGER, "keepaway/dropped.wav", VOL_BASE, ATTN_NONE);   // ATTN_NONE (it's a sound intended to be heard anywhere)
 175 =======
 176         WriteString(MSG_BROADCAST, strcat(plyr.netname, "^7 has dropped the ball!"));
 177         sound(other, CHAN_AUTO, "keepaway/dropped.wav", VOL_BASE, ATTN_NONE);   // ATTN_NONE (it's a sound intended to be heard anywhere)
 178 >>>>>>> terencehill/centerprint_stuff
 179
 180         // scoring
 181         // PlayerScore_Add(plyr, SP_KEEPAWAY_DROPS, 1); Not anymore, this is 100% the same as pickups and is useless.
 182
 183         // waypoints
 184         WaypointSprite_Spawn("ka-ball", 0, 0, ball, '0 0 64', world, ball.team, ball, waypointsprite_attachedforcarrier, FALSE, RADARICON_FLAGCARRIER, '0 1 1');
 185         WaypointSprite_UpdateRule(ball.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
 186         WaypointSprite_Ping(ball.waypointsprite_attachedforcarrier);
 187         WaypointSprite_Kill(plyr.waypointsprite_attachedforcarrier);
 188 }
 189
 190 float ka_ballcarrier_waypointsprite_visible_for_player(entity e) // runs on waypoints which are attached to ballcarriers, updates once per frame
 191 {
 192         if(e.ballcarried)
 193                 if(other.classname == "spectator")
 194                         return FALSE; // we don't want spectators of the ballcarrier to see the attached waypoint on the top of their screen
 195
 196         // TODO: Make the ballcarrier lack a waypointsprite whenever they have the invisibility powerup
 197
 198         return TRUE;
 199 }
 200
 201 void ka_TimeScoring()
 202 {
 203         if(self.owner.ballcarried)
 204         { // add points for holding the ball after a certain amount of time
 205                 if(autocvar_g_keepaway_score_timepoints)
 206                         PlayerScore_Add(self.owner, SP_SCORE, autocvar_g_keepaway_score_timepoints);
 207
 208                 PlayerScore_Add(self.owner, SP_KEEPAWAY_BCTIME, (autocvar_g_keepaway_score_timeinterval / 1)); // interval is divided by 1 so that time always shows "seconds"
 209                 self.nextthink = time + autocvar_g_keepaway_score_timeinterval;
 210         }
 211 }
 212
 213 MUTATOR_HOOKFUNCTION(ka_Scoring)
 214 {
 215         if((frag_attacker != frag_target) && (frag_attacker.classname == "player"))
 216         {
 217                 if(frag_target.ballcarried) { // add to amount of times killing carrier
 218                         PlayerScore_Add(frag_attacker, SP_KEEPAWAY_CARRIERKILLS, 1);
 219                         if(autocvar_g_keepaway_score_bckill) // add bckills to the score
 220                                 PlayerScore_Add(frag_attacker, SP_SCORE, autocvar_g_keepaway_score_bckill);
 221                 }
 222                 else if(!frag_attacker.ballcarried)
 223                         if(autocvar_g_keepaway_noncarrier_warn)
 224                                 centerprint(frag_attacker, "Killing people while you don't have the ball gives no points!");
 225
 226                 if(frag_attacker.ballcarried) // add to amount of kills while ballcarrier
 227                         PlayerScore_Add(frag_attacker, SP_SCORE, autocvar_g_keepaway_score_killac);
 228         }
 229
 230         if(self.ballcarried) { ka_DropEvent(self); } // a player with the ball has died, drop it
 231         return 0;
 232 }
 233
 234 MUTATOR_HOOKFUNCTION(ka_GiveFragsForKill)
 235 {
 236         frag_score = 0; // no frags counted in keepaway
 237         return 1; // you deceptive little bugger ;3 This needs to be true in order for this function to even count.
 238 }
 239
 240 MUTATOR_HOOKFUNCTION(ka_PlayerPreThink)
 241 {
 242         // clear the item used for the ball in keepaway
 243         self.items &~= IT_KEY1;
 244
 245         // if the player has the ball, make sure they have the item for it (Used for HUD primarily)
 246         if(self.ballcarried)
 247                 self.items |= IT_KEY1;
 248
 249         return 0;
 250 }
 251
 252 MUTATOR_HOOKFUNCTION(ka_PlayerUseKey)
 253 {
 254         if(MUTATOR_RETURNVALUE == 0)
 255         if(self.ballcarried)
 256         {
 257                 ka_DropEvent(self);
 258                 return 1;
 259         }
 260         return 0;
 261 }
 262
 263 MUTATOR_HOOKFUNCTION(ka_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
 264 {
 265         if(frag_attacker.ballcarried) // if the attacker is a ballcarrier
 266         {
 267                 if(frag_target == frag_attacker) // damage done to yourself
 268                 {
 269                         frag_damage *= autocvar_g_keepaway_ballcarrier_selfdamage;
 270                         frag_force *= autocvar_g_keepaway_ballcarrier_selfforce;
 271                 }
 272                 else // damage done to noncarriers
 273                 {
 274                         frag_damage *= autocvar_g_keepaway_ballcarrier_damage;
 275                         frag_force *= autocvar_g_keepaway_ballcarrier_force;
 276                 }
 277         }
 278         else if not(frag_target.ballcarried) // if the target is a noncarrier
 279         {
 280                 if(frag_target == frag_attacker) // damage done to yourself
 281                 {
 282                         frag_damage *= autocvar_g_keepaway_noncarrier_selfdamage;
 283                         frag_force *= autocvar_g_keepaway_noncarrier_selfforce;
 284                 }
 285                 else // damage done to other noncarriers
 286                 {
 287                         frag_damage *= autocvar_g_keepaway_noncarrier_damage;
 288                         frag_force *= autocvar_g_keepaway_noncarrier_force;
 289                 }
 290         }
 291         return 0;
 292 }
 293
 294 MUTATOR_HOOKFUNCTION(ka_RemovePlayer)
 295 {
 296         if(self.ballcarried) { ka_DropEvent(self); } // a player with the ball has left the match, drop it
 297         return 0;
 298 }
 299
 300 MUTATOR_HOOKFUNCTION(ka_PlayerPowerups)
 301 {
 302         // In the future this hook is supposed to allow me to do some extra stuff with waypointsprites and invisibility powerup
 303         // So bare with me until I can fix a certain bug with ka_ballcarrier_waypointsprite_visible_for_player()
 304
 305         self.effects &~= autocvar_g_keepaway_ballcarrier_effects;
 306
 307         if(self.ballcarried)
 308                 self.effects |= autocvar_g_keepaway_ballcarrier_effects;
 309
 310         return 0;
 311 }
 312
 313 MUTATOR_DEFINITION(gamemode_keepaway)
 314 {
 315         MUTATOR_HOOK(MakePlayerObserver, ka_RemovePlayer, CBC_ORDER_ANY);
 316         MUTATOR_HOOK(ClientDisconnect, ka_RemovePlayer, CBC_ORDER_ANY);
 317         MUTATOR_HOOK(PlayerDies, ka_Scoring, CBC_ORDER_ANY);
 318         MUTATOR_HOOK(GiveFragsForKill, ka_GiveFragsForKill, CBC_ORDER_ANY);
 319         MUTATOR_HOOK(PlayerPreThink, ka_PlayerPreThink, CBC_ORDER_ANY);
 320         MUTATOR_HOOK(PlayerDamage_Calculate, ka_PlayerDamage, CBC_ORDER_ANY);
 321         MUTATOR_HOOK(PlayerPowerups, ka_PlayerPowerups, CBC_ORDER_ANY);
 322         MUTATOR_HOOK(PlayerUseKey, ka_PlayerUseKey, CBC_ORDER_ANY);
 323
 324         MUTATOR_ONADD
 325         {
 326                 if(time > 1) // game loads at time 1
 327                         error("This is a game type and it cannot be added at runtime.");
 328                 g_keepaway = 1;
 329                 ka_Initialize();
 330         }
 331
 332         MUTATOR_ONREMOVE
 333         {
 334                 g_keepaway = 0;
 335                 error("This is a game type and it cannot be removed at runtime.");
 336         }
 337
 338         return 0;
 339 }