Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-05-02 17:57:59 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions
TombEngine/TR5Main/Objects/TR3/Vehicles/minecart.cpp

940 lines
27 KiB
C++
Raw Blame History

#include "framework.h"
#include "Objects/TR3/Vehicles/minecart.h"
#include "Game/animation.h"
#include "Game/camera.h"
#include "Game/collision/sphere.h"
#include "Game/collision/collide_item.h"
#include "Game/effects/effects.h"
#include "Game/items.h"
#include "Game/Lara/lara.h"
#include "Game/Lara/lara_flare.h"
#include "Game/Lara/lara_helpers.h"
#include "Objects/TR3/Vehicles/minecart_info.h"
#include "Sound/sound.h"
#include "Specific/input.h"
#include "Specific/level.h"
#include "Specific/setup.h"
using std::vector;
#define DISMOUNT_DISTANCE 330
#define CART_DEC -1536
#define CART_MIN_SPEED 2560
#define CART_MIN_VEL 32
#define TURN_DEATH_VEL 128
#define CART_FORWARD_GRADIENT -128
#define CART_BACK_GRADIENT 128
#define CART_JUMP_VELOCITY 64512
#define CART_GRAVITY (SECTOR(1) + 1)
#define CART_MAX_VERTICAL_VELOCITY 16128
#define TERMINAL_ANGLE SECTOR(4)
#define CART_RADIUS 100
#define CART_HEIGHT CLICK(3)
#define CART_NHITS 25
#define CART_ENTITY_RADIUS CLICK(1)
#define CART_IN_SWIPE IN_ACTION
#define CART_IN_DUCK IN_CROUCH
#define CART_IN_DISMOUNT IN_ROLL
#define CART_IN_BRAKE (IN_BACK | IN_JUMP)
#define CART_IN_LEFT IN_LEFT
#define CART_IN_RIGHT IN_RIGHT
enum MinecartState
{
CART_STATE_MOUNT,
CART_STATE_DISMOUNT,
CART_STATE_DISMOUNT_LEFT,
CART_STATE_DISMOUNT_RIGHT,
CART_STATE_IDLE,
CART_STATE_DUCK,
CART_STATE_MOVE,
CART_STATE_RIGHT,
CART_STATE_HARD_LEFT, // Unused.
CART_STATE_LEFT,
CART_STATE_HARD_RIGHT, // Unused.
CART_STATE_BRAKE,
CART_STATE_FORWARD,
CART_STATE_BACK,
CART_TURN_DEATH,
CART_FALL_DEATH,
CART_WALL_DEATH,
CART_STATE_HIT,
CART_STATE_SWIPE,
CART_STATE_BRAKING
};
enum MinecartAnim
{
CART_ANIM_MOUNT_LEFT = 0,
CART_ANIM_DISMOUNT_LEFT = 1,
CART_ANIM_DUCK_START = 2,
CART_ANIM_DUCK_CONTINUE = 3,
CART_ANIM_DUCK_END = 4,
CART_ANIM_PICK_UP_WRENCH = 5,
CART_ANIM_SWIPE_WRENCH = 6,
CART_ANIM_PUT_DOWN_WRENCH = 7,
CART_ANIM_LEAN_LEFT_START = 8,
CART_ANIM_LEAN_RIGHT_CONTINUE = 9,
CART_ANIM_BRAKE_DISENGAGE = 10, // Unused?
CART_ANIM_BRAKE_ENGAGE = 11, // Unused?
CART_ANIM_LEAN_RIGHT_START = 12,
CART_ANIM_LEAN_LEFT_CONTINUE = 13,
CART_ANIM_LEAN_RIGHT_BRAKE_ENGAGE = 14,
CART_ANIM_LEAN_LEFT_BRAKE_ENGAGE = 15,
CART_ANIM_LEAN_RIGHT_HARD_CONTINUE = 16, // Unused?
CART_ANIM_LEAN_LEFT_HARD_CONTINUE = 17, // Unused?
CART_ANIM_LEAN_RIGHT_HARD_START = 18, // Unused?
CART_ANIM_LEAN_RIGHT_HARD_END = 19, // Unused?
CART_ANIM_LEAN_LEFT_HARD_START = 20, // Unused?
CART_ANIM_LEAN_LEFT_HARD_END = 21, // Unused?
CART_ANIM_RIDE_FORWARD = 22,
CART_ANIM_WALL_DEATH = 23,
CART_ANIM_LEAN_FORWARD_START = 24,
CART_ANIM_LEAN_FORWARD_CONTINUE = 25,
CART_ANIM_LEAN_FORWARD_END = 26,
CART_ANIM_LEAN_BACK_START = 27,
CART_ANIM_LEAN_BACK_CONTINUE = 28,
CART_ANIM_LEAN_BACK_END = 29,
CART_ANIM_FALL_DEATH = 30, // Unused?
CART_ANIM_TURN_DEATH = 31, // Unused?
CART_ANIM_FALL_OUT_START = 32,
CART_ANIM_FALL_OUT_END = 33,
CART_ANIM_BONK_HEAD = 34,
CART_ANIM_LEAN_FORWARD_DUCK_START = 35,
CART_ANIM_LEAN_FORWARD_DUCK_CONTINUE = 36,
CART_ANIM_LEAN_FORWARD_DUCK_END = 37,
CART_ANIM_LEAN_BACK_DUCK_START = 38,
CART_ANIM_LEAN_BACK_DUCK_CONTINUE = 39,
CART_ANIM_LEAN_BACK_DUCK_END = 40,
CART_ANIM_LEAN_RIGHT_BRAKE_DISENGAGE = 41, // Unused?
CART_ANIM_LEAN_LEFT_BRAKE_DISENGAGE = 42, // Unused?
CART_ANIM_LEAN_RIGHT_END = 43,
CART_ANIM_LEAN_LEFT_END = 44,
CART_ANIM_IDLE = 45,
CART_ANIM_MOUNT_RIGHT = 46,
CART_ANIM_DISMOUNT_RIGHT = 47,
CART_ANIM_BRAKE = 48,
};
enum MinecartFlags
{
CART_FLAG_MESH = 1,
CART_FLAG_TURNING_LEFT = 2,
CART_FLAG_TURNING_RIGHT = 4,
CART_FLAG_RDIR = 8, // TODO
CART_FLAG_CONTROL = 16,
CART_FLAG_STOPPED = 32,
CART_FLAG_NO_ANIM = 64,
CART_FLAG_DEAD = 128
};
void InitialiseMineCart(short itemNumber)
{
auto* minecartItem = &g_Level.Items[itemNumber];
minecartItem->Data = MinecartInfo();
auto* minecart = (MinecartInfo*)minecartItem->Data;
minecart->Velocity = 0;
minecart->VerticalVelocity = 0;
minecart->Gradient = 0;
minecart->Flags = NULL;
}
static int TestMinecartHeight(ITEM_INFO* minecartItem, int xOffset, int zOffset)
{
float s = phd_sin(minecartItem->Position.yRot);
float c = phd_cos(minecartItem->Position.yRot);
PHD_VECTOR pos;
pos.x = minecartItem->Position.xPos + zOffset * s + xOffset * c;
pos.y = minecartItem->Position.yPos - zOffset * phd_sin(minecartItem->Position.xRot) + xOffset * phd_sin(minecartItem->Position.zRot);
pos.z = minecartItem->Position.zPos + zOffset * c - xOffset * s;
return GetCollisionResult(pos.x, pos.y, pos.z, minecartItem->RoomNumber).Position.Floor;
}
static short GetMinecartCollision(ITEM_INFO* minecartItem, short angle, int distance)
{
auto probe = GetCollisionResult(minecartItem, angle, distance, -LARA_HEIGHT);
if (probe.Position.Floor != NO_HEIGHT)
probe.Position.Floor -= minecartItem->Position.yPos;
return (short)probe.Position.Floor;
}
static bool GetInMineCart(ITEM_INFO* minecartItem, ITEM_INFO* laraItem, COLL_INFO* coll)
{
auto* lara = GetLaraInfo(laraItem);
if (!(TrInput & CART_IN_SWIPE) || lara->Control.HandStatus != HandStatus::Free ||
laraItem->Airborne)
{
return false;
}
if (!TestBoundsCollide(minecartItem, laraItem, coll->Setup.Radius))
return false;
if (!TestCollision(minecartItem, laraItem))
return false;
int x = laraItem->Position.xPos - minecartItem->Position.xPos;
int z = laraItem->Position.zPos - minecartItem->Position.zPos;
int distance = pow(x, 2) + pow(z, 2);
if (distance > pow(CLICK(2), 2))
return false;
if (GetCollisionResult(minecartItem).Position.Floor < -32000)
return false;
return true;
}
static bool TestMinecartDismount(ITEM_INFO* laraItem, int direction)
{
auto* lara = GetLaraInfo(laraItem);
auto* minecartItem = &g_Level.Items[lara->Vehicle];
short angle;
if (direction < 0)
angle = minecartItem->Position.yRot + ANGLE(90.0f);
else
angle = minecartItem->Position.yRot - ANGLE(90.0f);
auto probe = GetCollisionResult(minecartItem, angle, -DISMOUNT_DISTANCE);
if (probe.Position.FloorSlope || probe.Position.Floor == NO_HEIGHT)
return false;
if (abs(probe.Position.Floor - minecartItem->Position.yPos) > CLICK(2))
return false;
if ((probe.Position.Ceiling - minecartItem->Position.yPos) > -LARA_HEIGHT ||
(probe.Position.Floor - probe.Position.Ceiling) < LARA_HEIGHT)
{
return false;
}
return true;
}
static void CartToEntityCollision(ITEM_INFO* laraItem, ITEM_INFO* minecartItem)
{
vector<short> roomsList;
roomsList.push_back(minecartItem->RoomNumber);
auto* room = &g_Level.Rooms[minecartItem->RoomNumber];
for (int i = 0; i < room->doors.size(); i++)
roomsList.push_back(room->doors[i].room);
for (int i = 0; i < roomsList.size(); i++)
{
short itemNumber = g_Level.Rooms[roomsList[i]].itemNumber;
while (itemNumber != NO_ITEM)
{
auto* item = &g_Level.Items[itemNumber];
if (item->Collidable &&
item->Status != ITEM_INVISIBLE &&
item != laraItem && item != minecartItem)
{
auto* object = &Objects[item->ObjectNumber];
if (object->collision &&
(object->intelligent || item->ObjectNumber == ID_ROLLINGBALL || item->ObjectNumber == ID_ANIMATING2))
{
int x = minecartItem->Position.xPos - item->Position.xPos;
int y = minecartItem->Position.yPos - item->Position.yPos;
int z = minecartItem->Position.zPos - item->Position.zPos;
if (x > -SECTOR(2) && x < SECTOR(2) &&
y > -SECTOR(2) && y < SECTOR(2) &&
z > -SECTOR(2) && z < SECTOR(2))
{
if (TestBoundsCollide(item, laraItem, CART_ENTITY_RADIUS))
{
if (item->ObjectNumber == ID_ANIMATING2)
{
if (item->FrameNumber == g_Level.Anims[item->AnimNumber].frameBase &&
(laraItem->ActiveState == CART_STATE_SWIPE &&
laraItem->AnimNumber == Objects[ID_MINECART_LARA_ANIMS].animIndex + 6))
{
int frame = laraItem->FrameNumber - g_Level.Anims[laraItem->AnimNumber].frameBase;
if (frame >= 12 && frame <= 22)
{
SoundEffect(220, &item->Position, 2);
TestTriggers(item, true);
item->FrameNumber++;
}
}
}
else if (item->ObjectNumber == ID_ROLLINGBALL)
{
/*code, kill lara and stop both the boulder and the minecart*/
}
else
{
DoLotsOfBlood(item->Position.xPos, minecartItem->Position.yPos - CLICK(1), item->Position.zPos, GetRandomControl() & 3, minecartItem->Position.yRot, item->RoomNumber, 3);
item->HitPoints = 0;
}
}
}
}
}
itemNumber = item->NextItem;
}
}
}
static void MoveCart(ITEM_INFO* laraItem, ITEM_INFO* minecartItem)
{
auto* lara = GetLaraInfo(laraItem);
auto* minecart = (MinecartInfo*)minecartItem->Data;
if (minecart->StopDelay)
minecart->StopDelay--;
if ((lara->Control.Minecart.Left && lara->Control.Minecart.Right && !minecart->StopDelay) &&
(minecartItem->Position.xPos & 0x380 == 512 ||
minecartItem->Position.zRot & 0x380 == 512))
{
if (minecart->Velocity < 0xf000)
{
minecartItem->Velocity = 0;
minecart->Velocity = 0;
minecart->Flags |= CART_FLAG_STOPPED | CART_FLAG_CONTROL;
return;
}
else
minecart->StopDelay = 16;
}
if ((lara->Control.Minecart.Left || lara->Control.Minecart.Right) &&
!(lara->Control.Minecart.Left && lara->Control.Minecart.Right) &&
!minecart->StopDelay &&
!(minecart->Flags & (CART_FLAG_TURNING_LEFT | CART_FLAG_TURNING_RIGHT)))
{
short angle;
unsigned short rotation = (((unsigned short)minecartItem->Position.yRot) / ANGLE(90.0f)) | (lara->Control.Minecart.Left * 4);
switch (rotation)
{
case 0:
minecart->TurnX = (minecartItem->Position.xPos + 4096) & ~1023;
minecart->TurnZ = minecartItem->Position.zPos & ~1023;
break;
case 1:
minecart->TurnX = minecartItem->Position.xPos & ~1023;
minecart->TurnZ = (minecartItem->Position.zPos - 4096) | 1023;
break;
case 2:
minecart->TurnX = (minecartItem->Position.xPos - 4096) | 1023;
minecart->TurnZ = minecartItem->Position.zPos | 1023;
break;
case 3:
minecart->TurnX = minecartItem->Position.xPos | 1023;
minecart->TurnZ = (minecartItem->Position.zPos + 4096) & ~1023;
break;
case 4:
minecart->TurnX = (minecartItem->Position.xPos - 4096) | 1023;
minecart->TurnZ = minecartItem->Position.zPos & ~1023;
break;
case 5:
minecart->TurnX = minecartItem->Position.xPos & ~1023;
minecart->TurnZ = (minecartItem->Position.zPos + 4096) & ~1023;
break;
case 6:
minecart->TurnX = (minecartItem->Position.xPos + 4096) & ~1023;
minecart->TurnZ = minecartItem->Position.zPos | 1023;
break;
case 7:
minecart->TurnX = minecartItem->Position.xPos | 1023;
minecart->TurnZ = (minecartItem->Position.zPos - 4096) | 1023;
break;
}
angle = mGetAngle(minecartItem->Position.xPos, minecartItem->Position.zPos, minecart->TurnX, minecart->TurnZ) & 0x3fff;
if (rotation < 4)
{
minecart->TurnRot = minecartItem->Position.yRot;
minecart->TurnLen = angle;
}
else
{
minecart->TurnRot = minecartItem->Position.yRot;
if (angle)
angle = ANGLE(90.0f) - angle;
minecart->TurnLen = angle;
}
minecart->Flags |= (lara->Control.Minecart.Left) ? CART_FLAG_TURNING_LEFT : CART_FLAG_TURNING_RIGHT;
}
if (minecart->Velocity < CART_MIN_SPEED)
minecart->Velocity = CART_MIN_SPEED;
minecart->Velocity += -minecart->Gradient * 4;
minecart->Velocity /= 256; // TODO: Then why use the huge values in the first place??
if (minecartItem->Velocity < CART_MIN_VEL)
{
minecartItem->Velocity = CART_MIN_VEL;
StopSoundEffect(209);
if (minecart->VerticalVelocity)
StopSoundEffect(210);
else
SoundEffect(210, &minecartItem->Position, 2);
}
else
{
StopSoundEffect(210);
if (minecart->VerticalVelocity)
StopSoundEffect(209);
else
SoundEffect(209, &minecartItem->Position, (2 | 4) + 0x1000000 + (minecartItem->Velocity * 32768));
}
if (minecart->Flags & (CART_FLAG_TURNING_LEFT | CART_FLAG_TURNING_RIGHT))
{
minecart->TurnLen += minecartItem->Velocity * 3;
if (minecart->TurnLen > ANGLE(90.0f))
{
if (minecart->Flags & CART_FLAG_TURNING_LEFT)
minecartItem->Position.yRot = minecart->TurnRot - ANGLE(90.0f);
else
minecartItem->Position.yRot = minecart->TurnRot + ANGLE(90.0f);
minecart->Flags &= ~(CART_FLAG_TURNING_LEFT | CART_FLAG_TURNING_RIGHT);
}
else
{
if (minecart->Flags & CART_FLAG_TURNING_LEFT)
minecartItem->Position.yRot = minecart->TurnRot - minecart->TurnLen;
else
minecartItem->Position.yRot = minecart->TurnRot + minecart->TurnLen;
}
if (minecart->Flags & (CART_FLAG_TURNING_LEFT | CART_FLAG_TURNING_RIGHT))
{
unsigned short quadrant = ((unsigned short)minecartItem->Position.yRot) / ANGLE(90.0f);
unsigned short degree = minecartItem->Position.yRot & 16383;
float x, z;
switch (quadrant)
{
case 0:
x = -phd_cos(degree);
z = phd_sin(degree);
break;
case 1:
x = phd_sin(degree);
z = phd_cos(degree);
break;
case 2:
x = phd_cos(degree);
z = -phd_sin(degree);
break;
default:
x = -phd_sin(degree);
z = -phd_cos(degree);
break;
}
if (minecart->Flags & CART_FLAG_TURNING_LEFT)
{
x = -x;
z = -z;
}
minecartItem->Position.xPos = minecart->TurnX + x * 3584;
minecartItem->Position.zPos = minecart->TurnZ + z * 3584;
}
}
else
{
minecartItem->Position.xPos += minecartItem->Velocity * phd_sin(minecartItem->Position.yRot);
minecartItem->Position.zPos += minecartItem->Velocity * phd_cos(minecartItem->Position.yRot);
}
minecart->FloorHeightMiddle = TestMinecartHeight(minecartItem, 0, 0);
if (!minecart->VerticalVelocity)
{
minecart->FloorHeightFront = TestMinecartHeight(minecartItem, 0, CLICK(1));
minecart->Gradient = minecart->FloorHeightMiddle - minecart->FloorHeightFront;
minecartItem->Position.yPos = minecart->FloorHeightMiddle;
}
else
{
if (minecartItem->Position.yPos > minecart->FloorHeightMiddle)
{
if (minecart->VerticalVelocity > 0)
SoundEffect(202, &minecartItem->Position, 2);
minecartItem->Position.yPos = minecart->FloorHeightMiddle;
minecart->VerticalVelocity = 0;
}
else
{
minecart->VerticalVelocity += CART_GRAVITY;
if (minecart->VerticalVelocity > CART_MAX_VERTICAL_VELOCITY)
minecart->VerticalVelocity = CART_MAX_VERTICAL_VELOCITY;
minecartItem->Position.yPos += minecart->VerticalVelocity / 256;
}
}
minecartItem->Position.xRot = minecart->Gradient * 32;
if (minecart->Flags & (CART_FLAG_TURNING_LEFT | CART_FLAG_TURNING_RIGHT))
{
short val = minecartItem->Position.yRot & 16383;
if (minecart->Flags & CART_FLAG_TURNING_RIGHT)
minecartItem->Position.zRot = -(val * minecartItem->Velocity) / 512;
else
minecartItem->Position.zRot = ((ANGLE(90.0f) - val) * minecartItem->Velocity) / 512;
}
else
minecartItem->Position.zRot -= minecartItem->Position.zRot / 8;
}
static void DoUserInput(ITEM_INFO* minecartItem, ITEM_INFO* laraItem, MinecartInfo* minecart)
{
auto* lara = GetLaraInfo(laraItem);
short floorHeight;
switch (laraItem->ActiveState)
{
case CART_STATE_MOVE:
if (TrInput & CART_IN_SWIPE)
laraItem->TargetState = CART_STATE_SWIPE;
else if (TrInput & CART_IN_DUCK)
laraItem->TargetState = CART_STATE_DUCK;
else if (TrInput & CART_IN_BRAKE)
laraItem->TargetState = CART_STATE_BRAKE;
else if (minecart->Velocity == CART_MIN_VEL || minecart->Flags & CART_FLAG_STOPPED)
laraItem->TargetState = CART_STATE_IDLE;
else if (minecart->Gradient < CART_FORWARD_GRADIENT)
laraItem->TargetState = CART_STATE_FORWARD;
else if (minecart->Gradient > CART_BACK_GRADIENT)
laraItem->TargetState = CART_STATE_BACK;
else if (TrInput & CART_IN_LEFT)
laraItem->TargetState = CART_STATE_LEFT;
else if (TrInput & CART_IN_RIGHT)
laraItem->TargetState = CART_STATE_RIGHT;
break;
case CART_STATE_FORWARD:
if (TrInput & CART_IN_SWIPE)
laraItem->TargetState = CART_STATE_SWIPE;
else if (TrInput & CART_IN_DUCK)
laraItem->TargetState = CART_STATE_DUCK;
else if (TrInput & CART_IN_BRAKE)
laraItem->TargetState = CART_STATE_BRAKE;
else if (minecart->Gradient > CART_FORWARD_GRADIENT)
laraItem->TargetState = CART_STATE_MOVE;
break;
case CART_STATE_BACK:
if (TrInput & CART_IN_SWIPE)
laraItem->TargetState = CART_STATE_SWIPE;
else if (TrInput & CART_IN_DUCK)
laraItem->TargetState = CART_STATE_DUCK;
else if (TrInput & CART_IN_BRAKE)
laraItem->TargetState = CART_STATE_BRAKE;
else if (minecart->Gradient < CART_BACK_GRADIENT)
laraItem->TargetState = CART_STATE_MOVE;
break;
case CART_STATE_LEFT:
if (TrInput & CART_IN_SWIPE)
laraItem->TargetState = CART_STATE_SWIPE;
else if (TrInput & CART_IN_DUCK)
laraItem->TargetState = CART_STATE_DUCK;
else if (TrInput & CART_IN_BRAKE)
laraItem->TargetState = CART_STATE_BRAKE;
if (!(TrInput & CART_IN_LEFT))
laraItem->TargetState = CART_STATE_MOVE;
break;
case CART_STATE_RIGHT:
if (TrInput & CART_IN_SWIPE)
laraItem->TargetState = CART_STATE_SWIPE;
else if (TrInput & CART_IN_DUCK)
laraItem->TargetState = CART_STATE_DUCK;
else if (TrInput & CART_IN_BRAKE)
laraItem->TargetState = CART_STATE_BRAKE;
if (!(TrInput & CART_IN_RIGHT))
laraItem->TargetState = CART_STATE_MOVE;
break;
case CART_STATE_IDLE:
if (!(minecart->Flags & CART_FLAG_CONTROL))
{
SoundEffect(211, &minecartItem->Position, 2);
minecart->Flags |= CART_FLAG_CONTROL;
minecart->StopDelay = 64;
}
if (TrInput & CART_IN_DISMOUNT && minecart->Flags & CART_FLAG_STOPPED)
{
if (TrInput & CART_IN_LEFT && TestMinecartDismount(laraItem, -1))
{
laraItem->TargetState = CART_STATE_DISMOUNT;
minecart->Flags &= ~CART_FLAG_RDIR;
}
else if (TrInput & CART_IN_RIGHT && TestMinecartDismount(laraItem, 1))
{
laraItem->TargetState = CART_STATE_DISMOUNT;
minecart->Flags |= CART_FLAG_RDIR;
}
}
if (TrInput & CART_IN_DUCK)
laraItem->TargetState = CART_STATE_DUCK;
else if (minecart->Velocity > CART_MIN_VEL)
laraItem->TargetState = CART_STATE_MOVE;
break;
case CART_STATE_DUCK:
if (TrInput & CART_IN_SWIPE)
laraItem->TargetState = CART_STATE_SWIPE;
else if (TrInput & CART_IN_BRAKE)
laraItem->TargetState = CART_STATE_BRAKE;
else if (!(TrInput & CART_IN_DUCK))
laraItem->TargetState = CART_STATE_IDLE;
break;
case CART_STATE_SWIPE:
laraItem->TargetState = CART_STATE_MOVE;
break;
case CART_STATE_BRAKING:
if (TrInput & CART_IN_DUCK)
{
laraItem->TargetState = CART_STATE_DUCK;
StopSoundEffect(219);
}
else if (!(TrInput & CART_IN_BRAKE) || minecart->Flags & CART_FLAG_STOPPED)
{
laraItem->TargetState = CART_STATE_MOVE;
StopSoundEffect(219);
}
else
{
minecart->Velocity += CART_DEC;
SoundEffect(219, &laraItem->Position, 2);
}
break;
case CART_STATE_BRAKE:
laraItem->TargetState = CART_STATE_BRAKING;
break;
case CART_STATE_DISMOUNT:
if (laraItem->AnimNumber == Objects[ID_MINECART_LARA_ANIMS].animIndex + 7)
{
if (laraItem->FrameNumber == GetFrameNumber(minecartItem, 20) &&
minecart->Flags & CART_FLAG_MESH)
{
lara->MeshPtrs[LM_RHAND] = Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND;
minecart->Flags &= ~CART_FLAG_MESH;
}
if (minecart->Flags & CART_FLAG_RDIR)
laraItem->TargetState = CART_STATE_DISMOUNT_RIGHT;
else
laraItem->TargetState = CART_STATE_DISMOUNT_LEFT;
}
break;
case CART_STATE_DISMOUNT_LEFT:
if (laraItem->AnimNumber == Objects[ID_MINECART_LARA_ANIMS].animIndex + 1 &&
laraItem->FrameNumber == g_Level.Anims[laraItem->AnimNumber].frameEnd)
{
PHD_VECTOR pos = { 0, 640, 0 };
GetLaraJointPosition(&pos, LM_HIPS);
laraItem->Position.xPos = pos.x;
laraItem->Position.yPos = pos.y;
laraItem->Position.zPos = pos.z;
laraItem->Position.xRot = 0;
laraItem->Position.yRot = ANGLE(90.0f);
laraItem->Position.zRot = 0;
minecartItem->Position.yRot + ANGLE(90.0f);
SetAnimation(laraItem, LA_STAND_SOLID);
lara->Control.HandStatus = HandStatus::Free;
lara->Vehicle = NO_ITEM;
}
break;
case CART_STATE_DISMOUNT_RIGHT:
if (laraItem->AnimNumber == Objects[ID_MINECART_LARA_ANIMS].animIndex + 47 &&
laraItem->FrameNumber == g_Level.Anims[laraItem->AnimNumber].frameEnd)
{
PHD_VECTOR pos = { 0, 640, 0 };
GetLaraJointPosition(&pos, LM_HIPS);
laraItem->Position.xPos = pos.x;
laraItem->Position.yPos = pos.y;
laraItem->Position.zPos = pos.z;
laraItem->Position.xRot = 0;
laraItem->Position.yRot = ANGLE(90.0f);
laraItem->Position.zRot = 0;
minecartItem->Position.yRot + ANGLE(90.0f);
SetAnimation(laraItem, LA_STAND_SOLID);
lara->Control.HandStatus = HandStatus::Free;
lara->Vehicle = NO_ITEM;
}
break;
case CART_STATE_MOUNT:
if (laraItem->AnimNumber == Objects[ID_MINECART_LARA_ANIMS].animIndex + 5 &&
laraItem->FrameNumber == GetFrameNumber(minecartItem, 20) &&
!minecart->Flags & CART_FLAG_MESH)
{
auto temp = g_Level.Meshes[lara->MeshPtrs[LM_RHAND]];
lara->MeshPtrs[LM_RHAND] = Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND;
g_Level.Meshes[Objects[ID_MINECART_LARA_ANIMS].meshIndex + LM_RHAND] = temp;
minecart->Flags |= CART_FLAG_MESH;
}
break;
case CART_WALL_DEATH:
Camera.targetElevation = -ANGLE(25.0f);
Camera.targetDistance = SECTOR(4);
break;
case CART_TURN_DEATH:
Camera.targetElevation = -ANGLE(45.0f);
Camera.targetDistance = SECTOR(2);
floorHeight = GetMinecartCollision(minecartItem, minecartItem->Position.yRot, CLICK(2));
if (floorHeight > -CLICK(1) &&
floorHeight < CLICK(1))
{
if (Wibble & 7 == 0)
SoundEffect(SFX_TR3_QUAD_FRONT_IMPACT, &minecartItem->Position, 2);
minecartItem->Position.xPos += TURN_DEATH_VEL * phd_sin(minecartItem->Position.yRot);
minecartItem->Position.zPos += TURN_DEATH_VEL * phd_cos(minecartItem->Position.yRot);
}
else
{
if (laraItem->AnimNumber == Objects[ID_MINECART_LARA_ANIMS].animIndex + 30)
{
minecart->Flags |= CART_FLAG_NO_ANIM;
laraItem->HitPoints = -1;
}
}
break;
case CART_STATE_HIT:
if (laraItem->HitPoints <= 0 &&
laraItem->FrameNumber == GetFrameNumber(minecartItem, 34) + 28)
{
laraItem->FrameNumber = GetFrameNumber(minecartItem, 34) + 28;
minecartItem->Velocity = 0;
minecart->Flags = (minecart->Flags & ~CART_FLAG_CONTROL) | CART_FLAG_NO_ANIM;
minecart->Velocity = 0;
}
break;
}
if (lara->Vehicle != NO_ITEM &&
!(minecart->Flags & CART_FLAG_NO_ANIM))
{
AnimateItem(laraItem);
minecartItem->AnimNumber = Objects[ID_MINECART].animIndex + (laraItem->AnimNumber - Objects[ID_MINECART_LARA_ANIMS].animIndex);
minecartItem->FrameNumber = g_Level.Anims[minecartItem->AnimNumber].frameBase + (laraItem->FrameNumber - g_Level.Anims[laraItem->AnimNumber].frameBase);
}
if (laraItem->ActiveState != CART_TURN_DEATH &&
laraItem->ActiveState != CART_WALL_DEATH &&
laraItem->HitPoints > 0)
{
if (minecartItem->Position.zRot > TERMINAL_ANGLE ||
minecartItem->Position.zRot < -TERMINAL_ANGLE)
{
laraItem->AnimNumber = Objects[ID_MINECART_LARA_ANIMS].animIndex + 31;
laraItem->FrameNumber = g_Level.Anims[laraItem->AnimNumber].frameBase;
laraItem->ActiveState = laraItem->TargetState = CART_TURN_DEATH;
minecartItem->Velocity = 0;
minecart->Flags = (minecart->Flags & ~CART_FLAG_CONTROL) | CART_FLAG_STOPPED | CART_FLAG_DEAD;
minecart->Velocity = 0;
return;
}
floorHeight = GetMinecartCollision(minecartItem, minecartItem->Position.yRot, CLICK(2));
if (floorHeight < -CLICK(2))
{
laraItem->AnimNumber = Objects[ID_MINECART_LARA_ANIMS].animIndex + 23;
laraItem->FrameNumber = g_Level.Anims[laraItem->AnimNumber].frameBase;
laraItem->ActiveState = laraItem->TargetState = CART_WALL_DEATH;
laraItem->HitPoints = -1;
minecartItem->Velocity = 0;
minecart->Flags = (minecart->Flags & ~CART_FLAG_CONTROL) | (CART_FLAG_STOPPED | CART_FLAG_DEAD);
minecart->Velocity = 0;
return;
}
if (laraItem->ActiveState != CART_STATE_DUCK &&
laraItem->ActiveState != CART_STATE_HIT)
{
COLL_INFO coll;
coll.Setup.Radius = CART_RADIUS;
DoObjectCollision(minecartItem, &coll);
if (coll.HitStatic)
{
laraItem->AnimNumber = Objects[ID_MINECART_LARA_ANIMS].animIndex + 34;
laraItem->FrameNumber = g_Level.Anims[laraItem->AnimNumber].frameBase;
laraItem->ActiveState = laraItem->TargetState = CART_STATE_HIT;
DoLotsOfBlood(laraItem->Position.xPos, laraItem->Position.yPos - CLICK(3), laraItem->Position.zPos, minecartItem->Velocity, minecartItem->Position.yRot, laraItem->RoomNumber, 3);
int hits = CART_NHITS * short(minecart->Velocity / 2048);
if (hits < 20)
hits = 20;
laraItem->HitPoints -= hits;
return;
}
}
if (floorHeight > CLICK(2.25f) && !minecart->VerticalVelocity)
minecart->VerticalVelocity = CART_JUMP_VELOCITY;
CartToEntityCollision(laraItem, minecartItem);
}
}
void MineCartCollision(short itemNumber, ITEM_INFO* laraItem, COLL_INFO* coll)
{
auto* lara = GetLaraInfo(laraItem);
if (laraItem->HitPoints < 0 || lara->Vehicle != NO_ITEM)
return;
auto* minecartItem = &g_Level.Items[itemNumber];
int mount = GetInMineCart(minecartItem, laraItem, coll);
if (mount)
{
lara->Vehicle = itemNumber;
if (lara->Control.Weapon.GunType == WEAPON_FLARE)
{
CreateFlare(laraItem, ID_FLARE_ITEM, FALSE);
UndrawFlareMeshes(laraItem);
lara->Flare.ControlLeft = false;
lara->Control.Weapon.RequestGunType = WEAPON_NONE;
lara->Control.Weapon.GunType = WEAPON_NONE;
}
lara->Control.HandStatus = HandStatus::Busy;
short angle = short(mGetAngle(minecartItem->Position.xPos, minecartItem->Position.zPos, laraItem->Position.xPos, laraItem->Position.zPos) - minecartItem->Position.yRot);
if (angle > -ANGLE(45.0f) && angle < ANGLE(135.0f))
laraItem->AnimNumber = Objects[ID_MINECART_LARA_ANIMS].animIndex + CART_ANIM_MOUNT_RIGHT;
else
laraItem->AnimNumber = Objects[ID_MINECART_LARA_ANIMS].animIndex + CART_ANIM_MOUNT_LEFT;
laraItem->FrameNumber = g_Level.Anims[laraItem->AnimNumber].frameBase;
laraItem->TargetState = CART_STATE_MOUNT;
laraItem->ActiveState = CART_STATE_MOUNT;
laraItem->Position.xPos = minecartItem->Position.xPos;
laraItem->Position.yPos = minecartItem->Position.yPos;
laraItem->Position.zPos = minecartItem->Position.zPos;
laraItem->Position.xRot = minecartItem->Position.xRot;
laraItem->Position.yRot = minecartItem->Position.yRot;
laraItem->Position.zRot = minecartItem->Position.zRot;
}
else
ObjectCollision(itemNumber, laraItem, coll);
}
bool MineCartControl(ITEM_INFO* laraItem)
{
auto* lara = GetLaraInfo(laraItem);
auto* minecartItem = &g_Level.Items[lara->Vehicle];
if (!minecartItem->Data)
{
TENLog("Minecart data is nullptr!", LogLevel::Error);
return false;
}
auto* minecart = (MinecartInfo*)minecartItem->Data;
DoUserInput(minecartItem, laraItem, minecart);
if (minecart->Flags & CART_FLAG_CONTROL)
MoveCart(laraItem, minecartItem);
if (lara->Vehicle != NO_ITEM)
{
laraItem->Position.xPos = minecartItem->Position.xPos;
laraItem->Position.yPos = minecartItem->Position.yPos;
laraItem->Position.zPos = minecartItem->Position.zPos;
laraItem->Position.xRot = minecartItem->Position.xRot;
laraItem->Position.yRot = minecartItem->Position.yRot;
laraItem->Position.zRot = minecartItem->Position.zRot;
}
short probedRoomNumber = GetCollisionResult(minecartItem).RoomNumber;
if (probedRoomNumber != minecartItem->RoomNumber)
{
ItemNewRoom(lara->Vehicle, probedRoomNumber);
ItemNewRoom(lara->ItemNumber, probedRoomNumber);
}
TestTriggers(minecartItem, false);
if (!(minecart->Flags & CART_FLAG_DEAD))
{
Camera.targetElevation = -ANGLE(45.0f);
Camera.targetDistance = SECTOR(2);
}
return (lara->Vehicle == NO_ITEM) ? false : true;
}
Reference in a new issue View git blame Copy permalink