Implemented keyboard input.

Copied some functions from pldnet and d3d_render (now the player image shows
in the mirror).

1 files changed, 888 insertions, 0 deletions

diff --git a/src/net.c b/src/net.c
new file mode 100644
index 0000000..22d5bd6
--- /dev/null
+++ b/src/net.c
@@ -0,0 +1,888 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <SDL.h>
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+#include "fixer.h"
+
+#include "3dc.h"
+#include "platform.h"
+#include "inline.h"
+#include "gamedef.h"
+#include "module.h"
+#include "stratdef.h"
+#include "projfont.h"
+#include "krender.h"
+#include "kshape.h"
+#include "prototyp.h"
+#include "d3d_hud.h"
+#include "bh_types.h"
+#include "equipmnt.h"
+#include "bh_marin.h"
+#include "bh_alien.h"
+#include "pldghost.h"
+
+#define UseLocalAssert Yes
+#include "ourasert.h"
+
+DISPLAYBLOCK PlayersMirrorImage;
+STRATEGYBLOCK PlayersMirrorImageSB;		  
+NETGHOSTDATABLOCK PlayersMirrorGhost;
+DYNAMICSBLOCK PlayersMirrorDynBlock;
+
+extern int LastHand;
+
+/* support function for addnetmsg_playerstate() */	
+static int MyPlayerHasAMuzzleFlash(STRATEGYBLOCK *sbPtr)
+{
+	PLAYER_WEAPON_DATA *weaponPtr;
+	TEMPLATE_WEAPON_DATA *twPtr;
+ 	PLAYER_STATUS *playerStatusPtr = (PLAYER_STATUS *)(Player->ObStrategyBlock->SBdataptr);
+	LOCALASSERT(playerStatusPtr);
+    	        
+    weaponPtr = &(playerStatusPtr->WeaponSlot[playerStatusPtr->SelectedWeaponSlot]);
+	twPtr = &TemplateWeapon[weaponPtr->WeaponIDNumber];
+		
+	/* first check if we are displaying a muzle flash ourselves */
+	if(twPtr->MuzzleFlashShapeName == NULL) return 0;
+	if(twPtr->PrimaryIsMeleeWeapon) return 0;
+	
+	if (weaponPtr->WeaponIDNumber==WEAPON_TWO_PISTOLS) {
+		if (weaponPtr->CurrentState == WEAPONSTATE_FIRING_PRIMARY) {
+			if (LastHand) {
+				return 2;
+			} else {
+				return 1;
+			}
+		} else if (weaponPtr->CurrentState == WEAPONSTATE_FIRING_SECONDARY) {
+			if (LastHand) {
+				return 2;
+			} else {
+				return 1;
+			}
+			return 0;
+		}
+	}
+	
+	if (weaponPtr->WeaponIDNumber==WEAPON_MARINE_PISTOL) {
+		if ((weaponPtr->CurrentState==WEAPONSTATE_FIRING_PRIMARY) 
+			||(weaponPtr->CurrentState==WEAPONSTATE_FIRING_SECONDARY)) {
+			//ReleasePrintDebuggingText("Pistol Muzzle Flash 1\n");
+			return 1;
+		} else {
+			//ReleasePrintDebuggingText("Pistol Muzzle Flash 0\n");
+			return 0;
+		}
+	}
+	
+	if (weaponPtr->CurrentState != WEAPONSTATE_FIRING_PRIMARY) {
+		return 0;
+	}
+
+	/* even if we are displaying our own muzzle flash, we don't neccessarily want it to
+	be visible to other players (because it looks stupid) */
+	if((weaponPtr->WeaponIDNumber==WEAPON_PULSERIFLE)||
+	   (weaponPtr->WeaponIDNumber==WEAPON_MARINE_PISTOL)||
+	   (weaponPtr->WeaponIDNumber==WEAPON_AUTOSHOTGUN)||
+	   (weaponPtr->WeaponIDNumber==WEAPON_SMARTGUN)||
+	   (weaponPtr->WeaponIDNumber==WEAPON_MINIGUN)||
+	   (weaponPtr->WeaponIDNumber==WEAPON_FRISBEE_LAUNCHER)||
+	   (weaponPtr->WeaponIDNumber==WEAPON_PRED_PISTOL)||
+	   (weaponPtr->WeaponIDNumber==WEAPON_PRED_RIFLE))
+	{
+		/* if we get this far, we want to display a muzzle flash */
+		return 1;		
+	}
+	return 0;
+}
+
+/* Patrick 11/7/97 ----------------------------------------------
+Functions for determining our sequence for player update messages
+-----------------------------------------------------------------*/
+
+static MARINE_SEQUENCE GetMyMarineSequence(void)
+{
+	int playerIsMoving = 0;
+	int playerIsFiring = 0;
+	int playerIsCrouching = 0;
+	int playerIsAlive = 0;
+	int playerIsJumping = 0;
+	int usingCloseAttackWeapon;
+	extern int StaffAttack;		
+		
+	/* sort out what state we're in */
+	if(PlayerStatusPtr->IsAlive) playerIsAlive = 1;
+	else playerIsAlive = 0;					
+
+	if (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Backward) {
+		playerIsMoving=-1;
+	} else if((PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Forward)||
+	   (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepLeft)||
+	   (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepRight)) {
+	   playerIsMoving = 1;
+	} else {
+		playerIsMoving = 0;
+	}
+
+	if ( (Player->ObStrategyBlock->DynPtr->Position.vx==Player->ObStrategyBlock->DynPtr->PrevPosition.vx)
+		&& (Player->ObStrategyBlock->DynPtr->Position.vy==Player->ObStrategyBlock->DynPtr->PrevPosition.vy)
+		&& (Player->ObStrategyBlock->DynPtr->Position.vz==Player->ObStrategyBlock->DynPtr->PrevPosition.vz) ) {
+		/* Actually not moving - overruled! */
+		playerIsMoving=0;
+	}
+
+	if(PlayerStatusPtr->ShapeState!=PMph_Standing) 
+	{
+		playerIsCrouching = 1;
+	}
+	else 
+	{
+		playerIsCrouching = 0;		
+	}
+	
+	if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)||
+	   (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY)) {
+			playerIsFiring = 1;
+	} else {
+		if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_MARINE_PISTOL) {
+			if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_SECONDARY)||
+			   (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_SECONDARY)) {
+				playerIsFiring = 1;
+			} else {
+				playerIsFiring = 0;
+			}
+		} else {
+			playerIsFiring = 0;
+		}
+	}
+
+	if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_CUDGEL)
+		usingCloseAttackWeapon = 1;
+	else usingCloseAttackWeapon = 0;	
+
+	/* Fix cudgel. */
+	if (usingCloseAttackWeapon) {
+		if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_SECONDARY)||
+		   (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_SECONDARY)) {
+			playerIsFiring = 1;
+		}
+	}
+
+	/* KJL 14:27:14 10/29/97 - deal with jumping & falling */
+	{
+		DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr;
+		if (!dynPtr->IsInContactWithFloor && (dynPtr->TimeNotInContactWithFloor==0))
+			playerIsJumping=1;
+	}	
+
+	/* and deduce the sequence */
+	if(playerIsAlive==0) 
+	{
+		if(playerIsCrouching) {
+			return MSQ_CrouchDie;
+		} else {
+			return MSQ_StandDieFront;
+		}
+	}
+
+	if(playerIsJumping) {
+		return MSQ_Jump;
+	}
+
+	/* Put this in here... no running cudgel attacks yet. */
+	if(playerIsFiring&&usingCloseAttackWeapon) {
+		/* Deal with cudgel case! */
+		if (StaffAttack>=0) {
+			return(MSQ_BaseOfCudgelAttacks+StaffAttack);
+		}
+	}
+
+	if(playerIsCrouching)
+	{
+		if(playerIsMoving>0) {
+			return MSQ_Crawl;
+		} else if (playerIsMoving<0) {
+			return MSQ_Crawl_Backwards;
+		} else {
+			return MSQ_Crouch;
+		}
+	}
+
+	if(playerIsMoving>0)
+	{
+		if(playerIsFiring) {
+			if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_TWO_PISTOLS)
+				&&(LastHand)) {
+				return MSQ_RunningFireSecondary;
+			} else {
+				return MSQ_RunningFire;
+			}
+		} else {
+			return MSQ_Walk;
+		}
+	} else if (playerIsMoving<0) {
+		if(playerIsFiring) {
+			if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_TWO_PISTOLS)
+				&&(LastHand)) {
+				return MSQ_RunningFireSecondary_Backwards;
+			} else {
+				return MSQ_RunningFire_Backwards;
+			}
+		} else {
+			return MSQ_Walk_Backwards;
+		}
+	}
+
+	if(playerIsFiring) {
+		if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_TWO_PISTOLS)
+			&&(LastHand)) {
+			return MSQ_StandingFireSecondary;
+		} else {
+			return MSQ_StandingFire;
+		}
+	} else {
+		if (PlayerStatusPtr->tauntTimer!=0) {
+			return MSQ_Taunt;
+		} else {
+			return MSQ_Stand;
+		}
+	}
+} 
+
+static ALIEN_SEQUENCE GetMyAlienSequence(void)
+{
+	extern STRATEGYBLOCK *Biting;
+	extern int Bit;
+	int playerIsMoving = 0;
+	int playerIsFiring = 0;
+	int playerIsCrouching = 0;
+	int playerIsAlive = 0;
+	int playerIsJumping = 0;
+		
+	/* sort out what state we're in */
+	if(PlayerStatusPtr->IsAlive) playerIsAlive = 1;
+	else playerIsAlive = 0;					
+
+	if (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Backward) {
+		playerIsMoving =-1;
+	} else if ((PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Forward)||
+	   (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepLeft)||
+	   (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepRight)) {
+	   	playerIsMoving = 1;
+	} else {
+		playerIsMoving = 0;
+	}
+
+	if ( (Player->ObStrategyBlock->DynPtr->Position.vx==Player->ObStrategyBlock->DynPtr->PrevPosition.vx)
+		&& (Player->ObStrategyBlock->DynPtr->Position.vy==Player->ObStrategyBlock->DynPtr->PrevPosition.vy)
+		&& (Player->ObStrategyBlock->DynPtr->Position.vz==Player->ObStrategyBlock->DynPtr->PrevPosition.vz) ) {
+		/* Actually not moving - overruled! */
+		playerIsMoving=0;
+	}
+
+	if(PlayerStatusPtr->ShapeState!=PMph_Standing) playerIsCrouching = 1;
+	else playerIsCrouching = 0;		
+
+	/* ChrisF 20/4/98: playerIsFiring now specifies alien weapon behaviour. */
+	//if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)||
+	//   (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY))
+	//		playerIsFiring = 1;
+	//else playerIsFiring = 0;	
+	//
+	//if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber!=WEAPON_ALIEN_SPIT) {
+	//	usingCloseAttackWeapon = 1;
+	//} else {
+	//	usingCloseAttackWeapon = 0;
+	//}
+
+	switch(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState) {
+		case (WEAPONSTATE_FIRING_PRIMARY):
+			if(Biting) {
+				playerIsFiring=4; //Eat.
+			} else {
+				playerIsFiring=1; //Claw.
+			}
+			break;
+		case (WEAPONSTATE_FIRING_SECONDARY):
+			playerIsFiring=2; //Tail Poise.
+			break;
+		case (WEAPONSTATE_RECOIL_SECONDARY):
+			playerIsFiring=3; //Tail Strike.
+			break;
+		default:
+			playerIsFiring=0; //Nothing.
+			break;
+	}
+			
+
+	/* KJL 14:27:14 10/29/97 - deal with jumping & falling */
+	{
+		DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr;
+		if (!dynPtr->IsInContactWithFloor && (dynPtr->TimeNotInContactWithFloor==0))
+			playerIsJumping=1;
+	}	
+
+	/* and deduce the sequence */
+	if(playerIsAlive==0) 
+	{
+		return ASQ_Stand; /* kind of irrelevant really */
+	}
+
+	if(playerIsJumping) /* TODO: consider jump & crouch */
+	{
+		switch(playerIsFiring) {
+			case 1:
+				return ASQ_Pounce;
+				break;
+			case 2:
+				return ASQ_JumpingTailPoise;
+				break;
+			case 3:
+				return ASQ_JumpingTailStrike;
+				break;
+			case 4:
+				/* What the hell? */
+				return ASQ_Eat;
+				break;
+			default:
+				return ASQ_Jump;
+				break;
+		}
+	}
+
+	if(playerIsCrouching)
+	{
+		if(playerIsMoving>0)
+		{
+			switch(playerIsFiring) {
+				case 1:
+					return ASQ_CrawlingAttack_Claw;
+					break;
+				case 2:
+					return ASQ_CrawlingTailPoise;
+					break;
+				case 3:
+					return ASQ_CrawlingTailStrike;
+					break;
+				case 4:
+					/* What the hell? */
+					return ASQ_CrouchEat;
+					break;
+				default:
+					if(Player->ObStrategyBlock->DynPtr->OrientMat.mat22>50000)
+						return ASQ_Scamper;
+					else
+						return ASQ_Crawl;
+					break;
+			}
+		} else if(playerIsMoving<0)	{
+			switch(playerIsFiring) {
+				case 1:
+					return ASQ_CrawlingAttack_Claw_Backwards;
+					break;
+				case 2:
+					return ASQ_CrawlingTailPoise_Backwards;
+					break;
+				case 3:
+					return ASQ_CrawlingTailStrike_Backwards;
+					break;
+				case 4:
+					/* What the hell? */
+					return ASQ_CrouchEat;
+					break;
+				default:
+					if(Player->ObStrategyBlock->DynPtr->OrientMat.mat22>50000)
+						return ASQ_Scamper_Backwards;
+					else
+						return ASQ_Crawl_Backwards;
+					break;
+			}
+		} 		
+		
+		switch(playerIsFiring) {
+			case 1:
+				return ASQ_CrouchedAttack_Claw;
+				break;
+			case 2:
+				return ASQ_CrouchedTailPoise;
+				break;
+			case 3:
+				return ASQ_CrouchedTailStrike;
+				break;
+			case 4:
+				return ASQ_Eat;
+				break;
+			default:
+				return ASQ_Crouch;
+				break;
+		}
+	}
+	
+	if(playerIsMoving>0)
+	{
+		switch(playerIsFiring) {
+			case 1:
+				return ASQ_RunningAttack_Claw;
+				break;
+			case 2:
+				return ASQ_RunningTailPoise;
+				break;
+			case 3:
+				return ASQ_RunningTailStrike;
+				break;
+			case 4:
+				/* What the hell? */
+				return ASQ_Eat;
+				break;
+			default:
+				return ASQ_Run;
+				break;
+		}
+	} else if(playerIsMoving<0) {
+		switch(playerIsFiring) {
+			case 1:
+				return ASQ_RunningAttack_Claw_Backwards;
+				break;
+			case 2:
+				return ASQ_RunningTailPoise_Backwards;
+				break;
+			case 3:
+				return ASQ_RunningTailStrike_Backwards;
+				break;
+			case 4:
+				/* What the hell? */
+				return ASQ_Eat;
+				break;
+			default:
+				return ASQ_Run_Backwards;
+				break;
+		}
+	} 		
+
+	switch(playerIsFiring) {
+		case 1:
+			return ASQ_StandingAttack_Claw;
+			break;
+		case 2:
+			return ASQ_StandingTailPoise;
+			break;
+		case 3:
+			return ASQ_StandingTailStrike;
+			break;
+		case 4:
+			return ASQ_Eat;
+			break;
+		default:
+			if (PlayerStatusPtr->tauntTimer!=0) {
+				/* Second lowest priority ever. */
+				return ASQ_Taunt;
+			} else {
+				return ASQ_Stand;
+			}
+			break;
+	}
+
+} 
+
+static PREDATOR_SEQUENCE GetMyPredatorSequence(void)
+{
+	int playerIsMoving = 0;
+	int playerIsFiring = 0;
+	int playerIsCrouching = 0;
+	int playerIsAlive = 0;
+	int playerIsJumping = 0;
+	int usingCloseAttackWeapon;
+	extern int StaffAttack;		
+
+	/* sort out what state we're in */
+	if(PlayerStatusPtr->IsAlive) playerIsAlive = 1;
+	else playerIsAlive = 0;					
+
+	if (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Backward) {
+		playerIsMoving=-1;
+	} else if((PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_Forward)||
+	   (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepLeft)||
+	   (PlayerStatusPtr->Mvt_InputRequests.Flags.Rqst_SideStepRight)) {
+	   	playerIsMoving = 1;
+	} else {
+		playerIsMoving = 0;
+	}
+
+	if ( (Player->ObStrategyBlock->DynPtr->Position.vx==Player->ObStrategyBlock->DynPtr->PrevPosition.vx)
+		&& (Player->ObStrategyBlock->DynPtr->Position.vy==Player->ObStrategyBlock->DynPtr->PrevPosition.vy)
+		&& (Player->ObStrategyBlock->DynPtr->Position.vz==Player->ObStrategyBlock->DynPtr->PrevPosition.vz) ) {
+		/* Actually not moving - overruled! */
+		playerIsMoving=0;
+	}
+
+	if(PlayerStatusPtr->ShapeState!=PMph_Standing) playerIsCrouching = 1;
+	else playerIsCrouching = 0;		
+
+	playerIsFiring = 0;	
+	
+	if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_SHOULDERCANNON)
+	{
+		//the shoulder cannon is fired during recoil (I think)
+		if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY)
+		{
+			playerIsFiring = 1;
+		}
+	}
+	else if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_WRISTBLADE)
+	{
+		if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)||
+		   (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY) ||
+		   (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_SECONDARY))
+		{
+			if(StaffAttack!=-1)
+			{
+				playerIsFiring = 1;
+			}
+		}
+	}
+	else
+	{
+		if((PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_FIRING_PRIMARY)||
+		   (PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].CurrentState==WEAPONSTATE_RECOIL_PRIMARY))
+		{
+				playerIsFiring = 1;
+		}
+	}
+
+	if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_WRISTBLADE)
+		usingCloseAttackWeapon = 3;
+	else if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_DISC)
+		usingCloseAttackWeapon = 1;
+	else if(PlayerStatusPtr->WeaponSlot[PlayerStatusPtr->SelectedWeaponSlot].WeaponIDNumber==WEAPON_PRED_STAFF)
+		usingCloseAttackWeapon = 2;
+	else usingCloseAttackWeapon = 0;	
+
+	/* KJL 14:27:14 10/29/97 - deal with jumping & falling */
+	{
+		DYNAMICSBLOCK *dynPtr = Player->ObStrategyBlock->DynPtr;
+		if (!dynPtr->IsInContactWithFloor && (dynPtr->TimeNotInContactWithFloor==0))
+			playerIsJumping=1;
+	}	
+
+	/* and deduce the sequence */
+	if(playerIsAlive==0) 
+	{
+		if(playerIsCrouching) {
+			return PredSQ_CrouchDie;
+		} else {
+			return PredSQ_StandDie;
+		}
+	}
+
+	if(playerIsJumping) {
+		return(PredSQ_Jump);
+	}
+
+	if(playerIsCrouching)
+	{
+		if(playerIsMoving>0)
+		{
+			if(playerIsFiring&&usingCloseAttackWeapon) {
+				/* Deal with staff case! */
+				if (usingCloseAttackWeapon==2) {
+					if (StaffAttack>=0) {
+						return(PredSQ_BaseOfStaffAttacks+StaffAttack);
+					}
+				} else if (usingCloseAttackWeapon==3) {
+					if (StaffAttack>=0) {
+						return(PredSQ_BaseOfWristbladeAttacks+StaffAttack);
+					}
+				}
+				return PredSQ_CrawlingSwipe;
+			} else {
+				return PredSQ_Crawl;
+			}
+		} else if (playerIsMoving<0) {
+			if(playerIsFiring&&usingCloseAttackWeapon) {
+				/* Deal with staff case! */
+				if (usingCloseAttackWeapon==2) {
+					if (StaffAttack>=0) {
+						return(PredSQ_BaseOfStaffAttacks+StaffAttack);
+					}
+				} else if (usingCloseAttackWeapon==3) {
+					if (StaffAttack>=0) {
+						return(PredSQ_BaseOfWristbladeAttacks+StaffAttack);
+					}
+				}
+				return PredSQ_CrawlingSwipe_Backwards;
+			} else {
+				return PredSQ_Crawl_Backwards;
+			}
+		}
+		if(playerIsFiring&&usingCloseAttackWeapon) {
+			/* Deal with staff case! */
+			if (usingCloseAttackWeapon==2) {
+				if (StaffAttack>=0) {
+					return(PredSQ_BaseOfStaffAttacks+StaffAttack);
+				}
+			} else if (usingCloseAttackWeapon==3) {
+				if (StaffAttack>=0) {
+					return(PredSQ_BaseOfWristbladeAttacks+StaffAttack);
+				}
+			}
+			return PredSQ_CrouchedSwipe;
+		} else {
+			return PredSQ_Crouch;
+		}
+	}
+	
+	if(playerIsMoving>0)
+	{
+		if(playerIsFiring&&usingCloseAttackWeapon) {
+			/* Deal with staff case! */
+			if (usingCloseAttackWeapon==2) {
+				if (StaffAttack>=0) {
+					return(PredSQ_BaseOfStaffAttacks+StaffAttack);
+				}
+			} else if (usingCloseAttackWeapon==3) {
+				if (StaffAttack>=0) {
+					return(PredSQ_BaseOfWristbladeAttacks+StaffAttack);
+				}
+			}
+			return PredSQ_RunningSwipe;
+		} else {
+			return PredSQ_Run;
+		}
+	} else if (playerIsMoving<0) {
+		if(playerIsFiring&&usingCloseAttackWeapon) {
+			/* Deal with staff case! */
+			if (usingCloseAttackWeapon==2) {
+				if (StaffAttack>=0) {
+					return(PredSQ_BaseOfStaffAttacks+StaffAttack);
+				}
+			} else if (usingCloseAttackWeapon==3) {
+				if (StaffAttack>=0) {
+					return(PredSQ_BaseOfWristbladeAttacks+StaffAttack);
+				}
+			}
+			return PredSQ_RunningSwipe_Backwards;
+		} else {
+			return PredSQ_Run_Backwards;
+		}
+	}
+
+	if(playerIsFiring&&usingCloseAttackWeapon) {
+		/* Deal with staff case! */
+		if (usingCloseAttackWeapon==2) {
+			if (StaffAttack>=0) {
+				return(PredSQ_BaseOfStaffAttacks+StaffAttack);
+			}
+		} else if (usingCloseAttackWeapon==3) {
+			if (StaffAttack>=0) {
+				return(PredSQ_BaseOfWristbladeAttacks+StaffAttack);
+			}
+		}
+		return PredSQ_StandingSwipe;
+	} else {
+		if (PlayerStatusPtr->tauntTimer!=0) {
+			return PredSQ_Taunt;
+		} else {
+			return PredSQ_Stand;
+		}
+	}
+}
+
+BOOL Current_Level_Requires_Mirror_Image()
+{
+	extern char LevelName[];
+	if ( (!stricmp(LevelName,"e3demo")) || (!stricmp(LevelName,"e3demosp")) || (!stricmp(LevelName,"derelict")) )
+	{
+ 		return TRUE;
+	}
+	return FALSE;
+}
+
+
+void CreatePlayersImageInMirror(void)
+{
+	AVP_BEHAVIOUR_TYPE type;
+	STRATEGYBLOCK *sbPtr = &PlayersMirrorImageSB;
+	NETGHOSTDATABLOCK *ghostData = &PlayersMirrorGhost; 
+	PlayersMirrorImage.ObStrategyBlock = sbPtr;
+	
+	sbPtr->SBdptr = &PlayersMirrorImage;
+
+	sbPtr->SBdataptr = (void *)ghostData;
+	sbPtr->DynPtr = &PlayersMirrorDynBlock;
+	
+	switch(AvP.PlayerType)
+	{
+		case(I_Marine):
+		{
+			type = I_BehaviourMarinePlayer;
+			break;
+		}
+		case(I_Predator):
+		{
+			type = I_BehaviourPredatorPlayer;
+			break;
+		}
+		case(I_Alien):
+		{
+			type = I_BehaviourAlienPlayer;
+			break;
+		}
+	}
+	ghostData->type = type;
+	ghostData->IOType=IOT_Non;
+	ghostData->subtype=0;
+	ghostData->myGunFlash = NULL;
+	ghostData->SoundHandle = SOUND_NOACTIVEINDEX;
+	ghostData->currentAnimSequence = 0;
+	ghostData->CloakingEffectiveness = 0;
+	ghostData->IgnitionHandshaking = 0;
+	ghostData->soundStartFlag = 0;
+	
+	if(AvP.Network == I_No_Network)
+	{
+		ghostData->playerId=0;
+	}
+	else
+	{
+//		ghostData->playerId=AVPDPNetID;
+		fprintf(stderr, "CreatePlayersImageInMirror: ghostData->playerId=AVPDPNetID\n");
+	}
+
+	/* set the shape */
+
+	switch(type)
+	{
+		case I_BehaviourMarinePlayer:
+		{
+			CreateMarineHModel(ghostData,WEAPON_PULSERIFLE);
+			break;
+		}
+		case I_BehaviourAlienPlayer:
+		{
+			CreateAlienHModel(ghostData);
+			break;
+		}
+		case I_BehaviourPredatorPlayer:
+		{
+			CreatePredatorHModel(ghostData,WEAPON_PRED_WRISTBLADE);
+			break;
+		}
+		default:
+			break;
+	}
+
+	sbPtr->SBdptr->HModelControlBlock=&ghostData->HModelController;
+	ProveHModel(sbPtr->SBdptr->HModelControlBlock,sbPtr->SBdptr);
+}
+
+void DeallocatePlayersMirrorImage()
+{
+#if MIRRORING_ON
+	if(Current_Level_Requires_Mirror_Image())
+	{
+		Dispel_HModel(&PlayersMirrorGhost.HModelController);
+	}
+#endif
+}
+
+void RenderPlayersImageInMirror(void)
+{
+	STRATEGYBLOCK *sbPtr = &PlayersMirrorImageSB;
+	NETGHOSTDATABLOCK *ghostData = &PlayersMirrorGhost; 
+	
+	int sequence;
+	int weapon;
+	int firingPrimary;
+	int firingSecondary;
+
+	switch(AvP.PlayerType)
+	{
+		case I_Marine:
+		{
+			sequence = (unsigned char)GetMyMarineSequence();
+			//check for change of charcter type
+			if(ghostData->type!=I_BehaviourMarinePlayer)
+			{
+				ghostData->type=I_BehaviourMarinePlayer;
+				//settings currentweapon to -1 will forec the hmodel to be updated
+				ghostData->CurrentWeapon=-1;
+			}
+			
+			break;
+		}
+		case I_Predator:
+		{
+			sequence = (unsigned char)GetMyPredatorSequence();
+			//check for change of charcter type
+			if(ghostData->type!=I_BehaviourPredatorPlayer)
+			{
+				ghostData->type=I_BehaviourPredatorPlayer;
+				//settings currentweapon to -1 will forec the hmodel to be updated
+				ghostData->CurrentWeapon=-1;
+			}
+			break;
+		}
+		case I_Alien:
+		{
+			sequence = (unsigned char)GetMyAlienSequence();
+			//check for change of charcter type
+			if(ghostData->type!=I_BehaviourAlienPlayer)
+			{
+				ghostData->type=I_BehaviourAlienPlayer;
+				//setting currentweapon to -1 will force the hmodel to be updated
+				ghostData->CurrentWeapon=-1;
+			}
+			break;
+		}
+		default:
+		{
+			LOCALASSERT(1==0);
+			break;
+		}
+	}
+		/* my current weapon id, and whether I am firing it... */
+	{
+		PLAYER_WEAPON_DATA *weaponPtr;
+ 		PLAYER_STATUS *playerStatusPtr = (PLAYER_STATUS *)(Player->ObStrategyBlock->SBdataptr);
+		LOCALASSERT(playerStatusPtr);    	        
+		weaponPtr = &(playerStatusPtr->WeaponSlot[playerStatusPtr->SelectedWeaponSlot]);
+		weapon = (signed char)(weaponPtr->WeaponIDNumber);	
+
+		if((weaponPtr->CurrentState==WEAPONSTATE_FIRING_PRIMARY)&&(playerStatusPtr->IsAlive))		
+			firingPrimary = 1;
+		else firingPrimary = 0;
+		if((weaponPtr->CurrentState==WEAPONSTATE_FIRING_SECONDARY)&&(playerStatusPtr->IsAlive)) 
+			firingSecondary = 1;
+		else firingSecondary = 0;
+	}
+
+//		if(!(((!(messagePtr->IAmAlive)))&&(netGameData.playerData[playerIndex].characterType==NGCT_Alien)))
+	{
+		{
+			PLAYER_STATUS *playerStatusPtr= (PLAYER_STATUS *) (Player->ObStrategyBlock->SBdataptr);
+			HandleWeaponElevation(sbPtr,playerStatusPtr->ViewPanX,weapon);
+		
+			UpdateGhost(sbPtr,&(Player->ObStrategyBlock->DynPtr->Position),&(Player->ObStrategyBlock->DynPtr->OrientEuler),sequence,AreTwoPistolsInTertiaryFire());
+
+
+			MaintainGhostCloakingStatus(sbPtr,(int)playerStatusPtr->cloakOn);
+		}
+	}
+	{
+		extern VIEWDESCRIPTORBLOCK *Global_VDB_Ptr;
+		DISPLAYBLOCK *dPtr = &PlayersMirrorImage;
+		dPtr->ObWorld = PlayersMirrorDynBlock.Position;
+		dPtr->ObMat = PlayersMirrorDynBlock.OrientMat;	
+		ReflectObject(dPtr);	 
+
+		PlayersMirrorImage.ObStrategyBlock = 0;
+		
+		AddShape(dPtr,Global_VDB_Ptr);
+		PlayersMirrorImage.ObStrategyBlock = &PlayersMirrorImageSB;
+	
+	}
+	HandleGhostGunFlashEffect(sbPtr,MyPlayerHasAMuzzleFlash(sbPtr));
+}