path: root/src/jake2/game/PlayerView.java

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// Created on 28.12.2003 by RST.
// $Id: PlayerView.java,v 1.1 2004-07-07 19:59:24 hzi Exp $

package jake2.game;

import jake2.*;
import jake2.client.*;
import jake2.qcommon.*;
import jake2.render.*;
import jake2.server.*;

public class PlayerView extends PlayerClient {

	public static edict_t current_player;
	public static gclient_t current_client;

	public static float[] forward = { 0, 0, 0 }, right = { 0, 0, 0 }, up = { 0, 0, 0 };
	public static float xyspeed;

	public static float bobmove;
	public static int bobcycle; // odd cycles are right foot going forward
	public static float bobfracsin; // sin(bobfrac*M_PI)

	/*
	===============
	SV_CalcRoll
	
	===============
	*/
	public static float SV_CalcRoll(float[] angles, float[] velocity) {
		float sign;
		float side;
		float value;

		side = DotProduct(velocity, right);
		sign = side < 0 ? -1 : 1;
		side = Math.abs(side);

		value = sv_rollangle.value;

		if (side < sv_rollspeed.value)
			side = side * value / sv_rollspeed.value;
		else
			side = value;

		return side * sign;
	}

	/*
	===============
	P_DamageFeedback
	
	Handles color blends and view kicks
	===============
	*/
	private static int xxxi = 0;

	public static void P_DamageFeedback(edict_t player) {
		gclient_t client;
		float side;
		float realcount, count, kick;
		float[] v = { 0, 0, 0 };
		int r, l;
		float[] power_color = { 0.0f, 1.0f, 0.0f };
		float[] acolor = { 1.0f, 1.0f, 1.0f };
		float[] bcolor = { 1.0f, 0.0f, 0.0f };

		client = player.client;

		// flash the backgrounds behind the status numbers
		client.ps.stats[STAT_FLASHES] = 0;
		if (client.damage_blood != 0)
			client.ps.stats[STAT_FLASHES] |= 1;
		if (client.damage_armor != 0 && 0 == (player.flags & FL_GODMODE) && (client.invincible_framenum <= level.framenum))
			client.ps.stats[STAT_FLASHES] |= 2;

		// total points of damage shot at the player this frame
		count = (client.damage_blood + client.damage_armor + client.damage_parmor);

		if (count == 0)
			return; // didn't take any damage

		// start a pain animation if still in the player model
		if ((client.anim_priority < ANIM_PAIN) & (player.s.modelindex == 255)) {
			client.anim_priority = ANIM_PAIN;
			if ((client.ps.pmove.pm_flags & PMF_DUCKED) != 0) {
				player.s.frame = FRAME_crpain1 - 1;
				client.anim_end = FRAME_crpain4;
			}
			else {

				xxxi = (xxxi + 1) % 3;
				switch (xxxi) {
					case 0 :
						player.s.frame = FRAME_pain101 - 1;
						client.anim_end = FRAME_pain104;
						break;
					case 1 :
						player.s.frame = FRAME_pain201 - 1;
						client.anim_end = FRAME_pain204;
						break;
					case 2 :
						player.s.frame = FRAME_pain301 - 1;
						client.anim_end = FRAME_pain304;
						break;
				}
			}
		}

		realcount = count;
		if (count < 10)
			count = 10; // always make a visible effect

		// play an apropriate pain sound
		if ((level.time > player.pain_debounce_time)
			&& 0 == (player.flags & FL_GODMODE)
			&& (client.invincible_framenum <= level.framenum)) {
			r = 1 + (rand() & 1);
			player.pain_debounce_time = level.time + 0.7f;
			if (player.health < 25)
				l = 25;
			else if (player.health < 50)
				l = 50;
			else if (player.health < 75)
				l = 75;
			else
				l = 100;
			gi.sound(player, CHAN_VOICE, gi.soundindex("*pain" + l + "_" + r + ".wav"), 1, ATTN_NORM, 0);
		}

		// the total alpha of the blend is always proportional to count
		if (client.damage_alpha < 0)
			client.damage_alpha = 0;
		client.damage_alpha += count * 0.01f;
		if (client.damage_alpha < 0.2f)
			client.damage_alpha = 0.2f;
		if (client.damage_alpha > 0.6f)
			client.damage_alpha = 0.6f; // don't go too saturated

		// the color of the blend will vary based on how much was absorbed
		// by different armors
		VectorClear(v);
		if (client.damage_parmor != 0)
			VectorMA(v, (float) client.damage_parmor / realcount, power_color, v);

		if (client.damage_armor != 0)
			VectorMA(v, (float) client.damage_armor / realcount, acolor, v);

		if (client.damage_blood != 0)
			VectorMA(v, (float) client.damage_blood / realcount, bcolor, v);
		VectorCopy(v, client.damage_blend);

		//
		// calculate view angle kicks
		//
		kick = Math.abs(client.damage_knockback);
		if (kick != 0 && player.health > 0) // kick of 0 means no view adjust at all
			{
			kick = kick * 100 / player.health;

			if (kick < count * 0.5)
				kick = count * 0.5f;
			if (kick > 50)
				kick = 50;

			VectorSubtract(client.damage_from, player.s.origin, v);
			VectorNormalize(v);

			side = DotProduct(v, right);
			client.v_dmg_roll = kick * side * 0.3f;

			side = -DotProduct(v, forward);
			client.v_dmg_pitch = kick * side * 0.3f;

			client.v_dmg_time = level.time + DAMAGE_TIME;
		}

		//
		// clear totals
		//
		client.damage_blood = 0;
		client.damage_armor = 0;
		client.damage_parmor = 0;
		client.damage_knockback = 0;
	}

