shockwave.sw_time = time;
}
+.vector beam_color;
+.float beam_alpha;
+.float beam_thickness;
+.float beam_traileffect;
+.float beam_hiteffect;
+.float beam_hitlight[4]; // 0: radius, 123: rgb
+.float beam_muzzleeffect;
+.float beam_muzzlelight[4]; // 0: radius, 123: rgb
+.string beam_image;
+
+.entity beam_muzzleentity;
+
.float beam_usevieworigin;
.float beam_initialized;
.float beam_maxangle;
.float beam_range;
.float beam_returnspeed;
+.float beam_tightness;
.vector beam_shotorigin;
.vector beam_dir;
-void Draw_ArcBeam()
+
+entity Draw_ArcBeam_callback_entity;
+vector Draw_ArcBeam_callback_new_dir;
+float Draw_ArcBeam_callback_segmentdist;
+float Draw_ArcBeam_callback_last_thickness;
+vector Draw_ArcBeam_callback_last_top;
+vector Draw_ArcBeam_callback_last_bottom;
+
+void Draw_ArcBeam_callback(vector start, vector hit, vector end)
{
- if(self.teleport_time)
- if(time > self.teleport_time)
+ entity beam = Draw_ArcBeam_callback_entity;
+ vector transformed_view_org;
+ transformed_view_org = WarpZone_TransformOrigin(WarpZone_trace_transform, view_origin);
+
+ vector thickdir = normalize(cross(normalize(start - hit), transformed_view_org - start));
+
+ vector hitorigin;
+
+ // draw segment
+ #if 0
+ if(trace_fraction != 1)
+ {
+ // calculate our own hit origin as trace_endpos tends to jump around annoyingly (to player origin?)
+ hitorigin = start + (Draw_ArcBeam_callback_new_dir * Draw_ArcBeam_callback_segmentdist * trace_fraction);
+ hitorigin = WarpZone_TransformOrigin(WarpZone_trace_transform, hitorigin);
+ }
+ else
{
- sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, ATTEN_NORM); // safeguard
- self.teleport_time = 0;
+ hitorigin = hit;
}
+ #else
+ hitorigin = hit;
+ #endif
+
+ // decide upon thickness
+ float thickness = beam.beam_thickness;
+
+ // draw primary beam render
+ vector top = hitorigin + (thickdir * thickness);
+ vector bottom = hitorigin - (thickdir * thickness);
+ vector last_top = start + (thickdir * Draw_ArcBeam_callback_last_thickness);
+ vector last_bottom = start - (thickdir * Draw_ArcBeam_callback_last_thickness);
+
+ R_BeginPolygon(beam.beam_image, DRAWFLAG_NORMAL); // DRAWFLAG_ADDITIVE
+ R_PolygonVertex(
+ top,
+ '0 0.5 0' + ('0 0.5 0' * (thickness / beam.beam_thickness)),
+ beam.beam_color,
+ beam.beam_alpha
+ );
+ R_PolygonVertex(
+ last_top,
+ '0 0.5 0' + ('0 0.5 0' * (Draw_ArcBeam_callback_last_thickness / beam.beam_thickness)),
+ beam.beam_color,
+ beam.beam_alpha
+ );
+ R_PolygonVertex(
+ last_bottom,
+ '0 0.5 0' * (1 - (Draw_ArcBeam_callback_last_thickness / beam.beam_thickness)),
+ beam.beam_color,
+ beam.beam_alpha
+ );
+ R_PolygonVertex(
+ bottom,
+ '0 0.5 0' * (1 - (thickness / beam.beam_thickness)),
+ beam.beam_color,
+ beam.beam_alpha
+ );
+ R_EndPolygon();
+
+ // draw trailing particles
+ // NOTES:
+ // - Don't use spammy particle counts here, use a FEW small particles around the beam
+ // - We're not using WarpZone_TrailParticles here because we will handle warpzones ourselves.
+ if(beam.beam_traileffect)
+ {
+ trailparticles(beam, beam.beam_traileffect, start, hitorigin);
+ }
+
+ // set up for the next
+ Draw_ArcBeam_callback_last_thickness = thickness;
+ Draw_ArcBeam_callback_last_top = top;
+ Draw_ArcBeam_callback_last_bottom = bottom;
+}
+void Draw_ArcBeam()
+{
InterpolateOrigin_Do();
// origin = beam starting origin
vector wantdir; //= view_forward;
vector beamdir; //= self.beam_dir;
+ float segments;
if(self.beam_usevieworigin)
{
- // find *exactly* where we are aiming
+ // WEAPONTODO:
+ // Currently we have to replicate nearly the same method of figuring
+ // out the shotdir that the server does... Ideally in the future we
+ // should be able to acquire this from a generalized function built
+ // into a weapon system for client code.
+
+ // find where we are aiming
makevectors(view_angles);
// decide upon start position
view_up = vu;
// un-adjust trueaim if shotend is too close
- if(vlen(shothitpos - view_origin) < cvar("g_trueaim_minrange"))
- shothitpos = view_origin + (view_forward * cvar("g_trueaim_minrange"));
+ if(vlen(shothitpos - view_origin) < g_trueaim_minrange)
+ shothitpos = view_origin + (view_forward * g_trueaim_minrange);
// move shot origin to the actual gun muzzle origin
vector origin_offset = view_forward * self.beam_shotorigin_x + view_right * -self.beam_shotorigin_y + view_up * self.beam_shotorigin_z;
self.beam_initialized = TRUE;
}
+ // WEAPONTODO: Calculate segments dyanmically similarly to the server code
+ segments = 20;
if(self.beam_dir != wantdir)
{
float angle = ceil(vlen(wantdir - self.beam_dir) * RAD2DEG);
// calculate how much we're going to move the end of the beam to the want position
float blendfactor = bound(0, anglelimit * (1 - (self.beam_returnspeed * frametime)), 1);
self.beam_dir = normalize((wantdir * (1 - blendfactor)) + (self.beam_dir * blendfactor));
+
+ // WEAPONTODO (server and client):
+ // blendfactor never actually becomes 0 in this situation, which is a problem
+ // regarding precision... this means that self.beam_dir and w_shotdir approach
+ // eachother, however they never actually become the same value with this method.
+
+ // Perhaps we should do some form of rounding/snapping?
+
+ // printf("blendfactor = %f\n", blendfactor);
+
+ #if 0
+ // calculate how many segments are needed
+ float max_allowed_segments;
+
+ if(WEP_CVAR(arc, beam_distancepersegment))
+ max_allowed_segments = min(ARC_MAX_SEGMENTS, 1 + (vlen(w_shotdir / WEP_CVAR(arc, beam_distancepersegment))));
+ else
+ max_allowed_segments = ARC_MAX_SEGMENTS;
+
+ if(WEP_CVAR(arc, beam_degreespersegment))
+ {
+ segments = min( max(1, ( min(angle, WEP_CVAR(arc, beam_maxangle)) / WEP_CVAR(arc, beam_degreespersegment) ) ), max_allowed_segments );
+ }
+ else
+ {
+ segments = 1;
+ }
+ #endif
+ }
+ #if 0
+ else
+ {
+ segments = 1;
}
+ #endif
- // finally, set the beam direction which the rest of the code will refer to
+ // set the beam direction which the rest of the code will refer to
beamdir = self.beam_dir;
+
+ // finally, set self.angles to the proper direction so that muzzle attachment points in proper direction
+ self.angles = fixedvectoangles2(view_forward, view_up);
}
else
{
start_pos = self.origin;
wantdir = self.v_angle;
beamdir = self.angles;
- }
- setorigin(self, start_pos);
+ // WEAPONTODO: Calculate segments dyanmically similarly to the server code
+ segments = 20;
+ #if 0
+ if(beamdir != wantdir)
+ {
+ // calculate how many segments are needed
+ float max_allowed_segments;
- vector beam_endpos_estimate = (start_pos + (beamdir * self.beam_range));
+ if(WEP_CVAR(arc, beam_distancepersegment))
+ max_allowed_segments = min(ARC_MAX_SEGMENTS, 1 + (vlen(w_shotdir / WEP_CVAR(arc, beam_distancepersegment))));
+ else
+ max_allowed_segments = ARC_MAX_SEGMENTS;
- float i;
- float segments = 20; // todo: calculate this in a similar way to server does
- float maxthickness = 8;
-
- vector beamrgb;
- float beamalpha;
- float thickness;
-
- /*
- #define ARC_BT_MISS 0
- #define ARC_BT_WALL 1
- #define ARC_BT_HEAL 2
- #define ARC_BT_HIT 3
- #define ARC_BT_BURST_MISS 10
- #define ARC_BT_BURST_WALL 11
- #define ARC_BT_BURST_HEAL 12
- #define ARC_BT_BURST_HIT 13
- */
-
- switch(self.beam_type)
- {
- case ARC_BT_MISS: beamrgb = '-1 -1 1'; beamalpha = 0.5; thickness = 8; break;
- case ARC_BT_WALL: beamrgb = '0.5 0.5 1'; beamalpha = 0.5; thickness = 8; break;
- case ARC_BT_HEAL: beamrgb = '0 1 0'; beamalpha = 0.5; thickness = 8; break;
- case ARC_BT_HIT: beamrgb = '1 0 1'; beamalpha = 0.5; thickness = 8; break;
- case ARC_BT_BURST_MISS: beamrgb = '-1 -1 1'; beamalpha = 0.5; thickness = 14; break;
- case ARC_BT_BURST_WALL: beamrgb = '0.5 0.5 1'; beamalpha = 0.5; thickness = 14; break;
- case ARC_BT_BURST_HEAL: beamrgb = '0 1 0'; beamalpha = 0.5; thickness = 14; break;
- case ARC_BT_BURST_HIT: beamrgb = '1 0 1'; beamalpha = 0.5; thickness = 14; break;
-
- // shouldn't be possible...
- default: beamrgb = '1 1 1'; beamalpha = 1; thickness = 4; break;
+ if(WEP_CVAR(arc, beam_degreespersegment))
+ {
+ segments = min( max(1, ( min(angle, WEP_CVAR(arc, beam_maxangle)) / WEP_CVAR(arc, beam_degreespersegment) ) ), max_allowed_segments );
+ }
+ else
+ {
+ segments = 1;
+ }
+ }
+ else
+ {
+ segments = 1;
+ }
+ #endif
}
- printf("beam type: %d\n", self.beam_type);
-
- vector thickdir = normalize(cross(beamdir, view_origin - start_pos));
+ setorigin(self, start_pos);
+ self.beam_muzzleentity.angles_z = random() * 360; // WEAPONTODO: use avelocity instead?
- vector last_origin = start_pos;
+ vector beam_endpos_estimate = (start_pos + (beamdir * self.beam_range));
- float lastthickness = 0;
+ Draw_ArcBeam_callback_entity = self;
+ Draw_ArcBeam_callback_last_thickness = 0;
+ Draw_ArcBeam_callback_last_top = start_pos;
+ Draw_ArcBeam_callback_last_bottom = start_pos;
- vector last_top = start_pos + (thickdir * lastthickness);
- vector last_bottom = start_pos - (thickdir * lastthickness);
+ vector last_origin = start_pos;
+ //vector hitorigin = start_pos;
+ float i;
for(i = 1; i <= segments; ++i)
{
+ // WEAPONTODO (server and client):
+ // Segment blend and distance should probably really be calculated in a better way,
+ // however I am not sure how to do it properly. There are a few things I have tried,
+ // but most of them do not work properly due to my lack of understanding regarding
+ // the mathematics behind them.
+
+ // Ideally, we should calculate the positions along a perfect curve
+ // between wantdir and self.beam_dir with an option for depth of arc
+
+ // Another issue is that (on the client code) we must separate the
+ // curve into multiple rendered curves when handling warpzones.
+
+ // I can handle this by detecting it for each segment, however that
+ // is a fairly inefficient method in comparison to having a curved line
+ // drawing function similar to Draw_CylindricLine that accepts
+ // top and bottom origins as input, this way there would be no
+ // overlapping edges when connecting the curved pieces.
+
+ // WEAPONTODO (client):
+ // In order to do nice fading and pointing on the starting segment, we must always
+ // have that drawn as a separate triangle... However, that is difficult to do when
+ // keeping in mind the above problems and also optimizing the amount of segments
+ // drawn on screen at any given time. (Automatic beam quality scaling, essentially)
+
// calculate this on every segment to ensure that we always reach the full length of the attack
- float segmentblend = (i/segments);
+ float segmentblend = bound(0, (i/segments) + self.beam_tightness, 1);
float segmentdist = vlen(beam_endpos_estimate - last_origin) * (i/segments);
vector new_dir = normalize( (wantdir * (1 - segmentblend)) + (normalize(beam_endpos_estimate - last_origin) * segmentblend) );
vector new_origin = last_origin + (new_dir * segmentdist);
- WarpZone_TraceLine(
+ Draw_ArcBeam_callback_segmentdist = segmentdist;
+ Draw_ArcBeam_callback_new_dir = new_dir;
+
+ WarpZone_TraceBox_ThroughZone(
last_origin,
+ '0 0 0',
+ '0 0 0',
new_origin,
MOVE_NORMAL,
- self
+ world,
+ world,
+ Draw_ArcBeam_callback
);
- vector hitorigin;
-
- // draw segment
- if(trace_fraction != 1)
- {
- // calculate our own hit origin as trace_endpos tends to jump around annoyingly (to player origin?)
- hitorigin = last_origin + (new_dir * segmentdist * trace_fraction);
- }
- else
- {
- hitorigin = new_origin;
- }
-
- #if 0
- float falloff = ExponentialFalloff(
- WEP_CVAR(arc, beam_falloff_mindist),
- WEP_CVAR(arc, beam_falloff_maxdist),
- WEP_CVAR(arc, beam_falloff_halflifedist),
- vlen(WarpZone_UnTransformOrigin(WarpZone_trace_transform, hitorigin) - start_pos)
- );
- #else
- //float falloff = 1;
- #endif
-
- vector top = hitorigin + (thickdir * thickness);
- vector bottom = hitorigin - (thickdir * thickness);
-
- R_BeginPolygon("particles/lgbeam", DRAWFLAG_NORMAL);
- R_PolygonVertex(top, '0 0.5 0' + ('0 0.5 0' * (thickness / maxthickness)), beamrgb, beamalpha);
- R_PolygonVertex(last_top, '0 0.5 0' + ('0 0.5 0' * (lastthickness / maxthickness)), beamrgb, beamalpha);
- R_PolygonVertex(last_bottom, '0 0.5 0' * (1 - (lastthickness / maxthickness)), beamrgb, beamalpha);
- R_PolygonVertex(bottom, '0 0.5 0' * (1 - (thickness / maxthickness)), beamrgb, beamalpha);
- R_EndPolygon();
-
- // draw collision effect
- if(trace_fraction != 1)
+ // check if we're going to proceed with drawing
+ //if(trace_fraction != 1)
+ //{
+ // we're done with drawing this frame
+ //last_origin = last_origin + (new_dir * segmentdist * trace_fraction);
+ //hitorigin = last_origin + (new_dir * segmentdist * trace_fraction);
+ //break;
+ //}
+ //else
{
- #if 0
- switch(self.beam_type)
- {
- //case ARC_BT_MISS: te_customflash(hitorigin, 40, 5, '1 1 0'); break;
- case ARC_BT_WALL: te_customflash(hitorigin, 40, 2, '0 0 1'); break;
- case ARC_BT_HIT: te_customflash(hitorigin, 80, 5, '1 0 0'); break;
- //case ARC_BT_MISS: te_customflash(hitorigin, 80, 5, '0 1 0'); break;
- default: te_customflash(hitorigin, 40, 2, '0 1 0'); break;
- }
- #endif
- pointparticles(particleeffectnum("electro_lightning"), hitorigin, beamdir * -1, frametime * 2);
- break; // we're done with drawing this frame
- }
- else
- {
- last_origin = new_origin; // continue onto the next segment
- last_top = top;
- last_bottom = bottom;
- lastthickness = thickness;
+ // continue onto the next segment
+ last_origin = WarpZone_TransformOrigin(WarpZone_trace_transform, new_origin);
+ beam_endpos_estimate = WarpZone_TransformOrigin(WarpZone_trace_transform, beam_endpos_estimate);
}
}
- if(trace_fraction == 1)
+ if(self.beam_hiteffect)
+ {
+ pointparticles(self.beam_hiteffect, last_origin, beamdir * -1, frametime * 2);
+ }
+ if(self.beam_hitlight[0])
{
- // do end of beam effect here
+ adddynamiclight(last_origin, self.beam_hitlight[0], vec3(self.beam_hitlight[1], self.beam_hitlight[2], self.beam_hitlight[3]));
}
+ if(self.beam_muzzleeffect)
+ {
+ pointparticles(self.beam_muzzleeffect, start_pos + wantdir * 20, wantdir * 1000, frametime * 0.1);
+ }
+ if(self.beam_muzzlelight[0])
+ {
+ adddynamiclight(start_pos + wantdir * 20, self.beam_muzzlelight[0], vec3(self.beam_muzzlelight[1], self.beam_muzzlelight[2], self.beam_muzzlelight[3]));
+ }
+
+ // cleanup
+ Draw_ArcBeam_callback_entity = world;
+ Draw_ArcBeam_callback_new_dir = '0 0 0';
+ Draw_ArcBeam_callback_segmentdist = 0;
+ Draw_ArcBeam_callback_last_thickness = 0;
+ Draw_ArcBeam_callback_last_top = '0 0 0';
+ Draw_ArcBeam_callback_last_bottom = '0 0 0';
}
void Remove_ArcBeam(void)
{
+ remove(self.beam_muzzleentity);
sound(self, CH_SHOTS_SINGLE, "misc/null.wav", VOL_BASE, ATTEN_NORM);
}
void Ent_ReadArcBeam(float isnew)
{
float sf = ReadByte();
+ entity flash;
// self.iflags = IFLAG_ORIGIN | IFLAG_ANGLES | IFLAG_V_ANGLE; // why doesn't this work?
self.iflags = IFLAG_ORIGIN;
InterpolateOrigin_Undo();
+ if(isnew)
+ {
+ // calculate shot origin offset from gun alignment
+ float gunalign = autocvar_cl_gunalign;
+ if(gunalign != 1 && gunalign != 2 && gunalign != 4)
+ gunalign = 3; // default value
+ --gunalign;
+
+ self.beam_shotorigin = arc_shotorigin[gunalign];
+
+ // set other main attributes of the beam
+ self.draw = Draw_ArcBeam;
+ self.entremove = Remove_ArcBeam;
+ sound(self, CH_SHOTS_SINGLE, "weapons/lgbeam_fly.wav", VOL_BASE, ATTEN_NORM);
+
+ flash = spawn();
+ flash.owner = self;
+ flash.effects = EF_ADDITIVE | EF_FULLBRIGHT;
+ flash.drawmask = MASK_NORMAL;
+ flash.solid = SOLID_NOT;
+ setattachment(flash, self, "");
+ setorigin(flash, '0 0 0');
+
+ self.beam_muzzleentity = flash;
+ }
+ else
+ {
+ flash = self.beam_muzzleentity;
+ }
+
if(sf & 1) // settings information
{
self.beam_maxangle = ReadShort();
self.beam_range = ReadCoord();
self.beam_returnspeed = ReadShort();
+ self.beam_tightness = (ReadByte() / 10);
+
+ if(ReadByte())
+ {
+ if(autocvar_chase_active)
+ { self.beam_usevieworigin = 1; }
+ else // use view origin
+ { self.beam_usevieworigin = 2; }
+ }
+ else
+ {
+ self.beam_usevieworigin = 0;
+ }
}
if(sf & 2) // starting location
self.origin_x = ReadCoord();
self.origin_y = ReadCoord();
self.origin_z = ReadCoord();
- setorigin(self, self.origin);
- self.beam_usevieworigin = 0;
- //WriteCoord(MSG_ENTITY, WEP_CVAR(arc, beam_range));
}
- else // infer the location from player location
+ else if(self.beam_usevieworigin) // infer the location from player location
{
- if(autocvar_chase_active) // use player origin so that third person display still works
+ if(self.beam_usevieworigin == 2)
{
- self.beam_usevieworigin = 1;
- self.origin = getplayerorigin(player_localnum) + ('0 0 1' * getstati(STAT_VIEWHEIGHT));
+ // use view origin
+ self.origin = view_origin;
}
- else // use view origin
+ else
{
- self.beam_usevieworigin = 2;
- self.origin = view_origin; // note that this is only necessary for the sound to be properly located
+ // use player origin so that third person display still works
+ self.origin = getplayerorigin(player_localnum) + ('0 0 1' * getstati(STAT_VIEWHEIGHT));
}
- setorigin(self, self.origin);
}
+ setorigin(self, self.origin);
+
if(sf & 4) // want/aim direction
{
self.v_angle_x = ReadCoord();
if(sf & 16) // beam type
{
self.beam_type = ReadByte();
- }
-
- InterpolateOrigin_Note();
-
- if(isnew || !self.teleport_time)
- {
- // calculate shot origin offset from gun alignment
- float gunalign = autocvar_cl_gunalign;
- if(gunalign != 1 && gunalign != 2 && gunalign != 4)
- gunalign = 3; // default value
- --gunalign;
-
- self.beam_shotorigin = arc_shotorigin[gunalign];
+ switch(self.beam_type)
+ {
+ case ARC_BT_MISS:
+ {
+ self.beam_color = '-1 -1 1';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 8;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = particleeffectnum("electro_lightning");
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ case ARC_BT_WALL: // grenadelauncher_muzzleflash healray_muzzleflash
+ {
+ self.beam_color = '0.5 0.5 1';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 8;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = particleeffectnum("electro_lightning");
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; // particleeffectnum("grenadelauncher_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ case ARC_BT_HEAL:
+ {
+ self.beam_color = '0 1 0';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 8;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = particleeffectnum("healray_impact");
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ case ARC_BT_HIT:
+ {
+ self.beam_color = '1 0 1';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 8;
+ self.beam_traileffect = particleeffectnum("nex_beam");
+ self.beam_hiteffect = particleeffectnum("electro_lightning");
+ self.beam_hitlight[0] = 20;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 0;
+ self.beam_hitlight[3] = 0;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 50;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 0;
+ self.beam_muzzlelight[3] = 0;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ case ARC_BT_BURST_MISS:
+ {
+ self.beam_color = '-1 -1 1';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 14;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = particleeffectnum("electro_lightning");
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ case ARC_BT_BURST_WALL:
+ {
+ self.beam_color = '0.5 0.5 1';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 14;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = particleeffectnum("electro_lightning");
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ case ARC_BT_BURST_HEAL:
+ {
+ self.beam_color = '0 1 0';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 14;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = particleeffectnum("electro_lightning");
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ case ARC_BT_BURST_HIT:
+ {
+ self.beam_color = '1 0 1';
+ self.beam_alpha = 0.5;
+ self.beam_thickness = 14;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = particleeffectnum("electro_lightning");
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
- // set other main attributes of the beam
- self.draw = Draw_ArcBeam;
- self.entremove = Remove_ArcBeam;
- sound(self, CH_SHOTS_SINGLE, "weapons/lgbeam_fly.wav", VOL_BASE, ATTEN_NORM);
+ // shouldn't be possible, but lets make it colorful if it does :D
+ default:
+ {
+ self.beam_color = randomvec();
+ self.beam_alpha = 1;
+ self.beam_thickness = 8;
+ self.beam_traileffect = FALSE;
+ self.beam_hiteffect = FALSE;
+ self.beam_hitlight[0] = 0;
+ self.beam_hitlight[1] = 1;
+ self.beam_hitlight[2] = 1;
+ self.beam_hitlight[3] = 1;
+ self.beam_muzzleeffect = FALSE; //particleeffectnum("nex_muzzleflash");
+ self.beam_muzzlelight[0] = 0;
+ self.beam_muzzlelight[1] = 1;
+ self.beam_muzzlelight[2] = 1;
+ self.beam_muzzlelight[3] = 1;
+ self.beam_image = "particles/lgbeam";
+ setmodel(flash, "models/flash.md3");
+ flash.alpha = self.beam_alpha;
+ flash.colormod = self.beam_color;
+ flash.scale = 0.5;
+ break;
+ }
+ }
}
- self.teleport_time = time + 10;
+ InterpolateOrigin_Note();
#if 0
printf(
projects / xonotic / xonotic-data.pk3dir.git / blobdiff