bool QuickMenu_Open(string mode, string submenu);
bool HUD_MinigameMenu_IsOpened();
-void HUD_MinigameMenu_Close();
+void HUD_MinigameMenu_Close(entity this, entity actor, entity trigger);
void HUD_MinigameMenu_Open();
void HUD_Radar_Show_Maximized(bool doshow, bool clickable);
}
deactivate_minigame();
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
}
.float has_team;
onslaught_updatelinks();
// Use targets now (somebody make sure this is in the right place..)
- setself(this.owner);
- activator = this;
- WITHSELF(this, SUB_UseTargets());
- setself(this);
+ SUB_UseTargets(this.owner, this, NULL);
this.owner.waslinked = this.owner.islinked;
if(this.owner.model != "models/onslaught/controlpoint_pad.md3")
if(!self.owner.islinked)
self.owner.team = 0;
- setself(self.owner);
- activator = self;
- SUB_UseTargets ();
- setself(this);
+ SUB_UseTargets(self.owner, self, NULL);
self.owner.team = t;
onslaught_updatelinks();
// Use targets now (somebody make sure this is in the right place..)
- setself(self.owner);
- activator = self;
- SUB_UseTargets ();
- setself(this);
+ SUB_UseTargets(self.owner, self, NULL);
self.SendFlags |= CPSF_SETUP;
}
onslaught_updatelinks();
- activator = this;
- SUB_UseTargets(); // to reset the structures, playerspawns etc.
+ SUB_UseTargets(this, this, NULL); // to reset the structures, playerspawns etc.
CSQCMODEL_AUTOUPDATE(this);
}
void ons_MonsterSpawn_Delayed(entity this)
{
- entity e, own = self.owner;
+ entity own = self.owner;
- if(!own) { remove(self); return; }
+ if(!own) { remove(this); return; }
if(own.targetname)
{
- e = find(world, target, own.targetname);
+ entity e = find(world, target, own.targetname);
if(e != world)
{
own.team = e.team;
- activator = e;
- own.use();
+ own.use(own, e, NULL);
}
}
- remove(self);
+ remove(this);
}
MUTATOR_HOOKFUNCTION(ons, MonsterSpawn)
void ons_TurretSpawn_Delayed(entity this)
{
- entity e, own = self.owner;
+ entity own = self.owner;
if(!own) { remove(self); return; }
if(own.targetname)
{
- e = find(world, target, own.targetname);
+ entity e = find(world, target, own.targetname);
if(e != world)
{
own.team = e.team;
own.active = ACTIVE_NOT;
- activator = e;
- own.use();
+ own.use(own, e, NULL);
}
}
if ( auto_close_minigamemenu )
{
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
auto_close_minigamemenu = 0;
}
else
if(argv(1) == "minigame")
{
if (HUD_MinigameMenu_IsOpened())
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
else
HUD_MinigameMenu_Open();
return true;
void minigame_prompt();
float HUD_MinigameMenu_IsOpened();
-void HUD_MinigameMenu_Close();
+void HUD_MinigameMenu_Close(entity this, entity actor, entity trigger);
float HUD_Minigame_Showpanels();
// Adds a game-specific entry to the menu
void HUD_MinigameMenu_CustomEntry(entity parent, string message, string event_arg);
// Click the given item
void HUD_MinigameMenu_Click(entity menuitem)
-{SELFPARAM();
+{
if ( menuitem )
{
- WITHSELF(menuitem, menuitem.use());
+ menuitem.use(menuitem, NULL, NULL);
}
}
}
// Minigame menu options: create entry
-entity HUD_MinigameMenu_SpawnEntry(string s, vector offset, vector fontsize, vector color,void() click)
+entity HUD_MinigameMenu_SpawnEntry(string s, vector offset, vector fontsize, vector color,void(entity, entity, entity) click)
{
entity entry = spawn();
entry.message = s;
}
// Spawn a child entry of a collapsable entry
-entity HUD_MinigameMenu_SpawnSubEntry(string s, void() click, entity parent)
+entity HUD_MinigameMenu_SpawnSubEntry(string s, void(entity, entity, entity) click, entity parent)
{
vector item_fontsize = hud_fontsize*1.25;
vector item_offset = '1 0 0' * item_fontsize_x;
}
// Click action for Create sub-entries
-void HUD_MinigameMenu_ClickCreate_Entry()
-{SELFPARAM();
- minigame_cmd("create ",self.netname);
+void HUD_MinigameMenu_ClickCreate_Entry(entity this, entity actor, entity trigger)
+{
+ minigame_cmd("create ", this.netname);
}
// Helper click action for collapsible entries
// returns true when you have to create the sub-entries
-bool HUD_MinigameMenu_Click_ExpandCollapse()
-{SELFPARAM();
+bool HUD_MinigameMenu_Click_ExpandCollapse(entity this)
+{
entity e;
- if ( self.flags & 2 )
+ if ( this.flags & 2 )
{
if ( HUD_MinigameMenu_activeitem &&
- HUD_MinigameMenu_activeitem.owner == self )
+ HUD_MinigameMenu_activeitem.owner == this )
HUD_MinigameMenu_activeitem = world;
- self.flags &= ~2;
- for ( e = self.list_next; e != world && e.owner == self; e = self.list_next )
+ this.flags &= ~2;
+ for ( e = this.list_next; e != world && e.owner == this; e = this.list_next )
{
if ( e.flags & 2 )
HUD_MinigameMenu_Click(e);
- self.list_next = e.list_next;
+ this.list_next = e.list_next;
remove(e);
}
- if ( self.list_next )
- self.list_next.list_prev = self;
+ if ( this.list_next )
+ this.list_next.list_prev = this;
else
- HUD_MinigameMenu_last_entry = self;
+ HUD_MinigameMenu_last_entry = this;
}
else
{
for ( e = HUD_MinigameMenu_entries; e != world; e = e.list_next )
{
- if ( e.flags & 2 && e.origin_x == self.origin_x)
+ if ( e.flags & 2 && e.origin_x == this.origin_x)
HUD_MinigameMenu_Click(e);
}
- self.flags |= 2;
+ this.flags |= 2;
return true;
}
}
// Click action for the Create menu
-void HUD_MinigameMenu_ClickCreate()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickCreate(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
entity curr;
- entity prev = self;
+ entity prev = this;
FOREACH(Minigames, true, {
- curr = HUD_MinigameMenu_SpawnSubEntry(it.message, HUD_MinigameMenu_ClickCreate_Entry, self);
+ curr = HUD_MinigameMenu_SpawnSubEntry(it.message, HUD_MinigameMenu_ClickCreate_Entry, this);
curr.netname = it.netname;
curr.model = strzone(minigame_texture(strcat(it.netname,"/icon")));
HUD_MinigameMenu_InsertEntry( curr, prev );
}
// Click action for Join sub-entries
-void HUD_MinigameMenu_ClickJoin_Entry()
-{SELFPARAM();
- minigame_cmd("join ",self.netname);
- HUD_MinigameMenu_EraseEntry(self);
+void HUD_MinigameMenu_ClickJoin_Entry(entity this, entity actor, entity trigger)
+{
+ minigame_cmd("join ",this.netname);
+ HUD_MinigameMenu_EraseEntry(this);
}
// Click action for the Join menu
-void HUD_MinigameMenu_ClickJoin()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickJoin(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
entity e = world;
entity curr;
- entity prev = self;
+ entity prev = this;
while( (e = find(e,classname,"minigame")) )
{
if ( e != active_minigame )
{
curr = HUD_MinigameMenu_SpawnSubEntry(
- e.netname, HUD_MinigameMenu_ClickJoin_Entry, self );
+ e.netname, HUD_MinigameMenu_ClickJoin_Entry, this );
curr.netname = e.netname;
curr.model = strzone(minigame_texture(strcat(e.descriptor.netname,"/icon")));
HUD_MinigameMenu_InsertEntry( curr, prev );
}*/
// Click action for Quit
-void HUD_MinigameMenu_ClickQuit()
+void HUD_MinigameMenu_ClickQuit(entity this, entity actor, entity trigger)
{
deactivate_minigame();
minigame_cmd("end");
}
// Click action for Invite sub-entries
-void HUD_MinigameMenu_ClickInvite_Entry()
-{SELFPARAM();
- minigame_cmd("invite #",self.netname);
+void HUD_MinigameMenu_ClickInvite_Entry(entity this, entity actor, entity trigger)
+{
+ minigame_cmd("invite #",this.netname);
}
// Click action for the Invite menu
-void HUD_MinigameMenu_ClickInvite()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickInvite(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
entity e;
entity prev = self;
}
}
-void HUD_MinigameMenu_ClickCustomEntry()
-{SELFPARAM();
+void HUD_MinigameMenu_ClickCustomEntry(entity this, entity actor, entity trigger)
+{
if ( active_minigame )
- active_minigame.minigame_event(active_minigame,"menu_click",self.netname);
+ active_minigame.minigame_event(active_minigame,"menu_click",this.netname);
}
// Adds a game-specific entry to the menu
}
// Click action for the Current Game menu
-void HUD_MinigameMenu_ClickCurrentGame()
-{SELFPARAM();
- if ( HUD_MinigameMenu_Click_ExpandCollapse() )
+void HUD_MinigameMenu_ClickCurrentGame(entity this, entity actor, entity trigger)
+{
+ if ( HUD_MinigameMenu_Click_ExpandCollapse(this) )
{
HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
- _("Quit"), HUD_MinigameMenu_ClickQuit, self ), self);
+ _("Quit"), HUD_MinigameMenu_ClickQuit, this ), this);
- active_minigame.minigame_event(active_minigame,"menu_show",self);
+ active_minigame.minigame_event(active_minigame,"menu_show",this);
HUD_MinigameMenu_InsertEntry( HUD_MinigameMenu_SpawnSubEntry(
- _("Invite"), HUD_MinigameMenu_ClickInvite, self), self);
+ _("Invite"), HUD_MinigameMenu_ClickInvite, this), this);
}
}
// Whether the minigame menu panel is open
}
// Close the minigame menu panel
-void HUD_MinigameMenu_Close()
+void HUD_MinigameMenu_Close(entity this, entity actor, entity trigger)
{
if ( HUD_MinigameMenu_IsOpened() )
{
}
else if ( nPrimary == K_ESCAPE )
{
- HUD_MinigameMenu_Close();
+ HUD_MinigameMenu_Close(NULL, NULL, NULL);
return true;
}
}
self.nextthink = time + 0.2;
}
+void M_Shambler_Attack_Lightning_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, M_Shambler_Attack_Lightning_Explode());
+}
+
void M_Shambler_Attack_Lightning_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if (this.health <= 0)
this.health = this.health - damage;
if (this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.use));
+ W_PrepareExplosionByDamage(this, attacker, adaptor_think2use);
}
void M_Shambler_Attack_Lightning_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use ();
+ self.use(this, NULL, NULL);
}
void M_Shambler_Attack_Lightning_Think()
gren.cnt = time + 5;
gren.nextthink = time;
gren.think = M_Shambler_Attack_Lightning_Think;
- gren.use = M_Shambler_Attack_Lightning_Explode;
+ gren.use = M_Shambler_Attack_Lightning_Explode_use;
gren.touch = M_Shambler_Attack_Lightning_Touch;
gren.takedamage = DAMAGE_YES;
}
}
+void M_Spider_Attack_Web_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, M_Spider_Attack_Web_Explode());
+}
+
void M_Spider_Attack_Web_Touch()
{
PROJECTILE_TOUCH;
entity proj = new(plasma);
proj.owner = proj.realowner = this;
- proj.use = M_Spider_Attack_Web_Explode;
+ proj.use = M_Spider_Attack_Web_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.bot_dodge = true;
proj.bot_dodgerating = 0;
}
}
-void Monster_Use()
-{SELFPARAM();
- if(Monster_ValidTarget(this, activator)) { this.enemy = activator; }
+void Monster_Use(entity this, entity actor, entity trigger)
+{
+ if(Monster_ValidTarget(this, actor)) { this.enemy = actor; }
}
vector Monster_Move_Target(entity this, entity targ)
}
}
-void Monster_Appear()
-{SELFPARAM();
- this.enemy = activator;
+void Monster_Appear(entity this, entity actor, entity trigger)
+{
+ this.enemy = actor;
this.spawnflags &= ~MONSTERFLAG_APPEAR; // otherwise, we get an endless loop
Monster_Spawn(this, this.monsterid);
}
this.candrop = false; // killed by mobkill command
// TODO: fix this?
- activator = attacker;
- other = this.enemy;
- WITHSELF(this, SUB_UseTargets());
+ SUB_UseTargets(this, attacker, this.enemy);
this.target2 = this.oldtarget2; // reset to original target on death, incase we respawn
Monster_Dead(this, attacker, (this.health <= -100 || deathtype == DEATH_KILL.m_id));
this.realowner = attacker;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, nade_boom));
+ W_PrepareExplosionByDamage(this, attacker, nade_boom);
else
nade_burn_spawn(this);
}
this.health = this.health - damage;
if (this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_RocketPropelledChainsaw_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_RocketPropelledChainsaw_Explode);
}
void W_RocketPropelledChainsaw_Think()
// compatibility:
spawnfunc(item_quad) { this.classname = "item_strength";spawnfunc_item_strength(this);}
-void target_items_use()
-{SELFPARAM();
- if(activator.classname == "droppedweapon")
+void target_items_use(entity this, entity actor, entity trigger)
+{
+ other = trigger; // TODO
+
+ if(actor.classname == "droppedweapon")
{
EXACTTRIGGER_TOUCH;
- remove(activator);
+ remove(actor);
return;
}
- if (!IS_PLAYER(activator))
+ if (!IS_PLAYER(actor))
return;
- if(IS_DEAD(activator))
+ if(IS_DEAD(actor))
return;
EXACTTRIGGER_TOUCH;
- FOREACH_ENTITY_ENT(enemy, activator,
+ FOREACH_ENTITY_ENT(enemy, actor,
{
if(it.classname == "droppedweapon")
remove(it);
});
- if(GiveItems(activator, 0, tokenize_console(self.netname)))
- centerprint(activator, self.message);
+ if(GiveItems(actor, 0, tokenize_console(this.netname)))
+ centerprint(actor, this.message);
}
spawnfunc(target_items)
void _StartItem(entity this, entity def, float defaultrespawntime, float defaultrespawntimejitter);
-void target_items_use ();
-
float GiveWeapon(entity e, float wpn, float op, float val);
float GiveBit(entity e, .float fld, float bit, float op, float val);
// func_breakable
// - basically func_assault_destructible for general gameplay use
//
-void LaunchDebris (string debrisname, vector force)
-{SELFPARAM();
+void LaunchDebris (entity this, string debrisname, vector force)
+{
entity dbr = spawn();
- vector org = self.absmin
- + '1 0 0' * random() * (self.absmax.x - self.absmin.x)
- + '0 1 0' * random() * (self.absmax.y - self.absmin.y)
- + '0 0 1' * random() * (self.absmax.z - self.absmin.z);
+ vector org = this.absmin
+ + '1 0 0' * random() * (this.absmax.x - this.absmin.x)
+ + '0 1 0' * random() * (this.absmax.y - this.absmin.y)
+ + '0 0 1' * random() * (this.absmax.z - this.absmin.z);
setorigin(dbr, org);
_setmodel (dbr, debrisname );
- dbr.skin = self.debrisskin;
- dbr.colormap = self.colormap; // inherit team colors
- dbr.owner = self; // do not be affected by our own explosion
- dbr.movetype = self.debrismovetype;
- dbr.solid = self.debrissolid;
+ dbr.skin = this.debrisskin;
+ dbr.colormap = this.colormap; // inherit team colors
+ dbr.owner = this; // do not be affected by our own explosion
+ dbr.movetype = this.debrismovetype;
+ dbr.solid = this.debrissolid;
if(dbr.solid != SOLID_BSP) // SOLID_BSP has exact collision, MAYBE this works? TODO check this out
setsize(dbr, '0 0 0', '0 0 0'); // needed for performance, until engine can deal better with it
- dbr.velocity_x = self.debrisvelocity.x + self.debrisvelocityjitter.x * crandom();
- dbr.velocity_y = self.debrisvelocity.y + self.debrisvelocityjitter.y * crandom();
- dbr.velocity_z = self.debrisvelocity.z + self.debrisvelocityjitter.z * crandom();
- self.velocity = self.velocity + force * self.debrisdamageforcescale;
- dbr.avelocity_x = random()*self.debrisavelocityjitter.x;
- dbr.avelocity_y = random()*self.debrisavelocityjitter.y;
- dbr.avelocity_z = random()*self.debrisavelocityjitter.z;
- dbr.damageforcescale = self.debrisdamageforcescale;
+ dbr.velocity_x = this.debrisvelocity.x + this.debrisvelocityjitter.x * crandom();
+ dbr.velocity_y = this.debrisvelocity.y + this.debrisvelocityjitter.y * crandom();
+ dbr.velocity_z = this.debrisvelocity.z + this.debrisvelocityjitter.z * crandom();
+ this.velocity = this.velocity + force * this.debrisdamageforcescale;
+ dbr.avelocity_x = random()*this.debrisavelocityjitter.x;
+ dbr.avelocity_y = random()*this.debrisavelocityjitter.y;
+ dbr.avelocity_z = random()*this.debrisavelocityjitter.z;
+ dbr.damageforcescale = this.debrisdamageforcescale;
if(dbr.damageforcescale)
dbr.takedamage = DAMAGE_YES;
- SUB_SetFade(dbr, time + self.debristime + crandom() * self.debristimejitter, self.debrisfadetime);
+ SUB_SetFade(dbr, time + this.debristime + crandom() * this.debristimejitter, this.debrisfadetime);
}
-void func_breakable_colormod()
-{SELFPARAM();
+void func_breakable_colormod(entity this)
+{
float h;
- if (!(self.spawnflags & 2))
+ if (!(this.spawnflags & 2))
return;
- h = self.health / self.max_health;
+ h = this.health / this.max_health;
if(h < 0.25)
- self.colormod = '1 0 0';
+ this.colormod = '1 0 0';
else if(h <= 0.75)
- self.colormod = '1 0 0' + '0 1 0' * (2 * h - 0.5);
+ this.colormod = '1 0 0' + '0 1 0' * (2 * h - 0.5);
else
- self.colormod = '1 1 1';
+ this.colormod = '1 1 1';
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
}
-void func_breakable_look_destroyed()
-{SELFPARAM();
+void func_breakable_look_destroyed(entity this)
+{
float floorZ;
- if(self.solid == SOLID_BSP) // in case a misc_follow moved me, save the current origin first
- self.dropped_origin = self.origin;
+ if(this.solid == SOLID_BSP) // in case a misc_follow moved me, save the current origin first
+ this.dropped_origin = this.origin;
- if(self.mdl_dead == "")
- self.effects |= EF_NODRAW;
+ if(this.mdl_dead == "")
+ this.effects |= EF_NODRAW;
else {
- if (self.origin == '0 0 0') { // probably no origin brush, so don't spawn in the middle of the map..
- floorZ = self.absmin.z;
- setorigin(self,((self.absmax+self.absmin)*.5));
- self.origin_z = floorZ;
+ if (this.origin == '0 0 0') { // probably no origin brush, so don't spawn in the middle of the map..
+ floorZ = this.absmin.z;
+ setorigin(this,((this.absmax+this.absmin)*.5));
+ this.origin_z = floorZ;
}
- _setmodel(self, self.mdl_dead);
- self.effects &= ~EF_NODRAW;
+ _setmodel(this, this.mdl_dead);
+ this.effects &= ~EF_NODRAW;
}
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
- self.solid = SOLID_NOT;
+ this.solid = SOLID_NOT;
}
-void func_breakable_look_restore()
-{SELFPARAM();
- _setmodel(self, self.mdl);
- self.effects &= ~EF_NODRAW;
+void func_breakable_look_restore(entity this)
+{
+ _setmodel(this, this.mdl);
+ this.effects &= ~EF_NODRAW;
- if(self.mdl_dead != "") // only do this if we use mdl_dead, to behave better with misc_follow
- setorigin(self, self.dropped_origin);
+ if(this.mdl_dead != "") // only do this if we use mdl_dead, to behave better with misc_follow
+ setorigin(this, this.dropped_origin);
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
- self.solid = SOLID_BSP;
+ this.solid = SOLID_BSP;
}
-void func_breakable_behave_destroyed()
-{SELFPARAM();
- self.health = self.max_health;
- self.takedamage = DAMAGE_NO;
- self.bot_attack = false;
- self.event_damage = func_null;
- self.state = 1;
- if(self.spawnflags & 4)
- self.use = func_null;
- func_breakable_colormod();
- if (self.noise1)
- stopsound (self, CH_TRIGGER_SINGLE);
+void func_breakable_behave_destroyed(entity this)
+{
+ this.health = this.max_health;
+ this.takedamage = DAMAGE_NO;
+ this.bot_attack = false;
+ this.event_damage = func_null;
+ this.state = 1;
+ if(this.spawnflags & 4)
+ this.use = func_null;
+ func_breakable_colormod(this);
+ if (this.noise1)
+ stopsound (this, CH_TRIGGER_SINGLE);
}
-void func_breakable_behave_restore()
-{SELFPARAM();
- self.health = self.max_health;
- if(self.sprite)
+void func_breakable_behave_restore(entity this)
+{
+ this.health = this.max_health;
+ if(this.sprite)
{
- WaypointSprite_UpdateMaxHealth(self.sprite, self.max_health);
- WaypointSprite_UpdateHealth(self.sprite, self.health);
+ WaypointSprite_UpdateMaxHealth(this.sprite, this.max_health);
+ WaypointSprite_UpdateHealth(this.sprite, this.health);
}
- if(!(self.spawnflags & 4))
+ if(!(this.spawnflags & 4))
{
- self.takedamage = DAMAGE_AIM;
- self.bot_attack = true;
- self.event_damage = func_breakable_damage;
+ this.takedamage = DAMAGE_AIM;
+ this.bot_attack = true;
+ this.event_damage = func_breakable_damage;
}
- self.state = 0;
- self.nextthink = 0; // cancel auto respawn
- func_breakable_colormod();
- if (self.noise1)
- _sound (self, CH_TRIGGER_SINGLE, self.noise1, VOL_BASE, ATTEN_NORM);
+ this.state = 0;
+ this.nextthink = 0; // cancel auto respawn
+ func_breakable_colormod(this);
+ if (this.noise1)
+ _sound (this, CH_TRIGGER_SINGLE, this.noise1, VOL_BASE, ATTEN_NORM);
}
void func_breakable_init_for_player(entity player)
}
}
-void func_breakable_destroyed()
-{SELFPARAM();
- func_breakable_look_destroyed();
- func_breakable_behave_destroyed();
+void func_breakable_destroyed(entity this)
+{
+ func_breakable_look_destroyed(this);
+ func_breakable_behave_destroyed(this);
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
}
-void func_breakable_restore()
-{SELFPARAM();
- func_breakable_look_restore();
- func_breakable_behave_restore();
+void func_breakable_restore(entity this, entity actor, entity trigger)
+{
+ func_breakable_look_restore(this);
+ func_breakable_behave_restore(this);
- CSQCMODEL_AUTOUPDATE(self);
+ CSQCMODEL_AUTOUPDATE(this);
}
-vector debrisforce; // global, set before calling this
-void func_breakable_destroy()
+void func_breakable_restore_self()
{SELFPARAM();
+ func_breakable_restore(this, NULL, NULL);
+}
+
+vector debrisforce; // global, set before calling this
+void func_breakable_destroy(entity this, entity actor, entity trigger)
+{
float n, i;
string oldmsg;
- activator = self.owner;
- self.owner = world; // set by W_PrepareExplosionByDamage
+ entity act = this.owner;
+ this.owner = world; // set by W_PrepareExplosionByDamage
// now throw around the debris
- n = tokenize_console(self.debris);
+ n = tokenize_console(this.debris);
for(i = 0; i < n; ++i)
- LaunchDebris(argv(i), debrisforce);
+ LaunchDebris(this, argv(i), debrisforce);
- func_breakable_destroyed();
+ func_breakable_destroyed(this);
- if(self.noise)
- _sound (self, CH_TRIGGER, self.noise, VOL_BASE, ATTEN_NORM);
+ if(this.noise)
+ _sound (this, CH_TRIGGER, this.noise, VOL_BASE, ATTEN_NORM);
- if(self.dmg)
- RadiusDamage(self, activator, self.dmg, self.dmg_edge, self.dmg_radius, self, world, self.dmg_force, DEATH_HURTTRIGGER.m_id, world);
+ if(this.dmg)
+ RadiusDamage(this, act, this.dmg, this.dmg_edge, this.dmg_radius, this, world, this.dmg_force, DEATH_HURTTRIGGER.m_id, world);
- if(self.cnt) // TODO
- __pointparticles(self.cnt, self.absmin * 0.5 + self.absmax * 0.5, '0 0 0', self.count);
+ if(this.cnt) // TODO
+ __pointparticles(this.cnt, this.absmin * 0.5 + this.absmax * 0.5, '0 0 0', this.count);
- if(self.respawntime)
+ if(this.respawntime)
{
- self.think = func_breakable_restore;
- self.nextthink = time + self.respawntime + crandom() * self.respawntimejitter;
+ this.think = func_breakable_restore_self;
+ this.nextthink = time + this.respawntime + crandom() * this.respawntimejitter;
}
- oldmsg = self.message;
- self.message = "";
- SUB_UseTargets();
- self.message = oldmsg;
+ oldmsg = this.message;
+ this.message = "";
+ SUB_UseTargets(this, act, trigger);
+ this.message = oldmsg;
+}
+
+void func_breakable_destroy_self()
+{SELFPARAM();
+ func_breakable_destroy(this, NULL, NULL);
}
void func_breakable_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
WaypointSprite_Ping(this.sprite);
WaypointSprite_UpdateHealth(this.sprite, this.health);
}
- WITHSELF(this, func_breakable_colormod());
+ func_breakable_colormod(this);
if(this.health <= 0)
{
// do not explode NOW but in the NEXT FRAME!
// because recursive calls to RadiusDamage are not allowed
this.nextthink = time;
- this.think = func_breakable_destroy;
+ this.think = func_breakable_destroy_self;
}
}
void func_breakable_reset(entity this)
{
this.team = this.team_saved;
- func_breakable_look_restore();
+ func_breakable_look_restore(this);
if(this.spawnflags & 1)
- func_breakable_behave_destroyed();
+ func_breakable_behave_destroyed(this);
else
- func_breakable_behave_restore();
+ func_breakable_behave_restore(this);
CSQCMODEL_AUTOUPDATE(this);
}
self.state = STATE_TOP;
self.SUB_NEXTTHINK = self.SUB_LTIME + self.wait;
self.SUB_THINK = button_return;
- activator = self.enemy;
- SUB_UseTargets();
+ SUB_UseTargets(self, self.enemy, NULL);
self.frame = 1; // use alternate textures
}
self.takedamage = DAMAGE_YES; // can be shot again
}
-void button_use()
-{SELFPARAM();
- if(self.active != ACTIVE_ACTIVE)
+void button_use(entity this, entity actor, entity trigger)
+{
+ if(this.active != ACTIVE_ACTIVE)
return;
- self.enemy = activator;
- button_fire ();
+ this.enemy = actor;
+ WITHSELF(this, button_fire());
}
void button_touch()
#ifdef SVQC
-void conveyor_use()
-{SELFPARAM();
- self.state = !self.state;
+void conveyor_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
- self.SendFlags |= 2;
+ this.SendFlags |= 2;
}
void conveyor_reset(entity this)
string oldmessage;
oldmessage = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, NULL, NULL);
self.message = oldmessage;
}
return false;
}
-void door_fire()
-{SELFPARAM();
- entity starte;
-
- if (self.owner != self)
- objerror ("door_fire: self.owner != self");
+void door_fire(entity this, entity actor, entity trigger)
+{
+ entity starte;
+ if (this.owner != this)
+ objerror ("door_fire: this.owner != this");
- if (self.spawnflags & DOOR_TOGGLE)
+ if (this.spawnflags & DOOR_TOGGLE)
{
- if (self.state == STATE_UP || self.state == STATE_TOP)
+ if (this.state == STATE_UP || this.state == STATE_TOP)
{
starte = self;
do
setself(this);
}
-void door_use()
-{SELFPARAM();
+void door_use(entity this, entity actor, entity trigger)
+{
//dprint("door_use (model: ");dprint(self.model);dprint(")\n");
- if (self.owner)
- {
- WITHSELF(self.owner, door_fire());
- }
+ if (this.owner)
+ WITHSELF(this.owner, door_fire(this.owner, actor, trigger));
}
void door_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
this.owner.health = this.owner.max_health;
this.owner.takedamage = DAMAGE_NO; // wil be reset upon return
- WITHSELF(this.owner, door_use());
+ door_use(this.owner, NULL, NULL);
}
}
string oldmessage;
oldmessage = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, NULL, other); // TODO: is other needed here?
self.message = oldmessage;
}
self.door_finished = time + 1;
- activator = other;
-
- setself(self.owner);
- door_use ();
+ door_use(this.owner, other, NULL);
}
void door_spawnfield(vector fmins, vector fmaxs)
const float SECRET_NO_SHOOT = 8; // only opened by trigger
const float SECRET_YES_SHOOT = 16; // shootable even if targeted
-void fd_secret_use()
-{SELFPARAM();
+void fd_secret_use(entity this, entity actor, entity trigger)
+{
float temp;
string message_save;
- self.health = 10000;
- self.bot_attack = true;
+ this.health = 10000;
+ this.bot_attack = true;
// exit if still moving around...
- if (self.origin != self.oldorigin)
+ if (this.origin != this.oldorigin)
return;
- message_save = self.message;
- self.message = ""; // no more message
- SUB_UseTargets(); // fire all targets / killtargets
- self.message = message_save;
+ message_save = this.message;
+ this.message = ""; // no more message
+ SUB_UseTargets(this, actor, trigger); // fire all targets / killtargets
+ this.message = message_save;
- self.velocity = '0 0 0';
+ this.velocity = '0 0 0';
// Make a sound, wait a little...
- if (self.noise1 != "")
- _sound(self, CH_TRIGGER_SINGLE, self.noise1, VOL_BASE, ATTEN_NORM);
- self.SUB_NEXTTHINK = self.SUB_LTIME + 0.1;
+ if (this.noise1 != "")
+ _sound(this, CH_TRIGGER_SINGLE, this.noise1, VOL_BASE, ATTEN_NORM);
+ this.SUB_NEXTTHINK = this.SUB_LTIME + 0.1;
- temp = 1 - (self.spawnflags & SECRET_1ST_LEFT); // 1 or -1
- makevectors(self.mangle);
+ temp = 1 - (this.spawnflags & SECRET_1ST_LEFT); // 1 or -1
+ makevectors(this.mangle);
- if (!self.t_width)
+ if (!this.t_width)
{
- if (self.spawnflags & SECRET_1ST_DOWN)
- self.t_width = fabs(v_up * self.size);
+ if (this.spawnflags & SECRET_1ST_DOWN)
+ this.t_width = fabs(v_up * this.size);
else
- self.t_width = fabs(v_right * self.size);
+ this.t_width = fabs(v_right * this.size);
}
- if (!self.t_length)
- self.t_length = fabs(v_forward * self.size);
+ if (!this.t_length)
+ this.t_length = fabs(v_forward * this.size);
- if (self.spawnflags & SECRET_1ST_DOWN)
- self.dest1 = self.origin - v_up * self.t_width;
+ if (this.spawnflags & SECRET_1ST_DOWN)
+ this.dest1 = this.origin - v_up * this.t_width;
else
- self.dest1 = self.origin + v_right * (self.t_width * temp);
+ this.dest1 = this.origin + v_right * (this.t_width * temp);
- self.dest2 = self.dest1 + v_forward * self.t_length;
- SUB_CalcMove(self.dest1, TSPEED_LINEAR, self.speed, fd_secret_move1);
- if (self.noise2 != "")
- _sound(self, CH_TRIGGER_SINGLE, self.noise2, VOL_BASE, ATTEN_NORM);
+ this.dest2 = this.dest1 + v_forward * this.t_length;
+ WITHSELF(this, SUB_CalcMove(this.dest1, TSPEED_LINEAR, this.speed, fd_secret_move1));
+ if (this.noise2 != "")
+ _sound(this, CH_TRIGGER_SINGLE, this.noise2, VOL_BASE, ATTEN_NORM);
}
void fd_secret_damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
- WITHSELF(this, fd_secret_use());
+ fd_secret_use(this, NULL, NULL);
}
// Wait after first movement...
return 1;
}
-void pointparticles_use()
-{SELFPARAM();
- self.state = !self.state;
- self.SendFlags |= 2;
+void pointparticles_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
+ this.SendFlags |= 2;
}
void pointparticles_think()
#ifdef SVQC
-void func_rotating_setactive(float astate)
-{SELFPARAM();
-
+void func_rotating_setactive(entity this, int astate)
+{
if (astate == ACTIVE_TOGGLE)
{
- if(self.active == ACTIVE_ACTIVE)
- self.active = ACTIVE_NOT;
+ if(this.active == ACTIVE_ACTIVE)
+ this.active = ACTIVE_NOT;
else
- self.active = ACTIVE_ACTIVE;
+ this.active = ACTIVE_ACTIVE;
}
else
- self.active = astate;
+ this.active = astate;
- if(self.active == ACTIVE_NOT)
- self.avelocity = '0 0 0';
+ if(this.active == ACTIVE_NOT)
+ this.avelocity = '0 0 0';
else
- self.avelocity = self.pos1;
+ this.avelocity = this.pos1;
}
/*QUAKED spawnfunc_func_rotating (0 .5 .8) ? - - X_AXIS Y_AXIS
.float train_wait_turning;
void() train_next;
#ifdef SVQC
-void train_use();
+void train_use(entity this, entity actor, entity trigger);
#endif
void train_wait()
{SELFPARAM();
- WITHSELF(self.enemy, SUB_UseTargets());
+ SUB_UseTargets(this.enemy, NULL, NULL);
self.enemy = world;
// if turning is enabled, the train will turn toward the next point while waiting
//Net_LinkEntity(self, 0, false, train_send);
}
-void train_use()
+void train_use(entity this, entity actor, entity trigger)
{
- SELFPARAM();
- self.SUB_NEXTTHINK = self.SUB_LTIME + 1;
- self.SUB_THINK = train_next;
- self.use = func_null; // not again
+ this.SUB_NEXTTHINK = this.SUB_LTIME + 1;
+ this.SUB_THINK = train_next;
+ this.use = func_null; // not again
}
void func_train_find(entity this)
#ifdef SVQC
.float modelscale;
-void misc_laser_aim()
-{SELFPARAM();
+void misc_laser_aim(entity this)
+{
vector a;
- if(self.enemy)
+ if(this.enemy)
{
- if(self.spawnflags & 2)
+ if(this.spawnflags & 2)
{
- if(self.enemy.origin != self.mangle)
+ if(this.enemy.origin != this.mangle)
{
- self.mangle = self.enemy.origin;
- self.SendFlags |= 2;
+ this.mangle = this.enemy.origin;
+ this.SendFlags |= 2;
}
}
else
{
- a = vectoangles(self.enemy.origin - self.origin);
+ a = vectoangles(this.enemy.origin - this.origin);
a_x = -a_x;
- if(a != self.mangle)
+ if(a != this.mangle)
{
- self.mangle = a;
- self.SendFlags |= 2;
+ this.mangle = a;
+ this.SendFlags |= 2;
}
}
}
else
{
- if(self.angles != self.mangle)
+ if(this.angles != this.mangle)
{
- self.mangle = self.angles;
- self.SendFlags |= 2;
+ this.mangle = this.angles;
+ this.SendFlags |= 2;
}
}
- if(self.origin != self.oldorigin)
+ if(this.origin != this.oldorigin)
{
- self.SendFlags |= 1;
- self.oldorigin = self.origin;
+ this.SendFlags |= 1;
+ this.oldorigin = this.origin;
}
}
if(!self.state)
return;
- misc_laser_aim();
+ misc_laser_aim(this);
if(self.enemy)
{
{
self.count = 1;
- activator = self.enemy.pusher;
- WITHSELF(self.enemy, SUB_UseTargets());
+ SUB_UseTargets(self.enemy, self.enemy.pusher, NULL);
}
}
else
{
self.count = 0;
- activator = self.enemy.pusher;
- WITHSELF(self.enemy, SUB_UseTargets());
+ SUB_UseTargets(self.enemy, self.enemy.pusher, NULL);
}
}
}
"dmg"
damage per second (-1 for a laser that kills immediately)
*/
-void laser_use()
-{SELFPARAM();
- self.state = !self.state;
- self.SendFlags |= 4;
- misc_laser_aim();
+void laser_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
+ this.SendFlags |= 4;
+ misc_laser_aim(this);
}
void laser_reset(entity this)
plat_go_down ();
}
-void plat_trigger_use()
-{SELFPARAM();
+void plat_trigger_use(entity this, entity actor, entity trigger)
+{
#ifdef SVQC
- if (self.think)
+ if (this.think)
return; // already activated
#elif defined(CSQC)
- if(self.move_think)
+ if(this.move_think)
return;
#endif
- plat_go_down();
+ WITHSELF(this, plat_go_down());
}
}
}
-void plat_use()
-{SELFPARAM();
- self.use = func_null;
- if (self.state != 4)
+void plat_use(entity this, entity actor, entity trigger)
+{
+ this.use = func_null;
+ if (this.state != 4)
objerror ("plat_use: not in up state");
- plat_go_down();
+ WITHSELF(this, plat_go_down());
}
.string sound1, sound2;
void() plat_center_touch;
void() plat_outside_touch;
-void() plat_trigger_use;
+void plat_trigger_use(entity this, entity actor, entity trigger);
void() plat_go_up;
void() plat_go_down;
void() plat_crush;
void() SUB_CalcMoveDone;
void() SUB_CalcAngleMoveDone;
-//void() SUB_UseTargets;
/*
==================
#endif
+
void SUB_SetFade (entity ent, float when, float fading_time);
void SUB_VanishOrRemove (entity ent);
.string platmovetype;
.float platmovetype_start, platmovetype_end;
-entity activator;
+//entity activator;
.string killtarget;
.string chmap, gametype;
.entity chlevel_targ;
-
-void target_changelevel_use()
+void target_changelevel_use(entity this, entity actor, entity trigger)
{
- SELFPARAM();
- if(self.spawnflags & 2)
+ if(this.spawnflags & 2)
{
// simply don't react if a non-player triggers it
- if(!IS_PLAYER(activator)) { return; }
+ if(!IS_PLAYER(actor)) { return; }
- activator.chlevel_targ = self;
+ actor.chlevel_targ = this;
int plnum = 0;
int realplnum = 0;
// let's not count bots
FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), {
++realplnum;
- if(it.chlevel_targ == self)
+ if(it.chlevel_targ == this)
++plnum;
});
- if(plnum < ceil(realplnum * min(1, self.count))) // 70% of players
+ if(plnum < ceil(realplnum * min(1, this.count))) // 70% of players
return;
}
- if(self.gametype != "")
- MapInfo_SwitchGameType(MapInfo_Type_FromString(self.gametype));
+ if(this.gametype != "")
+ MapInfo_SwitchGameType(MapInfo_Type_FromString(this.gametype));
- if (self.chmap == "")
+ if (this.chmap == "")
localcmd("endmatch\n");
else
- localcmd(strcat("changelevel ", self.chmap, "\n"));
+ localcmd(strcat("changelevel ", this.chmap, "\n"));
}
spawnfunc(target_changelevel)
{
- self.use = target_changelevel_use;
+ this.use = target_changelevel_use;
- if(!self.count) { self.count = 0.7; }
+ if(!this.count) { this.count = 0.7; }
}
#endif
WITHSELF(it, target_music_sendto(MSG_ALL, 0));
});
}
-void target_music_use()
+void target_music_use(entity this, entity actor, entity trigger)
{
- if(!activator)
+ if(!actor)
return;
- if(IS_REAL_CLIENT(activator))
+ if(IS_REAL_CLIENT(actor))
{
- msg_entity = activator;
+ msg_entity = actor;
target_music_sendto(MSG_ONE, 1);
}
- FOREACH_CLIENT(IS_SPEC(it) && it.enemy == activator, {
+ FOREACH_CLIENT(IS_SPEC(it) && it.enemy == actor, {
msg_entity = it;
target_music_sendto(MSG_ONE, 1);
});
this.cnt = !(this.spawnflags & 1);
this.SendFlags |= 0x80;
}
-void trigger_music_use()
-{SELFPARAM();
- self.cnt = !self.cnt;
- self.SendFlags |= 0x80;
+void trigger_music_use(entity this, entity actor, entity trigger)
+{
+ this.cnt = !this.cnt;
+ this.SendFlags |= 0x80;
}
spawnfunc(trigger_music)
{
setsize(self, self.mins, self.maxs);
}
-void target_spawn_edit_entity(entity e, string msg, entity kt, entity t2, entity t3, entity t4, entity act)
-{SELFPARAM();
+void target_spawn_edit_entity(entity this, entity e, string msg, entity kt, entity t2, entity t3, entity t4, entity act, entity trigger)
+{
float i, n, valuefieldpos;
string key, value, valuefield, valueoffset, valueoffsetrandom;
entity valueent;
vector data, data2;
- entity oldactivator;
n = tokenize_console(msg);
if(value == "self")
{
- valueent = self;
+ valueent = this;
value = "";
}
else if(value == "activator")
}
else if(value == "other")
{
- valueent = other;
+ valueent = trigger;
value = "";
}
else if(value == "pusher")
value = strcat("target_spawn_helper", value);
putentityfieldstring(target_spawn_spawnfunc_field, e, value);
- oldactivator = activator;
-
- activator = act;
WITHSELF(e, e.target_spawn_spawnfunc(e));
- activator = oldactivator;
// We called an external function, so we have to re-tokenize msg.
n = tokenize_console(msg);
}
}
-void target_spawn_useon(entity e)
-{SELFPARAM();
- self.target_spawn_activator = activator;
+void target_spawn_useon(entity e, entity this, entity actor, entity trigger)
+{
+ this.target_spawn_activator = actor;
target_spawn_edit_entity(
+ this,
e,
- self.message,
- find(world, targetname, self.killtarget),
- find(world, targetname, self.target2),
- find(world, targetname, self.target3),
- find(world, targetname, self.target4),
- activator
+ this.message,
+ find(world, targetname, this.killtarget),
+ find(world, targetname, this.target2),
+ find(world, targetname, this.target3),
+ find(world, targetname, this.target4),
+ actor,
+ trigger
);
}
-float target_spawn_cancreate()
-{SELFPARAM();
+bool target_spawn_cancreate(entity this)
+{
float c;
entity e;
- c = self.count;
+ c = this.count;
if(c == 0) // no limit?
- return 1;
+ return true;
++c; // increase count to not include MYSELF
- for(e = world; (e = findfloat(e, target_spawn_id, self.target_spawn_id)); --c)
+ for(e = world; (e = findfloat(e, target_spawn_id, this.target_spawn_id)); --c)
;
// if c now is 0, we have AT LEAST the given count (maybe more), so don't spawn any more
if(c == 0)
- return 0;
- return 1;
+ return false;
+ return true;
}
-void target_spawn_use()
-{SELFPARAM();
- entity e;
-
- if(self.target == "")
+void target_spawn_use(entity this, entity actor, entity trigger)
+{
+ if(this.target == "")
{
// spawn new entity
- if(!target_spawn_cancreate())
+ if(!target_spawn_cancreate(this))
return;
- e = spawn();
+ entity e = spawn();
e.spawnfunc_checked = true;
- target_spawn_useon(e);
- e.target_spawn_id = self.target_spawn_id;
+ target_spawn_useon(e, this, actor, trigger);
+ e.target_spawn_id = this.target_spawn_id;
}
- else if(self.target == "*activator")
+ else if(this.target == "*activator")
{
// edit entity
- if(activator)
- target_spawn_useon(activator);
+ if(actor)
+ target_spawn_useon(actor, this, actor, trigger);
}
else
{
// edit entity
- for(e = world; (e = find(e, targetname, self.target)); )
- target_spawn_useon(e);
+ for(entity e = world; (e = find(e, targetname, this.target)); )
+ target_spawn_useon(e, this, actor, trigger);
}
}
void target_spawn_spawnfirst(entity this)
{
- activator = self.target_spawn_activator;
- if(self.spawnflags & 2)
- target_spawn_use();
+ entity act = this.target_spawn_activator;
+ if(this.spawnflags & 2)
+ target_spawn_use(this, act, NULL);
}
void initialize_field_db()
#ifdef SVQC
// TODO add a way to do looped sounds with sound(); then complete this entity
-void target_speaker_use_off();
-void target_speaker_use_activator()
-{SELFPARAM();
- if (!IS_REAL_CLIENT(activator))
+void target_speaker_use_off(entity this, entity actor, entity trigger);
+void target_speaker_use_activator(entity this, entity actor, entity trigger)
+{
+ if (!IS_REAL_CLIENT(actor))
return;
string snd;
- if(substring(self.noise, 0, 1) == "*")
+ if(substring(this.noise, 0, 1) == "*")
{
- var .string sample = GetVoiceMessageSampleField(substring(self.noise, 1, -1));
+ var .string sample = GetVoiceMessageSampleField(substring(this.noise, 1, -1));
if(GetPlayerSoundSampleField_notFound)
snd = SND(Null);
- else if(activator.(sample) == "")
+ else if(actor.(sample) == "")
snd = SND(Null);
else
{
- tokenize_console(activator.(sample));
+ tokenize_console(actor.(sample));
float n;
n = stof(argv(1));
if(n > 0)
}
}
else
- snd = self.noise;
- msg_entity = activator;
- soundto(MSG_ONE, self, CH_TRIGGER, snd, VOL_BASE * self.volume, self.atten);
+ snd = this.noise;
+ msg_entity = actor;
+ soundto(MSG_ONE, this, CH_TRIGGER, snd, VOL_BASE * this.volume, this.atten);
}
-void target_speaker_use_on()
-{SELFPARAM();
+void target_speaker_use_on(entity this, entity actor, entity trigger)
+{
string snd;
- if(substring(self.noise, 0, 1) == "*")
+ if(substring(this.noise, 0, 1) == "*")
{
- var .string sample = GetVoiceMessageSampleField(substring(self.noise, 1, -1));
+ var .string sample = GetVoiceMessageSampleField(substring(this.noise, 1, -1));
if(GetPlayerSoundSampleField_notFound)
snd = SND(Null);
- else if(activator.(sample) == "")
+ else if(actor.(sample) == "")
snd = SND(Null);
else
{
- tokenize_console(activator.(sample));
+ tokenize_console(actor.(sample));
float n;
n = stof(argv(1));
if(n > 0)
}
}
else
- snd = self.noise;
- _sound(self, CH_TRIGGER_SINGLE, snd, VOL_BASE * self.volume, self.atten);
- if(self.spawnflags & 3)
- self.use = target_speaker_use_off;
+ snd = this.noise;
+ _sound(this, CH_TRIGGER_SINGLE, snd, VOL_BASE * this.volume, this.atten);
+ if(this.spawnflags & 3)
+ this.use = target_speaker_use_off;
}
-void target_speaker_use_off()
-{SELFPARAM();
- sound(self, CH_TRIGGER_SINGLE, SND_Null, VOL_BASE * self.volume, self.atten);
- self.use = target_speaker_use_on;
+void target_speaker_use_off(entity this, entity actor, entity trigger)
+{
+ sound(this, CH_TRIGGER_SINGLE, SND_Null, VOL_BASE * this.volume, this.atten);
+ this.use = target_speaker_use_on;
}
void target_speaker_reset(entity this)
{
if(this.spawnflags & 1) // LOOPED_ON
{
if(this.use == target_speaker_use_on)
- target_speaker_use_on();
+ target_speaker_use_on(this, NULL, NULL);
}
else if(this.spawnflags & 2)
{
if(this.use == target_speaker_use_off)
- target_speaker_use_off();
+ target_speaker_use_off(this, NULL, NULL);
}
}
self.use = target_speaker_use_activator;
else if(self.spawnflags & 1) // LOOPED_ON
{
- target_speaker_use_on();
+ target_speaker_use_on(self, NULL, NULL);
self.reset = target_speaker_reset;
}
else if(self.spawnflags & 2) // LOOPED_OFF
pl.voicescript = world;
}
-void target_voicescript_use()
-{SELFPARAM();
- if(activator.voicescript != self)
+void target_voicescript_use(entity this, entity actor, entity trigger)
+{
+ if(actor.voicescript != this)
{
- activator.voicescript = self;
- activator.voicescript_index = 0;
- activator.voicescript_nextthink = time + self.delay;
+ actor.voicescript = this;
+ actor.voicescript_index = 0;
+ actor.voicescript_nextthink = time + this.delay;
}
}
#ifdef SVQC
-void trigger_teleport_use();
+void trigger_teleport_use(entity this, entity actor, entity trigger);
#define TDEATHLOOP(o) \
entity head; \
#ifdef SVQC
-void counter_use()
-{SELFPARAM();
- self.count -= 1;
- if (self.count < 0)
+void counter_use(entity this, entity actor, entity trigger)
+{
+ this.count -= 1;
+ if (this.count < 0)
return;
- if (self.count == 0)
+ if (this.count == 0)
{
- if(IS_PLAYER(activator) && (self.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
- Send_Notification(NOTIF_ONE, activator, MSG_CENTER, CENTER_SEQUENCE_COMPLETED);
+ if(IS_PLAYER(actor) && (this.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
+ Send_Notification(NOTIF_ONE, actor, MSG_CENTER, CENTER_SEQUENCE_COMPLETED);
- self.enemy = activator;
- multi_trigger ();
+ this.enemy = actor;
+ WITHSELF(this, multi_trigger ());
}
else
{
- if(IS_PLAYER(activator) && (self.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
- if(self.count >= 4)
- Send_Notification(NOTIF_ONE, activator, MSG_CENTER, CENTER_SEQUENCE_COUNTER);
+ if(IS_PLAYER(actor) && (this.spawnflags & SPAWNFLAG_NOMESSAGE) == 0)
+ if(this.count >= 4)
+ Send_Notification(NOTIF_ONE, actor, MSG_CENTER, CENTER_SEQUENCE_COUNTER);
else
- Send_Notification(NOTIF_ONE, activator, MSG_CENTER, CENTER_SEQUENCE_COUNTER_FEWMORE, self.count);
+ Send_Notification(NOTIF_ONE, actor, MSG_CENTER, CENTER_SEQUENCE_COUNTER_FEWMORE, this.count);
}
}
#ifdef SVQC
-void delay_use()
-{SELFPARAM();
- self.think = SUB_UseTargets;
- self.nextthink = self.wait;
+void delay_use(entity this, entity actor, entity trigger)
+{
+ this.think = SUB_UseTargets_self;
+ this.nextthink = this.wait;
}
void delay_reset(entity this)
#ifdef SVQC
-void trigger_disablerelay_use()
-{SELFPARAM();
- entity e;
-
- float a, b;
- a = b = 0;
+void trigger_disablerelay_use(entity this, entity actor, entity trigger)
+{
+ int a = 0, b = 0;
- for(e = world; (e = find(e, targetname, self.target)); )
+ for(entity e = world; (e = find(e, targetname, this.target)); )
{
if(e.use == SUB_UseTargets)
{
spawnfunc(trigger_disablerelay)
{
- self.use = trigger_disablerelay_use;
+ this.use = trigger_disablerelay_use;
}
#endif
/*QUAKED spawnfunc_trigger_flipflop (.5 .5 .5) (-8 -8 -8) (8 8 8) START_ENABLED
"Flip-flop" trigger gate... lets only every second trigger event through
*/
-void flipflop_use()
-{SELFPARAM();
- self.state = !self.state;
- if(self.state)
- SUB_UseTargets();
+void flipflop_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
+ if(this.state)
+ SUB_UseTargets(this, actor, trigger);
}
spawnfunc(trigger_flipflop)
#ifdef SVQC
-void gamestart_use(entity this)
+void gamestart_use(entity this, entity actor, entity trigger)
{
- activator = self;
- SUB_UseTargets();
- remove(self);
+ SUB_UseTargets(this, this, trigger);
+ remove(this);
+}
+
+void gamestart_use_this(entity this)
+{
+ gamestart_use(this, NULL, NULL);
}
void self_spawnfunc_trigger_gamestart();
spawnfunc(trigger_gamestart)
{
- setuse(this, gamestart_use);
+ this.use = gamestart_use;
this.reset2 = self_spawnfunc_trigger_gamestart;
if(this.wait)
{
- this.think = this.use;
+ this.think = adaptor_think2use;
this.nextthink = game_starttime + this.wait;
}
else
- InitializeEntity(this, gamestart_use, INITPRIO_FINDTARGET);
+ InitializeEntity(this, gamestart_use_this, INITPRIO_FINDTARGET);
}
void self_spawnfunc_trigger_gamestart() { SELFPARAM(); spawnfunc_trigger_gamestart(this); }
}
}
-void trigger_gravity_use()
-{SELFPARAM();
- self.state = !self.state;
+void trigger_gravity_use(entity this, entity actor, entity trigger)
+{
+ this.state = !this.state;
}
void trigger_gravity_touch()
#ifdef SVQC
-void trigger_hurt_use()
-{SELFPARAM();
- if(IS_PLAYER(activator))
- self.enemy = activator;
+void trigger_hurt_use(entity this, entity actor, entity trigger)
+{
+ if(IS_PLAYER(actor))
+ this.enemy = actor;
else
- self.enemy = world; // let's just destroy it, if taking over is too much work
+ this.enemy = world; // let's just destroy it, if taking over is too much work
}
.float triggerhurttime;
#include "jumppads.qh"
#include <common/physics/movetypes/movetypes.qh>
-void trigger_push_use()
-{SELFPARAM();
+void trigger_push_use(entity this, entity actor, entity trigger)
+{
if(teamplay)
{
- self.team = activator.team;
- self.SendFlags |= 2;
+ this.team = actor.team;
+ this.SendFlags |= 2;
}
}
#endif
}
if(this.enemy.target)
- {
- activator = other;
- WITHSELF(this.enemy, SUB_UseTargets());
- }
+ SUB_UseTargets(this.enemy, other, other); // TODO: do we need other as trigger too?
if (other.flags & FL_PROJECTILE)
{
float trigger_push_calculatevelocity_flighttime;
#ifdef SVQC
-void() SUB_UseTargets;
-void trigger_push_use();
+void SUB_UseTargets(entity this, entity actor, entity trigger);
+void trigger_push_use(entity this, entity actor, entity trigger);
#endif
/*
/**
* trigger given targets
*/
-void trigger_keylock_trigger(string s)
-{SELFPARAM();
- entity otemp = other;
- entity atemp = activator;
-
- entity t;
- for(t = world; (t = find(t, targetname, s)); )
+void trigger_keylock_trigger(entity this, entity actor, string s)
+{
+ for(entity t = world; (t = find(t, targetname, s)); )
if(t.use)
- {
- setself(t);
- other = this;
- activator = atemp;
- self.use();
- }
-
- setself(this);
- other = otemp;
- activator = atemp;
+ t.use(t, actor, this);
}
/**
if(self.itemkeys)
key_used = item_keys_usekey(self, other);
- activator = other;
-
if(self.itemkeys)
{
#ifdef SVQC
if(self.delay <= time || started_delay == true)
if(self.target2)
{
- trigger_keylock_trigger(self.target2);
+ trigger_keylock_trigger(this, other, self.target2);
started_delay = true;
self.delay = time + self.wait;
}
#endif
if(self.target)
- trigger_keylock_trigger(self.target);
+ trigger_keylock_trigger(this, other, self.target);
if(self.killtarget)
trigger_keylock_kill(self.killtarget);
if(dotrigger)
{
- activator = source;
- setself(ear);
savemessage = self.message;
self.message = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(ear, source, NULL);
self.message = savemessage;
- setself(this);
}
if(ear.netname != "")
if(dotrigger)
{
- activator = source;
- setself(ear);
savemessage = self.message;
self.message = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(ear, source, NULL);
self.message = savemessage;
- setself(this);
}
if(ear.spawnflags & 16)
/*QUAKED spawnfunc_trigger_monoflop (.5 .5 .5) (-8 -8 -8) (8 8 8)
"Mono-flop" trigger gate... turns one trigger event into one "on" and one "off" event, separated by a delay of "wait"
*/
-void monoflop_use()
-{SELFPARAM();
- self.nextthink = time + self.wait;
- self.enemy = activator;
- if(self.state)
+void monoflop_use(entity this, entity actor, entity trigger)
+{
+ this.nextthink = time + this.wait;
+ this.enemy = actor;
+ if(this.state)
return;
- self.state = 1;
- SUB_UseTargets();
+ this.state = 1;
+ SUB_UseTargets(this, actor, trigger);
}
-void monoflop_fixed_use()
-{SELFPARAM();
- if(self.state)
+void monoflop_fixed_use(entity this, entity actor, entity trigger)
+{
+ if(this.state)
return;
- self.nextthink = time + self.wait;
- self.state = 1;
- self.enemy = activator;
- SUB_UseTargets();
+ this.nextthink = time + this.wait;
+ this.state = 1;
+ this.enemy = actor;
+ SUB_UseTargets(this, actor, trigger);
}
void monoflop_think()
{SELFPARAM();
- self.state = 0;
- activator = self.enemy;
- SUB_UseTargets();
+ this.state = 0;
+ SUB_UseTargets(this, this.enemy, NULL);
}
void monoflop_reset(entity this)
spawnfunc(trigger_monoflop)
{
- if(!self.wait)
- self.wait = 1;
- if(self.spawnflags & 1)
- self.use = monoflop_fixed_use;
+ if(!this.wait)
+ this.wait = 1;
+ if(this.spawnflags & 1)
+ this.use = monoflop_fixed_use;
else
- self.use = monoflop_use;
- self.think = monoflop_think;
- self.state = 0;
- self.reset = monoflop_reset;
+ this.use = monoflop_use;
+ this.think = monoflop_think;
+ this.state = 0;
+ this.reset = monoflop_reset;
}
#endif
// don't trigger again until reset
self.takedamage = DAMAGE_NO;
- activator = self.enemy;
- other = self.goalentity;
- SUB_UseTargets();
+ SUB_UseTargets(self, self.enemy, self.goalentity);
if (self.wait > 0)
{
}
}
-void multi_use()
-{SELFPARAM();
- self.goalentity = other;
- self.enemy = activator;
- multi_trigger();
+void multi_use(entity this, entity actor, entity trigger)
+{
+ this.goalentity = trigger;
+ this.enemy = actor;
+ WITHSELF(this, multi_trigger());
}
void multi_touch()
newstate = (time < cyclestart + self.wait);
- activator = self;
if(self.state != newstate)
- SUB_UseTargets();
+ SUB_UseTargets(self, self, NULL);
self.state = newstate;
if(self.state)
self.nextthink = cyclestart + self.wait + self.respawntime + 0.01;
}
-void multivibrator_toggle()
-{SELFPARAM();
- if(self.nextthink == 0)
+void multivibrator_toggle(entity this, entity actor, entity trigger)
+{
+ if(this.nextthink == 0)
{
- multivibrator_send();
+ WITHSELF(this, multivibrator_send());
}
else
{
- if(self.state)
+ if(this.state)
{
- SUB_UseTargets();
- self.state = 0;
+ SUB_UseTargets(this, actor, trigger);
+ this.state = 0;
}
- self.nextthink = 0;
+ this.nextthink = 0;
}
}
#ifdef SVQC
-void relay_activators_use()
-{SELFPARAM();
+void relay_activators_use(entity this, entity actor, entity trigger)
+{
for(entity trg = world; (trg = find(trg, targetname, this.target)); )
{
- setself(trg);
if (trg.setactive)
- trg.setactive(this.cnt);
+ trg.setactive(trg, this.cnt);
else
{
//bprint("Not using setactive\n");
trg.active = this.cnt;
}
}
- setself(this);
}
spawnfunc(relay_activate)
{
- self.cnt = ACTIVE_ACTIVE;
- self.use = relay_activators_use;
+ this.cnt = ACTIVE_ACTIVE;
+ this.use = relay_activators_use;
}
spawnfunc(relay_deactivate)
{
- self.cnt = ACTIVE_NOT;
- self.use = relay_activators_use;
+ this.cnt = ACTIVE_NOT;
+ this.use = relay_activators_use;
}
spawnfunc(relay_activatetoggle)
{
- self.cnt = ACTIVE_TOGGLE;
- self.use = relay_activators_use;
+ this.cnt = ACTIVE_TOGGLE;
+ this.use = relay_activators_use;
}
#endif
#ifdef SVQC
-void trigger_relay_if_use()
-{SELFPARAM();
- float n;
- n = self.count;
+void trigger_relay_if_use(entity this, entity actor, entity trigger)
+{
+ int n = this.count;
// TODO make this generic AND faster than nextent()ing through all, if somehow possible
- n = (cvar_string(self.netname) == cvar_string(self.message));
- if(self.spawnflags & 1)
+ n = (cvar_string(this.netname) == cvar_string(this.message));
+ if(this.spawnflags & 1)
n = !n;
if(n)
- SUB_UseTargets();
+ SUB_UseTargets(this, actor, trigger);
}
spawnfunc(trigger_relay_if)
{
- self.use = trigger_relay_if_use;
+ this.use = trigger_relay_if_use;
}
#endif
#ifdef SVQC
-void trigger_relay_teamcheck_use()
-{SELFPARAM();
- if(activator.team)
+void trigger_relay_teamcheck_use(entity this, entity actor, entity trigger)
+{
+ if(actor.team)
{
- if(self.spawnflags & 2)
+ if(this.spawnflags & 2)
{
- if(DIFF_TEAM(activator, self))
- SUB_UseTargets();
+ if(DIFF_TEAM(actor, this))
+ SUB_UseTargets(this, actor, trigger);
}
else
{
- if(SAME_TEAM(activator, self))
- SUB_UseTargets();
+ if(SAME_TEAM(actor, this))
+ SUB_UseTargets(this, actor, trigger);
}
}
else
{
- if(self.spawnflags & 1)
- SUB_UseTargets();
+ if(this.spawnflags & 1)
+ SUB_UseTargets(this, actor, trigger);
}
}
REGISTER_NET_LINKED(ENT_CLIENT_TRIGGER_TELEPORT)
#ifdef SVQC
-void trigger_teleport_use()
-{SELFPARAM();
+void trigger_teleport_use(entity this, entity actor, entity trigger)
+{
if(teamplay)
- self.team = activator.team;
+ this.team = actor.team;
#ifdef SVQC
- self.SendFlags |= SF_TRIGGER_UPDATE;
+ this.SendFlags |= SF_TRIGGER_UPDATE;
#endif
}
#endif
e = Simple_TeleportPlayer(self, other);
#ifdef SVQC
- activator = other;
string s = self.target; self.target = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for trigger too?
if (!self.target) self.target = s;
- WITHSELF(e, SUB_UseTargets());
+ SUB_UseTargets(e, other, other);
#endif
}
-void SUB_DontUseTargets() { }
+void SUB_DontUseTargets(entity this, entity actor, entity trigger) { }
-void() SUB_UseTargets;
+void SUB_UseTargets(entity this, entity actor, entity trigger);
void DelayThink()
{SELFPARAM();
- activator = this.enemy;
- SUB_UseTargets ();
+ SUB_UseTargets (this, this.enemy, NULL);
remove(this);
}
==============================
*/
-void SUB_UseTargets()
-{SELFPARAM();
- entity t, otemp, act;
- string s;
- float i;
-
+void SUB_UseTargets(entity this, entity actor, entity trigger)
+{
//
// check for a delay
//
if (this.delay)
{
// create a temp object to fire at a later time
- t = new(DelayedUse);
+ entity t = new(DelayedUse);
t.nextthink = time + this.delay;
t.think = DelayThink;
- t.enemy = activator;
+ t.enemy = actor;
t.message = this.message;
t.killtarget = this.killtarget;
t.target = this.target;
return;
}
+ string s;
//
// print the message
//
#ifdef SVQC
if(this)
- if(IS_PLAYER(activator) && this.message != "")
- if(IS_REAL_CLIENT(activator))
+ if(IS_PLAYER(actor) && this.message != "")
+ if(IS_REAL_CLIENT(actor))
{
- centerprint(activator, this.message);
+ centerprint(actor, this.message);
if (this.noise == "")
- play2(activator, SND(TALK));
+ play2(actor, SND(TALK));
}
//
s = this.killtarget;
if (s != "")
{
- for(t = world; (t = find(t, targetname, s)); )
+ for(entity t = world; (t = find(t, targetname, s)); )
remove(t);
}
#endif
//
// fire targets
//
- act = activator;
- otemp = other;
if(this.target_random)
RandomSelection_Init();
- for(i = 0; i < 4; ++i)
+ for(int i = 0; i < 4; ++i)
{
switch(i)
{
{
// Flag to set func_clientwall state
// 1 == deactivate, 2 == activate, 0 == do nothing
- float aw_flag = this.antiwall_flag;
- for(t = world; (t = find(t, targetname, s)); )
- if(t.use)
+ int aw_flag = this.antiwall_flag;
+ for(entity t = world; (t = find(t, targetname, s)); )
{
- if(this.target_random)
+ if(t.use)
{
- RandomSelection_Add(t, 0, string_null, 1, 0);
- }
- else
- {
- if (t.classname == "func_clientwall" || t.classname == "func_clientillusionary")
- t.antiwall_flag = aw_flag;
- setself(t);
- other = this;
- activator = act;
- self.use();
+ if(this.target_random)
+ {
+ RandomSelection_Add(t, 0, string_null, 1, 0);
+ }
+ else
+ {
+ if (t.classname == "func_clientwall" || t.classname == "func_clientillusionary")
+ t.antiwall_flag = aw_flag;
+
+ t.use(t, actor, this);
+ }
}
}
}
}
if(this.target_random && RandomSelection_chosen_ent)
- {
- setself(RandomSelection_chosen_ent);
- other = this;
- activator = act;
- self.use();
- }
+ RandomSelection_chosen_ent.use(RandomSelection_chosen_ent, actor, this);
+}
- activator = act;
- setself(this);
- other = otemp;
+void SUB_UseTargets_self()
+{SELFPARAM();
+ SUB_UseTargets(this, NULL, NULL);
}
#ifdef CSQC
this.health -= damage;
//this.realowner = attacker; // Dont change realowner, it does not make much sense for turrets
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(this.owner, turret_projectile_explode));
+ W_PrepareExplosionByDamage(this, this.owner, turret_projectile_explode);
}
entity turret_projectile(Sound _snd, float _size, float _health, float _death, float _proj_type, float _cull, float _cli_anim)
When .used a turret switch team to activator.team.
If activator is world, the turret go inactive.
*/
-void turret_use()
-{SELFPARAM();
- LOG_TRACE("Turret ",self.netname, " used by ", activator.classname, "\n");
+void turret_use(entity this, entity actor, entity trigger)
+{
+ LOG_TRACE("Turret ",this.netname, " used by ", actor.classname, "\n");
- self.team = activator.team;
+ this.team = actor.team;
- if(self.team == 0)
- self.active = ACTIVE_NOT;
+ if(this.team == 0)
+ this.active = ACTIVE_NOT;
else
- self.active = ACTIVE_ACTIVE;
+ this.active = ACTIVE_ACTIVE;
}
if (self.pathgoal)
{
if (self.pathgoal.use)
- self.pathgoal.use();
+ self.pathgoal.use(self.pathgoal, NULL, NULL);
if (self.pathgoal.enemy)
{
this.velocity = this.velocity + vforce;
if (this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(this.owner, walker_rocket_explode));
+ W_PrepareExplosionByDamage(this, this.owner, walker_rocket_explode);
}
#define WALKER_ROCKET_MOVE movelib_move_simple(self, newdir, (autocvar_g_turrets_unit_walker_rocket_speed), (autocvar_g_turrets_unit_walker_rocket_turnrate)); UpdateCSQCProjectile(self)
if (self.pathgoal)
{
if (self.pathgoal.use)
- self.pathgoal.use();
+ self.pathgoal.use(self, NULL, NULL);
if (self.pathgoal.enemy)
{
#define COMMON_UTIL_H
#ifndef MENUQC
+
vector real_origin(entity ent);
#endif
{
this.takedamage = DAMAGE_NO;
this.event_damage = func_null;
- this.think = this.use;
+ this.think = adaptor_think2use;
this.nextthink = time;
}
}
remove (self);
}
+void vehicles_projectile_explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, vehicles_projectile_explode());
+}
+
entity vehicles_projectile(entity this, string _mzlfx, Sound _mzlsound,
vector _org, vector _vel,
float _dmg, float _radi, float _force, float _size,
proj.bot_dodgerating = _dmg;
proj.velocity = _vel;
proj.touch = vehicles_projectile_explode;
- proj.use = vehicles_projectile_explode;
+ proj.use = vehicles_projectile_explode_use;
proj.owner = this;
proj.realowner = _owner;
proj.think = SUB_Remove_self;
}
-void vehicle_use()
-{SELFPARAM();
- LOG_TRACE("vehicle ",self.netname, " used by ", activator.classname, "\n");
+void vehicle_use(entity this, entity actor, entity trigger)
+{
+ LOG_TRACE("vehicle ",this.netname, " used by ", actor.classname, "\n");
- self.tur_head.team = activator.team;
+ this.tur_head.team = actor.team;
- if(self.tur_head.team == 0)
- self.active = ACTIVE_NOT;
+ if(this.tur_head.team == 0)
+ this.active = ACTIVE_NOT;
else
- self.active = ACTIVE_ACTIVE;
+ this.active = ACTIVE_ACTIVE;
- if(self.active == ACTIVE_ACTIVE && !IS_DEAD(self) && !gameover)
+ if(this.active == ACTIVE_ACTIVE && !IS_DEAD(this) && !gameover)
{
- LOG_TRACE("Respawning vehicle: ", self.netname, "\n");
- if(self.effects & EF_NODRAW)
+ LOG_TRACE("Respawning vehicle: ", this.netname, "\n");
+ if(this.effects & EF_NODRAW)
{
- self.think = vehicles_spawn;
- self.nextthink = time + 3;
+ this.think = vehicles_spawn;
+ this.nextthink = time + 3;
}
else
{
- vehicles_setreturn(self);
- vehicles_reset_colors(self);
+ vehicles_setreturn(this);
+ vehicles_reset_colors(this);
}
}
}
if (IS_DEAD(self.owner) || self.cnt < time)
{
- self.use();
+ self.use(self, NULL, NULL);
return;
}
if(IS_DEAD(self.owner) || self.cnt < time)
{
- self.use();
+ self.use(self, NULL, NULL);
return;
}
UpdateCSQCProjectile(self);
if (IS_DEAD(self.owner) || self.cnt < time || vdist(self.pos1 - self.origin, <, 16))
- self.use();
+ self.use(self, NULL, NULL);
}
void spiderbot_rocket_guided()
UpdateCSQCProjectile(self);
if (IS_DEAD(self.owner) || self.cnt < time)
- self.use();
+ self.use(self, NULL, NULL);
}
void spiderbot_guide_release(entity this)
remove(self);
}
+void W_Arc_Bolt_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Arc_Bolt_Explode());
+}
+
void W_Arc_Bolt_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(this.health <= 0)
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.think));
+ W_PrepareExplosionByDamage(this, attacker, this.think);
}
void W_Arc_Bolt_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use();
+ self.use(this, NULL, NULL);
}
void W_Arc_Attack_Bolt(Weapon thiswep)
missile.damagedbycontents = true;
missile.touch = W_Arc_Bolt_Touch;
- missile.use = W_Arc_Bolt_Explode;
+ missile.use = W_Arc_Bolt_Explode_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR(arc, bolt_lifetime);
PROJECTILE_MAKETRIGGER(missile);
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_Devastator_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_Devastator_Explode);
}
void W_Devastator_Attack(Weapon thiswep)
remove(self);
}
+void W_Electro_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Electro_Explode());
+}
+
void W_Electro_TouchExplode()
{
PROJECTILE_TOUCH;
{SELFPARAM();
if(time >= self.ltime)
{
- self.use();
+ this.use(this, NULL, NULL);
return;
}
// if we triggered an orb, should we explode? if not, lets try again next time
if(found && WEP_CVAR_PRI(electro, midaircombo_explode))
- { self.use(); }
+ { this.use(this, NULL, NULL); }
else
{ self.nextthink = min(time + WEP_CVAR_PRI(electro, midaircombo_interval), self.ltime); }
}
proj.owner = proj.realowner = self;
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_PRI(electro, damage);
- proj.use = W_Electro_Explode;
+ proj.use = W_Electro_Explode_use;
proj.think = W_Electro_Bolt_Think;
proj.nextthink = time;
proj.ltime = time + WEP_CVAR_PRI(electro, lifetime);
}
else
{
- this.use = W_Electro_Explode;
+ this.use = W_Electro_Explode_use;
this.think = adaptor_think2use; // not _hittype_splash, as this runs "immediately"
}
}
entity proj = new(electro_orb);
proj.owner = proj.realowner = self;
- proj.use = W_Electro_Explode;
+ proj.use = W_Electro_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_SEC(electro, damage);
remove(self);
}
+void W_Fireball_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Fireball_Explode());
+}
+
void W_Fireball_TouchExplode()
{
PROJECTILE_TOUCH;
if(this.health <= 0)
{
this.cnt = 1;
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_Fireball_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_Fireball_Explode);
}
}
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_PRI(fireball, damage);
proj.pushltime = time + WEP_CVAR_PRI(fireball, lifetime);
- proj.use = W_Fireball_Explode;
+ proj.use = W_Fireball_Explode_use;
proj.think = W_Fireball_Think;
proj.nextthink = time;
proj.health = WEP_CVAR_PRI(fireball, health);
remove(self);
}
+void W_Hagar_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Hagar_Explode());
+}
+
void W_Hagar_Explode2()
{SELFPARAM();
self.event_damage = func_null;
remove(self);
}
+void W_Hagar_Explode2_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Hagar_Explode2());
+}
+
void W_Hagar_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(this.health <= 0)
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.think));
+ W_PrepareExplosionByDamage(this, attacker, this.think);
}
void W_Hagar_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use();
+ this.use(this, NULL, NULL);
}
void W_Hagar_Touch2()
PROJECTILE_TOUCH;
if(self.cnt > 0 || other.takedamage == DAMAGE_AIM) {
- self.use();
+ this.use(this, NULL, NULL);
} else {
self.cnt++;
Send_Effect(EFFECT_HAGAR_BOUNCE, self.origin, self.velocity, 1);
missile.damagedbycontents = true;
missile.touch = W_Hagar_Touch;
- missile.use = W_Hagar_Explode;
+ missile.use = W_Hagar_Explode_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR_PRI(hagar, lifetime);
PROJECTILE_MAKETRIGGER(missile);
missile.touch = W_Hagar_Touch2;
missile.cnt = 0;
- missile.use = W_Hagar_Explode2;
+ missile.use = W_Hagar_Explode2_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR_SEC(hagar, lifetime_min) + random() * WEP_CVAR_SEC(hagar, lifetime_rand);
PROJECTILE_MAKETRIGGER(missile);
missile.damagedbycontents = true;
missile.touch = W_Hagar_Touch; // not bouncy
- missile.use = W_Hagar_Explode2;
+ missile.use = W_Hagar_Explode2_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR_SEC(hagar, lifetime_min) + random() * WEP_CVAR_SEC(hagar, lifetime_rand);
PROJECTILE_MAKETRIGGER(missile);
self.movetype = MOVETYPE_NONE;
}
+void W_Hook_Explode2_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Hook_Explode2());
+}
+
void W_Hook_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
if(this.health <= 0)
this.health = this.health - damage;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(this.realowner, W_Hook_Explode2));
+ W_PrepareExplosionByDamage(this, this.realowner, W_Hook_Explode2);
}
void W_Hook_Touch2()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use();
+ this.use(this, NULL, NULL);
}
void W_Hook_Attack2(Weapon thiswep, entity actor)
gren.nextthink = time + WEP_CVAR_SEC(hook, lifetime);
gren.think = adaptor_think2use_hittype_splash;
- gren.use = W_Hook_Explode2;
+ gren.use = W_Hook_Explode2_use;
gren.touch = W_Hook_Touch2;
gren.takedamage = DAMAGE_YES;
this.angles = vectoangles(this.velocity);
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_MineLayer_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_MineLayer_Explode);
}
void W_MineLayer_Attack(Weapon thiswep)
remove(self);
}
+void W_Mortar_Grenade_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Mortar_Grenade_Explode());
+}
+
void W_Mortar_Grenade_Explode2()
{SELFPARAM();
if(other.takedamage == DAMAGE_AIM)
remove(self);
}
+void W_Mortar_Grenade_Explode2_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Mortar_Grenade_Explode2());
+}
void W_Mortar_Grenade_Damage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
this.health = this.health - damage;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, this.use));
+ W_PrepareExplosionByDamage(this, attacker, adaptor_think2use);
}
void W_Mortar_Grenade_Think1()
PROJECTILE_TOUCH;
if(other.takedamage == DAMAGE_AIM || WEP_CVAR_PRI(mortar, type) == 0) // always explode when hitting a player, or if normal mortar projectile
{
- self.use();
+ this.use(this, NULL, NULL);
}
else if(WEP_CVAR_PRI(mortar, type) == 1) // bounce
{
PROJECTILE_TOUCH;
if(other.takedamage == DAMAGE_AIM || WEP_CVAR_SEC(mortar, type) == 0) // always explode when hitting a player, or if normal mortar projectile
{
- self.use();
+ this.use(this, NULL, NULL);
}
else if(WEP_CVAR_SEC(mortar, type) == 1) // bounce
{
gren.cnt = time + WEP_CVAR_PRI(mortar, lifetime);
gren.nextthink = time;
gren.think = W_Mortar_Grenade_Think1;
- gren.use = W_Mortar_Grenade_Explode;
+ gren.use = W_Mortar_Grenade_Explode_use;
gren.touch = W_Mortar_Grenade_Touch1;
gren.takedamage = DAMAGE_YES;
gren.nextthink = time + WEP_CVAR_SEC(mortar, lifetime);
gren.think = adaptor_think2use_hittype_splash;
- gren.use = W_Mortar_Grenade_Explode2;
+ gren.use = W_Mortar_Grenade_Explode2_use;
gren.touch = W_Mortar_Grenade_Touch2;
gren.takedamage = DAMAGE_YES;
this.health = this.health - damage;
if(this.health <= 0)
- WITHSELF(this, W_PrepareExplosionByDamage(attacker, W_Seeker_Missile_Explode));
+ W_PrepareExplosionByDamage(this, attacker, W_Seeker_Missile_Explode);
}
/*
remove(self);
}
+void W_Seeker_Flac_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_Seeker_Flac_Explode());
+}
+
void W_Seeker_Flac_Touch()
{
PROJECTILE_TOUCH;
missile.bot_dodge = true;
missile.bot_dodgerating = WEP_CVAR(seeker, flac_damage);
missile.touch = W_Seeker_Flac_Explode;
- missile.use = W_Seeker_Flac_Explode;
+ missile.use = W_Seeker_Flac_Explode_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR(seeker, flac_lifetime) + WEP_CVAR(seeker, flac_lifetime_rand);
missile.solid = SOLID_BBOX;
remove(self);
}
+void W_RocketMinsta_Laser_Explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, W_RocketMinsta_Laser_Explode());
+}
+
void W_RocketMinsta_Laser_Touch ()
{SELFPARAM();
PROJECTILE_TOUCH;
proj.owner = proj.realowner = self;
proj.bot_dodge = true;
proj.bot_dodgerating = autocvar_g_rm_laser_damage;
- proj.use = W_RocketMinsta_Laser_Explode;
+ proj.use = W_RocketMinsta_Laser_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.nextthink = time + autocvar_g_rm_laser_lifetime;
PROJECTILE_MAKETRIGGER(proj);
proj.owner = proj.realowner = self;
proj.bot_dodge = true;
proj.bot_dodgerating = autocvar_g_rm_laser_damage;
- proj.use = W_RocketMinsta_Laser_Explode;
+ proj.use = W_RocketMinsta_Laser_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.nextthink = time + autocvar_g_rm_laser_lifetime;
PROJECTILE_MAKETRIGGER(proj);
#pragma noref 0
+#define use use1
+.void(entity this, entity actor, entity trigger) use;
+
#endif
#pragma noref 0
+#define use use1
+.void(entity this, entity actor, entity trigger) use;
+
#endif
void touch_self() { SELFPARAM(); this.selftouch(this); }
#define settouch(e, f) (e.touch = touch_self, e.selftouch = f)
-.void(entity this) selfuse;
-void use_self() { SELFPARAM(); this.selfuse(this); }
-#define setuse(e, f) (e.use = use_self, e.selfuse = f)
+//.void(entity this) selfuse;
+//void use_self() { SELFPARAM(); this.selfuse(this); }
+//#define setuse(e, f) (e.use = use_self, e.selfuse = f)
.void(entity this) selfthink;
void think_self() { SELFPARAM(); this.selfthink(this); }
{
#ifdef SVQC
string save1, save2;
- activator = other;
save1 = this.target; this.target = string_null;
save2 = this.target3; this.target3 = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(this, other, other); // use other too?
if (!this.target) this.target = save1;
if (!this.target3) this.target3 = save2;
- setself(this.enemy);
save1 = this.target; this.target = string_null;
save2 = this.target2; this.target2 = string_null;
- SUB_UseTargets();
+ SUB_UseTargets(this.enemy, other, other); // use other too?
if (!this.target) this.target = save1;
if (!this.target2) this.target2 = save2;
- setself(this);
#endif
}
else
player.velvec = player.warpzone_oldvelocity;
if(WarpZone_Teleport(wz, player, 0, 1))
{
- entity oldself;
string save1, save2;
- oldself = self;
- self = wz;
- other = player;
- activator = player;
-
- save1 = self.target; self.target = string_null;
- save2 = self.target3; self.target3 = string_null;
- SUB_UseTargets();
- if (!self.target) self.target = save1;
- if (!self.target3) self.target3 = save2;
-
- self = self.enemy;
- save1 = self.target; self.target = string_null;
- save2 = self.target2; self.target2 = string_null;
- SUB_UseTargets();
- if (!self.target) self.target = save1;
- if (!self.target2) self.target2 = save2;
- self = oldself;
+ save1 = wz.target; wz.target = string_null;
+ save2 = wz.target3; wz.target3 = string_null;
+ SUB_UseTargets(wz, player, player);
+ if (!wz.target) wz.target = save1;
+ if (!wz.target3) wz.target3 = save2;
+
+ save1 = wz.enemy.target; wz.enemy.target = string_null;
+ save2 = wz.enemy.target2; wz.enemy.target2 = string_null;
+ SUB_UseTargets(wz.enemy, player, player);
+ if (!wz.enemy.target) wz.enemy.target = save1;
+ if (!wz.enemy.target2) wz.enemy.target2 = save2;
}
else
{
));
return false;
}
-void trigger_warpzone_reconnect_use()
-{SELFPARAM();
+void trigger_warpzone_reconnect_use(entity this, entity actor, entity trigger)
+{
// NOTE: this matches for target, not targetname, but of course
// targetname must be set too on the other entities
for(entity e = warpzone_first; e; e = e.warpzone_next)
IS_CHEAT(0, argc, 0);
setself(spawn());
self.target = argv(1);
- activator = this;
- SUB_UseTargets();
+ SUB_UseTargets(self, this, NULL);
remove(self);
setself(this);
DID_CHEAT();
IS_CHEAT(0, argc, 0);
setself(spawn());
self.killtarget = argv(1);
- activator = this;
- SUB_UseTargets();
+ SUB_UseTargets(self, this, NULL);
remove(self);
setself(this);
DID_CHEAT();
{
string s = spot.target;
spot.target = string_null;
- WITH(entity, activator, this, LAMBDA(
- WITHSELF(spot, SUB_UseTargets())
- ));
+ SUB_UseTargets(spot, this, NULL);
spot.target = s;
}
.entity ballcarried; // Also used for keepaway
float g_nexball_meter_period;
-void SUB_DontUseTargets();
-void SUB_UseTargets();
+void SUB_DontUseTargets(entity this, entity actor, entity trigger);
+void SUB_UseTargets(entity this, entity actor, entity trigger);
.void(entity this) reset; // if set, an entity is reset using this
.void() reset2; // if set, an entity is reset using this (after calling ALL the reset functions for other entities)
const float ACTIVE_BUSY = 2;
const float ACTIVE_TOGGLE = 3;
.float active;
-.void (float act_state) setactive;
+.void (entity this, int act_state) setactive;
.entity realowner;
//float serverflags;
self.think = dynlight_think;
self.nextthink = time + 0.1;
}
-void dynlight_use()
+void dynlight_use(entity this, entity actor, entity trigger)
{
- SELFPARAM();
- if (self.light_lev == 0)
- self.light_lev = self.lefty;
+ if (this.light_lev == 0)
+ this.light_lev = this.lefty;
else
- self.light_lev = 0;
+ this.light_lev = 0;
}
spawnfunc(dynlight)
{
.float modelscale;
-void g_model_setcolormaptoactivator ()
-{SELFPARAM();
+void g_model_setcolormaptoactivator(entity this, entity actor, entity trigger)
+{
if(teamplay)
{
- if(activator.team)
- self.colormap = (activator.team - 1) * 0x11;
+ if(actor.team)
+ this.colormap = (actor.team - 1) * 0x11;
else
- self.colormap = 0x00;
+ this.colormap = 0x00;
}
else
- self.colormap = floor(random() * 256);
- self.colormap |= BIT(10); // RENDER_COLORMAPPED
+ this.colormap = floor(random() * 256);
+ this.colormap |= BIT(10); // RENDER_COLORMAPPED
}
-void g_clientmodel_setcolormaptoactivator ()
-{SELFPARAM();
- g_model_setcolormaptoactivator();
- self.SendFlags |= (BIT(3) | BIT(0));
+void g_clientmodel_setcolormaptoactivator(entity this, entity actor, entity trigger)
+{
+ g_model_setcolormaptoactivator(this, actor, trigger);
+ this.SendFlags |= (BIT(3) | BIT(0));
}
-void g_clientmodel_use()
-{SELFPARAM();
- if (self.antiwall_flag == 1)
+void g_clientmodel_use(entity this, entity actor, entity trigger)
+{
+ if (this.antiwall_flag == 1)
{
- self.inactive = 1;
- self.solid = SOLID_NOT;
+ this.inactive = 1;
+ this.solid = SOLID_NOT;
}
- else if (self.antiwall_flag == 2)
+ else if (this.antiwall_flag == 2)
{
- self.inactive = 0;
- self.solid = self.default_solid;
+ this.inactive = 0;
+ this.solid = this.default_solid;
}
- g_clientmodel_setcolormaptoactivator();
+ g_clientmodel_setcolormaptoactivator(this, actor, trigger);
}
void g_model_dropbyspawnflags(entity this)
void() SUB_CalcMoveDone;
void() SUB_CalcAngleMoveDone;
-//void() SUB_UseTargets;
spawnfunc(info_null);
string oldmsg = self.message;
self.message = "";
- activator = other;
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for the trigger here?
self.message = oldmsg;
};
void adaptor_think2use()
{SELFPARAM();
- entity o, a;
- o = other;
- a = activator;
- activator = world;
- other = world;
- self.use();
- other = o;
- activator = a;
+ if(this.use)
+ this.use(this, NULL, NULL);
}
void adaptor_think2use_hittype_splash() // for timed projectile detonation
{SELFPARAM();
- if(!(IS_ONGROUND(self))) // if onground, we ARE touching something, but HITTYPE_SPLASH is to be networked if the damage causing projectile is not touching ANYTHING
- self.projectiledeathtype |= HITTYPE_SPLASH;
- adaptor_think2use();
+ if(!(IS_ONGROUND(this))) // if onground, we ARE touching something, but HITTYPE_SPLASH is to be networked if the damage causing projectile is not touching ANYTHING
+ this.projectiledeathtype |= HITTYPE_SPLASH;
+ WITHSELF(this, adaptor_think2use());
}
// deferred dropping
void WarpZone_traceline_antilag (entity source, vector v1, vector v2, float nomonst, entity forent, float lag);
+void adaptor_think2use();
+
#define IS_DEAD(s) ((s).deadflag != DEAD_NO)
const float SP_ASSAULT_OBJECTIVES = 4;
// predefined spawnfuncs
-void target_objective_decrease_activate();
+void target_objective_decrease_activate(entity this);
#endif
#ifdef IMPLEMENTATION
.entity sprite;
// random functions
-void assault_objective_use()
-{SELFPARAM();
+void assault_objective_use(entity this, entity actor, entity trigger)
+{
// activate objective
- self.health = 100;
- //print("^2Activated objective ", self.targetname, "=", etos(self), "\n");
- //print("Activator is ", activator.classname, "\n");
+ this.health = 100;
+ //print("^2Activated objective ", this.targetname, "=", etos(this), "\n");
+ //print("Activator is ", actor.classname, "\n");
for (entity e = world; (e = find(e, target, this.targetname)); )
{
if (e.classname == "target_objective_decrease")
{
- WITHSELF(e, target_objective_decrease_activate());
+ target_objective_decrease_activate(e);
}
}
-
- setself(this);
}
vector target_objective_spawn_evalfunc(entity player, entity spot, vector current)
}
// decrease the health of targeted objectives
-void assault_objective_decrease_use()
-{SELFPARAM();
- if(activator.team != assault_attacker_team)
+void assault_objective_decrease_use(entity this, entity actor, entity trigger)
+{
+ if(actor.team != assault_attacker_team)
{
// wrong team triggered decrease
return;
}
- if(other.assault_sprite)
+ if(trigger.assault_sprite)
{
- WaypointSprite_Disown(other.assault_sprite, waypointsprite_deadlifetime);
- if(other.classname == "func_assault_destructible")
- other.sprite = world;
+ WaypointSprite_Disown(trigger.assault_sprite, waypointsprite_deadlifetime);
+ if(trigger.classname == "func_assault_destructible")
+ trigger.sprite = world; // TODO: just unsetting it?!
}
else
return; // already activated! cannot activate again!
- if(self.enemy.health < ASSAULT_VALUE_INACTIVE)
+ if(this.enemy.health < ASSAULT_VALUE_INACTIVE)
{
- if(self.enemy.health - self.dmg > 0.5)
+ if(this.enemy.health - this.dmg > 0.5)
{
- PlayerTeamScore_Add(activator, SP_SCORE, ST_SCORE, self.dmg);
- self.enemy.health = self.enemy.health - self.dmg;
+ PlayerTeamScore_Add(actor, SP_SCORE, ST_SCORE, this.dmg);
+ this.enemy.health = this.enemy.health - this.dmg;
}
else
{
- PlayerTeamScore_Add(activator, SP_SCORE, ST_SCORE, self.enemy.health);
- PlayerTeamScore_Add(activator, SP_ASSAULT_OBJECTIVES, ST_ASSAULT_OBJECTIVES, 1);
- self.enemy.health = -1;
-
- entity oldactivator;
+ PlayerTeamScore_Add(actor, SP_SCORE, ST_SCORE, this.enemy.health);
+ PlayerTeamScore_Add(actor, SP_ASSAULT_OBJECTIVES, ST_ASSAULT_OBJECTIVES, 1);
+ this.enemy.health = -1;
- setself(this.enemy);
- if(self.message)
- FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(centerprint(it, self.message)));
+ if(this.enemy.message)
+ FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(centerprint(it, this.enemy.message)));
- oldactivator = activator;
- activator = this;
- SUB_UseTargets();
- activator = oldactivator;
- setself(this);
+ SUB_UseTargets(this.enemy, this, trigger);
}
}
}
void assault_setenemytoobjective(entity this)
{
entity objective;
- for(objective = world; (objective = find(objective, targetname, self.target)); )
+ for(objective = world; (objective = find(objective, targetname, this.target)); )
{
if(objective.classname == "target_objective")
{
- if(self.enemy == world)
- self.enemy = objective;
+ if(this.enemy == world)
+ this.enemy = objective;
else
objerror("more than one objective as target - fix the map!");
break;
}
}
- if(self.enemy == world)
+ if(this.enemy == world)
objerror("no objective as target - fix the map!");
}
return true;
}
-void target_objective_decrease_activate()
-{SELFPARAM();
+void target_objective_decrease_activate(entity this)
+{
entity ent, spr;
- self.owner = world;
- for(ent = world; (ent = find(ent, target, self.targetname)); )
+ this.owner = world;
+ for(ent = world; (ent = find(ent, target, this.targetname)); )
{
if(ent.assault_sprite != world)
{
WaypointSprite_Disown(ent.assault_sprite, waypointsprite_deadlifetime);
if(ent.classname == "func_assault_destructible")
- ent.sprite = world;
+ ent.sprite = world; // TODO: just unsetting it?!
}
spr = WaypointSprite_SpawnFixed(WP_Assault, 0.5 * (ent.absmin + ent.absmax), ent, assault_sprite, RADARICON_OBJECTIVE);
- spr.assault_decreaser = self;
+ spr.assault_decreaser = this;
spr.waypointsprite_visible_for_player = assault_decreaser_sprite_visible;
spr.classname = "sprite_waypoint";
WaypointSprite_UpdateRule(spr, assault_attacker_team, SPRITERULE_TEAMPLAY);
this.winning = false; // up round
}
-void target_assault_roundend_use()
-{SELFPARAM();
- self.winning = 1; // round has been won by attackers
+void target_assault_roundend_use(entity this, entity actor, entity trigger)
+{
+ this.winning = 1; // round has been won by attackers
}
-void assault_roundstart_use(entity this)
+void assault_roundstart_use(entity this, entity actor, entity trigger)
{
- activator = self;
- SUB_UseTargets();
+ SUB_UseTargets(this, this, trigger);
//(Re)spawn all turrets
FOREACH_ENTITY_CLASS("turret_main", true, LAMBDA(
WITHSELF(it, turret_respawn());
));
}
+void assault_roundstart_use_this(entity this)
+{
+ assault_roundstart_use(this, NULL, NULL);
+}
void assault_roundstart_use_self()
{
SELFPARAM();
- assault_roundstart_use(this);
+ assault_roundstart_use(this, NULL, NULL);
}
void assault_wall_think()
FOREACH_CLIENT(IS_PLAYER(it) && it.vehicle, WITHSELF(it, vehicles_exit(VHEF_RELEASE)));
FOREACH_ENTITY_FLAGS(vehicle_flags, VHF_ISVEHICLE, LAMBDA(
- setself(it);
- vehicles_clearreturn(self);
- vehicles_spawn();
+ vehicles_clearreturn(it);
+ WITHSELF(it, vehicles_spawn());
));
- setself(this);
-
// up round counter
self.winning = self.winning + 1;
// spawnfuncs
spawnfunc(info_player_attacker)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.team = NUM_TEAM_1; // red, gets swapped every round
+ this.team = NUM_TEAM_1; // red, gets swapped every round
spawnfunc_info_player_deathmatch(this);
}
spawnfunc(info_player_defender)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.team = NUM_TEAM_2; // blue, gets swapped every round
+ this.team = NUM_TEAM_2; // blue, gets swapped every round
spawnfunc_info_player_deathmatch(this);
}
spawnfunc(target_objective_decrease)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.classname = "target_objective_decrease";
+ this.classname = "target_objective_decrease";
- if(!self.dmg)
- self.dmg = 101;
+ if(!this.dmg)
+ this.dmg = 101;
- self.use = assault_objective_decrease_use;
- self.health = ASSAULT_VALUE_INACTIVE;
- self.max_health = ASSAULT_VALUE_INACTIVE;
- self.enemy = world;
+ this.use = assault_objective_decrease_use;
+ this.health = ASSAULT_VALUE_INACTIVE;
+ this.max_health = ASSAULT_VALUE_INACTIVE;
+ this.enemy = world;
- InitializeEntity(self, target_objective_decrease_findtarget, INITPRIO_FINDTARGET);
+ InitializeEntity(this, target_objective_decrease_findtarget, INITPRIO_FINDTARGET);
}
// destructible walls that can be used to trigger target_objective_decrease
spawnfunc(func_breakable);
spawnfunc(func_assault_destructible)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.spawnflags = 3;
- self.classname = "func_assault_destructible";
+ this.spawnflags = 3;
+ this.classname = "func_assault_destructible";
if(assault_attacker_team == NUM_TEAM_1)
- self.team = NUM_TEAM_2;
+ this.team = NUM_TEAM_2;
else
- self.team = NUM_TEAM_1;
+ this.team = NUM_TEAM_1;
spawnfunc_func_breakable(this);
}
spawnfunc(func_assault_wall)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.classname = "func_assault_wall";
- self.mdl = self.model;
- _setmodel(self, self.mdl);
- self.solid = SOLID_BSP;
- self.think = assault_wall_think;
- self.nextthink = time;
- InitializeEntity(self, assault_setenemytoobjective, INITPRIO_FINDTARGET);
+ this.classname = "func_assault_wall";
+ this.mdl = this.model;
+ _setmodel(this, this.mdl);
+ this.solid = SOLID_BSP;
+ this.think = assault_wall_think;
+ this.nextthink = time;
+ InitializeEntity(this, assault_setenemytoobjective, INITPRIO_FINDTARGET);
}
spawnfunc(target_assault_roundend)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
- self.winning = 0; // round not yet won by attackers
- self.classname = "target_assault_roundend";
- self.use = target_assault_roundend_use;
- self.cnt = 0; // first round
- self.reset = target_assault_roundend_reset;
+ this.winning = 0; // round not yet won by attackers
+ this.classname = "target_assault_roundend";
+ this.use = target_assault_roundend_use;
+ this.cnt = 0; // first round
+ this.reset = target_assault_roundend_reset;
}
spawnfunc(target_assault_roundstart)
{
- if (!g_assault) { remove(self); return; }
+ if (!g_assault) { remove(this); return; }
assault_attacker_team = NUM_TEAM_1;
- self.classname = "target_assault_roundstart";
- self.use = assault_roundstart_use_self;
- self.reset2 = assault_roundstart_use_self;
- InitializeEntity(self, assault_roundstart_use, INITPRIO_FINDTARGET);
+ this.classname = "target_assault_roundstart";
+ this.use = assault_roundstart_use;
+ this.reset2 = assault_roundstart_use_self;
+ InitializeEntity(this, assault_roundstart_use_this, INITPRIO_FINDTARGET);
}
// legacy bot code
old_team = self.team;
self.team = real_team;
self.delay = 0;
- activator = self;
- SUB_UseTargets ();
+ SUB_UseTargets (self, self, NULL);
self.delay = old_delay;
self.team = old_team;
*/
if (!((self.spawnflags & 2) && (IS_PLAYER(other))))
{
- activator = other;
oldmsg = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for the trigger here?
self.message = oldmsg;
}
*/
if(self.spawnflags & 2)
{
- activator = other;
oldmsg = self.message;
self.message = "";
- SUB_UseTargets();
+ SUB_UseTargets(self, other, other); // TODO: should we be using other for the trigger here?
self.message = oldmsg;
}
checkpoint_passed();
}
-void checkpoint_use()
+void checkpoint_use(entity this, entity actor, entity trigger)
{
- if(other.classname == "info_player_deathmatch") // a spawn, a spawn
+ if(trigger.classname == "info_player_deathmatch") // a spawn, a spawn
return;
- other = activator;
+ other = actor;
checkpoint_passed();
}
}
}
-void penalty_use()
-{SELFPARAM();
- race_ImposePenaltyTime(activator, self.race_penalty, self.race_penalty_reason);
+void penalty_use(entity this, entity actor, entity trigger)
+{
+ race_ImposePenaltyTime(actor, this.race_penalty, this.race_penalty_reason);
}
spawnfunc(trigger_race_penalty)
}
}
-void spawnpoint_use()
-{SELFPARAM();
+void spawnpoint_use(entity this, entity actor, entity trigger)
+{
if(teamplay)
if(have_team_spawns > 0)
{
- self.team = activator.team;
+ this.team = actor.team;
some_spawn_has_been_used = 1;
}
//LOG_INFO("spawnpoint was used!\n");
entity Spawn_FilterOutBadSpots(entity firstspot, float mindist, float teamcheck);
entity SelectSpawnPoint (float anypoint);
spawnfunc(info_player_deathmatch);
-void spawnpoint_use();
+void spawnpoint_use(entity this, entity actor, entity trigger);
return true; // if none of these return, then allow damage anyway.
}
-void W_PrepareExplosionByDamage(entity attacker, void() explode)
-{SELFPARAM();
- self.takedamage = DAMAGE_NO;
- self.event_damage = func_null;
+void W_PrepareExplosionByDamage(entity this, entity attacker, void() explode)
+{
+ this.takedamage = DAMAGE_NO;
+ this.event_damage = func_null;
if(IS_CLIENT(attacker) && !autocvar_g_projectiles_keep_owner)
{
- self.owner = attacker;
- self.realowner = attacker;
+ this.owner = attacker;
+ this.realowner = attacker;
}
- MUTATOR_CALLHOOK(PrepareExplosionByDamage, self, attacker);
+ MUTATOR_CALLHOOK(PrepareExplosionByDamage, this, attacker);
// do not explode NOW but in the NEXT FRAME!
// because recursive calls to RadiusDamage are not allowed
- self.nextthink = time;
- self.think = explode;
+ this.nextthink = time;
+ this.think = explode;
}
.float prevstrengthsoundattempt;
void W_PlayStrengthSound(entity player);
float W_CheckProjectileDamage(entity inflictor, entity projowner, int deathtype, float exception);
-void W_PrepareExplosionByDamage(entity attacker, void() explode);
+void W_PrepareExplosionByDamage(entity this, entity attacker, void() explode);
projects / xonotic / xonotic-data.pk3dir.git / commitdiff