	/*
	===============
	SV_CalcViewOffset
	
	Auto pitching on slopes?
	
	  fall from 128: 400 = 160000
	  fall from 256: 580 = 336400
	  fall from 384: 720 = 518400
	  fall from 512: 800 = 640000
	  fall from 640: 960 = 
	
	  damage = deltavelocity*deltavelocity  * 0.0001
	
	===============
	*/
	public static void SV_CalcViewOffset(edict_t ent) {
		float angles[] = { 0, 0, 0 };
		float bob;
		float ratio;
		float delta;
		float[] v = { 0, 0, 0 };

		//===================================

		// base angles
		angles = ent.client.ps.kick_angles;

		// if dead, fix the angle and don't add any kick
		if (ent.deadflag != 0) {
			VectorClear(angles);

			ent.client.ps.viewangles[ROLL] = 40;
			ent.client.ps.viewangles[PITCH] = -15;
			ent.client.ps.viewangles[YAW] = ent.client.killer_yaw;
		}
		else {
			// add angles based on weapon kick

			VectorCopy(ent.client.kick_angles, angles);

			// add angles based on damage kick

			ratio = (ent.client.v_dmg_time - level.time) / DAMAGE_TIME;
			if (ratio < 0) {
				ratio = 0;
				ent.client.v_dmg_pitch = 0;
				ent.client.v_dmg_roll = 0;
			}
			angles[PITCH] += ratio * ent.client.v_dmg_pitch;
			angles[ROLL] += ratio * ent.client.v_dmg_roll;

			// add pitch based on fall kick

			ratio = (ent.client.fall_time - level.time) / FALL_TIME;
			if (ratio < 0)
				ratio = 0;
			angles[PITCH] += ratio * ent.client.fall_value;

			// add angles based on velocity

			delta = DotProduct(ent.velocity, forward);
			angles[PITCH] += delta * run_pitch.value;

			delta = DotProduct(ent.velocity, right);
			angles[ROLL] += delta * run_roll.value;

			// add angles based on bob

			delta = bobfracsin * bob_pitch.value * xyspeed;
			if ((ent.client.ps.pmove.pm_flags & PMF_DUCKED) != 0)
				delta *= 6; // crouching
			angles[PITCH] += delta;
			delta = bobfracsin * bob_roll.value * xyspeed;
			if ((ent.client.ps.pmove.pm_flags & PMF_DUCKED) != 0)
				delta *= 6; // crouching
			if ((bobcycle & 1) != 0)
				delta = -delta;
			angles[ROLL] += delta;
		}

		//===================================

		// base origin

		VectorClear(v);

		// add view height

		v[2] += ent.viewheight;

		// add fall height

		ratio = (ent.client.fall_time - level.time) / FALL_TIME;
		if (ratio < 0)
			ratio = 0;
		v[2] -= ratio * ent.client.fall_value * 0.4;

		// add bob height

		bob = bobfracsin * xyspeed * bob_up.value;
		if (bob > 6)
			bob = 6;
		//gi.DebugGraph (bob *2, 255);
		v[2] += bob;

		// add kick offset

		VectorAdd(v, ent.client.kick_origin, v);

		// absolutely bound offsets
		// so the view can never be outside the player box

		if (v[0] < -14)
			v[0] = -14;
		else if (v[0] > 14)
			v[0] = 14;
		if (v[1] < -14)
			v[1] = -14;
		else if (v[1] > 14)
			v[1] = 14;
		if (v[2] < -22)
			v[2] = -22;
		else if (v[2] > 30)
			v[2] = 30;

		VectorCopy(v, ent.client.ps.viewoffset);
	}

