// if (it.maxs) break;
// if (it.size) break;
// if (it.touch) break;
-// if (it.use1) break;
+// if (it.use) break;
// if (it.think) break;
// if (it.blocked) break;
// if (it.nextthink) break;
{
own.team = e.team;
- own.use1(own, e, NULL);
+ own.use(own, e, NULL);
}
}
own.team = e.team;
own.active = ACTIVE_NOT;
- own.use1(own, e, NULL);
+ own.use(own, e, NULL);
}
}
{
if ( menuitem )
{
- menuitem.use1(menuitem, NULL, NULL);
+ menuitem.use(menuitem, NULL, NULL);
}
}
entry.size = fontsize;
entry.colormod = color;
entry.flags = 0;
- entry.use1 = click;
+ entry.use = click;
panel_pos_y += fontsize_y;
return entry;
}
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use1(this, NULL, NULL);
+ 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.use1 = M_Shambler_Attack_Lightning_Explode_use;
+ gren.use = M_Shambler_Attack_Lightning_Explode_use;
gren.touch = M_Shambler_Attack_Lightning_Touch;
gren.takedamage = DAMAGE_YES;
entity proj = new(plasma);
proj.owner = proj.realowner = this;
- proj.use1 = M_Spider_Attack_Web_Explode_use;
+ proj.use = M_Spider_Attack_Web_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.bot_dodge = true;
proj.bot_dodgerating = 0;
this.think = func_null;
this.monsterid = monster_id; // set so this monster is properly registered (otherwise, normal initialization is used)
this.nextthink = 0;
- this.use1 = Monster_Appear;
+ this.use = Monster_Appear;
this.flags = FL_MONSTER; // set so this monster can get butchered
return true;
this.monsterid = mon_id;
this.event_damage = Monster_Damage;
this.touch = Monster_Touch;
- this.use1 = Monster_Use;
+ this.use = Monster_Use;
this.solid = SOLID_BBOX;
this.movetype = MOVETYPE_WALK;
this.spawnshieldtime = time + autocvar_g_monsters_spawnshieldtime;
float n, i;
string s;
- self.use1 = target_items_use;
+ self.use = target_items_use;
if(!self.strength_finished)
self.strength_finished = autocvar_g_balance_powerup_strength_time;
if(!self.invincible_finished)
self.event_damage = func_null;
self.state = 1;
if(self.spawnflags & 4)
- self.use1 = func_null;
+ self.use = func_null;
func_breakable_colormod();
if (self.noise1)
stopsound (self, CH_TRIGGER_SINGLE);
SetBrushEntityModel();
if(this.spawnflags & 4)
- this.use1 = func_breakable_destroy;
+ this.use = func_breakable_destroy;
else
- this.use1 = func_breakable_restore;
+ this.use = func_breakable_restore;
if(this.spawnflags & 4)
{
self.effects |= EF_LOWPRECISION;
self.blocked = button_blocked;
- self.use1 = button_use;
+ self.use = button_use;
// if (self.health == 0) // all buttons are now shootable
// self.health = 10;
this.nextthink = time;
IFTARGETED
{
- this.use1 = conveyor_use;
+ this.use = conveyor_use;
this.reset = conveyor_reset;
this.reset(this);
}
precache_sound(self.noise3);
self.blocked = door_blocked;
- self.use1 = door_use;
+ self.use = door_use;
if(self.dmg && (self.message == ""))
self.message = "was squished";
this.trigger_touch = door_touch;
this.draw = door_draw;
this.drawmask = MASK_NORMAL;
- this.use1 = door_use;
+ this.use = door_use;
LinkDoors(this);
self.classname = "door_rotating";
self.blocked = door_blocked;
- self.use1 = door_use;
+ self.use = door_use;
if(self.spawnflags & 8)
self.dmg = 10000;
this.touch = secret_touch;
this.blocked = secret_blocked;
this.speed = 50;
- this.use1 = fd_secret_use;
+ this.use = fd_secret_use;
IFTARGETED
{
}
this.movetype = MOVETYPE_PUSH;
this.drawmask = MASK_NORMAL;
this.draw = plat_draw;
- this.use1 = plat_use;
+ this.use = plat_use;
this.entremove = trigger_remove_generic;
plat_reset(this); // also called here
IFTARGETED
{
- this.use1 = pointparticles_use;
+ this.use = pointparticles_use;
this.reset = pointparticles_reset;
this.reset(this);
}
entity tg = find(world, targetname, self.target);
if(tg.spawnflags & 4)
{
- self.use1 = train_use;
+ self.use = train_use;
self.SUB_THINK = func_null;
self.SUB_NEXTTHINK = 0;
}
{
this.SUB_NEXTTHINK = this.SUB_LTIME + 1;
this.SUB_THINK = train_next;
- this.use1 = func_null; // not again
+ this.use = func_null; // not again
}
void func_train_find(entity this)
self.effects |= EF_LOWPRECISION;
if(self.spawnflags & 4)
- self.use1 = train_use;
+ self.use = train_use;
if (self.spawnflags & 2)
{
{
this.reset = laser_reset;
this.reset(this);
- this.use1 = laser_use;
+ this.use = laser_use;
}
else
this.state = 1;
void plat_use(entity this, entity actor, entity trigger)
{
- this.use1 = func_null;
+ this.use = func_null;
if (this.state != 4)
objerror ("plat_use: not in up state");
WITHSELF(this, plat_go_down());
{
setorigin (this, this.pos1);
this.state = 4;
- this.use1 = plat_use;
+ this.use = plat_use;
}
else
{
setorigin (this, this.pos2);
this.state = 2;
- this.use1 = plat_trigger_use;
+ this.use = plat_trigger_use;
}
#ifdef SVQC
spawnfunc(target_changelevel)
{
- this.use1 = target_changelevel_use;
+ this.use = target_changelevel_use;
if(!this.count) { this.count = 0.7; }
}
}
spawnfunc(target_music)
{
- self.use1 = target_music_use;
+ self.use = target_music_use;
self.reset = target_music_reset;
if(!self.volume)
self.volume = 1;
}
trigger_music_reset(this);
- this.use1 = trigger_music_use;
+ this.use = trigger_music_use;
this.reset = trigger_music_reset;
Net_LinkEntity(this, false, 0, trigger_music_SendEntity);
spawnfunc(target_spawn)
{
initialize_field_db();
- self.use1 = target_spawn_use;
+ self.use = target_spawn_use;
self.message = strzone(strreplace("'", "\"", self.message));
self.target_spawn_id = ++target_spawn_count;
InitializeEntity(self, target_spawn_spawnfirst, INITPRIO_LAST);
snd = this.noise;
_sound(this, CH_TRIGGER_SINGLE, snd, VOL_BASE * this.volume, this.atten);
if(this.spawnflags & 3)
- this.use1 = target_speaker_use_off;
+ this.use = target_speaker_use_off;
}
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.use1 = target_speaker_use_on;
+ this.use = target_speaker_use_on;
}
void target_speaker_reset(entity this)
{
if(this.spawnflags & 1) // LOOPED_ON
{
- if(this.use1 == target_speaker_use_on)
+ if(this.use == target_speaker_use_on)
target_speaker_use_on(this, NULL, NULL);
}
else if(this.spawnflags & 2)
{
- if(this.use1 == target_speaker_use_off)
+ if(this.use == target_speaker_use_off)
target_speaker_use_off(this, NULL, NULL);
}
}
IFTARGETED
{
if(self.spawnflags & 8) // ACTIVATOR
- self.use1 = target_speaker_use_activator;
+ self.use = target_speaker_use_activator;
else if(self.spawnflags & 1) // LOOPED_ON
{
target_speaker_use_on(self, NULL, NULL);
}
else if(self.spawnflags & 2) // LOOPED_OFF
{
- self.use1 = target_speaker_use_on;
+ self.use = target_speaker_use_on;
self.reset = target_speaker_reset;
}
else
- self.use1 = target_speaker_use_on;
+ self.use = target_speaker_use_on;
}
else if(self.spawnflags & 1) // LOOPED_ON
{
// delay: initial delay before the first message
float i, n;
- self.use1 = target_voicescript_use;
+ self.use = target_voicescript_use;
n = tokenize_console(self.message);
self.cnt = n / 2;
self.count = 2;
self.cnt = self.count;
- self.use1 = counter_use;
+ self.use = counter_use;
self.reset = counter_reset;
}
#endif
if(!self.wait)
self.wait = 1;
- self.use1 = delay_use;
+ self.use = delay_use;
self.reset = delay_reset;
}
#endif
for(entity e = world; (e = find(e, targetname, this.target)); )
{
- if(e.use1 == SUB_UseTargets)
+ if(e.use == SUB_UseTargets)
{
- e.use1 = SUB_DontUseTargets;
+ e.use = SUB_DontUseTargets;
++a;
}
- else if(e.use1 == SUB_DontUseTargets)
+ else if(e.use == SUB_DontUseTargets)
{
- e.use1 = SUB_UseTargets;
+ e.use = SUB_UseTargets;
++b;
}
}
spawnfunc(trigger_disablerelay)
{
- this.use1 = trigger_disablerelay_use;
+ this.use = trigger_disablerelay_use;
}
#endif
{
if(this.spawnflags & 1)
this.state = 1;
- this.use1 = flipflop_use;
+ this.use = flipflop_use;
this.reset = spawnfunc_trigger_flipflop; // perfect resetter
}
void self_spawnfunc_trigger_gamestart();
spawnfunc(trigger_gamestart)
{
- this.use1 = gamestart_use;
+ this.use = gamestart_use;
this.reset2 = self_spawnfunc_trigger_gamestart;
if(this.wait)
self.state = true;
IFTARGETED
{
- self.use1 = trigger_gravity_use;
+ self.use = trigger_gravity_use;
if(self.spawnflags & 2)
self.state = false;
}
EXACTTRIGGER_INIT;
self.active = ACTIVE_ACTIVE;
self.touch = trigger_hurt_touch;
- self.use1 = trigger_hurt_use;
+ self.use = trigger_hurt_use;
self.enemy = world; // I hate you all
if (!self.dmg)
self.dmg = 1000;
trigger_init(this);
this.active = ACTIVE_ACTIVE;
- this.use1 = trigger_push_use;
+ this.use = trigger_push_use;
this.touch = trigger_push_touch;
// normal push setup
void trigger_keylock_trigger(entity this, entity actor, string s)
{
for(entity t = world; (t = find(t, targetname, s)); )
- if(t.use1)
- t.use1(t, actor, this);
+ if(t.use)
+ t.use(t, actor, this);
}
/**
if(!this.wait)
this.wait = 1;
if(this.spawnflags & 1)
- this.use1 = monoflop_fixed_use;
+ this.use = monoflop_fixed_use;
else
- this.use1 = monoflop_use;
+ this.use = monoflop_use;
this.think = monoflop_think;
this.state = 0;
this.reset = monoflop_reset;
self.wait = 0.2;
else if(self.wait < -1)
self.wait = 0;
- self.use1 = multi_use;
+ self.use = multi_use;
EXACTTRIGGER_INIT;
self.respawntime = self.wait;
self.state = 0;
- self.use1 = multivibrator_toggle;
+ self.use = multivibrator_toggle;
self.think = multivibrator_send;
self.nextthink = max(1, time);
*/
spawnfunc(trigger_relay)
{
- this.use1 = SUB_UseTargets;
+ this.use = SUB_UseTargets;
this.reset = spawnfunc_trigger_relay; // this spawnfunc resets fully
}
#endif
spawnfunc(relay_activate)
{
this.cnt = ACTIVE_ACTIVE;
- this.use1 = relay_activators_use;
+ this.use = relay_activators_use;
}
spawnfunc(relay_deactivate)
{
this.cnt = ACTIVE_NOT;
- this.use1 = relay_activators_use;
+ this.use = relay_activators_use;
}
spawnfunc(relay_activatetoggle)
{
this.cnt = ACTIVE_TOGGLE;
- this.use1 = relay_activators_use;
+ this.use = relay_activators_use;
}
#endif
spawnfunc(trigger_relay_if)
{
- this.use1 = trigger_relay_if_use;
+ this.use = trigger_relay_if_use;
}
#endif
spawnfunc(trigger_relay_teamcheck)
{
this.team_saved = this.team;
- this.use1 = trigger_relay_teamcheck_use;
+ this.use = trigger_relay_teamcheck_use;
this.reset = trigger_relay_teamcheck_reset;
}
#endif
// take over the touch() function, so we can mark secret as found
self.touch = trigger_secret_touch;
// ignore triggering;
- self.use1 = func_null;
+ self.use = func_null;
}
#endif
self.active = ACTIVE_ACTIVE;
//trigger_init(self); // only for predicted triggers?
EXACTTRIGGER_INIT;
- self.use1 = trigger_teleport_use;
+ self.use = trigger_teleport_use;
if(self.noise != "")
FOREACH_WORD(self.noise, true, precache_sound(it));
int aw_flag = this.antiwall_flag;
for(entity t = world; (t = find(t, targetname, s)); )
{
- if(t.use1)
+ if(t.use)
{
if(this.target_random)
{
if (t.classname == "func_clientwall" || t.classname == "func_clientillusionary")
t.antiwall_flag = aw_flag;
- t.use1(t, actor, this);
+ t.use(t, actor, this);
}
}
}
}
if(this.target_random && RandomSelection_chosen_ent)
- RandomSelection_chosen_ent.use1(RandomSelection_chosen_ent, actor, this);
+ RandomSelection_chosen_ent.use(RandomSelection_chosen_ent, actor, this);
}
void SUB_UseTargets_self()
self.view_ofs = '0 0 0';
self.turret_firecheckfunc = turret_firecheck;
self.event_damage = turret_damage;
- self.use1 = turret_use;
+ self.use = turret_use;
self.bot_attack = true;
self.nextthink = time + 1;
self.nextthink += turret_count * sys_frametime;
if (self.pathgoal)
{
- if (self.pathgoal.use1)
- self.pathgoal.use1(self.pathgoal, NULL, NULL);
+ if (self.pathgoal.use)
+ self.pathgoal.use(self.pathgoal, NULL, NULL);
if (self.pathgoal.enemy)
{
if (self.pathgoal)
{
- if (self.pathgoal.use1)
- self.pathgoal.use1(self, NULL, NULL);
+ if (self.pathgoal.use)
+ self.pathgoal.use(self, NULL, NULL);
if (self.pathgoal.enemy)
{
#define COMMON_UTIL_H
#ifndef MENUQC
-.void(entity this, entity actor, entity trigger) use1;
vector real_origin(entity ent);
#endif
proj.bot_dodgerating = _dmg;
proj.velocity = _vel;
proj.touch = vehicles_projectile_explode;
- proj.use1 = vehicles_projectile_explode_use;
+ proj.use = vehicles_projectile_explode_use;
proj.owner = this;
proj.realowner = _owner;
proj.think = SUB_Remove_self;
else
{
this.team = this.vehicle_controller.team;
- this.use1 = vehicle_use;
+ this.use = vehicle_use;
if(teamplay)
{
if (IS_DEAD(self.owner) || self.cnt < time)
{
- self.use1(self, NULL, NULL);
+ self.use(self, NULL, NULL);
return;
}
if(IS_DEAD(self.owner) || self.cnt < time)
{
- self.use1(self, NULL, NULL);
+ self.use(self, NULL, NULL);
return;
}
UpdateCSQCProjectile(self);
if (IS_DEAD(self.owner) || self.cnt < time || vdist(self.pos1 - self.origin, <, 16))
- self.use1(self, NULL, NULL);
+ self.use(self, NULL, NULL);
}
void spiderbot_rocket_guided()
UpdateCSQCProjectile(self);
if (IS_DEAD(self.owner) || self.cnt < time)
- self.use1(self, NULL, NULL);
+ self.use(self, NULL, NULL);
}
void spiderbot_guide_release(entity this)
void W_Arc_Bolt_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- self.use1(this, NULL, NULL);
+ self.use(this, NULL, NULL);
}
void W_Arc_Attack_Bolt(Weapon thiswep)
missile.damagedbycontents = true;
missile.touch = W_Arc_Bolt_Touch;
- missile.use1 = W_Arc_Bolt_Explode_use;
+ missile.use = W_Arc_Bolt_Explode_use;
missile.think = adaptor_think2use_hittype_splash;
missile.nextthink = time + WEP_CVAR(arc, bolt_lifetime);
PROJECTILE_MAKETRIGGER(missile);
{SELFPARAM();
if(time >= self.ltime)
{
- this.use1(this, NULL, NULL);
+ 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))
- { this.use1(this, NULL, NULL); }
+ { 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.use1 = W_Electro_Explode_use;
+ 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.use1 = W_Electro_Explode_use;
+ 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.use1 = W_Electro_Explode_use;
+ proj.use = W_Electro_Explode_use;
proj.think = adaptor_think2use_hittype_splash;
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_SEC(electro, damage);
proj.bot_dodge = true;
proj.bot_dodgerating = WEP_CVAR_PRI(fireball, damage);
proj.pushltime = time + WEP_CVAR_PRI(fireball, lifetime);
- proj.use1 = W_Fireball_Explode_use;
+ proj.use = W_Fireball_Explode_use;
proj.think = W_Fireball_Think;
proj.nextthink = time;
proj.health = WEP_CVAR_PRI(fireball, health);
void W_Hagar_Touch()
{SELFPARAM();
PROJECTILE_TOUCH;
- this.use1(this, NULL, NULL);
+ this.use(this, NULL, NULL);
}
void W_Hagar_Touch2()
PROJECTILE_TOUCH;
if(self.cnt > 0 || other.takedamage == DAMAGE_AIM) {
- this.use1(this, NULL, NULL);
+ 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.use1 = W_Hagar_Explode_use;
+ 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.use1 = W_Hagar_Explode2_use;
+ 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.use1 = W_Hagar_Explode2_use;
+ 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);
void W_Hook_Touch2()
{SELFPARAM();
PROJECTILE_TOUCH;
- this.use1(this, NULL, NULL);
+ 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.use1 = W_Hook_Explode2_use;
+ gren.use = W_Hook_Explode2_use;
gren.touch = W_Hook_Touch2;
gren.takedamage = DAMAGE_YES;
PROJECTILE_TOUCH;
if(other.takedamage == DAMAGE_AIM || WEP_CVAR_PRI(mortar, type) == 0) // always explode when hitting a player, or if normal mortar projectile
{
- this.use1(this, NULL, NULL);
+ 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
{
- this.use1(this, NULL, NULL);
+ 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.use1 = W_Mortar_Grenade_Explode_use;
+ 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.use1 = W_Mortar_Grenade_Explode2_use;
+ gren.use = W_Mortar_Grenade_Explode2_use;
gren.touch = W_Mortar_Grenade_Touch2;
gren.takedamage = DAMAGE_YES;
missile.bot_dodge = true;
missile.bot_dodgerating = WEP_CVAR(seeker, flac_damage);
missile.touch = W_Seeker_Flac_Explode;
- missile.use1 = W_Seeker_Flac_Explode_use;
+ 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;
proj.owner = proj.realowner = self;
proj.bot_dodge = true;
proj.bot_dodgerating = autocvar_g_rm_laser_damage;
- proj.use1 = W_RocketMinsta_Laser_Explode_use;
+ 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.use1 = W_RocketMinsta_Laser_Explode_use;
+ 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
spawnfunc(trigger_warpzone_reconnect)
{
- this.use1 = trigger_warpzone_reconnect_use;
+ this.use = trigger_warpzone_reconnect_use;
}
spawnfunc(target_warpzone_reconnect)
if (!self.color)
self.color = '1 1 1';
self.lefty = self.light_lev;
- self.use1 = dynlight_use;
+ self.use = dynlight_use;
setsize (self, '0 0 0', '0 0 0');
setorigin (self, self.origin);
//self.pflags = PFLAGS_FULLDYNAMIC;
if(self.geomtype) if(autocvar_physics_ode && checkextension("DP_PHYSICS_ODE")) self.movetype = MOVETYPE_PHYSICS; \
if(!self.scale) self.scale = self.modelscale; \
SetBrushEntityModel(); \
- self.use1 = g_model_setcolormaptoactivator; \
+ self.use = g_model_setcolormaptoactivator; \
InitializeEntity(self, g_model_dropbyspawnflags, INITPRIO_DROPTOFLOOR); \
if(!self.solid) self.solid = (sol); else if(self.solid < 0) self.solid = SOLID_NOT;
if(self.geomtype) if(autocvar_physics_ode && checkextension("DP_PHYSICS_ODE")) self.movetype = MOVETYPE_PHYSICS; \
if(!self.scale) self.scale = self.modelscale; \
SetBrushEntityModel(); \
- self.use1 = g_clientmodel_use; \
+ self.use = g_clientmodel_use; \
InitializeEntity(self, g_clientmodel_dropbyspawnflags, INITPRIO_DROPTOFLOOR); \
if(!self.solid) self.solid = (sol); else if(self.solid < 0) self.solid = SOLID_NOT; \
if(!self.bgmscriptsustain) self.bgmscriptsustain = 1; else if(self.bgmscriptsustain < 0) self.bgmscriptsustain = 0; \
void adaptor_think2use()
{SELFPARAM();
- if(this.use1)
- this.use1(this, NULL, NULL);
+ if(this.use)
+ this.use(this, NULL, NULL);
}
void adaptor_think2use_hittype_splash() // for timed projectile detonation
if (!g_assault) { remove(this); return; }
this.classname = "target_objective";
- this.use1 = assault_objective_use;
+ this.use = assault_objective_use;
this.reset = assault_objective_reset;
this.reset(this);
this.spawn_evalfunc = target_objective_spawn_evalfunc;
if(!self.dmg)
self.dmg = 101;
- self.use1 = assault_objective_decrease_use;
+ self.use = assault_objective_decrease_use;
self.health = ASSAULT_VALUE_INACTIVE;
self.max_health = ASSAULT_VALUE_INACTIVE;
self.enemy = world;
self.winning = 0; // round not yet won by attackers
self.classname = "target_assault_roundend";
- self.use1 = target_assault_roundend_use;
+ self.use = target_assault_roundend_use;
self.cnt = 0; // first round
self.reset = target_assault_roundend_reset;
}
assault_attacker_team = NUM_TEAM_1;
self.classname = "target_assault_roundstart";
- self.use1 = assault_roundstart_use;
+ self.use = assault_roundstart_use;
self.reset2 = assault_roundstart_use_self;
InitializeEntity(self, assault_roundstart_use_this, INITPRIO_FINDTARGET);
}
EXACTTRIGGER_INIT;
- self.use1 = checkpoint_use;
+ self.use = checkpoint_use;
if (!(self.spawnflags & 1))
self.touch = checkpoint_touch;
EXACTTRIGGER_INIT;
- self.use1 = checkpoint_use;
+ self.use = checkpoint_use;
if (!(self.spawnflags & 1))
self.touch = checkpoint_touch;
EXACTTRIGGER_INIT;
- self.use1 = penalty_use;
+ self.use = penalty_use;
if (!(self.spawnflags & 1))
self.touch = penalty_touch;
}
}
- self.use1 = spawnpoint_use;
+ self.use = spawnpoint_use;
self.think = spawnpoint_think;
self.nextthink = time + 0.5 + random() * 2; // shouldn't need it for a little second
self.team_saved = self.team;
projects / xonotic / xonotic-data.pk3dir.git / commitdiff