def Check_Overhead(*qwp_extra):
qc.makevectors(qc.self.owner.angles)
# The following comparisons could be optimized by doing away with
# SRC and END, and plugging the values directly into the traceline
# function calls. Using SRC and END made debugging easier. You
# decide if it's worth it.
# quick check right above head
src = qc.self.owner.origin - Vector(0, 0, 24)
end = qc.self.owner.origin - Vector(0, 0, 24)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_forward * 16
end = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_forward * 16 + Vector(0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_forward * 16
end = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_forward * 16 + Vector(0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_right * 16
end = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_right * 16 + Vector(0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_right * 16
end = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_right * 16 + Vector(0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
return defs.TRUE
def W_FireLightning(*qwp_extra):
if qc.self.ammo_cells < 1:
qc.self.weapon = W_BestWeapon()
W_SetCurrentAmmo()
return
# explode if under water
if qc.self.waterlevel > 1:
cells = qc.self.ammo_cells
qc.self.ammo_cells = 0
W_SetCurrentAmmo()
combat.T_RadiusDamage(qc.self, qc.self, 35 * cells, qc.world)
return
if qc.self.t_width < qc.time:
qc.self.sound(defs.CHAN_WEAPON, 'weapons/lhit.wav', 1, defs.ATTN_NORM)
qc.self.t_width = qc.time + 0.6
qc.msg_entity = qc.self
qc.WriteByte(defs.MSG_ONE, defs.SVC_SMALLKICK)
qc.self.currentammo = qc.self.ammo_cells = qc.self.ammo_cells - 1
org = qc.self.origin + Vector(0, 0, 16)
qc.traceline(org, org + qc.v_forward * 600, defs.TRUE, qc.self)
qc.WriteByte(defs.MSG_MULTICAST, defs.SVC_TEMPENTITY)
qc.WriteByte(defs.MSG_MULTICAST, defs.TE_LIGHTNING2)
qc.WriteEntity(defs.MSG_MULTICAST, qc.self)
qc.WriteCoord(defs.MSG_MULTICAST, org.x)
qc.WriteCoord(defs.MSG_MULTICAST, org.y)
qc.WriteCoord(defs.MSG_MULTICAST, org.z)
qc.WriteCoord(defs.MSG_MULTICAST, qc.trace_endpos.x)
qc.WriteCoord(defs.MSG_MULTICAST, qc.trace_endpos.y)
qc.WriteCoord(defs.MSG_MULTICAST, qc.trace_endpos.z)
engine.multicast(org, defs.MULTICAST_PHS)
LightningDamage(qc.self.origin, qc.trace_endpos + qc.v_forward * 4,
qc.self, 30)
def W_FireAxe(*qwp_extra):
source = Vector(0, 0, 0)
org = Vector(0, 0, 0)
qc.makevectors(qc.self.v_angle)
source = qc.self.origin + Vector(0, 0, 16)
qc.traceline(source, source + qc.v_forward * 64, defs.FALSE, qc.self)
if qc.trace_fraction == 1.0:
return
org = qc.trace_endpos - qc.v_forward * 4
if qc.trace_ent.takedamage:
qc.trace_ent.axhitme = 1
SpawnBlood(org, 20)
if defs.deathmatch > 3:
combat.T_Damage(qc.trace_ent, qc.self, qc.self, 75)
else:
combat.T_Damage(qc.trace_ent, qc.self, qc.self, 20)
else:
# hit wall
qc.self.sound(defs.CHAN_WEAPON, 'player/axhit2.wav', 1, defs.ATTN_NORM)
qc.WriteByte(defs.MSG_MULTICAST, defs.SVC_TEMPENTITY)
qc.WriteByte(defs.MSG_MULTICAST, defs.TE_GUNSHOT)
qc.WriteByte(defs.MSG_MULTICAST, 3)
qc.WriteCoord(defs.MSG_MULTICAST, org.x)
qc.WriteCoord(defs.MSG_MULTICAST, org.y)
qc.WriteCoord(defs.MSG_MULTICAST, org.z)
engine.multicast(org, defs.MULTICAST_PVS)
def W_FireLightning(*qwp_extra):
if qc.self.ammo_cells < 1:
qc.self.weapon = W_BestWeapon()
W_SetCurrentAmmo()
return
# explode if under water
if qc.self.waterlevel > 1:
cells = qc.self.ammo_cells
qc.self.ammo_cells = 0
W_SetCurrentAmmo()
combat.T_RadiusDamage(qc.self, qc.self, 35 * cells, qc.world)
return
if qc.self.t_width < qc.time:
qc.self.sound(defs.CHAN_WEAPON, 'weapons/lhit.wav', 1, defs.ATTN_NORM)
qc.self.t_width = qc.time + 0.6
qc.msg_entity = qc.self
qc.WriteByte(defs.MSG_ONE, defs.SVC_SMALLKICK)
qc.self.currentammo = qc.self.ammo_cells = qc.self.ammo_cells - 1
org = qc.self.origin + Vector(0, 0, 16)
qc.traceline(org, org + qc.v_forward * 600, defs.TRUE, qc.self)
qc.WriteByte(defs.MSG_MULTICAST, defs.SVC_TEMPENTITY)
qc.WriteByte(defs.MSG_MULTICAST, defs.TE_LIGHTNING2)
qc.WriteEntity(defs.MSG_MULTICAST, qc.self)
qc.WriteCoord(defs.MSG_MULTICAST, org.x)
qc.WriteCoord(defs.MSG_MULTICAST, org.y)
qc.WriteCoord(defs.MSG_MULTICAST, org.z)
qc.WriteCoord(defs.MSG_MULTICAST, qc.trace_endpos.x)
qc.WriteCoord(defs.MSG_MULTICAST, qc.trace_endpos.y)
qc.WriteCoord(defs.MSG_MULTICAST, qc.trace_endpos.z)
engine.multicast(org, defs.MULTICAST_PHS)
LightningDamage(qc.self.origin, qc.trace_endpos + qc.v_forward * 4, qc.self, 30)
def identify_player(disp, *qwp_extra):
# e is a temp entity; guy is our current best guess
# as to at whom the player is pointing
guy = None
# The best "closeness" heuristic so far.
closeness = -1
# Walk the list of players...
e = qc.find(qc.world, 'classname', 'player')
while e != qc.world:
# Get a vector pointing from the viewer to the current
# player under consideration
diff = e.origin - qc.self.origin
# Normalize it since we only care where he's pointing,
# not how far away the guy is.
diff = diff.normalize()
# Normalize self.angles so we can do a length-independent
# consideration
point = qc.self.angles.normalize()
# Find the different between the current player's angle
# and the viewer's vision angle
diff -= point
# The length is going to be our definition of closeness
currclose = diff.length()
qc.traceline(qc.self.origin, e.origin, defs.FALSE, qc.self)
if qc.trace_ent == e:
if (closeness == -1) or (currclose < closeness):
closeness = currclose
guy = e
e = qc.find(e, 'classname', 'player')
# Now we display.
if disp == 0:
return guy
if not guy:
status.TeamPlayerUpdate(qc.self, "You're not looking at anyone!")
return qc.world
status.TeamPlayerUpdate2(qc.self, 'You are looking at ', guy.netname)
return guy
def identify_player(disp, *qwp_extra):
# e is a temp entity; guy is our current best guess
# as to at whom the player is pointing
guy = None
# The best "closeness" heuristic so far.
closeness = -1
# Walk the list of players...
e = qc.find(qc.world, "classname", "player")
while e != qc.world:
# Get a vector pointing from the viewer to the current
# player under consideration
diff = e.origin - qc.self.origin
# Normalize it since we only care where he's pointing,
# not how far away the guy is.
diff = diff.normalize()
# Normalize self.angles so we can do a length-independent
# consideration
point = qc.self.angles.normalize()
# Find the different between the current player's angle
# and the viewer's vision angle
diff -= point
# The length is going to be our definition of closeness
currclose = diff.length()
qc.traceline(qc.self.origin, e.origin, defs.FALSE, qc.self)
if qc.trace_ent == e:
if (closeness == -1) or (currclose < closeness):
closeness = currclose
guy = e
e = qc.find(e, "classname", "player")
# Now we display.
if disp == 0:
return guy
if not guy:
status.TeamPlayerUpdate(qc.self, "You're not looking at anyone!")
return qc.world
status.TeamPlayerUpdate2(qc.self, "You are looking at ", guy.netname)
return guy
def FireBullets(shotcount, dir, spread, *qwp_extra):
global puff_org
qc.makevectors(qc.self.v_angle)
src = qc.self.origin + qc.v_forward * 10
src %= Vector(None, None, qc.self.absmin.z + qc.self.size.z * 0.7)
ClearMultiDamage()
qc.traceline(src, src + dir * 2048, defs.FALSE, qc.self)
puff_org = qc.trace_endpos - dir * 4
while shotcount > 0:
direction = dir + crandom() * spread.x * qc.v_right + crandom() * spread.y * qc.v_up
qc.traceline(src, src + direction * 2048, defs.FALSE, qc.self)
if qc.trace_fraction != 1.0:
TraceAttack(4, direction)
shotcount -= 1
ApplyMultiDamage()
Multi_Finish()
def FireBullets(shotcount, dir, spread, *qwp_extra):
global puff_org
qc.makevectors(qc.self.v_angle)
src = qc.self.origin + qc.v_forward * 10
src %= Vector(None, None, qc.self.absmin.z + qc.self.size.z * 0.7)
ClearMultiDamage()
qc.traceline(src, src + dir * 2048, defs.FALSE, qc.self)
puff_org = qc.trace_endpos - dir * 4
while shotcount > 0:
direction = dir + crandom() * spread.x * qc.v_right + crandom(
) * spread.y * qc.v_up
qc.traceline(src, src + direction * 2048, defs.FALSE, qc.self)
if qc.trace_fraction != 1.0:
TraceAttack(4, direction)
shotcount -= 1
ApplyMultiDamage()
Multi_Finish()
def W_FireAxe(*qwp_extra):
qc.makevectors(qc.self.v_angle)
source = qc.self.origin + Vector(0, 0, 16)
qc.traceline(source, source + qc.v_forward * 64, defs.FALSE, qc.self)
if qc.trace_fraction == 1.0:
return
org = qc.trace_endpos - qc.v_forward * 4
if qc.trace_ent.takedamage:
qc.trace_ent.axhitme = 1
SpawnBlood(org, 20)
combat.T_Damage(qc.trace_ent, qc.self, qc.self, 20)
else:
# hit wall
qc.self.sound(defs.CHAN_WEAPON, 'player/axhit2.wav', 1, defs.ATTN_NORM)
qc.WriteByte(defs.MSG_MULTICAST, defs.SVC_TEMPENTITY)
qc.WriteByte(defs.MSG_MULTICAST, defs.TE_GUNSHOT)
qc.WriteByte(defs.MSG_MULTICAST, 3)
qc.WriteCoord(defs.MSG_MULTICAST, org.x)
qc.WriteCoord(defs.MSG_MULTICAST, org.y)
qc.WriteCoord(defs.MSG_MULTICAST, org.z)
engine.multicast(org, defs.MULTICAST_PVS)
def LightningDamage(p1, p2, from0, damage, *qwp_extra):
f = p2 - p1
f.normalize()
f %= Vector(0 - f.y, None, None)
f %= Vector(None, f.x, None)
f %= Vector(None, None, 0)
f *= 16
e1 = e2 = qc.world
qc.traceline(p1, p2, defs.FALSE, qc.self)
if qc.trace_ent.takedamage:
LightningHit(from0, damage)
if qc.self.classname == 'player':
if qc.other.classname == 'player':
qc.trace_ent.velocity %= Vector(None, None,
qc.trace_ent.velocity.z + 400)
e1 = qc.trace_ent
qc.traceline(p1 + f, p2 + f, defs.FALSE, qc.self)
if qc.trace_ent != e1 and qc.trace_ent.takedamage:
LightningHit(from0, damage)
e2 = qc.trace_ent
qc.traceline(p1 - f, p2 - f, defs.FALSE, qc.self)
if qc.trace_ent != e1 and qc.trace_ent != e2 and qc.trace_ent.takedamage:
LightningHit(from0, damage)
def LightningDamage(p1, p2, from0, damage, *qwp_extra):
e1 = engine.world
e2 = engine.world
f = Vector(0, 0, 0)
f = p2 - p1
f.normalize()
f %= Vector(0 - f.y, None, None)
f %= Vector(None, f.x, None)
f %= Vector(None, None, 0)
f *= 16
e1 = e2 = qc.world
qc.traceline(p1, p2, defs.FALSE, qc.self)
if qc.trace_ent.takedamage:
LightningHit(from0, damage)
if qc.self.classname == 'player':
if qc.other.classname == 'player':
qc.trace_ent.velocity %= Vector(None, None, qc.trace_ent.velocity.z + 400)
e1 = qc.trace_ent
qc.traceline(p1 + f, p2 + f, defs.FALSE, qc.self)
if qc.trace_ent != e1 and qc.trace_ent.takedamage:
LightningHit(from0, damage)
e2 = qc.trace_ent
qc.traceline(p1 - f, p2 - f, defs.FALSE, qc.self)
if qc.trace_ent != e1 and qc.trace_ent != e2 and qc.trace_ent.takedamage:
LightningHit(from0, damage)
def Check_Overhead(*qwp_extra):
qc.makevectors(qc.self.owner.angles)
# The following comparisons could be optimized by doing away with
# SRC and END, and plugging the values directly into the traceline
# function calls. Using SRC and END made debugging easier. You
# decide if it's worth it.
# quick check right above head
src = qc.self.owner.origin - Vector(0, 0, 24)
end = qc.self.owner.origin - Vector(0, 0, 24)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_forward * 16
end = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_forward * 16 + Vector(
0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_forward * 16
end = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_forward * 16 + Vector(
0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_right * 16
end = qc.self.owner.origin - Vector(0, 0, 24) - qc.v_right * 16 + Vector(
0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
src = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_right * 16
end = qc.self.owner.origin - Vector(0, 0, 24) + qc.v_right * 16 + Vector(
0, 0, 58)
qc.traceline(src, end, defs.FALSE, qc.self.owner)
if qc.trace_fraction != 1.0:
return defs.FALSE
return defs.TRUE
def CheckWaterJump(*qwp_extra):
start = Vector(0, 0, 0)
end = Vector(0, 0, 0)
# check for a jump-out-of-water
qc.makevectors(qc.self.angles)
start = qc.self.origin
start %= Vector(None, None, start.z + 8)
qc.v_forward %= Vector(None, None, 0)
qc.v_forward.normalize()
end = start + qc.v_forward * 24
qc.traceline(start, end, defs.TRUE, qc.self)
if qc.trace_fraction < 1:
# solid at waist
start %= Vector(None, None, start.z + qc.self.maxs.z - 8)
end = start + qc.v_forward * 24
qc.self.movedir = qc.trace_plane_normal * -50
qc.traceline(start, end, defs.TRUE, qc.self)
if qc.trace_fraction == 1:
# open at eye level
qc.self.flags |= defs.FL_WATERJUMP
qc.self.velocity %= Vector(None, None, 225)
qc.self.flags -= qc.self.flags & defs.FL_JUMPRELEASED
qc.self.teleport_time = qc.time + 2 # safety net
return
def CheckWaterJump(*qwp_extra):
start = Vector(0, 0, 0)
end = Vector(0, 0, 0)
# check for a jump-out-of-water
qc.makevectors(qc.self.angles)
start = qc.self.origin
start %= Vector(None, None, start.z + 8)
qc.v_forward %= Vector(None, None, 0)
qc.v_forward.normalize()
end = start + qc.v_forward * 24
qc.traceline(start, end, defs.TRUE, qc.self)
if qc.trace_fraction < 1:
# solid at waist
start %= Vector(None, None, start.z + qc.self.maxs.z - 8)
end = start + qc.v_forward * 24
qc.self.movedir = qc.trace_plane_normal * -50
qc.traceline(start, end, defs.TRUE, qc.self)
if qc.trace_fraction == 1:
# open at eye level
qc.self.flags |= defs.FL_WATERJUMP
qc.self.velocity %= Vector(None, None, 225)
qc.self.flags -= qc.self.flags & defs.FL_JUMPRELEASED
qc.self.teleport_time = qc.time + 2 # safety net
return
def CanDamage(targ, inflictor, *qwp_extra):
# bmodels need special checking because their origin is 0,0,0
if targ.movetype == defs.MOVETYPE_PUSH:
qc.traceline(inflictor.origin, 0.5 * (targ.absmin + targ.absmax), defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
if qc.trace_ent == targ:
return defs.TRUE
return defs.FALSE
qc.traceline(inflictor.origin, targ.origin, defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(15, 15, 0), defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(-15, -15, 0), defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(-15, 15, 0), defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(15, -15, 0), defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
return defs.FALSE
def CanDamage(targ, inflictor, *qwp_extra):
# bmodels need special checking because their origin is 0,0,0
if targ.movetype == defs.MOVETYPE_PUSH:
qc.traceline(inflictor.origin, 0.5 * (targ.absmin + targ.absmax),
defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
if qc.trace_ent == targ:
return defs.TRUE
return defs.FALSE
qc.traceline(inflictor.origin, targ.origin, defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(15, 15, 0), defs.TRUE,
qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(-15, -15, 0),
defs.TRUE, qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(-15, 15, 0), defs.TRUE,
qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
qc.traceline(inflictor.origin, targ.origin + Vector(15, -15, 0), defs.TRUE,
qc.self)
if qc.trace_fraction == 1:
return defs.TRUE
return defs.FALSE