	/*
	==============
	SV_CalcGunOffset
	==============
	*/
	public static void SV_CalcGunOffset(edict_t ent) {
		int i;
		float delta;

		// gun angles from bobbing
		ent.client.ps.gunangles[ROLL] = xyspeed * bobfracsin * 0.005f;
		ent.client.ps.gunangles[YAW] = xyspeed * bobfracsin * 0.01f;
		if ((bobcycle & 1) != 0) {
			ent.client.ps.gunangles[ROLL] = -ent.client.ps.gunangles[ROLL];
			ent.client.ps.gunangles[YAW] = -ent.client.ps.gunangles[YAW];
		}

		ent.client.ps.gunangles[PITCH] = xyspeed * bobfracsin * 0.005f;

		// gun angles from delta movement
		for (i = 0; i < 3; i++) {
			delta = ent.client.oldviewangles[i] - ent.client.ps.viewangles[i];
			if (delta > 180)
				delta -= 360;
			if (delta < -180)
				delta += 360;
			if (delta > 45)
				delta = 45;
			if (delta < -45)
				delta = -45;
			if (i == YAW)
				ent.client.ps.gunangles[ROLL] += 0.1 * delta;
			ent.client.ps.gunangles[i] += 0.2 * delta;
		}

		// gun height
		VectorClear(ent.client.ps.gunoffset);
		//	ent.ps.gunorigin[2] += bob;

		// gun_x / gun_y / gun_z are development tools
		for (i = 0; i < 3; i++) {
			ent.client.ps.gunoffset[i] += forward[i] * (gun_y.value);
			ent.client.ps.gunoffset[i] += right[i] * gun_x.value;
			ent.client.ps.gunoffset[i] += up[i] * (-gun_z.value);
		}
	}

	/*
	=============
	SV_AddBlend
	=============
	*/
	public static void SV_AddBlend(float r, float g, float b, float a, float v_blend[]) {
		float a2, a3;

		if (a <= 0)
			return;
		a2 = v_blend[3] + (1 - v_blend[3]) * a; // new total alpha
		a3 = v_blend[3] / a2; // fraction of color from old

		v_blend[0] = v_blend[0] * a3 + r * (1 - a3);
		v_blend[1] = v_blend[1] * a3 + g * (1 - a3);
		v_blend[2] = v_blend[2] * a3 + b * (1 - a3);
		v_blend[3] = a2;
	}

