kh_Initialize();
ActivateTeamplay();
- SetLimits(autocvar_g_keyhunt_point_limit, autocvar_g_keyhunt_point_leadlimit, -1, -1);
+ SetLimits(autocvar_g_keyhunt_point_limit, autocvar_g_keyhunt_point_leadlimit, autocvar_timelimit_override, -1);
if (autocvar_g_keyhunt_team_spawns)
have_team_spawns = -1; // request team spawns
}
ScoreRules_basics_end();
}
-float kh_KeyCarrier_waypointsprite_visible_for_player(entity e) // runs all the time
-{SELFPARAM();
- if(!IS_PLAYER(e) || DIFF_TEAM(self, e))
+bool kh_KeyCarrier_waypointsprite_visible_for_player(entity this, entity player, entity view) // runs all the time
+{
+ if(!IS_PLAYER(view) || DIFF_TEAM(this, view))
if(!kh_tracking_enabled)
return false;
return true;
}
-float kh_Key_waypointsprite_visible_for_player(entity e) // ??
-{SELFPARAM();
+bool kh_Key_waypointsprite_visible_for_player(entity this, entity player, entity view)
+{
if(!kh_tracking_enabled)
return false;
- if(!self.owner)
+ if(!this.owner)
return true;
- if(!self.owner.owner)
+ if(!this.owner.owner)
return true;
return false; // draw only when key is not owned
}
kh_controller.nextthink = time; // force
}
void kh_WaitForPlayers();
-void kh_Controller_Think() // called a lot
-{SELFPARAM();
+void kh_Controller_Think(entity this) // called a lot
+{
if(intermission_running)
return;
- if(self.cnt > 0)
- { if(self.think != kh_WaitForPlayers) { self.cnt -= 1; } }
- else if(self.cnt == 0)
+ if(this.cnt > 0)
+ { if(getthink(this) != kh_WaitForPlayers) { this.cnt -= 1; } }
+ else if(this.cnt == 0)
{
- self.cnt -= 1;
+ this.cnt -= 1;
kh_Controller_Thinkfunc();
}
- self.nextthink = time + 1;
+ this.nextthink = time + 1;
}
// frags f: take from cvar * f
kh_Key_AssignTo(key, player); // this also updates .kh_state
}
-void kh_Key_Touch() // runs many, many times when a key has been dropped and can be picked up
-{SELFPARAM();
+void kh_Key_Touch(entity this) // runs many, many times when a key has been dropped and can be picked up
+{
if(intermission_running)
return;
- if(self.owner) // already carried
+ if(this.owner) // already carried
return;
if(ITEM_TOUCH_NEEDKILL())
return;
if(IS_DEAD(other))
return;
- if(other == self.enemy)
- if(time < self.kh_droptime + autocvar_g_balance_keyhunt_delay_collect)
+ if(other == this.enemy)
+ if(time < this.kh_droptime + autocvar_g_balance_keyhunt_delay_collect)
return; // you just dropped it!
- kh_Key_Collect(self, other);
+ kh_Key_Collect(this, other);
}
void kh_Key_Remove(entity key) // runs after when all the keys have been collected or when a key has been dropped for more than X seconds
kh_FinishRound();
}
-void kh_Key_Think() // runs all the time
-{SELFPARAM();
+void kh_Key_Think(entity this) // runs all the time
+{
if(intermission_running)
return;
- if(self.owner)
+ if(this.owner)
{
#ifndef KH_PLAYER_USE_ATTACHMENT
- makevectors('0 1 0' * (self.cnt + (time % 360) * KH_KEY_XYSPEED));
- setorigin(self, v_forward * KH_KEY_XYDIST + '0 0 1' * self.origin.z);
+ makevectors('0 1 0' * (this.cnt + (time % 360) * KH_KEY_XYSPEED));
+ setorigin(this, v_forward * KH_KEY_XYDIST + '0 0 1' * this.origin.z);
#endif
}
// if in nodrop or time over, end the round
- if(!self.owner)
- if(time > self.pain_finished)
- kh_LoserTeam(self.team, self);
+ if(!this.owner)
+ if(time > this.pain_finished)
+ kh_LoserTeam(this.team, this);
- if(self.owner)
+ if(this.owner)
if(kh_Key_AllOwnedByWhichTeam() != -1)
{
- if(self.siren_time < time)
+ if(this.siren_time < time)
{
- sound(self.owner, CH_TRIGGER, SND_KH_ALARM, VOL_BASE, ATTEN_NORM); // play a simple alarm
- self.siren_time = time + 2.5; // repeat every 2.5 seconds
+ sound(this.owner, CH_TRIGGER, SND_KH_ALARM, VOL_BASE, ATTEN_NORM); // play a simple alarm
+ this.siren_time = time + 2.5; // repeat every 2.5 seconds
}
entity key;
vector p;
- p = self.owner.origin;
+ p = this.owner.origin;
FOR_EACH_KH_KEY(key)
- if(vlen(key.owner.origin - p) > autocvar_g_balance_keyhunt_maxdist)
+ if(vdist(key.owner.origin - p, >, autocvar_g_balance_keyhunt_maxdist))
goto not_winning;
- kh_WinnerTeam(self.team);
+ kh_WinnerTeam(this.team);
LABEL(not_winning)
}
));
}
- self.nextthink = time + 0.05;
+ this.nextthink = time + 0.05;
}
void key_reset(entity this)
entity key = spawn();
key.count = i;
key.classname = STR_ITEM_KH_KEY;
- key.touch = kh_Key_Touch;
- key.think = kh_Key_Think;
+ settouch(key, kh_Key_Touch);
+ setthink(key, kh_Key_Think);
key.nextthink = time;
key.items = IT_KEY1 | IT_KEY2;
key.cnt = _angle;
kh_Key_AssignTo(key, world);
makevectors(player.v_angle);
- key.velocity = W_CalculateProjectileVelocity(player.velocity, autocvar_g_balance_keyhunt_throwvelocity * v_forward, false);
+ key.velocity = W_CalculateProjectileVelocity(player, player.velocity, autocvar_g_balance_keyhunt_throwvelocity * v_forward, false);
key.pusher = world;
key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
key.kh_dropperteam = key.team;
Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT(key, INFO_KEYHUNT_LOST), player.netname);
kh_Key_AssignTo(key, world);
makevectors('-1 0 0' * (45 + 45 * random()) + '0 360 0' * random());
- key.velocity = W_CalculateProjectileVelocity(player.velocity, autocvar_g_balance_keyhunt_dropvelocity * v_forward, false);
+ key.velocity = W_CalculateProjectileVelocity(player, player.velocity, autocvar_g_balance_keyhunt_dropvelocity * v_forward, false);
key.pusher = mypusher;
key.pushltime = time + autocvar_g_balance_keyhunt_protecttime;
if(suicide)
// make a KH entity for controlling the game
kh_controller = spawn();
- kh_controller.think = kh_Controller_Think;
+ setthink(kh_controller, kh_Controller_Think);
kh_Controller_SetThink(0, kh_WaitForPlayers);
setmodel(kh_controller, MDL_KH_KEY);
// register this as a mutator
MUTATOR_HOOKFUNCTION(kh, ClientDisconnect)
-{SELFPARAM();
- kh_Key_DropAll(self, true);
- return 0;
+{
+ entity player = M_ARGV(0, entity);
+
+ kh_Key_DropAll(player, true);
}
MUTATOR_HOOKFUNCTION(kh, MakePlayerObserver)
-{SELFPARAM();
- kh_Key_DropAll(self, true);
- return 0;
+{
+ entity player = M_ARGV(0, entity);
+
+ kh_Key_DropAll(player, true);
}
MUTATOR_HOOKFUNCTION(kh, PlayerDies)
{
- if(frag_target == other)
+ entity frag_attacker = M_ARGV(1, entity);
+ entity frag_target = M_ARGV(2, entity);
+
+ if(frag_target == frag_attacker)
kh_Key_DropAll(frag_target, true);
- else if(IS_PLAYER(other))
+ else if(IS_PLAYER(frag_attacker))
kh_Key_DropAll(frag_target, false);
else
kh_Key_DropAll(frag_target, true);
- return 0;
}
MUTATOR_HOOKFUNCTION(kh, GiveFragsForKill, CBC_ORDER_FIRST)
{
- frag_score = kh_HandleFrags(frag_attacker, frag_target, frag_score);
- return 0;
+ entity frag_attacker = M_ARGV(0, entity);
+ entity frag_target = M_ARGV(1, entity);
+ float frag_score = M_ARGV(2, float);
+ M_ARGV(2, float) = kh_HandleFrags(frag_attacker, frag_target, frag_score);
}
MUTATOR_HOOKFUNCTION(kh, MatchEnd)
{
kh_finalize();
- return 0;
}
MUTATOR_HOOKFUNCTION(kh, GetTeamCount, CBC_ORDER_EXCLUSIVE)
{
- ret_float = kh_teams;
- return false;
+ M_ARGV(0, float) = kh_teams;
}
MUTATOR_HOOKFUNCTION(kh, SpectateCopy)
-{SELFPARAM();
- self.kh_state = other.kh_state;
- return 0;
+{
+ entity spectatee = M_ARGV(0, entity);
+ entity client = M_ARGV(1, entity);
+
+ client.kh_state = spectatee.kh_state;
}
MUTATOR_HOOKFUNCTION(kh, PlayerUseKey)
-{SELFPARAM();
+{
+ entity player = M_ARGV(0, entity);
+
if(MUTATOR_RETURNVALUE == 0)
{
- entity k;
- k = self.kh_next;
+ entity k = player.kh_next;
if(k)
{
kh_Key_DropOne(k);
- return 1;
+ return true;
}
}
- return 0;
}
MUTATOR_HOOKFUNCTION(kh, HavocBot_ChooseRole)
{
- SELFPARAM();
- if(IS_DEAD(self))
+ entity bot = M_ARGV(0, entity);
+
+ if(IS_DEAD(bot))
return true;
float r = random() * 3;
if (r < 1)
- self.havocbot_role = havocbot_role_kh_offense;
+ bot.havocbot_role = havocbot_role_kh_offense;
else if (r < 2)
- self.havocbot_role = havocbot_role_kh_defense;
+ bot.havocbot_role = havocbot_role_kh_defense;
else
- self.havocbot_role = havocbot_role_kh_freelancer;
+ bot.havocbot_role = havocbot_role_kh_freelancer;
return true;
}
MUTATOR_HOOKFUNCTION(kh, DropSpecialItems)
{
+ entity frag_target = M_ARGV(0, entity);
+
kh_Key_DropAll(frag_target, false);
- return false;
}
MUTATOR_HOOKFUNCTION(kh, reset_map_global)
{
kh_Controller_SetThink(autocvar_g_balance_keyhunt_delay_round + (game_starttime - time), kh_StartRound);
- return false;
}
#endif
projects / xonotic / xonotic-data.pk3dir.git / blobdiff