Beispiel #1
0
//--------------------------------------------------------------
// Name:		setupStateAdvance()
// Class:		GeneralCombatWithRangedWeapon
//
// Description:	Sets up the Advance State
//
// Parameters:	None
//
// Returns:		None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::setupStateAdvance()
{
	Vector selfToEnemy;	
	float dist;

	dist = G_Random ( 64.0f ) + 96.0f;

	if ( !_currentEnemy )
	{
		updateEnemy();
		return;
	}

	// Lets get oriented towards our enemy
	selfToEnemy = _currentEnemy->origin - _self->origin;
	selfToEnemy = selfToEnemy.toAngles();
	_self->setAngles( selfToEnemy );
	selfToEnemy.AngleVectors( &selfToEnemy );
	_self->movementSubsystem->setMoveDir( selfToEnemy );
	_self->movementSubsystem->setAnimDir( selfToEnemy );

	_moveRandomDir.SetDistance( dist );
	_moveRandomDir.SetAnim( "run" );
	_moveRandomDir.SetMode(MoveRandomDirection::RANDOM_MOVE_IN_FRONT);
	_moveRandomDir.Begin(*_self);
	_moveRandomDir.SetMinDistance( dist * .75 );
	
}
Beispiel #2
0
//--------------------------------------------------------------
// Name:		setupStateRetreat()
// Class:		GeneralCombatWithRangedWeapon
//
// Description:	Sets up the Retreat State
//
// Parameters:	None
//
// Returns:		None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::setupStateRetreat()
{
	Vector selfToEnemy;	
	float dist;

	dist = G_Random ( 64.0f ) + 96.0f;

	selfToEnemy = _currentEnemy->origin - _self->origin;
	selfToEnemy = selfToEnemy.toAngles();
	selfToEnemy[PITCH] = 0;
	selfToEnemy[ROLL] = 0;
	_self->setAngles( selfToEnemy );
	selfToEnemy.AngleVectors( &selfToEnemy );
	_self->movementSubsystem->setMoveDir( selfToEnemy );
	_self->movementSubsystem->setAnimDir( selfToEnemy );

	_moveRandomDir.SetDistance( dist );
	_moveRandomDir.SetAnim( "backpedal" );
	_moveRandomDir.SetMode(MoveRandomDirection::RANDOM_MOVE_IN_BACK);
	_moveRandomDir.Begin(*_self);
	_moveRandomDir.SetMinDistance( dist * .75 );
	_self->movementSubsystem->setMovingBackwards( true );

}
Beispiel #3
0
bool HoldableItemSpawnPowerup::use( void )
{
	SpawnArgs args;
	Entity *ent;
	Item *item;


	if ( _powerupToSpawn.length() == 0 )
		return true;

	if ( _owner )
	{
		args.setArg( "model", _powerupToSpawn );

		ent = args.Spawn();

		if ( !ent || !ent->isSubclassOf( Item ) )
			return true;

		item = (Item *)ent;

		item->setOrigin( _owner->centroid );

		item->ProcessPendingEvents();

		item->PlaceItem();
		item->setOrigin( _owner->centroid );

		if ( _owner->isSubclassOf( Player ) )
		{
			Vector viewAngles;
			Vector viewDir;
			Player *player = (Player *)_owner;
			Vector pos;

			player->GetPlayerView( &pos, &viewAngles );

			//viewAngles = player->GetVAngles();
			viewAngles.AngleVectors( &viewDir );

			viewDir.normalize();
			viewDir *= 500.0f;

			item->velocity = viewDir;

			item->setOrigin( pos );
		}
		else
		{
			item->velocity = Vector( G_CRandom( 100.0f ), G_CRandom( 100.0f ), 200.0f + G_Random( 200.0f ) );
		}

		item->edict->clipmask = CONTENTS_SOLID | CONTENTS_PLAYERCLIP;
		item->_nextPickupTime = level.time + 1.0f;

		item->setRespawn( false );

		// Powerup is only gets half time

		item->setAmount( item->getAmount() / 2.0f );

		// Get rid of the spawned powerup in 10 seconds

		item->PostEvent( EV_Remove, 10.0f );

		return true;
	}

	return false;
}
void CombatSubsystem::AimWeaponTag(const Vector& targetPos)
{
  Vector aimAngles;
  Vector gunPos, gunForward, gunRight, gunUp;

  //currentEnemy = act->enemyManager->GetCurrentEnemy();

  if (!_activeWeapon.weapon)
    return;

  _activeWeapon.weapon->setOrigin();
  _activeWeapon.weapon->setAngles();

  _activeWeapon.weapon->SetControllerAngles(WEAPONBONE_BARREL_TAG, vec_zero);

  GetGunPositionData(&gunPos, &gunForward, &gunRight, &gunUp);

  Vector mypos, myforward, myleft, myup;
  _activeWeapon.weapon->GetTag(WEAPONBONE_BARREL_TAG, &mypos, &myforward, &myleft, &myup);

  float gfToWorld[ 3 ][ 3 ];
  float worldToGf[ 3 ][ 3 ];
  gunForward.copyTo(gfToWorld[0]);
  gunRight.copyTo(gfToWorld[1]);
  gunUp.copyTo(gfToWorld[2]);

  TransposeMatrix(gfToWorld, worldToGf);

  auto barrelToEnemyVector = targetPos - gunPos;
  vec3_t barrelToEnemyVec3_t;
  barrelToEnemyVector.copyTo(barrelToEnemyVec3_t);

  vec3_t barrelToEnemyTransformedVec3_t;
  MatrixTransformVector(barrelToEnemyVec3_t, worldToGf, barrelToEnemyTransformedVec3_t);
  Vector barrelToEnemyTransformed(barrelToEnemyTransformedVec3_t);
  barrelToEnemyTransformed.normalize();
  barrelToEnemyTransformed = barrelToEnemyTransformed.toAngles();
  barrelToEnemyTransformed.EulerNormalize();
  aimAngles = -barrelToEnemyTransformed;

  Vector aimUp, aimLeft, aimForward;
  float spreadX, spreadY;
  aimAngles.AngleVectors(&aimForward, &aimLeft, &aimUp);
  spreadX = GetDataForMyWeapon("spreadx");
  spreadY = GetDataForMyWeapon("spready");

  // figure the new projected impact point based upon computed spread
  if (_activeWeapon.weapon->GetFireType(FIRE_MODE1) == FT_PROJECTILE)
  {
    // Apply Spread
    aimForward = aimForward * _activeWeapon.weapon->GetRange(FIRE_MODE1) +
                 aimLeft * G_CRandom(spreadX) +
                 aimUp * G_CRandom(spreadY);
  }

  // after figuring spread location, re-normalize vectors
  aimForward.normalize();

  aimAngles = aimForward.toAngles();

  _activeWeapon.weapon->SetControllerTag(WEAPONBONE_BARREL_TAG, gi.Tag_NumForName(_activeWeapon.weapon->edict->s.modelindex, "tag_barrel"));
  _activeWeapon.weapon->SetControllerAngles(WEAPONBONE_BARREL_TAG, aimAngles);

  //Draw Trace
  if (g_showbullettrace->integer)
  {
    Vector test;
    GetGunPositionData(&gunPos, &gunForward);
    test = gunForward * 1000 + gunPos;

    G_DebugLine(gunPos, test, 1.0f, 0.0f, 0.0f, 1.0f);

    Vector barrelForward;
    aimAngles.AngleVectors(&barrelForward);
  }
}
Beispiel #5
0
bool CBotNav::CantMoveForward(const Vector &move_angles)
{
   // use some TraceLines to determine if anything is blocking the current
   // path of the bot.

   Vector         v_forward, v_right, v_src, v_dest;
   traceresult_t  tr;

   move_angles.AngleVectors(&v_forward, &v_right);

   v_src = m_pBot->EyePosition();
   v_dest = v_src + v_forward * 40;

   // first do a trace from the bot's eyes forward...
   tr = TestLine(v_src, v_dest, false, m_pBot);

   // check if the trace hit something...
   if (tr.fraction < 1.0) {
      if (strncmp(tr.ent->GetClassname(), "func_door", 9) != 0)
         return true;
   }

   // bot's head is clear, check at shoulder level...
   // trace from the bot's shoulder left diagonal forward to the right shoulder...
   v_src = m_pBot->EyePosition() + Vector(0, 0, -16) - v_right * 16;
   v_dest = v_src + v_forward * 40;

   tr = TestLine(v_src, v_dest, false, m_pBot);

   // check if the trace hit something...
   if (tr.fraction < 1.0) {
      if (strncmp(tr.ent->GetClassname(), "func_door", 9) != 0)
         return true;
   }

   // bot's head is clear, check at shoulder level...
   // trace from the bot's shoulder right diagonal forward to the left shoulder...
   v_src = m_pBot->EyePosition() + Vector(0, 0, -16) + v_right * 16;
   v_dest = v_src + v_forward * 40;

   tr = TestLine(v_src, v_dest, false, m_pBot);

   // check if the trace hit something...
   if (tr.fraction < 1.0) {
      if (strncmp(tr.ent->GetClassname(), "func_door", 9) != 0)
         return true;
   }

   // Now check below Waist
   if (m_pBot->IsDucking())  {
      v_src = m_pBot->GetOrigin();
      v_dest = v_src + v_forward * 40;

      tr = TestLine(v_src, v_dest, false, m_pBot);

      // check if the trace hit something...
      if (tr.fraction < 1.0) {
         if (strncmp(tr.ent->GetClassname(), "func_door", 9) != 0)
            return true;
      }
   } else {
      // Trace from the left Waist to the right forward Waist Pos
      v_src = m_pBot->GetOrigin() + Vector(0, 0, -17) + v_right * -16;
      v_dest = m_pBot->GetOrigin() + Vector(0, 0, -17) + v_right * 16 + v_forward * 40;

      tr = TestLine(v_src, v_dest, false, m_pBot);

      // check if the trace hit something...
      if (tr.fraction < 1.0) {
         if (strncmp(tr.ent->GetClassname(), "func_door", 9) != 0)
            return true;
      }

      // Trace from the left Waist to the right forward Waist Pos
      v_src = m_pBot->GetOrigin() + Vector(0, 0, -17) + v_right * 16;
      v_dest = m_pBot->GetOrigin() + Vector(0, 0, -17) + v_right * -16 + v_forward * 40;

      tr = TestLine(v_src, v_dest, false, m_pBot);

      // check if the trace hit something...
      if (tr.fraction < 1.0) {
         if (strncmp(tr.ent->GetClassname(), "func_door", 9) != 0)
            return true;
      }
   }

   return false;  // bot can move forward, return false
}