	/*
	=============
	SV_CalcBlend
	=============
	*/
	public static void SV_CalcBlend(edict_t ent) {
		int contents;
		float[] vieworg = { 0, 0, 0 };
		int remaining;

		ent.client.ps.blend[0] = ent.client.ps.blend[1] = ent.client.ps.blend[2] = ent.client.ps.blend[3] = 0;

		// add for contents
		VectorAdd(ent.s.origin, ent.client.ps.viewoffset, vieworg);
		contents = gi.pointcontents.pointcontents(vieworg);
		if ((contents & (CONTENTS_LAVA | CONTENTS_SLIME | CONTENTS_WATER)) != 0)
			ent.client.ps.rdflags |= RDF_UNDERWATER;
		else
			ent.client.ps.rdflags &= ~RDF_UNDERWATER;

		if ((contents & (CONTENTS_SOLID | CONTENTS_LAVA)) != 0)
			SV_AddBlend(1.0f, 0.3f, 0.0f, 0.6f, ent.client.ps.blend);
		else if ((contents & CONTENTS_SLIME) != 0)
			SV_AddBlend(0.0f, 0.1f, 0.05f, 0.6f, ent.client.ps.blend);
		else if ((contents & CONTENTS_WATER) != 0)
			SV_AddBlend(0.5f, 0.3f, 0.2f, 0.4f, ent.client.ps.blend);

		// add for powerups
		if (ent.client.quad_framenum > level.framenum) {
			remaining = (int) (ent.client.quad_framenum - level.framenum);
			if (remaining == 30) // beginning to fade
				gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage2.wav"), 1, ATTN_NORM, 0);
			if (remaining > 30 || (remaining & 4) != 0)
				SV_AddBlend(0, 0, 1, 0.08f, ent.client.ps.blend);
		}
		else if (ent.client.invincible_framenum > level.framenum) {
			remaining = (int) ent.client.invincible_framenum - level.framenum;
			if (remaining == 30) // beginning to fade
				gi.sound(ent, CHAN_ITEM, gi.soundindex("items/protect2.wav"), 1, ATTN_NORM, 0);
			if (remaining > 30 || (remaining & 4) != 0)
				SV_AddBlend(1, 1, 0, 0.08f, ent.client.ps.blend);
		}
		else if (ent.client.enviro_framenum > level.framenum) {
			remaining = (int) ent.client.enviro_framenum - level.framenum;
			if (remaining == 30) // beginning to fade
				gi.sound(ent, CHAN_ITEM, gi.soundindex("items/airout.wav"), 1, ATTN_NORM, 0);
			if (remaining > 30 || (remaining & 4) != 0)
				SV_AddBlend(0, 1, 0, 0.08f, ent.client.ps.blend);
		}
		else if (ent.client.breather_framenum > level.framenum) {
			remaining = (int) ent.client.breather_framenum - level.framenum;
			if (remaining == 30) // beginning to fade
				gi.sound(ent, CHAN_ITEM, gi.soundindex("items/airout.wav"), 1, ATTN_NORM, 0);
			if (remaining > 30 || (remaining & 4) != 0)
				SV_AddBlend(0.4f, 1, 0.4f, 0.04f, ent.client.ps.blend);
		}

		// add for damage
		if (ent.client.damage_alpha > 0)
			SV_AddBlend(
				ent.client.damage_blend[0],
				ent.client.damage_blend[1],
				ent.client.damage_blend[2],
				ent.client.damage_alpha,
				ent.client.ps.blend);

		if (ent.client.bonus_alpha > 0)
			SV_AddBlend(0.85f, 0.7f, 0.3f, ent.client.bonus_alpha, ent.client.ps.blend);

		// drop the damage value
		ent.client.damage_alpha -= 0.06;
		if (ent.client.damage_alpha < 0)
			ent.client.damage_alpha = 0;

		// drop the bonus value
		ent.client.bonus_alpha -= 0.1;
		if (ent.client.bonus_alpha < 0)
			ent.client.bonus_alpha = 0;
	}

	/*
	=================
	P_FallingDamage
	=================
	*/
	public static void P_FallingDamage(edict_t ent) {
		float delta;
		int damage;
		float[] dir = { 0, 0, 0 };

		if (ent.s.modelindex != 255)
			return; // not in the player model

		if (ent.movetype == MOVETYPE_NOCLIP)
			return;

		if ((ent.client.oldvelocity[2] < 0) && (ent.velocity[2] > ent.client.oldvelocity[2]) && (null == ent.groundentity)) {
			delta = ent.client.oldvelocity[2];
		}
		else {
			if (ent.groundentity == null)
				return;
			delta = ent.velocity[2] - ent.client.oldvelocity[2];
		}
		delta = delta * delta * 0.0001f;

		// never take falling damage if completely underwater
		if (ent.waterlevel == 3)
			return;
		if (ent.waterlevel == 2)
			delta *= 0.25;
		if (ent.waterlevel == 1)
			delta *= 0.5;

		if (delta < 1)
			return;

		if (delta < 15) {
			ent.s.event = EV_FOOTSTEP;
			return;
		}

		ent.client.fall_value = delta * 0.5f;
		if (ent.client.fall_value > 40)
			ent.client.fall_value = 40;
		ent.client.fall_time = level.time + FALL_TIME;

		if (delta > 30) {
			if (ent.health > 0) {
				if (delta >= 55)
					ent.s.event = EV_FALLFAR;
				else
					ent.s.event = EV_FALL;
			}
			ent.pain_debounce_time = level.time; // no normal pain sound
			damage = (int) ((delta - 30) / 2);
			if (damage < 1)
				damage = 1;
			VectorSet(dir, 0, 0, 1);

			if (deathmatch.value == 0 || 0 == ((int) dmflags.value & DF_NO_FALLING))
				T_Damage(ent, g_edicts[0], g_edicts[0], dir, ent.s.origin, vec3_origin, damage, 0, 0, MOD_FALLING);
		}
		else {
			ent.s.event = EV_FALLSHORT;
			return;
		}
	}

