Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-05-13 14:07:04 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into lara_state_cleaning_etc

Browse source
This commit is contained in:
Sezz 2021-11-16 00:41:38 +11:00
commit aaccfb44da
2 changed files with 242 additions and 241 deletions
Download patch file Download diff file Expand all files Collapse all files

481
TR5Main/Objects/TR3/Vehicles/quad.cpp
View file

@ -20,8 +20,8 @@
using std::vector; using std::vector;
using namespace TEN::Math::Random; using namespace TEN::Math::Random;
#define MAX_VELOCITY 0xA000 #define MAX_VELOCITY 0xA000
#define MIN_DRIFT_SPEED 0x3000 #define MIN_HANDBRAKE_SPEED 0x3000
#define BRAKE 0x0280 #define BRAKE 0x0280
@ -39,7 +39,6 @@ using namespace TEN::Math::Random;
#define QUAD_SIDE 260 #define QUAD_SIDE 260
#define QUAD_RADIUS 500 #define QUAD_RADIUS 500
#define QUAD_HEIGHT 512 #define QUAD_HEIGHT 512
#define QUAD_SNOW 500 // Unused.
#define QUAD_HIT_LEFT 11 #define QUAD_HIT_LEFT 11
#define QUAD_HIT_RIGHT 12 #define QUAD_HIT_RIGHT 12
@ -52,18 +51,23 @@ using namespace TEN::Math::Random;
#define DAMAGE_START 140 #define DAMAGE_START 140
#define DAMAGE_LENGTH 14 #define DAMAGE_LENGTH 14
#define GETOFF_DISTANCE 385 // Root bone offset from final frame of animation. #define GETOFF_DISTANCE STEP_SIZE * 2
#define QUAD_UNDO_TURN ANGLE(2.0f) #define QUAD_UNDO_TURN ANGLE(2.0f)
#define QUAD_TURN_RATE (ANGLE(0.5f) + QUAD_UNDO_TURN) #define QUAD_TURN (ANGLE(0.5f) + QUAD_UNDO_TURN)
#define QUAD_TURN_MAX ANGLE(5.0f) #define QUAD_MAX_TURN ANGLE(5.0f)
#define QUAD_DRIFT_TURN_RATE (ANGLE(0.75f) + QUAD_UNDO_TURN) #define QUAD_HTURN (ANGLE(0.75f) + QUAD_UNDO_TURN)
#define QUAD_DRIFT_TURN_MAX ANGLE(8.0f) #define QUAD_MAX_HTURN ANGLE(8.0f)
#define MIN_MOMENTUM_TURN ANGLE(3.0f) #define MIN_MOMENTUM_TURN ANGLE(3.0f)
#define MAX_MOMENTUM_TURN ANGLE(1.5f) #define MAX_MOMENTUM_TURN ANGLE(1.5f)
#define QUAD_MAX_MOM_TURN ANGLE(150.0f) #define QUAD_MAX_MOM_TURN ANGLE(150.0f)
#define QUAD_FRONT 550
#define QUAD_SIDE 260
#define QUAD_RADIUS 500
#define QUAD_SNOW 500
#define QUAD_MAX_HEIGHT STEP_SIZE #define QUAD_MAX_HEIGHT STEP_SIZE
#define QUAD_MIN_BOUNCE (MAX_VELOCITY / 2) / 256 #define QUAD_MIN_BOUNCE (MAX_VELOCITY / 2) / 256
@ -94,7 +98,7 @@ using namespace TEN::Math::Random;
#define QUAD_IN_LEFT IN_LEFT #define QUAD_IN_LEFT IN_LEFT
#define QUAD_IN_RIGHT IN_RIGHT #define QUAD_IN_RIGHT IN_RIGHT
enum QuadEffectPosition { enum QUAD_EFFECTS_POSITIONS {
EXHAUST_LEFT = 0, EXHAUST_LEFT = 0,
EXHAUST_RIGHT, EXHAUST_RIGHT,
BACKLEFT_TYRE, BACKLEFT_TYRE,
@ -103,33 +107,33 @@ enum QuadEffectPosition {
FRONTLEFT_TYRE FRONTLEFT_TYRE
}; };
enum QuadFlags { enum QUAD_FLAGS {
QUAD_FLAGS_DEAD = 0x80, QUAD_FLAGS_DEAD = 0x80,
QUAD_FLAGS_IS_FALLING = 0x40 QUAD_FLAGS_IS_FALLING = 0x40
}; };
enum QuadState { enum QUAD_ANIM_STATES {
QUAD_STATE_DRIVE = 1, QUAD_STATE_DRIVE = 1,
QUAD_STATE_TURN_LEFT = 2, QUAD_STATE_TURNL = 2,
QUAD_STATE_SLOW = 5, QUAD_STATE_SLOW = 5,
QUAD_STATE_BRAKE = 6, QUAD_STATE_BRAKE = 6,
QUAD_STATE_BIKE_DEATH = 7, QUAD_STATE_BIKEDEATH = 7,
QUAD_STATE_FALL = 8, QUAD_STATE_FALL = 8,
QUAD_STATE_GET_ON_RIGHT = 9, QUAD_STATE_GETONR = 9,
QUAD_STATE_GET_OFF_RIGHT = 10, QUAD_STATE_GETOFFR = 10,
QUAD_STATE_HIT_BACK = 11, QUAD_STATE_HITBACK = 11,
QUAD_STATE_HIT_FRONT = 12, QUAD_STATE_HITFRONT = 12,
QUAD_STATE_HIT_LEFT = 13, QUAD_STATE_HITLEFT = 13,
QUAD_STATE_HIT_RIGHT = 14, QUAD_STATE_HITRIGHT = 14,
QUAD_STATE_IDLE = 15, QUAD_STATE_STOP = 15,
QUAD_STATE_LAND = 17, QUAD_STATE_LAND = 17,
QUAD_STATE_IDLE_SLOWLY = 18, QUAD_STATE_STOPSLOWLY = 18,
QUAD_STATE_FALL_DEATH = 19, QUAD_STATE_FALLDEATH = 19,
QUAD_STATE_FALL_OFF = 20, QUAD_STATE_FALLOFF = 20,
QUAD_STATE_WHEELIE = 21, // Unused. QUAD_STATE_WHEELIE = 21,
QUAD_STATE_TURN_RIGHT = 22, QUAD_STATE_TURNR = 22,
QUAD_STATE_GET_ON_LEFT = 23, QUAD_STATE_GETONL = 23,
QUAD_STATE_GET_OFF_LEFT = 24, QUAD_STATE_GETOFFL = 24,
}; };
BITE_INFO quadEffectsPositions[6] = { BITE_INFO quadEffectsPositions[6] = {
@ -141,48 +145,30 @@ BITE_INFO quadEffectsPositions[6] = {
{ -90, 180, -32, 7 } { -90, 180, -32, 7 }
}; };
bool QuadDriftStarting; bool QuadHandbrakeStarting;
bool QuadCanDriftStart; bool QuadCanHandbrakeStart;
int QuadSmokeStart; int QuadSmokeStart;
bool QuadNoGetOff; bool QuadNoGetOff;
void InitialiseQuadBike(short itemNumber) static void QuadbikeExplode(ITEM_INFO* item)
{ {
ITEM_INFO* quad = &g_Level.Items[itemNumber]; if (g_Level.Rooms[item->roomNumber].flags & ENV_FLAG_WATER)
auto quadInfo = (QUAD_INFO*)quad->data; TriggerUnderwaterExplosion(item, 1);
quadInfo->velocity = 0;
quadInfo->turnRate = 0;
quadInfo->leftFallspeed = 0;
quadInfo->rightFallspeed = 0;
quadInfo->momentumAngle = quad->pos.yRot;
quadInfo->extraRotation = 0;
quadInfo->trackMesh = 0;
quadInfo->pitch = 0;
quadInfo->flags = 0;
}
static void QuadbikeExplode(ITEM_INFO* lara, ITEM_INFO* quad)
{
LaraInfo*& laraInfo = LaraItem->data;
if (g_Level.Rooms[quad->roomNumber].flags & ENV_FLAG_WATER)
TriggerUnderwaterExplosion(quad, 1);
else else
{ {
TriggerExplosionSparks(quad->pos.xPos, quad->pos.yPos, quad->pos.zPos, 3, -2, 0, quad->roomNumber); TriggerExplosionSparks(item->pos.xPos, item->pos.yPos, item->pos.zPos, 3, -2, 0, item->roomNumber);
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
TriggerExplosionSparks(quad->pos.xPos, quad->pos.yPos, quad->pos.zPos, 3, -1, 0, quad->roomNumber); TriggerExplosionSparks(item->pos.xPos, item->pos.yPos, item->pos.zPos, 3, -1, 0, item->roomNumber);
} }
auto pos = PHD_3DPOS(quad->pos.xPos, quad->pos.yPos - (STEP_SIZE / 2), quad->pos.zPos, 0, quad->pos.yRot, 0); auto pos = PHD_3DPOS(item->pos.xPos, item->pos.yPos - (STEP_SIZE / 2), item->pos.zPos, 0, item->pos.yRot, 0);
TriggerShockwave(&pos, 50, 180, 40, GenerateFloat(160, 200), 60, 60, 64, GenerateFloat(0, 359), 0); TriggerShockwave(&pos, 50, 180, 40, GenerateFloat(160, 200), 60, 60, 64, GenerateFloat(0, 359), 0);
SoundEffect(SFX_TR4_EXPLOSION1, NULL, 0); SoundEffect(SFX_TR4_EXPLOSION1, NULL, 0);
SoundEffect(SFX_TR4_EXPLOSION2, NULL, 0); SoundEffect(SFX_TR4_EXPLOSION2, NULL, 0);
quad->status = ITEM_DEACTIVATED; item->status = ITEM_DEACTIVATED;
laraInfo->Vehicle = NO_ITEM; Lara.Vehicle = NO_ITEM;
} }
static int CanQuadbikeGetOff(int direction) static int CanQuadbikeGetOff(int direction)
@ -219,7 +205,7 @@ static int CanQuadbikeGetOff(int direction)
return true; return true;
} }
static bool QuadCheckGetOff(ITEM_INFO* lara, ITEM_INFO* quad) static bool QuadCheckGetOff(ITEM_INFO* quad, ITEM_INFO* lara)
{ {
LaraInfo*& laraInfo = lara->data; LaraInfo*& laraInfo = lara->data;
auto quadInfo = (QUAD_INFO*)quad->data; auto quadInfo = (QUAD_INFO*)quad->data;
@ -227,29 +213,30 @@ static bool QuadCheckGetOff(ITEM_INFO* lara, ITEM_INFO* quad)
if (laraInfo->Vehicle == NO_ITEM) if (laraInfo->Vehicle == NO_ITEM)
return true; return true;
if ((lara->currentAnimState == QUAD_STATE_GET_OFF_RIGHT || lara->currentAnimState == QUAD_STATE_GET_OFF_LEFT) && if ((lara->currentAnimState == QUAD_STATE_GETOFFR || lara->currentAnimState == QUAD_STATE_GETOFFL) &&
TestLastFrame(lara, lara->animNumber)) TestLastFrame(lara, lara->animNumber))
{ {
if (lara->currentAnimState == QUAD_STATE_GET_OFF_LEFT) if (lara->currentAnimState == QUAD_STATE_GETOFFL)
lara->pos.yRot += ANGLE(90.0f); lara->pos.yRot += ANGLE(90.0f);
else else
lara->pos.yRot -= ANGLE(90.0f); lara->pos.yRot -= ANGLE(90.0f);
SetAnimation(lara, LA_STAND_IDLE); SetAnimation(lara, LA_STAND_IDLE);
laraInfo->Vehicle = NO_ITEM;
laraInfo->gunStatus = LG_NO_ARMS;
lara->pos.xPos -= GETOFF_DISTANCE * phd_sin(lara->pos.yRot); lara->pos.xPos -= GETOFF_DISTANCE * phd_sin(lara->pos.yRot);
lara->pos.zPos -= GETOFF_DISTANCE * phd_cos(lara->pos.yRot); lara->pos.zPos -= GETOFF_DISTANCE * phd_cos(lara->pos.yRot);
lara->pos.xRot = 0; lara->pos.xRot = 0;
lara->pos.zRot = 0; lara->pos.zRot = 0;
laraInfo->Vehicle = NO_ITEM;
laraInfo->gunStatus = LG_NO_ARMS;
if (lara->currentAnimState == QUAD_STATE_FALL_OFF) if (lara->currentAnimState == QUAD_STATE_FALLOFF)
{ {
PHD_VECTOR pos = { 0, 0, 0 }; PHD_VECTOR pos = { 0, 0, 0 };
SetAnimation(lara, LA_FREEFALL); SetAnimation(lara, LA_FREEFALL);
GetJointAbsPosition(lara, &pos, LM_HIPS); GetJointAbsPosition(lara, &pos, LM_HIPS);
quad->flags |= ONESHOT;
lara->pos.xPos = pos.x; lara->pos.xPos = pos.x;
lara->pos.yPos = pos.y; lara->pos.yPos = pos.y;
lara->pos.zPos = pos.z; lara->pos.zPos = pos.z;
@ -259,11 +246,10 @@ static bool QuadCheckGetOff(ITEM_INFO* lara, ITEM_INFO* quad)
lara->pos.zRot = 0; lara->pos.zRot = 0;
lara->hitPoints = 0; lara->hitPoints = 0;
laraInfo->gunStatus = LG_NO_ARMS; laraInfo->gunStatus = LG_NO_ARMS;
quad->flags |= ONESHOT;
return false; return false;
} }
else if (lara->currentAnimState == QUAD_STATE_FALL_DEATH) else if (lara->currentAnimState == QUAD_STATE_FALLDEATH)
{ {
quadInfo->flags |= QUAD_FLAGS_DEAD; quadInfo->flags |= QUAD_FLAGS_DEAD;
lara->goalAnimState = LS_DEATH; lara->goalAnimState = LS_DEATH;
@ -284,9 +270,9 @@ static int GetOnQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, COLL_INFO* coll)
LaraInfo*& laraInfo = lara->data; LaraInfo*& laraInfo = lara->data;
if (!(TrInput & IN_ACTION) || if (!(TrInput & IN_ACTION) ||
lara->gravityStatus ||
laraInfo->gunStatus != LG_NO_ARMS ||
quad->flags & ONESHOT || quad->flags & ONESHOT ||
laraInfo->gunStatus != LG_NO_ARMS ||
lara->gravityStatus ||
abs(quad->pos.yPos - lara->pos.yPos) > STEP_SIZE) abs(quad->pos.yPos - lara->pos.yPos) > STEP_SIZE)
{ {
return false; return false;
@ -332,6 +318,7 @@ static int GetOnQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, COLL_INFO* coll)
static void QuadBaddieCollision(ITEM_INFO* lara, ITEM_INFO* quad) static void QuadBaddieCollision(ITEM_INFO* lara, ITEM_INFO* quad)
{ {
vector<short> roomsList; vector<short> roomsList;
roomsList.push_back(quad->roomNumber); roomsList.push_back(quad->roomNumber);
ROOM_INFO* room = &g_Level.Rooms[quad->roomNumber]; ROOM_INFO* room = &g_Level.Rooms[quad->roomNumber];
@ -345,10 +332,7 @@ static void QuadBaddieCollision(ITEM_INFO* lara, ITEM_INFO* quad)
while (itemNum != NO_ITEM) while (itemNum != NO_ITEM)
{ {
ITEM_INFO* item = &g_Level.Items[itemNum]; ITEM_INFO* item = &g_Level.Items[itemNum];
if (item->collidable && if (item->collidable && item->status != ITEM_INVISIBLE && item != lara && item != quad)
item->status != ITEM_INVISIBLE &&
item != lara &&
item != quad)
{ {
OBJECT_INFO* object = &Objects[item->objectNumber]; OBJECT_INFO* object = &Objects[item->objectNumber];
if (object->collision && object->intelligent) if (object->collision && object->intelligent)
@ -373,15 +357,15 @@ static void QuadBaddieCollision(ITEM_INFO* lara, ITEM_INFO* quad)
} }
} }
static int GetQuadCollisionAnim(ITEM_INFO* quad, PHD_VECTOR* p) static int GetQuadCollisionAnim(ITEM_INFO* item, PHD_VECTOR* p)
{ {
p->x = quad->pos.xPos - p->x; p->x = item->pos.xPos - p->x;
p->z = quad->pos.zPos - p->z; p->z = item->pos.zPos - p->z;
if (p->x || p->z) if (p->x || p->z)
{ {
float c = phd_cos(quad->pos.yRot); float c = phd_cos(item->pos.yRot);
float s = phd_sin(quad->pos.yRot); float s = phd_sin(item->pos.yRot);
int front = p->z * c + p->x * s; int front = p->z * c + p->x * s;
int side = -p->z * s + p->x * c; int side = -p->z * s + p->x * c;
@ -404,17 +388,17 @@ static int GetQuadCollisionAnim(ITEM_INFO* quad, PHD_VECTOR* p)
return 0; return 0;
} }
static int TestQuadHeight(ITEM_INFO* quad, int dz, int dx, PHD_VECTOR* pos) static int TestQuadHeight(ITEM_INFO* item, int dz, int dx, PHD_VECTOR* pos)
{ {
pos->y = quad->pos.yPos - dz * phd_sin(quad->pos.xRot) + dx * phd_sin(quad->pos.zRot); pos->y = item->pos.yPos - dz * phd_sin(item->pos.xRot) + dx * phd_sin(item->pos.zRot);
float c = phd_cos(quad->pos.yRot); float c = phd_cos(item->pos.yRot);
float s = phd_sin(quad->pos.yRot); float s = phd_sin(item->pos.yRot);
pos->z = quad->pos.zPos + dz * c - dx * s; pos->z = item->pos.zPos + dz * c - dx * s;
pos->x = quad->pos.xPos + dz * s + dx * c; pos->x = item->pos.xPos + dz * s + dx * c;
auto probe = GetCollisionResult(pos->x, pos->y, pos->z, quad->roomNumber); auto probe = GetCollisionResult(pos->x, pos->y, pos->z, item->roomNumber);
if (probe.Position.Ceiling > pos->y || if (probe.Position.Ceiling > pos->y ||
probe.Position.Ceiling == NO_HEIGHT) probe.Position.Ceiling == NO_HEIGHT)
{ {
@ -557,7 +541,7 @@ static int DoQuadDynamics(int height, int fallspeed, int *y)
static int QuadDynamics(ITEM_INFO* lara, ITEM_INFO* quad) static int QuadDynamics(ITEM_INFO* lara, ITEM_INFO* quad)
{ {
LaraInfo*& laraInfo = lara->data; LaraInfo*& laraInfo = lara->data;
auto quadInfo = (QUAD_INFO*)quad->data; QUAD_INFO* quadInfo = (QUAD_INFO*)quad->data;
COLL_RESULT probe; COLL_RESULT probe;
PHD_VECTOR moved, fl, fr, br, bl, mtl, mbl, mtr, mbr, mml, mmr; PHD_VECTOR moved, fl, fr, br, bl, mtl, mbl, mtr, mbr, mml, mmr;
@ -779,12 +763,12 @@ static int QuadDynamics(ITEM_INFO* lara, ITEM_INFO* quad)
static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int dead) static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int dead)
{ {
auto quadInfo = (QUAD_INFO*)quad->data; QUAD_INFO* quadInfo = (QUAD_INFO *)quad->data;
if (quad->pos.yPos != quad->floor && if (quad->pos.yPos != quad->floor &&
lara->currentAnimState != QUAD_STATE_FALL && lara->currentAnimState != QUAD_STATE_FALL &&
lara->currentAnimState != QUAD_STATE_LAND && lara->currentAnimState != QUAD_STATE_LAND &&
lara->currentAnimState != QUAD_STATE_FALL_OFF && lara->currentAnimState != QUAD_STATE_FALLOFF &&
!dead) !dead)
{ {
if (quadInfo->velocity < 0) if (quadInfo->velocity < 0)
@ -797,37 +781,37 @@ static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int d
lara->goalAnimState = QUAD_STATE_FALL; lara->goalAnimState = QUAD_STATE_FALL;
} }
else if (collide && else if (collide &&
lara->currentAnimState != QUAD_STATE_HIT_FRONT && lara->currentAnimState != QUAD_STATE_HITFRONT &&
lara->currentAnimState != QUAD_STATE_HIT_BACK && lara->currentAnimState != QUAD_STATE_HITBACK &&
lara->currentAnimState != QUAD_STATE_HIT_LEFT && lara->currentAnimState != QUAD_STATE_HITLEFT &&
lara->currentAnimState != QUAD_STATE_HIT_RIGHT && lara->currentAnimState != QUAD_STATE_HITRIGHT &&
lara->currentAnimState != QUAD_STATE_FALL_OFF && lara->currentAnimState != QUAD_STATE_FALLOFF &&
quadInfo->velocity > (MAX_VELOCITY / 3) && quadInfo->velocity > (MAX_VELOCITY / 3) &&
!dead) !dead)
{ {
if (collide == QUAD_HIT_FRONT) if (collide == QUAD_HIT_FRONT)
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITF_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITF_A;
lara->currentAnimState = QUAD_STATE_HIT_FRONT; lara->currentAnimState = QUAD_STATE_HITFRONT;
lara->goalAnimState = QUAD_STATE_HIT_FRONT; lara->goalAnimState = QUAD_STATE_HITFRONT;
} }
else if (collide == QUAD_HIT_BACK) else if (collide == QUAD_HIT_BACK)
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITB_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITB_A;
lara->currentAnimState = QUAD_STATE_HIT_BACK; lara->currentAnimState = QUAD_STATE_HITBACK;
lara->goalAnimState = QUAD_STATE_HIT_BACK; lara->goalAnimState = QUAD_STATE_HITBACK;
} }
else if (collide == QUAD_HIT_LEFT) else if (collide == QUAD_HIT_LEFT)
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITL_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITL_A;
lara->currentAnimState = QUAD_STATE_HIT_LEFT; lara->currentAnimState = QUAD_STATE_HITLEFT;
lara->goalAnimState = QUAD_STATE_HIT_LEFT; lara->goalAnimState = QUAD_STATE_HITLEFT;
} }
else else
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITR_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + Q_HITR_A;
lara->currentAnimState = QUAD_STATE_HIT_RIGHT; lara->currentAnimState = QUAD_STATE_HITRIGHT;
lara->goalAnimState = QUAD_STATE_HIT_RIGHT; lara->goalAnimState = QUAD_STATE_HITRIGHT;
} }
lara->frameNumber = GetFrameNumber(lara, lara->animNumber); lara->frameNumber = GetFrameNumber(lara, lara->animNumber);
@ -837,17 +821,17 @@ static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int d
{ {
switch (lara->currentAnimState) switch (lara->currentAnimState)
{ {
case QUAD_STATE_IDLE: case QUAD_STATE_STOP:
if (dead) if (dead)
lara->goalAnimState = QUAD_STATE_BIKE_DEATH; lara->goalAnimState = QUAD_STATE_BIKEDEATH;
else if (TrInput & QUAD_IN_UNMOUNT && else if (TrInput & QUAD_IN_UNMOUNT &&
quadInfo->velocity == 0 && quadInfo->velocity == 0 &&
!QuadNoGetOff) !QuadNoGetOff)
{ {
if (TrInput & QUAD_IN_LEFT && CanQuadbikeGetOff(-1)) if (TrInput & QUAD_IN_LEFT && CanQuadbikeGetOff(-1))
lara->goalAnimState = QUAD_STATE_GET_OFF_LEFT; lara->goalAnimState = QUAD_STATE_GETOFFL;
else if (TrInput & QUAD_IN_RIGHT && CanQuadbikeGetOff(1)) else if (TrInput & QUAD_IN_RIGHT && CanQuadbikeGetOff(1))
lara->goalAnimState = QUAD_STATE_GET_OFF_RIGHT; lara->goalAnimState = QUAD_STATE_GETOFFR;
} }
else if (TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE)) else if (TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE))
lara->goalAnimState = QUAD_STATE_DRIVE; lara->goalAnimState = QUAD_STATE_DRIVE;
@ -858,24 +842,24 @@ static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int d
if (dead) if (dead)
{ {
if (quadInfo->velocity > (MAX_VELOCITY / 2)) if (quadInfo->velocity > (MAX_VELOCITY / 2))
lara->goalAnimState = QUAD_STATE_FALL_DEATH; lara->goalAnimState = QUAD_STATE_FALLDEATH;
else else
lara->goalAnimState = QUAD_STATE_BIKE_DEATH; lara->goalAnimState = QUAD_STATE_BIKEDEATH;
} }
else if (!(TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE)) && else if (!(TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE)) &&
(quadInfo->velocity / 256) == 0) (quadInfo->velocity / 256) == 0)
{ {
lara->goalAnimState = QUAD_STATE_IDLE; lara->goalAnimState = QUAD_STATE_STOP;
} }
else if (TrInput & QUAD_IN_LEFT && else if (TrInput & QUAD_IN_LEFT &&
!QuadDriftStarting) !QuadHandbrakeStarting)
{ {
lara->goalAnimState = QUAD_STATE_TURN_LEFT; lara->goalAnimState = QUAD_STATE_TURNL;
} }
else if (TrInput & QUAD_IN_RIGHT && else if (TrInput & QUAD_IN_RIGHT &&
!QuadDriftStarting) !QuadHandbrakeStarting)
{ {
lara->goalAnimState = QUAD_STATE_TURN_RIGHT; lara->goalAnimState = QUAD_STATE_TURNR;
} }
else if (TrInput & QUAD_IN_BRAKE) else if (TrInput & QUAD_IN_BRAKE)
{ {
@ -889,40 +873,40 @@ static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int d
case QUAD_STATE_BRAKE: case QUAD_STATE_BRAKE:
case QUAD_STATE_SLOW: case QUAD_STATE_SLOW:
case QUAD_STATE_IDLE_SLOWLY: case QUAD_STATE_STOPSLOWLY:
if ((quadInfo->velocity / 256) == 0) if ((quadInfo->velocity / 256) == 0)
lara->goalAnimState = QUAD_STATE_IDLE; lara->goalAnimState = QUAD_STATE_STOP;
else if (TrInput & QUAD_IN_LEFT) else if (TrInput & QUAD_IN_LEFT)
lara->goalAnimState = QUAD_STATE_TURN_LEFT; lara->goalAnimState = QUAD_STATE_TURNL;
else if (TrInput & QUAD_IN_RIGHT) else if (TrInput & QUAD_IN_RIGHT)
lara->goalAnimState = QUAD_STATE_TURN_RIGHT; lara->goalAnimState = QUAD_STATE_TURNR;
break; break;
case QUAD_STATE_TURN_LEFT: case QUAD_STATE_TURNL:
if ((quadInfo->velocity / 256) == 0) if ((quadInfo->velocity / 256) == 0)
lara->goalAnimState = QUAD_STATE_IDLE; lara->goalAnimState = QUAD_STATE_STOP;
else if (TrInput & QUAD_IN_RIGHT) else if (TrInput & QUAD_IN_RIGHT)
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_TURNR_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_TURNR_A;
lara->frameNumber = GetFrameNumber(lara, lara->animNumber); lara->frameNumber = GetFrameNumber(lara, lara->animNumber);
lara->currentAnimState = QUAD_STATE_TURN_RIGHT; lara->currentAnimState = QUAD_STATE_TURNR;
lara->goalAnimState = QUAD_STATE_TURN_RIGHT; lara->goalAnimState = QUAD_STATE_TURNR;
} }
else if (!(TrInput & QUAD_IN_LEFT)) else if (!(TrInput & QUAD_IN_LEFT))
lara->goalAnimState = QUAD_STATE_DRIVE; lara->goalAnimState = QUAD_STATE_DRIVE;
break; break;
case QUAD_STATE_TURN_RIGHT: case QUAD_STATE_TURNR:
if ((quadInfo->velocity / 256) == 0) if ((quadInfo->velocity / 256) == 0)
lara->goalAnimState = QUAD_STATE_IDLE; lara->goalAnimState = QUAD_STATE_STOP;
else if (TrInput & QUAD_IN_LEFT) else if (TrInput & QUAD_IN_LEFT)
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_TURNL_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_TURNL_A;
lara->frameNumber = GetFrameNumber(lara, lara->animNumber); lara->frameNumber = GetFrameNumber(lara, lara->animNumber);
lara->currentAnimState = QUAD_STATE_TURN_LEFT; lara->currentAnimState = QUAD_STATE_TURNL;
lara->goalAnimState = QUAD_STATE_TURN_LEFT; lara->goalAnimState = QUAD_STATE_TURNL;
} }
else if (!(TrInput & QUAD_IN_RIGHT)) else if (!(TrInput & QUAD_IN_RIGHT))
lara->goalAnimState = QUAD_STATE_DRIVE; lara->goalAnimState = QUAD_STATE_DRIVE;
@ -937,13 +921,13 @@ static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int d
break; break;
case QUAD_STATE_FALL_OFF: case QUAD_STATE_FALLOFF:
break; break;
case QUAD_STATE_HIT_FRONT: case QUAD_STATE_HITFRONT:
case QUAD_STATE_HIT_BACK: case QUAD_STATE_HITBACK:
case QUAD_STATE_HIT_LEFT: case QUAD_STATE_HITLEFT:
case QUAD_STATE_HIT_RIGHT: case QUAD_STATE_HITRIGHT:
if (TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE)) if (TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE))
lara->goalAnimState = QUAD_STATE_DRIVE; lara->goalAnimState = QUAD_STATE_DRIVE;
@ -952,212 +936,227 @@ static void AnimateQuadBike(ITEM_INFO* lara, ITEM_INFO* quad, int collide, int d
if (g_Level.Rooms[quad->roomNumber].flags & (ENV_FLAG_WATER | ENV_FLAG_SWAMP)) if (g_Level.Rooms[quad->roomNumber].flags & (ENV_FLAG_WATER | ENV_FLAG_SWAMP))
{ {
lara->goalAnimState = QUAD_STATE_FALL_OFF; lara->goalAnimState = QUAD_STATE_FALLOFF;
lara->pos.yPos = quad->pos.yPos + 700; lara->pos.yPos = quad->pos.yPos + 700;
lara->roomNumber = quad->roomNumber; lara->roomNumber = quad->roomNumber;
lara->hitPoints = 0; lara->hitPoints = 0;
QuadbikeExplode(lara, quad); QuadbikeExplode(quad);
} }
} }
} }
static int QuadUserControl(ITEM_INFO* quad, int height, int* pitch) static int QuadUserControl(ITEM_INFO* item, int height, int* pitch)
{ {
auto quadInfo = (QUAD_INFO*)quad->data; bool drive = false;
bool drive = false; // Never changes? int revs = 0;
QUAD_INFO* quad = (QUAD_INFO *)item->data;
if (!(TrInput & QUAD_IN_DRIFT) && if (!(TrInput & QUAD_IN_DRIFT) &&
!quadInfo->velocity && !quad->velocity &&
!QuadCanDriftStart) !QuadCanHandbrakeStart)
{ {
QuadCanDriftStart = true; QuadCanHandbrakeStart = true;
} }
else if (quadInfo->velocity) else if (quad->velocity)
QuadCanDriftStart = false; QuadCanHandbrakeStart = false;
if (!(TrInput & QUAD_IN_DRIFT)) if (!(TrInput & QUAD_IN_DRIFT))
QuadDriftStarting = false; QuadHandbrakeStarting = false;
if (!QuadDriftStarting) if (!QuadHandbrakeStarting)
{ {
if (quadInfo->revs > 0x10) if (quad->revs > 0x10)
{ {
quadInfo->velocity += (quadInfo->revs / 16); quad->velocity += (quad->revs / 16);
quadInfo->revs -= (quadInfo->revs / 8); quad->revs -= (quad->revs / 8);
} }
else else
quadInfo->revs = 0; quad->revs = 0;
} }
if (quad->pos.yPos >= (height - STEP_SIZE)) if (item->pos.yPos >= (height - STEP_SIZE))
{ {
if (TrInput & IN_LOOK && if (TrInput & IN_LOOK &&
!quadInfo->velocity) !quad->velocity)
{ {
LookUpDown(); LookUpDown();
} }
// Driving forward. if (quad->velocity > 0)
if (quadInfo->velocity > 0)
{ {
if (TrInput & QUAD_IN_DRIFT && if (TrInput & QUAD_IN_DRIFT &&
!QuadDriftStarting && !QuadHandbrakeStarting &&
quadInfo->velocity > MIN_DRIFT_SPEED) quad->velocity > MIN_HANDBRAKE_SPEED)
{ {
if (TrInput & QUAD_IN_LEFT) if (TrInput & QUAD_IN_LEFT)
{ {
quadInfo->turnRate -= QUAD_DRIFT_TURN_RATE; quad->turnRate -= QUAD_HTURN;
if (quadInfo->turnRate < -QUAD_DRIFT_TURN_MAX) if (quad->turnRate < -QUAD_MAX_HTURN)
quadInfo->turnRate = -QUAD_DRIFT_TURN_MAX; quad->turnRate = -QUAD_MAX_HTURN;
} }
else if (TrInput & QUAD_IN_RIGHT) else if (TrInput & QUAD_IN_RIGHT)
{ {
quadInfo->turnRate += QUAD_DRIFT_TURN_RATE; quad->turnRate += QUAD_HTURN;
if (quadInfo->turnRate > QUAD_DRIFT_TURN_MAX) if (quad->turnRate > QUAD_MAX_HTURN)
quadInfo->turnRate = QUAD_DRIFT_TURN_MAX; quad->turnRate = QUAD_MAX_HTURN;
} }
} }
else else
{ {
if (TrInput & QUAD_IN_LEFT) if (TrInput & QUAD_IN_LEFT)
{ {
quadInfo->turnRate -= QUAD_TURN_RATE; quad->turnRate -= QUAD_TURN;
if (quadInfo->turnRate < -QUAD_TURN_MAX) if (quad->turnRate < -QUAD_MAX_TURN)
quadInfo->turnRate = -QUAD_TURN_MAX; quad->turnRate = -QUAD_MAX_TURN;
} }
else if (TrInput & QUAD_IN_RIGHT) else if (TrInput & QUAD_IN_RIGHT)
{ {
quadInfo->turnRate += QUAD_TURN_RATE; quad->turnRate += QUAD_TURN;
if (quadInfo->turnRate > QUAD_TURN_MAX) if (quad->turnRate > QUAD_MAX_TURN)
quadInfo->turnRate = QUAD_TURN_MAX; quad->turnRate = QUAD_MAX_TURN;
} }
} }
} }
// Driving back. else if (quad->velocity < 0)
else if (quadInfo->velocity < 0)
{ {
if (TrInput & QUAD_IN_DRIFT && if (TrInput & QUAD_IN_DRIFT &&
!QuadDriftStarting && !QuadHandbrakeStarting &&
quadInfo->velocity < (-MIN_DRIFT_SPEED + 0x800)) quad->velocity < (-MIN_HANDBRAKE_SPEED + 0x800))
{ {
if (TrInput & QUAD_IN_RIGHT) if (TrInput & QUAD_IN_RIGHT)
{ {
quadInfo->turnRate -= QUAD_DRIFT_TURN_RATE; quad->turnRate -= QUAD_HTURN;
if (quadInfo->turnRate < -QUAD_DRIFT_TURN_MAX) if (quad->turnRate < -QUAD_MAX_HTURN)
quadInfo->turnRate = -QUAD_DRIFT_TURN_MAX; quad->turnRate = -QUAD_MAX_HTURN;
} }
else if (TrInput & QUAD_IN_LEFT) else if (TrInput & IN_LEFT)
{ {
quadInfo->turnRate += QUAD_DRIFT_TURN_RATE; quad->turnRate += QUAD_HTURN;
if (quadInfo->turnRate > QUAD_DRIFT_TURN_MAX) if (quad->turnRate > QUAD_MAX_HTURN)
quadInfo->turnRate = QUAD_DRIFT_TURN_MAX; quad->turnRate = QUAD_MAX_HTURN;
} }
} }
else else
{ {
if (TrInput & QUAD_IN_LEFT) if (TrInput & QUAD_IN_RIGHT)
{ {
quadInfo->turnRate -= QUAD_TURN_RATE; quad->turnRate -= QUAD_TURN;
if (quadInfo->turnRate < -QUAD_TURN_MAX) if (quad->turnRate < -QUAD_MAX_TURN)
quadInfo->turnRate = -QUAD_TURN_MAX; quad->turnRate = -QUAD_MAX_TURN;
} }
else if (TrInput & QUAD_IN_RIGHT) else if (TrInput & QUAD_IN_LEFT)
{ {
quadInfo->turnRate += QUAD_TURN_RATE; quad->turnRate += QUAD_TURN;
if (quadInfo->turnRate > QUAD_TURN_MAX) if (quad->turnRate > QUAD_MAX_TURN)
quadInfo->turnRate = QUAD_TURN_MAX; quad->turnRate = QUAD_MAX_TURN;
} }
} }
} }
// Driving back / braking.
if (TrInput & QUAD_IN_BRAKE) if (TrInput & QUAD_IN_BRAKE)
{ {
if (TrInput & QUAD_IN_DRIFT && if (TrInput & QUAD_IN_DRIFT &&
(QuadCanDriftStart || QuadDriftStarting)) (QuadCanHandbrakeStart || QuadHandbrakeStarting))
{ {
QuadDriftStarting = true; QuadHandbrakeStarting = true;
quadInfo->revs -= 0x200; quad->revs -= 0x200;
if (quadInfo->revs < MAX_BACK) if (quad->revs < MAX_BACK)
quadInfo->revs = MAX_BACK; quad->revs = MAX_BACK;
} }
else if (quadInfo->velocity > 0) else if (quad->velocity > 0)
quadInfo->velocity -= BRAKE; quad->velocity -= BRAKE;
else else
{ {
if (quadInfo->velocity > MAX_BACK) if (quad->velocity > MAX_BACK)
quadInfo->velocity += REVERSE_ACC; quad->velocity += REVERSE_ACC;
} }
} }
else if (TrInput & QUAD_IN_ACCELERATE) else if (TrInput & QUAD_IN_ACCELERATE)
{ {
if (TrInput & QUAD_IN_DRIFT && if (TrInput & QUAD_IN_DRIFT &&
(QuadCanDriftStart || QuadDriftStarting)) (QuadCanHandbrakeStart || QuadHandbrakeStarting))
{ {
QuadDriftStarting = true; QuadHandbrakeStarting = true;
quadInfo->revs += 0x200; quad->revs += 0x200;
if (quadInfo->revs >= MAX_VELOCITY) if (quad->revs >= MAX_VELOCITY)
quadInfo->revs = MAX_VELOCITY; quad->revs = MAX_VELOCITY;
} }
else if (quadInfo->velocity < MAX_VELOCITY) else if (quad->velocity < MAX_VELOCITY)
{ {
if (quadInfo->velocity < 0x4000) if (quad->velocity < 0x4000)
quadInfo->velocity += (8 + (0x4000 + 0x800 - quadInfo->velocity) / 8); quad->velocity += (8 + (0x4000 + 0x800 - quad->velocity) / 8);
else if (quadInfo->velocity < 0x7000) else if (quad->velocity < 0x7000)
quadInfo->velocity += (4 + (0x7000 + 0x800 - quadInfo->velocity) / 16); quad->velocity += (4 + (0x7000 + 0x800 - quad->velocity) / 16);
else if (quadInfo->velocity < MAX_VELOCITY) else if (quad->velocity < MAX_VELOCITY)
quadInfo->velocity += (2 + (MAX_VELOCITY - quadInfo->velocity) / 8); quad->velocity += (2 + (MAX_VELOCITY - quad->velocity) / 8);
} }
else else
quadInfo->velocity = MAX_VELOCITY; quad->velocity = MAX_VELOCITY;
quadInfo->velocity -= abs(quad->pos.yRot - quadInfo->momentumAngle) / 64; quad->velocity -= abs(item->pos.yRot - quad->momentumAngle) / 64;
} }
else if (quadInfo->velocity > 0x0100) else if (quad->velocity > 0x0100)
quadInfo->velocity -= 0x0100; quad->velocity -= 0x0100;
else if (quadInfo->velocity < -0x0100) else if (quad->velocity < -0x0100)
quadInfo->velocity += 0x0100; quad->velocity += 0x0100;
else else
quadInfo->velocity = 0; quad->velocity = 0;
if (!(TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE)) && if (!(TrInput & (QUAD_IN_ACCELERATE | QUAD_IN_BRAKE)) &&
QuadDriftStarting && QuadHandbrakeStarting &&
quadInfo->revs) quad->revs)
{ {
if (quadInfo->revs > 0x8) if (quad->revs > 0x8)
quadInfo->revs -= quadInfo->revs / 8; quad->revs -= quad->revs / 8;
else else
quadInfo->revs = 0; quad->revs = 0;
} }
quad->speed = quadInfo->velocity / 256; item->speed = quad->velocity / 256;
if (quadInfo->engineRevs > 0x7000) if (quad->engineRevs > 0x7000)
quadInfo->engineRevs = -0x2000; quad->engineRevs = -0x2000;
int revs = 0; if (quad->velocity < 0)
if (quadInfo->velocity < 0) revs = abs(quad->velocity / 2);
revs = abs(quadInfo->velocity / 2); else if (quad->velocity < 0x7000)
else if (quadInfo->velocity < 0x7000) revs = -0x2000 + (quad->velocity * (0x6800 - -0x2000)) / 0x7000;
revs = -0x2000 + (quadInfo->velocity * (0x6800 - -0x2000)) / 0x7000; else if (quad->velocity <= MAX_VELOCITY)
else if (quadInfo->velocity <= MAX_VELOCITY) revs = -0x2800 + ((quad->velocity - 0x7000) * (0x7000 - -0x2800)) / (MAX_VELOCITY - 0x7000);
revs = -0x2800 + ((quadInfo->velocity - 0x7000) * (0x7000 - -0x2800)) / (MAX_VELOCITY - 0x7000);
revs += abs(quadInfo->revs); revs += abs(quad->revs);
quadInfo->engineRevs += (revs - quadInfo->engineRevs) / 8; quad->engineRevs += (revs - quad->engineRevs) / 8;
} }
else else
{ {
if (quadInfo->engineRevs < 0xA000) if (quad->engineRevs < 0xA000)
quadInfo->engineRevs += (0xA000 - quadInfo->engineRevs) / 8; quad->engineRevs += (0xA000 - quad->engineRevs) / 8;
} }
*pitch = quadInfo->engineRevs; *pitch = quad->engineRevs;
return drive; return drive;
} }
void InitialiseQuadBike(short itemNumber)
{
ITEM_INFO* item = &g_Level.Items[itemNumber];
item->data = QUAD_INFO();
QUAD_INFO* info = item->data;
info->velocity = 0;
info->turnRate = 0;
info->leftFallspeed = 0;
info->rightFallspeed = 0;
info->momentumAngle = item->pos.yRot;
info->extraRotation = 0;
info->trackMesh = 0;
info->pitch = 0;
info->flags = 0;
}
void QuadBikeCollision(short itemNumber, ITEM_INFO* lara, COLL_INFO* coll) void QuadBikeCollision(short itemNumber, ITEM_INFO* lara, COLL_INFO* coll)
{ {
LaraInfo*& laraInfo = lara->data; LaraInfo*& laraInfo = lara->data;
@ -1189,12 +1188,12 @@ void QuadBikeCollision(short itemNumber, ITEM_INFO* lara, COLL_INFO* coll)
if (ang > -ANGLE(45.0f) && ang < ANGLE(135.0f)) if (ang > -ANGLE(45.0f) && ang < ANGLE(135.0f))
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_GETONL_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_GETONL_A;
lara->currentAnimState = lara->goalAnimState = QUAD_STATE_GET_ON_LEFT; lara->currentAnimState = lara->goalAnimState = QUAD_STATE_GETONL;
} }
else else
{ {
lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_GETONR_A; lara->animNumber = Objects[ID_QUAD_LARA_ANIMS].animIndex + QUADBIKE_GETONR_A;
lara->currentAnimState = lara->goalAnimState = QUAD_STATE_GET_ON_RIGHT; lara->currentAnimState = lara->goalAnimState = QUAD_STATE_GETONR;
} }
lara->frameNumber = g_Level.Anims[lara->animNumber].frameBase; lara->frameNumber = g_Level.Anims[lara->animNumber].frameBase;
@ -1280,7 +1279,7 @@ int QuadBikeControl(void)
ITEM_INFO* lara = LaraItem; ITEM_INFO* lara = LaraItem;
LaraInfo*& laraInfo = LaraItem->data; LaraInfo*& laraInfo = LaraItem->data;
ITEM_INFO* quad = &g_Level.Items[laraInfo->Vehicle]; ITEM_INFO* quad = &g_Level.Items[laraInfo->Vehicle];
auto quadInfo = (QUAD_INFO*)quad->data; QUAD_INFO* quadInfo = (QUAD_INFO*)quad->data;
short xRot, zRot, rotadd; short xRot, zRot, rotadd;
int pitch, dead = 0; int pitch, dead = 0;
@ -1319,10 +1318,10 @@ int QuadBikeControl(void)
{ {
switch (lara->currentAnimState) switch (lara->currentAnimState)
{ {
case QUAD_STATE_GET_ON_LEFT: case QUAD_STATE_GETONL:
case QUAD_STATE_GET_ON_RIGHT: case QUAD_STATE_GETONR:
case QUAD_STATE_GET_OFF_LEFT: case QUAD_STATE_GETOFFL:
case QUAD_STATE_GET_OFF_RIGHT: case QUAD_STATE_GETOFFR:
drive = -1; drive = -1;
collide = false; collide = false;
@ -1402,17 +1401,17 @@ int QuadBikeControl(void)
ExplodingDeath(laraInfo->itemNumber, 0xffffffff, 1); ExplodingDeath(laraInfo->itemNumber, 0xffffffff, 1);
lara->hitPoints = 0; lara->hitPoints = 0;
lara->flags |= ONESHOT; lara->flags |= ONESHOT;
QuadbikeExplode(lara, quad); QuadbikeExplode(quad);
return 0; return 0;
} }
} }
} }
if (lara->currentAnimState != QUAD_STATE_GET_ON_RIGHT && if (lara->currentAnimState != QUAD_STATE_GETONR &&
lara->currentAnimState != QUAD_STATE_GET_ON_LEFT && lara->currentAnimState != QUAD_STATE_GETONL &&
lara->currentAnimState != QUAD_STATE_GET_OFF_RIGHT && lara->currentAnimState != QUAD_STATE_GETOFFR &&
lara->currentAnimState != QUAD_STATE_GET_OFF_LEFT) lara->currentAnimState != QUAD_STATE_GETOFFL)
{ {
PHD_VECTOR pos; PHD_VECTOR pos;
int speed = 0; int speed = 0;
@ -1440,7 +1439,7 @@ int QuadBikeControl(void)
speed = ((QuadSmokeStart * 2) + (GetRandomControl() & 7) + (GetRandomControl() & 16)) * 128; speed = ((QuadSmokeStart * 2) + (GetRandomControl() & 7) + (GetRandomControl() & 16)) * 128;
QuadSmokeStart++; QuadSmokeStart++;
} }
else if (QuadDriftStarting) else if (QuadHandbrakeStarting)
speed = (abs(quadInfo->revs) * 2) + ((GetRandomControl() & 7) * 128); speed = (abs(quadInfo->revs) * 2) + ((GetRandomControl() & 7) * 128);
else if ((GetRandomControl() & 3) == 0) else if ((GetRandomControl() & 3) == 0)
speed = ((GetRandomControl() & 15) + (GetRandomControl() & 16)) * 128; speed = ((GetRandomControl() & 15) + (GetRandomControl() & 16)) * 128;
@ -1454,5 +1453,5 @@ int QuadBikeControl(void)
else else
QuadSmokeStart = 0; QuadSmokeStart = 0;
return QuadCheckGetOff(lara, quad); return QuadCheckGetOff(quad, lara);
} }

2
TR5Main/Objects/TR3/Vehicles/quad_info.h
View file

@ -1,5 +1,7 @@
#pragma once #pragma once
struct QUAD_INFO { struct QUAD_INFO {
int velocity; int velocity;
short frontRot; short frontRot;