data/qcsrc/server/assault.qc

   1 //=============================================================================
   2
   3 /*QUAKED info_player_attacker (1 0 0) (-16 -16 -24) (16 16 45) INITIAL
   4 Normal attacker spawning location for Nexuiz Asssault
   5 -------- KEYS --------
   6 angle : direction in which player will look when spawning in the game. Does not apply to bots.
   7 target : this should point to a target_objective to decide when this spawning point is active.
   8 nobots : when set to 1, bots will never use this spawn point to respawn in the game.
   9 nohumans : when set to 1, human players will never use this spawn point to respawn in the game.
  10 notfree : when set to 1, entity will not spawn in "Free for all" and "Tournament" modes.
  11 notteam : when set to 1, entity will not spawn in "Teamplay" and "CTF" modes.
  12 notsingle : when set to 1, entity will not spawn in Single Player mode (bot play mode).
  13 -------- SPAWNFLAGS --------
  14 INITIAL : makes the spawnpoint the initial place for the player to spawn at the beginning of the game.*/
  15 void info_player_attacker() {
  16         info_player_deathmatch();
  17         self.team = COLOR_TEAM1; // red, gets swapped every round
  18 }
  19
  20 //=============================================================================
  21
  22 /*QUAKED info_player_defender (0 1 0) (-16 -16 -24) (16 16 45) INITIAL
  23 Normal defender spawning location for Nexuiz Asssault
  24 -------- KEYS --------
  25 angle : direction in which player will look when spawning in the game. Does not apply to bots.
  26 target : this should point to a target_objective to decide when this spawning point is active.
  27 nobots : when set to 1, bots will never use this spawn point to respawn in the game.
  28 nohumans : when set to 1, human players will never use this spawn point to respawn in the game.
  29 notfree : when set to 1, entity will not spawn in "Free for all" and "Tournament" modes.
  30 notteam : when set to 1, entity will not spawn in "Teamplay" and "CTF" modes.
  31 notsingle : when set to 1, entity will not spawn in Single Player mode (bot play mode).
  32 -------- SPAWNFLAGS --------
  33 INITIAL : makes the spawnpoint the initial place for the player to spawn at the beginning of the game.*/
  34 void info_player_defender() {
  35         info_player_deathmatch();
  36         self.team = COLOR_TEAM2; // blue, gets swapped every round
  37 }
  38
  39 // reset this objective. Used when spawning an objective
  40 // and when a new round starts
  41 void assault_objective_reset() {
  42         self.health = ASSAULT_VALUE_INACTIVE;
  43 }
  44
  45 void assault_objective_use() {
  46         // activate objective
  47         self.health = 100;
  48         self.nextthink = time + 0.1;
  49 }
  50
  51 void assault_objective_think() {
  52         local entity oldself;
  53         if(self.health < 0) {
  54                 //self.effects = 0;
  55                 local entity ent;
  56                 ent = find(world, targetname, self.target);
  57                 while(ent) {
  58                         oldself = self;
  59                         self = ent;
  60                         self.use();
  61                         self = oldself;
  62                         ent = find(ent, targetname, self.target);
  63
  64                 }
  65         } else {
  66                 //self.effects = EF_STARDUST;
  67                 self.nextthink = time + 0.1;
  68         }
  69
  70 }
  71 //=============================================================================
  72
  73 /*QUAKED target_objective (0 .5 0) (-8 -8 -8) (8 8 8)
  74 Objective controller for Nexuiz Assault. When active it has 100 health. If it falls below 0 then
  75 it'll trigger the next targeted entity (usually the next objective or target_assault_roundend etc.)
  76 -------- KEYS --------
  77 targetname : point to e.g. next objective*/
  78 void target_objective() {
  79         self.classname = "target_objective";
  80         self.think = assault_objective_think;
  81         self.use = assault_objective_use;
  82         assault_objective_reset();
  83 }
  84
  85 float assault_objective_decrease_customizeforclient() {
  86         if(!self.spawnflags)
  87                 return FALSE;
  88
  89         if(self.cnt == 0) {
  90                 if(other.team == assault_attacker_team)
  91                         if(self.spawnflags == 1)
  92                                 setmodel(self, "models/sprites/push.sp2");
  93                         else
  94                                 setmodel(self, "models/sprites/destroy.sp2");
  95                 else
  96                         setmodel(self, "models/sprites/defend.sp2");
  97         } else {
  98                 return FALSE;
  99         }
 100         return TRUE;
 101 }
 102
 103
 104 void assault_objective_decrease_think() {
 105
 106         local entity objective;
 107         local float found;
 108         found = 0;
 109         objective = find(world, targetname, self.target);
 110         while(objective && found == 0) {
 111                 if(objective.classname == "target_objective") {
 112                         found = 1;
 113                         if(objective.health < ASSAULT_VALUE_INACTIVE) { // targeted objective is active
 114                                 if(self.cnt == 1 && self.max_health >= ASSAULT_VALUE_INACTIVE) {
 115                                         // decrease was fired already, but objective did recover (round reset)
 116                                         self.cnt = 0;
 117                                 }
 118                         } else { // objective isn't active
 119                                 self.cnt = 1;
 120                         }
 121                         self.max_health = objective.health; // save current objective status for next think
 122                 }
 123         }
 124
 125         if(!self.spawnflags) {
 126                 local entity ent;
 127                 ent = find(world, target, self.targetname);
 128                 if(ent) {
 129                         if(ent.classname == "func_assault_destructible")
 130                                 self.spawnflags = 2;
 131                         else
 132                                 self.spawnflags = 1;
 133                 }
 134         }
 135
 136         self.nextthink = time + 0.2;
 137 }
 138
 139
 140 // decrease the health of targeted objectives
 141 void assault_objective_decrease_use() {
 142
 143         if(self.cnt > 0)
 144                 return;
 145
 146         if(activator.team != assault_attacker_team)
 147                 return;
 148
 149         local entity ent;
 150         ent = find(world, targetname, self.target);
 151         while(ent) {
 152                 if(ent.health > 0 && ent.health < ASSAULT_VALUE_INACTIVE)
 153                         ent.health = ent.health - self.dmg;
 154                 ent = find(ent, targetname, self.target);
 155         }
 156
 157         self.cnt = 1;
 158 }
 159
 160 //=============================================================================
 161
 162 /*QUAKED target_objective_decrease (0 .5 0) (-8 -8 -8) (8 8 8)
 163 When triggered decreases health of the targeted target_objective.
 164 -------- KEYS --------
 165 targetname : point to a target_objective entity*/
 166 void target_objective_decrease() {
 167
 168         self.classname = "target_objective_decrease";
 169
 170         precache_model("models/sprites/defend.sp2");
 171         precache_model("models/sprites/destroy.sp2");
 172         precache_model("models/sprites/push.sp2");
 173
 174         if(!self.dmg) {
 175                 self.dmg = 101;
 176         }
 177         self.cnt = 0; // not used yet
 178         self.use = assault_objective_decrease_use;
 179         self.mdl = "models/sprites/here.sp2";
 180         self.effects = EF_NODEPTHTEST;
 181         self.health = ASSAULT_VALUE_INACTIVE;
 182         self.max_health = ASSAULT_VALUE_INACTIVE;
 183         self.think = assault_objective_decrease_think;
 184         self.customizeentityforclient = assault_objective_decrease_customizeforclient;
 185         self.nextthink = time;
 186 }
 187
 188
 189 void assault_destructible_reset() {
 190         self.health = self.max_health;
 191         self.model = self.mdl;
 192         self.solid = SOLID_BSP;
 193         self.colormod = '1 1 1';
 194         self.cnt = 0; // not active
 195         if(self.spawnflags)
 196                 self.use();
 197 }
 198
 199 void assault_destructible_use() {
 200         self.cnt = 1; // mark active
 201         self.takedamage = DAMAGE_YES;
 202 }
 203
 204 void assault_destructible_destroy() {
 205         local entity oldself;
 206
 207         self.model = "";
 208         self.takedamage = DAMAGE_NO;
 209         self.solid = SOLID_NOT;
 210         local entity ent;
 211         ent = find(world, targetname, self.target);
 212         while(ent) {
 213                 oldself = self;
 214                 self = ent;
 215                 self.use();
 216                 self = oldself;
 217                 ent = find(ent, targetname, self.target);
 218         }
 219 }
 220
 221 void assault_destructible_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force) {
 222
 223         if(self.cnt > 0 && assault_attacker_team == attacker.team) {
 224                 self.health = self.health - damage;
 225                 if(self.health / self.max_health < 0.25)
 226                         self.colormod = '1 0 0';
 227                 else if(self.health / self.max_health < 0.375)
 228                         self.colormod = '1 0.25 0';
 229                 else if(self.health / self.max_health < 0.50)
 230                         self.colormod = '1 0.5 0';
 231                 else if(self.health / self.max_health < 0.625)
 232                         self.colormod = '1 0.75 0';
 233                 else if(self.health / self.max_health < 0.75)
 234                         self.colormod = '1 1 0';
 235                 else
 236                         self.colormod = '1 1 1';
 237         }
 238
 239         if(self.health < 0) {
 240                 activator = attacker;
 241                 assault_destructible_destroy();
 242         }
 243 }
 244
 245 // destructible walls that can be used to trigger target_objective_decrease
 246 void func_assault_destructible() {
 247         if(!self.health)
 248                 self.health = 100;
 249
 250         self.max_health = self.health;
 251
 252         self.cnt = 0; // not yet activated
 253
 254         self.classname = "func_assault_destructible";
 255         self.mdl = self.model;
 256         setmodel(self, self.mdl);
 257
 258         self.solid = SOLID_BSP;
 259         self.use = assault_destructible_use;
 260         self.event_damage = assault_destructible_damage;
 261
 262 }
 263
 264 void assault_wall_think() {
 265         local entity ent;
 266         local float notvisible;
 267         notvisible = 0;
 268         ent = find(world, targetname, self.target);
 269         while(ent) {
 270                 if(ent.classname == "target_objective" && ent.health < 0)
 271                         notvisible = 1;
 272                 ent = find(ent, targetname, self.target);
 273         }
 274
 275         if(notvisible) {
 276                 self.model = "";
 277                 self.solid = SOLID_NOT;
 278         } else {
 279                 self.model = self.mdl;
 280                 self.solid = SOLID_BSP;
 281         }
 282
 283         self.nextthink = time + 0.2;
 284 }
 285
 286 void func_assault_wall() {
 287         self.classname = "func_assault_wall";
 288         self.mdl = self.model;
 289         setmodel(self, self.mdl);
 290         self.solid = SOLID_BSP;
 291         self.think = assault_wall_think;
 292         self.nextthink = time;
 293 }
 294
 295
 296 void target_assault_roundend_reset() {
 297         self.cnt = self.cnt + 1; // up round counter
 298         self.winning = 0; // up round
 299 }
 300
 301 void target_assault_roundend_use() {
 302         self.winning = 1; // round has been won by attackers
 303 }
 304
 305 void target_assault_roundend() {
 306         if(!self.health)
 307                 self.health = 300; // 5 minutes
 308
 309         cvar_set("timelimit", ftos(self.health/60));
 310         self.winning = 0; // round not yet won by attackers
 311         self.classname = "target_assault_roundend";
 312         self.use = target_assault_roundend_use;
 313         self.cnt = 0; // first round
 314 }
 315
 316 void assault_roundstart_use() {
 317         local entity ent;
 318         local entity oldself;
 319         ent = find(world, targetname, self.target);
 320         while(ent) {
 321                 oldself = self;
 322                 self = ent;
 323                 self.use();
 324                 self = oldself;
 325                 ent = find(ent, targetname, self.target);
 326         }
 327 }
 328
 329 void target_assault_roundstart() {
 330         assault_attacker_team = COLOR_TEAM1;
 331         self.classname = "target_assault_roundstart";
 332         self.use = assault_roundstart_use;
 333         self.think = assault_roundstart_use;
 334         self.nextthink = time + 0.1;
 335 }
 336
 337 // trigger new round
 338 // reset objectives, toggle spawnpoints, reset triggers, ...
 339 void assault_new_round() {
 340
 341         // up round counter
 342         self.winning = self.winning + 1;
 343         // set end time for next round
 344         self.cnt = time + self.health;
 345
 346         // swap spawn point teams
 347         local entity ent;
 348         local entity oldself;
 349
 350         // reward attackers for winning the round
 351         ent = find(world, classname, "player");
 352         while(ent) {
 353                 if(ent.team == assault_attacker_team) {
 354                         UpdateFrags(ent, 10);
 355                 }
 356                 ent = find(ent, classname, "player");
 357         }
 358
 359         // swap attacker/defender roles
 360         if(assault_attacker_team == COLOR_TEAM1) {
 361                 assault_attacker_team = COLOR_TEAM2;
 362         } else {
 363                 assault_attacker_team = COLOR_TEAM1;
 364         }
 365
 366         ent = find(world, classname, "info_player_deathmatch");
 367         while (ent)
 368         {
 369                 oldself = self;
 370                 self = ent;
 371                 if(self.team == COLOR_TEAM1) {
 372                         self.team = COLOR_TEAM2;
 373                 } else {
 374                         self.team = COLOR_TEAM1;
 375                 }
 376                 self = oldself;
 377
 378                 ent = find(ent, classname, "info_player_deathmatch");
 379         }
 380
 381         // reset all objectives
 382         ent = find(world, classname, "target_objective");
 383         while (ent)
 384         {
 385                 oldself = self;
 386                 self = ent;
 387                 assault_objective_reset();
 388                 self = oldself;
 389
 390                 ent = find(ent, classname, "target_objective");
 391         }
 392
 393         // reset round end triggers
 394         ent = find(world, classname, "target_assault_roundend");
 395         while (ent)
 396         {
 397                 oldself = self;
 398                 self = ent;
 399                 target_assault_roundend_reset();
 400                 self = oldself;
 401
 402                 ent = find(ent, classname, "target_assault_roundend");
 403         }
 404
 405         // reset all target_object_decrease
 406         ent = find(world, classname, "target_objective_decrease");
 407         while (ent)
 408         {
 409                 ent.cnt = 0;
 410                 ent = find(ent, classname, "target_objective_decrease");
 411         }
 412
 413         // reset all func_assault_destructible
 414         ent = find(world, classname, "func_assault_destructible");
 415         while (ent)
 416         {
 417                 oldself = self;
 418                 self = ent;
 419                 assault_destructible_reset();
 420                 self = oldself;
 421                 ent = find(ent, classname, "func_assault_destructible");
 422         }
 423
 424         ent = find(world, classname, "target_assault_roundstart");
 425         while (ent)
 426         {
 427                 oldself = self;
 428                 self = ent;
 429                 self.use();
 430                 self = oldself;
 431                 ent = find(ent, classname, "target_assault_roundstart");
 432         }
 433
 434         // actually restart round... how to do that?
 435         ent = find(world, classname, "player");
 436         while(ent) {
 437                 oldself = self;
 438                 self = ent;
 439                 PutClientInServer();
 440                 self = oldself;
 441                 ent = find(ent, classname, "player");
 442         }
 443
 444
 445 }
 446
 447