{
this.takedamage = DAMAGE_NO;
this.event_damage = func_null;
- this.think = this.use;
+ setthink(this, adaptor_think2use);
this.nextthink = time;
}
}
-void vehicles_projectile_explode()
-{SELFPARAM();
+void vehicles_projectile_explode(entity this)
+{
if(self.owner && other != world)
{
if(other == self.owner.vehicle)
return;
}
- PROJECTILE_TOUCH;
+ PROJECTILE_TOUCH(this);
self.event_damage = func_null;
RadiusDamage (self, self.realowner, self.shot_dmg, 0, self.shot_radius, self, world, self.shot_force, self.totalfrags, other);
remove (self);
}
+void vehicles_projectile_explode_use(entity this, entity actor, entity trigger)
+{
+ WITHSELF(this, vehicles_projectile_explode(this));
+}
+
entity vehicles_projectile(entity this, string _mzlfx, Sound _mzlsound,
vector _org, vector _vel,
float _dmg, float _radi, float _force, float _size,
proj.bot_dodge = true;
proj.bot_dodgerating = _dmg;
proj.velocity = _vel;
- proj.touch = vehicles_projectile_explode;
- proj.use = vehicles_projectile_explode;
+ settouch(proj, vehicles_projectile_explode);
+ proj.use = vehicles_projectile_explode_use;
proj.owner = this;
proj.realowner = _owner;
- proj.think = SUB_Remove_self;
+ setthink(proj, SUB_Remove);
proj.nextthink = time + 30;
if(_health)
return proj;
}
-void vehicles_gib_explode()
-{SELFPARAM();
+void vehicles_gib_explode(entity this)
+{
sound (self, CH_SHOTS, SND_ROCKET_IMPACT, VOL_BASE, ATTEN_NORM);
Send_Effect(EFFECT_EXPLOSION_SMALL, randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
Send_Effect(EFFECT_EXPLOSION_SMALL, self.wp00.origin + '0 0 64', '0 0 0', 1);
remove(self);
}
-void vehicles_gib_think()
-{SELFPARAM();
+void vehicles_gib_think(entity this)
+{
self.alpha -= 0.1;
if(self.cnt >= time)
remove(self);
if(_explode)
{
- _gib.think = vehicles_gib_explode;
+ setthink(_gib, vehicles_gib_explode);
_gib.nextthink = time + random() * _explode;
- _gib.touch = vehicles_gib_explode;
+ settouch(_gib, vehicles_gib_explode);
}
else
{
_gib.cnt = time + _maxtime;
- _gib.think = vehicles_gib_think;
+ setthink(_gib, vehicles_gib_think);
_gib.nextthink = time + _maxtime - 1;
_gib.alpha = 1;
}
int _hud,
Model _hud_model,
bool(entity) _framefunc,
- void(bool) _exitfunc, float(entity, entity) _enterfunc)
+ void(entity,bool) _exitfunc, float(entity, entity) _enterfunc)
{
if(!(_owner.vehicle_flags & VHF_MULTISLOT))
_owner.vehicle_flags |= VHF_MULTISLOT;
if(ret.wp00 == veh)
{
ret.classname = "";
- ret.think = SUB_Remove_self;
+ setthink(ret, SUB_Remove);
ret.nextthink = time + 0.1;
if(ret.waypointsprite_attached)
}
}
-void vehicles_spawn();
-void vehicles_return()
-{SELFPARAM();
+void vehicles_spawn(entity this);
+void vehicles_return(entity this)
+{
Send_Effect(EFFECT_TELEPORT, self.wp00.origin + '0 0 64', '0 0 0', 1);
- self.wp00.think = vehicles_spawn;
+ setthink(self.wp00, vehicles_spawn);
self.wp00.nextthink = time;
if(self.waypointsprite_attached)
remove(self);
}
-void vehicles_showwp_goaway()
-{SELFPARAM();
+void vehicles_showwp_goaway(entity this)
+{
if(self.waypointsprite_attached)
WaypointSprite_Kill(self.waypointsprite_attached);
}
-void vehicles_showwp()
-{SELFPARAM();
- entity oldself = world;
+void vehicles_showwp(entity this)
+{
vector rgb;
- if(self.cnt)
+ entity ent = this;
+
+ if(ent.cnt)
{
- self.think = vehicles_return;
- self.nextthink = self.cnt;
+ setthink(ent, vehicles_return);
+ ent.nextthink = ent.cnt;
}
else
{
- self.think = vehicles_return;
- self.nextthink = time +1;
-
- oldself = self;
- setself(spawn());
- setmodel(self, MDL_Null);
- self.team = oldself.wp00.team;
- self.wp00 = oldself.wp00;
- setorigin(self, oldself.wp00.pos1);
-
- self.nextthink = time + 5;
- self.think = vehicles_showwp_goaway;
+ setthink(ent, vehicles_return);
+ ent.nextthink = time + 1;
+
+ ent = spawn();
+ setmodel(ent, MDL_Null);
+ ent.team = this.wp00.team;
+ ent.wp00 = this.wp00;
+ setorigin(ent, this.wp00.pos1);
+
+ ent.nextthink = time + 5;
+ setthink(ent, vehicles_showwp_goaway);
}
- if(teamplay && self.team)
- rgb = Team_ColorRGB(self.team);
+ if(teamplay && ent.team)
+ rgb = Team_ColorRGB(ent.team);
else
rgb = '1 1 1';
- entity wp = WaypointSprite_Spawn(WP_Vehicle, 0, 0, self, '0 0 64', world, 0, self, waypointsprite_attached, true, RADARICON_Vehicle);
+ entity wp = WaypointSprite_Spawn(WP_Vehicle, 0, 0, ent, '0 0 64', world, 0, ent, waypointsprite_attached, true, RADARICON_Vehicle);
wp.colormod = rgb;
- if(self.waypointsprite_attached)
+ if(ent.waypointsprite_attached)
{
- WaypointSprite_UpdateRule(self.waypointsprite_attached, self.wp00.team, SPRITERULE_DEFAULT);
+ WaypointSprite_UpdateRule(ent.waypointsprite_attached, ent.wp00.team, SPRITERULE_DEFAULT);
if(this == NULL)
- WaypointSprite_UpdateBuildFinished(self.waypointsprite_attached, self.nextthink);
- WaypointSprite_Ping(self.waypointsprite_attached);
+ WaypointSprite_UpdateBuildFinished(ent.waypointsprite_attached, ent.nextthink);
+ WaypointSprite_Ping(ent.waypointsprite_attached);
}
-
- if(this)
- setself(this);
}
void vehicles_setreturn(entity veh)
ret = new(vehicle_return);
ret.wp00 = veh;
ret.team = veh.team;
- ret.think = vehicles_showwp;
+ setthink(ret, vehicles_showwp);
if(IS_DEAD(veh))
{
}
-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;
+ setthink(this, vehicles_spawn);
+ this.nextthink = time + 3;
}
else
{
- vehicles_setreturn(self);
- vehicles_reset_colors(self);
+ vehicles_setreturn(this);
+ vehicles_reset_colors(this);
}
}
}
}
}
-void shieldhit_think()
-{SELFPARAM();
+void shieldhit_think(entity this)
+{
self.alpha -= 0.1;
if (self.alpha <= 0)
{
setattachment(this.vehicle_shieldent, this, "");
setorigin(this.vehicle_shieldent, real_origin(this) - this.origin);
this.vehicle_shieldent.scale = 256 / vlen(this.maxs - this.mins);
- this.vehicle_shieldent.think = shieldhit_think;
+ setthink(this.vehicle_shieldent, shieldhit_think);
}
this.vehicle_shieldent.colormod = '1 1 1';
{
if(this.owner)
if(this.vehicle_flags & VHF_DEATHEJECT)
- WITHSELF(this, vehicles_exit(VHEF_EJECT));
+ vehicles_exit(this, VHEF_EJECT);
else
- WITHSELF(this, vehicles_exit(VHEF_RELEASE));
+ vehicles_exit(this, VHEF_RELEASE);
antilag_clear(this, this);
}
// vehicle enter/exit handling
-vector vehicles_findgoodexit(vector prefer_spot)
-{SELFPARAM();
+vector vehicles_findgoodexit(entity this, vector prefer_spot)
+{
//vector exitspot;
float mysize;
- tracebox(self.origin + '0 0 32', STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), prefer_spot, MOVE_NORMAL, self.owner);
+ tracebox(this.origin + '0 0 32', STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), prefer_spot, MOVE_NORMAL, this.owner);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return prefer_spot;
- mysize = 1.5 * vlen(self.maxs - self.mins);
+ mysize = 1.5 * vlen(this.maxs - this.mins);
float i;
vector v, v2;
- v2 = 0.5 * (self.absmin + self.absmax);
+ v2 = 0.5 * (this.absmin + this.absmax);
for(i = 0; i < 100; ++i)
{
v = randomvec();
v_z = 0;
v = v2 + normalize(v) * mysize;
- tracebox(v2, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), v, MOVE_NORMAL, self.owner);
+ tracebox(v2, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL), v, MOVE_NORMAL, this.owner);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return v;
}
/*
- exitspot = (self.origin + '0 0 48') + v_forward * mysize;
- tracebox(self.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, self.owner);
+ exitspot = (this.origin + '0 0 48') + v_forward * mysize;
+ tracebox(this.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, this.owner);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return exitspot;
- exitspot = (self.origin + '0 0 48') - v_forward * mysize;
- tracebox(self.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, self.owner);
+ exitspot = (this.origin + '0 0 48') - v_forward * mysize;
+ tracebox(this.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, this.owner);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return exitspot;
- exitspot = (self.origin + '0 0 48') + v_right * mysize;
- tracebox(self.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, self.owner);
+ exitspot = (this.origin + '0 0 48') + v_right * mysize;
+ tracebox(this.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, this.owner);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return exitspot;
- exitspot = (self.origin + '0 0 48') - v_right * mysize;
- tracebox(self.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, self.owner);
+ exitspot = (this.origin + '0 0 48') - v_right * mysize;
+ tracebox(this.origin + '0 0 32', PL_MIN, PL_MAX, exitspot, MOVE_NORMAL, this.owner);
if(trace_fraction == 1.0 && !trace_startsolid && !trace_allsolid)
return exitspot;
*/
- return self.origin;
+ return this.origin;
}
-void vehicles_exit(bool eject)
-{SELFPARAM();
- entity _vehicle;
- entity _player;
+void vehicles_exit(entity vehic, bool eject)
+{
+ entity player = vehic.owner;
if(vehicles_exit_running)
{
- LOG_TRACE("^1vehicles_exit allready running! this is not good..\n");
+ LOG_TRACE("^1vehicles_exit already running! this is not good...\n");
return;
}
vehicles_exit_running = true;
- if(IS_CLIENT(self))
- {
- _vehicle = self.vehicle;
- if (_vehicle.vehicle_flags & VHF_PLAYERSLOT)
- {
- _vehicle.vehicle_exit(eject);
- setself(this);
- vehicles_exit_running = false;
- return;
- }
+ // TODO: this was in an IS_CLIENT check, make sure it isn't actually needed!
+ if(vehic.vehicle_flags & VHF_PLAYERSLOT)
+ {
+ vehic.vehicle_exit(vehic, eject);
+ vehicles_exit_running = false;
+ return;
}
- else
- _vehicle = self;
-
- _player = _vehicle.owner;
- setself(_vehicle);
-
- if (_player)
+ if (player)
{
- if (IS_REAL_CLIENT(_player))
+ if (IS_REAL_CLIENT(player))
{
- msg_entity = _player;
+ msg_entity = player;
WriteByte (MSG_ONE, SVC_SETVIEWPORT);
- WriteEntity( MSG_ONE, _player);
+ WriteEntity( MSG_ONE, player);
WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
WriteAngle(MSG_ONE, 0);
- WriteAngle(MSG_ONE, _vehicle.angles_y);
+ WriteAngle(MSG_ONE, vehic.angles_y);
WriteAngle(MSG_ONE, 0);
}
- setsize(_player, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL));
-
- _player.takedamage = DAMAGE_AIM;
- _player.solid = SOLID_SLIDEBOX;
- _player.movetype = MOVETYPE_WALK;
- _player.effects &= ~EF_NODRAW;
- _player.teleportable = TELEPORT_NORMAL;
- _player.alpha = 1;
- _player.PlayerPhysplug = func_null;
- _player.vehicle = world;
- _player.view_ofs = STAT(PL_VIEW_OFS, NULL);
- _player.event_damage = PlayerDamage;
- _player.hud = HUD_NORMAL;
- PS(_player).m_switchweapon = _vehicle.m_switchweapon;
- _player.last_vehiclecheck = time + 3;
- _player.vehicle_enter_delay = time + 2;
-
- CSQCVehicleSetup(_player, HUD_NORMAL);
+ setsize(player, STAT(PL_MIN, NULL), STAT(PL_MAX, NULL));
+
+ player.takedamage = DAMAGE_AIM;
+ player.solid = SOLID_SLIDEBOX;
+ player.movetype = MOVETYPE_WALK;
+ player.effects &= ~EF_NODRAW;
+ player.teleportable = TELEPORT_NORMAL;
+ player.alpha = 1;
+ player.PlayerPhysplug = func_null;
+ player.vehicle = world;
+ player.view_ofs = STAT(PL_VIEW_OFS, NULL);
+ player.event_damage = PlayerDamage;
+ player.hud = HUD_NORMAL;
+ PS(player).m_switchweapon = vehic.m_switchweapon;
+ player.last_vehiclecheck = time + 3;
+ player.vehicle_enter_delay = time + 2;
+
+ CSQCVehicleSetup(player, HUD_NORMAL);
+
+ Kill_Notification(NOTIF_ONE, player, MSG_CENTER, CPID_VEHICLES);
+ Kill_Notification(NOTIF_ONE, player, MSG_CENTER, CPID_VEHICLES_OTHER); // kill all vehicle notifications when exiting a vehicle?
}
- _vehicle.flags |= FL_NOTARGET;
- if(!IS_DEAD(_vehicle))
- _vehicle.avelocity = '0 0 0';
+ vehic.flags |= FL_NOTARGET;
- _vehicle.tur_head.nodrawtoclient = world;
+ if(!IS_DEAD(vehic))
+ vehic.avelocity = '0 0 0';
- if(!teamplay)
- _vehicle.team = 0;
+ vehic.tur_head.nodrawtoclient = world;
- Kill_Notification(NOTIF_ONE, _player, MSG_CENTER, CPID_VEHICLES);
- Kill_Notification(NOTIF_ONE, _player, MSG_CENTER, CPID_VEHICLES_OTHER); // kill all vehicle notifications when exiting a vehicle?
+ if(!teamplay)
+ vehic.team = 0;
- WaypointSprite_Kill(_vehicle.wps_intruder);
+ WaypointSprite_Kill(vehic.wps_intruder);
- MUTATOR_CALLHOOK(VehicleExit, _player, _vehicle);
+ MUTATOR_CALLHOOK(VehicleExit, player, vehic);
- _vehicle.team = _vehicle.tur_head.team;
+ vehic.team = vehic.tur_head.team;
- sound (_vehicle, CH_TRIGGER_SINGLE, SND_Null, 1, ATTEN_NORM);
- _vehicle.vehicle_hudmodel.viewmodelforclient = _vehicle;
- _vehicle.phase = time + 1;
+ sound (vehic, CH_TRIGGER_SINGLE, SND_Null, 1, ATTEN_NORM);
+ vehic.vehicle_hudmodel.viewmodelforclient = vehic;
+ vehic.phase = time + 1;
- _vehicle.vehicle_exit(eject);
+ vehic.vehicle_exit(vehic, eject);
- vehicles_setreturn(_vehicle);
- vehicles_reset_colors(_vehicle);
- _vehicle.owner = world;
+ vehicles_setreturn(vehic);
+ vehicles_reset_colors(vehic);
+ vehic.owner = world;
- CSQCMODEL_AUTOINIT(self);
+ CSQCMODEL_AUTOINIT(vehic);
- setself(this);
vehicles_exit_running = false;
}
-void vehicles_touch()
-{SELFPARAM();
+void vehicles_touch(entity this)
+{
if(MUTATOR_CALLHOOK(VehicleTouch, self, other))
return;
entity v = this.vehicle;
if (!v) return false;
if (IS_DEAD(v)) return false;
- bool(int) f = v.vehicles_impulse;
- if (f && f(imp)) return true;
+ bool(entity,int) f = v.vehicles_impulse;
+ if (f && f(this,imp)) return true;
switch (imp)
{
case IMP_weapon_drop.impulse:
void vehicles_enter(entity pl, entity veh)
{
- SELFPARAM();
- entity oldself = self;
-
// Remove this when bots know how to use vehicles
if((IS_BOT_CLIENT(pl) && !autocvar_g_vehicles_allow_bots))
return;
MUTATOR_CALLHOOK(VehicleEnter, pl, veh);
- setself(veh);
CSQCModel_UnlinkEntity(veh);
Vehicle info = Vehicles_from(veh.vehicleid);
- info.vr_enter(info, veh);
- setself(oldself);
+ WITHSELF(veh, info.vr_enter(info, veh));
antilag_clear(pl, CS(pl));
}
-void vehicles_think()
-{SELFPARAM();
+void vehicles_think(entity this)
+{
self.nextthink = time;
if(self.owner)
}
// initialization
-void vehicles_spawn()
-{SELFPARAM();
+void vehicles_spawn(entity this)
+{
LOG_TRACE("Spawning vehicle: ", self.classname, "\n");
// disown & reset
self.vehicle_hudmodel.viewmodelforclient = self;
self.owner = world;
- self.touch = vehicles_touch;
+ settouch(self, vehicles_touch);
self.event_damage = vehicles_damage;
self.iscreature = true;
self.teleportable = false; // no teleporting for vehicles, too buggy
self.flags = FL_NOTARGET;
self.avelocity = '0 0 0';
self.velocity = '0 0 0';
- self.think = vehicles_think;
+ setthink(self, vehicles_think);
self.nextthink = time;
// Reset locking
this.vehicleid = info.vehicleid;
this.PlayerPhysplug = info.PlayerPhysplug;
this.event_damage = func_null;
- this.touch = vehicles_touch;
- this.think = vehicles_spawn;
+ settouch(this, vehicles_touch);
+ setthink(this, vehicles_spawn);
this.nextthink = time;
this.effects = EF_NODRAW;
this.dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_SOLID;
projects / xonotic / xonotic-data.pk3dir.git / blobdiff