player.cpp

this keik game source

CLASS_DECLARATION( Sentient, Player, "player" );

ResponseDef Player::Responses[] =
	{
	   { &EV_ClientMove,					( Response )Player::ClientThink },
	   { &EV_ClientEndFrame,			( Response )Player::EndFrame },
      { &EV_Player_ShowInfo,		   ( Response )Player::ShowInfo },
		{ &EV_Vehicle_Enter,				( Response )Player::EnterVehicle },
		{ &EV_Vehicle_Exit,				( Response )Player::ExitVehicle },
      
      { &EV_Player_EndLevel,		   ( Response )Player::EndLevel },

		{ &EV_Player_AddPathNode,		( Response )Player::AddPathNode },
	   { &EV_Player_PrevWeapon,		( Response )Player::EventPreviousWeapon },
	   { &EV_Player_NextWeapon,		( Response )Player::EventNextWeapon },
      { &EV_Player_PrevItem,	   	( Response )Player::EventPreviousItem },
	   { &EV_Player_NextItem,  		( Response )Player::EventNextItem },
		{ &EV_Player_UseItem,			( Response )Player::EventUseItem },
      { &EV_Player_UseInventoryItem,( Response )Player::EventUseInventoryItem },
	   { &EV_Player_GiveCheat,			( Response )Player::GiveCheat },
		{ &EV_Player_GiveAllCheat,		( Response )Player::GiveAllCheat },
      { &EV_Player_Take,   			( Response )Player::Take },
	   { &EV_Player_GodCheat,			( Response )Player::GodCheat },
      { &EV_Player_DevGodCheat,		( Response )Player::GodCheat },
      { &EV_Player_Spectator,			( Response )Player::Spectator },
	   { &EV_Player_NoTargetCheat,	( Response )Player::NoTargetCheat },
      { &EV_Player_DevNoTargetCheat,( Response )Player::NoTargetCheat },
	   { &EV_Player_NoClipCheat,		( Response )Player::NoclipCheat },
      { &EV_Player_DevNoClipCheat,	( Response )Player::NoclipCheat },
	   { &EV_Player_GameVersion,		( Response )Player::GameVersion },
	   { &EV_Player_Fov,					( Response )Player::Fov },
	   { &EV_Player_SaveFov,			( Response )Player::SaveFov },
	   { &EV_Player_RestoreFov,		( Response )Player::RestoreFov },
		{ &EV_Player_ToggleViewMode,	( Response )Player::ToggleViewMode },
      { &EV_Player_ToggleZoomMode,	( Response )Player::ToggleZoomMode },
      { &EV_Player_ZoomOut, 	      ( Response )Player::ZoomOut },
      { &EV_EnterConsole,           ( Response )Player::EnterConsole },
      { &EV_ExitConsole,            ( Response )Player::ExitConsole },
      { &EV_KickFromConsole,        ( Response )Player::KickConsole },
		{ &EV_Player_Kill,				( Response )Player::Kill },
      { &EV_Player_Dead,				( Response )Player::Dead },
		{ &EV_Player_SpawnEntity,		( Response )Player::SpawnEntity },
      { &EV_Player_SpawnActor,      ( Response )Player::SpawnActor },
		{ &EV_Player_Respawn,			( Response )Player::Respawn },

		{ &EV_Pain,							( Response )Player::Pain },
		{ &EV_Killed,						( Response )Player::Killed },
      { &EV_Gib,                    ( Response )Player::GibEvent },
		{ &EV_GotKill,						( Response )Player::GotKill },

		{ &EV_Player_ReadyToFire,		( Response )Player::ReadyToFire },
		{ &EV_Player_WaitingToFire,	( Response )Player::WaitingToFire },
		{ &EV_Player_AttackDone,		( Response )Player::DoneFiring },
		{ &EV_Player_TestThread,		( Response )Player::TestThread },

      { &EV_Player_ClearFloatingInventory,   (Response)Player::ClearFloatingInventory },
      { &EV_Player_PowerupTimer,		         ( Response )Player::SetPowerupTimer },
      { &EV_Player_UpdatePowerupTimer,		   ( Response )Player::UpdatePowerupTimer },

		{ &EV_Player_WhatIs,							( Response )Player::WhatIs },
      { &EV_Player_ActorInfo,                ( Response )Player::ActorInfo },
		{ &EV_Player_Taunt,							( Response )Player::Taunt },
		{ &EV_Player_KillEnt,						( Response )Player::KillEnt },
		{ &EV_Player_RemoveEnt,						( Response )Player::RemoveEnt },
		{ &EV_Player_KillClass,						( Response )Player::KillClass },
		{ &EV_Player_RemoveClass,					( Response )Player::RemoveClass },

		{ &EV_Player_DrawOverlay,					( Response )Player::DrawOverlay },
		{ &EV_Player_HideOverlay,					( Response )Player::HideOverlay },
		{ &EV_Player_DrawStats,					   ( Response )Player::DrawStats },
		{ &EV_Player_HideStats,					   ( Response )Player::HideStats },

      { &EV_Player_SetFlashColor,    		   ( Response )Player::SetFlashColor },
      { &EV_Player_ClearFlashColor,    		( Response )Player::ClearFlashColor },
      { &EV_Player_Mutate,    		         ( Response )Player::Mutate },
      { &EV_Player_Human,               		( Response )Player::Human },
      { &EV_Player_Skin,               		( Response )Player::SetSkin },

      { NULL, NULL }
	};

