-// =========================
-// SVQC Vehicle Properties
-// =========================
+#include "sv_vehicles.qh"
+#include "../effects.qh"
+#if 0
+bool vehicle_send(entity to, int sf)
+{
+ WriteByte(MSG_ENTITY, ENT_CLIENT_VEHICLE);
+ WriteByte(MSG_ENTITY, sf);
+
+ if(sf & VSF_SPAWN)
+ {
+ WriteByte(MSG_ENTITY, self.vehicleid);
+ }
+
+ if(sf & VSF_SETUP)
+ {
+ // send stuff?
+ }
+
+ if(sf & VSF_ENTER)
+ {
+ // player handles the .vehicle stuff, we need only set ourselves up for driving
+
+ // send stuff?
+ }
+
+ if(sf & VSF_EXIT)
+ {
+ // senf stuff?
+ }
-float SendAuxiliaryXhair(entity to, float sf)
+ if(sf & VSF_PRECACHE)
+ {
+ // send stuff?!
+ }
+
+ return true;
+}
+#endif
+
+bool SendAuxiliaryXhair(entity to, int sf)
{
WriteByte(MSG_ENTITY, ENT_CLIENT_AUXILIARYXHAIR);
WriteByte(MSG_ENTITY, rint(self.colormod_y * 255));
WriteByte(MSG_ENTITY, rint(self.colormod_z * 255));
- return TRUE;
+ return true;
}
-void UpdateAuxiliaryXhair(entity own, vector loc, vector clr, float axh_id)
+void UpdateAuxiliaryXhair(entity own, vector loc, vector clr, int axh_id)
{
if(!IS_REAL_CLIENT(own))
return;
axh.cnt = axh_id;
axh.drawonlytoclient = own;
axh.owner = own;
- Net_LinkEntity(axh, FALSE, 0, SendAuxiliaryXhair);
+ Net_LinkEntity(axh, false, 0, SendAuxiliaryXhair);
}
setorigin(axh, loc);
own.(AuxiliaryXhair[axh_id]) = axh;
}
-void CSQCVehicleSetup(entity own, float vehicle_id)
+void CSQCVehicleSetup(entity own, int vehicle_id)
{
if(!IS_REAL_CLIENT(own))
return;
vector targetdrone_getnewspot()
{
vector spot;
- float i;
+ int i;
for(i = 0; i < 100; ++i)
{
spot = self.origin + randomvec() * 1024;
if(trace_ent.deadflag != DEAD_NO)
trace_ent = world;
- if(!((trace_ent.vehicle_flags & VHF_ISVEHICLE) || (trace_ent.turrcaps_flags & TFL_TURRCAPS_ISTURRET)))
+ if(!(IS_VEHICLE(trace_ent) || IS_TURRET(trace_ent)))
trace_ent = world;
- if(trace_ent.alpha <= 0.5)
+ if(trace_ent.alpha <= 0.5 && trace_ent.alpha != 0)
trace_ent = world; // invisible
}
}
// projectile handling
-void vehicles_projectile_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void vehicles_projectile_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
// Ignore damage from oterh projectiles from my owner (dont mess up volly's)
if(inflictor.owner == self.owner)
PROJECTILE_TOUCH;
self.event_damage = func_null;
- RadiusDamage (self, self.realowner, self.shot_dmg, 0, self.shot_radius, self, self.shot_force, self.totalfrags, other);
+ RadiusDamage (self, self.realowner, self.shot_dmg, 0, self.shot_radius, self, world, self.shot_force, self.totalfrags, other);
remove (self);
}
entity vehicles_projectile(string _mzlfx, string _mzlsound,
vector _org, vector _vel,
float _dmg, float _radi, float _force, float _size,
- float _deahtype, float _projtype, float _health,
- float _cull, float _clianim, entity _owner)
+ int _deahtype, float _projtype, float _health,
+ bool _cull, bool _clianim, entity _owner)
{
entity proj;
proj.solid = SOLID_BBOX;
proj.movetype = MOVETYPE_FLYMISSILE;
proj.flags = FL_PROJECTILE;
- proj.bot_dodge = TRUE;
+ proj.bot_dodge = true;
proj.bot_dodgerating = _dmg;
proj.velocity = _vel;
proj.touch = vehicles_projectile_explode;
sound (self, CH_WEAPON_A, _mzlsound, VOL_BASE, ATTEN_NORM);
if(_mzlfx)
- pointparticles(particleeffectnum(_mzlfx), proj.origin, proj.velocity, 1);
-
+ Send_Effect(_mzlfx, proj.origin, proj.velocity, 1);
setsize (proj, '-1 -1 -1' * _size, '1 1 1' * _size);
void vehicles_gib_explode()
{
sound (self, CH_SHOTS, "weapons/rocket_impact.wav", VOL_BASE, ATTEN_NORM);
- pointparticles(particleeffectnum("explosion_small"), randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
+ Send_Effect("explosion_small", randomvec() * 80 + (self.origin + '0 0 100'), '0 0 0', 1);
+ Send_Effect("explosion_small", self.wp00.origin + '0 0 64', '0 0 0', 1);
remove(self);
}
self.nextthink = time + 0.1;
}
-entity vehicle_tossgib(entity _template, vector _vel, string _tag, float _burn, float _explode, float _maxtime, vector _rot)
+entity vehicle_tossgib(entity _template, vector _vel, string _tag, bool _burn, bool _explode, float _maxtime, vector _rot)
{
entity _gib = spawn();
setmodel(_gib, _template.model);
return _gib;
}
-float vehicle_addplayerslot( entity _owner,
+bool vehicle_addplayerslot( entity _owner,
entity _slot,
- float _hud,
+ int _hud,
string _hud_model,
- float() _framefunc,
- void(float) _exitfunc, float() _enterfunc)
+ bool() _framefunc,
+ void(bool) _exitfunc, float() _enterfunc)
{
if(!(_owner.vehicle_flags & VHF_MULTISLOT))
_owner.vehicle_flags |= VHF_MULTISLOT;
setattachment(_slot.vehicle_hudmodel, _slot, "");
setattachment(_slot.vehicle_viewport, _slot.vehicle_hudmodel, "");
- return TRUE;
+ return true;
}
vector vehicle_aimturret(entity _vehic, vector _target, entity _turrret, string _tagname,
vtag = gettaginfo(_turrret, gettagindex(_turrret, _tagname));
vtmp = vectoangles(normalize(_target - vtag));
vtmp = AnglesTransform_ToAngles(AnglesTransform_LeftDivide(AnglesTransform_FromAngles(_vehic.angles), AnglesTransform_FromAngles(vtmp))) - _turrret.angles;
- vtmp = AnglesTransform_Normalize(vtmp, TRUE);
+ vtmp = AnglesTransform_Normalize(vtmp, true);
ftmp = _aimspeed * frametime;
vtmp_y = bound(-ftmp, vtmp_y, ftmp);
vtmp_x = bound(-ftmp, vtmp_x, ftmp);
void vehicles_spawn();
void vehicles_return()
{
- pointparticles(particleeffectnum("teleport"), self.wp00.origin + '0 0 64', '0 0 0', 1);
+ Send_Effect("teleport", self.wp00.origin + '0 0 64', '0 0 0', 1);
self.wp00.think = vehicles_spawn;
self.wp00.nextthink = time;
rgb = Team_ColorRGB(self.team);
else
rgb = '1 1 1';
- WaypointSprite_Spawn("vehicle", 0, 0, self, '0 0 64', world, 0, self, waypointsprite_attached, TRUE, RADARICON_POWERUP, rgb);
+ entity wp = WaypointSprite_Spawn(WP_Vehicle, 0, 0, self, '0 0 64', world, 0, self, waypointsprite_attached, true, RADARICON_POWERUP);
+ wp.colormod = rgb;
if(self.waypointsprite_attached)
{
WaypointSprite_UpdateRule(self.waypointsprite_attached, self.wp00.team, SPRITERULE_DEFAULT);
if(self.active == ACTIVE_ACTIVE && self.deadflag == DEAD_NO && !gameover)
{
dprint("Respawning vehicle: ", self.netname, "\n");
- vehicles_setreturn(self);
- vehicles_reset_colors();
+ if(self.effects & EF_NODRAW)
+ {
+ self.think = vehicles_spawn;
+ self.nextthink = time + 3;
+ }
+ else
+ {
+ vehicles_setreturn(self);
+ vehicles_reset_colors();
+ }
}
}
}
}
-void vehicles_damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
+void vehicles_damage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
{
self.dmg_time = time;
- if(DEATH_ISWEAPON(deathtype, WEP_NEX))
- damage *= autocvar_g_vehicles_nex_damagerate;
+ // WEAPONTODO
+ if(DEATH_ISWEAPON(deathtype, WEP_VORTEX.m_id))
+ damage *= autocvar_g_vehicles_vortex_damagerate;
- if(DEATH_ISWEAPON(deathtype, WEP_UZI))
- damage *= autocvar_g_vehicles_uzi_damagerate;
+ if(DEATH_ISWEAPON(deathtype, WEP_MACHINEGUN.m_id))
+ damage *= autocvar_g_vehicles_machinegun_damagerate;
- if(DEATH_ISWEAPON(deathtype, WEP_RIFLE))
+ if(DEATH_ISWEAPON(deathtype, WEP_RIFLE.m_id))
damage *= autocvar_g_vehicles_rifle_damagerate;
- if(DEATH_ISWEAPON(deathtype, WEP_MINSTANEX))
- damage *= autocvar_g_vehicles_minstanex_damagerate;
+ if(DEATH_ISWEAPON(deathtype, WEP_VAPORIZER.m_id))
+ damage *= autocvar_g_vehicles_vaporizer_damagerate;
- if(DEATH_ISWEAPON(deathtype, WEP_SEEKER))
+ if(DEATH_ISWEAPON(deathtype, WEP_SEEKER.m_id))
damage *= autocvar_g_vehicles_tag_damagerate;
+ if(DEATH_WEAPONOFWEAPONDEATH(deathtype))
+ damage *= autocvar_g_vehicles_weapon_damagerate;
+
self.enemy = attacker;
self.pain_finished = time;
float vehicles_crushable(entity e)
{
- if(IS_PLAYER(e))
- return TRUE;
+ if(IS_PLAYER(e) && time >= e.vehicle_enter_delay)
+ return true;
- if(e.flags & FL_MONSTER)
- return TRUE;
+ if(IS_MONSTER(e))
+ return true;
- return FALSE;
+ return false;
}
void vehicles_impact(float _minspeed, float _speedfac, float _maxpain)
return self.origin;
}
-void vehicles_exit(float eject)
+void vehicles_exit(bool eject)
{
entity _vehicle;
entity _player;
return;
}
- vehicles_exit_running = TRUE;
+ vehicles_exit_running = true;
if(IS_CLIENT(self))
{
_vehicle = self.vehicle;
{
_vehicle.vehicle_exit(eject);
self = _oldself;
- vehicles_exit_running = FALSE;
+ vehicles_exit_running = false;
return;
}
}
_player.hud = HUD_NORMAL;
_player.switchweapon = _vehicle.switchweapon;
_player.last_vehiclecheck = time + 3;
+ _player.vehicle_enter_delay = time + 2;
CSQCVehicleSetup(_player, HUD_NORMAL);
}
WaypointSprite_Kill(_vehicle.wps_intruder);
- vh_player = _player;
- vh_vehicle = _vehicle;
- MUTATOR_CALLHOOK(VehicleExit);
- _player = vh_player;
- _vehicle = vh_vehicle;
+ MUTATOR_CALLHOOK(VehicleExit, _player, _vehicle);
_vehicle.team = _vehicle.tur_head.team;
self = _oldself;
- vehicles_exit_running = FALSE;
+ vehicles_exit_running = false;
}
void vehicles_touch()
{
- if(MUTATOR_CALLHOOK(VehicleTouch))
+ if(MUTATOR_CALLHOOK(VehicleTouch, self, other))
return;
// Vehicle currently in use
if((self.origin_z + self.maxs_z) > (other.origin_z))
if(vehicles_crushable(other))
{
- if(vlen(self.velocity) != 0)
+ if(vlen(self.velocity) >= 30)
Damage(other, self, self.owner, autocvar_g_vehicles_crush_dmg, DEATH_VH_CRUSH, '0 0 0', normalize(other.origin - self.origin) * autocvar_g_vehicles_crush_force);
return; // Dont do selfdamage when hitting "soft targets".
vehicles_enter(other, self);
}
-void vehicles_enter(entity pl, entity veh)
+bool vehicle_impulse(int imp)
{
- // Remove this when bots know how to use vehicles
- if (IS_BOT_CLIENT(pl))
- if (autocvar_g_vehicles_allow_bots)
- dprint("Bot enters vehicle\n"); // This is where we need to disconnect (some, all?) normal bot AI and hand over to vehicle's _aiframe()
- else
- return;
-
- if(!IS_PLAYER(pl))
- return;
-
- if(veh.phase > time)
- return;
+ switch(imp)
+ {
+ case 17:
+ {
+ stuffcmd(self, "\ntoggle cl_eventchase_vehicle\nset _vehicles_shownchasemessage 1\n");
+ return true;
+ }
+ }
- if(pl.freezetag_frozen)
- return;
+ return false;
+}
- if(pl.deadflag != DEAD_NO)
+void vehicles_enter(entity pl, entity veh)
+{
+ // Remove this when bots know how to use vehicles
+ if((IS_BOT_CLIENT(pl) && !autocvar_g_vehicles_allow_bots))
return;
- if(pl.vehicle)
- return;
+ if((!IS_PLAYER(pl))
+ || (veh.phase >= time)
+ || (pl.vehicle_enter_delay >= time)
+ || (pl.frozen)
+ || (pl.deadflag != DEAD_NO)
+ || (pl.vehicle)
+ ) { return; }
- if(autocvar_g_vehicles_enter) // skip if we're using regular touch code
+ if(autocvar_g_vehicles_enter) // vehicle's touch function should handle this if entering via use key is disabled (TODO)
if(veh.vehicle_flags & VHF_MULTISLOT)
if(veh.owner)
{
other = pl; // TODO: fix
if(!veh.gunner1)
- if(veh.gun1.phase <= time)
+ if(time >= veh.gun1.phase)
if(veh.gun1.vehicle_enter)
if(veh.gun1.vehicle_enter())
{
}
if(!veh.gunner2)
- if(veh.gun2.phase <= time)
+ if(time >= veh.gun2.phase)
if(veh.gun2.vehicle_enter)
if(veh.gun2.vehicle_enter())
{
Send_Notification(NOTIF_ONE, pl, MSG_CENTER, CENTER_VEHICLE_STEAL_SELF);
- if(autocvar_g_vehicles_steal_show_waypoint)
- WaypointSprite_Spawn("intruder", 0, 0, pl, '0 0 68', world, veh.team, veh, wps_intruder, TRUE, RADARICON_DANGER, Team_ColorRGB(pl.team));
+ if (autocvar_g_vehicles_steal_show_waypoint) {
+ entity wp = WaypointSprite_Spawn(WP_VehicleIntruder, 0, 0, pl, '0 0 68', world, veh.team, veh, wps_intruder, true, RADARICON_DANGER);
+ wp.colormod = Team_ColorRGB(pl.team);
+ }
}
else return;
veh.vehicle_hudmodel.viewmodelforclient = pl;
- pl.crouch = FALSE;
+ tracebox(pl.origin, PL_MIN, PL_MAX, pl.origin, false, pl);
+ pl.crouch = false;
pl.view_ofs = PL_VIEW_OFS;
setsize (pl, PL_MIN, PL_MAX);
pl.takedamage = DAMAGE_NO;
pl.solid = SOLID_NOT;
pl.movetype = MOVETYPE_NOCLIP;
- pl.teleportable = FALSE;
+ pl.teleportable = false;
pl.alpha = -1;
pl.event_damage = func_null;
pl.view_ofs = '0 0 0';
pl.vehicle_ammo2 = veh.vehicle_ammo2;
pl.vehicle_reload1 = veh.vehicle_reload1;
pl.vehicle_reload2 = veh.vehicle_reload2;
+ pl.vehicle_energy = veh.vehicle_energy;
// Cant do this, hides attached objects too.
//veh.exteriormodeltoclient = veh.owner;
CSQCVehicleSetup(pl, veh.vehicleid);
- vh_player = pl;
- vh_vehicle = veh;
- MUTATOR_CALLHOOK(VehicleEnter);
+ MUTATOR_CALLHOOK(VehicleEnter, pl, veh);
entity oldself = self;
self = veh;
void vehicles_think()
{
self.nextthink = time;
-
+
if(self.owner)
self.owner.vehicle_weapon2mode = self.vehicle_weapon2mode;
-
+
VEH_ACTION(self.vehicleid, VR_THINK);
CSQCMODEL_AUTOUPDATE();
self.owner = world;
self.touch = vehicles_touch;
self.event_damage = vehicles_damage;
- self.iscreature = TRUE;
- self.teleportable = FALSE; // no teleporting for vehicles, too buggy
- self.damagedbycontents = TRUE;
+ self.iscreature = true;
+ self.teleportable = false; // no teleporting for vehicles, too buggy
+ self.damagedbycontents = true;
self.movetype = MOVETYPE_WALK;
self.solid = SOLID_SLIDEBOX;
self.takedamage = DAMAGE_AIM;
self.deadflag = DEAD_NO;
- self.bot_attack = TRUE;
+ self.bot_attack = true;
self.flags = FL_NOTARGET;
self.avelocity = '0 0 0';
self.velocity = '0 0 0';
self.angles = self.pos2;
setorigin(self, self.pos1);
// Show it
- pointparticles(particleeffectnum("teleport"), self.origin + '0 0 64', '0 0 0', 1);
+ Send_Effect("teleport", self.origin + '0 0 64', '0 0 0', 1);
if(self.vehicle_controller)
self.team = self.vehicle_controller.team;
CSQCMODEL_AUTOINIT();
}
-float vehicle_initialize(float vehicle_id, float nodrop)
+bool vehicle_initialize(entity veh, bool nodrop)
{
if(!autocvar_g_vehicles)
- return FALSE;
-
- entity veh = get_vehicleinfo(vehicle_id);
+ return false;
if(!veh.vehicleid)
- return FALSE;
+ return false;
+
+ if(!veh.tur_head) { VEH_ACTION(veh.vehicleid, VR_PRECACHE); }
- if(self.targetname)
+ if(self.targetname && self.targetname != "")
{
self.vehicle_controller = find(world, target, self.targetname);
if(!self.vehicle_controller)
{
bprint("^1WARNING: ^7Vehicle with invalid .targetname\n");
+ self.active = ACTIVE_ACTIVE;
}
else
{
}
}
}
+ else { self.active = ACTIVE_ACTIVE; }
if(self.team && (!teamplay || !autocvar_g_vehicles_teams))
self.team = 0;
- self.vehicle_flags |= VHF_ISVEHICLE;
+ if(self.mdl == "" || !self.mdl)
+ setmodel(self, veh.model);
+ else
+ setmodel(self, self.mdl);
- setmodel(self, veh.model);
+ self.vehicle_flags |= VHF_ISVEHICLE;
self.vehicle_viewport = spawn();
self.vehicle_hudmodel = spawn();
self.tur_head = spawn();
self.tur_head.owner = self;
self.takedamage = DAMAGE_NO;
- self.bot_attack = TRUE;
- self.iscreature = TRUE;
- self.teleportable = FALSE; // no teleporting for vehicles, too buggy
- self.damagedbycontents = TRUE;
- self.vehicleid = vehicle_id;
+ self.bot_attack = true;
+ self.iscreature = true;
+ self.teleportable = false; // no teleporting for vehicles, too buggy
+ self.damagedbycontents = true;
+ self.vehicleid = veh.vehicleid;
self.PlayerPhysplug = veh.PlayerPhysplug;
self.event_damage = func_null;
self.touch = vehicles_touch;
self.pos2 = self.angles;
self.tur_head.team = self.team;
- VEH_ACTION(vehicle_id, VR_SETUP);
+ VEH_ACTION(veh.vehicleid, VR_SETUP);
- if(autocvar_g_vehicles_delayspawn)
+ if(self.active == ACTIVE_NOT)
+ self.nextthink = 0; // wait until activated
+ else if(autocvar_g_vehicles_delayspawn)
self.nextthink = time + self.respawntime + (random() * autocvar_g_vehicles_delayspawn_jitter);
else
self.nextthink = time + game_starttime;
if(MUTATOR_CALLHOOK(VehicleSpawn))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
projects / xonotic / xonotic-data.pk3dir.git / blobdiff