	/*
	=============
	P_WorldEffects
	=============
	*/
	public static void P_WorldEffects() {
		boolean breather;
		boolean envirosuit;
		int waterlevel, old_waterlevel;

		if (current_player.movetype == MOVETYPE_NOCLIP) {
			current_player.air_finished = level.time + 12; // don't need air
			return;
		}

		waterlevel = current_player.waterlevel;
		old_waterlevel = current_client.old_waterlevel;
		current_client.old_waterlevel = waterlevel;

		breather = current_client.breather_framenum > level.framenum;
		envirosuit = current_client.enviro_framenum > level.framenum;

		//
		// if just entered a water volume, play a sound
		//
		if (old_waterlevel == 0 && waterlevel != 0) {
			PlayerNoise(current_player, current_player.s.origin, PNOISE_SELF);
			if ((current_player.watertype & CONTENTS_LAVA) != 0)
				gi.sound(current_player, CHAN_BODY, gi.soundindex("player/lava_in.wav"), 1, ATTN_NORM, 0);
			else if ((current_player.watertype & CONTENTS_SLIME) != 0)
				gi.sound(current_player, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0);
			else if ((current_player.watertype & CONTENTS_WATER) != 0)
				gi.sound(current_player, CHAN_BODY, gi.soundindex("player/watr_in.wav"), 1, ATTN_NORM, 0);
			current_player.flags |= FL_INWATER;

			// clear damage_debounce, so the pain sound will play immediately
			current_player.damage_debounce_time = level.time - 1;
		}

		//
		// if just completely exited a water volume, play a sound
		//
		if (old_waterlevel != 0 && waterlevel == 0) {
			PlayerNoise(current_player, current_player.s.origin, PNOISE_SELF);
			gi.sound(current_player, CHAN_BODY, gi.soundindex("player/watr_out.wav"), 1, ATTN_NORM, 0);
			current_player.flags &= ~FL_INWATER;
		}

		//
		// check for head just going under water
		//
		if (old_waterlevel != 3 && waterlevel == 3) {
			gi.sound(current_player, CHAN_BODY, gi.soundindex("player/watr_un.wav"), 1, ATTN_NORM, 0);
		}

		//
		// check for head just coming out of water
		//
		if (old_waterlevel == 3 && waterlevel != 3) {
			if (current_player.air_finished < level.time) { // gasp for air
				gi.sound(current_player, CHAN_VOICE, gi.soundindex("player/gasp1.wav"), 1, ATTN_NORM, 0);
				PlayerNoise(current_player, current_player.s.origin, PNOISE_SELF);
			}
			else if (current_player.air_finished < level.time + 11) { // just break surface
				gi.sound(current_player, CHAN_VOICE, gi.soundindex("player/gasp2.wav"), 1, ATTN_NORM, 0);
			}
		}

		//
		// check for drowning
		//
		if (waterlevel == 3) {
			// breather or envirosuit give air
			if (breather || envirosuit) {
				current_player.air_finished = level.time + 10;

				if (((int) (current_client.breather_framenum - level.framenum) % 25) == 0) {
					if (current_client.breather_sound == 0)
						gi.sound(current_player, CHAN_AUTO, gi.soundindex("player/u_breath1.wav"), 1, ATTN_NORM, 0);
					else
						gi.sound(current_player, CHAN_AUTO, gi.soundindex("player/u_breath2.wav"), 1, ATTN_NORM, 0);
					current_client.breather_sound ^= 1;
					PlayerNoise(current_player, current_player.s.origin, PNOISE_SELF);
					//FIXME: release a bubble?
				}
			}

			// if out of air, start drowning
			if (current_player.air_finished < level.time) { // drown!
				if (current_player.client.next_drown_time < level.time && current_player.health > 0) {
					current_player.client.next_drown_time = level.time + 1;

					// take more damage the longer underwater
					current_player.dmg += 2;
					if (current_player.dmg > 15)
						current_player.dmg = 15;

					// play a gurp sound instead of a normal pain sound
					if (current_player.health <= current_player.dmg)
						gi.sound(current_player, CHAN_VOICE, gi.soundindex("player/drown1.wav"), 1, ATTN_NORM, 0);
					else if ((rand() & 1) != 0)
						gi.sound(current_player, CHAN_VOICE, gi.soundindex("*gurp1.wav"), 1, ATTN_NORM, 0);
					else
						gi.sound(current_player, CHAN_VOICE, gi.soundindex("*gurp2.wav"), 1, ATTN_NORM, 0);

					current_player.pain_debounce_time = level.time;

					T_Damage(
						current_player,
						g_edicts[0],
						g_edicts[0],
						vec3_origin,
						current_player.s.origin,
						vec3_origin,
						current_player.dmg,
						0,
						DAMAGE_NO_ARMOR,
						MOD_WATER);
				}
			}
		}
		else {
			current_player.air_finished = level.time + 12;
			current_player.dmg = 2;
		}

		//
		// check for sizzle damage
		//
		if (waterlevel != 0 && 0 != (current_player.watertype & (CONTENTS_LAVA | CONTENTS_SLIME))) {
			if ((current_player.watertype & CONTENTS_LAVA) != 0) {
				if (current_player.health > 0
					&& current_player.pain_debounce_time <= level.time
					&& current_client.invincible_framenum < level.framenum) {
					if ((rand() & 1) != 0)
						gi.sound(current_player, CHAN_VOICE, gi.soundindex("player/burn1.wav"), 1, ATTN_NORM, 0);
					else
						gi.sound(current_player, CHAN_VOICE, gi.soundindex("player/burn2.wav"), 1, ATTN_NORM, 0);
					current_player.pain_debounce_time = level.time + 1;
				}

				if (envirosuit) // take 1/3 damage with envirosuit
					T_Damage(
						current_player,
						g_edicts[0],
						g_edicts[0],
						vec3_origin,
						current_player.s.origin,
						vec3_origin,
						1 * waterlevel,
						0,
						0,
						MOD_LAVA);
				else
					T_Damage(
						current_player,
						g_edicts[0],
						g_edicts[0],
						vec3_origin,
						current_player.s.origin,
						vec3_origin,
						3 * waterlevel,
						0,
						0,
						MOD_LAVA);
			}

			if ((current_player.watertype & CONTENTS_SLIME) != 0) {
				if (!envirosuit) { // no damage from slime with envirosuit
					T_Damage(
						current_player,
						g_edicts[0],
						g_edicts[0],
						vec3_origin,
						current_player.s.origin,
						vec3_origin,
						1 * waterlevel,
						0,
						0,
						MOD_SLIME);
				}
			}
		}
	}

