#define rkt_size 32
#define rld_size_x 256
#define rld_size_y 16

entity porto;
float trace_networkentity;
float Q3SURFACEFLAG_SLICK = 2; // low friction surface
float DPCONTENTS_SOLID = 1; // blocks player movement
float DPCONTENTS_BODY = 32; // blocks player movement
float DPCONTENTS_CORPSE = 64; // blocks player movement
float DPCONTENTS_PLAYERCLIP = 256; // blocks player movement
void Porto_Draw()
{
	vector dir;

	if(spectatee_status)
		return;
	if(intermission == 1)
		return;
	if(intermission == 2)
		return;
	if (getstati(STAT_HEALTH) <= 0)
		return;

	dir = view_forward;

	if(angles_held_status)
	{
		makevectors(angles_held);
		dir = v_forward;
	}
}

/**
 * Checks whether the server initiated a map restart (stat_game_starttime changed)
 *
 * TODO: Use a better solution where a common shared entitiy is used that contains
 * timelimit, fraglimit and game_starttime! Requires engine changes (remove STAT_TIMELIMIT
 * and STAT_FRAGLIMIT to be auto-sent)
 */
void CheckForGamestartChange() {
	float startTime;
	startTime = getstatf(STAT_GAMESTARTTIME);
	if (previous_game_starttime != startTime) {
		if ((time + 5.0) < startTime) {
			//if connecting to server while restart was active don't always play prepareforbattle
			sound(self, CHAN_VOICE, strcat("announcer/", cvar_string("cl_announcer"), "/prepareforbattle.wav"), VOL_BASEVOICE, ATTN_NONE);
		}
		if (time < startTime) {
			restartAnnouncer = spawn();
			restartAnnouncer.think = restartAnnouncer_Think;
			restartAnnouncer.nextthink = startTime - floor(startTime - time); //synchronize nextthink to startTime
		}
	}
	previous_game_starttime = startTime;
}

void Porto_Init()
{
	porto = spawn();
	porto.classname = "porto";
	porto.draw = Porto_Draw;
	porto.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP;
}

float drawtime;
float avgspeed;
vector GetCurrentFov(float fov)
{
	float zoomsensitivity, zoomspeed, zoomfactor, zoomdir, velocityzoom;

	zoomsensitivity = cvar("cl_zoomsensitivity");
	zoomfactor = cvar("cl_zoomfactor");
	if(zoomfactor < 1 || zoomfactor > 16)
		zoomfactor = 2.5;
	zoomspeed = cvar("cl_zoomspeed");
	if(zoomspeed >= 0)
		if(zoomspeed < 0.5 || zoomspeed > 16)
			zoomspeed = 3.5;

	zoomdir = button_zoom;
	if(spectatee_status > 0 || isdemo())
	{
		if(spectatorbutton_zoom)
			zoomdir = 0 + !zoomdir;
		// do not even THINK about removing this 0
		// _I_ know what I am doing
		// fteqcc does not
	}

	if(zoomdir)
		zoomin_effect = 0;

	if(zoomin_effect || camera_active)
	{
		current_viewzoom = min(1, current_viewzoom + drawframetime);
	}
	else
	{
		if(zoomspeed < 0) // instant zoom
		{
			if(zoomdir)
				current_viewzoom = 1 / zoomfactor;
			else
				current_viewzoom = 1;
		}
		else
		{
			if(zoomdir)
				current_viewzoom = 1 / bound(1, 1 / current_viewzoom + drawframetime * zoomspeed * (zoomfactor - 1), zoomfactor);
			else
				current_viewzoom = bound(1 / zoomfactor, current_viewzoom + drawframetime * zoomspeed * (1 - 1 / zoomfactor), 1);
		}
	}

	if(almost_equals(current_viewzoom, 1))
		current_zoomfraction = 0;
	else if(almost_equals(current_viewzoom, 1/zoomfactor))
		current_zoomfraction = 1;
	else
		current_zoomfraction = (current_viewzoom - 1) / (1/zoomfactor - 1);

	if(zoomsensitivity < 1)
		setsensitivityscale(pow(current_viewzoom, 1 - zoomsensitivity));
	else
		setsensitivityscale(1);

	velocityzoom = bound(0, drawframetime / max(0.000000001, cvar_or("cl_velocityzoomtime", 0.3)), 1);
	avgspeed = avgspeed * (1 - velocityzoom) + (vlen(pmove_vel) / 1000) * velocityzoom;
	velocityzoom = exp(float2range11(avgspeed * -cvar_or("cl_velocityzoom", 0) / 1) * 1);

	//print(ftos(avgspeed), " avgspeed, ", ftos(cvar_or("cl_velocityzoom", 0)), " cvar, ", ftos(velocityzoom), " return\n"); // for debugging

	float frustumx, frustumy, fovx, fovy;
	frustumy = tan(fov * M_PI / 360.0) * 0.75 * current_viewzoom * velocityzoom;
	frustumx = frustumy * vid_width / vid_height / vid_pixelheight;
	fovx = atan2(frustumx, 1) / M_PI * 360.0;
	fovy = atan2(frustumy, 1) / M_PI * 360.0;

	return '1 0 0' * fovx + '0 1 0' * fovy;
}

// this function must match W_SetupShot!
float zoomscript_caught;

vector wcross_origin;
float wcross_scale_prev, wcross_alpha_prev;
vector wcross_color_prev;
float wcross_scale_goal_prev, wcross_alpha_goal_prev;
vector wcross_color_goal_prev;
float wcross_changedonetime;

string wcross_name_goal_prev, wcross_name_goal_prev_prev;
float wcross_resolution_goal_prev, wcross_resolution_goal_prev_prev;
float wcross_name_changestarttime, wcross_name_changedonetime;
float wcross_name_alpha_goal_prev, wcross_name_alpha_goal_prev_prev;
entity trueaim;
entity trueaim_rifle;

#define SHOTTYPE_HITTEAM 1
#define SHOTTYPE_HITOBSTRUCTION 2
#define SHOTTYPE_HITWORLD 3
#define SHOTTYPE_HITENEMY 4

void TrueAim_Init()
{
	trueaim = spawn();
	trueaim.classname = "trueaim";
	trueaim.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_CORPSE;
	trueaim_rifle = spawn();
	trueaim_rifle.classname = "trueaim_rifle";
	trueaim_rifle.dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_CORPSE;
}

float EnemyHitCheck()
{
	float t;
	wcross_origin = project_3d_to_2d(trace_endpos);
	wcross_origin_z = 0;
	if(trace_networkentity < 1)
		return SHOTTYPE_HITWORLD;
	if(trace_networkentity > maxclients)
		return SHOTTYPE_HITWORLD;
	t = GetPlayerColor(trace_networkentity - 1);
	if(teamplay)
		if(t == myteam)
			return SHOTTYPE_HITTEAM;
	if(t == COLOR_SPECTATOR)
		return SHOTTYPE_HITWORLD;
	return SHOTTYPE_HITENEMY;
}

float TrueAimCheck()
{
	float nudge = 1; // added to traceline target and subtracted from result
	vector vecs, trueaimpoint, w_shotorg;
	vector mi, ma, dv;
	float shottype;
	entity ta;
	float mv;

	mi = ma = '0 0 0';
	ta = trueaim;
	mv = MOVE_NOMONSTERS;

	vecs = decompressShotOrigin(getstati(STAT_SHOTORG));

	traceline(view_origin, view_origin + view_forward * MAX_SHOT_DISTANCE, mv, ta);
	trueaimpoint = trace_endpos;

	if(vecs_x > 0)
		vecs_y = -vecs_y;
	else
		vecs = '0 0 0';

	dv = view_right * vecs_y + view_up * vecs_z;
	w_shotorg = view_origin + 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
	w_shotorg = trace_endpos - view_forward * nudge;

	tracebox(w_shotorg, mi, ma, trueaimpoint, MOVE_NORMAL, ta);
	shottype = EnemyHitCheck();
	if(shottype != SHOTTYPE_HITWORLD)
		return shottype;

#if 0
	// FIXME WHY DOES THIS NOT WORK FOR THE ROCKET LAUNCHER?
	// or rather, I know why, but see no fix
	if(vlen(trace_endpos - trueaimpoint) > vlen(ma) + vlen(mi) + 1)
		// yes, this is an ugly hack... but it seems good enough to find out whether the test hits the same place as the initial trace
		return SHOTTYPE_HITOBSTRUCTION;
#endif

	return SHOTTYPE_HITWORLD;
}

