mirror of
https://github.com/electronicarts/CnC_Renegade.git
synced 2025-12-15 23:21:40 -05:00
Initial commit of Command & Conquer Renegade source code.
This commit is contained in:
LFeenanEA
792
Code/wwphys/humanphys.cpp
Normal file
792
Code/wwphys/humanphys.cpp
Normal file
@@ -0,0 +1,792 @@
|
||||
/*
|
||||
** Command & Conquer Renegade(tm)
|
||||
** Copyright 2025 Electronic Arts 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 3 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, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/***********************************************************************************************
|
||||
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
|
||||
***********************************************************************************************
|
||||
* *
|
||||
* Project Name : WWPhys *
|
||||
* *
|
||||
* $Archive:: /Commando/Code/wwphys/humanphys.cpp $*
|
||||
* *
|
||||
* Author:: Greg Hjelstrom *
|
||||
* *
|
||||
* $Modtime:: 10/27/01 4:32p $*
|
||||
* *
|
||||
* $Revision:: 44 $*
|
||||
* *
|
||||
*---------------------------------------------------------------------------------------------*
|
||||
* Functions: *
|
||||
* HumanPhysClass::HumanPhysClass -- Constructor *
|
||||
* HumanPhysClass::HumanPhysClass -- Constructor, initializes from a Definition *
|
||||
* HumanPhysClass::~HumanPhysClass -- Destructor *
|
||||
* HumanPhysClass::Timestep -- Simulate this object for time dt *
|
||||
* HumanPhysClass::Check_Ground -- check the ground state *
|
||||
* HumanPhysClass::Ballistic_Move -- ballistic motion *
|
||||
* HumanPhysClass::Slide_Move -- Sliding down a slope *
|
||||
* HumanPhysClass::Normal_Move -- Moving under user control *
|
||||
* HumanPhysClass::Compute_Desired_Move_Vector -- compute the move vector *
|
||||
* HumanPhysClass::Get_Factory -- returns the PersistFactory for save-load support *
|
||||
* HumanPhysClass::Save -- Save this object *
|
||||
* HumanPhysClass::Load -- Load this object *
|
||||
* HumanPhysClass::Render -- Render this object *
|
||||
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
||||
|
||||
|
||||
#include "humanphys.h"
|
||||
#include "wwdebug.h"
|
||||
#include "physcoltest.h"
|
||||
#include "pscene.h"
|
||||
#include "physcon.h"
|
||||
#include "physcontrol.h"
|
||||
#include "wwphysids.h"
|
||||
#include "persistfactory.h"
|
||||
#include "simpledefinitionfactory.h"
|
||||
#include "wwhack.h"
|
||||
#include "wwprofile.h"
|
||||
|
||||
DECLARE_FORCE_LINK(humanphys);
|
||||
|
||||
#define VERBOSE_LOGGING 0
|
||||
|
||||
#if VERBOSE_LOGGING
|
||||
#define VERBOSE_LOG(x) if (WWDEBUG_TRIGGER(WWDEBUG_TRIGGER_GENERIC0)) { WWDEBUG_SAY(x); }
|
||||
#else
|
||||
#define VERBOSE_LOG(x)
|
||||
#endif
|
||||
|
||||
|
||||
bool HumanPhysClass::_DisableHumanSimulation = false;
|
||||
bool HumanPhysClass::_DisableHumanRendering = false;
|
||||
|
||||
|
||||
/*
|
||||
** Declare a PersistFactory for HumanPhysClass
|
||||
*/
|
||||
SimplePersistFactoryClass<HumanPhysClass,PHYSICS_CHUNKID_HUMANPHYS> _HumanPhysFactory;
|
||||
|
||||
/*
|
||||
** Chunk-ID's used by HumanPhysClass
|
||||
*/
|
||||
enum
|
||||
{
|
||||
HUMANPHYS_CHUNK_PHYS3 = 0x04040404, // parent Phys3Class data
|
||||
HUMANPHYS_CHUNK_VARIABLES,
|
||||
|
||||
HUMANPHYS_VARIABLE_JUSTJUMPED = 0x00
|
||||
};
|
||||
|
||||
/*
|
||||
** SLOPE_SPEED_ADJUSTMENT - fraction of the speed to shave off when player is walking on
|
||||
** the steepest possible slope (just before sliding takes over). Also the fraction to
|
||||
** add when the player is walking straight downhill
|
||||
** AIR_SPEED_ADJUSTMENT - scale factor to apply to the users move when in the air
|
||||
*/
|
||||
const float SLOPE_SPEED_REDUCTION = 0.1f;
|
||||
const float AIR_MOVE_SCALE = 0.1f;
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::HumanPhysClass -- Constructor *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
HumanPhysClass::HumanPhysClass(void) :
|
||||
IsAIControlledJump (false)
|
||||
{
|
||||
JustJumped = false;
|
||||
Set_Mass(1.0f); // ??
|
||||
|
||||
// (gth) turn on shadows for all humans for now
|
||||
Enable_Shadow_Generation(true);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Init -- initializes from a Definition *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
void HumanPhysClass::Init(const HumanPhysDefClass & def)
|
||||
{
|
||||
Phys3Class::Init(def);
|
||||
|
||||
// (gth) turn on shadows for all humans for now
|
||||
Enable_Shadow_Generation(true);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::~HumanPhysClass -- Destructor *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
*=============================================================================================*/
|
||||
HumanPhysClass::~HumanPhysClass(void)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Timestep -- Simulate this object for time dt *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
void HumanPhysClass::Timestep(float dt)
|
||||
{
|
||||
VERBOSE_LOG(("HumanPhys::Timestep\r\n"));
|
||||
bool was_on_ground = OnGround;
|
||||
|
||||
if (Is_Asleep()) {
|
||||
if ((Controller != NULL) && (!Controller->Is_Inactive())) {
|
||||
Set_Flag(ASLEEP,false);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Phys3Class::Timestep(dt);
|
||||
|
||||
if (Is_Asleep()) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
WWPROFILE("HumanPhys::Timestep");
|
||||
|
||||
// if we didn't jump, we're not on the ground, we were on the ground, and our Z velocity is >0, set it to 0
|
||||
if (was_on_ground && !OnGround && !JustJumped && (State.Velocity.Z > 0.0f)) {
|
||||
State.Velocity.Z = 0.0f;
|
||||
}
|
||||
|
||||
// clear the just jumped flag if its set and we've reached the apex.
|
||||
if (JustJumped && State.Velocity.Z < 0.0f) {
|
||||
JustJumped = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Render -- Render this object *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
*=============================================================================================*/
|
||||
void HumanPhysClass::Render(RenderInfoClass & rinfo)
|
||||
{
|
||||
#ifdef WWDEBUG
|
||||
PhysicsSceneClass::Get_Instance()->Debug_Display_Dynamic_Vis_Node(VisNodeID);
|
||||
#endif
|
||||
Phys3Class::Render(rinfo);
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Check_Ground -- check the ground state *
|
||||
* *
|
||||
* Humans override this so that they don't stick to the ground when they want to jump *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
* 7/20/2001 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
void HumanPhysClass::Check_Ground(const AABoxClass & box,GroundStateStruct * gs,float check_dist)
|
||||
{
|
||||
if (JustJumped) {
|
||||
gs->OnGround = false;
|
||||
} else {
|
||||
Phys3Class::Check_Ground(box,gs,check_dist);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Ballistic_Move -- ballistic motion *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
bool HumanPhysClass::Ballistic_Move(float dt)
|
||||
{
|
||||
WWPROFILE("HumanPhys::Ballistic_Move");
|
||||
VERBOSE_LOG(("HumanPhys::Ballistic_Move\r\n"));
|
||||
|
||||
// Compute a move vector for the object flying through the air...
|
||||
Vector3 move;
|
||||
float accel = PhysicsConstants::GravityAcceleration.Z * GravScale;
|
||||
|
||||
Vector3 start_vel = State.Velocity;
|
||||
Vector3 start_pos = State.Position;
|
||||
|
||||
move.X = State.Velocity.X * dt;
|
||||
move.Y = State.Velocity.Y * dt;
|
||||
move.Z = 0.5f * accel * dt * dt + State.Velocity.Z * dt;
|
||||
|
||||
bool moved = Apply_Move(move,dt);
|
||||
|
||||
// Compute X,Y velocities from the actual move that was performed
|
||||
State.Velocity.X = (State.Position.X - start_pos.X) / dt;
|
||||
State.Velocity.Y = (State.Position.Y - start_pos.Y) / dt;
|
||||
|
||||
// Compute the analytical Z velocity and the ad-hoc Z velocity, the
|
||||
// more negative one is the one to keep. What this does is use the
|
||||
// analytical velocity unless the character hits a roof.
|
||||
State.Velocity.Z = start_vel.Z + accel * dt;
|
||||
#if 0
|
||||
State.Velocity.Z = min((State.Position.Z - start_pos.Z) / dt,start_vel.Z + accel * dt);
|
||||
#endif
|
||||
|
||||
// Now let the user adjust the movement a little
|
||||
if (Controller && !IsAIControlledJump) {
|
||||
Vector3 player_move(Controller->Get_Move_Vector());
|
||||
player_move.Rotate_Z(Heading);
|
||||
State.Velocity.X += AIR_MOVE_SCALE * NormSpeed * player_move.X;
|
||||
State.Velocity.Y += AIR_MOVE_SCALE * NormSpeed * player_move.Y;
|
||||
|
||||
Vector3 xy_vel = State.Velocity;
|
||||
xy_vel.Z = 0;
|
||||
if (xy_vel.Length2() > NormSpeed * NormSpeed) {
|
||||
float scale = NormSpeed / xy_vel.Length();
|
||||
State.Velocity.X *= scale;
|
||||
State.Velocity.Y *= scale;
|
||||
}
|
||||
}
|
||||
|
||||
IsAIControlledJump &= (Is_In_Contact () == false);
|
||||
return moved;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Slide_Move -- Sliding down a slope *
|
||||
* *
|
||||
* Humans can jump when sliding down a slope *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
bool HumanPhysClass::Slide_Move(const GroundStateStruct & gs,float dt)
|
||||
{
|
||||
WWPROFILE("HumanPhys::Slide_Move");
|
||||
VERBOSE_LOG(("HumanPhys::Slide_Move\r\n"));
|
||||
|
||||
// Compute a move vector which causes the object to slide down the slope...
|
||||
Vector3 start_pos = State.Position;
|
||||
Vector3 move = NormSpeed * dt * gs.Down;
|
||||
if (Controller != NULL) {
|
||||
if (Controller->Get_Move_Vector().Z > 0.0f) {
|
||||
move.Z += Controller->Get_Move_Vector().Z * dt;
|
||||
JustJumped = true;
|
||||
}
|
||||
}
|
||||
|
||||
bool moved = Apply_Move(move,dt,true,false,true);
|
||||
State.Velocity = (State.Position - start_pos)/dt;
|
||||
|
||||
return moved;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Normal_Move -- Moving under user control *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
bool HumanPhysClass::Normal_Move(const GroundStateStruct & gs,float dt)
|
||||
{
|
||||
WWPROFILE("HumanPhys::Normal_Move");
|
||||
VERBOSE_LOG(("HumanPhys::Normal_Move\r\n"));
|
||||
|
||||
if (Controller == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
** STEP ONE: Compute the desired Move. The desired move is determined by the player's
|
||||
** controller setting and the plane that we are currently standing on.
|
||||
*/
|
||||
Vector3 move;
|
||||
Compute_Desired_Move_Vector(gs,dt,&move);
|
||||
|
||||
/*
|
||||
** STEP TWO: Try to apply the move and snap back down to the ground. If we did not
|
||||
** jump and we end up on an un-walkable slope, we'll re-wind and clip our original
|
||||
** move so that it avoids that slope.
|
||||
*/
|
||||
Vector3 start_position = State.Position;
|
||||
Vector3 start_move = move;
|
||||
|
||||
bool moved = Apply_Move(move,dt,true,!JustJumped);
|
||||
|
||||
if ((moved) && (!JustJumped)) {
|
||||
Snap_To_Ground(State.Position - start_position,true);
|
||||
}
|
||||
|
||||
/*
|
||||
** STEP THREE: If we snapped down onto an un-walkable slope, revert our state,
|
||||
** clip the original move against the equivalent wall for this slope, and try
|
||||
** one more time.
|
||||
*/
|
||||
if (moved && !JustJumped && (GroundState.OnGround) && (GroundState.Normal.Z < SlideNormalZ)) {
|
||||
|
||||
State.Position = start_position;
|
||||
move = start_move;
|
||||
|
||||
Vector3 slope_wall = GroundState.Normal;
|
||||
slope_wall.Z = 0.0f;
|
||||
slope_wall.Normalize();
|
||||
|
||||
Clip_Move(&slope_wall,1,&move);
|
||||
moved = Apply_Move(move,dt,true,!JustJumped);
|
||||
|
||||
if ((moved) && (!JustJumped)) {
|
||||
Snap_To_Ground(State.Position - start_position,true);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
** STEP FOUR: Finally, compute our velocity in case we became airborne
|
||||
*/
|
||||
State.Velocity = (State.Position - start_position) / dt;
|
||||
// BMG Unless they just jumped
|
||||
if ( !JustJumped ) {
|
||||
State.Velocity.Z = WWMath::Min(State.Velocity.Z,0.0f); // don't ever let humans launch off slopes
|
||||
}
|
||||
|
||||
|
||||
return moved;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Compute_Desired_Move_Vector -- compute the move vector *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
void HumanPhysClass::Compute_Desired_Move_Vector(const GroundStateStruct & gs,float dt,Vector3 * set_move)
|
||||
{
|
||||
Vector3 move(Controller->Get_Move_Vector());
|
||||
|
||||
if (move.Z < 0.0f) {
|
||||
move.Z = 0.0f;
|
||||
}
|
||||
|
||||
float jump = move.Z;
|
||||
if (jump > 0.0f) {
|
||||
move.Z = 0.0f;
|
||||
JustJumped = true;
|
||||
}
|
||||
|
||||
/*
|
||||
** rotate the move vector into "2D" world space
|
||||
*/
|
||||
move.Rotate_Z(Heading);
|
||||
|
||||
/*
|
||||
** rotate the move vector onto the current contact plane
|
||||
*/
|
||||
Vector3 axis;
|
||||
Vector3::Cross_Product(Vector3(0,0,1),gs.Normal,&axis);
|
||||
float axis_len = axis.Length2();
|
||||
|
||||
if (axis_len > 0.0f) {
|
||||
float s_angle = axis.Length();
|
||||
float c_angle = Vector3::Dot_Product(Vector3(0,0,1),gs.Normal);
|
||||
axis.Normalize();
|
||||
Matrix3 rotation(axis,s_angle,c_angle);
|
||||
Matrix3::Rotate_Vector(rotation,move,&move);
|
||||
}
|
||||
|
||||
/*
|
||||
** check the result to ensure it is 90deg from the plane normal (moving on plane)
|
||||
*/
|
||||
#ifdef WWDEBUG
|
||||
Vector3 movedir = move;
|
||||
movedir.Normalize();
|
||||
WWASSERT(fabs(Vector3::Dot_Product(movedir,gs.Normal)) < WWMATH_EPSILON);
|
||||
#endif
|
||||
|
||||
/*
|
||||
** adjust the vector to make uphill slower and downhill faster
|
||||
*/
|
||||
float dot = Vector3::Dot_Product(move,gs.Down);
|
||||
float scale = (1.0f - gs.Normal.Z) / (1.0f - SlideNormalZ);
|
||||
move = move + SLOPE_SPEED_REDUCTION * scale * dot * move;
|
||||
|
||||
/*
|
||||
** Multiply by the human velocity
|
||||
*/
|
||||
move *= NormSpeed;
|
||||
if (jump > 0.0f) {
|
||||
move.Z = jump;
|
||||
}
|
||||
move *= dt;
|
||||
|
||||
/*
|
||||
** done!
|
||||
*/
|
||||
*set_move = move;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Get_Factory -- returns the PersistFactory for save-load support *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
const PersistFactoryClass & HumanPhysClass::Get_Factory(void) const
|
||||
{
|
||||
return _HumanPhysFactory;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Save -- Save this object *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
bool HumanPhysClass::Save(ChunkSaveClass &csave)
|
||||
{
|
||||
csave.Begin_Chunk(HUMANPHYS_CHUNK_PHYS3);
|
||||
Phys3Class::Save(csave);
|
||||
csave.End_Chunk();
|
||||
|
||||
csave.Begin_Chunk(HUMANPHYS_CHUNK_VARIABLES);
|
||||
WRITE_MICRO_CHUNK(csave,HUMANPHYS_VARIABLE_JUSTJUMPED,JustJumped);
|
||||
csave.End_Chunk();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Load -- Load this object *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 9/16/2000 gth : Created. *
|
||||
*=============================================================================================*/
|
||||
bool HumanPhysClass::Load(ChunkLoadClass &cload)
|
||||
{
|
||||
while (cload.Open_Chunk()) {
|
||||
|
||||
switch(cload.Cur_Chunk_ID())
|
||||
{
|
||||
case HUMANPHYS_CHUNK_PHYS3:
|
||||
Phys3Class::Load(cload);
|
||||
break;
|
||||
|
||||
case HUMANPHYS_CHUNK_VARIABLES:
|
||||
while (cload.Open_Micro_Chunk()) {
|
||||
switch(cload.Cur_Micro_Chunk_ID()) {
|
||||
READ_MICRO_CHUNK(cload,HUMANPHYS_VARIABLE_JUSTJUMPED,JustJumped);
|
||||
}
|
||||
cload.Close_Micro_Chunk();
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
|
||||
break;
|
||||
}
|
||||
|
||||
cload.Close_Chunk();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************************************
|
||||
* HumanPhysClass::Jump_To_Point -- Jump to the given X, Y, Z location. *
|
||||
* *
|
||||
* INPUT: *
|
||||
* *
|
||||
* OUTPUT: *
|
||||
* *
|
||||
* WARNINGS: *
|
||||
* *
|
||||
* HISTORY: *
|
||||
* 10/19/2000 pds : Created. *
|
||||
*=============================================================================================*/
|
||||
void HumanPhysClass::Jump_To_Point (const Vector3 &dest_pos)
|
||||
{
|
||||
const float gravity = PhysicsConstants::GravityAcceleration.Z * Get_Gravity_Multiplier();
|
||||
const float minangle = 0.3491f; // 20 degrees.
|
||||
const float maxangle = 1.2217f; // 70 degrees.
|
||||
|
||||
Vector3 displacement, velocity, acceleration;
|
||||
float x, y, theta;
|
||||
float time;
|
||||
|
||||
acceleration.Set (0.0f, 0.0f, gravity);
|
||||
displacement = (dest_pos - Get_Transform().Get_Translation());
|
||||
|
||||
// Calculate a launch/landing angle most appropriate for the jump to be made.
|
||||
// Horizontal jumps will use the minimum launch angle, nera vertical jumps will
|
||||
// use the maximum launch/landing angle.
|
||||
x = Vector2 (displacement.X, displacement.Y).Length();
|
||||
y = WWMath::Fabs (displacement.Z);
|
||||
theta = WWMath::Lerp (minangle, maxangle, y / (x + y));
|
||||
|
||||
// If character is jumping up then theta is the landing angle
|
||||
// - otherwise theta is the launch angle.
|
||||
if (displacement.Z >= 0.0f) {
|
||||
|
||||
// Using standard projectile math, final velocity is given by:
|
||||
//
|
||||
// vfy = viy + g * t (1)
|
||||
//
|
||||
// and
|
||||
//
|
||||
// vfx = vix = x / t (2)
|
||||
//
|
||||
// and
|
||||
//
|
||||
// viy = y / t - 0.5 * g * t (3)
|
||||
//
|
||||
// where vfy is final vertical velocity, viy is initial vertical velocity, g is acceleration
|
||||
// due to gravity, t is time, vfx is final horizontal velocity, vix is initial horizontal
|
||||
// velocity, y is vertical displacement.
|
||||
//
|
||||
// We require at landing time:
|
||||
// tan (theta) = vfy / vfx
|
||||
// = (viy + g * t) / (x / t) (4).
|
||||
//
|
||||
// Substituting (3) in (4):
|
||||
//
|
||||
// tan (theta) = (y / t - 0.5 * g * t + g * t) / (x / t).
|
||||
//
|
||||
// Rearranging gives:
|
||||
//
|
||||
// t = sqrt ((2.0f * (-x * tan (theta) - y)) / g).
|
||||
time = sqrt (2.0f * ((-x * tanf (theta)) - y) / gravity);
|
||||
|
||||
} else {
|
||||
|
||||
// Using standard projectile math, vertical displacement is given by:
|
||||
//
|
||||
// y = s * sin(theta) * t + 0.5 * g * t^2 (1)
|
||||
//
|
||||
// where s is speed, theta is launch angle, g is acceleration due to gravity(-ve),
|
||||
// and t is time.
|
||||
//
|
||||
// Horizontal displacement is given by:
|
||||
//
|
||||
// x = s * sin(theta) * t (2)
|
||||
//
|
||||
// because horizontal velocity is constant.
|
||||
// Substituting (2) for t in (1) gives:
|
||||
//
|
||||
// y = (s * sin(theta) * x / (s * cos(theta))) + 0.5 * g * t^2
|
||||
//
|
||||
// which simplifies in terms of t to:
|
||||
//
|
||||
// t = sqrt (2.0 * (y - x * tan(theta)) / g).
|
||||
time = sqrt (2.0f * (-y - (x * tanf (theta))) / gravity);
|
||||
}
|
||||
|
||||
// Calculate velocity vector using standard projectile math.
|
||||
velocity = (displacement / time) - ((0.5f * acceleration) * time);
|
||||
|
||||
//
|
||||
// Set the new velocity
|
||||
//
|
||||
Set_Velocity(velocity);
|
||||
|
||||
//
|
||||
// Reset some internal states so the physics object knows its
|
||||
// in a jumping state.
|
||||
//
|
||||
Invalidate_Ground_State();
|
||||
Set_Flag(ASLEEP,false);
|
||||
JustJumped = true;
|
||||
IsAIControlledJump = true;
|
||||
return ;
|
||||
}
|
||||
|
||||
|
||||
/****************************************************************************************************
|
||||
**
|
||||
** HumanPhysDefClass Implementation
|
||||
**
|
||||
****************************************************************************************************/
|
||||
|
||||
/*
|
||||
** Persist factory for HumanPhysDefClass
|
||||
*/
|
||||
SimplePersistFactoryClass<HumanPhysDefClass,PHYSICS_CHUNKID_HUMANPHYSDEF> _HumanPhysDefFactory;
|
||||
|
||||
/*
|
||||
** Definition factory for HumanPhysDefClass. This makes it show up in the editor
|
||||
*/
|
||||
DECLARE_DEFINITION_FACTORY(HumanPhysDefClass, CLASSID_HUMANPHYSDEF, "Human") _HumanPhysDefDefFactory;
|
||||
|
||||
/*
|
||||
** Chunk ID's used by HumanPhysDefClass
|
||||
*/
|
||||
enum
|
||||
{
|
||||
HUMANPHYSDEF_CHUNK_PHYS3DEF = 0x00516000, // phys3def data (parent class)
|
||||
};
|
||||
|
||||
HumanPhysDefClass::HumanPhysDefClass(void)
|
||||
{
|
||||
}
|
||||
|
||||
uint32 HumanPhysDefClass::Get_Class_ID (void) const
|
||||
{
|
||||
return CLASSID_HUMANPHYSDEF;
|
||||
}
|
||||
|
||||
PersistClass * HumanPhysDefClass::Create(void) const
|
||||
{
|
||||
HumanPhysClass * obj = NEW_REF(HumanPhysClass,());
|
||||
obj->Init(*this);
|
||||
return obj;
|
||||
}
|
||||
|
||||
const PersistFactoryClass & HumanPhysDefClass::Get_Factory (void) const
|
||||
{
|
||||
return _HumanPhysDefFactory;
|
||||
}
|
||||
|
||||
bool HumanPhysDefClass::Save(ChunkSaveClass &csave)
|
||||
{
|
||||
csave.Begin_Chunk(HUMANPHYSDEF_CHUNK_PHYS3DEF);
|
||||
Phys3DefClass::Save(csave);
|
||||
csave.End_Chunk();
|
||||
|
||||
// no variables for now
|
||||
return true;
|
||||
}
|
||||
|
||||
bool HumanPhysDefClass::Load(ChunkLoadClass &cload)
|
||||
{
|
||||
while (cload.Open_Chunk()) {
|
||||
switch(cload.Cur_Chunk_ID()) {
|
||||
|
||||
case HUMANPHYSDEF_CHUNK_PHYS3DEF:
|
||||
Phys3DefClass::Load(cload);
|
||||
break;
|
||||
|
||||
default:
|
||||
WWDEBUG_SAY(("Unhandled Chunk: 0x%X File: %s Line: %d\r\n",cload.Cur_Chunk_ID(),__FILE__,__LINE__));
|
||||
break;
|
||||
}
|
||||
cload.Close_Chunk();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
bool HumanPhysDefClass::Is_Type(const char * type_name)
|
||||
{
|
||||
if (stricmp(type_name,HumanPhysDefClass::Get_Type_Name()) == 0) {
|
||||
return true;
|
||||
} else {
|
||||
return Phys3DefClass::Is_Type(type_name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user