qcsrc/server/mutators/gamemode_keepaway.qc

   1 // ===========================================================
   2 //  Keepaway game mode coding, written by Samual and Diabolik
   3 //  Last updated: September, 2012
   4 // ===========================================================
   5
   6 float ka_ballcarrier_waypointsprite_visible_for_player(entity e) // runs on waypoints which are attached to ballcarriers, updates once per frame
   7 {
   8         if(e.ballcarried)
   9                 if(other.classname == "spectator")
  10                         return FALSE; // we don't want spectators of the ballcarrier to see the attached waypoint on the top of their screen
  11
  12         // TODO: Make the ballcarrier lack a waypointsprite whenever they have the invisibility powerup
  13
  14         return TRUE;
  15 }
  16
  17 void ka_EventLog(string mode, entity actor) // use an alias for easy changing and quick editing later
  18 {
  19         if(autocvar_sv_eventlog)
  20                 GameLogEcho(strcat(":ka:", mode, ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
  21 }
  22
  23 void ka_RespawnBall() // runs whenever the ball needs to be relocated
  24 {
  25         if(gameover) { return; }
  26         vector oldballorigin = self.origin;
  27
  28         if(MoveToRandomMapLocation(self, DPCONTENTS_SOLID | DPCONTENTS_CORPSE | DPCONTENTS_PLAYERCLIP, DPCONTENTS_SLIME | DPCONTENTS_LAVA | DPCONTENTS_SKY | DPCONTENTS_BODY | DPCONTENTS_DONOTENTER, Q3SURFACEFLAG_SKY, 10, 1024, 256))
  29         {
  30                 makevectors(self.angles);
  31                 self.movetype = MOVETYPE_BOUNCE;
  32                 self.velocity = '0 0 200';
  33                 self.angles = '0 0 0';
  34                 self.effects = autocvar_g_keepawayball_effects;
  35                 self.think = ka_RespawnBall;
  36                 self.nextthink = time + autocvar_g_keepawayball_respawntime;
  37
  38                 pointparticles(particleeffectnum("electro_combo"), oldballorigin, '0 0 0', 1);
  39                 pointparticles(particleeffectnum("electro_combo"), self.origin, '0 0 0', 1);
  40
  41                 WaypointSprite_Spawn("ka-ball", 0, 0, self, '0 0 64', world, self.team, self, waypointsprite_attachedforcarrier, FALSE, RADARICON_FLAGCARRIER, '0 1 1');
  42                 WaypointSprite_Ping(self.waypointsprite_attachedforcarrier);
  43
  44                 sound(self, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NONE); // ATTN_NONE (it's a sound intended to be heard anywhere)
  45         }
  46         else
  47         {
  48                 ka_RespawnBall(); // finding a location failed, retry
  49         }
  50 }
  51
  52 void ka_TimeScoring()
  53 {
  54         if(self.owner.ballcarried)
  55         { // add points for holding the ball after a certain amount of time
  56                 if(autocvar_g_keepaway_score_timepoints)
  57                         PlayerScore_Add(self.owner, SP_SCORE, autocvar_g_keepaway_score_timepoints);
  58
  59                 PlayerScore_Add(self.owner, SP_KEEPAWAY_BCTIME, (autocvar_g_keepaway_score_timeinterval / 1)); // interval is divided by 1 so that time always shows "seconds"
  60                 self.nextthink = time + autocvar_g_keepaway_score_timeinterval;
  61         }
  62 }
  63
  64 void ka_TouchEvent() // runs any time that the ball comes in contact with something
  65 {
  66         if(gameover) { return; }
  67         if(!self) { return; }
  68         if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
  69         { // The ball fell off the map, respawn it since players can't get to it
  70                 ka_RespawnBall();
  71                 return;
  72         }
  73         if(other.deadflag != DEAD_NO) { return; }
  74         if(other.classname != "player")
  75         {  // The ball just touched an object, most likely the world
  76                 pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
  77                 sound(self, CH_TRIGGER, "keepaway/touch.wav", VOL_BASE, ATTN_NORM);
  78                 return;
  79         }
  80         else if(self.wait > time) { return; }
  81
  82         // attach the ball to the player
  83         self.owner = other;
  84         other.ballcarried = self;
  85         setattachment(self, other, "");
  86         setorigin(self, '0 0 0');
  87
  88         // make the ball invisible/unable to do anything/set up time scoring
  89         self.velocity = '0 0 0';
  90         self.movetype = MOVETYPE_NONE;
  91         self.effects |= EF_NODRAW;
  92         self.touch = func_null;
  93         self.think = ka_TimeScoring;
  94         self.nextthink = time + autocvar_g_keepaway_score_timeinterval;
  95         self.takedamage = DAMAGE_NO;
  96
  97         // apply effects to player
  98         other.glow_color = autocvar_g_keepawayball_trail_color;
  99         other.glow_trail = TRUE;
 100         other.effects |= autocvar_g_keepaway_ballcarrier_effects;
 101
 102         // messages and sounds
 103         ka_EventLog("pickup", other);
 104         Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_KEEPAWAY_PICKUP, other.netname);
 105         Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_KEEPAWAY_PICKUP, other.netname);
 106         sound(self.owner, CH_TRIGGER, "keepaway/pickedup.wav", VOL_BASE, ATTN_NONE); // ATTN_NONE (it's a sound intended to be heard anywhere)
 107
 108         // scoring
 109         PlayerScore_Add(other, SP_KEEPAWAY_PICKUPS, 1);
 110
 111         // waypoints
 112         WaypointSprite_AttachCarrier("ka-ballcarrier", other, RADARICON_FLAGCARRIER, '1 0 0');
 113         other.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = ka_ballcarrier_waypointsprite_visible_for_player;
 114         WaypointSprite_UpdateRule(other.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
 115         WaypointSprite_Ping(other.waypointsprite_attachedforcarrier);
 116         WaypointSprite_Kill(self.waypointsprite_attachedforcarrier);
 117 }
 118
 119 void ka_DropEvent(entity plyr) // runs any time that a player is supposed to lose the ball
 120 {
 121         entity ball;
 122         ball = plyr.ballcarried;
 123
 124         if(!ball) { return; }
 125
 126         // reset the ball
 127         setattachment(ball, world, "");
 128         ball.movetype = MOVETYPE_BOUNCE;
 129         ball.wait = time + 1;
 130         ball.touch = ka_TouchEvent;
 131         ball.think = ka_RespawnBall;
 132         ball.nextthink = time + autocvar_g_keepawayball_respawntime;
 133         ball.takedamage = DAMAGE_YES;
 134         ball.effects &~= EF_NODRAW;
 135         setorigin(ball, plyr.origin + '0 0 10');
 136         ball.velocity = '0 0 200' + '0 100 0'*crandom() + '100 0 0'*crandom();
 137         ball.owner.ballcarried = world; // I hope nothing checks to see if the world has the ball in the rest of my code :P
 138         ball.owner = world;
 139
 140         // reset the player effects
 141         plyr.glow_trail = FALSE;
 142         plyr.effects &~= autocvar_g_keepaway_ballcarrier_effects;
 143
 144         // messages and sounds
 145         ka_EventLog("dropped", plyr);
 146         Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_KEEPAWAY_DROPPED, plyr.netname);
 147         Send_Notification(NOTIF_ALL, world, MSG_CENTER, CENTER_KEEPAWAY_DROPPED, plyr.netname);
 148         sound(other, CH_TRIGGER, "keepaway/dropped.wav", VOL_BASE, ATTN_NONE);  // ATTN_NONE (it's a sound intended to be heard anywhere)
 149
 150         // scoring
 151         // PlayerScore_Add(plyr, SP_KEEPAWAY_DROPS, 1); Not anymore, this is 100% the same as pickups and is useless.
 152
 153         // waypoints
 154         WaypointSprite_Spawn("ka-ball", 0, 0, ball, '0 0 64', world, ball.team, ball, waypointsprite_attachedforcarrier, FALSE, RADARICON_FLAGCARRIER, '0 1 1');
 155         WaypointSprite_UpdateRule(ball.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
 156         WaypointSprite_Ping(ball.waypointsprite_attachedforcarrier);
 157         WaypointSprite_Kill(plyr.waypointsprite_attachedforcarrier);
 158 }
 159
 160 void ka_Reset() // used to clear the ballcarrier whenever the match switches from warmup to normal
 161 {
 162         if((self.owner) && (self.owner.classname == "player"))
 163                 ka_DropEvent(self.owner);
 164
 165         ka_RespawnBall();
 166 }
 167
 168
 169 // ================
 170 // Bot player logic
 171 // ================
 172
 173 void havocbot_goalrating_ball(float ratingscale, vector org)
 174 {
 175         float t;
 176         entity ball_owner;
 177         ball_owner = ka_ball.owner;
 178
 179         if (ball_owner == self)
 180                 return;
 181
 182         // If ball is carried by player then hunt them down.
 183         if (ball_owner)
 184         {
 185                 t = (self.health + self.armorvalue) / (ball_owner.health + ball_owner.armorvalue);
 186                 navigation_routerating(ball_owner, t * ratingscale, 2000);
 187         }
 188
 189         // Ball has been dropped so collect.
 190         navigation_routerating(ka_ball, ratingscale, 2000);
 191 }
 192
 193 void havocbot_role_ka_carrier()
 194 {
 195         if (self.deadflag != DEAD_NO)
 196                 return;
 197
 198         if (time > self.bot_strategytime)
 199         {
 200                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 201
 202                 navigation_goalrating_start();
 203                 havocbot_goalrating_items(10000, self.origin, 10000);
 204                 havocbot_goalrating_enemyplayers(20000, self.origin, 10000);
 205                 //havocbot_goalrating_waypoints(1, self.origin, 1000);
 206                 navigation_goalrating_end();
 207         }
 208
 209         if (!self.ballcarried)
 210         {
 211                 self.havocbot_role = havocbot_role_ka_collector;
 212                 self.bot_strategytime = 0;
 213         }
 214 }
 215
 216 void havocbot_role_ka_collector()
 217 {
 218         if (self.deadflag != DEAD_NO)
 219                 return;
 220
 221         if (time > self.bot_strategytime)
 222         {
 223                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
 224
 225                 navigation_goalrating_start();
 226                 havocbot_goalrating_items(10000, self.origin, 10000);
 227                 havocbot_goalrating_enemyplayers(1000, self.origin, 10000);
 228                 havocbot_goalrating_ball(20000, self.origin);
 229                 navigation_goalrating_end();
 230         }
 231
 232         if (self.ballcarried)
 233         {
 234                 self.havocbot_role = havocbot_role_ka_carrier;
 235                 self.bot_strategytime = 0;
 236         }
 237 }
 238
 239
 240 // ==============
 241 // Hook Functions
 242 // ==============
 243
 244 MUTATOR_HOOKFUNCTION(ka_Scoring)
 245 {
 246         if((frag_attacker != frag_target) && (frag_attacker.classname == "player"))
 247         {
 248                 if(frag_target.ballcarried) { // add to amount of times killing carrier
 249                         PlayerScore_Add(frag_attacker, SP_KEEPAWAY_CARRIERKILLS, 1);
 250                         if(autocvar_g_keepaway_score_bckill) // add bckills to the score
 251                                 PlayerScore_Add(frag_attacker, SP_SCORE, autocvar_g_keepaway_score_bckill);
 252                 }
 253                 else if(!frag_attacker.ballcarried)
 254                         if(autocvar_g_keepaway_noncarrier_warn)
 255                                 Send_Notification(NOTIF_ONE_ONLY, frag_attacker, MSG_CENTER, CENTER_KEEPAWAY_WARN);
 256
 257                 if(frag_attacker.ballcarried) // add to amount of kills while ballcarrier
 258                         PlayerScore_Add(frag_attacker, SP_SCORE, autocvar_g_keepaway_score_killac);
 259         }
 260
 261         if(self.ballcarried) { ka_DropEvent(self); } // a player with the ball has died, drop it
 262         return 0;
 263 }
 264
 265 MUTATOR_HOOKFUNCTION(ka_GiveFragsForKill)
 266 {
 267         frag_score = 0; // no frags counted in keepaway
 268         return 1; // you deceptive little bugger ;3 This needs to be true in order for this function to even count.
 269 }
 270
 271 MUTATOR_HOOKFUNCTION(ka_PlayerPreThink)
 272 {
 273         // clear the item used for the ball in keepaway
 274         self.items &~= IT_KEY1;
 275
 276         // if the player has the ball, make sure they have the item for it (Used for HUD primarily)
 277         if(self.ballcarried)
 278                 self.items |= IT_KEY1;
 279
 280         return 0;
 281 }
 282
 283 MUTATOR_HOOKFUNCTION(ka_PlayerUseKey)
 284 {
 285         if(MUTATOR_RETURNVALUE == 0)
 286         if(self.ballcarried)
 287         {
 288                 ka_DropEvent(self);
 289                 return 1;
 290         }
 291         return 0;
 292 }
 293
 294 MUTATOR_HOOKFUNCTION(ka_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
 295 {
 296         if(frag_attacker.ballcarried) // if the attacker is a ballcarrier
 297         {
 298                 if(frag_target == frag_attacker) // damage done to yourself
 299                 {
 300                         frag_damage *= autocvar_g_keepaway_ballcarrier_selfdamage;
 301                         frag_force *= autocvar_g_keepaway_ballcarrier_selfforce;
 302                 }
 303                 else // damage done to noncarriers
 304                 {
 305                         frag_damage *= autocvar_g_keepaway_ballcarrier_damage;
 306                         frag_force *= autocvar_g_keepaway_ballcarrier_force;
 307                 }
 308         }
 309         else if not(frag_target.ballcarried) // if the target is a noncarrier
 310         {
 311                 if(frag_target == frag_attacker) // damage done to yourself
 312                 {
 313                         frag_damage *= autocvar_g_keepaway_noncarrier_selfdamage;
 314                         frag_force *= autocvar_g_keepaway_noncarrier_selfforce;
 315                 }
 316                 else // damage done to other noncarriers
 317                 {
 318                         frag_damage *= autocvar_g_keepaway_noncarrier_damage;
 319                         frag_force *= autocvar_g_keepaway_noncarrier_force;
 320                 }
 321         }
 322         return 0;
 323 }
 324
 325 MUTATOR_HOOKFUNCTION(ka_RemovePlayer)
 326 {
 327         if(self.ballcarried) { ka_DropEvent(self); } // a player with the ball has left the match, drop it
 328         return 0;
 329 }
 330
 331 MUTATOR_HOOKFUNCTION(ka_PlayerPowerups)
 332 {
 333         // In the future this hook is supposed to allow me to do some extra stuff with waypointsprites and invisibility powerup
 334         // So bare with me until I can fix a certain bug with ka_ballcarrier_waypointsprite_visible_for_player()
 335
 336         self.effects &~= autocvar_g_keepaway_ballcarrier_effects;
 337
 338         if(self.ballcarried)
 339                 self.effects |= autocvar_g_keepaway_ballcarrier_effects;
 340
 341         return 0;
 342 }
 343
 344 MUTATOR_HOOKFUNCTION(ka_BotRoles)
 345 {
 346         if (self.ballcarried)
 347                 self.havocbot_role = havocbot_role_ka_carrier;
 348         else
 349                 self.havocbot_role = havocbot_role_ka_collector;
 350         return TRUE;
 351 }
 352
 353
 354 // ==============
 355 // Initialization
 356 // ==============
 357
 358 void ka_SpawnBall() // loads various values for the ball, runs only once at start of match
 359 {
 360         if(!g_keepaway) { return; }
 361
 362         entity e;
 363         e = spawn();
 364         e.model = "models/orbs/orbblue.md3";
 365         precache_model(e.model);
 366         setmodel(e, e.model);
 367         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
 368         e.classname = "keepawayball";
 369         e.damageforcescale = autocvar_g_keepawayball_damageforcescale;
 370         e.takedamage = DAMAGE_YES;
 371         e.solid = SOLID_TRIGGER;
 372         e.movetype = MOVETYPE_BOUNCE;
 373         e.glow_color = autocvar_g_keepawayball_trail_color;
 374         e.glow_trail = TRUE;
 375         e.flags = FL_ITEM;
 376         e.reset = ka_Reset;
 377         e.touch = ka_TouchEvent;
 378         e.owner = world;
 379         ka_ball = e;
 380
 381         InitializeEntity(e, ka_RespawnBall, INITPRIO_SETLOCATION); // is this the right priority? Neh, I have no idea.. Well-- it works! So.
 382 }
 383
 384 void ka_ScoreRules()
 385 {
 386         ScoreRules_basics(0, SFL_SORT_PRIO_PRIMARY, 0, TRUE); // SFL_SORT_PRIO_PRIMARY
 387         ScoreInfo_SetLabel_PlayerScore(SP_KEEPAWAY_PICKUPS,                     "pickups",              0);
 388         ScoreInfo_SetLabel_PlayerScore(SP_KEEPAWAY_CARRIERKILLS,        "bckills",              0);
 389         ScoreInfo_SetLabel_PlayerScore(SP_KEEPAWAY_BCTIME,                      "bctime",               SFL_SORT_PRIO_SECONDARY);
 390         ScoreRules_basics_end();
 391 }
 392
 393 void ka_Initialize() // run at the start of a match, initiates game mode
 394 {
 395         if(!g_keepaway)
 396                 return;
 397
 398         precache_sound("keepaway/pickedup.wav");
 399         precache_sound("keepaway/dropped.wav");
 400         precache_sound("keepaway/respawn.wav");
 401         precache_sound("keepaway/touch.wav");
 402
 403         ka_ScoreRules();
 404         ka_SpawnBall();
 405 }
 406
 407
 408 MUTATOR_DEFINITION(gamemode_keepaway)
 409 {
 410         MUTATOR_HOOK(MakePlayerObserver, ka_RemovePlayer, CBC_ORDER_ANY);
 411         MUTATOR_HOOK(ClientDisconnect, ka_RemovePlayer, CBC_ORDER_ANY);
 412         MUTATOR_HOOK(PlayerDies, ka_Scoring, CBC_ORDER_ANY);
 413         MUTATOR_HOOK(GiveFragsForKill, ka_GiveFragsForKill, CBC_ORDER_ANY);
 414         MUTATOR_HOOK(PlayerPreThink, ka_PlayerPreThink, CBC_ORDER_ANY);
 415         MUTATOR_HOOK(PlayerDamage_Calculate, ka_PlayerDamage, CBC_ORDER_ANY);
 416         MUTATOR_HOOK(PlayerPowerups, ka_PlayerPowerups, CBC_ORDER_ANY);
 417         MUTATOR_HOOK(PlayerUseKey, ka_PlayerUseKey, CBC_ORDER_ANY);
 418         MUTATOR_HOOK(HavocBot_ChooseRule, ka_BotRoles, CBC_ORDER_ANY);
 419
 420         MUTATOR_ONADD
 421         {
 422                 if(time > 1) // game loads at time 1
 423                         error("This is a game type and it cannot be added at runtime.");
 424                 ka_Initialize();
 425         }
 426
 427         MUTATOR_ONROLLBACK_OR_REMOVE
 428         {
 429                 // we actually cannot roll back ka_Initialize here
 430                 // BUT: we don't need to! If this gets called, adding always
 431                 // succeeds.
 432         }
 433
 434         MUTATOR_ONREMOVE
 435         {
 436                 print("This is a game type and it cannot be removed at runtime.");
 437                 return -1;
 438         }
 439
 440         return 0;
 441 }