Player::Player()
	{
	path = NULL;
   
   respawn_time = -1;

   watchCamera       = NULL;
   thirdpersonCamera = NULL;
   movieCamera       = NULL;
   spectatorCamera   = NULL;

	damage_blood = 0;
	damage_alpha = 0;

   action_level = 0;
   drawoverlay  = false;

	defaultViewMode = FIRST_PERSON;

	fov = atof( Info_ValueForKey( client->pers.userinfo, "fov" ) );
	if ( fov < 1 )
      {
		fov = 90;
      }
	else if ( fov > 160 )
      {
		fov = 160;
      }

   savedfov = 0;
   has_thought = false;

	s_debugmusic = gi.cvar ("s_debugmusic", "0", 0);
	whereami = gi.cvar ("whereami", "0", 0);

   // Remove him from the world until we spawn him
   unlink();
	}

void Player::InitSkin
   (
   void
   )

   {
   
   // If this is a new level, there will be no custom skin, so go back to the original blade skin.
   if ( !LoadingSavegame && !deathmatch->value )
      {
      int playernum = edict-g_edicts-1;

      strcpy( client->pers.skin, "blade_base" );
   
   
      // combine name, skin and model into a configstring
	   gi.configstring( CS_PLAYERSKINS+playernum, va( "%s\\%s\\%s", 
                       client->pers.netname,
                       client->pers.model,
                       client->pers.skin ) );     
      }
   }


void Player::Init
	(
	void
	)

	{
   InitClient();
   InitPhysics();
   InitPowerups();
   InitWorldEffects();
   InitMusic();
   InitPath();
   InitView();
   InitState();
   InitEdict();
   InitModel();
   InitWeapons();
   InitSkin();

   // don't call RestoreEnt when respawning on a training level
   if ( !LoadingServer && ( deathmatch->value || ( level.training && ( respawn_time != -1 ) ) || 
      !PersistantData.RestoreEnt( this ) ) )
      {
      InitInventory();
      InitHealth();
      }

   ChooseSpawnPoint();

	if ( !LoadingSavegame && ( viewmode == THIRD_PERSON ) && !crosshair )
		{
      cvar_t * chair;

      chair = gi.cvar("crosshair", "0", 0);
		crosshair = new Entity;
		crosshair->setModel( va( "sprites/crosshair%d.spr", (int)chair->value ) );
      crosshair->edict->svflags |= SVF_ONLYPARENT;
      crosshair->edict->owner = this->edict;
		}

   if ( !deathmatch->value )
      {
      gi.AddCommandString( "con_clearfade\n" );
      }

   // make sure we put the player back into the world
   link();
	}