	/*
	===============
	G_SetClientEffects
	===============
	*/
	public static void G_SetClientEffects(edict_t ent) {
		int pa_type;
		int remaining;

		ent.s.effects = 0;
		ent.s.renderfx = 0;

		if (ent.health <= 0 || level.intermissiontime != 0)
			return;

		if (ent.powerarmor_time > level.time) {
			pa_type = PowerArmorType(ent);
			if (pa_type == POWER_ARMOR_SCREEN) {
				ent.s.effects |= EF_POWERSCREEN;
			}
			else if (pa_type == POWER_ARMOR_SHIELD) {
				ent.s.effects |= EF_COLOR_SHELL;
				ent.s.renderfx |= RF_SHELL_GREEN;
			}
		}

		if (ent.client.quad_framenum > level.framenum) {
			remaining = (int) ent.client.quad_framenum - level.framenum;
			if (remaining > 30 || 0 != (remaining & 4))
				ent.s.effects |= EF_QUAD;
		}

		if (ent.client.invincible_framenum > level.framenum) {
			remaining = (int) ent.client.invincible_framenum - level.framenum;
			if (remaining > 30 || 0 != (remaining & 4))
				ent.s.effects |= EF_PENT;
		}

		// show cheaters!!!
		if ((ent.flags & FL_GODMODE) != 0) {
			ent.s.effects |= EF_COLOR_SHELL;
			ent.s.renderfx |= (RF_SHELL_RED | RF_SHELL_GREEN | RF_SHELL_BLUE);
		}
	}

