void Porto_Draw()
{
vector p, dir, ang, q, nextdir;
- float idx, portal_number, portal1_idx;
+ float portal_number, portal1_idx;
if(activeweapon != WEP_PORTO || spectatee_status || gametype == MAPINFO_TYPE_NEXBALL)
return;
p = view_origin;
polyline[0] = p;
- idx = 1;
+ int idx = 1;
portal_number = 0;
nextdir = dir;
- for(;;)
+ for(0;;)
{
dir = nextdir;
- traceline(p, p + 65536 * dir, TRUE, porto);
+ traceline(p, p + 65536 * dir, true, porto);
if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
return;
nextdir = dir - 2 * (dir * trace_plane_normal) * trace_plane_normal; // mirror dir at trace_plane_normal
continue;
++portal_number;
ang = vectoangles2(trace_plane_normal, dir);
- ang_x = -ang_x;
+ ang_x = -ang.x;
makevectors(ang);
if(!CheckWireframeBox(porto, p - 48 * v_right - 48 * v_up + 16 * v_forward, 96 * v_right, 96 * v_up, 96 * v_forward))
return;
vector GetOrthoviewFOV(vector ov_worldmin, vector ov_worldmax, vector ov_mid, vector ov_org)
{
float fovx, fovy;
- float width = (ov_worldmax_x - ov_worldmin_x);
- float height = (ov_worldmax_y - ov_worldmin_y);
+ float width = (ov_worldmax.x - ov_worldmin.x);
+ float height = (ov_worldmax.y - ov_worldmin.y);
float distance_to_middle_of_world = vlen(ov_mid - ov_org);
fovx = atan2(width/2, distance_to_middle_of_world) / M_PI * 360.0;
fovy = atan2(height/2, distance_to_middle_of_world) / M_PI * 360.0;
entity trueaim;
entity trueaim_rifle;
-#define SHOTTYPE_HITTEAM 1
-#define SHOTTYPE_HITOBSTRUCTION 2
-#define SHOTTYPE_HITWORLD 3
-#define SHOTTYPE_HITENEMY 4
+const float SHOTTYPE_HITTEAM = 1;
+const float SHOTTYPE_HITOBSTRUCTION = 2;
+const float SHOTTYPE_HITWORLD = 3;
+const float SHOTTYPE_HITENEMY = 4;
void TrueAim_Init()
{
if(vlen(trueaimpoint - traceorigin) < g_trueaim_minrange)
trueaimpoint = traceorigin + view_forward * g_trueaim_minrange;
- if(vecs_x > 0)
- vecs_y = -vecs_y;
+ if(vecs.x > 0)
+ vecs_y = -vecs.y;
else
vecs = '0 0 0';
- dv = view_right * vecs_y + view_up * vecs_z;
+ dv = view_right * vecs.y + view_up * vecs.z;
w_shotorg = traceorigin + dv;
// now move the vecs forward as much as requested if possible
- tracebox(w_shotorg, mi, ma, w_shotorg + view_forward * (vecs_x + nudge), MOVE_NORMAL, ta); // FIXME this MOVE_NORMAL part will misbehave a little in csqc
+ tracebox(w_shotorg, mi, ma, w_shotorg + view_forward * (vecs.x + nudge), MOVE_NORMAL, ta); // FIXME this MOVE_NORMAL part will misbehave a little in csqc
w_shotorg = trace_endpos - view_forward * nudge;
tracebox(w_shotorg, mi, ma, trueaimpoint, MOVE_NORMAL, ta);
vector freeze_org, freeze_ang;
entity nightvision_noise, nightvision_noise2;
-#define MAX_TIME_DIFF 5
+const float MAX_TIME_DIFF = 5;
float pickup_crosshair_time, pickup_crosshair_size;
float hitindication_crosshair_size;
float use_vortex_chargepool;
float WantEventchase()
{
if(autocvar_cl_orthoview)
- return FALSE;
+ return false;
if(intermission)
- return TRUE;
+ return true;
if(spectatee_status >= 0)
{
if(autocvar_cl_eventchase_nexball && gametype == MAPINFO_TYPE_NEXBALL && !(WepSet_GetFromStat() & WepSet_FromWeapon(WEP_PORTO)))
- return TRUE;
+ return true;
if(autocvar_cl_eventchase_death && (getstati(STAT_HEALTH) <= 0))
{
if(autocvar_cl_eventchase_death == 2)
{
// don't stop eventchase once it's started (even if velocity changes afterwards)
if(self.velocity == '0 0 0' || eventchase_running)
- return TRUE;
+ return true;
}
- else return TRUE;
+ else return true;
}
}
- return FALSE;
+ return false;
}
vector damage_blurpostprocess, content_blurpostprocess;
if(shottype == SHOTTYPE_HITWORLD)
{
v = wcross_origin - wcross_oldorigin;
- v_x /= vid_conwidth;
- v_y /= vid_conheight;
+ v.x /= vid_conwidth;
+ v.y /= vid_conheight;
if(vlen(v) > 0.01)
shottype = SHOTTYPE_HITOBSTRUCTION;
}
hitindication_crosshair_size = 0;
wcross_scale += sin(hitindication_crosshair_size) * autocvar_crosshair_hitindication;
- wcross_color_x += sin(hitindication_crosshair_size) * hitindication_color_x;
- wcross_color_y += sin(hitindication_crosshair_size) * hitindication_color_y;
- wcross_color_z += sin(hitindication_crosshair_size) * hitindication_color_z;
+ wcross_color.x += sin(hitindication_crosshair_size) * hitindication_color.x;
+ wcross_color.y += sin(hitindication_crosshair_size) * hitindication_color.y;
+ wcross_color.z += sin(hitindication_crosshair_size) * hitindication_color.z;
}
if(shottype == SHOTTYPE_HITENEMY)
float ok_ammo_charge, ok_ammo_chargepool;
ok_ammo_charge = getstatf(STAT_OK_AMMO_CHARGE);
- ok_ammo_chargepool = getstatf(STAT_OK_AMMO_CHARGEPOOl);
+ ok_ammo_chargepool = getstatf(STAT_OK_AMMO_CHARGEPOOL);
float vortex_charge, vortex_chargepool;
vortex_charge = getstatf(STAT_VORTEX_CHARGE);
if(autocvar_crosshair_effect_time > 0)
{
f = (time - wcross_name_changestarttime) / autocvar_crosshair_effect_time;
- if (!(f < 1))
+ if (f >= 1)
{
- wcross_ring_prev = ((ring_image) ? TRUE : FALSE);
+ wcross_ring_prev = ((ring_image) ? true : false);
}
if(wcross_ring_prev)
}
if (autocvar_crosshair_ring_inner && ring_inner_value) // lets draw a ring inside a ring so you can ring while you ring
- DrawCircleClippedPic(wcross_origin, wcross_size_x * ring_scale, ring_inner_image, ring_inner_value, ring_inner_rgb, wcross_alpha * ring_inner_alpha, DRAWFLAG_ADDITIVE);
+ DrawCircleClippedPic(wcross_origin, wcross_size.x * ring_scale, ring_inner_image, ring_inner_value, ring_inner_rgb, wcross_alpha * ring_inner_alpha, DRAWFLAG_ADDITIVE);
if (ring_value)
- DrawCircleClippedPic(wcross_origin, wcross_size_x * ring_scale, ring_image, ring_value, ring_rgb, wcross_alpha * ring_alpha, DRAWFLAG_ADDITIVE);
+ DrawCircleClippedPic(wcross_origin, wcross_size.x * ring_scale, ring_image, ring_value, ring_rgb, wcross_alpha * ring_alpha, DRAWFLAG_ADDITIVE);
}
#define CROSSHAIR_DO_BLUR(M,sz,wcross_name,wcross_alpha) \
while(0)
#define CROSSHAIR_DRAW_SINGLE(i,j,sz,wcross_name,wcross_alpha) \
- drawpic(wcross_origin - ('0.5 0 0' * (sz * wcross_size_x + i * wcross_blur) + '0 0.5 0' * (sz * wcross_size_y + j * wcross_blur)), wcross_name, sz * wcross_size, wcross_color, wcross_alpha, DRAWFLAG_NORMAL)
+ drawpic(wcross_origin - ('0.5 0 0' * (sz * wcross_size.x + i * wcross_blur) + '0 0.5 0' * (sz * wcross_size.y + j * wcross_blur)), wcross_name, sz * wcross_size, wcross_color, wcross_alpha, DRAWFLAG_NORMAL)
#define CROSSHAIR_DRAW(sz,wcross_name,wcross_alpha) \
CROSSHAIR_DO_BLUR(CROSSHAIR_DRAW_SINGLE,sz,wcross_name,wcross_alpha)
}
}
-#define BUTTON_3 4
-#define BUTTON_4 8
+const float BUTTON_3 = 4;
+const float BUTTON_4 = 8;
float cl_notice_run();
float prev_myteam;
void CSQC_UpdateView(float w, float h)
{
entity e;
float fov;
- float f, i;
+ float f;
+ int i;
vector vf_size, vf_min;
float a;
vf_size = getpropertyvec(VF_SIZE);
vf_min = getpropertyvec(VF_MIN);
- vid_width = vf_size_x;
- vid_height = vf_size_y;
+ vid_width = vf_size.x;
+ vid_height = vf_size.y;
vector reticle_pos = '0 0 0', reticle_size = '0 0 0';
vector splash_pos = '0 0 0', splash_size = '0 0 0';
{
// no zoom while dead or in intermission please
localcmd("-zoom\n");
- button_zoom = FALSE;
+ button_zoom = false;
}
// event chase camera
{
if(WantEventchase())
{
- eventchase_running = TRUE;
+ eventchase_running = true;
// make special vector since we can't use view_origin (It is one frame old as of this code, it gets set later with the results this code makes.)
vector current_view_origin = (csqcplayer ? csqcplayer.origin : pmove_org);
// detect maximum viewoffset and use it
if(autocvar_cl_eventchase_viewoffset)
{
- WarpZone_TraceLine(current_view_origin, current_view_origin + autocvar_cl_eventchase_viewoffset + ('0 0 1' * autocvar_cl_eventchase_maxs_z), MOVE_WORLDONLY, self);
+ WarpZone_TraceLine(current_view_origin, current_view_origin + autocvar_cl_eventchase_viewoffset + ('0 0 1' * autocvar_cl_eventchase_maxs.z), MOVE_WORLDONLY, self);
if(trace_fraction == 1) { current_view_origin += autocvar_cl_eventchase_viewoffset; }
- else { current_view_origin_z += max(0, (trace_endpos_z - current_view_origin_z) - autocvar_cl_eventchase_maxs_z); }
+ else { current_view_origin.z += max(0, (trace_endpos.z - current_view_origin.z) - autocvar_cl_eventchase_maxs.z); }
}
// We must enable chase_active to get a third person view (weapon viewmodel hidden and own player model showing).
{
eventchase_target_origin = (current_view_origin - (v_forward * eventchase_current_distance));
WarpZone_TraceLine(current_view_origin, eventchase_target_origin, MOVE_WORLDONLY, self);
- setproperty(VF_ORIGIN, (trace_endpos - (v_forward * autocvar_cl_eventchase_mins_z)));
+ setproperty(VF_ORIGIN, (trace_endpos - (v_forward * autocvar_cl_eventchase_mins.z)));
}
else { setproperty(VF_ORIGIN, trace_endpos); }
}
else if(autocvar_chase_active < 0) // time to disable chase_active if it was set by this code
{
- eventchase_running = FALSE;
+ eventchase_running = false;
cvar_set("chase_active", "0");
eventchase_current_distance = 0; // start from 0 next time
}
ov_worldmin = mi_picmin;
ov_worldmax = mi_picmax;
- float ov_width = (ov_worldmax_x - ov_worldmin_x);
- float ov_height = (ov_worldmax_y - ov_worldmin_y);
+ float ov_width = (ov_worldmax.x - ov_worldmin.x);
+ float ov_height = (ov_worldmax.y - ov_worldmin.y);
float ov_distance = (max(vid_width, vid_height) * max(ov_width, ov_height));
ov_mid = ((ov_worldmax + ov_worldmin) * 0.5);
- ov_org = vec3(ov_mid_x, ov_mid_y, (ov_mid_z + ov_distance));
+ ov_org = vec3(ov_mid.x, ov_mid.y, (ov_mid.z + ov_distance));
float ov_nearest = vlen(ov_org - vec3(
- bound(ov_worldmin_x, ov_org_x, ov_worldmax_x),
- bound(ov_worldmin_y, ov_org_y, ov_worldmax_y),
- bound(ov_worldmin_z, ov_org_z, ov_worldmax_z)
+ bound(ov_worldmin.x, ov_org.x, ov_worldmax.x),
+ bound(ov_worldmin.y, ov_org.y, ov_worldmax.y),
+ bound(ov_worldmin.z, ov_org.z, ov_worldmax.z)
));
float ov_furthest = 0;
float dist = 0;
- if((dist = vlen(vec3(ov_worldmin_x, ov_worldmin_y, ov_worldmin_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
- if((dist = vlen(vec3(ov_worldmax_x, ov_worldmin_y, ov_worldmin_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
- if((dist = vlen(vec3(ov_worldmin_x, ov_worldmax_y, ov_worldmin_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
- if((dist = vlen(vec3(ov_worldmin_x, ov_worldmin_y, ov_worldmax_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
- if((dist = vlen(vec3(ov_worldmax_x, ov_worldmax_y, ov_worldmin_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
- if((dist = vlen(vec3(ov_worldmin_x, ov_worldmax_y, ov_worldmax_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
- if((dist = vlen(vec3(ov_worldmax_x, ov_worldmin_y, ov_worldmax_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
- if((dist = vlen(vec3(ov_worldmax_x, ov_worldmax_y, ov_worldmax_z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmin.x, ov_worldmin.y, ov_worldmin.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmax.x, ov_worldmin.y, ov_worldmin.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmin.x, ov_worldmax.y, ov_worldmin.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmin.x, ov_worldmin.y, ov_worldmax.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmax.x, ov_worldmax.y, ov_worldmin.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmin.x, ov_worldmax.y, ov_worldmax.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmax.x, ov_worldmin.y, ov_worldmax.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
+ if((dist = vlen(vec3(ov_worldmax.x, ov_worldmax.y, ov_worldmax.z) - ov_org)) > ov_furthest) { ov_furthest = dist; }
cvar_settemp("r_nearclip", ftos(ov_nearest));
cvar_settemp("r_farclip_base", ftos(ov_furthest));
if(button_zoom && autocvar_cl_unpress_zoom_on_weapon_switch)
{
localcmd("-zoom\n");
- button_zoom = FALSE;
+ button_zoom = false;
}
if(autocvar_cl_unpress_attack_on_weapon_switch)
{
localcmd("-fire\n");
localcmd("-fire2\n");
- button_attack2 = FALSE;
+ button_attack2 = false;
}
}
if(last_activeweapon != activeweapon)
{
cvar_set("chase_active", ftos(chase_active_backup));
cvar_set("cl_demo_mousegrab", "0");
- camera_active = FALSE;
+ camera_active = false;
}
}
#ifdef CAMERATEST
chase_active_backup = autocvar_chase_active;
cvar_set("chase_active", "2");
cvar_set("cl_demo_mousegrab", "1");
- camera_active = TRUE;
- camera_mode = FALSE;
+ camera_active = true;
+ camera_mode = false;
}
// Draw the Crosshair
{
reticle_size_x = max(vid_conwidth, vid_conheight);
reticle_size_y = max(vid_conwidth, vid_conheight);
- reticle_pos_x = (vid_conwidth - reticle_size_x) / 2;
- reticle_pos_y = (vid_conheight - reticle_size_y) / 2;
+ reticle_pos_x = (vid_conwidth - reticle_size.x) / 2;
+ reticle_pos_y = (vid_conheight - reticle_size.y) / 2;
}
if(zoomscript_caught)
{
splash_size_x = max(vid_conwidth, vid_conheight);
splash_size_y = max(vid_conwidth, vid_conheight);
- splash_pos_x = (vid_conwidth - splash_size_x) / 2;
- splash_pos_y = (vid_conheight - splash_size_y) / 2;
+ splash_pos_x = (vid_conwidth - splash_size.x) / 2;
+ splash_pos_y = (vid_conheight - splash_size.y) / 2;
float myhealth_flash_temp;
myhealth = getstati(STAT_HEALTH);
if(cvar("r_glsl_postprocess_uservec2_enable") != e2) { cvar_set("r_glsl_postprocess_uservec2_enable", ftos(e2)); }
// blur postprocess handling done first (used by hud_damage and hud_contents)
- if((damage_blurpostprocess_x || content_blurpostprocess_x))
+ if((damage_blurpostprocess.x || content_blurpostprocess.x))
{
- float blurradius = bound(0, damage_blurpostprocess_y + content_blurpostprocess_y, autocvar_hud_postprocessing_maxblurradius);
- float bluralpha = bound(0, damage_blurpostprocess_z + content_blurpostprocess_z, autocvar_hud_postprocessing_maxbluralpha);
+ float blurradius = bound(0, damage_blurpostprocess.y + content_blurpostprocess.y, autocvar_hud_postprocessing_maxblurradius);
+ float bluralpha = bound(0, damage_blurpostprocess.z + content_blurpostprocess.z, autocvar_hud_postprocessing_maxbluralpha);
if(blurradius != old_blurradius || bluralpha != old_bluralpha) // reduce cvar_set spam as much as possible
{
cvar_set("r_glsl_postprocess_uservec1", strcat(ftos(blurradius), " ", ftos(bluralpha), " 0 0"));
scoreboard_active = HUD_WouldDrawScoreboard();
UpdateDamage();
- UpdateHitsound();
UpdateCrosshair();
+ UpdateHitsound();
if(NextFrameCommand)
{
camera_offset = '0 0 0';
current_angles = '0 0 0';
camera_direction = '0 0 0';
- camera_offset_z += 30;
- camera_offset_x += 30 * -cos(current_angles_y * DEG2RAD);
- camera_offset_y += 30 * -sin(current_angles_y * DEG2RAD);
+ camera_offset.z += 30;
+ camera_offset.x += 30 * -cos(current_angles.y * DEG2RAD);
+ camera_offset.y += 30 * -sin(current_angles.y * DEG2RAD);
current_origin = view_origin;
current_camera_offset = camera_offset;
cvar_set("camera_reset", "0");
// Camera angles
if( camera_roll )
- mouse_angles_z += camera_roll * autocvar_camera_speed_roll;
+ mouse_angles.z += camera_roll * autocvar_camera_speed_roll;
if(autocvar_camera_look_player)
{
float n;
dir = normalize(view_origin - current_position);
- n = mouse_angles_z;
+ n = mouse_angles.z;
mouse_angles = vectoangles(dir);
- mouse_angles_x = mouse_angles_x * -1;
+ mouse_angles_x = mouse_angles.x * -1;
mouse_angles_z = n;
}
else
tmp = getmousepos() * 0.1;
if(vlen(tmp)>autocvar_camera_mouse_threshold)
{
- mouse_angles_x += tmp_y * cos(mouse_angles_z * DEG2RAD) + (tmp_x * sin(mouse_angles_z * DEG2RAD));
- mouse_angles_y -= tmp_x * cos(mouse_angles_z * DEG2RAD) + (tmp_y * -sin(mouse_angles_z * DEG2RAD));
+ mouse_angles.x += tmp.y * cos(mouse_angles.z * DEG2RAD) + (tmp.x * sin(mouse_angles.z * DEG2RAD));
+ mouse_angles.y -= tmp.x * cos(mouse_angles.z * DEG2RAD) + (tmp.y * -sin(mouse_angles.z * DEG2RAD));
}
}
- while (mouse_angles_x < -180) mouse_angles_x = mouse_angles_x + 360;
- while (mouse_angles_x > 180) mouse_angles_x = mouse_angles_x - 360;
- while (mouse_angles_y < -180) mouse_angles_y = mouse_angles_y + 360;
- while (mouse_angles_y > 180) mouse_angles_y = mouse_angles_y - 360;
+ while (mouse_angles.x < -180) mouse_angles_x = mouse_angles.x + 360;
+ while (mouse_angles.x > 180) mouse_angles_x = mouse_angles.x - 360;
+ while (mouse_angles.y < -180) mouse_angles_y = mouse_angles.y + 360;
+ while (mouse_angles.y > 180) mouse_angles_y = mouse_angles.y - 360;
// Fix difference when angles don't have the same sign
delta = '0 0 0';
- if(mouse_angles_y < -60 && current_angles_y > 60)
+ if(mouse_angles.y < -60 && current_angles.y > 60)
delta = '0 360 0';
- if(mouse_angles_y > 60 && current_angles_y < -60)
+ if(mouse_angles.y > 60 && current_angles.y < -60)
delta = '0 -360 0';
if(autocvar_camera_look_player)
attenuation = 1 / max(1, attenuation);
current_angles += (mouse_angles - current_angles + delta) * attenuation;
- while (current_angles_x < -180) current_angles_x = current_angles_x + 360;
- while (current_angles_x > 180) current_angles_x = current_angles_x - 360;
- while (current_angles_y < -180) current_angles_y = current_angles_y + 360;
- while (current_angles_y > 180) current_angles_y = current_angles_y - 360;
+ while (current_angles.x < -180) current_angles_x = current_angles.x + 360;
+ while (current_angles.x > 180) current_angles_x = current_angles.x - 360;
+ while (current_angles.y < -180) current_angles_y = current_angles.y + 360;
+ while (current_angles.y > 180) current_angles_y = current_angles.y - 360;
// Camera position
tmp = '0 0 0';
dimensions = 0;
- if( camera_direction_x )
+ if( camera_direction.x )
{
- tmp_x = camera_direction_x * cos(current_angles_y * DEG2RAD);
- tmp_y = camera_direction_x * sin(current_angles_y * DEG2RAD);
+ tmp_x = camera_direction.x * cos(current_angles.y * DEG2RAD);
+ tmp_y = camera_direction.x * sin(current_angles.y * DEG2RAD);
if( autocvar_camera_forward_follows && !autocvar_camera_look_player )
- tmp_z = camera_direction_x * -sin(current_angles_x * DEG2RAD);
+ tmp_z = camera_direction.x * -sin(current_angles.x * DEG2RAD);
++dimensions;
}
- if( camera_direction_y )
+ if( camera_direction.y )
{
- tmp_x += camera_direction_y * -sin(current_angles_y * DEG2RAD);
- tmp_y += camera_direction_y * cos(current_angles_y * DEG2RAD) * cos(current_angles_z * DEG2RAD);
- tmp_z += camera_direction_y * sin(current_angles_z * DEG2RAD);
+ tmp.x += camera_direction.y * -sin(current_angles.y * DEG2RAD);
+ tmp.y += camera_direction.y * cos(current_angles.y * DEG2RAD) * cos(current_angles.z * DEG2RAD);
+ tmp.z += camera_direction.y * sin(current_angles.z * DEG2RAD);
++dimensions;
}
- if( camera_direction_z )
+ if( camera_direction.z )
{
- tmp_z += camera_direction_z * cos(current_angles_z * DEG2RAD);
+ tmp.z += camera_direction.z * cos(current_angles.z * DEG2RAD);
++dimensions;
}
projects / xonotic / xonotic-data.pk3dir.git / blobdiff