void Player::WritePersistantData
   (
   SpawnArgGroup &group
   )

   {
   str text;
   char t[ 3 ];
   int hi;
   int lo;
   int i;

   // encode the damage states into a text string
   t[ 2 ] = 0;
   for( i = 0; i < MAX_MODEL_GROUPS; i++ )
      {
      hi = ( edict->s.groups[ i ] >> 4 ) & 0xf;
      lo = edict->s.groups[ i ] & 0xf;
      t[ 0 ] = ( char )( 'A' + hi );
      t[ 1 ] = ( char )( 'A' + lo );
      text += t;
      }

   G_SetSpawnArg( "savemodel", savemodel.c_str() );
   G_SetSpawnArg( "saveskin", saveskin.c_str() );
   G_SetSpawnArg( "damage_groups", text.c_str() );
   G_SetFloatArg( "fov", fov );
   G_SetIntArg( "defaultViewMode", defaultViewMode );
   G_SetIntArg( "flags", flags & ( FL_GODMODE | FL_NOTARGET	| FL_SP_MUTANT ) );

   Sentient::WritePersistantData( group );
   }

void Player::RestorePersistantData
   (
   SpawnArgGroup &group
   )

   {
#ifndef SIN_DEMO
   SpiderMine *spidermine;
   Detonator  *detonator;
#endif
   int i;
   int len;
   str text;
   const char *ptr;
   int hi;
   int lo;

   Sentient::RestorePersistantData( group );

   group.RestoreArgs( 1 );

   // clear the damage states
   memset( edict->s.groups, 0, sizeof( edict->s.groups ) );

   savemodel = G_GetStringArg( "savemodel" );
   saveskin = G_GetStringArg( "saveskin" );

   text = G_GetStringArg( "damage_groups" );
   len = text.length() >> 1;
   if ( len > MAX_MODEL_GROUPS )
      {
      len = MAX_MODEL_GROUPS;
      }

   // decode the damage states from text string
   ptr = text.c_str();
   for( i = 0; i < len; i++ )
      {
      hi = ( *ptr++ - 'A' ) & 0xf;
      lo = ( *ptr++ - 'A' ) & 0xf;
      edict->s.groups[ i ]  = ( hi << 4 ) + lo;
      }

   flags |= G_GetIntArg( "flags" );
   fov = G_GetFloatArg( "fov", 90 );
   defaultViewMode = ( viewmode_t )G_GetIntArg( "defaultViewMode", FIRST_PERSON );

#ifndef SIN_DEMO
   spidermine = ( SpiderMine * )FindItem( "SpiderMine" );
   detonator  = ( Detonator * )FindItem( "Detonator" );
   
   if ( spidermine )
      {
      spidermine->SetDetonator( detonator );
      }

   if ( FindItem( "Silencer" ) )
      {
      flags |= FL_SILENCER;
      }
   
   if ( FindItem( "ScubaGear" ) )
      {
      flags |= FL_OXYGEN;
      }

   if ( flags & FL_SP_MUTANT )
      {
      setModel( "manumit_pl.def" );
      SetAnim( "idle" );
      }
#endif

   if ( defaultViewMode == CAMERA_VIEW )
      {
      defaultViewMode = FIRST_PERSON;
      }

   SetViewMode( defaultViewMode );

   // prevent the player from starting dead
   if ( health < 1 )
      {
      health = 1;
      }
   }

