tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/wwphys/humanphys.cpp

793 lines
33 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Renegade source code.
2025-02-27 16:39:46 +00:00
/*
** 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 a new issue Copy permalink