void CSQC_common_hud(void);

void CSQC_kh_hud(void);
void CSQC_ctf_hud(void);
void PostInit(void);
void CSQC_Demo_Camera();
float Sbar_WouldDrawScoreboard ();
float last_health, last_spectatee;
float camera_mode;
float reticle_type;
float chase_active_old;
float artwork_fade;
float pickup_crosshair_time, pickup_crosshair_size, pickup_flash_time, vore_flash_laststate, grab_flash_laststate;
float spawnfov_current;
float myhealth, myhealth_prev, myhealth_flash;
float contentavgalpha, liquidalpha_prev;
float old_blurradius, old_bluralpha, old_cartoon_intensity;
float stomachsplash_alpha;
float eventchase_current_distance;
float helper_pause, helper_health, helper_armor, helper_ammo, helper_speed, helper_stomachload;
vector freeze_org, freeze_ang;
vector myhealth_gentlergb;
vector liquidcolor_prev;
vector damage_blurpostprocess, content_blurpostprocess;
string artwork_image;
string intermission_song;
string NextFrameCommand;
void CSQC_UpdateView(float w, float h)
{
	entity e;
	float fov;
	float f, i, j;
	vector v, vo;
	float a;
	float respawned;

	vector reticle_pos, reticle_size;
	vector splash_pos, splash_size;
	vector artwork_pos, artwork_size;

	WaypointSprite_Load();

	if(spectatee_status)
		myteam = GetPlayerColor(spectatee_status - 1);
	else
		myteam = GetPlayerColor(player_localentnum - 1);

	ticrate = getstatf(STAT_MOVEVARS_TICRATE) * getstatf(STAT_MOVEVARS_TIMESCALE);
	vo = '0 0 1' * getstati(STAT_VIEWHEIGHT);

	warpzone_fixview_origin = pmove_org + vo;
	warpzone_fixview_angles = input_angles;
	WarpZone_FixView();
	pmove_org = warpzone_fixview_origin - vo;
	input_angles = warpzone_fixview_angles;

	if((last_health <= 0 && getstati(STAT_HEALTH) > 0) || (!spectatee_status && last_spectatee)) // also cover switching from a spectator to a player instantly
	if not(spectatee_status && last_spectatee != spectatee_status) // not if we switched players and that detects a different health
		respawned = TRUE; // stays true for one frame

	// helper system
	if(cvar("cl_helper"))
	if not(getstati(STAT_ARMOR) < g_power || time <= power_boot)
	{
		if(intermission || respawned || spectatee_status < 0 || getstati(STAT_HEALTH) <= 0 || getstati(STAT_VORE_EATEN))
		{
			// Set these helper messages as having been triggered, so that the player must first reach them before they complain.
			// Otherwise, if you don't have any start armor for instance, the helper will complain about low armor when we spawn.
			helper_health = TRUE;
			helper_armor = TRUE;
			helper_ammo = TRUE;
			helper_stomachload = TRUE;
		}
		else if(helper_pause <= time)
		{
			// health helper
			if(getstati(STAT_HEALTH) <= cvar("cl_helper_item_health"))
			{
				if(cvar("cl_helper_item_health") && !helper_health)
				{
					sound(self, CHAN_VOICE, strcat("helper/", cvar_string("cl_helper_voice"), "/health.wav"), VOL_BASEVOICE, ATTN_NONE);
					helper_health = TRUE;
					helper_pause = time + cvar("cl_helper_pause");
					helper_ammo = time + cvar("cl_helper_pause");
				}
			}
			else if(helper_health)
				helper_health = FALSE;

			// armor helper
			if(getstati(STAT_ARMOR) <= cvar("cl_helper_item_armor"))
			{
				if(cvar("cl_helper_item_armor") && !helper_armor)
				{
					sound(self, CHAN_VOICE, strcat("helper/", cvar_string("cl_helper_voice"), "/armor.wav"), VOL_BASEVOICE, ATTN_NONE);
					helper_armor = TRUE;
					helper_pause = time + cvar("cl_helper_pause");
				}
			}
			else if(helper_armor)
				helper_armor = FALSE;

			// ammo helper
			if(getstati(STAT_FUEL) <= cvar("cl_helper_item_ammo_fuel"))
			{
				if(cvar("cl_helper_item_ammo_fuel") && !helper_ammo)
				{
					sound(self, CHAN_VOICE, strcat("helper/", cvar_string("cl_helper_voice"), "/ammo.wav"), VOL_BASEVOICE, ATTN_NONE);
					helper_ammo = TRUE;
					helper_pause = time + cvar("cl_helper_pause");
				}
			}
			else if(helper_ammo)
				helper_ammo = FALSE;

			// speed helper
			if(vlen(pmove_vel) >= cvar("cl_helper_item_speed"))
			{
				if(cvar("cl_helper_item_speed") && !helper_speed)
				{
					sound(self, CHAN_VOICE, strcat("helper/", cvar_string("cl_helper_voice"), "/speed.wav"), VOL_BASEVOICE, ATTN_NONE);
					helper_speed = TRUE;
					helper_pause = time + cvar("cl_helper_pause");
				}
			}
			else if(helper_speed)
				helper_speed = FALSE;

			// stomach load helper
			if(getstati(STAT_VORE_LOAD) / getstati(STAT_VORE_MAXLOAD) >= cvar("cl_helper_item_stomachload"))
			{
				if(cvar("cl_helper_item_stomachload") && !helper_stomachload)
				{
					sound(self, CHAN_VOICE, strcat("helper/", cvar_string("cl_helper_voice"), "/stomachload.wav"), VOL_BASEVOICE, ATTN_NONE);
					helper_stomachload = TRUE;
					helper_pause = time + cvar("cl_helper_pause");
				}
			}
			else if(helper_stomachload)
				helper_stomachload = FALSE;
		}
	}

	// event chase camera
	if(cvar("chase_active") <= 0) // greater than 0 means it's enabled manually, and this code is skipped
	{
		if(spectatee_status >= 0 && (cvar("cl_eventchase_death") && getstati(STAT_HEALTH) <= 0 && !intermission && !getstati(STAT_VORE_EATEN)) || intermission)
		{
			// 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 = getpropertyvec(VF_ORIGIN);
			
			// We must enable chase_active to get a third person view (weapon viewmodel hidden and own player model showing).
			// Ideally, there should be another way to enable third person cameras, such as through setproperty()
			if(!cvar("chase_active"))
				cvar_set("chase_active", "-1"); // -1 enables chase_active while marking it as set by this code, and not by the user (which would be 1)

			// make the camera smooth back
			if(cvar("cl_eventchase_speed") && eventchase_current_distance < cvar("cl_eventchase_distance"))
				eventchase_current_distance += cvar("cl_eventchase_speed") * (cvar("cl_eventchase_distance") - eventchase_current_distance) * frametime; // slow down the further we get
			else if(eventchase_current_distance != cvar("cl_eventchase_distance"))
				eventchase_current_distance = cvar("cl_eventchase_distance");

			vector eventchase_target_origin;
			makevectors(view_angles);
			// pass 1, used to check where the camera would go and obtain the trace_fraction
			eventchase_target_origin = current_view_origin - v_forward * eventchase_current_distance;
			WarpZone_TraceLine(current_view_origin, eventchase_target_origin, MOVE_WORLDONLY, self);
			// pass 2, also multiplying view_forward with trace_fraction, to prevent the camera from going through walls
			// The 0.1 subtraction is to not limit the camera precisely at the wall surface, as that allows the view to poke through
			eventchase_target_origin = current_view_origin - v_forward * eventchase_current_distance * (trace_fraction - 0.1);
			WarpZone_TraceLine(current_view_origin, eventchase_target_origin, MOVE_WORLDONLY, self);

			setproperty(VF_ORIGIN, trace_endpos);
			setproperty(VF_ANGLES, WarpZone_TransformVAngles(WarpZone_trace_transform, view_angles));
		}
		else if(cvar("chase_active") < 0) // time to disable chase_active if it was set by this code
		{
			cvar_set("chase_active", "0");
			eventchase_current_distance = 0; // start from 0 next time
		}
	}

	if(frametime)
	{
		float apply_fov;
		apply_fov = cvar("menu_fov");
		if(g_healthsize_center >= 0 && cvar("cl_healthsize_fov") && spectatee_status >= 0)
			apply_fov += (g_healthsize_center - bound(g_healthsize_min, getstati(STAT_HEALTH), g_healthsize_max)) * cvar("cl_healthsize_fov");
		if(cvar("fov") != apply_fov)
			cvar_set("fov", ftos(apply_fov));
	}

	float apply_idlescale;
	if(cvar("cl_vore_vieweffects_idlescale_prey") && frametime)
	{
		apply_idlescale += getstatf(STAT_VORE_PROGRESS_PREY) * cvar("cl_vore_vieweffects_idlescale_prey");
		if(cvar("v_idlescale") != apply_idlescale)
			cvar_set("v_idlescale", ftos(apply_idlescale));
	}
	if(cvar("cl_vore_vieweffects_idlescale_predator") && frametime)
	{
		apply_idlescale += getstatf(STAT_VORE_PROGRESS_PRED) * cvar("cl_vore_vieweffects_idlescale_predator");
		if(cvar("v_idlescale") != apply_idlescale)
			cvar_set("v_idlescale", ftos(apply_idlescale));
	}
	if(cvar("cl_vore_vieweffects_idlescale_stomach") && frametime)
	{
		apply_idlescale += getstati(STAT_VORE_EATEN) * cvar("cl_vore_vieweffects_idlescale_stomach");
		if(cvar("v_idlescale") != apply_idlescale)
			cvar_set("v_idlescale", ftos(apply_idlescale));
	}

	// do lockview after event chase camera so that it still applies whenever necessary.
	if(intermission > 1)
	{
		setproperty(VF_ORIGIN, freeze_org);
		setproperty(VF_ANGLES, freeze_ang);
	}
	else
	{
		freeze_org = getpropertyvec(VF_ORIGIN);
		freeze_ang = getpropertyvec(VF_ANGLES);
	}

	// Render the Scene
	view_origin = getpropertyvec(VF_ORIGIN);
	view_angles = getpropertyvec(VF_ANGLES);
	makevectors(view_angles);
	view_forward = v_forward;
	view_right = v_right;
	view_up = v_up;

	vid_width = w;
	vid_height = h;

#ifdef BLURTEST
	if(time > blurtest_time0 && time < blurtest_time1)
	{
		float r, t;

		t = (time - blurtest_time0) / (blurtest_time1 - blurtest_time0);
		r = t * blurtest_radius;
		f = 1 / pow(t, blurtest_power) - 1;

		cvar_set("r_glsl_postprocess", "1");
		cvar_set("r_glsl_postprocess_uservec1", strcat(ftos(r), " ", ftos(f), " 0 0"));
	}
	else
	{
		cvar_set("r_glsl_postprocess", "0");
		cvar_set("r_glsl_postprocess_uservec1", "0 0 0 0");
	}
#endif

	TargetMusic_Advance();
	Fog_Force();

	drawframetime = max(0.000001, time - drawtime);
	drawtime = time;

	// watch for gametype changes here...
	// in ParseStuffCMD the cmd isn't executed yet :/
	// might even be better to add the gametype to TE_CSQC_INIT...?
	if(!postinit)
		PostInit();

	if(intermission && !isdemo() && !(calledhooks & HOOK_END))
		if(calledhooks & HOOK_START)
		{
			localcmd("\ncl_hook_gameend;");
			if(g_campaign)
				localcmd("\ncl_hook_campaign_gameend;");
			calledhooks |= HOOK_END;
		}

	CheckForGamestartChange();
	serverAnnouncer();
	maptimeAnnouncer();
	carrierAnnouncer();

	fov = cvar("fov");
	if(button_zoom || fov <= 59.5)
	{
		if(!zoomscript_caught)
		{
			localcmd("+button4\n");
			zoomscript_caught = 1;
			ignore_plus_zoom += 1;
		}
	}
	else
	{
		if(zoomscript_caught)
		{
			localcmd("-button4\n");
			zoomscript_caught = 0;
			ignore_minus_zoom += 1;
		}
	}

	sbar_alpha_fg = cvar("sbar_alpha_fg" ) * (1 - cvar("_menu_alpha"));
	sbar_hudselector = cvar("sbar_hudselector");
	sbar_accuracy_hud = cvar_or("sbar_accuracy_hud", 1);
	ColorTranslateMode = cvar("cl_stripcolorcodes");
	activeweapon = getstati(STAT_SWITCHWEAPON);
	f = cvar("teamplay");
	if(f != teamplay)
	{
		teamplay = f;
		Sbar_InitScores();
	}

	if(last_weapon != activeweapon) {
		weapontime = time;
		last_weapon = activeweapon;
	}

	// ALWAYS Clear Current Scene First
	R_ClearScene();

	if(checkextension("DP_CSQC_ROTATEMOVES"))
	{
		setproperty(VF_ORIGIN, view_origin);
		setproperty(VF_ANGLES, view_angles);
	}

	// Assign Standard Viewflags
	// Draw the World (and sky)
	setproperty(VF_DRAWWORLD, 1);

	// Set the console size vars
	vid_conwidth = cvar("vid_conwidth");
	vid_conheight = cvar("vid_conheight");
	vid_pixelheight = cvar("vid_pixelheight");

	// spawn fov effect
	if(cvar("cl_spawnfov"))
	{
		if(respawned)
			spawnfov_current = 1 + cvar("cl_spawnfov");

		if(spawnfov_current > 1)
			spawnfov_current -= cvar("cl_spawnfov_speed") * frametime;
		else
			spawnfov_current = 1;
		fov *= spawnfov_current;
	}

	if(respawned)
	{
		if(g_power_reboot_spawn)
			power_boot = time + g_power_reboot;
		else
			power_boot = time;
	}

	setproperty(VF_FOV, GetCurrentFov(fov));

	// Camera for demo playback
	if(camera_active)
	{
		if(cvar("camera_enable"))
			CSQC_Demo_Camera();
		else
		{
			cvar_set("chase_active", ftos(chase_active_backup));
			cvar_set("cl_demo_mousegrab", "0");
			camera_active = FALSE;
		}
	}
#ifdef CAMERATEST
	else if(cvar("camera_enable"))
#else
	else if(cvar("camera_enable") && isdemo())
#endif
	{
		// Enable required Darkplaces cvars
		chase_active_backup = cvar("chase_active");
		cvar_set("chase_active", "2");
		cvar_set("cl_demo_mousegrab", "1");
		camera_active = TRUE;
		camera_mode = FALSE;
	}

	// Draw the Crosshair
	float scoreboard_active;
	scoreboard_active = Sbar_WouldDrawScoreboard();
	setproperty(VF_DRAWCROSSHAIR, 0); //Make sure engine crosshairs are always hidden

	// Draw the Engine Status Bar (the default Quake HUD)
	setproperty(VF_DRAWENGINESBAR, 0);

	// fetch this one only once per frame
	sbar_showbinds = cvar("sbar_showbinds");
	sbar_showbinds_limit = cvar("sbar_showbinds_limit");

	// Update the mouse position
	/*
	   mousepos_x = vid_conwidth;
	   mousepos_y = vid_conheight;
	   mousepos = mousepos*0.5 + getmousepos();
	 */

	e = self;
	for(self = world; (self = nextent(self)); )
		if(self.draw)
			self.draw();
	self = e;

	R_AddEntities(MASK_NORMAL | MASK_ENGINE | MASK_ENGINEVIEWMODELS);
	R_RenderScene();

	// now switch to 2D drawing mode by calling a 2D drawing function
	// then polygon drawing will draw as 2D stuff, and NOT get queued until the
	// next R_RenderScene call
	drawstring('0 0 0', "", '1 1 0', '1 1 1', 0, 0);

	// Draw the aiming reticle for weapons that use it
	// reticle_type is changed to the item we are zooming / aiming with, to decide which reticle to use
	// It must be a persisted float for fading out to work properly (you let go of the zoom button for
	// the view to go back to normal, so reticle_type would become 0 as we fade out)
	if(spectatee_status || getstati(STAT_HEALTH) <= 0)
		reticle_type = 0; // prevent reticle from showing during the respawn zoom effect or for spectators
	else if(activeweapon && (button_zoom || zoomscript_caught))
		reticle_type = 2; // weapon zoom
	else if(button_zoom || zoomscript_caught)
		reticle_type = 1; // normal zoom

	if (reticle_type)
	{
		if(cvar("cl_reticle_stretch"))
		{
			reticle_size_x = vid_conwidth;
			reticle_size_y = vid_conheight;
			reticle_pos_x = 0;
			reticle_pos_y = 0;
		}
		else
		{
			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;
		}

		f = current_zoomfraction;
		if(zoomscript_caught)
			f = 1;
		if(cvar("cl_reticle_item_normal"))
		{
			if(reticle_type == 1 && f)
				drawpic(reticle_pos, "gfx/reticle_normal", reticle_size, '1 1 1', f * cvar("cl_reticle_item_normal"), DRAWFLAG_NORMAL);
		}
		if(cvar("cl_reticle_item_weapon"))
		{
			if(reticle_type == 2 && f)
				drawpic(reticle_pos, "gfx/reticle_weapon", reticle_size, '1 1 1', f * cvar("cl_reticle_item_weapon"), DRAWFLAG_NORMAL);
		}
	}

	// screen effects
	if(cvar("hud_contents"))
	{
		float contentalpha_temp, incontent, liquidalpha, contentfadetime;
		vector liquidcolor;

		if (getstati(STAT_VORE_EATEN))
		{
			liquidalpha = cvar("hud_contents_stomach_alpha");
			liquidcolor = stov(cvar_string("hud_contents_stomach_color"));
			incontent = 1;
		}
		else if(getstatf(STAT_VORE_PROGRESS_PREY))
		{
			liquidalpha = cvar("hud_contents_swallow_alpha");
			liquidcolor = stov(cvar_string("hud_contents_swallow_color"));
			incontent = getstatf(STAT_VORE_PROGRESS_PREY); // based on the swallow progress
		}
		else
		{
			switch(pointcontents(view_origin))
			{
				case CONTENT_WATER:
					liquidalpha = cvar("hud_contents_water_alpha");
					liquidcolor = stov(cvar_string("hud_contents_water_color"));
					incontent = 1;
					break;
					
				case CONTENT_LAVA:
					liquidalpha = cvar("hud_contents_lava_alpha");
					liquidcolor = stov(cvar_string("hud_contents_lava_color"));
					incontent = 1;
					break;	
								
				case CONTENT_SLIME:
					liquidalpha = cvar("hud_contents_slime_alpha");
					liquidcolor = stov(cvar_string("hud_contents_slime_color"));
					incontent = 1;
					break;
					
				default:
					liquidalpha = 0;
					liquidcolor = '0 0 0';
					incontent = 0;
					break;
			}
		}
		
		if(incontent) // fade in/out at different speeds so you can do e.g. instant fade when entering water and slow when leaving it.
		{ // also lets delcare previous values for blending properties, this way it isn't reset until after you have entered a different content
			contentfadetime = cvar("hud_contents_fadeintime");
			liquidalpha_prev = liquidalpha;
			liquidcolor_prev = liquidcolor;
		}
		else
			contentfadetime = cvar("hud_contents_fadeouttime");
			
		contentalpha_temp = bound(0, drawframetime / max(0.0001, contentfadetime), 1);
		contentavgalpha = contentavgalpha * (1 - contentalpha_temp) + incontent * contentalpha_temp;

		if(contentavgalpha)
			drawfill('0 0 0', '1 0 0' * vid_conwidth + '0 1 0' * vid_conheight, liquidcolor_prev, contentavgalpha * liquidalpha_prev, DRAWFLAG_NORMAL);

		if(cvar("hud_postprocessing"))
		{
			if(cvar("hud_contents_liquid_blur") && contentavgalpha)
			{
				// when inside the stomach, we use different blur settings than when we're inside other fluids
				content_blurpostprocess_x = 1;
				if(getstati(STAT_VORE_EATEN))
				{
					content_blurpostprocess_y = contentavgalpha * cvar("hud_contents_stomach_blur");
					content_blurpostprocess_z = contentavgalpha * cvar("hud_contents_stomach_blur_alpha");
				}
				else
				{
					content_blurpostprocess_y = contentavgalpha * cvar("hud_contents_liquid_blur");
					content_blurpostprocess_z = contentavgalpha * cvar("hud_contents_liquid_blur_alpha");
				}
			}
			else
			{
				content_blurpostprocess_x = 0;
				content_blurpostprocess_y = 0;
				content_blurpostprocess_z = 0;
			}
		}
	}

	if(cvar("hud_damage"))
	{
		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;

		float myhealth_flash_temp;
		myhealth = getstati(STAT_HEALTH);

		// fade out
		myhealth_flash = max(0, myhealth_flash - cvar("hud_damage_fade_rate") * frametime);
		// add new damage
		myhealth_flash = bound(0, myhealth_flash + dmg_take * cvar("hud_damage_factor"), cvar("hud_damage_maxalpha"));

		float pain_threshold, pain_threshold_lower, pain_threshold_lower_health;
		pain_threshold = cvar("hud_damage_pain_threshold");
		pain_threshold_lower = cvar("hud_damage_pain_threshold_lower");
		pain_threshold_lower_health = cvar("hud_damage_pain_threshold_lower_health");

		if(pain_threshold_lower && myhealth < pain_threshold_lower_health)
		{
			pain_threshold = pain_threshold - max(cvar("hud_damage_pain_threshold_pulsating_min"), fabs(sin(M_PI * time / cvar("hud_damage_pain_threshold_pulsating_period")))) * pain_threshold_lower * (1 - max(0, myhealth)/pain_threshold_lower_health);
		}

		myhealth_flash_temp = bound(0, myhealth_flash - pain_threshold, 1);

		if(myhealth_prev < 1)
		{
			if(myhealth >= 1)
			{
				myhealth_flash = 0; // just spawned, clear the flash immediately
				myhealth_flash_temp = 0;
			}
			else
			{
				myhealth_flash += cvar("hud_damage_fade_rate") * frametime; // dead
			}
		}

		if(spectatee_status == -1 || intermission)
		{
			myhealth_flash = 0; // observing, or match ended
			myhealth_flash_temp = 0;
		}

		myhealth_prev = myhealth;

		if(cvar("cl_gentle_damage") || cvar("cl_gentle"))
		{
			if(cvar("cl_gentle_damage") == 2)
			{
				if(myhealth_flash < pain_threshold) // only randomize when the flash is gone
				{
					myhealth_gentlergb = '1 0 0' * random() + '0 1 0' * random() + '0 0 1' * random();
				}
			}
			else
				myhealth_gentlergb = stov(cvar_string("hud_damage_gentle_color"));

			drawfill('0 0 0', '1 0 0' * vid_conwidth + '0 1 0' * vid_conheight, myhealth_gentlergb, cvar("hud_damage_gentle_alpha_multiplier") * bound(0, myhealth_flash_temp, 1) * cvar("hud_damage"), DRAWFLAG_NORMAL);
		}
		else
			drawpic(splash_pos, "gfx/blood", splash_size, stov(cvar_string("hud_damage_color")), bound(0, myhealth_flash_temp, 1) * cvar("hud_damage"), DRAWFLAG_NORMAL);

		if(cvar("hud_postprocessing"))
		{
			if(cvar("hud_damage_blur") && myhealth_flash_temp)
			{
				damage_blurpostprocess_x = 1;
				damage_blurpostprocess_y = bound(0, myhealth_flash_temp, 1) * cvar("hud_damage_blur");
				damage_blurpostprocess_z = bound(0, myhealth_flash_temp, 1) * cvar("hud_damage_blur_alpha");
			}
			else
			{
				damage_blurpostprocess_x = 0;
				damage_blurpostprocess_y = 0;
				damage_blurpostprocess_z = 0;
			}
		}
	}

	if(cvar("hud_stomach"))
	{
		if(getstati(STAT_VORE_EATEN))
		{
			if(stomachsplash_alpha < cvar("hud_stomach"))
				stomachsplash_alpha += cvar("hud_stomach_fade_in") * frametime;
			else
				stomachsplash_alpha = cvar("hud_stomach");
		}
		else if(getstati(STAT_HEALTH) > 0)
		{
			if(stomachsplash_alpha > 0)
				stomachsplash_alpha -= cvar("hud_stomach_fade_out") * frametime;
			else
				stomachsplash_alpha = 0;
		}

		if(respawned)
			stomachsplash_alpha = 0; // we respawned, remove the effect
		if(spectatee_status == -1)
			stomachsplash_alpha = 0;

		stomachsplash_alpha = bound(0, stomachsplash_alpha, 1);
		drawpic(splash_pos, "gfx/food", splash_size, stov(cvar_string("hud_stomach_color")), stomachsplash_alpha, DRAWFLAG_NORMAL);
	}

	if(cvar("hud_postprocessing"))
	{
		// all of this should be done in the engine eventually

		// disable damage blur when dead, but keep content blur
		if(getstati(STAT_HEALTH) <= 0)
			damage_blurpostprocess = '0 0 0';

		// enable or disable rendering types if they are used or not
		if(cvar("r_glsl_postprocess_uservec1_enable") != (cvar("hud_postprocessing_maxbluralpha") != 0))
			cvar_set("r_glsl_postprocess_uservec1_enable", ftos(cvar("hud_postprocessing_maxbluralpha") != 0));
		if(cvar("r_glsl_postprocess_uservec2_enable") != (cvar("hud_powerup") != 0))
			cvar_set("r_glsl_postprocess_uservec2_enable", ftos(cvar("hud_powerup") != 0));

		// lets apply the postprocess effects from the previous two functions if needed
		if((damage_blurpostprocess_x || content_blurpostprocess_x) && cvar("chase_active") >= 0) // not while the event chase camera is active
		{
			float blurradius = bound(0, damage_blurpostprocess_y + content_blurpostprocess_y, cvar("hud_postprocessing_maxblurradius"));
			float bluralpha = bound(0, damage_blurpostprocess_z + content_blurpostprocess_z, cvar("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"));
				old_blurradius = blurradius;
				old_bluralpha = bluralpha;
			}
		}
		else if(cvar_string("r_glsl_postprocess_uservec1") != "0 0 0 0") // reduce cvar_set spam as much as possible
		{
			cvar_set("r_glsl_postprocess_uservec1", "0 0 0 0");
			old_blurradius = 0;
			old_bluralpha = 0;
		}

		if(cvar("hud_powerup"))
		{
			// When having the strength or invincible powerups, enable white outlines
			// As powerup time goes under 5 seconds (warning time) the lines fade away
			float cartoon_intensity;

			if((getstatf(STAT_STRENGTH_FINISHED) >= time || getstatf(STAT_INVINCIBLE_FINISHED) >= time) && cvar("chase_active") >= 0)
			{
				// not while the event chase camera is active
				cartoon_intensity = bound(0, getstatf(STAT_STRENGTH_FINISHED) - time, 5) + bound(0, getstatf(STAT_INVINCIBLE_FINISHED) - time, 5);
				cartoon_intensity = cvar("hud_powerup") * bound(0, cartoon_intensity, 5);
			}
			else
				cartoon_intensity = 0;

			if(cartoon_intensity != old_cartoon_intensity) // reduce cvar_set spam as much as possible
			{
				cvar_set("r_glsl_postprocess_uservec2", strcat("0 ", ftos(cartoon_intensity), " ", cvar_string("hud_powerup_tolerance"), " 0"));
				old_cartoon_intensity = cartoon_intensity;
			}
		}
		else if(cvar_string("r_glsl_postprocess_uservec2") != "0 0 0 0") // reduce cvar_set spam as much as possible
		{
			cvar_set("r_glsl_postprocess_uservec2", "0 0 0 0");
			old_cartoon_intensity = 0;
		}
	}

	if(cvar("hud_postprocessing") && !cvar("hud_postprocessing_maxbluralpha"))
	if(cvar("r_glsl_postprocess_uservec1_enable"))
	{
		// don't allow blur to get stuck on if we disable the cvar while damaged
		cvar_set("r_glsl_postprocess_uservec1", "0 0 0 0");
		cvar_set("r_glsl_postprocess_uservec1_enable", "0");
	}
	if(cvar("hud_postprocessing") && !cvar("hud_powerup"))
	if(cvar("r_glsl_postprocess_uservec2_enable"))
	{
		// don't allow sharpen to get stuck on if we disable the cvar while powered up
		cvar_set("r_glsl_postprocess_uservec2", "0 0 0 0");
		cvar_set("r_glsl_postprocess_uservec2_enable", "0");
	}

	if(cvar("hud_postprocessing"))
	{
		// change saturation based on the amount of armor we have
		// ranges between 0.5 and 1 saturation, over 0 armor and half the armor limit

		if(cvar("hud_saturation_armor") && armor_max && spectatee_status != -1 && getstati(STAT_HEALTH) > 0)
		{
			float saturation;
			saturation = 0.5 + (getstati(STAT_ARMOR) / armor_max);
			saturation = bound(0, saturation, 1);

			if(cvar("r_glsl_saturation") != saturation)
				cvar_set("r_glsl_saturation", ftos(saturation));
		}
		else if (cvar("hud_saturation_death") && spectatee_status != -1 && getstati(STAT_HEALTH) <= 0)
		{
			if(cvar("r_glsl_saturation") != 0)
				cvar_set("r_glsl_saturation", "0");
		}
		else if(cvar("r_glsl_saturation") != 1)
			cvar_set("r_glsl_saturation", "1");
	}

	float target_volume;
	if(cvar("cl_vore_cutvolume_sound") && frametime)
	{
		// sound volume cutting
		target_volume = 0;
		if(getstatf(STAT_VORE_PROGRESS_PREY))
			target_volume = getstatf(STAT_VORE_PROGRESS_PREY);
		else if(getstati(STAT_VORE_EATEN))
			target_volume = 1;
		target_volume = cvar("menu_volume") * (1 - target_volume * cvar("cl_vore_cutvolume_sound"));

		if(cvar("volume") != target_volume) // reduce cvar_set spam as much as possible
			cvar_set("volume", ftos(target_volume));
	}
	if(cvar("cl_vore_cutvolume_music") && frametime)
	{
		// music volume cutting
		target_volume = 0;
		if(getstatf(STAT_VORE_PROGRESS_PREY))
			target_volume = getstatf(STAT_VORE_PROGRESS_PREY);
		else if(getstati(STAT_VORE_EATEN))
			target_volume = 1;
		target_volume = cvar("menu_bgmvolume") * (1 - target_volume * cvar("cl_vore_cutvolume_music"));

		if(cvar("bgmvolume") != target_volume) // reduce cvar_set spam as much as possible
			cvar_set("bgmvolume", ftos(target_volume));
	}

	// Draw the mouse cursor
	// NOTE: drawpic must happen after R_RenderScene for some reason
	//drawpic(getmousepos(), "gfx/cursor.tga", '11 14 0', '1 1 1', 1, 0);
	//drawstring('50 50', ftos(game), '10 10 0', '1 1 1', 1, 0);
	//self = edict_num(player_localnum);
	//drawstring('0 0', vtos(pmove_org), '8 8 0', '1 1 1', 1, 0);
	//drawstring('0 8', strcat("ORG: ", vtos(self.origin), " state: ", ftos(self.ctf_state), " HP: ", ftos(self.health)), '8 8 0', '1 1 1', 1, 0);
	// as long as the ctf part isn't in, this is useless
	if(menu_visible)
		menu_show();

	/*if(gametype == GAME_CTF)
	  {
	  ctf_view();
	  } else */

	// draw 2D entities
	e = self;
	for(self = world; (self = nextent(self)); )
		if(self.draw2d)
			self.draw2d();
	self = e;
	Draw_ShowNames_All();

	// draw radar
	if(
			showmap
			||
			(
			 !scoreboard_active
			 &&
			 cvar_string("cl_radar") != "0"
			 &&
			 (
			  cvar("cl_radar") == 2
			  ||
			  teamplay
			 )
			)
	  )
		radar_view();

	// Draw artwork and play intermission music
	if(intermission && !isdemo() && gametype != GAME_RPG && !spectatee_status) // the match has ended. Don't do this for RPG because no one wins or loses there
	{
		if(cvar("cl_artwork"))
		{
			if(artwork_image == "")
			{
				if(getstati(STAT_WINNING)) // we are the winner
				{
					if(cvar("cl_artwork_win"))
					{
						artwork_image = strcat("gfx/artwork_won_", ftos(floor(1 + (random() * cvar("cl_artwork_win")))));
						artwork_image = strzone(artwork_image);
					}
				}
				else // we have lost
				{
					if(cvar("cl_artwork_lose"))
					{
						artwork_image = strcat("gfx/artwork_lost_", ftos(floor(1 + (random() * cvar("cl_artwork_lose")))));
						artwork_image = strzone(artwork_image);
					}
				}
			}

			if(cvar("cl_artwork_stretch"))
			{
				artwork_size_x = vid_conwidth;
				artwork_size_y = vid_conheight;
				artwork_pos_x = 0;
				artwork_pos_y = 0;
			}
			else
			{
				artwork_size_x = max(vid_conwidth, vid_conheight);
				artwork_size_y = max(vid_conwidth, vid_conheight);
				artwork_pos_x = (vid_conwidth - artwork_size_x) / 2;
				artwork_pos_y = (vid_conheight - artwork_size_y) / 2;
			}

			if(artwork_fade < cvar("cl_artwork_alpha") && cvar("cl_artwork_fade"))
				artwork_fade += frametime * cvar("cl_artwork_fade");
			else
				artwork_fade = cvar("cl_artwork_alpha");

			if(artwork_image != "")
				drawpic(artwork_pos, artwork_image, artwork_size, '1 1 1', artwork_fade, DRAWFLAG_NORMAL);
		}

		if(cvar("cl_intermission") && intermission_song == "") // don't start the song each frame
		{
			if(getstati(STAT_WINNING))
				intermission_song = cvar_string("cl_intermission_cdtrack_win");
			else
				intermission_song = cvar_string("cl_intermission_cdtrack_lose");
			if(intermission_song != "")
			{
				localcmd(strcat("\ncd play ", intermission_song, "\n"));
				intermission_song = strzone(intermission_song);
			}
		}
	}
	else
	{
		artwork_fade = 0;
		if(artwork_image != "")
		{
			strunzone(artwork_image);
			artwork_image = "";
		}

		if(intermission_song != "")
		{
			strunzone(intermission_song);
			intermission_song = "";
		}
	}

	// draw sbar
	if(cvar("r_letterbox") == 0) {
		if (cvar("cl_showpressedkeys")) { // draw pressed keys when spectating and playing
			if(spectatee_status > 0 || cvar("cl_showpressedkeys") >= 2)
				Sbar_DrawPressedKeys();
		}

		if (cvar("cl_showspeed"))
			Sbar_ShowSpeed();
		if (cvar("cl_showacceleration"))
			Sbar_ShowAcceleration();

		Sbar_DrawCenterPrint(); // draw centerprint messages even if viewsize >= 120
	}

	float weapon_clipload, weapon_clipsize, ring_scale;

	float swallow_indicator;
	if(cvar("crosshair_swallowindicator"))
		swallow_indicator = getstati(STAT_VORE_CANSWALLOW);

	float hud;
	hud = getstati(STAT_HUD);

	if(cvar("r_letterbox") == 0)
		if(cvar("viewsize") < 120 && sbar_hudselector)
			CSQC_common_hud();

	if(sbar_hudselector) // flashes require some HUD components to work
	{
		if(cvar("cl_flash_pickup"))
		if(pickup_flash_time < getstatf(STAT_LAST_PICKUP))
		{
			localcmd(strcat("bf ", cvar_string("cl_flash_pickup_color"), " ", cvar_string("cl_flash_pickup"), "\n"));
			pickup_flash_time = getstatf(STAT_LAST_PICKUP);
		}
		if(cvar("cl_flash_vore"))
		{
			float vore_flash_state;
			if(getstati(STAT_VORE_EATEN))
				vore_flash_state = -1;
			else
				vore_flash_state = hud_total_prey;

			if not(spectatee_status && last_spectatee != spectatee_status) // not if we switched players and that detects a different stomach load
			{
				if(vore_flash_state > vore_flash_laststate && vore_flash_state > 0) // stomach load is bigger, so we ate someone
					localcmd(strcat("bf ", cvar_string("cl_flash_vore_color_pred"), " ", cvar_string("cl_flash_vore"), "\n"));
				if(vore_flash_state < vore_flash_laststate && vore_flash_state < 0) // -1 means we have been eaten
					localcmd(strcat("bf ", cvar_string("cl_flash_vore_color_prey"), " ", cvar_string("cl_flash_vore"), "\n"));
			}

			// always update the last vore state, or the flash can be triggered when switching spectated players one frame after
			vore_flash_laststate = vore_flash_state;
		}
		if(cvar("cl_flash_grab"))
		{
			float grab_flash_state = getstatf(STAT_VORE_PROGRESS_PREY) > 0;
			if(grab_flash_state > grab_flash_laststate)
				localcmd(strcat("bf ", cvar_string("cl_flash_grab_color"), " ", cvar_string("cl_flash_grab"), "\n"));

			// always update the last grab state, or the flash can be triggered when switching spectated players one frame after
			grab_flash_laststate = grab_flash_state;
		}
		if(cvar("cl_flash_respawn"))
		if(respawned)
			localcmd(strcat("bf ", cvar_string("cl_flash_respawn_color"), " ", cvar_string("cl_flash_respawn"), "\n"));
	}

	if not(getstati(STAT_VORE_EATEN)) // crosshair is useless if we're in the stomach
	if not(getstati(STAT_ARMOR) < g_power || time <= power_boot)
	{
		// crosshair goes VERY LAST
		if(!scoreboard_active && !showmap && !camera_active) {
			// TrueAim check
			float shottype;
			// wcross_origin = '0.5 0 0' * vid_conwidth + '0 0.5 0' * vid_conheight;
			wcross_origin = project_3d_to_2d(view_origin + MAX_SHOT_DISTANCE * view_forward);
			wcross_origin_z = 0;
			if(cvar("crosshair_hittest"))
			if(!swallow_indicator)
			{
				vector wcross_oldorigin;
				wcross_oldorigin = wcross_origin;
				shottype = TrueAimCheck();
				if(shottype == SHOTTYPE_HITWORLD)
				{
					v = wcross_origin - wcross_oldorigin;
					v_x /= vid_conwidth;
					v_y /= vid_conheight;
					if(vlen(v) > 0.01)
						shottype = SHOTTYPE_HITOBSTRUCTION;
				}
				if(!cvar("crosshair_hittest_showimpact"))
					wcross_origin = wcross_oldorigin;
			}
			else
				shottype = SHOTTYPE_HITWORLD;

			string wcross_style;

			if(swallow_indicator  > 1)
				wcross_style = "_canswallow_team.tga";
			else if(swallow_indicator > 0)
				wcross_style = "_canswallow.tga";
			else if(swallow_indicator < 0)
				wcross_style = "_canswallow_no.tga";
			else
			{
				// normal crosshair, based on what weapon we have and what firing type we can use
				if(!activeweapon)
					wcross_style = cvar_string("crosshair");
				else if(getstati(STAT_CROSSHAIR_STYLE))
					wcross_style = cvar_string("crosshair_secondary");
				else
					wcross_style = cvar_string("crosshair_primary");
			}

			if (wcross_style != "0") {
				vector wcross_color, wcross_size;
				string wcross_name;
				float wcross_alpha, wcross_scale, wcross_blur, wcross_resolution;

				if(swallow_indicator && (cvar("crosshair_swallowindicator_color_red") || cvar("crosshair_swallowindicator_color_green") || cvar("crosshair_swallowindicator_color_blue")))
				{
					wcross_color_x = cvar("crosshair_swallowindicator_color_red");
					wcross_color_y = cvar("crosshair_swallowindicator_color_green");
					wcross_color_z = cvar("crosshair_swallowindicator_color_blue");
				}
				else if(cvar("crosshair_color_by_health"))
				{
					local float x = getstati(STAT_HEALTH);
					
					//x = red
					//y = green
					//z = blue
					
					wcross_color_z = 0;
					
					if(x > 200)
					{
						wcross_color_x = 0;
						wcross_color_y = 1;
					}
					else if(x > 150)
					{
						wcross_color_x = 0.4 - (x-150)*0.02 * 0.4;
						wcross_color_y = 0.9 + (x-150)*0.02 * 0.1;
					}
					else if(x > 100)
					{
						wcross_color_x = 1 - (x-100)*0.02 * 0.6;
						wcross_color_y = 1 - (x-100)*0.02 * 0.1;
						wcross_color_z = 1 - (x-100)*0.02;
					}
					else if(x > 50)
					{
						wcross_color_x = 1;
						wcross_color_y = 1;
						wcross_color_z = 0.2 + (x-50)*0.02 * 0.8;  
					}
					else if(x > 20)
					{
						wcross_color_x = 1;
						wcross_color_y = (x-20)*90/27/100;
						wcross_color_z = (x-20)*90/27/100 * 0.2;
					}
					else
					{
						wcross_color_x = 1;
						wcross_color_y = 0;
					}
				}
				else
					wcross_color = stov(cvar_string("crosshair_color"));
				wcross_alpha = cvar("crosshair_alpha");
				wcross_resolution = cvar("crosshair_size");

				if(!activeweapon)
				if(!swallow_indicator)
				{
					if(cvar("crosshair_unarmed_dim_color"))
						wcross_color *= cvar("crosshair_unarmed_dim_color");
					if(cvar("crosshair_unarmed_dim_alpha"))
						wcross_alpha *= cvar("crosshair_unarmed_dim_alpha");
				}

				wcross_name = strcat("gfx/crosshair", wcross_style);

				if(cvar("crosshair_effect_scalefade"))
				{
					wcross_scale = wcross_resolution;
					wcross_resolution = 1;
				}
				else
				{
					wcross_scale = 1;
				}
				if(swallow_indicator)
					wcross_scale *= cvar("crosshair_swallowindicator_size");

				if(cvar("crosshair_pickup"))
				{
					if(pickup_crosshair_time < getstatf(STAT_LAST_PICKUP))
					{
						pickup_crosshair_size = 1;
						pickup_crosshair_time = getstatf(STAT_LAST_PICKUP);
					}

					if(pickup_crosshair_size > 0)
						pickup_crosshair_size -= cvar("crosshair_pickup_speed") * frametime;
					else
						pickup_crosshair_size = 0;

					wcross_scale += sin(pickup_crosshair_size) * cvar("crosshair_pickup");
				}

				if(shottype == SHOTTYPE_HITENEMY)
					wcross_scale *= cvar("crosshair_hittest"); // is not queried if hittest is 0
				if(shottype == SHOTTYPE_HITTEAM)
					wcross_scale /= cvar("crosshair_hittest"); // is not queried if hittest is 0

				f = cvar("crosshair_effect_speed");
				if(wcross_scale != wcross_scale_goal_prev || wcross_alpha != wcross_alpha_goal_prev || wcross_color != wcross_color_goal_prev)
				{
					wcross_changedonetime = time + f;
				}
				if(wcross_name != wcross_name_goal_prev || wcross_resolution != wcross_resolution_goal_prev)
				{
					wcross_name_changestarttime = time;
					wcross_name_changedonetime = time + f;
					if(wcross_name_goal_prev_prev)
						strunzone(wcross_name_goal_prev_prev);
					wcross_name_goal_prev_prev = wcross_name_goal_prev;
					wcross_name_goal_prev = strzone(wcross_name);
					wcross_name_alpha_goal_prev_prev = wcross_name_alpha_goal_prev;
					wcross_resolution_goal_prev_prev = wcross_resolution_goal_prev;
					wcross_resolution_goal_prev = wcross_resolution;
				}

				wcross_scale_goal_prev = wcross_scale;
				wcross_alpha_goal_prev = wcross_alpha;
				wcross_color_goal_prev = wcross_color;

				if(shottype == SHOTTYPE_HITTEAM || (shottype == SHOTTYPE_HITOBSTRUCTION && cvar("crosshair_hittest_blur") && !cvar("chase_active")))
				{
					wcross_blur = 1;
					wcross_alpha *= 0.75;
				}
				else
					wcross_blur = 0;
				// *_prev is at time-frametime
				// * is at wcross_changedonetime+f
				// what do we have at time?
				if(time < wcross_changedonetime)
				{
					f = frametime / (wcross_changedonetime - time + frametime);
					wcross_scale = f * wcross_scale + (1 - f) * wcross_scale_prev;
					wcross_alpha = f * wcross_alpha + (1 - f) * wcross_alpha_prev;
					wcross_color = f * wcross_color + (1 - f) * wcross_color_prev;
				}

				wcross_scale_prev = wcross_scale;
				wcross_alpha_prev = wcross_alpha;
				wcross_color_prev = wcross_color;

				wcross_scale *= 1 - cvar("_menu_alpha");
				wcross_alpha *= 1 - cvar("_menu_alpha");

#define CROSSHAIR_DO_BLUR(M,sz,wcross_name,wcross_alpha) \
				do \
				{ \
					if(wcross_blur > 0) \
					{ \
						for(i = -2; i <= 2; ++i) \
							for(j = -2; j <= 2; ++j) \
								M(i,j,sz,wcross_name,wcross_alpha*0.04); \
					} \
					else \
					{ \
						M(0,0,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)

#define CROSSHAIR_DRAW(sz,wcross_name,wcross_alpha) \
				CROSSHAIR_DO_BLUR(CROSSHAIR_DRAW_SINGLE,sz,wcross_name,wcross_alpha)

				if(time < wcross_name_changedonetime && wcross_name != wcross_name_goal_prev_prev && wcross_name_goal_prev_prev)
				{
					f = (wcross_name_changedonetime - time) / (wcross_name_changedonetime - wcross_name_changestarttime);
					wcross_size = drawgetimagesize(wcross_name_goal_prev_prev) * wcross_scale;
					CROSSHAIR_DRAW(wcross_resolution_goal_prev_prev, wcross_name_goal_prev_prev, wcross_alpha * f * wcross_name_alpha_goal_prev_prev);
					f = 1 - f;
				}
				else
				{
					f = 1;
				}

				wcross_size = drawgetimagesize(wcross_name) * wcross_scale;
				CROSSHAIR_DRAW(wcross_resolution, wcross_name, wcross_alpha * f);
				wcross_name_alpha_goal_prev = f;

				// ring around crosshair representing ammo left in weapon clip
				weapon_clipload = getstati(STAT_WEAPON_CLIPLOAD);
				a = cvar("crosshair_ring_alpha");
				if (weapon_clipload && a)
				if (!swallow_indicator)
				{
					weapon_clipsize = getstati(STAT_WEAPON_CLIPSIZE);
					ring_scale = cvar("crosshair_ring_size");
					f = bound(0, weapon_clipload / weapon_clipsize, 1);
					DrawCircleClippedPic(wcross_origin, wcross_size_x * ring_scale, "gfx/crosshair_ring.tga", f, wcross_color, wcross_alpha * a, DRAWFLAG_ADDITIVE);
				}
			}
		}
		else
		{
			wcross_scale_prev = 0;
			wcross_alpha_prev = 0;
			wcross_scale_goal_prev = 0;
			wcross_alpha_goal_prev = 0;
			wcross_changedonetime = 0;
			if(wcross_name_goal_prev)
				strunzone(wcross_name_goal_prev);
			wcross_name_goal_prev = string_null;
			if(wcross_name_goal_prev_prev)
				strunzone(wcross_name_goal_prev_prev);
			wcross_name_goal_prev_prev = string_null;
			wcross_name_changestarttime = 0;
			wcross_name_changedonetime = 0;
			wcross_name_alpha_goal_prev = 0;
			wcross_name_alpha_goal_prev_prev = 0;
			wcross_resolution_goal_prev = 0;
			wcross_resolution_goal_prev_prev = 0;
		}
	}

	if(NextFrameCommand)
	{
		localcmd("\n", NextFrameCommand, "\n");
		NextFrameCommand = string_null;
	}

	// we must do this check AFTER a frame was rendered, or it won't work
	if(cs_project_is_b0rked == 0)
	{
		string w0, h0;
		w0 = cvar_string("vid_conwidth");
		h0 = cvar_string("vid_conheight");
		//setproperty(VF_VIEWPORT, '0 0 0', '640 480 0');
		//setproperty(VF_FOV, '90 90 0');
		setproperty(VF_ORIGIN, '0 0 0');
		setproperty(VF_ANGLES, '0 0 0');
		setproperty(VF_PERSPECTIVE, 1);
		makevectors('0 0 0');
		vector v1, v2;
		cvar_set("vid_conwidth", "800");
		cvar_set("vid_conheight", "600");
		v1 = cs_project(v_forward);
		cvar_set("vid_conwidth", "640");
		cvar_set("vid_conheight", "480");
		v2 = cs_project(v_forward);
		if(v1 == v2)
			cs_project_is_b0rked = 1;
		else
			cs_project_is_b0rked = -1;
		cvar_set("vid_conwidth", w0);
		cvar_set("vid_conheight", h0);
	}

	// be safe against triggerbots until everyone has the fixed engine
	// this call is meant to overwrite the trace globals by something
	// unsuspicious
	traceline('0 0 0', '0 0 0', MOVE_WORLDONLY, world);

	// this cvar must be constantly updated on the server
	if(chase_active_old != cvar("chase_active"))
	{
		localcmd("sendcvar chase_active\n");
		chase_active_old = cvar("chase_active");
	}

	// update some stats to be detected next frame
	last_health = getstati(STAT_HEALTH);
	last_spectatee = spectatee_status;
}

void Sbar_Draw();

void CSQC_common_hud(void)
{
	// Sbar_SortFrags(); done in Sbar_Draw
	float hud;
	hud = getstati(STAT_HUD);

	//hud = 10;
	switch(hud)
	{
		case HUD_NORMAL:
			Sbar_Draw();
			break;
	}
}


// following vectors must be global to allow seamless switching between camera modes
vector camera_offset, current_camera_offset, mouse_angles, current_angles, current_origin, current_position;
void CSQC_Demo_Camera()
{
	float speed, attenuation, dimensions;
	vector tmp, delta;

	if( cvar("camera_reset") || !camera_mode )
	{
		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);
		current_origin = view_origin;
		current_camera_offset  = camera_offset;
		cvar_set("camera_reset", "0");
		camera_mode = CAMERA_CHASE;
	}

	// Camera angles
	if( camera_roll )
		mouse_angles_z += camera_roll * cvar("camera_speed_roll");

	if(cvar("camera_look_player"))
	{
		local vector dir;
		local float n;

		dir = normalize(view_origin - current_position);
		n = mouse_angles_z;
		mouse_angles = vectoangles(dir);
		mouse_angles_x = mouse_angles_x * -1;
		mouse_angles_z = n;
	}
	else
	{
		tmp = getmousepos() * 0.1;
		if(vlen(tmp)>cvar("camera_mouse_treshold"))
		{
			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;

	// Fix difference when angles don't have the same sign
	delta = '0 0 0';
	if(mouse_angles_y < -60 && current_angles_y > 60)
		delta = '0 360 0';
	if(mouse_angles_y > 60 && current_angles_y < -60)
		delta = '0 -360 0';

	if(cvar("camera_look_player"))
		attenuation = cvar("camera_look_attenuation");
	else
		attenuation = cvar("camera_speed_attenuation");

	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;

	// Camera position
	tmp = '0 0 0';
	dimensions = 0;

	if( camera_direction_x )
	{
		tmp_x = camera_direction_x * cos(current_angles_y * DEG2RAD);
		tmp_y = camera_direction_x * sin(current_angles_y * DEG2RAD);
		if( cvar("camera_forward_follows") && !cvar("camera_look_player") )
			tmp_z = camera_direction_x * -sin(current_angles_x * DEG2RAD);
		++dimensions;
	}

	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);
		++dimensions;
	}

	if( camera_direction_z )
	{
		tmp_z += camera_direction_z * cos(current_angles_z * DEG2RAD);
		++dimensions;
	}

	if(cvar("camera_free"))
		speed = cvar("camera_speed_free");
	else
		speed = cvar("camera_speed_chase");

	if(dimensions)
	{
		speed = speed * sqrt(1 / dimensions);
		camera_offset += tmp * speed;
	}

	current_camera_offset += (camera_offset - current_camera_offset) * attenuation;

	// Camera modes
	if( cvar("camera_free") )
	{
		if ( camera_mode == CAMERA_CHASE )
		{
			current_camera_offset = current_origin + current_camera_offset;
			camera_offset = current_origin + camera_offset;
		}

		camera_mode = CAMERA_FREE;
		current_position = current_camera_offset;
	}
	else
	{
		if ( camera_mode == CAMERA_FREE )
		{
			current_origin = view_origin;
			camera_offset = camera_offset - current_origin;
			current_camera_offset = current_camera_offset - current_origin;
		}

		camera_mode = CAMERA_CHASE;

		if(cvar("camera_chase_smoothly"))
			current_origin += (view_origin - current_origin) * attenuation;
		else
			current_origin = view_origin;

		current_position = current_origin + current_camera_offset;
	}

	setproperty(VF_ANGLES, current_angles);
	setproperty(VF_ORIGIN, current_position);
}