	/*
	===============
	G_SetClientEvent
	===============
	*/
	public static void G_SetClientEvent(edict_t ent) {
		if (ent.s.event != 0)
			return;

		if (ent.groundentity != null && xyspeed > 225) {
			if ((int) (current_client.bobtime + bobmove) != bobcycle)
				ent.s.event = EV_FOOTSTEP;
		}
	}

	/*
	===============
	G_SetClientSound
	===============
	*/
	public static void G_SetClientSound(edict_t ent) {
		String weap;

		if (ent.client.pers.game_helpchanged != game.helpchanged) {
			ent.client.pers.game_helpchanged = game.helpchanged;
			ent.client.pers.helpchanged = 1;
		}

		// help beep (no more than three times)
		if (ent.client.pers.helpchanged != 0 && ent.client.pers.helpchanged <= 3 && 0 == (level.framenum & 63)) {
			ent.client.pers.helpchanged++;
			gi.sound(ent, CHAN_VOICE, gi.soundindex("misc/pc_up.wav"), 1, ATTN_STATIC, 0);
		}

		if (ent.client.pers.weapon != null)
			weap = ent.client.pers.weapon.classname;
		else
			weap = "";

		if (ent.waterlevel != 0 && 0 != (ent.watertype & (CONTENTS_LAVA | CONTENTS_SLIME)))
			ent.s.sound = snd_fry;
		else if (strcmp(weap, "weapon_railgun") == 0)
			ent.s.sound = gi.soundindex("weapons/rg_hum.wav");
		else if (strcmp(weap, "weapon_bfg") == 0)
			ent.s.sound = gi.soundindex("weapons/bfg_hum.wav");
		else if (ent.client.weapon_sound != 0)
			ent.s.sound = ent.client.weapon_sound;
		else
			ent.s.sound = 0;
	}

	/*
	===============
	G_SetClientFrame
	===============
	*/
	public static void G_SetClientFrame(edict_t ent) {
		gclient_t client;
		boolean duck, run;

		if (ent.s.modelindex != 255)
			return; // not in the player model

		client = ent.client;

		if ((client.ps.pmove.pm_flags & PMF_DUCKED)!=0)
			duck = true;
		else
			duck = false;
		if (xyspeed!=0)
			run = true;
		else
			run = false;

		boolean skip = false;
		// check for stand/duck and stop/go transitions
		if (duck != client.anim_duck && client.anim_priority < ANIM_DEATH)
			skip = true;

		if (run != client.anim_run && client.anim_priority == ANIM_BASIC)
			skip = true;

		if (null==ent.groundentity && client.anim_priority <= ANIM_WAVE)
			skip = true;

		if (!skip) {
			if (client.anim_priority == ANIM_REVERSE) {
				if (ent.s.frame > client.anim_end) {
					ent.s.frame--;
					return;
				}
			}
			else if (ent.s.frame < client.anim_end) { // continue an animation
				ent.s.frame++;
				return;
			}

			if (client.anim_priority == ANIM_DEATH)
				return; // stay there
			if (client.anim_priority == ANIM_JUMP) {
				if (null==ent.groundentity)
					return; // stay there
				ent.client.anim_priority = ANIM_WAVE;
				ent.s.frame = FRAME_jump3;
				ent.client.anim_end = FRAME_jump6;
				return;
			}
		}

		// return to either a running or standing frame
		client.anim_priority = ANIM_BASIC;
		client.anim_duck = duck;
		client.anim_run = run;

		if (null==ent.groundentity) {
			client.anim_priority = ANIM_JUMP;
			if (ent.s.frame != FRAME_jump2)
				ent.s.frame = FRAME_jump1;
			client.anim_end = FRAME_jump2;
		}
		else if (run) { // running
			if (duck) {
				ent.s.frame = FRAME_crwalk1;
				client.anim_end = FRAME_crwalk6;
			}
			else {
				ent.s.frame = FRAME_run1;
				client.anim_end = FRAME_run6;
			}
		}
		else { // standing
			if (duck) {
				ent.s.frame = FRAME_crstnd01;
				client.anim_end = FRAME_crstnd19;
			}
			else {
				ent.s.frame = FRAME_stand01;
				client.anim_end = FRAME_stand40;
			}
		}
	}

