From: Mario Date: Thu, 19 May 2016 21:32:06 +0000 (+1000) Subject: Clean up even more self uses X-Git-Tag: xonotic-v0.8.2~919 X-Git-Url: http://git.xonotic.org/?a=commitdiff_plain;h=304b8158c9b753dd5674d055a1b91bd5472a66b8;p=xonotic%2Fxonotic-data.pk3dir.git Clean up even more self uses --- diff --git a/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc b/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc index b0872497d..dd844e77e 100644 --- a/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc +++ b/qcsrc/common/gamemodes/gamemode/nexball/nexball.qc @@ -125,8 +125,8 @@ void relocate_nexball(entity this) void DropOwner() {SELFPARAM(); entity ownr; - ownr = self.owner; - DropBall(self, ownr.origin, ownr.velocity); + ownr = this.owner; + DropBall(this, ownr.origin, ownr.velocity); makevectors(ownr.v_angle.y * '0 1 0'); ownr.velocity += ('0 0 0.75' - v_forward) * 1000; UNSET_ONGROUND(ownr); @@ -227,56 +227,56 @@ void DropBall(entity ball, vector org, vector vel) void InitBall() {SELFPARAM(); if(gameover) return; - UNSET_ONGROUND(self); - self.movetype = MOVETYPE_BOUNCE; - if(self.classname == "nexball_basketball") - self.touch = basketball_touch; - else if(self.classname == "nexball_football") - self.touch = football_touch; - self.cnt = 0; - self.think = ResetBall; - self.nextthink = time + autocvar_g_nexball_delay_idle + 3; - self.teamtime = 0; - self.pusher = world; - self.team = false; - _sound(self, CH_TRIGGER, self.noise1, VOL_BASE, ATTEN_NORM); - WaypointSprite_Ping(self.waypointsprite_attachedforcarrier); + UNSET_ONGROUND(this); + this.movetype = MOVETYPE_BOUNCE; + if(this.classname == "nexball_basketball") + this.touch = basketball_touch; + else if(this.classname == "nexball_football") + this.touch = football_touch; + this.cnt = 0; + this.think = ResetBall; + this.nextthink = time + autocvar_g_nexball_delay_idle + 3; + this.teamtime = 0; + this.pusher = world; + this.team = false; + _sound(this, CH_TRIGGER, this.noise1, VOL_BASE, ATTEN_NORM); + WaypointSprite_Ping(this.waypointsprite_attachedforcarrier); LogNB("init", world); } void ResetBall() {SELFPARAM(); - if(self.cnt < 2) // step 1 + if(this.cnt < 2) // step 1 { - if(time == self.teamtime) - bprint("The ", Team_ColoredFullName(self.team), " held the ball for too long.\n"); + if(time == this.teamtime) + bprint("The ", Team_ColoredFullName(this.team), " held the ball for too long.\n"); - self.touch = func_null; - self.movetype = MOVETYPE_NOCLIP; - self.velocity = '0 0 0'; // just in case? - if(!self.cnt) + this.touch = func_null; + this.movetype = MOVETYPE_NOCLIP; + this.velocity = '0 0 0'; // just in case? + if(!this.cnt) LogNB("resetidle", world); - self.cnt = 2; - self.nextthink = time; + this.cnt = 2; + this.nextthink = time; } - else if(self.cnt < 4) // step 2 and 3 + else if(this.cnt < 4) // step 2 and 3 { -// dprint("Step ", ftos(self.cnt), ": Calculated velocity: ", vtos(self.spawnorigin - self.origin), ", time: ", ftos(time), "\n"); - self.velocity = (self.spawnorigin - self.origin) * (self.cnt - 1); // 1 or 0.5 second movement - self.nextthink = time + 0.5; - self.cnt += 1; +// dprint("Step ", ftos(this.cnt), ": Calculated velocity: ", vtos(this.spawnorigin - this.origin), ", time: ", ftos(time), "\n"); + this.velocity = (this.spawnorigin - this.origin) * (this.cnt - 1); // 1 or 0.5 second movement + this.nextthink = time + 0.5; + this.cnt += 1; } else // step 4 { // dprint("Step 4: time: ", ftos(time), "\n"); - if(vlen(self.origin - self.spawnorigin) > 10) // should not happen anymore + if(vlen(this.origin - this.spawnorigin) > 10) // should not happen anymore LOG_TRACE("The ball moved too far away from its spawn origin.\nOffset: ", - vtos(self.origin - self.spawnorigin), " Velocity: ", vtos(self.velocity), "\n"); - self.velocity = '0 0 0'; - setorigin(self, self.spawnorigin); // make sure it's positioned correctly anyway - self.movetype = MOVETYPE_NONE; - self.think = InitBall; - self.nextthink = max(time, game_starttime) + autocvar_g_nexball_delay_start; + vtos(this.origin - this.spawnorigin), " Velocity: ", vtos(this.velocity), "\n"); + this.velocity = '0 0 0'; + setorigin(this, this.spawnorigin); // make sure it's positioned correctly anyway + this.movetype = MOVETYPE_NONE; + this.think = InitBall; + this.nextthink = max(time, game_starttime) + autocvar_g_nexball_delay_start; } } @@ -709,16 +709,16 @@ spawnfunc(ball_bound) void W_Nexball_Think() {SELFPARAM(); //dprint("W_Nexball_Think\n"); - //vector new_dir = steerlib_arrive(self.enemy.origin, 2500); - vector new_dir = normalize(self.enemy.origin + '0 0 50' - self.origin); - vector old_dir = normalize(self.velocity); - float _speed = vlen(self.velocity); + //vector new_dir = steerlib_arrive(this.enemy.origin, 2500); + vector new_dir = normalize(this.enemy.origin + '0 0 50' - this.origin); + vector old_dir = normalize(this.velocity); + float _speed = vlen(this.velocity); vector new_vel = normalize(old_dir + (new_dir * autocvar_g_nexball_safepass_turnrate)) * _speed; //vector new_vel = (new_dir * autocvar_g_nexball_safepass_turnrate - self.velocity = new_vel; + this.velocity = new_vel; - self.nextthink = time; + this.nextthink = time; } void W_Nexball_Touch() diff --git a/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc b/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc index 6653f28ad..726dd52d6 100644 --- a/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc +++ b/qcsrc/common/gamemodes/gamemode/onslaught/onslaught.qc @@ -400,31 +400,31 @@ void ons_Link_CheckUpdate() // TODO check if the two sides have moved (currently they won't move anyway) float cc = 0, cc1 = 0, cc2 = 0; - if(self.goalentity.islinked || self.goalentity.iscaptured) { cc1 = (self.goalentity.team - 1) * 0x01; } - if(self.enemy.islinked || self.enemy.iscaptured) { cc2 = (self.enemy.team - 1) * 0x10; } + if(this.goalentity.islinked || this.goalentity.iscaptured) { cc1 = (this.goalentity.team - 1) * 0x01; } + if(this.enemy.islinked || this.enemy.iscaptured) { cc2 = (this.enemy.team - 1) * 0x10; } cc = cc1 + cc2; - if(cc != self.clientcolors) + if(cc != this.clientcolors) { - self.clientcolors = cc; - self.SendFlags |= 4; + this.clientcolors = cc; + this.SendFlags |= 4; } - self.nextthink = time; + this.nextthink = time; } void ons_DelayedLinkSetup(entity this) { - self.goalentity = find(world, targetname, self.target); - self.enemy = find(world, targetname, self.target2); - if(!self.goalentity) { objerror("can not find target\n"); } - if(!self.enemy) { objerror("can not find target2\n"); } + this.goalentity = find(world, targetname, this.target); + this.enemy = find(world, targetname, this.target2); + if(!this.goalentity) { objerror("can not find target\n"); } + if(!this.enemy) { objerror("can not find target2\n"); } - LOG_DEBUG(strcat(etos(self.goalentity), " linked with ", etos(self.enemy), "\n")); - self.SendFlags |= 3; - self.think = ons_Link_CheckUpdate; - self.nextthink = time; + LOG_DEBUG(strcat(etos(this.goalentity), " linked with ", etos(this.enemy), "\n")); + this.SendFlags |= 3; + this.think = ons_Link_CheckUpdate; + this.nextthink = time; } @@ -561,7 +561,7 @@ void ons_ControlPoint_Icon_Damage(entity this, entity inflictor, entity attacker void ons_ControlPoint_Icon_Think() {SELFPARAM(); - self.nextthink = time + ONS_CP_THINKRATE; + this.nextthink = time + ONS_CP_THINKRATE; if(autocvar_g_onslaught_cp_proxydecap) { @@ -569,9 +569,9 @@ void ons_ControlPoint_Icon_Think() int _friendly_count = 0; FOREACH_CLIENT(IS_PLAYER(it) && !IS_DEAD(it), { - if(vdist(it.origin - self.origin, <, autocvar_g_onslaught_cp_proxydecap_distance)) + if(vdist(it.origin - this.origin, <, autocvar_g_onslaught_cp_proxydecap_distance)) { - if(SAME_TEAM(it, self)) + if(SAME_TEAM(it, this)) ++_friendly_count; else ++_enemy_count; @@ -581,49 +581,49 @@ void ons_ControlPoint_Icon_Think() _friendly_count = _friendly_count * (autocvar_g_onslaught_cp_proxydecap_dps * ONS_CP_THINKRATE); _enemy_count = _enemy_count * (autocvar_g_onslaught_cp_proxydecap_dps * ONS_CP_THINKRATE); - self.health = bound(0, self.health + (_friendly_count - _enemy_count), self.max_health); - self.SendFlags |= CPSF_STATUS; - if(self.health <= 0) + this.health = bound(0, this.health + (_friendly_count - _enemy_count), this.max_health); + this.SendFlags |= CPSF_STATUS; + if(this.health <= 0) { - ons_ControlPoint_Icon_Damage(self, self, self, 1, 0, self.origin, '0 0 0'); + ons_ControlPoint_Icon_Damage(this, this, this, 1, 0, this.origin, '0 0 0'); return; } } - if (time > self.pain_finished + 5) + if (time > this.pain_finished + 5) { - if(self.health < self.max_health) + if(this.health < this.max_health) { - self.health = self.health + self.count; - if (self.health >= self.max_health) - self.health = self.max_health; - WaypointSprite_UpdateHealth(self.owner.sprite, self.health); + this.health = this.health + this.count; + if (this.health >= this.max_health) + this.health = this.max_health; + WaypointSprite_UpdateHealth(this.owner.sprite, this.health); } } - if(self.owner.islinked != self.owner.waslinked) + if(this.owner.islinked != this.owner.waslinked) { // unteam the spawnpoint if needed - int t = self.owner.team; - if(!self.owner.islinked) - self.owner.team = 0; + int t = this.owner.team; + if(!this.owner.islinked) + this.owner.team = 0; - SUB_UseTargets(self.owner, self, NULL); + SUB_UseTargets(this.owner, this, NULL); - self.owner.team = t; + this.owner.team = t; - self.owner.waslinked = self.owner.islinked; + this.owner.waslinked = this.owner.islinked; } // damaged fx - if(random() < 0.6 - self.health / self.max_health) + if(random() < 0.6 - this.health / this.max_health) { - Send_Effect(EFFECT_ELECTRIC_SPARKS, self.origin + randompos('-10 -10 -20', '10 10 20'), '0 0 0', 1); + Send_Effect(EFFECT_ELECTRIC_SPARKS, this.origin + randompos('-10 -10 -20', '10 10 20'), '0 0 0', 1); if(random() > 0.8) - sound(self, CH_PAIN, SND_ONS_SPARK1, VOL_BASE, ATTEN_NORM); + sound(this, CH_PAIN, SND_ONS_SPARK1, VOL_BASE, ATTEN_NORM); else if (random() > 0.5) - sound(self, CH_PAIN, SND_ONS_SPARK2, VOL_BASE, ATTEN_NORM); + sound(this, CH_PAIN, SND_ONS_SPARK2, VOL_BASE, ATTEN_NORM); } } @@ -631,54 +631,54 @@ void ons_ControlPoint_Icon_BuildThink() {SELFPARAM(); int a; - self.nextthink = time + ONS_CP_THINKRATE; + this.nextthink = time + ONS_CP_THINKRATE; // only do this if there is power - a = ons_ControlPoint_CanBeLinked(self.owner, self.owner.team); + a = ons_ControlPoint_CanBeLinked(this.owner, this.owner.team); if(!a) return; - self.health = self.health + self.count; + this.health = this.health + this.count; - self.SendFlags |= CPSF_STATUS; + this.SendFlags |= CPSF_STATUS; - if (self.health >= self.max_health) + if (this.health >= this.max_health) { - self.health = self.max_health; - self.count = autocvar_g_onslaught_cp_regen * ONS_CP_THINKRATE; // slow repair rate from now on - self.think = ons_ControlPoint_Icon_Think; - sound(self, CH_TRIGGER, SND_ONS_CONTROLPOINT_BUILT, VOL_BASE, ATTEN_NORM); - self.owner.iscaptured = true; - self.solid = SOLID_BBOX; + this.health = this.max_health; + this.count = autocvar_g_onslaught_cp_regen * ONS_CP_THINKRATE; // slow repair rate from now on + this.think = ons_ControlPoint_Icon_Think; + sound(this, CH_TRIGGER, SND_ONS_CONTROLPOINT_BUILT, VOL_BASE, ATTEN_NORM); + this.owner.iscaptured = true; + this.solid = SOLID_BBOX; - Send_Effect(EFFECT_CAP(self.owner.team), self.owner.origin, '0 0 0', 1); + Send_Effect(EFFECT_CAP(this.owner.team), this.owner.origin, '0 0 0', 1); - WaypointSprite_UpdateMaxHealth(self.owner.sprite, self.max_health); - WaypointSprite_UpdateHealth(self.owner.sprite, self.health); + WaypointSprite_UpdateMaxHealth(this.owner.sprite, this.max_health); + WaypointSprite_UpdateHealth(this.owner.sprite, this.health); - if(IS_PLAYER(self.owner.ons_toucher)) + if(IS_PLAYER(this.owner.ons_toucher)) { - Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ONSLAUGHT_CAPTURE, self.owner.ons_toucher.netname, self.owner.message); - Send_Notification(NOTIF_ALL_EXCEPT, self.owner.ons_toucher, MSG_CENTER, APP_TEAM_NUM(self.owner.ons_toucher.team, CENTER_ONS_CAPTURE), self.owner.message); - Send_Notification(NOTIF_ONE, self.owner.ons_toucher, MSG_CENTER, CENTER_ONS_CAPTURE, self.owner.message); - PlayerScore_Add(self.owner.ons_toucher, SP_ONS_CAPS, 1); - PlayerTeamScore_AddScore(self.owner.ons_toucher, 10); + Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_ONSLAUGHT_CAPTURE, this.owner.ons_toucher.netname, this.owner.message); + Send_Notification(NOTIF_ALL_EXCEPT, this.owner.ons_toucher, MSG_CENTER, APP_TEAM_NUM(this.owner.ons_toucher.team, CENTER_ONS_CAPTURE), this.owner.message); + Send_Notification(NOTIF_ONE, this.owner.ons_toucher, MSG_CENTER, CENTER_ONS_CAPTURE, this.owner.message); + PlayerScore_Add(this.owner.ons_toucher, SP_ONS_CAPS, 1); + PlayerTeamScore_AddScore(this.owner.ons_toucher, 10); } - self.owner.ons_toucher = world; + this.owner.ons_toucher = world; onslaught_updatelinks(); // Use targets now (somebody make sure this is in the right place..) - SUB_UseTargets(self.owner, self, NULL); + SUB_UseTargets(this.owner, this, NULL); - self.SendFlags |= CPSF_SETUP; + this.SendFlags |= CPSF_SETUP; } - if(self.owner.model != MDL_ONS_CP_PAD2.model_str()) - setmodel_fixsize(self.owner, MDL_ONS_CP_PAD2); + if(this.owner.model != MDL_ONS_CP_PAD2.model_str()) + setmodel_fixsize(this.owner, MDL_ONS_CP_PAD2); - if(random() < 0.9 - self.health / self.max_health) - Send_Effect(EFFECT_RAGE, self.origin + 10 * randomvec(), '0 0 -1', 1); + if(random() < 0.9 - this.health / this.max_health) + Send_Effect(EFFECT_RAGE, this.origin + 10 * randomvec(), '0 0 -1', 1); } void onslaught_controlpoint_icon_link(entity e, void() spawnproc); @@ -1027,20 +1027,20 @@ void ons_GeneratorDamage(entity this, entity inflictor, entity attacker, float d void ons_GeneratorThink() {SELFPARAM(); - self.nextthink = time + GEN_THINKRATE; + this.nextthink = time + GEN_THINKRATE; if (!gameover) { - if(!self.isshielded && self.wait < time) + if(!this.isshielded && this.wait < time) { - self.wait = time + 5; + this.wait = time + 5; FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), { - if(SAME_TEAM(it, self)) + if(SAME_TEAM(it, this)) { Send_Notification(NOTIF_ONE, it, MSG_CENTER, CENTER_ONS_NOTSHIELDED_TEAM); soundto(MSG_ONE, it, CHAN_AUTO, SND(KH_ALARM), VOL_BASE, ATTEN_NONE); // FIXME: unique sound? } else - Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_TEAM_NUM(self.team, CENTER_ONS_NOTSHIELDED)); + Send_Notification(NOTIF_ONE, it, MSG_CENTER, APP_TEAM_NUM(this.team, CENTER_ONS_NOTSHIELDED)); }); } } diff --git a/qcsrc/common/minigames/minigame/pong.qc b/qcsrc/common/minigames/minigame/pong.qc index 87c75f48c..5074dccff 100644 --- a/qcsrc/common/minigames/minigame/pong.qc +++ b/qcsrc/common/minigames/minigame/pong.qc @@ -148,53 +148,53 @@ bool pong_goal(entity ball, int pteam) void pong_ball_think() {SELFPARAM(); float think_speed = autocvar_sys_ticrate; - self.nextthink = time + think_speed; + this.nextthink = time + think_speed; - self.origin_x += self.velocity_x * think_speed; - self.origin_y += self.velocity_y * think_speed; - self.SendFlags |= MINIG_SF_UPDATE; + this.origin_x += this.velocity_x * think_speed; + this.origin_y += this.velocity_y * think_speed; + this.SendFlags |= MINIG_SF_UPDATE; int i; for ( i = 1; i <= PONG_MAX_PLAYERS; i++ ) - if ( pong_paddle_hit(self, i) ) + if ( pong_paddle_hit(this, i) ) { - pong_paddle_bounce(self,i); - self.team = i; - self.SendFlags |= PONG_SF_BALLTEAM; + pong_paddle_bounce(this,i); + this.team = i; + this.SendFlags |= PONG_SF_BALLTEAM; return; } - if ( self.origin_y <= self.pong_length ) + if ( this.origin_y <= this.pong_length ) { - if ( !pong_goal(self,3) ) + if ( !pong_goal(this,3) ) { - self.origin_y = self.pong_length; - self.velocity_y *= -1; + this.origin_y = this.pong_length; + this.velocity_y *= -1; } } - else if ( self.origin_y >= 1-self.pong_length ) + else if ( this.origin_y >= 1-this.pong_length ) { - if ( !pong_goal(self,4) ) + if ( !pong_goal(this,4) ) { - self.origin_y = 1-self.pong_length; - self.velocity_y *= -1; + this.origin_y = 1-this.pong_length; + this.velocity_y *= -1; } } - if ( self.origin_x <= self.pong_length ) + if ( this.origin_x <= this.pong_length ) { - if ( !pong_goal(self,2) ) + if ( !pong_goal(this,2) ) { - self.origin_x = self.pong_length; - self.velocity_x *= -1; + this.origin_x = this.pong_length; + this.velocity_x *= -1; } } - else if ( self.origin_x >= 1-self.pong_length ) + else if ( this.origin_x >= 1-this.pong_length ) { - if ( !pong_goal(self,1) ) + if ( !pong_goal(this,1) ) { - self.origin_x = 1-self.pong_length; - self.velocity_x *= -1; + this.origin_x = 1-this.pong_length; + this.velocity_x *= -1; } } @@ -204,18 +204,18 @@ void pong_ball_think() void pong_ai_think() {SELFPARAM(); float think_speed = autocvar_sv_minigames_pong_ai_thinkspeed; - self.nextthink = time + think_speed; + this.nextthink = time + think_speed; float distance; float next_distance; float min_distance = 1; entity ball = world; entity mayball = world; - while ( ( mayball = findentity(mayball,owner,self.owner) ) ) + while ( ( mayball = findentity(mayball,owner,this.owner) ) ) if ( mayball.classname == "pong_ball" ) { - distance = vlen(mayball.origin-self.pong_ai_paddle.origin); - next_distance = vlen(mayball.origin+mayball.velocity-self.pong_ai_paddle.origin); + distance = vlen(mayball.origin-this.pong_ai_paddle.origin); + next_distance = vlen(mayball.origin+mayball.velocity-this.pong_ai_paddle.origin); if ( distance < min_distance && ( distance < 0.5 || next_distance < distance ) ) { min_distance = distance; @@ -224,31 +224,31 @@ void pong_ai_think() } float target = 0.5; - float self_pos; + float my_pos; - if ( self.team <= 2 ) + if ( this.team <= 2 ) { if ( ball ) target = ball.origin_y + ball.velocity_y*think_speed; - self_pos = self.pong_ai_paddle.origin_y; + my_pos = this.pong_ai_paddle.origin_y; } else { if ( ball ) target = ball.origin_x + ball.velocity_x*think_speed; - self_pos = self.pong_ai_paddle.origin_x; + my_pos = this.pong_ai_paddle.origin_x; } - distance = self.pong_length/2 * autocvar_sv_minigames_pong_ai_tolerance + distance = this.pong_length/2 * autocvar_sv_minigames_pong_ai_tolerance + autocvar_sv_minigames_pong_paddle_speed * think_speed; - if (target < self_pos - distance) - self.pong_keys = PONG_KEY_DECREASE; - else if (target > self_pos + distance) - self.pong_keys = PONG_KEY_INCREASE; + if (target < my_pos - distance) + this.pong_keys = PONG_KEY_DECREASE; + else if (target > my_pos + distance) + this.pong_keys = PONG_KEY_INCREASE; else - self.pong_keys = 0; + this.pong_keys = 0; } entity pong_ai_spawn(entity paddle) @@ -269,23 +269,23 @@ entity pong_ai_spawn(entity paddle) void pong_paddle_think() {SELFPARAM(); float think_speed = autocvar_sys_ticrate; - self.nextthink = time + think_speed; + this.nextthink = time + think_speed; - if ( self.realowner.minigame_players.pong_keys == PONG_KEY_INCREASE || - self.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE ) + if ( this.realowner.minigame_players.pong_keys == PONG_KEY_INCREASE || + this.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE ) { float movement = autocvar_sv_minigames_pong_paddle_speed * think_speed; - float halflen = self.pong_length/2; + float halflen = this.pong_length/2; - if ( self.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE ) + if ( this.realowner.minigame_players.pong_keys == PONG_KEY_DECREASE ) movement *= -1; - if ( self.team > 2 ) - self.origin_x = bound(halflen, self.origin_x+movement, 1-halflen); + if ( this.team > 2 ) + this.origin_x = bound(halflen, this.origin_x+movement, 1-halflen); else - self.origin_y = bound(halflen, self.origin_y+movement, 1-halflen); + this.origin_y = bound(halflen, this.origin_y+movement, 1-halflen); - self.SendFlags |= MINIG_SF_UPDATE; + this.SendFlags |= MINIG_SF_UPDATE; } } diff --git a/qcsrc/common/minigames/minigame/snake.qc b/qcsrc/common/minigames/minigame/snake.qc index d367472d8..56efb2e09 100644 --- a/qcsrc/common/minigames/minigame/snake.qc +++ b/qcsrc/common/minigames/minigame/snake.qc @@ -156,14 +156,14 @@ void snake_move_head(entity minigame, entity head); void snake_head_think() { SELFPARAM(); - entity minigame = self.owner; + entity minigame = this.owner; if(minigame.minigame_flags & SNAKE_TURN_MOVE) - snake_move_head(minigame, self); + snake_move_head(minigame, this); snake_check_winner(minigame); - self.nextthink = time + self.snake_delay; + this.nextthink = time + this.snake_delay; } void minigame_setup_snake(entity minigame, int pteam) diff --git a/qcsrc/common/monsters/monster/mage.qc b/qcsrc/common/monsters/monster/mage.qc index 66ea47f25..de7bccb4b 100644 --- a/qcsrc/common/monsters/monster/mage.qc +++ b/qcsrc/common/monsters/monster/mage.qc @@ -173,55 +173,55 @@ void M_Mage_Attack_Spike_Touch() // copied from W_Seeker_Think void M_Mage_Attack_Spike_Think() {SELFPARAM(); - if (time > self.ltime || (self.enemy && self.enemy.health <= 0) || self.owner.health <= 0) { - self.projectiledeathtype |= HITTYPE_SPLASH; - M_Mage_Attack_Spike_Explode(self); + if (time > this.ltime || (this.enemy && this.enemy.health <= 0) || this.owner.health <= 0) { + this.projectiledeathtype |= HITTYPE_SPLASH; + M_Mage_Attack_Spike_Explode(this); } - float spd = vlen(self.velocity); + float spd = vlen(this.velocity); spd = bound( spd - (autocvar_g_monster_mage_attack_spike_decel) * frametime, (autocvar_g_monster_mage_attack_spike_speed_max), spd + (autocvar_g_monster_mage_attack_spike_accel) * frametime ); - if (self.enemy != world) - if (self.enemy.takedamage != DAMAGE_AIM || IS_DEAD(self.enemy)) - self.enemy = world; + if (this.enemy != world) + if (this.enemy.takedamage != DAMAGE_AIM || IS_DEAD(this.enemy)) + this.enemy = world; - if (self.enemy != world) + if (this.enemy != world) { - entity e = self.enemy; + entity e = this.enemy; vector eorg = 0.5 * (e.absmin + e.absmax); float turnrate = (autocvar_g_monster_mage_attack_spike_turnrate); // how fast to turn - vector desireddir = normalize(eorg - self.origin); - vector olddir = normalize(self.velocity); // get my current direction + vector desireddir = normalize(eorg - this.origin); + vector olddir = normalize(this.velocity); // get my current direction // Do evasive maneuvers for world objects? ( this should be a cpu hog. :P ) - if ((autocvar_g_monster_mage_attack_spike_smart) && vdist(eorg - self.origin, >, autocvar_g_monster_mage_attack_spike_smart_mindist)) + if ((autocvar_g_monster_mage_attack_spike_smart) && vdist(eorg - this.origin, >, autocvar_g_monster_mage_attack_spike_smart_mindist)) { - // Is it a better idea (shorter distance) to trace to the target itself? - if ( vlen2(self.origin + olddir * self.wait) < vlen2(eorg - self.origin)) - traceline(self.origin, self.origin + olddir * self.wait, false, self); + // Is it a better idea (shorter distance) to trace to the target itthis? + if ( vlen2(this.origin + olddir * this.wait) < vlen2(eorg - this.origin)) + traceline(this.origin, this.origin + olddir * this.wait, false, this); else - traceline(self.origin, eorg, false, self); + traceline(this.origin, eorg, false, this); // Setup adaptive tracelength - self.wait = bound((autocvar_g_monster_mage_attack_spike_smart_trace_min), vlen(self.origin - trace_endpos), self.wait = (autocvar_g_monster_mage_attack_spike_smart_trace_max)); + this.wait = bound((autocvar_g_monster_mage_attack_spike_smart_trace_min), vlen(this.origin - trace_endpos), this.wait = (autocvar_g_monster_mage_attack_spike_smart_trace_max)); // Calc how important it is that we turn and add this to the desierd (enemy) dir. desireddir = normalize(((trace_plane_normal * (1 - trace_fraction)) + (desireddir * trace_fraction)) * 0.5); } vector newdir = normalize(olddir + desireddir * turnrate); // take the average of the 2 directions; not the best method but simple & easy - self.velocity = newdir * spd; // make me fly in the new direction at my flight speed + this.velocity = newdir * spd; // make me fly in the new direction at my flight speed } /////////////// - //self.angles = vectoangles(self.velocity); // turn model in the new flight direction - self.nextthink = time;// + 0.05; // csqc projectiles - UpdateCSQCProjectile(self); + //this.angles = vectoangles(this.velocity); // turn model in the new flight direction + this.nextthink = time;// + 0.05; // csqc projectiles + UpdateCSQCProjectile(this); } void M_Mage_Attack_Spike(entity this, vector dir) diff --git a/qcsrc/common/monsters/monster/shambler.qc b/qcsrc/common/monsters/monster/shambler.qc index 139967a2c..97e0d49ba 100644 --- a/qcsrc/common/monsters/monster/shambler.qc +++ b/qcsrc/common/monsters/monster/shambler.qc @@ -78,36 +78,36 @@ void M_Shambler_Attack_Swing(entity this) #include -void M_Shambler_Attack_Lightning_Explode() -{SELFPARAM(); +void M_Shambler_Attack_Lightning_Explode(entity this) +{ entity head; - sound(self, CH_SHOTS, SND_ELECTRO_IMPACT, VOL_BASE, ATTEN_NORM); - Send_Effect(EFFECT_ELECTRO_IMPACT, self.origin, '0 0 0', 1); + sound(this, CH_SHOTS, SND_ELECTRO_IMPACT, VOL_BASE, ATTEN_NORM); + Send_Effect(EFFECT_ELECTRO_IMPACT, this.origin, '0 0 0', 1); - self.event_damage = func_null; - self.takedamage = DAMAGE_NO; - self.movetype = MOVETYPE_NONE; - self.velocity = '0 0 0'; + this.event_damage = func_null; + this.takedamage = DAMAGE_NO; + this.movetype = MOVETYPE_NONE; + this.velocity = '0 0 0'; - if(self.movetype == MOVETYPE_NONE) - self.velocity = self.oldvelocity; + if(this.movetype == MOVETYPE_NONE) + this.velocity = this.oldvelocity; - RadiusDamage (self, self.realowner, (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_radius), world, world, (autocvar_g_monster_shambler_attack_lightning_force), self.projectiledeathtype, other); + RadiusDamage (this, this.realowner, (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_damage), (autocvar_g_monster_shambler_attack_lightning_radius), world, world, (autocvar_g_monster_shambler_attack_lightning_force), this.projectiledeathtype, other); - for(head = findradius(self.origin, (autocvar_g_monster_shambler_attack_lightning_radius_zap)); head; head = head.chain) if(head != self.realowner) if(head.takedamage) + for(head = findradius(this.origin, (autocvar_g_monster_shambler_attack_lightning_radius_zap)); head; head = head.chain) if(head != this.realowner) if(head.takedamage) { - te_csqc_lightningarc(self.origin, head.origin); - Damage(head, self, self.realowner, (autocvar_g_monster_shambler_attack_lightning_damage_zap) * MONSTER_SKILLMOD(self), DEATH_MONSTER_SHAMBLER_ZAP.m_id, head.origin, '0 0 0'); + te_csqc_lightningarc(this.origin, head.origin); + Damage(head, this, this.realowner, (autocvar_g_monster_shambler_attack_lightning_damage_zap) * MONSTER_SKILLMOD(this), DEATH_MONSTER_SHAMBLER_ZAP.m_id, head.origin, '0 0 0'); } - self.think = SUB_Remove_self; - self.nextthink = time + 0.2; + this.think = SUB_Remove_self; + this.nextthink = time + 0.2; } void M_Shambler_Attack_Lightning_Explode_use(entity this, entity actor, entity trigger) { - WITHSELF(this, M_Shambler_Attack_Lightning_Explode()); + M_Shambler_Attack_Lightning_Explode(this); } void M_Shambler_Attack_Lightning_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force) @@ -133,11 +133,11 @@ void M_Shambler_Attack_Lightning_Touch() void M_Shambler_Attack_Lightning_Think() {SELFPARAM(); - self.nextthink = time; - if (time > self.cnt) + this.nextthink = time; + if (time > this.cnt) { other = world; - M_Shambler_Attack_Lightning_Explode(); + M_Shambler_Attack_Lightning_Explode(this); return; } } diff --git a/qcsrc/common/monsters/monster/wyvern.qc b/qcsrc/common/monsters/monster/wyvern.qc index 1adf8f84c..3757f7941 100644 --- a/qcsrc/common/monsters/monster/wyvern.qc +++ b/qcsrc/common/monsters/monster/wyvern.qc @@ -102,19 +102,19 @@ const float wyvern_anim_death = 4; void M_Wyvern_Attack_Fireball_Explode() { SELFPARAM(); - Send_Effect(EFFECT_FIREBALL_EXPLODE, self.origin, '0 0 0', 1); + Send_Effect(EFFECT_FIREBALL_EXPLODE, this.origin, '0 0 0', 1); - entity own = self.realowner; + entity own = this.realowner; - RadiusDamage(self, own, autocvar_g_monster_wyvern_attack_fireball_damage, autocvar_g_monster_wyvern_attack_fireball_edgedamage, autocvar_g_monster_wyvern_attack_fireball_force, world, world, autocvar_g_monster_wyvern_attack_fireball_radius, self.projectiledeathtype, world); + RadiusDamage(this, own, autocvar_g_monster_wyvern_attack_fireball_damage, autocvar_g_monster_wyvern_attack_fireball_edgedamage, autocvar_g_monster_wyvern_attack_fireball_force, world, world, autocvar_g_monster_wyvern_attack_fireball_radius, this.projectiledeathtype, world); FOREACH_ENTITY_FLOAT(takedamage, DAMAGE_AIM, { - if(vdist(it.origin - self.origin, <=, autocvar_g_monster_wyvern_attack_fireball_radius)) - Fire_AddDamage(it, own, 5 * MONSTER_SKILLMOD(own), autocvar_g_monster_wyvern_attack_fireball_damagetime, self.projectiledeathtype); + if(vdist(it.origin - this.origin, <=, autocvar_g_monster_wyvern_attack_fireball_radius)) + Fire_AddDamage(it, own, 5 * MONSTER_SKILLMOD(own), autocvar_g_monster_wyvern_attack_fireball_damagetime, this.projectiledeathtype); }); - remove(self); + remove(this); } void M_Wyvern_Attack_Fireball_Touch() diff --git a/qcsrc/common/monsters/sv_monsters.qc b/qcsrc/common/monsters/sv_monsters.qc index def29e969..0179a251b 100644 --- a/qcsrc/common/monsters/sv_monsters.qc +++ b/qcsrc/common/monsters/sv_monsters.qc @@ -212,7 +212,7 @@ void Monster_Delay_Action(entity this) void Monster_Delay_Action_self() { SELFPARAM(); - Monster_Delay_Action(self); + Monster_Delay_Action(this); } void Monster_Delay(entity this, int repeat_count, float defer_amnt, void(entity) func) diff --git a/qcsrc/common/mutators/mutator/buffs/buffs.qc b/qcsrc/common/mutators/mutator/buffs/buffs.qc index 3ab9bc1cd..18841767f 100644 --- a/qcsrc/common/mutators/mutator/buffs/buffs.qc +++ b/qcsrc/common/mutators/mutator/buffs/buffs.qc @@ -175,16 +175,16 @@ void buff_Waypoint_Spawn(entity e) e.buff_waypoint.waypointsprite_visible_for_player = buff_Waypoint_visible_for_player; } -void buff_SetCooldown(float cd) -{SELFPARAM(); +void buff_SetCooldown(entity this, float cd) +{ cd = max(0, cd); - if(!self.buff_waypoint) - buff_Waypoint_Spawn(self); + if(!this.buff_waypoint) + buff_Waypoint_Spawn(this); - WaypointSprite_UpdateBuildFinished(self.buff_waypoint, time + cd); - self.buff_activetime = cd; - self.buff_active = !cd; + WaypointSprite_UpdateBuildFinished(this.buff_waypoint, time + cd); + this.buff_activetime = cd; + this.buff_active = !cd; } void buff_Respawn(entity this) @@ -300,80 +300,80 @@ void buff_NewType(entity ent, float cb) void buff_Think() {SELFPARAM(); - if(self.buffs != self.oldbuffs) + if(this.buffs != this.oldbuffs) { - entity buff = buff_FirstFromFlags(self.buffs); - self.color = buff.m_color; - self.glowmod = buff_GlowColor(buff); - self.skin = buff.m_skin; + entity buff = buff_FirstFromFlags(this.buffs); + this.color = buff.m_color; + this.glowmod = buff_GlowColor(buff); + this.skin = buff.m_skin; - setmodel(self, MDL_BUFF); + setmodel(this, MDL_BUFF); - if(self.buff_waypoint) + if(this.buff_waypoint) { - //WaypointSprite_Disown(self.buff_waypoint, 1); - WaypointSprite_Kill(self.buff_waypoint); - buff_Waypoint_Spawn(self); - if(self.buff_activetime) - WaypointSprite_UpdateBuildFinished(self.buff_waypoint, time + self.buff_activetime - frametime); + //WaypointSprite_Disown(this.buff_waypoint, 1); + WaypointSprite_Kill(this.buff_waypoint); + buff_Waypoint_Spawn(this); + if(this.buff_activetime) + WaypointSprite_UpdateBuildFinished(this.buff_waypoint, time + this.buff_activetime - frametime); } - self.oldbuffs = self.buffs; + this.oldbuffs = this.buffs; } if(!gameover) if((round_handler_IsActive() && !round_handler_IsRoundStarted()) || time >= game_starttime) - if(!self.buff_activetime_updated) + if(!this.buff_activetime_updated) { - buff_SetCooldown(self.buff_activetime); - self.buff_activetime_updated = true; + buff_SetCooldown(this, this.buff_activetime); + this.buff_activetime_updated = true; } - if(!self.buff_active && !self.buff_activetime) - if(!self.owner || STAT(FROZEN, self.owner) || IS_DEAD(self.owner) || !self.owner.iscreature || !(self.owner.buffs & self.buffs)) + if(!this.buff_active && !this.buff_activetime) + if(!this.owner || STAT(FROZEN, this.owner) || IS_DEAD(this.owner) || !this.owner.iscreature || !(this.owner.buffs & this.buffs)) { - buff_SetCooldown(autocvar_g_buffs_cooldown_respawn + frametime); - self.owner = world; + buff_SetCooldown(this, autocvar_g_buffs_cooldown_respawn + frametime); + this.owner = world; if(autocvar_g_buffs_randomize) - buff_NewType(self, self.buffs); + buff_NewType(this, this.buffs); - if(autocvar_g_buffs_random_location || (self.spawnflags & 64)) - buff_Respawn(self); + if(autocvar_g_buffs_random_location || (this.spawnflags & 64)) + buff_Respawn(this); } - if(self.buff_activetime) + if(this.buff_activetime) if(!gameover) if((round_handler_IsActive() && !round_handler_IsRoundStarted()) || time >= game_starttime) { - self.buff_activetime = max(0, self.buff_activetime - frametime); + this.buff_activetime = max(0, this.buff_activetime - frametime); - if(!self.buff_activetime) + if(!this.buff_activetime) { - self.buff_active = true; - sound(self, CH_TRIGGER, SND_STRENGTH_RESPAWN, VOL_BASE, ATTN_NORM); - Send_Effect(EFFECT_ITEM_RESPAWN, CENTER_OR_VIEWOFS(self), '0 0 0', 1); + this.buff_active = true; + sound(this, CH_TRIGGER, SND_STRENGTH_RESPAWN, VOL_BASE, ATTN_NORM); + Send_Effect(EFFECT_ITEM_RESPAWN, CENTER_OR_VIEWOFS(this), '0 0 0', 1); } } - if(self.buff_active) + if(this.buff_active) { - if(self.team && !self.buff_waypoint) - buff_Waypoint_Spawn(self); + if(this.team && !this.buff_waypoint) + buff_Waypoint_Spawn(this); - if(self.lifetime) - if(time >= self.lifetime) - buff_Respawn(self); + if(this.lifetime) + if(time >= this.lifetime) + buff_Respawn(this); } - self.nextthink = time; - //self.angles_y = time * 110.1; + this.nextthink = time; + //this.angles_y = time * 110.1; } -void buff_Waypoint_Reset() -{SELFPARAM(); - WaypointSprite_Kill(self.buff_waypoint); +void buff_Waypoint_Reset(entity this) +{ + WaypointSprite_Kill(this.buff_waypoint); - if(self.buff_activetime) { buff_Waypoint_Spawn(self); } + if(this.buff_activetime) { buff_Waypoint_Spawn(this); } } void buff_Reset(entity this) @@ -381,8 +381,8 @@ void buff_Reset(entity this) if(autocvar_g_buffs_randomize) buff_NewType(this, this.buffs); this.owner = world; - buff_SetCooldown(autocvar_g_buffs_cooldown_activate); - buff_Waypoint_Reset(); + buff_SetCooldown(this, autocvar_g_buffs_cooldown_activate); + buff_Waypoint_Reset(this); this.buff_activetime_updated = false; if(autocvar_g_buffs_random_location || (this.spawnflags & 64)) @@ -392,68 +392,65 @@ void buff_Reset(entity this) float buff_Customize() {SELFPARAM(); entity player = WaypointSprite_getviewentity(other); - if(!self.buff_active || (self.team && DIFF_TEAM(player, self))) + if(!this.buff_active || (this.team && DIFF_TEAM(player, this))) { - self.alpha = 0.3; - if(self.effects & EF_FULLBRIGHT) { self.effects &= ~(EF_FULLBRIGHT); } - self.pflags = 0; + this.alpha = 0.3; + if(this.effects & EF_FULLBRIGHT) { this.effects &= ~(EF_FULLBRIGHT); } + this.pflags = 0; } else { - self.alpha = 1; - if(!(self.effects & EF_FULLBRIGHT)) { self.effects |= EF_FULLBRIGHT; } - self.light_lev = 220 + 36 * sin(time); - self.pflags = PFLAGS_FULLDYNAMIC; + this.alpha = 1; + if(!(this.effects & EF_FULLBRIGHT)) { this.effects |= EF_FULLBRIGHT; } + this.light_lev = 220 + 36 * sin(time); + this.pflags = PFLAGS_FULLDYNAMIC; } return true; } -void buff_Init(entity ent) -{SELFPARAM(); - if(!cvar("g_buffs")) { remove(ent); return; } - - if(!teamplay && ent.team) { ent.team = 0; } - - entity buff = buff_FirstFromFlags(self.buffs); - - setself(ent); - if(!self.buffs || buff_Available(buff)) - buff_NewType(self, 0); - - self.classname = "item_buff"; - self.solid = SOLID_TRIGGER; - self.flags = FL_ITEM; - self.think = buff_Think; - self.touch = buff_Touch; - self.reset = buff_Reset; - self.nextthink = time + 0.1; - self.gravity = 1; - self.movetype = MOVETYPE_TOSS; - self.scale = 1; - self.skin = buff.m_skin; - self.effects = EF_FULLBRIGHT | EF_STARDUST | EF_NOSHADOW; - self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY; - self.customizeentityforclient = buff_Customize; - //self.gravity = 100; - self.color = buff.m_color; - self.glowmod = buff_GlowColor(self); - buff_SetCooldown(autocvar_g_buffs_cooldown_activate + game_starttime); - self.buff_active = !self.buff_activetime; - self.pflags = PFLAGS_FULLDYNAMIC; - - if(self.spawnflags & 1) - self.noalign = true; - - if(self.noalign) - self.movetype = MOVETYPE_NONE; // reset by random location - - setmodel(self, MDL_BUFF); - setsize(self, BUFF_MIN, BUFF_MAX); - - if(cvar("g_buffs_random_location") || (self.spawnflags & 64)) - buff_Respawn(self); +void buff_Init(entity this) +{ + if(!cvar("g_buffs")) { remove(this); return; } + + if(!teamplay && this.team) { this.team = 0; } - setself(this); + entity buff = buff_FirstFromFlags(this.buffs); + + if(!this.buffs || buff_Available(buff)) + buff_NewType(this, 0); + + this.classname = "item_buff"; + this.solid = SOLID_TRIGGER; + this.flags = FL_ITEM; + this.think = buff_Think; + this.touch = buff_Touch; + this.reset = buff_Reset; + this.nextthink = time + 0.1; + this.gravity = 1; + this.movetype = MOVETYPE_TOSS; + this.scale = 1; + this.skin = buff.m_skin; + this.effects = EF_FULLBRIGHT | EF_STARDUST | EF_NOSHADOW; + this.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY; + this.customizeentityforclient = buff_Customize; + //this.gravity = 100; + this.color = buff.m_color; + this.glowmod = buff_GlowColor(this); + buff_SetCooldown(this, autocvar_g_buffs_cooldown_activate + game_starttime); + this.buff_active = !this.buff_activetime; + this.pflags = PFLAGS_FULLDYNAMIC; + + if(this.spawnflags & 1) + this.noalign = true; + + if(this.noalign) + this.movetype = MOVETYPE_NONE; // reset by random location + + setmodel(this, MDL_BUFF); + setsize(this, BUFF_MIN, BUFF_MAX); + + if(cvar("g_buffs_random_location") || (this.spawnflags & 64)) + buff_Respawn(this); } void buff_Init_Compat(entity ent, entity replacement) @@ -479,10 +476,10 @@ void buff_SpawnReplacement(entity ent, entity old) void buff_Vengeance_DelayedDamage() {SELFPARAM(); - if(self.enemy) - Damage(self.enemy, self.owner, self.owner, self.dmg, DEATH_BUFF.m_id, self.enemy.origin, '0 0 0'); + if(this.enemy) + Damage(this.enemy, this.owner, this.owner, this.dmg, DEATH_BUFF.m_id, this.enemy.origin, '0 0 0'); - remove(self); + remove(this); return; } diff --git a/qcsrc/common/mutators/mutator/instagib/instagib.qc b/qcsrc/common/mutators/mutator/instagib/instagib.qc index 575e95210..d9504f82f 100644 --- a/qcsrc/common/mutators/mutator/instagib/instagib.qc +++ b/qcsrc/common/mutators/mutator/instagib/instagib.qc @@ -31,7 +31,7 @@ spawnfunc(item_minst_cells) void instagib_invisibility() {SELFPARAM(); - self.strength_finished = autocvar_g_balance_powerup_strength_time; + this.strength_finished = autocvar_g_balance_powerup_strength_time; StartItem(this, ITEM_Invisibility); } @@ -42,7 +42,7 @@ void instagib_extralife() void instagib_speed() {SELFPARAM(); - self.invincible_finished = autocvar_g_balance_powerup_invincible_time; + this.invincible_finished = autocvar_g_balance_powerup_invincible_time; StartItem(this, ITEM_Speed); } @@ -55,86 +55,86 @@ void instagib_stop_countdown(entity e) Kill_Notification(NOTIF_ONE_ONLY, e, MSG_CENTER, CPID_INSTAGIB_FINDAMMO); e.instagib_needammo = false; } -void instagib_ammocheck() -{SELFPARAM(); - if(time < self.instagib_nextthink) +void instagib_ammocheck(entity this) +{ + if(time < this.instagib_nextthink) return; - if(!IS_PLAYER(self)) + if(!IS_PLAYER(this)) return; // not a player - if(IS_DEAD(self) || gameover) - instagib_stop_countdown(self); - else if (self.ammo_cells > 0 || (self.items & IT_UNLIMITED_WEAPON_AMMO) || (self.flags & FL_GODMODE)) - instagib_stop_countdown(self); + if(IS_DEAD(this) || gameover) + instagib_stop_countdown(this); + else if (this.ammo_cells > 0 || (this.items & IT_UNLIMITED_WEAPON_AMMO) || (this.flags & FL_GODMODE)) + instagib_stop_countdown(this); else if(autocvar_g_rm && autocvar_g_rm_laser) { - if(!self.instagib_needammo) + if(!this.instagib_needammo) { - Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_INSTAGIB_DOWNGRADE); - self.instagib_needammo = true; + Send_Notification(NOTIF_ONE, this, MSG_CENTER, CENTER_INSTAGIB_DOWNGRADE); + this.instagib_needammo = true; } } else { - self.instagib_needammo = true; - if (self.health <= 5) + this.instagib_needammo = true; + if (this.health <= 5) { - Damage(self, self, self, 5, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_INSTAGIB_TERMINATED); + Damage(this, this, this, 5, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_INSTAGIB_TERMINATED); } - else if (self.health <= 10) + else if (this.health <= 10) { - Damage(self, self, self, 5, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_1); + Damage(this, this, this, 5, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_1); } - else if (self.health <= 20) + else if (this.health <= 20) { - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_2); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_2); } - else if (self.health <= 30) + else if (this.health <= 30) { - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_3); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_3); } - else if (self.health <= 40) + else if (this.health <= 40) { - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_4); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_4); } - else if (self.health <= 50) + else if (this.health <= 50) { - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_5); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_5); } - else if (self.health <= 60) + else if (this.health <= 60) { - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_6); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_6); } - else if (self.health <= 70) + else if (this.health <= 70) { - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_7); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_7); } - else if (self.health <= 80) + else if (this.health <= 80) { - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_8); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_8); } - else if (self.health <= 90) + else if (this.health <= 90) { - Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_INSTAGIB_FINDAMMO); - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); - Send_Notification(NOTIF_ONE, self, MSG_ANNCE, ANNCE_NUM_9); + Send_Notification(NOTIF_ONE_ONLY, this, MSG_CENTER, CENTER_INSTAGIB_FINDAMMO); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); + Send_Notification(NOTIF_ONE, this, MSG_ANNCE, ANNCE_NUM_9); } else { - Send_Notification(NOTIF_ONE_ONLY, self, MSG_MULTI, MULTI_INSTAGIB_FINDAMMO); - Damage(self, self, self, 10, DEATH_NOAMMO.m_id, self.origin, '0 0 0'); + Send_Notification(NOTIF_ONE_ONLY, this, MSG_MULTI, MULTI_INSTAGIB_FINDAMMO); + Damage(this, this, this, 10, DEATH_NOAMMO.m_id, this.origin, '0 0 0'); } } - self.instagib_nextthink = time + 1; + this.instagib_nextthink = time + 1; } MUTATOR_HOOKFUNCTION(mutator_instagib, MatchEnd) @@ -180,8 +180,8 @@ MUTATOR_HOOKFUNCTION(mutator_instagib, PlayerSpawn) } MUTATOR_HOOKFUNCTION(mutator_instagib, PlayerPreThink) -{ - instagib_ammocheck(); +{SELFPARAM(); + instagib_ammocheck(self); return false; } diff --git a/qcsrc/common/mutators/mutator/nades/nades.qc b/qcsrc/common/mutators/mutator/nades/nades.qc index cabfd31b8..9be8f96de 100644 --- a/qcsrc/common/mutators/mutator/nades/nades.qc +++ b/qcsrc/common/mutators/mutator/nades/nades.qc @@ -149,10 +149,10 @@ REGISTER_MUTATOR(nades, cvar("g_nades")); void nade_timer_think() {SELFPARAM(); - self.skin = 8 - (self.owner.wait - time) / (autocvar_g_nades_nade_lifetime / 10); - self.nextthink = time; - if(!self.owner || wasfreed(self.owner)) - remove(self); + this.skin = 8 - (this.owner.wait - time) / (autocvar_g_nades_nade_lifetime / 10); + this.nextthink = time; + if(!this.owner || wasfreed(this.owner)) + remove(this); } void nade_burn_spawn(entity _nade) @@ -178,8 +178,8 @@ void nade_spawn(entity _nade) CSQCProjectile(_nade, true, Nades_from(_nade.nade_type).m_projectile[false], true); } -void napalm_damage(float dist, float damage, float edgedamage, float burntime) -{SELFPARAM(); +void napalm_damage(entity this, float dist, float damage, float edgedamage, float burntime) +{ entity e; float d; vector p; @@ -188,17 +188,17 @@ void napalm_damage(float dist, float damage, float edgedamage, float burntime) return; RandomSelection_Init(); - for(e = WarpZone_FindRadius(self.origin, dist, true); e; e = e.chain) + for(e = WarpZone_FindRadius(this.origin, dist, true); e; e = e.chain) if(e.takedamage == DAMAGE_AIM) - if(self.realowner != e || autocvar_g_nades_napalm_selfdamage) - if(!IS_PLAYER(e) || !self.realowner || DIFF_TEAM(e, self)) + if(this.realowner != e || autocvar_g_nades_napalm_selfdamage) + if(!IS_PLAYER(e) || !this.realowner || DIFF_TEAM(e, this)) if(!STAT(FROZEN, e)) { p = e.origin; p.x += e.mins.x + random() * (e.maxs.x - e.mins.x); p.y += e.mins.y + random() * (e.maxs.y - e.mins.y); p.z += e.mins.z + random() * (e.maxs.z - e.mins.z); - d = vlen(WarpZone_UnTransformOrigin(e, self.origin) - p); + d = vlen(WarpZone_UnTransformOrigin(e, this.origin) - p); if(d < dist) { e.fireball_impactvec = p; @@ -207,11 +207,11 @@ void napalm_damage(float dist, float damage, float edgedamage, float burntime) } if(RandomSelection_chosen_ent) { - d = vlen(WarpZone_UnTransformOrigin(RandomSelection_chosen_ent, self.origin) - RandomSelection_chosen_ent.fireball_impactvec); + d = vlen(WarpZone_UnTransformOrigin(RandomSelection_chosen_ent, this.origin) - RandomSelection_chosen_ent.fireball_impactvec); d = damage + (edgedamage - damage) * (d / dist); - Fire_AddDamage(RandomSelection_chosen_ent, self.realowner, d * burntime, burntime, self.projectiledeathtype | HITTYPE_BOUNCE); - //trailparticles(self, particleeffectnum(EFFECT_FIREBALL_LASER), self.origin, RandomSelection_chosen_ent.fireball_impactvec); - Send_Effect(EFFECT_FIREBALL_LASER, self.origin, RandomSelection_chosen_ent.fireball_impactvec - self.origin, 1); + Fire_AddDamage(RandomSelection_chosen_ent, this.realowner, d * burntime, burntime, this.projectiledeathtype | HITTYPE_BOUNCE); + //trailparticles(this, particleeffectnum(EFFECT_FIREBALL_LASER), this.origin, RandomSelection_chosen_ent.fireball_impactvec); + Send_Effect(EFFECT_FIREBALL_LASER, this.origin, RandomSelection_chosen_ent.fireball_impactvec - this.origin, 1); } } @@ -221,45 +221,45 @@ void napalm_ball_think() if(round_handler_IsActive()) if(!round_handler_IsRoundStarted()) { - remove(self); + remove(this); return; } - if(time > self.pushltime) + if(time > this.pushltime) { - remove(self); + remove(this); return; } - vector midpoint = ((self.absmin + self.absmax) * 0.5); + vector midpoint = ((this.absmin + this.absmax) * 0.5); if(pointcontents(midpoint) == CONTENT_WATER) { - self.velocity = self.velocity * 0.5; + this.velocity = this.velocity * 0.5; if(pointcontents(midpoint + '0 0 16') == CONTENT_WATER) - { self.velocity_z = 200; } + { this.velocity_z = 200; } } - self.angles = vectoangles(self.velocity); + this.angles = vectoangles(this.velocity); - napalm_damage(autocvar_g_nades_napalm_ball_radius,autocvar_g_nades_napalm_ball_damage, + napalm_damage(this, autocvar_g_nades_napalm_ball_radius,autocvar_g_nades_napalm_ball_damage, autocvar_g_nades_napalm_ball_damage,autocvar_g_nades_napalm_burntime); - self.nextthink = time + 0.1; + this.nextthink = time + 0.1; } -void nade_napalm_ball() -{SELFPARAM(); +void nade_napalm_ball(entity this) +{ entity proj; vector kick; - spamsound(self, CH_SHOTS, SND(FIREBALL_FIRE), VOL_BASE, ATTEN_NORM); + spamsound(this, CH_SHOTS, SND(FIREBALL_FIRE), VOL_BASE, ATTEN_NORM); proj = new(grenade); - proj.owner = self.owner; - proj.realowner = self.realowner; - proj.team = self.owner.team; + proj.owner = this.owner; + proj.realowner = this.realowner; + proj.team = this.owner.team; proj.bot_dodge = true; proj.bot_dodgerating = autocvar_g_nades_napalm_ball_damage; proj.movetype = MOVETYPE_BOUNCE; @@ -268,7 +268,7 @@ void nade_napalm_ball() setmodel(proj, MDL_Null); proj.scale = 1;//0.5; setsize(proj, '-4 -4 -4', '4 4 4'); - setorigin(proj, self.origin); + setorigin(proj, this.origin); proj.think = napalm_ball_think; proj.nextthink = time; proj.damageforcescale = autocvar_g_nades_napalm_ball_damageforcescale; @@ -295,44 +295,44 @@ void napalm_fountain_think() if(round_handler_IsActive()) if(!round_handler_IsRoundStarted()) { - remove(self); + remove(this); return; } - if(time >= self.ltime) + if(time >= this.ltime) { - remove(self); + remove(this); return; } - vector midpoint = ((self.absmin + self.absmax) * 0.5); + vector midpoint = ((this.absmin + this.absmax) * 0.5); if(pointcontents(midpoint) == CONTENT_WATER) { - self.velocity = self.velocity * 0.5; + this.velocity = this.velocity * 0.5; if(pointcontents(midpoint + '0 0 16') == CONTENT_WATER) - { self.velocity_z = 200; } + { this.velocity_z = 200; } - UpdateCSQCProjectile(self); + UpdateCSQCProjectile(this); } - napalm_damage(autocvar_g_nades_napalm_fountain_radius, autocvar_g_nades_napalm_fountain_damage, + napalm_damage(this, autocvar_g_nades_napalm_fountain_radius, autocvar_g_nades_napalm_fountain_damage, autocvar_g_nades_napalm_fountain_edgedamage, autocvar_g_nades_napalm_burntime); - self.nextthink = time + 0.1; - if(time >= self.nade_special_time) + this.nextthink = time + 0.1; + if(time >= this.nade_special_time) { - self.nade_special_time = time + autocvar_g_nades_napalm_fountain_delay; - nade_napalm_ball(); + this.nade_special_time = time + autocvar_g_nades_napalm_fountain_delay; + nade_napalm_ball(this); } } -void nade_napalm_boom() -{SELFPARAM(); +void nade_napalm_boom(entity this) +{ entity fountain; int c; for (c = 0; c < autocvar_g_nades_napalm_ball_count; c++) - nade_napalm_ball(); + nade_napalm_ball(this); fountain = spawn(); @@ -428,25 +428,25 @@ void nade_ice_think() nade_ice_freeze(self, e, current_freeze_time); } -void nade_ice_boom() -{SELFPARAM(); +void nade_ice_boom(entity this) +{ entity fountain; fountain = spawn(); - fountain.owner = self.owner; - fountain.realowner = self.realowner; - fountain.origin = self.origin; + fountain.owner = this.owner; + fountain.realowner = this.realowner; + fountain.origin = this.origin; setorigin(fountain, fountain.origin); fountain.think = nade_ice_think; fountain.nextthink = time; fountain.ltime = time + autocvar_g_nades_ice_freeze_time; fountain.pushltime = fountain.wait = fountain.ltime; - fountain.team = self.team; + fountain.team = this.team; fountain.movetype = MOVETYPE_TOSS; fountain.projectiledeathtype = DEATH_NADE_ICE.m_id; fountain.bot_dodge = false; setsize(fountain, '-16 -16 -16', '16 16 16'); fountain.nade_special_time = time+0.3; - fountain.angles = self.angles; + fountain.angles = this.angles; if ( autocvar_g_nades_ice_explode ) { @@ -454,8 +454,8 @@ void nade_ice_boom() entity timer = new(nade_timer); setmodel(timer, MDL_NADE_TIMER); setattachment(timer, fountain, ""); - timer.colormap = self.colormap; - timer.glowmod = self.glowmod; + timer.colormap = this.colormap; + timer.glowmod = this.glowmod; timer.think = nade_timer_think; timer.nextthink = time; timer.wait = fountain.ltime; @@ -466,40 +466,40 @@ void nade_ice_boom() setmodel(fountain, MDL_Null); } -void nade_translocate_boom() -{SELFPARAM(); - if(self.realowner.vehicle) +void nade_translocate_boom(entity this) +{ + if(this.realowner.vehicle) return; - vector locout = self.origin + '0 0 1' * (1 - self.realowner.mins.z - 24); - tracebox(locout, self.realowner.mins, self.realowner.maxs, locout, MOVE_NOMONSTERS, self.realowner); + vector locout = this.origin + '0 0 1' * (1 - this.realowner.mins.z - 24); + tracebox(locout, this.realowner.mins, this.realowner.maxs, locout, MOVE_NOMONSTERS, this.realowner); locout = trace_endpos; - makevectors(self.realowner.angles); + makevectors(this.realowner.angles); - MUTATOR_CALLHOOK(PortalTeleport, self.realowner); + MUTATOR_CALLHOOK(PortalTeleport, this.realowner); - TeleportPlayer(self, self.realowner, locout, self.realowner.angles, v_forward * vlen(self.realowner.velocity), '0 0 0', '0 0 0', TELEPORT_FLAGS_TELEPORTER); + TeleportPlayer(this, this.realowner, locout, this.realowner.angles, v_forward * vlen(this.realowner.velocity), '0 0 0', '0 0 0', TELEPORT_FLAGS_TELEPORTER); } -void nade_spawn_boom() -{SELFPARAM(); +void nade_spawn_boom(entity this) +{ entity spawnloc = spawn(); - setorigin(spawnloc, self.origin); - setsize(spawnloc, self.realowner.mins, self.realowner.maxs); + setorigin(spawnloc, this.origin); + setsize(spawnloc, this.realowner.mins, this.realowner.maxs); spawnloc.movetype = MOVETYPE_NONE; spawnloc.solid = SOLID_NOT; - spawnloc.drawonlytoclient = self.realowner; + spawnloc.drawonlytoclient = this.realowner; spawnloc.effects = EF_STARDUST; spawnloc.cnt = autocvar_g_nades_spawn_count; - if(self.realowner.nade_spawnloc) + if(this.realowner.nade_spawnloc) { - remove(self.realowner.nade_spawnloc); - self.realowner.nade_spawnloc = world; + remove(this.realowner.nade_spawnloc); + this.realowner.nade_spawnloc = world; } - self.realowner.nade_spawnloc = spawnloc; + this.realowner.nade_spawnloc = spawnloc; } void nade_heal_think() @@ -563,16 +563,16 @@ void nade_heal_touch() } } -void nade_heal_boom() -{SELFPARAM(); +void nade_heal_boom(entity this) +{ entity healer; healer = spawn(); - healer.owner = self.owner; - healer.realowner = self.realowner; - setorigin(healer, self.origin); + healer.owner = this.owner; + healer.realowner = this.realowner; + setorigin(healer, this.origin); healer.healer_lifetime = autocvar_g_nades_heal_time; // save the cvar healer.ltime = time + healer.healer_lifetime; - healer.team = self.realowner.team; + healer.team = this.realowner.team; healer.bot_dodge = false; healer.solid = SOLID_TRIGGER; healer.touch = nade_heal_touch; @@ -589,9 +589,9 @@ void nade_heal_boom() healer.SendFlags |= 1; } -void nade_monster_boom() -{SELFPARAM(); - entity e = spawnmonster(self.pokenade_type, 0, self.realowner, self.realowner, self.origin, false, false, 1); +void nade_monster_boom(entity this) +{ + entity e = spawnmonster(this.pokenade_type, 0, this.realowner, this.realowner, this.origin, false, false, 1); if(autocvar_g_nades_pokenade_monster_lifetime > 0) e.monster_lifetime = time + autocvar_g_nades_pokenade_monster_lifetime; @@ -603,7 +603,7 @@ void nade_boom() entity expef = NULL; bool nade_blast = true; - switch ( Nades_from(self.nade_type) ) + switch ( Nades_from(this.nade_type) ) { case NADE_TYPE_NAPALM: nade_blast = autocvar_g_nades_napalm_blast; @@ -619,7 +619,7 @@ void nade_boom() case NADE_TYPE_MONSTER: case NADE_TYPE_SPAWN: nade_blast = false; - switch(self.realowner.team) + switch(this.realowner.team) { case NUM_TEAM_1: expef = EFFECT_SPAWN_RED; break; case NUM_TEAM_2: expef = EFFECT_SPAWN_BLUE; break; @@ -635,43 +635,43 @@ void nade_boom() default: case NADE_TYPE_NORMAL: - expef = EFFECT_NADE_EXPLODE(self.realowner.team); + expef = EFFECT_NADE_EXPLODE(this.realowner.team); break; } if(expef) - Send_Effect(expef, findbetterlocation(self.origin, 8), '0 0 0', 1); + Send_Effect(expef, findbetterlocation(this.origin, 8), '0 0 0', 1); - sound(self, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, ATTEN_NORM); - sound(self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM); + sound(this, CH_SHOTS_SINGLE, SND_Null, VOL_BASE, ATTEN_NORM); + sound(this, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM); - self.event_damage = func_null; // prevent somehow calling damage in the next call + this.event_damage = func_null; // prevent somehow calling damage in the next call if(nade_blast) { - RadiusDamage(self, self.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage, - autocvar_g_nades_nade_radius, self, world, autocvar_g_nades_nade_force, self.projectiledeathtype, self.enemy); - Damage_DamageInfo(self.origin, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage, autocvar_g_nades_nade_radius, '1 1 1' * autocvar_g_nades_nade_force, self.projectiledeathtype, 0, self); + RadiusDamage(this, this.realowner, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage, + autocvar_g_nades_nade_radius, this, world, autocvar_g_nades_nade_force, this.projectiledeathtype, this.enemy); + Damage_DamageInfo(this.origin, autocvar_g_nades_nade_damage, autocvar_g_nades_nade_edgedamage, autocvar_g_nades_nade_radius, '1 1 1' * autocvar_g_nades_nade_force, this.projectiledeathtype, 0, this); } - if(self.takedamage) - switch ( Nades_from(self.nade_type) ) + if(this.takedamage) + switch ( Nades_from(this.nade_type) ) { - case NADE_TYPE_NAPALM: nade_napalm_boom(); break; - case NADE_TYPE_ICE: nade_ice_boom(); break; - case NADE_TYPE_TRANSLOCATE: nade_translocate_boom(); break; - case NADE_TYPE_SPAWN: nade_spawn_boom(); break; - case NADE_TYPE_HEAL: nade_heal_boom(); break; - case NADE_TYPE_MONSTER: nade_monster_boom(); break; + case NADE_TYPE_NAPALM: nade_napalm_boom(this); break; + case NADE_TYPE_ICE: nade_ice_boom(this); break; + case NADE_TYPE_TRANSLOCATE: nade_translocate_boom(this); break; + case NADE_TYPE_SPAWN: nade_spawn_boom(this); break; + case NADE_TYPE_HEAL: nade_heal_boom(this); break; + case NADE_TYPE_MONSTER: nade_monster_boom(this); break; } - FOREACH_ENTITY_ENT(aiment, self, + FOREACH_ENTITY_ENT(aiment, this, { if(it.classname == "grapplinghook") RemoveGrapplingHook(it.realowner); }); - remove(self); + remove(this); } void spawn_held_nade(entity player, entity nowner, float ntime, int ntype, string pntype); @@ -740,9 +740,9 @@ void nade_touch() void nade_beep() {SELFPARAM(); - sound(self, CH_SHOTS_SINGLE, SND_NADE_BEEP, VOL_BASE, 0.5 *(ATTEN_LARGE + ATTEN_MAX)); - self.think = nade_boom; - self.nextthink = max(self.wait, time); + sound(this, CH_SHOTS_SINGLE, SND_NADE_BEEP, VOL_BASE, 0.5 *(ATTEN_LARGE + ATTEN_MAX)); + this.think = nade_boom; + this.nextthink = max(this.wait, time); } void nade_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)