void Player::InitEdict
   (
   void
   )

   {
   // entity state stuff
   setSolidType( SOLID_BBOX );
	setMoveType( MOVETYPE_WALK );
	setSize( Vector( -16, -16, 0 ), Vector( 16, 16, STAND_HEIGHT ) );
	edict->clipmask	 = MASK_PLAYERSOLID;
	edict->svflags		&= ~SVF_DEADMONSTER;
   edict->svflags    &= ~SVF_HIDEOWNER;
   edict->owner       = NULL;

	// clear entity state values
	edict->s.effects		= 0;
	edict->s.frame	      = 0;
   }

void Player::InitMusic
   (
   void
   )

   {
   //
   // reset the music 
   //
	client->ps.current_music_mood = mood_normal;
	client->ps.fallback_music_mood = mood_normal;
   ChangeMusic( "normal", "normal", false );
   music_forced = false;
   }

void Player::InitClient
   (
   void
   )

   {
	client_persistant_t	saved;
	client_respawn_t		resp;

   // deathmatch wipes most client data every spawn
	if ( deathmatch->value || level.training )
		{
		char userinfo[ MAX_INFO_STRING ];

		resp = client->resp;
		memcpy( userinfo, client->pers.userinfo, sizeof( userinfo ) );
		G_InitClientPersistant( client );
		G_ClientUserinfoChanged( edict, userinfo );
		}
	else
		{
		memset( &resp, 0, sizeof( resp ) );
		}

	// clear everything but the persistant data and fov
	saved = client->pers;
	memset( client, 0, sizeof( *client ) );
	client->pers = saved;
	client->resp = resp;
   }

void Player::InitState
   (
   void
   )
   
   {
   in_console         = false;
   trappedInQuantum   = false;
   floating_owner     = NULL;
   gibbed             = false;
   enemy              = NULL;
   lastEnemyTime      = 0;
   lastTauntTime      = 0;

   takedamage			 = DAMAGE_AIM;
   deadflag				 = DEAD_NO;
	flags					&= ~FL_NO_KNOCKBACK;
	flags					|= ( FL_BLOOD | FL_DIE_GIBS );

   if ( parentmode->value )
      {
      flags &= ~FL_BLOOD;
      flags &= ~FL_DIE_GIBS;
      }
   }

void Player::InitHealth
   (
   void
   )
   
   {
   // Don't do anything if we're loading a server game.
   // This is either a loadgame or a restart
   if ( LoadingServer )
      {
      return;
      }

   // reset the health values
   health	  = 100;
	max_health = 100;
   last_damage_time = 0;

   // clear the damage states
   memset( edict->s.groups, 0, sizeof( edict->s.groups ) );
   }

void Player::InitModel
   (
   void
   )

   {
   str model;

   // Model stuff
   edict->s.renderfx |= RF_CUSTOMSKIN;
   edict->s.skinnum   = edict->s.number - 1;

   // Make sure that the model is allowed
   model = client->pers.model;
   if ( !game.ValidPlayerModels.ObjectInList( model ) )
      {
      model = "pl_blade.def";
      }
   
   setModel( model.c_str() );
   TempAnim( "idle", NULL );
	showModel();
   }

void Player::InitPhysics
   (
   void
   )

   {
   // Physics stuff
   onladder       = false;
   sentientFrozen = false;
   oldvelocity    = vec_zero;
	velocity       = vec_zero;
	gravity        = 1.0;
   falling        = false;
   fall_time      = 0;
   fall_value     = 0;
   fallsurface    = NULL; 
	mass				= 200;
   xyspeed        = 0;
   }
 
void Player::InitPowerups
   (
   void
   )

   {
   // powerups
   poweruptimer       = 0;
   poweruptype        = 0;
   flags             &= ~( FL_SHIELDS | FL_ADRENALINE | FL_CLOAK | FL_MUTANT | FL_SILENCER | FL_OXYGEN );
   edict->s.renderfx &= ~( RF_DLIGHT | RF_ENVMAPPED );
   }

void Player::InitWorldEffects
   (
   void
   )