	/*
	=================
	ClientEndServerFrame
	
	Called for each player at the end of the server frame
	and right after spawning
	=================
	*/
	public static void ClientEndServerFrame(edict_t ent) {
		float bobtime;
		int i;

		current_player = ent;
		current_client = ent.client;

		//
		// If the origin or velocity have changed since ClientThink(),
		// update the pmove values.  This will happen when the client
		// is pushed by a bmodel or kicked by an explosion.
		// 
		// If it wasn't updated here, the view position would lag a frame
		// behind the body position when pushed -- "sinking into plats"
		//
		for (i = 0; i < 3; i++) {
			current_client.ps.pmove.origin[i] = (short) (ent.s.origin[i] * 8.0);
			current_client.ps.pmove.velocity[i] = (short) (ent.velocity[i] * 8.0);
		}

		//
		// If the end of unit layout is displayed, don't give
		// the player any normal movement attributes
		//
		if (level.intermissiontime!=0) {
			// FIXME: add view drifting here?
			current_client.ps.blend[3] = 0;
			current_client.ps.fov = 90;
			G_SetStats(ent);
			return;
		}

		AngleVectors(ent.client.v_angle, forward, right, up);

		// burn from lava, etc
		P_WorldEffects();

		//
		// set model angles from view angles so other things in
		// the world can tell which direction you are looking
		//
		if (ent.client.v_angle[PITCH] > 180)
			ent.s.angles[PITCH] = (-360 + ent.client.v_angle[PITCH]) / 3;
		else
			ent.s.angles[PITCH] = ent.client.v_angle[PITCH] / 3;
		ent.s.angles[YAW] = ent.client.v_angle[YAW];
		ent.s.angles[ROLL] = 0;
		ent.s.angles[ROLL] = SV_CalcRoll(ent.s.angles, ent.velocity) * 4;

		//
		// calculate speed and cycle to be used for
		// all cyclic walking effects
		//
		xyspeed = (float) Math.sqrt(ent.velocity[0] * ent.velocity[0] + ent.velocity[1] * ent.velocity[1]);

		if (xyspeed < 5) {
			bobmove = 0;
			current_client.bobtime = 0; // start at beginning of cycle again
		}
		else if (ent.groundentity!=null) { // so bobbing only cycles when on ground
			if (xyspeed > 210)
				bobmove = 0.25f;
			else if (xyspeed > 100)
				bobmove = 0.125f;
			else
				bobmove = 0.0625f;
		}

		bobtime = (current_client.bobtime += bobmove);

		if ((current_client.ps.pmove.pm_flags & PMF_DUCKED)!=0)
			bobtime *= 4;

		bobcycle = (int) bobtime;
		bobfracsin = (float) Math.abs(Math.sin(bobtime * Math.PI));

		// detect hitting the floor
		P_FallingDamage(ent);

		// apply all the damage taken this frame
		P_DamageFeedback(ent);

		// determine the view offsets
		SV_CalcViewOffset(ent);

		// determine the gun offsets
		SV_CalcGunOffset(ent);

		// determine the full screen color blend
		// must be after viewoffset, so eye contents can be
		// accurately determined
		// FIXME: with client prediction, the contents
		// should be determined by the client
		SV_CalcBlend(ent);

		// chase cam stuff
		if (ent.client.resp.spectator)
			G_SetSpectatorStats(ent);
		else
			G_SetStats(ent);
		G_CheckChaseStats(ent);

		G_SetClientEvent(ent);

		G_SetClientEffects(ent);

		G_SetClientSound(ent);

		G_SetClientFrame(ent);

		VectorCopy(ent.velocity, ent.client.oldvelocity);
		VectorCopy(ent.client.ps.viewangles, ent.client.oldviewangles);

		// clear weapon kicks
		VectorClear(ent.client.kick_origin);
		VectorClear(ent.client.kick_angles);

		// if the scoreboard is up, update it
		if (ent.client.showscores && 0==(level.framenum & 31)) {
			DeathmatchScoreboardMessage(ent, ent.enemy);
			gi.unicast(ent, false);
		}
	}
}