Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-05-10 20:46:47 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix phd_sin() and phd_cos()

Browse source
This commit is contained in:
asasas9500 2020-10-05 22:24:57 -03:00
parent 54f6db166b
commit 6fc9bd9890
79 changed files with 597 additions and 601 deletions
Download patch file Download diff file Expand all files Collapse all files

18
TR5Main/Game/Lara/lara.cpp
View file

@ -1025,9 +1025,9 @@ void LaraUnderWater(ITEM_INFO* item, COLL_INFO* coll)//4BFB4, 4C418 (F)
AnimateLara(item);
item->pos.xPos += phd_cos(item->pos.xRot) * (item->fallspeed * phd_sin(item->pos.yRot) >> (W2V_SHIFT + 2)) >> W2V_SHIFT;
item->pos.yPos -= item->fallspeed * phd_sin(item->pos.xRot) >> (W2V_SHIFT + 2);
item->pos.zPos += phd_cos(item->pos.xRot) * (item->fallspeed * phd_cos(item->pos.yRot) >> (W2V_SHIFT + 2)) >> W2V_SHIFT;
item->pos.xPos += phd_cos(item->pos.xRot) * item->fallspeed * phd_sin(item->pos.yRot) / 4;
item->pos.yPos -= item->fallspeed * phd_sin(item->pos.xRot) / 4;
item->pos.zPos += phd_cos(item->pos.xRot) * item->fallspeed * phd_cos(item->pos.yRot) / 4;
LaraBaddieCollision(item, coll);
@ -1083,8 +1083,8 @@ void LaraSurface(ITEM_INFO* item, COLL_INFO* coll)//4D684, 4DAE8 (F)
AnimateLara(item);
item->pos.xPos += item->fallspeed * phd_sin(item->pos.yRot + Lara.moveAngle) >> (W2V_SHIFT + 2);
item->pos.zPos += item->fallspeed * phd_cos(item->pos.yRot + Lara.moveAngle) >> (W2V_SHIFT + 2);
item->pos.xPos += item->fallspeed * phd_sin(item->pos.yRot + Lara.moveAngle) / 4;
item->pos.zPos += item->fallspeed * phd_cos(item->pos.yRot + Lara.moveAngle) / 4;
LaraBaddieCollision(item, coll);
@ -1293,11 +1293,11 @@ void AnimateLara(ITEM_INFO* item)
if (!Lara.isMoving) // TokyoSU: i dont know why but it's wreid, in TR3 only the 2 first line there is used and worked fine !
{
item->pos.xPos += item->speed * phd_sin(item->pos.yRot + Lara.moveAngle) >> W2V_SHIFT;
item->pos.zPos += item->speed * phd_cos(item->pos.yRot + Lara.moveAngle) >> W2V_SHIFT;
item->pos.xPos += item->speed * phd_sin(item->pos.yRot + Lara.moveAngle);
item->pos.zPos += item->speed * phd_cos(item->pos.yRot + Lara.moveAngle);
item->pos.xPos += lateral * phd_sin(item->pos.yRot + Lara.moveAngle + ANGLE(90)) >> W2V_SHIFT;
item->pos.zPos += lateral * phd_cos(item->pos.yRot + Lara.moveAngle + ANGLE(90)) >> W2V_SHIFT;
item->pos.xPos += lateral * phd_sin(item->pos.yRot + Lara.moveAngle + ANGLE(90));
item->pos.zPos += lateral * phd_cos(item->pos.yRot + Lara.moveAngle + ANGLE(90));
}
// Update matrices

4
TR5Main/Game/Lara/lara_collide.cpp
View file

@ -83,8 +83,8 @@ void LaraDeflectEdgeJump(ITEM_INFO* item, COLL_INFO* coll)//12904, 129B4 (F)
item->pos.yRot -= ANGLE(5.0f);
break;
case CT_CLAMP:
item->pos.xPos -= (100 * 4 * phd_sin(coll->facing)) >> W2V_SHIFT;
item->pos.zPos -= (100 * 4 * phd_cos(coll->facing)) >> W2V_SHIFT;
item->pos.xPos -= 400 * phd_sin(coll->facing);
item->pos.zPos -= 400 * phd_cos(coll->facing);
item->speed = 0;
coll->midFloor = 0;

28
TR5Main/Game/Lara/lara_crawl.cpp
View file

@ -198,9 +198,9 @@ void lara_as_all4s(ITEM_INFO* item, COLL_INFO* coll)//14970, 14A78 (F)
s.z = LaraItem->pos.zPos;
s.roomNumber = LaraItem->roomNumber;
d.x = s.x + (768 * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT);
d.x = s.x + 768 * phd_sin(LaraItem->pos.yRot);
d.y = s.y + 160;
d.z = s.z + (768 * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT);
d.z = s.z + 768 * phd_cos(LaraItem->pos.yRot);
if (LOS(&s, &d) && item->animNumber != LA_CROUCH_TO_CRAWL_START && item->animNumber != LA_CROUCH_TO_CRAWL_CONTINUE)
{
@ -224,9 +224,9 @@ void lara_as_all4s(ITEM_INFO* item, COLL_INFO* coll)//14970, 14A78 (F)
s.z = LaraItem->pos.zPos;
s.roomNumber = LaraItem->roomNumber;
d.x = s.x + (768 * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT);
d.x = s.x + 768 * phd_sin(LaraItem->pos.yRot);
d.y = s.y + 160;
d.z = s.z + (768 * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT);
d.z = s.z + 768 * phd_cos(LaraItem->pos.yRot);
if (LOS(&s, &d) && item->animNumber != LA_CROUCH_TO_CRAWL_START && item->animNumber != LA_CROUCH_TO_CRAWL_CONTINUE)// && EnableCrawlFlex3clickE == true)
{
@ -248,9 +248,9 @@ void lara_as_all4s(ITEM_INFO* item, COLL_INFO* coll)//14970, 14A78 (F)
s.z = LaraItem->pos.zPos;
s.roomNumber = LaraItem->roomNumber;
d.x = s.x + (768 * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT);
d.x = s.x + 768 * phd_sin(LaraItem->pos.yRot);
d.y = s.y + 160;
d.z = s.z + (768 * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT);
d.z = s.z + 768 * phd_cos(LaraItem->pos.yRot);
if (LOS(&s, &d) && item->animNumber != LA_CROUCH_TO_CRAWL_START && item->animNumber != LA_CROUCH_TO_CRAWL_CONTINUE)// && EnableCrawlFlex2clickE == true)
{
@ -271,9 +271,9 @@ void lara_as_all4s(ITEM_INFO* item, COLL_INFO* coll)//14970, 14A78 (F)
s.z = LaraItem->pos.zPos;
s.roomNumber = LaraItem->roomNumber;
d.x = s.x + (768 * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT);
d.x = s.x + 768 * phd_sin(LaraItem->pos.yRot);
d.y = s.y + 160;
d.z = s.z + (768 * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT);
d.z = s.z + 768 * phd_cos(LaraItem->pos.yRot);
if (LOS(&s, &d) && item->animNumber != LA_CROUCH_TO_CRAWL_START && item->animNumber != LA_CROUCH_TO_CRAWL_CONTINUE)// && EnableCrawlFlex1clickE == true)
{
@ -400,13 +400,13 @@ void lara_col_all4s(ITEM_INFO* item, COLL_INFO* coll)//14B40, 14C74 (F)
int x = item->pos.xPos;
int z = item->pos.zPos;
item->pos.xPos += 128 * phd_sin(item->pos.yRot - ANGLE(90.0f)) >> W2V_SHIFT;
item->pos.zPos += 128 * phd_cos(item->pos.yRot - ANGLE(90.0f)) >> W2V_SHIFT;
item->pos.xPos += 128 * phd_sin(item->pos.yRot - ANGLE(90.0f));
item->pos.zPos += 128 * phd_cos(item->pos.yRot - ANGLE(90.0f));
heightl = LaraFloorFront(item, item->pos.yRot, -300);
item->pos.xPos += 256 * phd_sin(item->pos.yRot + ANGLE(90.0f)) >> W2V_SHIFT;
item->pos.zPos += 256 * phd_cos(item->pos.yRot + ANGLE(90.0f)) >> W2V_SHIFT;
item->pos.xPos += 256 * phd_sin(item->pos.yRot + ANGLE(90.0f));
item->pos.zPos += 256 * phd_cos(item->pos.yRot + ANGLE(90.0f));
heightr = LaraFloorFront(item, item->pos.yRot, -300);
@ -431,8 +431,8 @@ void lara_col_all4s(ITEM_INFO* item, COLL_INFO* coll)//14B40, 14C74 (F)
int x = item->pos.xPos;
int z = item->pos.zPos;
item->pos.xPos -= 100 * phd_sin(coll->facing) >> W2V_SHIFT;
item->pos.zPos -= 100 * phd_cos(coll->facing) >> W2V_SHIFT;
item->pos.xPos -= 100 * phd_sin(coll->facing);
item->pos.zPos -= 100 * phd_cos(coll->facing);
tmp = GetCollidedObjects(item, 100, 1, &tmp1, &tmp2, 0);

7
TR5Main/Game/Lara/lara_fire.cpp
View file

@ -837,7 +837,8 @@ FireWeaponType FireWeapon(int weaponType, ITEM_INFO* target, ITEM_INFO* src, sho
void find_target_point(ITEM_INFO* item, GAME_VECTOR* target) // (F) (D)
{
BOUNDING_BOX* bounds;
int x, y, z, c, s;
int x, y, z;
float c, s;
bounds = (BOUNDING_BOX*)GetBestFrame(item);
x = (int)(bounds->X1 + bounds->X2) / 2;
@ -846,9 +847,9 @@ void find_target_point(ITEM_INFO* item, GAME_VECTOR* target) // (F) (D)
c = phd_cos(item->pos.yRot);
s = phd_sin(item->pos.yRot);
target->x = item->pos.xPos + ((c * x + s * z) >> W2V_SHIFT);
target->x = item->pos.xPos + c * x + s * z;
target->y = item->pos.yPos + y;
target->z = item->pos.zPos + ((c * z - s * x) >> W2V_SHIFT);
target->z = item->pos.zPos + c * z - s * x;
target->roomNumber = item->roomNumber;
}

8
TR5Main/Game/Lara/lara_flare.cpp
View file

@ -44,8 +44,8 @@ void FlareControl(short itemNumber) // (AF) (D)
int oldY = item->pos.yPos;
int oldZ = item->pos.zPos;
int xv = item->speed * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int zv = item->speed * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int xv = item->speed * phd_sin(item->pos.yRot);
int zv = item->speed * phd_cos(item->pos.yRot);
item->pos.xPos += xv;
item->pos.zPos += zv;
@ -328,8 +328,8 @@ void CreateFlare(short objectNum, int thrown) // (F) (D)
{
flag = true;
item->pos.yRot = LaraItem->pos.yRot + ANGLE(180);
item->pos.xPos = LaraItem->pos.xPos + (320 * phd_sin(item->pos.yRot) >> W2V_SHIFT);
item->pos.zPos = LaraItem->pos.zPos + (320 * phd_cos(item->pos.yRot) >> W2V_SHIFT);
item->pos.xPos = LaraItem->pos.xPos + 320 * phd_sin(item->pos.yRot);
item->pos.zPos = LaraItem->pos.zPos + 320 * phd_cos(item->pos.yRot);
item->roomNumber = LaraItem->roomNumber;
}
else

8
TR5Main/Game/Lara/lara_objects.cpp
View file

@ -256,9 +256,9 @@ void lara_as_pbleapoff(ITEM_INFO* item, COLL_INFO* coll)//1D244, 1D3D8 (F)
if (item->frameNumber == g_Level.Anims[item->animNumber].frameEnd)
{
item->pos.xPos += 700 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos += 700 * phd_sin(item->pos.yRot);
item->pos.yPos -= 361;
item->pos.zPos += 700 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.zPos += 700 * phd_cos(item->pos.yRot);
item->animNumber = LA_REACH;
item->frameNumber = g_Level.Anims[item->animNumber].frameBase;
@ -677,8 +677,8 @@ void lara_col_polestat(ITEM_INFO* item, COLL_INFO* coll)//16DFC, 16F30 (F)
}
else
{
item->pos.xPos -= (phd_sin(item->pos.yRot)) << 6 >> W2V_SHIFT;
item->pos.zPos -= (phd_cos(item->pos.yRot)) << 6 >> W2V_SHIFT;
item->pos.xPos -= phd_sin(item->pos.yRot) * 64;
item->pos.zPos -= phd_cos(item->pos.yRot) * 64;
item->goalAnimState = LS_FREEFALL;
}
}

45
TR5Main/Game/Lara/lara_one_gun.cpp
View file

@ -93,8 +93,8 @@ void FireHarpoon()
item->pos.zRot = 0;
item->fallspeed = (short)(-HARPOON_SPEED * phd_sin(item->pos.xRot) >> W2V_SHIFT);
item->speed = (short)(HARPOON_SPEED * phd_cos(item->pos.xRot) >> W2V_SHIFT);
item->fallspeed = -HARPOON_SPEED * phd_sin(item->pos.xRot);
item->speed = HARPOON_SPEED * phd_cos(item->pos.xRot);
item->hitPoints = HARPOON_TIME;
AddActiveItem(itemNumber);
@ -166,8 +166,8 @@ void ControlHarpoonBolt(short itemNumber)
item->pos.xRot -= ANGLE(1);
if (item->pos.xRot < -16384)
item->pos.xRot = -16384;
item->fallspeed = (short)(-HARPOON_SPEED * phd_sin(item->pos.xRot) >> W2V_SHIFT);
item->speed = (short)(HARPOON_SPEED * phd_cos(item->pos.xRot) >> W2V_SHIFT);
item->fallspeed = -HARPOON_SPEED * phd_sin(item->pos.xRot);
item->speed = HARPOON_SPEED * phd_cos(item->pos.xRot);
aboveWater = true;
}
else
@ -176,15 +176,15 @@ void ControlHarpoonBolt(short itemNumber)
if ((Wibble & 15) == 0)
CreateBubble((PHD_VECTOR*)& item->pos, item->roomNumber, 0, 0, BUBBLE_FLAG_CLUMP | BUBBLE_FLAG_HIGH_AMPLITUDE, 0, 0, 0); // CHECK
TriggerRocketSmoke(item->pos.xPos, item->pos.yPos, item->pos.zPos, 64);
item->fallspeed = (short)(-(HARPOON_SPEED >> 1) * phd_sin(item->pos.xRot) >> W2V_SHIFT);
item->speed = (short)((HARPOON_SPEED >> 1) * phd_cos(item->pos.xRot) >> W2V_SHIFT);
item->fallspeed = -HARPOON_SPEED * phd_sin(item->pos.xRot) / 2;
item->speed = HARPOON_SPEED * phd_cos(item->pos.xRot) / 2;
aboveWater = false;
}
// Update bolt's position
item->pos.xPos += ((item->speed * phd_cos(item->pos.xRot) >> W2V_SHIFT) * phd_sin(item->pos.yRot)) >> W2V_SHIFT;
item->pos.yPos += item->speed * phd_sin(-item->pos.xRot) >> W2V_SHIFT;
item->pos.zPos += ((item->speed * phd_cos(item->pos.xRot) >> W2V_SHIFT) * phd_cos(item->pos.yRot)) >> W2V_SHIFT;
item->pos.xPos += item->speed * phd_cos(item->pos.xRot) * phd_sin(item->pos.yRot);
item->pos.yPos += item->speed * phd_sin(-item->pos.xRot);
item->pos.zPos += item->speed * phd_cos(item->pos.xRot) * phd_cos(item->pos.yRot);
roomNumber = item->roomNumber;
FLOOR_INFO * floor = GetFloor(item->pos.xPos, item->pos.yPos, item->pos.zPos, &roomNumber);
@ -356,7 +356,7 @@ void FireGrenade()
}
item->speed = GRENADE_SPEED;
item->fallspeed = (-512 * phd_sin(item->pos.xRot)) >> W2V_SHIFT;
item->fallspeed = -512 * phd_sin(item->pos.xRot);
item->currentAnimState = item->pos.xRot;
item->goalAnimState = item->pos.yRot;
item->requiredAnimState = 0;
@ -437,7 +437,7 @@ void ControlGrenade(short itemNumber)
newGrenade->pos.yRot = GetRandomControl() * 2;
newGrenade->pos.zRot = 0;
newGrenade->speed = 64;
newGrenade->fallspeed = -64 * phd_sin(newGrenade->pos.xRot) >> W2V_SHIFT;
newGrenade->fallspeed = -64 * phd_sin(newGrenade->pos.xRot);
newGrenade->currentAnimState = newGrenade->pos.xRot;
newGrenade->goalAnimState = newGrenade->pos.yRot;
newGrenade->requiredAnimState = 0;
@ -521,9 +521,9 @@ void ControlGrenade(short itemNumber)
}
// Update grenade position
xv = ((item->speed * phd_sin(item->goalAnimState)) >> W2V_SHIFT);
xv = item->speed * phd_sin(item->goalAnimState);
yv = item->fallspeed;
zv = ((item->speed * phd_cos(item->goalAnimState)) >> W2V_SHIFT);
zv = item->speed * phd_cos(item->goalAnimState);
item->pos.xPos += xv;
item->pos.yPos += yv;
@ -799,10 +799,10 @@ void ControlRocket(short itemNumber)
}
// Update rocket's position
short speed = (item->speed * phd_cos(item->pos.xRot)) >> W2V_SHIFT;
item->pos.xPos += (speed * phd_sin(item->pos.yRot)) >> W2V_SHIFT;
item->pos.yPos += -((item->speed * phd_sin(item->pos.xRot)) >> W2V_SHIFT);
item->pos.zPos += (speed * phd_cos(item->pos.yRot)) >> W2V_SHIFT;
short speed = item->speed * phd_cos(item->pos.xRot);
item->pos.xPos += speed * phd_sin(item->pos.yRot);
item->pos.yPos += -item->speed * phd_sin(item->pos.xRot);
item->pos.zPos += speed * phd_cos(item->pos.yRot);
bool explode = false;
@ -1271,9 +1271,9 @@ void ControlCrossbowBolt(short itemNumber)
}
// Update bolt's position
item->pos.xPos += ((item->speed * phd_cos(item->pos.xRot) >> W2V_SHIFT) * phd_sin(item->pos.yRot)) >> W2V_SHIFT;
item->pos.yPos += item->speed * phd_sin(-item->pos.xRot) >> W2V_SHIFT;
item->pos.zPos += ((item->speed * phd_cos(item->pos.xRot) >> W2V_SHIFT) * phd_cos(item->pos.yRot)) >> W2V_SHIFT;
item->pos.xPos += item->speed * phd_cos(item->pos.xRot) * phd_sin(item->pos.yRot);
item->pos.yPos += item->speed * phd_sin(-item->pos.xRot);
item->pos.zPos += item->speed * phd_cos(item->pos.xRot) * phd_cos(item->pos.yRot);
roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(item->pos.xPos, item->pos.yPos, item->pos.zPos, &roomNumber);
@ -1726,9 +1726,10 @@ void SomeSparkEffect(int x, int y, int z, int count)
spark->sLife = 24;
spark->transType = COLADD;
spark->friction = 5;
spark->xVel = -128 * phd_sin(GetRandomControl());
int random = GetRandomControl() & 0xFFF;
spark->xVel = -128 * phd_sin(random << 4);
spark->yVel = -640 - (byte)GetRandomControl();
spark->zVel = -128 * phd_cos(GetRandomControl());
spark->zVel = 128 * phd_cos(random << 4);
spark->flags = 0;
spark->x = x + (spark->xVel >> 3);
spark->y = y - (spark->yVel >> 5);

4
TR5Main/Game/Lara/lara_slide.cpp
View file

@ -137,8 +137,8 @@ void LaraSlideEdgeJump(ITEM_INFO* item, COLL_INFO* coll)//12B18, 12BC8 (F)
break;
case CT_CLAMP:
item->pos.zPos -= (400 * phd_cos(coll->facing)) >> W2V_SHIFT;
item->pos.xPos -= (400 * phd_sin(coll->facing)) >> W2V_SHIFT;
item->pos.zPos -= 400 * phd_cos(coll->facing);
item->pos.xPos -= 400 * phd_sin(coll->facing);
item->speed = 0;

6
TR5Main/Game/Lara/lara_swim.cpp
View file

@ -33,8 +33,8 @@ void LaraWaterCurrent(COLL_INFO* coll) // (F) (D)
OBJECT_VECTOR* sink = &FixedCameras[Lara.currentActive - 1];
short angle = mGetAngle(sink->x, sink->z, LaraItem->pos.xPos, LaraItem->pos.zPos);
Lara.currentXvel += ((sink->data * (phd_sin(angle - ANGLE(90)) / 4) >> 2) - Lara.currentXvel) >> 4;
Lara.currentZvel += ((sink->data * (phd_cos(angle - ANGLE(90)) / 4) >> 2) - Lara.currentZvel) >> 4;
Lara.currentXvel += (sink->data * 1024 * phd_sin(angle - ANGLE(90)) - Lara.currentXvel) / 16;
Lara.currentZvel += (sink->data * 1024 * phd_cos(angle - ANGLE(90)) - Lara.currentZvel) / 16;
LaraItem->pos.yPos += (sink->y - LaraItem->pos.yPos) >> 4;
}
@ -522,7 +522,7 @@ void LaraSwimCollision(ITEM_INFO* item, COLL_INFO* coll)//4B608, 4BA6C
coll->facing = item->pos.yRot;
}
short height = 762 * phd_sin(item->pos.xRot) >> W2V_SHIFT;
short height = 762 * phd_sin(item->pos.xRot);
height = abs(height);
if (height < ((LaraDrawType == LARA_DIVESUIT) << 6) + 200)

12
TR5Main/Game/Lara/lara_tests.cpp
View file

@ -958,8 +958,8 @@ int TestHangSwingIn(ITEM_INFO* item, short angle)//14104, 141B4 (F)
z += 256;
}*/
z += (phd_cos(angle) * STEP_SIZE) >> W2V_SHIFT;
x += (phd_sin(angle) * STEP_SIZE) >> W2V_SHIFT;
z += phd_cos(angle) * STEP_SIZE;
x += phd_sin(angle) * STEP_SIZE;
floor = GetFloor(x, y, z, &roomNum);
h = GetFloorHeight(floor, x, y, z);
@ -1177,9 +1177,9 @@ short LaraFloorFront(ITEM_INFO* item, short ang, int dist) // (F) (D)
{
short room = item->roomNumber;
int x = item->pos.xPos + ((dist * phd_sin(ang)) >> W2V_SHIFT);
int x = item->pos.xPos + dist * phd_sin(ang);
int y = item->pos.yPos - 762;
int z = item->pos.zPos + ((dist * phd_cos(ang)) >> W2V_SHIFT);
int z = item->pos.zPos + dist * phd_cos(ang);
int height = GetFloorHeight(GetFloor(x, y, z, &room), x, y, z);
@ -1193,9 +1193,9 @@ short LaraCeilingFront(ITEM_INFO* item, short ang, int dist, int h) // (F) (D)
{
short room = item->roomNumber;
int x = item->pos.xPos + ((dist * phd_sin(ang)) >> W2V_SHIFT);
int x = item->pos.xPos + dist * phd_sin(ang);
int y = item->pos.yPos - h;
int z = item->pos.zPos + ((dist * phd_cos(ang)) >> W2V_SHIFT);
int z = item->pos.zPos + dist * phd_cos(ang);
int height = GetCeiling(GetFloor(x, y, z, &room), x, y, z);

16
TR5Main/Game/box.cpp
View file

@ -1387,8 +1387,8 @@ void FindAITargetObject(CREATURE_INFO* creature, short objectNumber)
if (!(creature->aiTarget.flags & 0x20))
{
creature->aiTarget.pos.xPos += phd_sin(creature->aiTarget.pos.yRot) >> 4;
creature->aiTarget.pos.zPos += phd_cos(creature->aiTarget.pos.yRot) >> 4;
creature->aiTarget.pos.xPos += phd_sin(creature->aiTarget.pos.yRot) * 1024;
creature->aiTarget.pos.zPos += phd_cos(creature->aiTarget.pos.yRot) * 1024;
}
}
}
@ -1437,13 +1437,13 @@ void CreatureAIInfo(ITEM_INFO* item, AI_INFO* info)
if (enemy == LaraItem)
{
x = (enemy->pos.xPos + (enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_sin(LaraItem->pos.yRot + Lara.moveAngle) >> W2V_SHIFT)) - (item->pos.xPos + (obj->pivotLength * phd_sin(item->pos.yRot) >> W2V_SHIFT));
z = (enemy->pos.zPos + (enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_cos(LaraItem->pos.yRot + Lara.moveAngle) >> W2V_SHIFT)) - (item->pos.zPos + (obj->pivotLength * phd_cos(item->pos.yRot) >> W2V_SHIFT));
x = enemy->pos.xPos + enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_sin(LaraItem->pos.yRot + Lara.moveAngle) - item->pos.xPos + obj->pivotLength * phd_sin(item->pos.yRot);
z = enemy->pos.zPos + enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_cos(LaraItem->pos.yRot + Lara.moveAngle) - item->pos.zPos + obj->pivotLength * phd_cos(item->pos.yRot);
}
else
{
x = (enemy->pos.xPos + (enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_sin(enemy->pos.yRot) >> W2V_SHIFT)) - (item->pos.xPos + (obj->pivotLength * phd_sin(item->pos.yRot) >> W2V_SHIFT));
z = (enemy->pos.zPos + (enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_cos(enemy->pos.yRot) >> W2V_SHIFT)) - (item->pos.zPos + (obj->pivotLength * phd_cos(item->pos.yRot) >> W2V_SHIFT));
x = enemy->pos.xPos + enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_sin(enemy->pos.yRot) - item->pos.xPos + obj->pivotLength * phd_sin(item->pos.yRot);
z = enemy->pos.zPos + enemy->speed * PREDICTIVE_SCALE_FACTOR * phd_cos(enemy->pos.yRot) - item->pos.zPos + obj->pivotLength * phd_cos(item->pos.yRot);
}
y = item->pos.yPos - enemy->pos.yPos;
@ -1961,8 +1961,8 @@ void AdjustStopperFlag(ITEM_INFO* item, int dir, int set)
FLOOR_INFO* floor = &XZ_GET_SECTOR(r, x - r->x, z - r->z);
floor->stopper = set;
x = item->pos.xPos + ((1024 * phd_sin(dir)) >> W2V_SHIFT);
z = item->pos.zPos + ((1024 * phd_cos(dir)) >> W2V_SHIFT);
x = item->pos.xPos + 1024 * phd_sin(dir);
z = item->pos.zPos + 1024 * phd_cos(dir);
short roomNumber = item->roomNumber;
GetFloor(x, item->pos.yPos, z, &roomNumber);

40
TR5Main/Game/camera.cpp
View file

@ -340,9 +340,9 @@ void MoveCamera(GAME_VECTOR* ideal, int speed)
else
{
short angle = phd_atan(Camera.target.z - Camera.pos.z, Camera.target.x - Camera.pos.x);
Camera.mikePos.x = Camera.pos.x + (PhdPerspective * phd_sin(angle) >> W2V_SHIFT);
Camera.mikePos.x = Camera.pos.x + PhdPerspective * phd_sin(angle);
Camera.mikePos.y = Camera.pos.y;
Camera.mikePos.z = Camera.pos.z + (PhdPerspective * phd_cos(angle) >> W2V_SHIFT);
Camera.mikePos.z = Camera.pos.z + PhdPerspective * phd_cos(angle);
Camera.oldType = Camera.type;
}
}
@ -362,7 +362,7 @@ void ChaseCamera(ITEM_INFO* item)
else if (Camera.actualElevation < -ANGLE(85))
Camera.actualElevation = -ANGLE(85);
int distance = Camera.targetDistance * phd_cos(Camera.actualElevation) >> W2V_SHIFT;
int distance = Camera.targetDistance * phd_cos(Camera.actualElevation);
GetFloor(Camera.target.x, Camera.target.y, Camera.target.z, &Camera.target.roomNumber);
if (g_Level.Rooms[Camera.target.roomNumber].flags & ENV_FLAG_SWAMP)
@ -392,7 +392,7 @@ void ChaseCamera(ITEM_INFO* item)
for (int i = 0; i < 5; i++)
{
Ideals[i].y = Camera.target.y + (Camera.targetDistance * phd_sin(Camera.actualElevation) >> W2V_SHIFT);
Ideals[i].y = Camera.target.y + Camera.targetDistance * phd_sin(Camera.actualElevation);
}
int farthest = 0x7FFFFFFF;
@ -412,8 +412,8 @@ void ChaseCamera(ITEM_INFO* item)
angle = (i - 1) * ANGLE(90);
}
Ideals[i].x = Camera.target.x - ((distance * phd_sin(angle)) >> W2V_SHIFT);
Ideals[i].z = Camera.target.z - ((distance * phd_cos(angle)) >> W2V_SHIFT);
Ideals[i].x = Camera.target.x - distance * phd_sin(angle);
Ideals[i].z = Camera.target.z - distance * phd_cos(angle);
Ideals[i].roomNumber = Camera.target.roomNumber;
if (mgLOS(&Camera.target, &Ideals[i], 200))
@ -579,11 +579,11 @@ void CombatCamera(ITEM_INFO* item)
UpdateCameraElevation();
Camera.targetDistance = 1536;
int distance = Camera.targetDistance * phd_cos(Camera.actualElevation) >> W2V_SHIFT;
int distance = Camera.targetDistance * phd_cos(Camera.actualElevation);
for (int i = 0; i < 5; i++)
{
Ideals[i].y = Camera.target.y + (Camera.targetDistance * phd_sin(Camera.actualElevation) >> W2V_SHIFT);
Ideals[i].y = Camera.target.y + Camera.targetDistance * phd_sin(Camera.actualElevation);
}
int farthest = 0x7FFFFFFF;
@ -603,8 +603,8 @@ void CombatCamera(ITEM_INFO* item)
angle = (i - 1) * ANGLE(90);
}
Ideals[i].x = Camera.target.x - ((distance * phd_sin(angle)) >> W2V_SHIFT);
Ideals[i].z = Camera.target.z - ((distance * phd_cos(angle)) >> W2V_SHIFT);
Ideals[i].x = Camera.target.x - distance * phd_sin(angle);
Ideals[i].z = Camera.target.z - distance * phd_cos(angle);
Ideals[i].roomNumber = Camera.target.roomNumber;
if (mgLOS(&Camera.target, &Ideals[i], 200))
@ -1119,8 +1119,8 @@ void LookCamera(ITEM_INFO* item)
else
{
Camera.actualAngle = phd_atan(Camera.target.z - Camera.pos.z, Camera.target.x - Camera.pos.x);
Camera.mikePos.x = Camera.pos.x + ((PhdPerspective * phd_sin(Camera.actualAngle)) >> W2V_SHIFT);
Camera.mikePos.z = Camera.pos.z + ((PhdPerspective * phd_cos(Camera.actualAngle)) >> W2V_SHIFT);
Camera.mikePos.x = Camera.pos.x + PhdPerspective * phd_sin(Camera.actualAngle);
Camera.mikePos.z = Camera.pos.z + PhdPerspective * phd_cos(Camera.actualAngle);
Camera.mikePos.y = Camera.pos.y;
}
@ -1214,11 +1214,11 @@ void BinocularCamera(ITEM_INFO* item)
Camera.pos.z = z;
Camera.pos.roomNumber = roomNumber;
int l = 20736 * phd_cos(headXrot) >> W2V_SHIFT;
int l = 20736 * phd_cos(headXrot);
int tx = x + (l * phd_sin(LaraItem->pos.yRot + headYrot) >> W2V_SHIFT);
int ty = y - (20736 * phd_sin(headXrot) >> W2V_SHIFT);
int tz = z + (l * phd_cos(LaraItem->pos.yRot + headYrot) >> W2V_SHIFT);
int tx = x + l * phd_sin(LaraItem->pos.yRot + headYrot);
int ty = y - 20736 * phd_sin(headXrot);
int tz = z + l * phd_cos(LaraItem->pos.yRot + headYrot);
if (Camera.oldType == FIXED_CAMERA)
{
@ -1264,8 +1264,8 @@ void BinocularCamera(ITEM_INFO* item)
else
{
Camera.actualAngle = phd_atan(Camera.target.z - Camera.pos.z, Camera.target.x - Camera.pos.x);
Camera.mikePos.x = Camera.pos.x + ((PhdPerspective * phd_sin(Camera.actualAngle)) >> W2V_SHIFT);
Camera.mikePos.z = Camera.pos.z + ((PhdPerspective * phd_cos(Camera.actualAngle)) >> W2V_SHIFT);
Camera.mikePos.x = Camera.pos.x + PhdPerspective * phd_sin(Camera.actualAngle);
Camera.mikePos.z = Camera.pos.z + PhdPerspective * phd_cos(Camera.actualAngle);
Camera.mikePos.y = Camera.pos.y;
}
@ -1694,8 +1694,8 @@ void CalculateCamera()
else
{
int shift = (bounds->X1 + bounds->X2 + bounds->Z1 + bounds->Z2) / 4;
x = item->pos.xPos + (shift * phd_sin(item->pos.yRot) >> W2V_SHIFT);
z = item->pos.zPos + (shift * phd_cos(item->pos.yRot) >> W2V_SHIFT);
x = item->pos.xPos + shift * phd_sin(item->pos.yRot);
z = item->pos.zPos + shift * phd_cos(item->pos.yRot);
Camera.target.x = x;
Camera.target.z = z;

77
TR5Main/Game/collide.cpp
View file

@ -133,7 +133,7 @@ int GetCollidedObjects(ITEM_INFO* collidingItem, int radius, int onlyVisible, IT
short roomsArray[255];
short numRooms;
short numItems = 0, numMeshes = 0;
int c, s;
float c, s;
int rx, rz;
// Collect all the rooms where to check
@ -158,8 +158,8 @@ int GetCollidedObjects(ITEM_INFO* collidingItem, int radius, int onlyVisible, IT
{
s = phd_sin(mesh->yRot);
c = phd_cos(mesh->yRot);
rx = ((collidingItem->pos.xPos - mesh->x) * c - s * (collidingItem->pos.zPos - mesh->z)) >> W2V_SHIFT;
rz = ((collidingItem->pos.zPos - mesh->z) * c + s * (collidingItem->pos.xPos - mesh->x)) >> W2V_SHIFT;
rx = (collidingItem->pos.xPos - mesh->x) * c - s * (collidingItem->pos.zPos - mesh->z);
rz = (collidingItem->pos.zPos - mesh->z) * c + s * (collidingItem->pos.xPos - mesh->x);
if (radius + rx + STEP_SIZE/2 >= staticMesh->collisionBox.X1 && rx - radius - STEP_SIZE/2 <= staticMesh->collisionBox.X2)
{
@ -231,11 +231,11 @@ int GetCollidedObjects(ITEM_INFO* collidingItem, int radius, int onlyVisible, IT
&& collidingItem->pos.yPos + radius + 128 >= item->pos.yPos + framePtr->boundingBox.Y1
&& collidingItem->pos.yPos - radius - 128 <= item->pos.yPos + framePtr->boundingBox.Y2)
{
int s = phd_sin(item->pos.yRot);
int c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
int rx = (dx * c - s * dz) >> W2V_SHIFT;
int rz = (dz * c + s * dx) >> W2V_SHIFT;
int rx = dx * c - s * dz;
int rz = dz * c + s * dx;
if (item->objectNumber == ID_TURN_SWITCH)
{
@ -280,14 +280,14 @@ int TestWithGlobalCollisionBounds(ITEM_INFO* item, ITEM_INFO* lara, COLL_INFO* c
if (item->pos.yPos + GlobalCollisionBounds.Y1 >= framePtr->boundingBox.Y2)
return false;
int s = phd_sin(item->pos.yRot);
int c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
int dx = lara->pos.xPos - item->pos.xPos;
int dz = lara->pos.zPos - item->pos.zPos;
int x = (c * dx - s * dz) >> W2V_SHIFT;
int z = (c * dz + s * dx) >> W2V_SHIFT;
int x = c * dx - s * dz;
int z = c * dz + s * dx;
if (x < GlobalCollisionBounds.X1 - coll->radius ||
x > GlobalCollisionBounds.X2 + coll->radius ||
@ -326,11 +326,10 @@ void TestForObjectOnLedge(ITEM_INFO* item, COLL_INFO* coll)//2A940(<), 2AB68(<)
s.roomNumber = LaraItem->roomNumber;
GAME_VECTOR d;
d.x = 0;
d.x = (s.x + ((phd_sin(LaraItem->pos.yRot) << 1) + phd_sin(LaraItem->pos.yRot))) >> 4;
d.x = s.x + phd_sin(LaraItem->pos.yRot) * 768;
d.y = s.y;
d.z = (s.z + ((phd_cos(LaraItem->pos.yRot) << 1) + phd_cos(LaraItem->pos.yRot))) >> 4;
d.z = s.z + phd_cos(LaraItem->pos.yRot) * 768;
LOS(&s, &d);
PHD_VECTOR v;
@ -465,15 +464,15 @@ int TestBoundsCollideStatic(BOUNDING_BOX* bounds, PHD_3DPOS* pos, int radius)
if (pos->yPos + bounds->Y1 >= LaraItem->pos.yPos + frame->boundingBox.Y2)
return false;
int c, s;
float c, s;
int x, z, dx, dz;
c = phd_cos(pos->yRot);
s = phd_sin(pos->yRot);
x = LaraItem->pos.xPos - pos->xPos;
z = LaraItem->pos.zPos - pos->zPos;
dx = (c * x - s * z) >> W2V_SHIFT;
dz = (c * z + s * x) >> W2V_SHIFT;
dx = c * x - s * z;
dz = c * z + s * x;
if (dx <= radius + bounds->X2
&& dx >= bounds->X1 - radius
@ -490,7 +489,7 @@ int TestBoundsCollideStatic(BOUNDING_BOX* bounds, PHD_3DPOS* pos, int radius)
int ItemPushLaraStatic(ITEM_INFO* item, BOUNDING_BOX* bounds, PHD_3DPOS* pos, COLL_INFO* coll)
{
int c, s;
float c, s;
int dx, dz, rx, rz, minX, maxX, minZ, maxZ;
int left, right, top, bottom;
short oldFacing;
@ -499,8 +498,8 @@ int ItemPushLaraStatic(ITEM_INFO* item, BOUNDING_BOX* bounds, PHD_3DPOS* pos, CO
s = phd_sin(pos->yRot);
dx = LaraItem->pos.xPos - pos->xPos;
dz = LaraItem->pos.zPos - pos->zPos;
rx = (c * dx - s * dz) >> W2V_SHIFT;
rz = (c * dz + s * dx) >> W2V_SHIFT;
rx = c * dx - s * dz;
rz = c * dz + s * dx;
minX = bounds->X1 - coll->radius;
maxX = bounds->X2 + coll->radius;
minZ = bounds->Z1 - coll->radius;
@ -528,8 +527,8 @@ int ItemPushLaraStatic(ITEM_INFO* item, BOUNDING_BOX* bounds, PHD_3DPOS* pos, CO
else
rz -= bottom;
item->pos.xPos = pos->xPos + ((c * rx + s * rz) >> W2V_SHIFT);
item->pos.zPos = pos->zPos + ((c * rz - s * rx) >> W2V_SHIFT);
item->pos.xPos = pos->xPos + c * rx + s * rz;
item->pos.zPos = pos->zPos + c * rz - s * rx;
coll->badPos = NO_BAD_POS;
coll->badNeg = -STEPUP_HEIGHT;
@ -565,7 +564,7 @@ int ItemPushLaraStatic(ITEM_INFO* item, BOUNDING_BOX* bounds, PHD_3DPOS* pos, CO
int ItemPushLara(ITEM_INFO* item, ITEM_INFO* l, COLL_INFO* coll, int spazon, char bigpush)
{
int c, s;
float c, s;
int dx, dz, rx, rz, minX, maxX, minZ, maxZ;
int left, right, bottom, top;
BOUNDING_BOX* bounds;
@ -575,8 +574,8 @@ int ItemPushLara(ITEM_INFO* item, ITEM_INFO* l, COLL_INFO* coll, int spazon, cha
s = phd_sin(item->pos.yRot);
dx = LaraItem->pos.xPos - item->pos.xPos;
dz = LaraItem->pos.zPos - item->pos.zPos;
rx = (c * dx - s * dz) >> W2V_SHIFT;
rz = (c * dz + s * dx) >> W2V_SHIFT;
rx = c * dx - s * dz;
rz = c * dz + s * dx;
if (bigpush & 2)
bounds = &GlobalCollisionBounds;
@ -619,16 +618,16 @@ int ItemPushLara(ITEM_INFO* item, ITEM_INFO* l, COLL_INFO* coll, int spazon, cha
else
rz -= bottom;
l->pos.xPos = item->pos.xPos + ((c * rx + s * rz) >> W2V_SHIFT);
l->pos.zPos = item->pos.zPos + ((c * rz - s * rx) >> W2V_SHIFT);
l->pos.xPos = item->pos.xPos + c * rx + s * rz;
l->pos.zPos = item->pos.zPos + c * rz - s * rx;
if (spazon && bounds->Y2 - bounds->Y1 > STEP_SIZE)
{
rx = (bounds->X1 + bounds->X2) / 2;
rz = (bounds->Z1 + bounds->Z2) / 2;
dx -= (c * rx + s * rz) >> W2V_SHIFT;
dz -= (c * rz - s * rx) >> W2V_SHIFT;
dx -= c * rx + s * rz;
dz -= c * rz - s * rx;
Lara.hitDirection = (l->pos.yRot - phd_atan(dz, dz) - ANGLE(135)) >> W2V_SHIFT;
@ -959,7 +958,7 @@ int TestBoundsCollide(ITEM_INFO* item, ITEM_INFO* l, int radius)
{
BOUNDING_BOX* bounds;
BOUNDING_BOX* laraBounds;
int c, s;
float c, s;
int x, z;
int dx, dz;
@ -974,8 +973,8 @@ int TestBoundsCollide(ITEM_INFO* item, ITEM_INFO* l, int radius)
s = phd_sin(item->pos.yRot);
x = l->pos.xPos - item->pos.xPos;
z = l->pos.zPos - item->pos.zPos;
dx = (c * x - s * z) >> W2V_SHIFT;
dz = (c * z + s * x) >> W2V_SHIFT;
dx = c * x - s * z;
dz = c * z + s * x;
if (dx >= bounds->X1 - radius
&& dx <= radius + bounds->X2
@ -993,7 +992,7 @@ int TestBoundsCollide(ITEM_INFO* item, ITEM_INFO* l, int radius)
void CreatureCollision(short itemNum, ITEM_INFO* l, COLL_INFO* coll)
{
ITEM_INFO* item = &g_Level.Items[itemNum];
int c, s;
float c, s;
int x, z, rx, rz;
ANIM_FRAME* frame;
@ -1019,7 +1018,7 @@ void CreatureCollision(short itemNum, ITEM_INFO* l, COLL_INFO* coll)
if (frame->boundingBox.Y2 - frame->boundingBox.Y1 > STEP_SIZE)
{
int angle = (l->pos.yRot - phd_atan(z - ((c * rx - s * rz) >> W2V_SHIFT), x - ((c * rx + s * rz) >> W2V_SHIFT)) - ANGLE(135)) >> W2V_SHIFT;
int angle = (l->pos.yRot - phd_atan(z - c * rx - s * rz, x - c * rx + s * rz) - ANGLE(135)) >> W2V_SHIFT;
Lara.hitDirection = (short)angle;
// TODO: check if a second Lara.hitFrame++; is required there !
Lara.hitFrame++;
@ -1127,8 +1126,8 @@ void GetCollisionInfo(COLL_INFO* coll, int xPos, int yPos, int zPos, int roomNum
break;
}*/
XFront = (phd_sin(coll->facing) * coll->radius) >> (W2V_SHIFT);
ZFront = (phd_cos(coll->facing) * coll->radius) >> (W2V_SHIFT);
XFront = phd_sin(coll->facing) * coll->radius;
ZFront = phd_cos(coll->facing) * coll->radius;
xleft = -ZFront;
zleft = XFront;
xright = ZFront;
@ -1620,8 +1619,8 @@ void CalcItemToFloorRotation(ITEM_INFO* item, int radiusDivide)
radiusZ = bounds->Z2 / radiusDivide; // need divide in any case else it's too much !
ratioXZ = radiusZ / radiusX;
frontX = (phd_sin(item->pos.yRot) * radiusZ) >> W2V_SHIFT;
frontZ = (phd_cos(item->pos.yRot) * radiusZ) >> W2V_SHIFT;
frontX = phd_sin(item->pos.yRot) * radiusZ;
frontZ = phd_cos(item->pos.yRot) * radiusZ;
leftX = -frontZ * ratioXZ;
leftZ = frontX * ratioXZ;
rightX = frontZ * ratioXZ;

16
TR5Main/Game/control.cpp
View file

@ -1346,12 +1346,12 @@ short GetDoor(FLOOR_INFO *floor)
void TranslateItem(ITEM_INFO *item, int x, int y, int z)
{
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
item->pos.xPos += (c * x + s * z) >> W2V_SHIFT;
item->pos.xPos += c * x + s * z;
item->pos.yPos += y;
item->pos.zPos += (-s * x + c * z) >> W2V_SHIFT;
item->pos.zPos += -s * x + c * z;
}
int GetWaterSurface(int x, int y, int z, short roomNumber)
@ -2958,11 +2958,11 @@ void AnimateItem(ITEM_INFO *item)
lateral >>= 16;
}
item->pos.xPos += item->speed * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.zPos += item->speed * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos += item->speed * phd_sin(item->pos.yRot);
item->pos.zPos += item->speed * phd_cos(item->pos.yRot);
item->pos.xPos += lateral * phd_sin(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
item->pos.zPos += lateral * phd_cos(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
item->pos.xPos += lateral * phd_sin(item->pos.yRot + ANGLE(90));
item->pos.zPos += lateral * phd_cos(item->pos.yRot + ANGLE(90));
// Update matrices
short itemNumber = item - g_Level.Items.data();

4
TR5Main/Game/effect.cpp
View file

@ -327,8 +327,8 @@ void ControlWaterfallMist(short itemNumber) // ControlWaterfallMist
ITEM_INFO* item = &g_Level.Items[itemNumber];
int x, z;
x = item->pos.xPos - (phd_sin(item->pos.yRot + ANGLE(180)) >> 5) + ((phd_sin(item->pos.yRot - ANGLE(90)) * 256) >> W2V_SHIFT);
z = item->pos.zPos - (phd_cos(item->pos.yRot + ANGLE(180)) >> 5) + ((phd_cos(item->pos.yRot - ANGLE(90)) * 256) >> W2V_SHIFT);
x = item->pos.xPos - phd_sin(item->pos.yRot + ANGLE(180)) * 512 + phd_sin(item->pos.yRot - ANGLE(90)) * 256;
z = item->pos.zPos - phd_cos(item->pos.yRot + ANGLE(180)) * 512 + phd_cos(item->pos.yRot - ANGLE(90)) * 256;
TriggerWaterfallMist(x, item->pos.yPos, z, item->pos.yRot + ANGLE(180));
SoundEffect(SFX_WATERFALL_LOOP, &item->pos, 0);

8
TR5Main/Game/effect2.cpp
View file

@ -1083,9 +1083,9 @@ void TriggerWaterfallMist(int x, int y, int z, int angle)
spark->life = spark->sLife = (GetRandomControl() & 3) + 6;
spark->fadeToBlack = spark->life - 4;
dl = ((dh + (GlobalCounter << 6)) % 1536) + (GetRandomControl() & 0x3F) - 32;
spark->x = dl * phd_sin(ang1) >> W2V_SHIFT + (GetRandomControl() & 0xF) + x - 8;
spark->x = dl * phd_sin(ang1) + (GetRandomControl() & 0xF) + x - 8;
spark->y = (GetRandomControl() & 0xF) + y - 8;
spark->z = dl * phd_cos(ang1) >> W2V_SHIFT + (GetRandomControl() & 0xF) + z - 8;
spark->z = dl * phd_cos(ang1) + (GetRandomControl() & 0xF) + z - 8;
spark->xVel = 0;
spark->zVel = 0;
spark->friction = 0;
@ -1117,11 +1117,11 @@ void TriggerWaterfallMist(int x, int y, int z, int angle)
spark->life = spark->sLife = (GetRandomControl() & 3) + 6;
spark->fadeToBlack = spark->life - 1;
dl = GetRandomControl() % 1408 + 64;
spark->x = dl * phd_sin(ang1) >> W2V_SHIFT + (GetRandomControl() & 0x1F) + x - 16;
spark->x = dl * phd_sin(ang1) + (GetRandomControl() & 0x1F) + x - 16;
spark->y = (GetRandomControl() & 0xF) + y - 8;
spark->xVel = 0;
spark->zVel = 0;
spark->z = dl * phd_cos(ang1) >> W2V_SHIFT + (GetRandomControl() & 0x1F) + z - 16;
spark->z = dl * phd_cos(ang1) + (GetRandomControl() & 0x1F) + z - 16;
spark->friction = 0;
spark->flags = 10;
spark->yVel = GetRandomControl() & 0x100 + (GetRandomControl() & 0x7F) + 128;

4
TR5Main/Game/flmtorch.cpp
View file

@ -203,8 +203,8 @@ void TorchControl(short itemNumber) // (F) (D)
item->pos.zRot = 0;
}
int xv = item->speed * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int zv = item->speed * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int xv = item->speed * phd_sin(item->pos.yRot);
int zv = item->speed * phd_cos(item->pos.yRot);
item->pos.xPos += xv;
item->pos.zPos += zv;

4
TR5Main/Game/hair.cpp
View file

@ -225,8 +225,8 @@ void HairControl(int cutscene, int ponytail, ANIM_FRAME* framePtr)
WindAngle = (WindAngle + ((DWindAngle - WindAngle) >> 3)) & 0x1FFE;
SmokeWindX = Wind * phd_sin(WindAngle << 3) >> 14;
SmokeWindZ = Wind * phd_cos(WindAngle << 3) >> 14;
SmokeWindX = Wind * phd_sin(WindAngle << 3);
SmokeWindZ = Wind * phd_cos(WindAngle << 3);
for (int i = 1; i < HAIR_SEGMENTS + 1; i++, bone += 4)
{

12
TR5Main/Game/missile.cpp
View file

@ -51,10 +51,10 @@ void ControlMissile(short fxNumber)
if (fx->objectNumber == ID_SCUBA_HARPOON && !(g_Level.Rooms[fx->roomNumber].flags & 1) && fx->pos.xRot > -0x3000)
fx->pos.xRot -= ONE_DEGREE;
fx->pos.yPos += (fx->speed * phd_sin(-fx->pos.xRot) >> W2V_SHIFT);
speed = fx->speed * phd_cos(fx->pos.xRot) >> W2V_SHIFT;
fx->pos.zPos += (speed * phd_cos(fx->pos.yRot) >> W2V_SHIFT);
fx->pos.xPos += (speed * phd_sin(fx->pos.yRot) >> W2V_SHIFT);
fx->pos.yPos += fx->speed * phd_sin(-fx->pos.xRot);
speed = fx->speed * phd_cos(fx->pos.xRot);
fx->pos.zPos += speed * phd_cos(fx->pos.yRot);
fx->pos.xPos += speed * phd_sin(fx->pos.yRot);
roomNumber = fx->roomNumber;
floor = GetFloor(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos, &roomNumber);
@ -144,8 +144,8 @@ void ControlNatlaGun(short fx_number)
/* If first frame, then start another explosion at next position */
if (fx->frameNumber == -1)
{
z = fx->pos.zPos + (fx->speed * phd_cos(fx->pos.yRot) >> W2V_SHIFT);
x = fx->pos.xPos + (fx->speed * phd_sin(fx->pos.yRot) >> W2V_SHIFT);
z = fx->pos.zPos + fx->speed * phd_cos(fx->pos.yRot);
x = fx->pos.xPos + fx->speed * phd_sin(fx->pos.yRot);
y = fx->pos.yPos;
roomNumber = fx->roomNumber;
floor = GetFloor(x, y, z, &roomNumber);

2
TR5Main/Game/people.cpp
View file

@ -19,7 +19,7 @@ int ShotLara(ITEM_INFO* item, AI_INFO* info, BITE_INFO* gun, short extra_rotatio
if (info->distance <= SQUARE(8192) && Targetable(item, info))
{
int distance = phd_sin(info->enemyFacing) * enemy->speed >> W2V_SHIFT * SQUARE(8192) / 300;
int distance = phd_sin(info->enemyFacing) * enemy->speed * SQUARE(8192) / 300;
distance = info->distance + SQUARE(distance);
if (distance <= SQUARE(8192))
{

12
TR5Main/Game/rope.cpp
View file

@ -178,7 +178,7 @@ void RopeCollision(short itemNumber, ITEM_INFO* l, COLL_INFO* coll) // (F) (D)
if (TrInput & IN_ACTION && Lara.gunStatus == LG_NO_ARMS && (l->currentAnimState == LS_REACH || l->currentAnimState == LS_JUMP_UP) && l->gravityStatus && l->fallspeed > 0 && rope->active)
{
frame = GetBoundsAccurate(l);
segment = _0x0046D200(rope, l->pos.xPos, l->pos.yPos + frame->Y1 + 512, l->pos.zPos + ((int)(frame->Z2 * phd_cos(l->pos.yRot)) >> W2V_SHIFT), l->currentAnimState == LS_REACH ? 128 : 320);
segment = _0x0046D200(rope, l->pos.xPos, l->pos.yPos + frame->Y1 + 512, l->pos.zPos + frame->Z2 * phd_cos(l->pos.yRot), l->currentAnimState == LS_REACH ? 128 : 320);
if (segment >= 0)
{
if (l->currentAnimState == LS_REACH)
@ -390,9 +390,9 @@ int _0x0046D200(ROPE_STRUCT* rope, int x, int y, int z, int radius) // (F) (D)
void ApplyVelocityToRope(int node, short angle, short n) // (F) (D)
{
SetPendulumVelocity(
(unsigned short) n * phd_sin(angle) >> 2,
(unsigned short) n * phd_sin(angle) * 4096,
0,
(unsigned short) n * phd_cos(angle) >> 2); /* @ORIGINAL_BUG: casting n to unsigned short results in the rope glitch */
(unsigned short) n * phd_cos(angle) * 4096); /* @ORIGINAL_BUG: casting n to unsigned short results in the rope glitch */
}
void SetPendulumVelocity(int x, int y, int z) // (F) (D)
@ -702,11 +702,11 @@ void DelAlignLaraToRope(ITEM_INFO* item) // (F) (D)
diff2.x = diff.x;
diff2.y = diff.y;
diff2.z = diff.z;
ScaleVector(&vec3, phd_cos(ropeY), &vec3);
ScaleVector(&vec3, 16384 * phd_cos(ropeY), &vec3);
ScaleVector(&diff2, DotProduct(&diff2, &vec2), &diff2);
ScaleVector(&diff2, 4096 - phd_cos(ropeY), &diff2);
ScaleVector(&diff2, 4096 - 16384 * phd_cos(ropeY), &diff2);
CrossProduct(&diff, &vec2, &vec4);
ScaleVector(&vec4, phd_sin(ropeY), &vec4);
ScaleVector(&vec4, 16384 * phd_sin(ropeY), &vec4);
diff2.x += vec3.x;
diff2.y += vec3.y;
diff2.z += vec3.z;

16
TR5Main/Game/switch.cpp
View file

@ -584,8 +584,8 @@ void TurnSwitchCollision(short itemNum, ITEM_INFO* l, COLL_INFO* coll)
item->animNumber = Objects[item->objectNumber].animIndex + 4;
item->frameNumber = g_Level.Anims[item->animNumber].frameBase;
item->itemFlags[0] = 1;
ForcedFixedCamera.x = item->pos.xPos - (1024 * phd_sin(item->pos.yRot) >> W2V_SHIFT);
ForcedFixedCamera.z = item->pos.zPos - (1024 * phd_cos(item->pos.yRot) >> W2V_SHIFT);
ForcedFixedCamera.x = item->pos.xPos - 1024 * phd_sin(item->pos.yRot);
ForcedFixedCamera.z = item->pos.zPos - 1024 * phd_cos(item->pos.yRot);
Lara.isMoving = 0;
Lara.headYrot = 0;
Lara.headXrot = 0;
@ -626,8 +626,8 @@ void TurnSwitchCollision(short itemNum, ITEM_INFO* l, COLL_INFO* coll)
flag = 1;
l->frameNumber = g_Level.Anims[319].frameBase;
item->itemFlags[0] = 2;
ForcedFixedCamera.x = item->pos.xPos + (1024 * phd_sin(item->pos.yRot) >> W2V_SHIFT);
ForcedFixedCamera.z = item->pos.zPos + (1024 * phd_cos(item->pos.yRot) >> W2V_SHIFT);
ForcedFixedCamera.x = item->pos.xPos + 1024 * phd_sin(item->pos.yRot);
ForcedFixedCamera.z = item->pos.zPos + 1024 * phd_cos(item->pos.yRot);
}
else
{
@ -854,9 +854,9 @@ void UnderwaterSwitchCollision(short itemNum, ITEM_INFO* l, COLL_INFO* coll)
AddActiveItem(itemNum);
ForcedFixedCamera.x = item->pos.xPos - 1024 * phd_sin(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
ForcedFixedCamera.x = item->pos.xPos - 1024 * phd_sin(item->pos.yRot + ANGLE(90));
ForcedFixedCamera.y = item->pos.yPos - 1024;
ForcedFixedCamera.z = item->pos.zPos - 1024 * phd_cos(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
ForcedFixedCamera.z = item->pos.zPos - 1024 * phd_cos(item->pos.yRot + ANGLE(90));
ForcedFixedCamera.roomNumber = item->roomNumber;
return;
@ -885,9 +885,9 @@ void UnderwaterSwitchCollision(short itemNum, ITEM_INFO* l, COLL_INFO* coll)
AddActiveItem(itemNum);
ForcedFixedCamera.x = item->pos.xPos - 1024 * phd_sin(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
ForcedFixedCamera.x = item->pos.xPos - 1024 * phd_sin(item->pos.yRot + ANGLE(90));
ForcedFixedCamera.y = item->pos.yPos - 1024;
ForcedFixedCamera.z = item->pos.zPos - 1024 * phd_cos(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
ForcedFixedCamera.z = item->pos.zPos - 1024 * phd_cos(item->pos.yRot + ANGLE(90));
ForcedFixedCamera.roomNumber = item->roomNumber;
}
}

24
TR5Main/Game/tomb4fx.cpp
View file

@ -684,8 +684,8 @@ void TriggerBlood(int x, int y, int z, int unk, int num)// (F)
blood->z = (GetRandomControl() & 0x1F) + z - 16;
int a = (unk == -1 ? GetRandomControl() : (GetRandomControl() & 0x1F) + unk - 16) & 0xFFF;
int b = GetRandomControl() & 0xF;
blood->zVel = b * phd_cos(a << 4) >> 9;
blood->xVel = -b * phd_sin(a << 4) >> 9;
blood->zVel = b * phd_cos(a << 4) * 32;
blood->xVel = -b * phd_sin(a << 4) * 32;
blood->friction = 4;
blood->yVel = -((GetRandomControl() & 0xFF) + 128);
blood->rotAng = GetRandomControl() & 0xFFF;
@ -949,9 +949,9 @@ void UpdateGunShells()
gs->pos.yRot += gs->speed * ANGLE(1);
gs->pos.zRot += ANGLE(23);
gs->pos.xPos += gs->speed * phd_sin(gs->dirXrot) >> W2V_SHIFT;
gs->pos.xPos += gs->speed * phd_sin(gs->dirXrot);
gs->pos.yPos += gs->fallspeed;
gs->pos.zPos += gs->speed * phd_cos(gs->dirXrot) >> W2V_SHIFT;
gs->pos.zPos += gs->speed * phd_cos(gs->dirXrot);
FLOOR_INFO* floor = GetFloor(gs->pos.xPos, gs->pos.yPos, gs->pos.zPos, &gs->roomNumber);
if (g_Level.Rooms[gs->roomNumber].flags & ENV_FLAG_WATER
@ -1028,9 +1028,9 @@ void AddWaterSparks(int x, int y, int z, int num)
spark->sLife = 24;
spark->transType = COLADD;
int random = GetRandomControl() & 0xFFF;
spark->xVel = -phd_sin(random << 4) >> 7;
spark->xVel = -phd_sin(random << 4) * 128;
spark->yVel = -640 - GetRandomControl();
spark->zVel = phd_cos(random << 4) >> 7;
spark->zVel = phd_cos(random << 4) * 128;
spark->friction = 5;
spark->flags = SP_NONE;
spark->x = x + (spark->xVel >> 3);
@ -1374,9 +1374,9 @@ void TriggerShockwaveHitEffect(int x, int y, int z, byte r, byte g, byte b, shor
spark->life = spark->sLife = (GetRandomControl() & 3) + 16;
int speed = (GetRandomControl() & 0xF) + vel;
spark->xVel = speed * 16 * phd_sin(rot) >> W2V_SHIFT;
spark->xVel = speed * 16 * phd_sin(rot);
spark->yVel = -512 - (GetRandomControl() & 0x1FF);
spark->zVel = speed * 16 * phd_cos(rot) >> W2V_SHIFT;
spark->zVel = speed * 16 * phd_cos(rot);
short angle;
if (GetRandomControl() & 1)
@ -1385,8 +1385,8 @@ void TriggerShockwaveHitEffect(int x, int y, int z, byte r, byte g, byte b, shor
angle = rot - ANGLE(90);
int shift = (GetRandomControl() & 0x1FF) - 256;
x += (shift * phd_sin(angle) >> W2V_SHIFT);
z += (shift * phd_cos(angle) >> W2V_SHIFT);
x += shift * phd_sin(angle);
z += shift * phd_cos(angle);
spark->x = (GetRandomControl() & 0x1F) + x - 16;
spark->y = (GetRandomControl() & 0x1F) + y - 16;
@ -1689,9 +1689,9 @@ void TriggerSmallSplash(int x, int y, int z, int num)
angle = GetRandomControl() << 3;
sptr->xVel = -phd_sin(angle) >> 5;
sptr->xVel = -phd_sin(angle) * 512;
sptr->yVel = -640 - (GetRandomControl() & 0xFF);
sptr->zVel = phd_cos(angle) >> 5;
sptr->zVel = phd_cos(angle) * 512;
sptr->friction = 5;
sptr->flags = 0;

4
TR5Main/Game/traps.cpp
View file

@ -917,9 +917,9 @@ void FlameEmitter3Control(short itemNumber)
{
if (item->triggerFlags == 2 || item->triggerFlags == 4)
{
dest.x = item->pos.xPos + 2048 * phd_sin(item->pos.yRot - ANGLE(180)) >> W2V_SHIFT;
dest.x = item->pos.xPos + 2048 * phd_sin(item->pos.yRot + ANGLE(180));
dest.y = item->pos.yPos;
dest.z = item->pos.zPos + 2048 * phd_cos(item->pos.yRot - ANGLE(180)) >> W2V_SHIFT;
dest.z = item->pos.zPos + 2048 * phd_cos(item->pos.yRot + ANGLE(180));
if (GetRandomControl() & 3)
{

9
TR5Main/Game/trmath.cpp
View file

@ -323,15 +323,14 @@ const Vector3 getRandomVectorInCone(const Vector3& direction, const float angleD
return result;
}
// FIXME: game code still expects << 2 >> W2V_SHIFT so we multiply by 16384.0f
int phd_sin(short a)
float phd_sin(short a)
{
return (sin(TO_RAD(a)) * 16384.0f);
return sin(TO_RAD(a));
}
int phd_cos(short a)
float phd_cos(short a)
{
return (cos(TO_RAD(a)) * 16384.0f);
return cos(TO_RAD(a));
}
int mGetAngle(int x1, int y1, int x2, int y2)

4
TR5Main/Game/trmath.h
View file

@ -36,8 +36,8 @@ short ANGLE(float angle);
float TO_DEGREES(short angle);
float TO_RAD(short angle);
int phd_sin(short a);
int phd_cos(short a);
float phd_sin(short a);
float phd_cos(short a);
// returns a float between 0-1
const float frand();

8
TR5Main/Objects/Effects/tr4_bubbles.cpp
View file

@ -270,10 +270,10 @@ void BubblesControl(short fxNum)
int oldY = fx->pos.yPos;
int oldZ = fx->pos.zPos;
int c = fx->speed * phd_cos(fx->pos.xRot) >> W2V_SHIFT;
fx->pos.xPos += c * phd_sin(fx->pos.yRot) >> W2V_SHIFT;
fx->pos.yPos += fx->speed * phd_sin(-fx->pos.xRot) >> W2V_SHIFT;
fx->pos.zPos += c * phd_cos(fx->pos.yRot) >> W2V_SHIFT;
int c = fx->speed * phd_cos(fx->pos.xRot);
fx->pos.xPos += c * phd_sin(fx->pos.yRot);
fx->pos.yPos += fx->speed * phd_sin(-fx->pos.xRot);
fx->pos.zPos += c * phd_cos(fx->pos.yRot);
short roomNumber = fx->roomNumber;
FLOOR_INFO* floor = GetFloor(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos, &roomNumber);

6
TR5Main/Objects/Effects/tr4_locusts.cpp
View file

@ -207,9 +207,9 @@ void UpdateLocusts(void)
locust->pos.xRot += shiftXrot;
}
locust->pos.xPos += (locust->randomRotation * phd_cos(locust->pos.xRot) >> W2V_SHIFT) * phd_sin(locust->pos.yRot) >> W2V_SHIFT;
locust->pos.yPos += locust->randomRotation * phd_sin(-locust->pos.xRot) >> W2V_SHIFT;
locust->pos.zPos += (locust->randomRotation * phd_cos(locust->pos.xRot) >> W2V_SHIFT) * phd_cos(locust->pos.yRot) >> W2V_SHIFT;
locust->pos.xPos += locust->randomRotation * phd_cos(locust->pos.xRot) * phd_sin(locust->pos.yRot);
locust->pos.yPos += locust->randomRotation * phd_sin(-locust->pos.xRot);
locust->pos.zPos += locust->randomRotation * phd_cos(locust->pos.xRot) * phd_cos(locust->pos.yRot);
if (ItemNearTarget(&locust->pos, locust->target, CLICK(1) / 2))
{
TriggerBlood(locust->pos.xPos, locust->pos.yPos, locust->pos.zPos, 2 * GetRandomControl(), 2);

8
TR5Main/Objects/Generic/Object/generic_trapdoor.cpp
View file

@ -55,9 +55,9 @@ void CeilingTrapDoorCollision(short itemNumber, ITEM_INFO* l, COLL_INFO* coll)
item->goalAnimState = 1;
UseForcedFixedCamera = 1;
ForcedFixedCamera.x = item->pos.xPos - phd_sin(item->pos.yRot) / 16;
ForcedFixedCamera.x = item->pos.xPos - phd_sin(item->pos.yRot) * 1024;
ForcedFixedCamera.y = item->pos.yPos + 1024;
ForcedFixedCamera.z = item->pos.zPos - phd_cos(item->pos.yRot) / 16;
ForcedFixedCamera.z = item->pos.zPos - phd_cos(item->pos.yRot) * 1024;
ForcedFixedCamera.roomNumber = item->roomNumber;
}
else
@ -96,11 +96,11 @@ void FloorTrapDoorCollision(short itemNumber, ITEM_INFO* l, COLL_INFO* coll)
item->goalAnimState = 1;
UseForcedFixedCamera = 1;
ForcedFixedCamera.x = item->pos.xPos - phd_sin(item->pos.yRot) / 8;
ForcedFixedCamera.x = item->pos.xPos - phd_sin(item->pos.yRot) * 2048;
ForcedFixedCamera.y = item->pos.yPos - 2048;
if (ForcedFixedCamera.y < g_Level.Rooms[item->roomNumber].maxceiling)
ForcedFixedCamera.y = g_Level.Rooms[item->roomNumber].maxceiling;
ForcedFixedCamera.z = item->pos.zPos - phd_cos(item->pos.yRot) / 8;
ForcedFixedCamera.z = item->pos.zPos - phd_cos(item->pos.yRot) * 2048;
ForcedFixedCamera.roomNumber = item->roomNumber;
}
else

11
TR5Main/Objects/TR2/Entity/tr2_dragon.cpp
View file

@ -174,8 +174,9 @@ static void createDragonBone(short front_number)
void DragonCollision(short itemNum, ITEM_INFO* laraitem, COLL_INFO* coll)
{
ITEM_INFO* item;
int c, s, rx, rz, shift, side_shift, angle;
int rx, rz, shift, side_shift, angle;
int anim, frame;
float c, s;
/* If Lara has collided with correct bit of dragon, then start him up */
item = &g_Level.Items[itemNum];
@ -194,10 +195,10 @@ void DragonCollision(short itemNum, ITEM_INFO* laraitem, COLL_INFO* coll)
s = phd_sin(item->pos.yRot);
/* See if Lara within leg space of dragon; if so use different collision to sphere stuff */
side_shift = (rx * s + rz * c) >> W2V_SHIFT;
side_shift = rx * s + rz * c;
if (side_shift > DRAGON_LCOL&& side_shift < DRAGON_RCOL)
{
shift = (rx * c - rz * s) >> W2V_SHIFT;
shift = rx * c - rz * s;
if (shift <= DRAGON_CLOSE && shift >= DRAGON_FAR)
return;
@ -259,8 +260,8 @@ void DragonCollision(short itemNum, ITEM_INFO* laraitem, COLL_INFO* coll)
else
shift = DRAGON_FAR - shift;
laraitem->pos.xPos += shift * c >> W2V_SHIFT;
laraitem->pos.zPos -= shift * s >> W2V_SHIFT;
laraitem->pos.xPos += shift * c;
laraitem->pos.zPos -= shift * s;
return;
}

8
TR5Main/Objects/TR2/Entity/tr2_knifethrower.cpp
View file

@ -31,10 +31,10 @@ void KnifeControl(short fxNum)
fx->counter--;
}
speed = (fx->speed * phd_cos(fx->pos.xRot)) >> W2V_SHIFT;
fx->pos.zPos += (speed * phd_cos(fx->pos.yRot)) >> W2V_SHIFT;
fx->pos.xPos += (speed * phd_sin(fx->pos.yRot)) >> W2V_SHIFT;
fx->pos.yPos += (fx->speed * phd_sin(-fx->pos.xRot) >> W2V_SHIFT);
speed = fx->speed * phd_cos(fx->pos.xRot);
fx->pos.zPos += speed * phd_cos(fx->pos.yRot);
fx->pos.xPos += speed * phd_sin(fx->pos.yRot);
fx->pos.yPos += fx->speed * phd_sin(-fx->pos.xRot);
roomNumber = fx->roomNumber;
floor = GetFloor(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos, &roomNumber);

4
TR5Main/Objects/TR2/Trap/tr2_spinningblade.cpp
View file

@ -26,8 +26,8 @@ void SpinningBladeControl(short itemNumber)
{
if (item->goalAnimState != 1)
{
int x = item->pos.xPos + (WALL_SIZE * 3 / 2 * phd_sin(item->pos.yRot) >> W2V_SHIFT);
int z = item->pos.zPos + (WALL_SIZE * 3 / 2 * phd_cos(item->pos.yRot) >> W2V_SHIFT);
int x = item->pos.xPos + WALL_SIZE * 3 * phd_sin(item->pos.yRot) / 2;
int z = item->pos.zPos + WALL_SIZE * 3 * phd_cos(item->pos.yRot) / 2;
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x, item->pos.yPos, z, &roomNumber);

48
TR5Main/Objects/TR2/Vehicles/boat.cpp
View file

@ -175,9 +175,9 @@ void SpeedBoatGetOff(ITEM_INFO* boat)
LaraItem->pos.xRot = LaraItem->pos.zRot = 0;
Lara.Vehicle = NO_ITEM;
int x = LaraItem->pos.xPos + (360 * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT);
int x = LaraItem->pos.xPos + 360 * phd_sin(LaraItem->pos.yRot);
int y = LaraItem->pos.yPos - 90;
int z = LaraItem->pos.zPos + (360 * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT);
int z = LaraItem->pos.zPos + 360 * phd_cos(LaraItem->pos.yRot);
short roomNumber = LaraItem->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);
@ -206,9 +206,9 @@ bool SpeedBoatCanGetOff(int direction)
else
angle = v->pos.yRot + ANGLE(90);
int x = v->pos.xPos + (GETOFF_DIST * phd_sin(angle) >> W2V_SHIFT);
int x = v->pos.xPos + GETOFF_DIST * phd_sin(angle);
int y = v->pos.yPos;
int z = v->pos.zPos + (GETOFF_DIST * phd_cos(angle) >> W2V_SHIFT);
int z = v->pos.zPos + GETOFF_DIST * phd_cos(angle);
short roomNumber = v->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);
@ -237,8 +237,7 @@ int SpeedBoatCheckGeton(short itemNum, COLL_INFO* coll)
ITEM_INFO* boat = &g_Level.Items[itemNum];
int dist = ((LaraItem->pos.zPos - boat->pos.zPos) * phd_cos(-boat->pos.yRot) -
(LaraItem->pos.xPos - boat->pos.xPos) * phd_sin(-boat->pos.yRot)) >> W2V_SHIFT;
int dist = (LaraItem->pos.zPos - boat->pos.zPos) * phd_cos(-boat->pos.yRot) - (LaraItem->pos.xPos - boat->pos.xPos) * phd_sin(-boat->pos.yRot);
if (dist > 200)
return 0;
@ -294,14 +293,13 @@ int SpeedBoatTestWaterHeight(ITEM_INFO* item, int zOff, int xOff, PHD_VECTOR* po
// Moves the vector in 'pos' to the required test position too
// Get y pos correctly, but don't bother changing zOff and xOff using x_rot and z_rot
pos->y = item->pos.yPos - (zOff * phd_sin(item->pos.xRot) >> W2V_SHIFT) +
(xOff * phd_sin(item->pos.zRot) >> W2V_SHIFT);
pos->y = item->pos.yPos - zOff * phd_sin(item->pos.xRot) + xOff * phd_sin(item->pos.zRot);
int s = phd_sin(item->pos.yRot);
int c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
pos->x = item->pos.xPos + ((zOff * s + xOff * c) >> W2V_SHIFT);
pos->z = item->pos.zPos + ((zOff * c - xOff * s) >> W2V_SHIFT);
pos->x = item->pos.xPos + zOff * s + xOff * c;
pos->z = item->pos.zPos + zOff * c - xOff * s;
// Try to get water height; if none get ground height instead
short roomNumber = item->roomNumber;
@ -467,11 +465,11 @@ int SpeedBoatGetCollisionAnim(ITEM_INFO* skidoo, PHD_VECTOR* moved)
if (moved->x || moved->z)
{
// Get direction of movement relative to facing
int s = phd_sin(skidoo->pos.yRot);
int c = phd_cos(skidoo->pos.yRot);
float s = phd_sin(skidoo->pos.yRot);
float c = phd_cos(skidoo->pos.yRot);
int front = (moved->z * c + moved->x * s) >> W2V_SHIFT;
int side = (-moved->z * s + moved->x * c) >> W2V_SHIFT;
int front = moved->z * c + moved->x * s;
int side = -moved->z * s + moved->x * c;
if (abs(front) > abs(side))
{
@ -565,8 +563,8 @@ int SpeedBoatDynamics(short itemNum)
binfo->tiltAngle = binfo->boatTurn * 6;
// Move boat according to speed
boat->pos.xPos += boat->speed * phd_sin(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.zPos += boat->speed * phd_cos(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.xPos += boat->speed * phd_sin(boat->pos.yRot);
boat->pos.zPos += boat->speed * phd_cos(boat->pos.yRot);
/*if (boat->speed >= 0)
binfo->propRot += (boat->speed * ANGLE(3));
@ -574,17 +572,17 @@ int SpeedBoatDynamics(short itemNum)
binfo->propRot += ANGLE(33);*/
// Slide boat according to tilts (to avoid getting stuck on slopes)
slip = BOAT_SIDE_SLIP * phd_sin(boat->pos.zRot) >> W2V_SHIFT;
slip = BOAT_SIDE_SLIP * phd_sin(boat->pos.zRot);
if (!slip && boat->pos.zRot)
slip = (boat->pos.zRot > 0) ? 1 : -1;
boat->pos.xPos += slip * phd_sin(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.zPos -= slip * phd_cos(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.xPos += slip * phd_sin(boat->pos.yRot);
boat->pos.zPos -= slip * phd_cos(boat->pos.yRot);
slip = BOAT_SLIP * phd_sin(boat->pos.xRot) >> W2V_SHIFT;
slip = BOAT_SLIP * phd_sin(boat->pos.xRot);
if (!slip && boat->pos.xRot)
slip = (boat->pos.xRot > 0) ? 1 : -1;
boat->pos.xPos -= slip * phd_sin(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.zPos -= slip * phd_cos(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.xPos -= slip * phd_sin(boat->pos.yRot);
boat->pos.zPos -= slip * phd_cos(boat->pos.yRot);
// Remember desired position in case of collisions moving us about
moved.x = boat->pos.xPos;
@ -636,7 +634,7 @@ int SpeedBoatDynamics(short itemNum)
// Check final movement if slipped or collided and adjust speed
if (slip || collide)
{
newspeed = ((boat->pos.zPos - old.z) * phd_cos(boat->pos.yRot) + (boat->pos.xPos - old.x) * phd_sin(boat->pos.yRot)) >> W2V_SHIFT;
newspeed = (boat->pos.zPos - old.z) * phd_cos(boat->pos.yRot) + (boat->pos.xPos - old.x) * phd_sin(boat->pos.yRot);
if (boat->speed > BOAT_MAX_SPEED + BOAT_ACCELERATION && newspeed < boat->speed - 10)
{

45
TR5Main/Objects/TR2/Vehicles/snowmobile.cpp
View file

@ -226,9 +226,9 @@ bool SkidooCheckGetOffOK(int direction)
else
angle = skidoo->pos.yRot - 0x4000;
int x = skidoo->pos.xPos - (SKIDOO_GETOFF_DIST * phd_sin(angle) >> W2V_SHIFT);
int x = skidoo->pos.xPos - SKIDOO_GETOFF_DIST * phd_sin(angle);
int y = skidoo->pos.yPos;
int z = skidoo->pos.zPos - (SKIDOO_GETOFF_DIST * phd_cos(angle) >> W2V_SHIFT);
int z = skidoo->pos.zPos - SKIDOO_GETOFF_DIST * phd_cos(angle);
short roomNumber = skidoo->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);
@ -266,8 +266,8 @@ bool SkidooCheckGetOff()
LaraItem->animNumber = LA_STAND_SOLID;
LaraItem->frameNumber = g_Level.Anims[LaraItem->animNumber].frameBase;
LaraItem->currentAnimState = LaraItem->goalAnimState = LS_STOP;
LaraItem->pos.xPos -= SKIDOO_GETOFF_DIST * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.zPos -= SKIDOO_GETOFF_DIST * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.xPos -= SKIDOO_GETOFF_DIST * phd_sin(LaraItem->pos.yRot);
LaraItem->pos.zPos -= SKIDOO_GETOFF_DIST * phd_cos(LaraItem->pos.yRot);
LaraItem->pos.xRot = LaraItem->pos.zRot = 0;
Lara.Vehicle = NO_ITEM;
Lara.gunStatus = LG_NO_ARMS;
@ -457,11 +457,11 @@ int GetSkidooCollisionAnim(ITEM_INFO* skidoo, PHD_VECTOR* moved)
if (moved->x || moved->z)
{
// Get direction of movement relative to facing
int s = phd_sin(skidoo->pos.yRot);
int c = phd_cos(skidoo->pos.yRot);
float s = phd_sin(skidoo->pos.yRot);
float c = phd_cos(skidoo->pos.yRot);
int side = (-moved->z * s + moved->x * c) >> W2V_SHIFT;
int front = (moved->z * c + moved->x * s) >> W2V_SHIFT;
int side = -moved->z * s + moved->x * c;
int front = moved->z * c + moved->x * s;
if (abs(front) > abs(side))
{
@ -681,14 +681,13 @@ void SkidooCollision(short itemNum, ITEM_INFO* litem, COLL_INFO* coll)
int TestSkidooHeight(ITEM_INFO* item, int zOff, int xOff, PHD_VECTOR* pos)
{
pos->y = item->pos.yPos - (zOff * phd_sin(item->pos.xRot) >> W2V_SHIFT) +
(xOff * phd_sin(item->pos.zRot) >> W2V_SHIFT);
pos->y = item->pos.yPos - zOff * phd_sin(item->pos.xRot) + xOff * phd_sin(item->pos.zRot);
int s = phd_sin(item->pos.yRot);
int c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
pos->x = item->pos.xPos + ((zOff * s + xOff * c) >> W2V_SHIFT);
pos->z = item->pos.zPos + ((zOff * c - xOff * s) >> W2V_SHIFT);
pos->x = item->pos.xPos + zOff * s + xOff * c;
pos->z = item->pos.zPos + zOff * c - xOff * s;
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(pos->x, pos->y, pos->z, &roomNumber);
@ -877,22 +876,22 @@ int SkidooDynamics(ITEM_INFO* skidoo)
skidoo->pos.yRot += skinfo->skidooTurn + skinfo->extraRotation;
// Move skidoo according to speed
skidoo->pos.zPos += skidoo->speed * phd_cos(skinfo->momentumAngle) >> W2V_SHIFT;
skidoo->pos.xPos += skidoo->speed * phd_sin(skinfo->momentumAngle) >> W2V_SHIFT;
skidoo->pos.zPos += skidoo->speed * phd_cos(skinfo->momentumAngle);
skidoo->pos.xPos += skidoo->speed * phd_sin(skinfo->momentumAngle);
// Slide skidoo according to tilts (to avoid getting stuck on slopes)
int slip = SKIDOO_SLIP * phd_sin(skidoo->pos.xRot) >> W2V_SHIFT;
int slip = SKIDOO_SLIP * phd_sin(skidoo->pos.xRot);
if (abs(slip) > SKIDOO_SLIP / 2)
{
skidoo->pos.zPos -= slip * phd_cos(skidoo->pos.yRot) >> W2V_SHIFT;
skidoo->pos.xPos -= slip * phd_sin(skidoo->pos.yRot) >> W2V_SHIFT;
skidoo->pos.zPos -= slip * phd_cos(skidoo->pos.yRot);
skidoo->pos.xPos -= slip * phd_sin(skidoo->pos.yRot);
}
slip = SKIDOO_SLIP_SIDE * phd_sin(skidoo->pos.zRot) >> W2V_SHIFT;
slip = SKIDOO_SLIP_SIDE * phd_sin(skidoo->pos.zRot);
if (abs(slip) > SKIDOO_SLIP_SIDE / 2)
{
skidoo->pos.zPos -= slip * phd_sin(skidoo->pos.yRot) >> W2V_SHIFT;
skidoo->pos.xPos += slip * phd_cos(skidoo->pos.yRot) >> W2V_SHIFT;
skidoo->pos.zPos -= slip * phd_sin(skidoo->pos.yRot);
skidoo->pos.xPos += slip * phd_cos(skidoo->pos.yRot);
}
// Remember desired position in case of collisions moving us about
@ -935,7 +934,7 @@ int SkidooDynamics(ITEM_INFO* skidoo)
// Check final actual movement; if speed is more than halved then reduce to zero
if (collide)
{
int newspeed = ((skidoo->pos.zPos - old.z) * phd_cos(skinfo->momentumAngle) + (skidoo->pos.xPos - old.x) * phd_sin(skinfo->momentumAngle)) >> W2V_SHIFT;
int newspeed = (skidoo->pos.zPos - old.z) * phd_cos(skinfo->momentumAngle) + (skidoo->pos.xPos - old.x) * phd_sin(skinfo->momentumAngle);
if (skidoo->speed > SKIDOO_MAX_SPEED + SKIDOO_ACCELERATION && newspeed < skidoo->speed - 10)
{
LaraItem->hitPoints -= (skidoo->speed - newspeed) / 2;

8
TR5Main/Objects/TR3/Entity/tr3_fishemitter.cpp
View file

@ -258,8 +258,8 @@ void ControlFish(short itemNumber)
int x = fish->x;
int z = fish->z;
x -= fish->speed * phd_sin(fish->angle << 4) >> 15;
z += fish->speed * phd_cos(fish->angle << 4) >> 15;
x -= fish->speed * phd_sin(fish->angle << 4) / 2;
z += fish->speed * phd_cos(fish->angle << 4) / 2;
if (pirahnaAttack == 0)
{
@ -436,8 +436,8 @@ void ControlFish(short itemNumber)
fish->swim += (fish->speed >> 4) + (fish->speed >> 5);
fish->swim &= 63;
x = fish->x - fish->speed * phd_sin(fish->angle << 4) >> 15;
z = fish->z + fish->speed * phd_cos(fish->angle << 4) >> 15;
x = fish->x - fish->speed * phd_sin(fish->angle << 4) / 2;
z = fish->z + fish->speed * phd_cos(fish->angle << 4) / 2;
if (z < -32000)
z = -32000;

16
TR5Main/Objects/TR3/Entity/tr3_flamethrower.cpp
View file

@ -190,19 +190,19 @@ static short TriggerFlameThrower(ITEM_INFO* item, BITE_INFO* bite, short speed)
for (int i = 0; i < 2; i++)
{
speed = (GetRandomControl() % (speed << 2)) + 32;
velocity = (speed * phd_cos(fx->pos.xRot)) >> W2V_SHIFT;
velocity = speed * phd_cos(fx->pos.xRot);
xv = (velocity * phd_sin(fx->pos.yRot)) >> W2V_SHIFT;
yv = -((speed * phd_sin(fx->pos.xRot)) >> W2V_SHIFT);
zv = (velocity * phd_cos(fx->pos.yRot)) >> W2V_SHIFT;
xv = velocity * phd_sin(fx->pos.yRot);
yv = -speed * phd_sin(fx->pos.xRot);
zv = velocity * phd_cos(fx->pos.yRot);
TriggerFlamethrowerFlame(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos, xv << 5, yv << 5, zv << 5, -1);
}
velocity = ((speed << 1) * phd_cos(fx->pos.xRot)) >> W2V_SHIFT;
zv = (velocity * phd_cos(fx->pos.yRot)) >> W2V_SHIFT;
xv = (velocity * phd_sin(fx->pos.yRot)) >> W2V_SHIFT;
yv = -(((speed << 1) * phd_sin(fx->pos.xRot)) >> W2V_SHIFT);
velocity = (speed << 1) * phd_cos(fx->pos.xRot);
zv = velocity * phd_cos(fx->pos.yRot);
xv = velocity * phd_sin(fx->pos.yRot);
yv = -(speed << 1) * phd_sin(fx->pos.xRot);
TriggerFlamethrowerFlame(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos, xv << 5, yv << 5, zv << 5, -2);
}

4
TR5Main/Objects/TR3/Entity/tr3_mpgun.cpp
View file

@ -154,9 +154,9 @@ void MPGunControl(short itemNumber)
angle = CreatureTurn(item, creature->maximumTurn);
int x = item->pos.xPos + (WALL_SIZE * phd_sin(item->pos.yRot + laraInfo.angle) >> W2V_SHIFT);
int x = item->pos.xPos + WALL_SIZE * phd_sin(item->pos.yRot + laraInfo.angle);
int y = item->pos.yPos;
int z = item->pos.zPos + (WALL_SIZE * phd_cos(item->pos.yRot + laraInfo.angle) >> W2V_SHIFT);
int z = item->pos.zPos + WALL_SIZE * phd_cos(item->pos.yRot + laraInfo.angle);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);

8
TR5Main/Objects/TR3/Entity/tr3_scuba.cpp
View file

@ -52,10 +52,10 @@ void ScubaHarpoonControl(short itemNum)
int ox = item->pos.xPos;
int oz = item->pos.zPos;
short speed = (item->speed * phd_cos(item->pos.xRot)) >> W2V_SHIFT;
item->pos.zPos += (speed * phd_cos(item->pos.yRot)) >> W2V_SHIFT;
item->pos.xPos += (speed * phd_sin(item->pos.yRot)) >> W2V_SHIFT;
item->pos.yPos += -((item->speed * phd_sin(item->pos.xRot)) >> W2V_SHIFT);
short speed = item->speed * phd_cos(item->pos.xRot);
item->pos.zPos += speed * phd_cos(item->pos.yRot);
item->pos.xPos += speed * phd_sin(item->pos.yRot);
item->pos.yPos += -item->speed * phd_sin(item->pos.xRot);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(item->pos.xPos, item->pos.yPos, item->pos.zPos, &roomNumber);

4
TR5Main/Objects/TR3/Entity/tr3_shiva.cpp
View file

@ -240,8 +240,8 @@ void ShivaControl(short itemNum)
if (shiva->mood == ESCAPE_MOOD)
{
roomNumber = item->roomNumber;
x = item->pos.xPos + (WALL_SIZE * phd_sin(item->pos.yRot + 0x8000) >> W2V_SHIFT);
z = item->pos.zPos + (WALL_SIZE * phd_cos(item->pos.yRot + 0x8000) >> W2V_SHIFT);
x = item->pos.xPos + WALL_SIZE * phd_sin(item->pos.yRot + 0x8000);
z = item->pos.zPos + WALL_SIZE * phd_cos(item->pos.yRot + 0x8000);
floor = GetFloor(x, item->pos.yPos, z, &roomNumber);
if (!shiva->flags && floor->box != NO_BOX && !(g_Level.Boxes[floor->box].flags & BLOCKABLE))

4
TR5Main/Objects/TR3/Entity/tr3_tony.cpp
View file

@ -361,8 +361,8 @@ void ControlTonyFireBall(short fxNumber)
if (fx->fallspeed > 512)
fx->fallspeed = 512;
fx->pos.yPos += fx->fallspeed >> 1;
fx->pos.zPos += (fx->speed * phd_cos(fx->pos.yRot) >> W2V_SHIFT);
fx->pos.xPos += (fx->speed * phd_sin(fx->pos.yRot) >> W2V_SHIFT);
fx->pos.zPos += fx->speed * phd_cos(fx->pos.yRot);
fx->pos.xPos += fx->speed * phd_sin(fx->pos.yRot);
if (Wibble & 4)
TriggerFireBallFlame(fxNumber, (TonyFlameType)fx->flag1, (short)((old_x - fx->pos.xPos) << 3), (short)((old_y - fx->pos.yPos) << 3), (short)((old_z - fx->pos.zPos) << 3));
}

31
TR5Main/Objects/TR3/Trap/train.cpp
View file

@ -14,17 +14,16 @@
long TrainTestHeight(ITEM_INFO *item, long x, long z, short *room_number)
{
long s, c;
float s, c;
PHD_VECTOR pos;
FLOOR_INFO *floor;
c = phd_cos(item->pos.yRot);
s = phd_sin(item->pos.yRot);
pos.x = item->pos.xPos + (((z * s) + (x * c)) >> W2V_SHIFT);
pos.y = item->pos.yPos - (z * phd_sin(item->pos.xRot) >> W2V_SHIFT)
+ (x * phd_sin(item->pos.zRot) >> W2V_SHIFT);
pos.z = item->pos.zPos + (((z * c) - (x * s)) >> W2V_SHIFT);
pos.x = item->pos.xPos + z * s + x * c;
pos.y = item->pos.yPos - z * phd_sin(item->pos.xRot) + x * phd_sin(item->pos.zRot);
pos.z = item->pos.zPos + z * c - x * s;
*room_number = item->roomNumber;
floor = GetFloor(pos.x, pos.y, pos.z, room_number);
@ -34,9 +33,10 @@ long TrainTestHeight(ITEM_INFO *item, long x, long z, short *room_number)
void TrainControl(short trainNum)
{
ITEM_INFO *train;
long s, c, fh, rh;
long fh, rh;
FLOOR_INFO *floor;
short roomNum;
float s, c;
train = &g_Level.Items[trainNum];
@ -49,8 +49,8 @@ void TrainControl(short trainNum)
c = phd_cos(train->pos.yRot);
s = phd_sin(train->pos.yRot);
train->pos.xPos += ((train->itemFlags[1] * s) >> W2V_SHIFT);
train->pos.zPos += ((train->itemFlags[1] * c) >> W2V_SHIFT);
train->pos.xPos += train->itemFlags[1] * s;
train->pos.zPos += train->itemFlags[1] * c;
rh = TrainTestHeight(train, 0, 5120, &roomNum);
train->pos.yPos = fh = TrainTestHeight(train, 0, 0, &roomNum);
@ -71,7 +71,7 @@ void TrainControl(short trainNum)
train->pos.xRot = -(rh - fh) << 1;
TriggerDynamicLight(train->pos.xPos + ((3072 * s) >> W2V_SHIFT), train->pos.yPos, train->pos.zPos + ((3072 * c) >> W2V_SHIFT), 16, 31, 31, 31);
TriggerDynamicLight(train->pos.xPos + 3072 * s, train->pos.yPos, train->pos.zPos + 3072 * c, 16, 31, 31, 31);
if (train->itemFlags[1] != TRAIN_VEL)
{
@ -80,10 +80,10 @@ void TrainControl(short trainNum)
if (!UseForcedFixedCamera)
{
ForcedFixedCamera.x = train->pos.xPos + ((8192 * s) >> W2V_SHIFT),
ForcedFixedCamera.z = train->pos.zPos + ((8192 * c) >> W2V_SHIFT),
ForcedFixedCamera.x = train->pos.xPos + 8192 * s;
ForcedFixedCamera.z = train->pos.zPos + 8192 * c;
roomNum = train->roomNumber;
roomNum = train->roomNumber;
floor = GetFloor(ForcedFixedCamera.x, train->pos.yPos - 512, ForcedFixedCamera.z, &roomNum);
ForcedFixedCamera.y = GetFloorHeight(floor, ForcedFixedCamera.x, train->pos.yPos - 512, ForcedFixedCamera.z);
@ -99,7 +99,8 @@ void TrainControl(short trainNum)
void TrainCollision(short trainNum, ITEM_INFO *larA, COLL_INFO *coll)
{
ITEM_INFO *train;
long s, c, x, z;
long x, z;
float s, c;
train = &g_Level.Items[trainNum];
@ -137,8 +138,8 @@ void TrainCollision(short trainNum, ITEM_INFO *larA, COLL_INFO *coll)
c = phd_cos(train->pos.yRot);
s = phd_sin(train->pos.yRot);
x = larA->pos.xPos + ((256 * s) >> W2V_SHIFT);
z = larA->pos.zPos + ((256 * c) >> W2V_SHIFT);
x = larA->pos.xPos + 256 * s;
z = larA->pos.zPos + 256 * c;
DoLotsOfBlood(x, larA->pos.yPos - 512, z, 1024, train->pos.yRot, larA->roomNumber, 15);

43
TR5Main/Objects/TR3/Vehicles/kayak.cpp
View file

@ -107,11 +107,11 @@ void KayakDoWake(ITEM_INFO* v, short xoff, short zoff, short rotate)
if (WakePts[CurrentStartWake][rotate].life)
return;
int s = phd_sin(v->pos.yRot);
int c = phd_cos(v->pos.yRot);
float s = phd_sin(v->pos.yRot);
float c = phd_cos(v->pos.yRot);
int x = v->pos.xPos + (((zoff * s) + (xoff * c)) >> W2V_SHIFT);
int z = v->pos.zPos + (((zoff * c) - (xoff * s)) >> W2V_SHIFT);
int x = v->pos.xPos + zoff * s + xoff * c;
int z = v->pos.zPos + zoff * c - xoff * s;
short angle1, angle2;
@ -147,10 +147,10 @@ void KayakDoWake(ITEM_INFO* v, short xoff, short zoff, short rotate)
}
}
xv[0] = (WAKE_SPEED * phd_sin(angle1)) >> W2V_SHIFT;
zv[0] = (WAKE_SPEED * phd_cos(angle1)) >> W2V_SHIFT;
xv[1] = ((WAKE_SPEED + 2) * phd_sin(angle2)) >> W2V_SHIFT;
zv[1] = ((WAKE_SPEED + 2) * phd_cos(angle2)) >> W2V_SHIFT;
xv[0] = WAKE_SPEED * phd_sin(angle1);
zv[0] = WAKE_SPEED * phd_cos(angle1);
xv[1] = (WAKE_SPEED + 2) * phd_sin(angle2);
zv[1] = (WAKE_SPEED + 2) * phd_cos(angle2);
WakePts[CurrentStartWake][rotate].y = v->pos.yPos + KAYAK_DRAW_SHIFT;
WakePts[CurrentStartWake][rotate].life = 0x40;
@ -173,11 +173,11 @@ void KayakDoWake(ITEM_INFO* v, short xoff, short zoff, short rotate)
void KayakDoRipple(ITEM_INFO* v, short xoff, short zoff)
{
int s = phd_sin(v->pos.yRot);
int c = phd_cos(v->pos.yRot);
float s = phd_sin(v->pos.yRot);
float c = phd_cos(v->pos.yRot);
int x = v->pos.xPos + (((zoff * s) + (xoff * c)) >> W2V_SHIFT);
int z = v->pos.zPos + (((zoff * c) - (xoff * s)) >> W2V_SHIFT);
int x = v->pos.xPos + zoff * s + xoff * c;
int z = v->pos.zPos + zoff * c - xoff * s;
short roomNumber = v->roomNumber;
FLOOR_INFO* floor = GetFloor(x, v->pos.yPos, z, &roomNumber);
@ -338,11 +338,11 @@ int KayakGetCollisionAnim(ITEM_INFO* v, int xdiff, int zdiff)
if ((xdiff) || (zdiff))
{
int s = phd_sin(v->pos.yRot);
int c = phd_cos(v->pos.yRot);
float s = phd_sin(v->pos.yRot);
float c = phd_cos(v->pos.yRot);
int front = ((zdiff * c) + (xdiff * s)) >> W2V_SHIFT;
int side = ((-zdiff * s) + (xdiff * c)) >> W2V_SHIFT;
int front = zdiff * c + xdiff * s;
int side = -zdiff * s + xdiff * c;
if (abs(front) > abs(side))
{
@ -448,8 +448,8 @@ void KayakDoCurrent(ITEM_INFO* item)
int dz = target.z - LaraItem->pos.zPos;
int speed = FixedCameras[sinkval].data;
dx = phd_sin(angle << 4) * speed / 16;
dz = phd_cos(angle << 4) * speed / 16;
dx = phd_sin(angle << 4) * speed * 1024;
dz = phd_cos(angle << 4) * speed * 1024;
Lara.currentXvel += (dx - Lara.currentXvel) / 16;
Lara.currentZvel += (dz - Lara.currentZvel) / 16;
@ -659,8 +659,8 @@ void KayakToBackground(ITEM_INFO* v, KAYAK_INFO* Kayak)
v->pos.yRot += (Kayak->Rot >> 16);
v->pos.xPos += (v->speed * phd_sin(v->pos.yRot)) >> W2V_SHIFT;
v->pos.zPos += (v->speed * phd_cos(v->pos.yRot)) >> W2V_SHIFT;
v->pos.xPos += v->speed * phd_sin(v->pos.yRot);
v->pos.zPos += v->speed * phd_cos(v->pos.yRot);
KayakDoCurrent(v);
@ -753,8 +753,7 @@ void KayakToBackground(ITEM_INFO* v, KAYAK_INFO* Kayak)
{
int newspeed;
newspeed = ((v->pos.zPos - oldpos[8].z) * phd_cos(v->pos.yRot)
+ (v->pos.xPos - oldpos[8].x) * phd_sin(v->pos.yRot)) >> W2V_SHIFT;
newspeed = (v->pos.zPos - oldpos[8].z) * phd_cos(v->pos.yRot) + (v->pos.xPos - oldpos[8].x) * phd_sin(v->pos.yRot);
newspeed *= 256;

30
TR5Main/Objects/TR3/Vehicles/minecart.cpp
View file

@ -70,15 +70,15 @@ static int TestMinecartHeight(ITEM_INFO* v, int x, int z)
{
PHD_VECTOR pos;
FLOOR_INFO* floor;
int s, c;
float s, c;
short roomNumber;
c = phd_cos(v->pos.yRot);
s = phd_sin(v->pos.yRot);
pos.x = v->pos.xPos + (((z * s) + (x * c)) >> W2V_SHIFT);
pos.y = v->pos.yPos - (z * phd_sin(v->pos.xRot) >> W2V_SHIFT) + (x * phd_sin(v->pos.zRot) >> W2V_SHIFT);
pos.z = v->pos.zPos + (((z * c) - (x * s)) >> W2V_SHIFT);
pos.x = v->pos.xPos + z * s + x * c;
pos.y = v->pos.yPos - z * phd_sin(v->pos.xRot) + x * phd_sin(v->pos.zRot);
pos.z = v->pos.zPos + z * c - x * s;
roomNumber = v->roomNumber;
floor = GetFloor(pos.x, pos.y, pos.z, &roomNumber);
@ -91,9 +91,9 @@ static short GetCollision(ITEM_INFO* v, short ang, int dist, short* ceiling)
int x, y, z, height, cheight;
short roomNumber;
x = v->pos.xPos + ((phd_sin(ang) * dist) >> W2V_SHIFT);
x = v->pos.xPos + phd_sin(ang) * dist;
y = v->pos.yPos - LARA_HITE;
z = v->pos.zPos + ((phd_cos(ang) * dist) >> W2V_SHIFT);
z = v->pos.zPos + phd_cos(ang) * dist;
roomNumber = v->roomNumber;
floor = GetFloor(x, y, z, &roomNumber);
@ -156,9 +156,9 @@ static bool CanGetOut(int direction)
angle = v->pos.yRot - 0x4000;
x = v->pos.xPos - (GETOFF_DIST * phd_sin(angle) >> W2V_SHIFT);
x = v->pos.xPos - GETOFF_DIST * phd_sin(angle);
y = v->pos.yPos;
z = v->pos.zPos - (GETOFF_DIST * phd_cos(angle) >> W2V_SHIFT);
z = v->pos.zPos - GETOFF_DIST * phd_cos(angle);
roomNumber = v->roomNumber;
floor = GetFloor(x, y, z, &roomNumber);
@ -363,7 +363,7 @@ static void MoveCart(ITEM_INFO* v, ITEM_INFO* l, CART_INFO* cart)
// move cart around corners
if (cart->Flags & (CF_TURNINGL | CF_TURNINGR))
{
int x, z;
float x, z;
unsigned short quad, deg;
if ((cart->TurnLen += (v->speed * 3)) > ANGLE(90))
@ -414,15 +414,15 @@ static void MoveCart(ITEM_INFO* v, ITEM_INFO* l, CART_INFO* cart)
z = -z;
}
v->pos.xPos = cart->TurnX + ((x * 3584) >> W2V_SHIFT);
v->pos.zPos = cart->TurnZ + ((z * 3584) >> W2V_SHIFT);
v->pos.xPos = cart->TurnX + x * 3584;
v->pos.zPos = cart->TurnZ + z * 3584;
}
}
else
{
// move cart normally
v->pos.xPos += (v->speed * phd_sin(v->pos.yRot)) >> W2V_SHIFT;
v->pos.zPos += (v->speed * phd_cos(v->pos.yRot)) >> W2V_SHIFT;
v->pos.xPos += v->speed * phd_sin(v->pos.yRot);
v->pos.zPos += v->speed * phd_cos(v->pos.yRot);
}
// tilt cart on slopes
@ -698,8 +698,8 @@ static void DoUserInput(ITEM_INFO* v, ITEM_INFO* l, CART_INFO* cart)
if ((Wibble & 7) == 0)
SoundEffect(SFX_TR3_QUAD_FRONT_IMPACT, &v->pos, 2);
v->pos.xPos += (TURN_DEATH_VEL * phd_sin(v->pos.yRot)) >> W2V_SHIFT;
v->pos.zPos += (TURN_DEATH_VEL * phd_cos(v->pos.yRot)) >> W2V_SHIFT;
v->pos.xPos += TURN_DEATH_VEL * phd_sin(v->pos.yRot);
v->pos.zPos += TURN_DEATH_VEL * phd_cos(v->pos.yRot);
}
else
{

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

@ -171,9 +171,9 @@ static int CanQuadbikeGetOff(int direction)
else
angle = item->pos.yRot + ANGLE(90);
int x = item->pos.xPos + (512 * phd_sin(angle) >> W2V_SHIFT);
int x = item->pos.xPos + 512 * phd_sin(angle);
int y = item->pos.yPos;
int z = item->pos.zPos + (512 * phd_cos(angle) >> W2V_SHIFT);
int z = item->pos.zPos + 512 * phd_cos(angle);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);
@ -214,8 +214,8 @@ static int QuadCheckGetOff()
LaraItem->animNumber = LA_STAND_SOLID;
LaraItem->frameNumber = GF(LaraItem->animNumber, 0);
LaraItem->currentAnimState = LaraItem->goalAnimState = LS_STOP;
LaraItem->pos.xPos -= GETOFF_DISTANCE * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.zPos -= GETOFF_DISTANCE * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.xPos -= GETOFF_DISTANCE * phd_sin(LaraItem->pos.yRot);
LaraItem->pos.zPos -= GETOFF_DISTANCE * phd_cos(LaraItem->pos.yRot);
LaraItem->pos.xRot = LaraItem->pos.zRot = 0;
Lara.Vehicle = NO_ITEM;
Lara.gunStatus = LG_NO_ARMS;
@ -362,10 +362,10 @@ static int GetQuadCollisionAnim(ITEM_INFO* item, PHD_VECTOR* p)
if (p->x || p->z)
{
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
int front = ((p->z * c) + (p->x * s)) >> W2V_SHIFT;
int side = ((-p->z * s) + (p->x * c)) >> W2V_SHIFT;
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
int front = p->z * c + p->x * s;
int side = -p->z * s + p->x * c;
if (abs(front) > abs(side))
{
@ -388,13 +388,13 @@ static int GetQuadCollisionAnim(ITEM_INFO* item, PHD_VECTOR* p)
static int TestQuadHeight(ITEM_INFO* item, int dz, int dx, PHD_VECTOR* pos)
{
pos->y = item->pos.yPos - (dz * phd_sin(item->pos.xRot) >> W2V_SHIFT) + (dx * phd_sin(item->pos.zRot) >> W2V_SHIFT);
pos->y = item->pos.yPos - dz * phd_sin(item->pos.xRot) + dx * phd_sin(item->pos.zRot);
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
pos->z = item->pos.zPos + ((dz * c - dx * s) >> W2V_SHIFT);
pos->x = item->pos.xPos + ((dz * s + dx * c) >> W2V_SHIFT);
pos->z = item->pos.zPos + dz * c - dx * s;
pos->x = item->pos.xPos + dz * s + dx * c;
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(pos->x, pos->y, pos->z, &roomNumber);
@ -640,29 +640,29 @@ static int QuadDynamics(ITEM_INFO* item)
int height = GetFloorHeight(floor, item->pos.xPos, item->pos.yPos, item->pos.zPos);
int speed = 0;
if (item->pos.yPos >= height)
speed = (item->speed * phd_cos(item->pos.xRot)) >> W2V_SHIFT;
speed = item->speed * phd_cos(item->pos.xRot);
else
speed = item->speed;
item->pos.zPos += (speed * phd_cos(quad->momentumAngle)) >> W2V_SHIFT;
item->pos.xPos += (speed * phd_sin(quad->momentumAngle)) >> W2V_SHIFT;
item->pos.zPos += speed * phd_cos(quad->momentumAngle);
item->pos.xPos += speed * phd_sin(quad->momentumAngle);
slip = QUAD_SLIP * phd_sin(item->pos.xRot) >> W2V_SHIFT;
slip = QUAD_SLIP * phd_sin(item->pos.xRot);
if (abs(slip) > QUAD_SLIP / 2)
{
if (slip > 0)
slip -= 10;
else
slip += 10;
item->pos.zPos -= slip * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos -= slip * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.zPos -= slip * phd_cos(item->pos.yRot);
item->pos.xPos -= slip * phd_sin(item->pos.yRot);
}
slip = QUAD_SLIP_SIDE * phd_sin(item->pos.zRot) >> W2V_SHIFT;
slip = QUAD_SLIP_SIDE * phd_sin(item->pos.zRot);
if (abs(slip) > QUAD_SLIP_SIDE / 2)
{
item->pos.zPos -= slip * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos += slip * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.zPos -= slip * phd_sin(item->pos.yRot);
item->pos.xPos += slip * phd_cos(item->pos.yRot);
}
moved.x = item->pos.xPos;
@ -738,7 +738,7 @@ static int QuadDynamics(ITEM_INFO* item)
if (collide)
{
newspeed = ((item->pos.zPos - old.z) * phd_cos(quad->momentumAngle) + (item->pos.xPos - old.x) * phd_sin(quad->momentumAngle)) >> W2V_SHIFT;
newspeed = (item->pos.zPos - old.z) * phd_cos(quad->momentumAngle) + (item->pos.xPos - old.x) * phd_sin(quad->momentumAngle);
newspeed <<= 8;
@ -1240,8 +1240,8 @@ static void TriggerQuadExhaustSmoke(int x, int y, int z, short angle, int speed,
spark->x = x + ((GetRandomControl() & 15) - 8);
spark->y = y + ((GetRandomControl() & 15) - 8);
spark->z = z + ((GetRandomControl() & 15) - 8);
int zv = (speed * phd_cos(angle)) >> (W2V_SHIFT + 2);
int xv = (speed * phd_sin(angle)) >> (W2V_SHIFT + 2);
int zv = speed * phd_cos(angle) / 4;
int xv = speed * phd_sin(angle) / 4;
spark->xVel = xv + ((GetRandomControl() & 255) - 128);
spark->yVel = -(GetRandomControl() & 7) - 8;
spark->zVel = zv + ((GetRandomControl() & 255) - 128);

52
TR5Main/Objects/TR3/Vehicles/rubberboat.cpp
View file

@ -70,7 +70,7 @@ int RubberBoatCheckGeton(short itemNum, COLL_INFO *coll)
xDelta = LaraItem->pos.xPos - boat->pos.xPos;
zDelta = LaraItem->pos.zPos - boat->pos.zPos;
dist = ((zDelta * phd_cos(-boat->pos.yRot)) - (xDelta * phd_sin(-boat->pos.yRot))) >> W2V_SHIFT;
dist = zDelta * phd_cos(-boat->pos.yRot) - xDelta * phd_sin(-boat->pos.yRot);
if (dist > 512) return 0;
@ -119,17 +119,17 @@ int RubberBoatCheckGeton(short itemNum, COLL_INFO *coll)
static long TestWaterHeight(ITEM_INFO *item, long zOff, long xOff, PHD_VECTOR *pos)
{
FLOOR_INFO *floor;
long s, c, height;
long height;
short roomNum;
float s, c;
pos->y = item->pos.yPos - (zOff * phd_sin(item->pos.xRot) >> W2V_SHIFT) +
(xOff * phd_sin(item->pos.zRot) >> W2V_SHIFT);
pos->y = item->pos.yPos - zOff * phd_sin(item->pos.xRot) + xOff * phd_sin(item->pos.zRot);
c = phd_cos(item->pos.yRot);
s = phd_sin(item->pos.yRot);
pos->z = item->pos.zPos + ((zOff *c - xOff * s) >> W2V_SHIFT);
pos->x = item->pos.xPos + ((zOff *s + xOff * c) >> W2V_SHIFT);
pos->z = item->pos.zPos + zOff * c - xOff * s;
pos->x = item->pos.xPos + zOff * s + xOff * c;
roomNum = item->roomNumber;
GetFloor(pos->x, pos->y, pos->z, &roomNum);
@ -290,7 +290,8 @@ static int DoRubberBoatShift2(ITEM_INFO *skidoo, PHD_VECTOR *pos, PHD_VECTOR *ol
static int GetRubberBoatCollisionAnim(ITEM_INFO *rubber, PHD_VECTOR *moved)
{
long c, s, front, side;
long front, side;
float c, s;
moved->x = rubber->pos.xPos - moved->x;
moved->z = rubber->pos.zPos - moved->z;
@ -299,8 +300,8 @@ static int GetRubberBoatCollisionAnim(ITEM_INFO *rubber, PHD_VECTOR *moved)
{
c = phd_cos(rubber->pos.yRot);
s = phd_sin(rubber->pos.yRot);
front = (moved->z * c + moved->x * s) >> W2V_SHIFT;
side = (-moved->z * s + moved->x * c) >> W2V_SHIFT;
front = moved->z * c + moved->x * s;
side = -moved->z * s + moved->x * c;
if (abs(front) > abs(side))
{
@ -380,25 +381,25 @@ static int RubberBoatDynamics(short boat_number)
binfo->tiltAngle = binfo->boatTurn * 6;
/* Move boat according to speed */
boat->pos.zPos += boat->speed * phd_cos(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.xPos += boat->speed * phd_sin(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.zPos += boat->speed * phd_cos(boat->pos.yRot);
boat->pos.xPos += boat->speed * phd_sin(boat->pos.yRot);
if (boat->speed >= 0)
binfo->propRot += (boat->speed * (ONE_DEGREE * 3)) + (ONE_DEGREE << 1);
else
binfo->propRot += ONE_DEGREE * 33;
/* Slide boat according to tilts (to avoid getting stuck on slopes) */
slip = RUBBER_BOAT_SIDE_SLIP * phd_sin(boat->pos.zRot) >> W2V_SHIFT;
slip = RUBBER_BOAT_SIDE_SLIP * phd_sin(boat->pos.zRot);
if (!slip && boat->pos.zRot)
slip = (boat->pos.zRot > 0) ? 1 : -1;
boat->pos.zPos -= slip * phd_sin(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.xPos += slip * phd_cos(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.zPos -= slip * phd_sin(boat->pos.yRot);
boat->pos.xPos += slip * phd_cos(boat->pos.yRot);
slip = RUBBER_BOAT_SLIP * phd_sin(boat->pos.xRot) >> W2V_SHIFT;
slip = RUBBER_BOAT_SLIP * phd_sin(boat->pos.xRot);
if (!slip && boat->pos.xRot)
slip = (boat->pos.xRot > 0) ? 1 : -1;
boat->pos.zPos -= slip * phd_cos(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.xPos -= slip * phd_sin(boat->pos.yRot) >> W2V_SHIFT;
boat->pos.zPos -= slip * phd_cos(boat->pos.yRot);
boat->pos.xPos -= slip * phd_sin(boat->pos.yRot);
/* Remember desired position in case of collisions moving us about */
moved.x = boat->pos.xPos;
@ -448,10 +449,7 @@ static int RubberBoatDynamics(short boat_number)
/* Check final movement if slipped or collided and adjust speed */
if (slip || collide)
{
//## newspeed = (boat->pos.zPos - old.z) * phd_cos(boat->pos.yRot) + (boat->pos.xPos - old.x) * phd_sin(boat->pos.yRot) >> W2V_SHIFT;
newspeed = ((boat->pos.zPos - old.z) * phd_cos(boat->pos.yRot)
+ (boat->pos.xPos - old.x) * phd_sin(boat->pos.yRot))
>> W2V_SHIFT;
newspeed = (boat->pos.zPos - old.z) * phd_cos(boat->pos.yRot) + (boat->pos.xPos - old.x) * phd_sin(boat->pos.yRot);
if (Lara.Vehicle == boat_number && boat->speed > RUBBER_BOAT_MAX_SPEED + RUBBER_BOAT_ACCELERATION && newspeed < boat->speed - 10)
{
@ -714,9 +712,9 @@ static int CanGetOffRubberBoat(int direction)
else
angle = boat->pos.yRot + ANGLE(90);
x = boat->pos.xPos + (1024 * phd_sin(angle) >> W2V_SHIFT);
x = boat->pos.xPos + 1024 * phd_sin(angle);
y = boat->pos.yPos;
z = boat->pos.zPos + (1024 * phd_cos(angle) >> W2V_SHIFT);
z = boat->pos.zPos + 1024 * phd_cos(angle);
roomNum = boat->roomNumber;
floor = GetFloor(x, y, z, &roomNum);
@ -853,8 +851,8 @@ static void TriggerRubberBoatMist(long x, long y, long z, long speed, short angl
sptr->x = x * ((GetRandomControl() & 15) - 8);
sptr->y = y * ((GetRandomControl() & 15) - 8);
sptr->z = z * ((GetRandomControl() & 15) - 8);
zv = (speed * phd_cos(angle)) >> (W2V_SHIFT + 2);
xv = (speed * phd_sin(angle)) >> (W2V_SHIFT + 2);
zv = speed * phd_cos(angle) / 4;
xv = speed * phd_sin(angle) / 4;
sptr->xVel = xv + ((GetRandomControl() & 127) - 64);
sptr->yVel = (speed << 3) + (speed << 2);
sptr->zVel = zv + ((GetRandomControl() & 127) - 64);
@ -909,9 +907,9 @@ void RubberBoatDoGetOff(ITEM_INFO* boat)
Lara.Vehicle = NO_ITEM;
roomNum = LaraItem->roomNumber;
x = LaraItem->pos.xPos + (360 * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT);
x = LaraItem->pos.xPos + 360 * phd_sin(LaraItem->pos.yRot);
y = LaraItem->pos.yPos - 90;
z = LaraItem->pos.zPos + (360 * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT);
z = LaraItem->pos.zPos + 360 * phd_cos(LaraItem->pos.yRot);
floor = GetFloor(x, y, z, &roomNum);
if (GetFloorHeight(floor, x, y, z) >= y - 256)
{

28
TR5Main/Objects/TR3/Vehicles/upv.cpp
View file

@ -118,8 +118,8 @@ static void FireSubHarpoon(ITEM_INFO* v)
item->pos.yRot = v->pos.yRot;
item->pos.zRot = 0;
item->fallspeed = (short)(-HARPOON_SPEED * phd_sin(item->pos.xRot) >> W2V_SHIFT);
item->speed = (short)(HARPOON_SPEED * phd_cos(item->pos.xRot) >> W2V_SHIFT);
item->fallspeed = -HARPOON_SPEED * phd_sin(item->pos.xRot);
item->speed = HARPOON_SPEED * phd_cos(item->pos.xRot);
item->hitPoints = HARPOON_TIME;
item->itemFlags[0] = 1;
@ -162,8 +162,8 @@ static void TriggerSubMist(long x, long y, long z, long speed, short angle)
sptr->x = x + ((GetRandomControl() & 15) - 8);
sptr->y = y + ((GetRandomControl() & 15) - 8);
sptr->z = z + ((GetRandomControl() & 15) - 8);
zv = (speed * phd_cos(angle)) >> (W2V_SHIFT + 2);
xv = (speed * phd_sin(angle)) >> (W2V_SHIFT + 2);
zv = speed * phd_cos(angle) / 4;
xv = speed * phd_sin(angle) / 4;
sptr->xVel = xv + ((GetRandomControl() & 127) - 64);
sptr->yVel = 0;
sptr->zVel = zv + ((GetRandomControl() & 127) - 64);
@ -280,10 +280,10 @@ static int CanGetOff(ITEM_INFO* v)
return 0;
yangle = v->pos.yRot + ANGLE(180);
speed = (GETOFF_DIST * phd_cos(v->pos.xRot)) >> W2V_SHIFT;
x = v->pos.xPos + (speed * phd_sin(yangle) >> W2V_SHIFT);
z = v->pos.zPos + (speed * phd_cos(yangle) >> W2V_SHIFT);
y = v->pos.yPos - ((GETOFF_DIST * phd_sin(-v->pos.xRot)) >> W2V_SHIFT);
speed = GETOFF_DIST * phd_cos(v->pos.xRot);
x = v->pos.xPos + speed * phd_sin(yangle);
z = v->pos.zPos + speed * phd_cos(yangle);
y = v->pos.yPos - GETOFF_DIST * phd_sin(-v->pos.xRot);
roomNumber = v->roomNumber;
floor = GetFloor(x, y, z, &roomNumber);
@ -386,8 +386,8 @@ static void DoCurrent(ITEM_INFO* item)
dz = target.z - LaraItem->pos.zPos;
speed = FixedCameras[sinkval].data;
dx = phd_sin(angle << 4) * speed >> 4;
dz = phd_cos(angle << 4) * speed >> 4;
dx = phd_sin(angle << 4) * speed * 1024;
dz = phd_cos(angle << 4) * speed * 1024;
Lara.currentXvel += (dx - Lara.currentXvel) >> 4;
Lara.currentZvel += (dz - Lara.currentZvel) >> 4;
@ -425,7 +425,7 @@ static void BackgroundCollision(ITEM_INFO* v, ITEM_INFO* l, SUB_INFO* sub)
else
coll->facing = Lara.moveAngle = v->pos.yRot - ANGLE(180);
height = phd_sin(v->pos.xRot) * SUB_LENGTH >> W2V_SHIFT;
height = phd_sin(v->pos.xRot) * SUB_LENGTH;
if (height < 0)
height = -height;
if (height < 200)
@ -878,9 +878,9 @@ int SubControl(void)
else if (v->pos.xRot < -UPDOWN_LIMIT)
v->pos.xRot = -UPDOWN_LIMIT;
v->pos.xPos += (((phd_sin(v->pos.yRot) * v->speed) >> W2V_SHIFT)* phd_cos(v->pos.xRot)) >> W2V_SHIFT;
v->pos.yPos -= (phd_sin(v->pos.xRot) * v->speed) >> W2V_SHIFT;
v->pos.zPos += (((phd_cos(v->pos.yRot) * v->speed) >> W2V_SHIFT)* phd_cos(v->pos.xRot)) >> W2V_SHIFT;
v->pos.xPos += phd_sin(v->pos.yRot) * v->speed * phd_cos(v->pos.xRot);
v->pos.yPos -= phd_sin(v->pos.xRot) * v->speed;
v->pos.zPos += phd_cos(v->pos.yRot) * v->speed * phd_cos(v->pos.xRot);
}
/* -------- determine if vehicle is near the surface */

28
TR5Main/Objects/TR4/Entity/tr4_baddy.cpp
View file

@ -236,8 +236,8 @@ void InitialiseBaddy(short itemNum)
item->frameNumber = g_Level.Anims[item->animNumber].frameBase;
item->goalAnimState = STATE_BADDY_CLIMB_4_CLICKS;
item->currentAnimState = STATE_BADDY_CLIMB_4_CLICKS;
item->pos.xPos += phd_sin(item->pos.yRot) * (STEP_SIZE * 4) >> W2V_SHIFT;
item->pos.zPos += phd_cos(item->pos.yRot) * (STEP_SIZE * 4) >> W2V_SHIFT;
item->pos.xPos += phd_sin(item->pos.yRot) * (STEP_SIZE * 4);
item->pos.zPos += phd_cos(item->pos.yRot) * (STEP_SIZE * 4);
return;
}
@ -248,8 +248,8 @@ void InitialiseBaddy(short itemNum)
item->frameNumber = g_Level.Anims[item->animNumber].frameBase;
item->goalAnimState = STATE_BADDY_CROUCH;
item->currentAnimState = STATE_BADDY_CROUCH;
item->pos.xPos += phd_sin(item->pos.yRot) * (STEP_SIZE * 4) >> W2V_SHIFT;
item->pos.zPos += phd_cos(item->pos.yRot) * (STEP_SIZE * 4) >> W2V_SHIFT;
item->pos.xPos += phd_sin(item->pos.yRot) * (STEP_SIZE * 4);
item->pos.zPos += phd_cos(item->pos.yRot) * (STEP_SIZE * 4);
item->itemFlags[3] = ocb;
return;
@ -298,8 +298,8 @@ void BaddyControl(short itemNum)
int y = item->pos.yPos;
int z = item->pos.zPos;
int dx = 942 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = 942 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = 942 * phd_sin(item->pos.yRot);
int dz = 942 * phd_cos(item->pos.yRot);
x += dx;
z += dz;
@ -492,8 +492,8 @@ void BaddyControl(short itemNum)
jump = false;
}
dx = 942 * phd_sin(item->pos.yRot + ANGLE(45)) >> W2V_SHIFT;
dz = 942 * phd_cos(item->pos.yRot + ANGLE(45)) >> W2V_SHIFT;
dx = 942 * phd_sin(item->pos.yRot + ANGLE(45));
dz = 942 * phd_cos(item->pos.yRot + ANGLE(45));
x = item->pos.xPos + dx;
y = item->pos.yPos;
@ -503,8 +503,8 @@ void BaddyControl(short itemNum)
floor = GetFloor(x, y, z, &roomNumber);
int height4 = GetFloorHeight(floor, x, y, z);
dx = 942 * phd_sin(item->pos.yRot + ANGLE(78.75f)) >> W2V_SHIFT;
dz = 942 * phd_cos(item->pos.yRot + ANGLE(78.75f)) >> W2V_SHIFT;
dx = 942 * phd_sin(item->pos.yRot + ANGLE(78.75f));
dz = 942 * phd_cos(item->pos.yRot + ANGLE(78.75f));
x = item->pos.xPos + dx;
y = item->pos.yPos;
@ -523,8 +523,8 @@ void BaddyControl(short itemNum)
jump = false;
}
dx = 942 * phd_sin(item->pos.yRot - ANGLE(45)) >> W2V_SHIFT;
dz = 942 * phd_cos(item->pos.yRot - ANGLE(45)) >> W2V_SHIFT;
dx = 942 * phd_sin(item->pos.yRot - ANGLE(45));
dz = 942 * phd_cos(item->pos.yRot - ANGLE(45));
x = item->pos.xPos + dx;
y = item->pos.yPos;
@ -534,8 +534,8 @@ void BaddyControl(short itemNum)
floor = GetFloor(x, y, z, &roomNumber);
int height6 = GetFloorHeight(floor, x, y, z);
dx = 942 * phd_sin(item->pos.yRot - ANGLE(78.75f)) >> W2V_SHIFT;
dz = 942 * phd_cos(item->pos.yRot - ANGLE(78.75f)) >> W2V_SHIFT;
dx = 942 * phd_sin(item->pos.yRot - ANGLE(78.75f));
dz = 942 * phd_cos(item->pos.yRot - ANGLE(78.75f));
x = item->pos.xPos + dx;
y = item->pos.yPos;

16
TR5Main/Objects/TR4/Entity/tr4_bigscorpion.cpp
View file

@ -50,16 +50,16 @@ void ScorpionControl(short itemNumber)
short joint3 = 0;
short roomNumber = item->roomNumber;
int x = item->pos.xPos + 682 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int z = item->pos.zPos + 682 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int x = item->pos.xPos + 682 * phd_sin(item->pos.yRot);
int z = item->pos.zPos + 682 * phd_cos(item->pos.yRot);
FLOOR_INFO* floor = GetFloor(x, item->pos.yPos, z, &roomNumber);
int height1 = GetFloorHeight(floor, x, item->pos.yPos, z);
if (abs(item->pos.yPos - height1) > 512)
height1 = item->pos.yPos;
x = item->pos.xPos - 682 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
z = item->pos.zPos - 682 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
x = item->pos.xPos - 682 * phd_sin(item->pos.yRot);
z = item->pos.zPos - 682 * phd_cos(item->pos.yRot);
floor = GetFloor(x, item->pos.yPos, z, &roomNumber);
int height2 = GetFloorHeight(floor, x, item->pos.yPos, z);
@ -68,16 +68,16 @@ void ScorpionControl(short itemNumber)
short angle1 = phd_atan(1344, height2 - height1);
x = item->pos.xPos - 682 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
z = item->pos.zPos + 682 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
x = item->pos.xPos - 682 * phd_sin(item->pos.yRot);
z = item->pos.zPos + 682 * phd_cos(item->pos.yRot);
floor = GetFloor(x, item->pos.yPos, z, &roomNumber);
int height3 = GetFloorHeight(floor, x, item->pos.yPos, z);
if (abs(item->pos.yPos - height3) > 512)
height3 = item->pos.yPos;
x = item->pos.xPos + 682 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
z = item->pos.zPos - 682 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
x = item->pos.xPos + 682 * phd_sin(item->pos.yRot);
z = item->pos.zPos - 682 * phd_cos(item->pos.yRot);
floor = GetFloor(x, item->pos.yPos, z, &roomNumber);
int height4 = GetFloorHeight(floor, x, item->pos.yPos, z);

4
TR5Main/Objects/TR4/Entity/tr4_demigod.cpp
View file

@ -207,9 +207,9 @@ static void DemigodHammerAttack(int x, int y, int z, int something)
spark->x = (GetRandomControl() & 0x1F) + x - 16;
spark->y = (GetRandomControl() & 0x1F) + y - 16;
spark->z = (GetRandomControl() & 0x1F) + z - 16;
spark->xVel = (byte)(GetRandomControl() + 256) * phd_sin(angle) >> W2V_SHIFT;
spark->xVel = (byte)(GetRandomControl() + 256) * phd_sin(angle);
spark->yVel = -32 - (GetRandomControl() & 0x3F);
spark->zVel = (byte)(GetRandomControl() + 256) * phd_cos(angle) >> W2V_SHIFT;
spark->zVel = (byte)(GetRandomControl() + 256) * phd_cos(angle);
spark->friction = 9;
if (GetRandomControl() & 1)

18
TR5Main/Objects/TR4/Entity/tr4_enemy_jeep.cpp
View file

@ -31,9 +31,9 @@ void EnemyJeepLaunchGrenade(ITEM_INFO* item)
grenadeItem->pos.yRot = item->pos.yRot + -ANGLE(180);
grenadeItem->pos.zRot = 0;
grenadeItem->pos.xPos = item->pos.xPos + (1024 * phd_sin(grenadeItem->pos.yRot) >> W2V_SHIFT);
grenadeItem->pos.xPos = item->pos.xPos + 1024 * phd_sin(grenadeItem->pos.yRot);
grenadeItem->pos.yPos = item->pos.yPos - 768;
grenadeItem->pos.zPos = item->pos.xPos + (1024 * phd_cos(grenadeItem->pos.yRot) >> W2V_SHIFT);
grenadeItem->pos.zPos = item->pos.xPos + 1024 * phd_cos(grenadeItem->pos.yRot);
SmokeCountL = 32;
SmokeWeapon = 5;
@ -54,7 +54,7 @@ void EnemyJeepLaunchGrenade(ITEM_INFO* item)
grenadeItem->speed = 32;
grenadeItem->currentAnimState = grenadeItem->pos.xRot;
grenadeItem->fallspeed = -32 * phd_sin(grenadeItem->pos.xRot) >> W2V_SHIFT;
grenadeItem->fallspeed = -32 * phd_sin(grenadeItem->pos.xRot);
grenadeItem->goalAnimState = grenadeItem->pos.yRot;
grenadeItem->requiredAnimState = 0;
grenadeItem->hitPoints = 120;
@ -96,8 +96,8 @@ void EnemyJeepControl(short itemNumber)
int y = item->pos.yPos;
int z = item->pos.zPos;
int dx = 682 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = 682 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = 682 * phd_sin(item->pos.yRot);
int dz = 682 * phd_cos(item->pos.yRot);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x - dz, y, z - dx, &roomNumber);
@ -337,8 +337,8 @@ void EnemyJeepControl(short itemNumber)
target->boxNumber = aiObject->boxNumber;
if (!(aiObject->flags & 0x20))
{
target->pos.xPos += 256 * phd_sin(target->pos.yRot) >> W2V_SHIFT;
target->pos.zPos += 256 * phd_cos(target->pos.yRot) >> W2V_SHIFT;
target->pos.xPos += 256 * phd_sin(target->pos.yRot);
target->pos.zPos += 256 * phd_cos(target->pos.yRot);
}
}
}
@ -366,8 +366,8 @@ void EnemyJeepControl(short itemNumber)
if (item->itemFlags[0] < 0)
item->itemFlags[0] = 0;
dx = item->itemFlags[0] * phd_sin(-2 - xRot / 512) >> W2V_SHIFT;
dz = item->itemFlags[0] * phd_cos(-2 - xRot / 512) >> W2V_SHIFT;
dx = item->itemFlags[0] * phd_sin(-2 - xRot / 512);
dz = item->itemFlags[0] * phd_cos(-2 - xRot / 512);
item->pos.xPos += dx / 64;
item->pos.zPos += dz / 64;

16
TR5Main/Objects/TR4/Entity/tr4_horseman.cpp
View file

@ -45,8 +45,8 @@ static void HorsemanSparks(PHD_VECTOR* pos, int param1, int num)
spark->flags = SP_NONE;
spark->gravity = (r >> 7) & 0x1F;
spark->maxYvel = 0;
spark->zVel = phd_cos((r & 0x7FF) + param1 - 1024) >> 2;
spark->xVel = -phd_sin((r & 0x7FF) + param1 - 1024) >> 2;
spark->zVel = phd_cos((r & 0x7FF) + param1 - 1024) * 4096;
spark->xVel = -phd_sin((r & 0x7FF) + param1 - 1024) * 4096;
}
for (int i = 0; i < num; i++)
@ -87,8 +87,8 @@ static void HorsemanSparks(PHD_VECTOR* pos, int param1, int num)
spark->dSize = spark->sSize / 2;
spark->flags = 26;
spark->maxYvel = 0;
spark->zVel = phd_cos((r & 0x7FF) + param1 - 1024) >> 2;
spark->xVel = -phd_sin((r & 0x7FF) + param1 - 1024) >> 2;
spark->zVel = phd_cos((r & 0x7FF) + param1 - 1024) * 4096;
spark->xVel = -phd_sin((r & 0x7FF) + param1 - 1024) * 4096;
}
}
@ -172,16 +172,16 @@ void HorsemanControl(short itemNumber)
y = horseItem->pos.yPos;
z = horseItem->pos.zPos;
x = horseItem->pos.xPos + 341 * phd_sin(horseItem->pos.yRot) >> 14;
x = horseItem->pos.xPos + 341 * phd_sin(horseItem->pos.yRot);
y = horseItem->pos.yPos;
z = horseItem->pos.zPos + 341 * phd_cos(horseItem->pos.yRot) >> 14;
z = horseItem->pos.zPos + 341 * phd_cos(horseItem->pos.yRot);
floor = GetFloor(x, y, z, &roomNumber);
height1 = GetFloorHeight(floor, x, y, z);
x = horseItem->pos.xPos - 341 * phd_sin(horseItem->pos.yRot) >> 14;
x = horseItem->pos.xPos - 341 * phd_sin(horseItem->pos.yRot);
y = horseItem->pos.yPos;
z = horseItem->pos.zPos - 341 * phd_cos(horseItem->pos.yRot) >> 14;
z = horseItem->pos.zPos - 341 * phd_cos(horseItem->pos.yRot);
floor = GetFloor(x, y, z, &roomNumber);
height2 = GetFloorHeight(floor, x, y, z);

4
TR5Main/Objects/TR4/Entity/tr4_littlebeetle.cpp
View file

@ -140,9 +140,9 @@ void UpdateLittleBeetles()
int oldy = beetle->pos.yPos;
int oldz = beetle->pos.zPos;
beetle->pos.xPos += beetle->speed * phd_sin(beetle->pos.yRot) >> W2V_SHIFT;
beetle->pos.xPos += beetle->speed * phd_sin(beetle->pos.yRot);
beetle->pos.yPos += beetle->fallspeed;
beetle->pos.zPos += beetle->speed * phd_cos(beetle->pos.yRot) >> W2V_SHIFT;
beetle->pos.zPos += beetle->speed * phd_cos(beetle->pos.yRot);
beetle->fallspeed += GRAVITY;

4
TR5Main/Objects/TR4/Entity/tr4_sas.cpp
View file

@ -592,9 +592,9 @@ void SasDragBlokeCollision(short itemNumber, ITEM_INFO* l, COLL_INFO* c)
{
if (item->frameNumber == g_Level.Anims[item->animNumber].frameEnd)
{
int x = l->pos.xPos - (512 * phd_sin(l->pos.yRot) >> W2V_SHIFT);
int x = l->pos.xPos - 512 * phd_sin(l->pos.yRot);
int y = l->pos.yPos;
int z = l->pos.xPos - (512 * phd_cos(l->pos.yRot) >> W2V_SHIFT);
int z = l->pos.xPos - 512 * phd_cos(l->pos.yRot);
short roomNumber = l->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);

2
TR5Main/Objects/TR4/Entity/tr4_sentrygun.cpp
View file

@ -146,7 +146,7 @@ void SentryGunControl(short itemNum)
{
// Throw fire
SentryGunThrowFire(item);
c = phd_sin((GlobalCounter & 0x1F) << 11) >> 2;
c = phd_sin((GlobalCounter & 0x1F) << 11) * 4096;
}
else
{

4
TR5Main/Objects/TR4/Entity/tr4_setha.cpp
View file

@ -40,8 +40,8 @@ void SethaControl(short itemNumber)
int y = item->pos.yPos;
int z = item->pos.zPos;
int dx = 870 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = 870 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = 870 * phd_sin(item->pos.yRot);
int dz = 870 * phd_cos(item->pos.yRot);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);

24
TR5Main/Objects/TR4/Entity/tr4_skeleton.cpp
View file

@ -52,9 +52,9 @@ static void WakeUpSkeleton(ITEM_INFO* item)
spark->x = fx->pos.xPos;
spark->y = fx->pos.yPos;
spark->z = fx->pos.zPos;
spark->xVel = phd_sin(fx->pos.yRot) >> 2;
spark->xVel = phd_sin(fx->pos.yRot) * 4096;
spark->yVel = 0;
spark->zVel = phd_cos(fx->pos.yRot) >> 2;
spark->zVel = phd_cos(fx->pos.yRot) * 4096;
spark->transType = COLADD;
spark->friction = 68;
spark->flags = 26;
@ -139,8 +139,8 @@ void SkeletonControl(short itemNumber)
int y = item->pos.yPos;
int z = item->pos.zPos;
int dx = 870 * phd_sin(item->pos.yRot) >> 14;
int dz = 870 * phd_cos(item->pos.yRot) >> 14;
int dx = 870 * phd_sin(item->pos.yRot);
int dz = 870 * phd_cos(item->pos.yRot);
x += dx;
z += dz;
@ -256,8 +256,8 @@ void SkeletonControl(short itemNumber)
}
else
{
dx = 870 * phd_sin(item->pos.yRot + ANGLE(45)) >> 14;
dz = 870 * phd_cos(item->pos.yRot + ANGLE(45)) >> 14;
dx = 870 * phd_sin(item->pos.yRot + ANGLE(45));
dz = 870 * phd_cos(item->pos.yRot + ANGLE(45));
x = item->pos.xPos + dx;
y = item->pos.yPos;
@ -267,8 +267,8 @@ void SkeletonControl(short itemNumber)
floor = GetFloor(x, y, z, &roomNumber);
int height4 = GetFloorHeight(floor, x, y, z);
dx = 870 * phd_sin(item->pos.yRot + 14336) >> 14;
dz = 870 * phd_cos(item->pos.yRot + 14336) >> 14;
dx = 870 * phd_sin(item->pos.yRot + 14336);
dz = 870 * phd_cos(item->pos.yRot + 14336);
x = item->pos.xPos + dx;
y = item->pos.yPos;
@ -287,8 +287,8 @@ void SkeletonControl(short itemNumber)
someFlag2 = false;
}
dx = 870 * phd_sin(item->pos.yRot - 8192) >> 14;
dz = 870 * phd_cos(item->pos.yRot - 8192) >> 14;
dx = 870 * phd_sin(item->pos.yRot - 8192);
dz = 870 * phd_cos(item->pos.yRot - 8192);
x = item->pos.xPos + dx;
y = item->pos.yPos;
@ -298,8 +298,8 @@ void SkeletonControl(short itemNumber)
floor = GetFloor(x, y, z, &roomNumber);
int height6 = GetFloorHeight(floor, x, y, z);
dx = 870 * phd_sin(item->pos.yRot - 14336) >> 14;
dz = 870 * phd_cos(item->pos.yRot - 14336) >> 14;
dx = 870 * phd_sin(item->pos.yRot - 14336);
dz = 870 * phd_cos(item->pos.yRot - 14336);
x = item->pos.xPos + dx;
y = item->pos.yPos;

8
TR5Main/Objects/TR4/Entity/tr4_sphinx.cpp
View file

@ -32,9 +32,9 @@ void SphinxControl(short itemNumber)
CREATURE_INFO* creature = (CREATURE_INFO*)item->data;
OBJECT_INFO* obj = &Objects[item->objectNumber];
int x = item->pos.xPos + 614 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int x = item->pos.xPos + 614 * phd_sin(item->pos.yRot);
int y = item->pos.yPos;
int z = item->pos.zPos + 614 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int z = item->pos.zPos + 614 * phd_cos(item->pos.yRot);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);
@ -61,9 +61,9 @@ void SphinxControl(short itemNumber)
}
}
x = item->pos.xPos - 614 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
x = item->pos.xPos - 614 * phd_sin(item->pos.yRot);
y = item->pos.yPos;
z = item->pos.zPos - 614 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
z = item->pos.zPos - 614 * phd_cos(item->pos.yRot);
roomNumber = item->roomNumber;

4
TR5Main/Objects/TR4/Entity/tr4_von_croy.cpp
View file

@ -82,8 +82,8 @@ void VonCroyControl(short itemNumber)
int x = item->pos.xPos;
int z = item->pos.zPos;
int dx = 808 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = 808 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = 808 * phd_sin(item->pos.yRot);
int dz = 808 * phd_cos(item->pos.yRot);
x += dx;
z += dz;

10
TR5Main/Objects/TR4/Entity/tr4_wraith.cpp
View file

@ -161,9 +161,9 @@ void WraithControl(short itemNumber)
oldY = item->pos.yPos;
oldZ = item->pos.zPos;
item->pos.xPos += item->speed * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.yPos += item->speed * phd_sin(item->pos.xRot) >> W2V_SHIFT;
item->pos.zPos += item->speed * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos += item->speed * phd_sin(item->pos.yRot);
item->pos.yPos += item->speed * phd_sin(item->pos.xRot);
item->pos.zPos += item->speed * phd_cos(item->pos.yRot);
IsRoomOutsideNo = NO_ROOM;
IsRoomOutside(item->pos.xPos, item->pos.yPos, item->pos.zPos);
@ -541,9 +541,9 @@ void WraithWallsEffect(int x, int y, int z, short yrot, short objNumber)
spark->z = (GetRandomControl() & 0x1F) + z - 16;
short rot = yrot + GetRandomControl() - ANGLE(90);
short velocity = ((GetRandomControl() & 0x3FF) + 1024);
spark->xVel = velocity * phd_sin(rot) >> W2V_SHIFT;
spark->xVel = velocity * phd_sin(rot);
spark->yVel = (GetRandomControl() & 0x7F) - 64;
spark->zVel = velocity * phd_cos(rot) >> W2V_SHIFT;
spark->zVel = velocity * phd_cos(rot);
spark->friction = 4;
spark->flags = SP_EXPDEF | SP_DEF | SP_SCALE;
spark->maxYvel = 0;

6
TR5Main/Objects/TR4/Trap/tr4_slicerdicer.cpp
View file

@ -9,8 +9,8 @@ void InitialiseSlicerDicer(short itemNum)
{
ITEM_INFO* item = &g_Level.Items[itemNum];
int dx = phd_sin(item->pos.yRot + ANGLE(90.0f)) >> 5;
int dz = phd_cos(item->pos.yRot + ANGLE(90.0f)) >> 5;
int dx = phd_sin(item->pos.yRot + ANGLE(90.0f)) * 512;
int dz = phd_cos(item->pos.yRot + ANGLE(90.0f)) * 512;
item->pos.xPos += dx;
item->pos.zPos += dz;
@ -28,7 +28,7 @@ void SlicerDicerControl(short itemNum)
SoundEffect(SFX_TR4_METAL_SCRAPE_LOOP1, &item->pos, 0);
SoundEffect(SFX_TR4_METAL_SCRAPE_LOOP, &item->pos, 0);
int factor = (9 * phd_cos(item->triggerFlags) << 9 >> W2V_SHIFT) * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int factor = 4608 * phd_cos(item->triggerFlags) * phd_cos(item->pos.yRot);
item->pos.xPos = (item->itemFlags[0] << 8) + factor;
item->pos.yPos = (item->itemFlags[1] << 8) - 4608 * phd_sin(item->triggerFlags);

4
TR5Main/Objects/TR4/Trap/tr4_spikywall.cpp
View file

@ -14,8 +14,8 @@ void ControlSpikyWall(short itemNum)
/* Move wall */
if (TriggerActive(item) && item->status != ITEM_DEACTIVATED)
{
int x = item->pos.xPos + phd_sin(item->pos.yRot) >> WALL_SHIFT;
int z = item->pos.zPos + phd_cos(item->pos.yRot) >> WALL_SHIFT;
int x = item->pos.xPos + phd_sin(item->pos.yRot);
int z = item->pos.zPos + phd_cos(item->pos.yRot);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x, item->pos.yPos, z, &roomNumber);

50
TR5Main/Objects/TR4/Vehicles/jeep.cpp
View file

@ -70,13 +70,13 @@ extern Inventory g_Inventory;
static int TestJeepHeight(ITEM_INFO* item, int dz, int dx, PHD_VECTOR* pos)
{
pos->y = item->pos.yPos - (dz * phd_sin(item->pos.xRot) >> W2V_SHIFT) + (dx * phd_sin(item->pos.zRot) >> W2V_SHIFT);
pos->y = item->pos.yPos - dz * phd_sin(item->pos.xRot) + dx * phd_sin(item->pos.zRot);
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
pos->z = item->pos.zPos + ((dz * c - dx * s) >> W2V_SHIFT);
pos->x = item->pos.xPos + ((dz * s + dx * c) >> W2V_SHIFT);
pos->z = item->pos.zPos + dz * c - dx * s;
pos->x = item->pos.xPos + dz * s + dx * c;
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(pos->x, pos->y, pos->z, &roomNumber);
@ -243,9 +243,9 @@ static int JeepCanGetOff()
short angle = item->pos.yRot + 0x4000;
int x = item->pos.xPos - (JEEP_GETOFF_DISTANCE * phd_sin(angle) >> W2V_SHIFT);
int x = item->pos.xPos - JEEP_GETOFF_DISTANCE * phd_sin(angle);
int y = item->pos.yPos;
int z = item->pos.zPos - (JEEP_GETOFF_DISTANCE * phd_cos(angle) >> W2V_SHIFT);
int z = item->pos.zPos - JEEP_GETOFF_DISTANCE * phd_cos(angle);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);
@ -301,9 +301,9 @@ static void TriggerJeepExhaustSmoke(int x, int y, int z, short angle, short spee
spark->x = (GetRandomControl() & 0xF) + x - 8;
spark->y = (GetRandomControl() & 0xF) + y - 8;
spark->z = (GetRandomControl() & 0xF) + z - 8;
spark->xVel = speed * phd_sin(angle) >> (W2V_SHIFT + 2);
spark->xVel = speed * phd_sin(angle) / 4;
spark->yVel = -8 - (GetRandomControl() & 7);
spark->zVel = speed * phd_cos(angle) >> (W2V_SHIFT + 2);
spark->zVel = speed * phd_cos(angle) / 4;
spark->friction = 4;
if (GetRandomControl() & 1)
@ -367,8 +367,8 @@ static int JeepCheckGetOff()
LaraItem->frameNumber = g_Level.Anims[LaraItem->animNumber].frameBase;
LaraItem->goalAnimState = LS_STOP;
LaraItem->currentAnimState = LS_STOP;
LaraItem->pos.xPos -= JEEP_GETOFF_DISTANCE * phd_sin(LaraItem->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.zPos -= JEEP_GETOFF_DISTANCE * phd_cos(LaraItem->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.xPos -= JEEP_GETOFF_DISTANCE * phd_sin(LaraItem->pos.yRot);
LaraItem->pos.zPos -= JEEP_GETOFF_DISTANCE * phd_cos(LaraItem->pos.yRot);
LaraItem->pos.xRot = 0;
LaraItem->pos.zRot = 0;
Lara.Vehicle = NO_ITEM;
@ -487,10 +487,10 @@ static int GetJeepCollisionAnim(ITEM_INFO* item, PHD_VECTOR* p)
if (p->x || p->z)
{
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
int front = ((p->z * c) + (p->x * s)) >> W2V_SHIFT;
int side = (-(p->z * s) + (p->x * c)) >> W2V_SHIFT;
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
int front = p->z * c + p->x * s;
int side = -p->z * s + p->x * c;
if (abs(front) > abs(side))
{
@ -716,15 +716,15 @@ static int JeepDynamics(ITEM_INFO* item)
if (item->pos.yPos < height)
speed = item->speed;
else
speed = item->speed * phd_cos(item->pos.xRot) >> W2V_SHIFT;
speed = item->speed * phd_cos(item->pos.xRot);
item->pos.xPos += (speed * phd_sin(jeep->momentumAngle)) >> W2V_SHIFT;
item->pos.zPos += (speed * phd_cos(jeep->momentumAngle)) >> W2V_SHIFT;
item->pos.xPos += speed * phd_sin(jeep->momentumAngle);
item->pos.zPos += speed * phd_cos(jeep->momentumAngle);
int slip = 0;
if (item->pos.yPos >= height)
{
slip = JEEP_SLIP * phd_sin(item->pos.xRot) >> W2V_SHIFT;
slip = JEEP_SLIP * phd_sin(item->pos.xRot);
if (abs(slip) > 16)
{
@ -736,20 +736,20 @@ static int JeepDynamics(ITEM_INFO* item)
jeep->velocity = slip;
}
slip = JEEP_SLIP_SIDE * phd_sin(item->pos.zRot) >> W2V_SHIFT;
slip = JEEP_SLIP_SIDE * phd_sin(item->pos.zRot);
if (abs(slip) > JEEP_SLIP_SIDE / 4)
{
JeepNoGetOff = 1;
if (slip >= 0)
{
item->pos.xPos += (slip - 24) * phd_sin(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
item->pos.zPos += (slip - 24) * phd_cos(item->pos.yRot + ANGLE(90)) >> W2V_SHIFT;
item->pos.xPos += (slip - 24) * phd_sin(item->pos.yRot + ANGLE(90));
item->pos.zPos += (slip - 24) * phd_cos(item->pos.yRot + ANGLE(90));
}
else
{
item->pos.xPos += (slip - 24) * phd_sin(item->pos.yRot - ANGLE(90)) >> W2V_SHIFT;
item->pos.zPos += (slip - 24) * phd_cos(item->pos.yRot - ANGLE(90)) >> W2V_SHIFT;
item->pos.xPos += (slip - 24) * phd_sin(item->pos.yRot - ANGLE(90));
item->pos.zPos += (slip - 24) * phd_cos(item->pos.yRot - ANGLE(90));
}
}
}
@ -832,7 +832,7 @@ static int JeepDynamics(ITEM_INFO* item)
if (collide)
{
newspeed = ((item->pos.zPos - oldPos.z) * phd_cos(jeep->momentumAngle) + (item->pos.xPos - oldPos.x) * phd_sin(jeep->momentumAngle)) >> W2V_SHIFT;
newspeed = (item->pos.zPos - oldPos.z) * phd_cos(jeep->momentumAngle) + (item->pos.xPos - oldPos.x) * phd_sin(jeep->momentumAngle);
newspeed <<= 8;
if ((&g_Level.Items[Lara.Vehicle] == item) && (jeep->velocity == JEEP_MAX_SPEED) && (newspeed < (JEEP_MAX_SPEED - 10)))

48
TR5Main/Objects/TR4/Vehicles/motorbike.cpp
View file

@ -98,13 +98,13 @@ void InitialiseMotorbike(short itemNumber)
static int TestMotorbikeHeight(ITEM_INFO* item, int dz, int dx, PHD_VECTOR* pos)
{
pos->y = item->pos.yPos - (dz * phd_sin(item->pos.xRot) >> W2V_SHIFT) + (dx * phd_sin(item->pos.zRot) >> W2V_SHIFT);
pos->y = item->pos.yPos - dz * phd_sin(item->pos.xRot) + dx * phd_sin(item->pos.zRot);
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
pos->z = item->pos.zPos + ((dz * c - dx * s) >> W2V_SHIFT);
pos->x = item->pos.xPos + ((dz * s + dx * c) >> W2V_SHIFT);
pos->z = item->pos.zPos + dz * c - dx * s;
pos->x = item->pos.xPos + dz * s + dx * c;
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(pos->x, pos->y, pos->z, &roomNumber);
@ -391,9 +391,9 @@ static void TriggerMotorbikeExhaustSmoke(int x, int y, int z, short angle, short
sptr->x = x + (GetRandomControl() & 0xF) - 8;
sptr->y = y + (GetRandomControl() & 0xF) - 8;
sptr->z = z + (GetRandomControl() & 0xF) - 8;
sptr->xVel = (speed * phd_sin(angle)) >> 16;
sptr->xVel = speed * phd_sin(angle) / 4;
sptr->yVel = (GetRandomControl() & 7) - 8;
sptr->zVel = (speed * phd_cos(angle)) >> 16;
sptr->zVel = speed * phd_cos(angle) / 4;
sptr->friction = 4;
if (GetRandomControl() & 1)
@ -521,8 +521,8 @@ static int MotorBikeCheckGetOff(void)
LaraItem->frameNumber = g_Level.Anims[LaraItem->animNumber].frameBase;
LaraItem->goalAnimState = LS_STOP;
LaraItem->currentAnimState = LS_STOP;
LaraItem->pos.xPos -= 2 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.zPos -= 2 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
LaraItem->pos.xPos -= 2 * phd_sin(item->pos.yRot);
LaraItem->pos.zPos -= 2 * phd_cos(item->pos.yRot);
LaraItem->pos.xRot = 0;
LaraItem->pos.zRot = 0;
Lara.Vehicle = NO_ITEM;
@ -600,10 +600,10 @@ static int GetMotorbikeCollisionAnim(ITEM_INFO* item, PHD_VECTOR* pos)
if (pos->x || pos->z)
{
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
int front = ((pos->z * c) + (pos->x * s)) >> W2V_SHIFT;
int side = (-(pos->z * s) + (pos->x * c)) >> W2V_SHIFT;
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
int front = pos->z * c + pos->x * s;
int side = -pos->z * s + pos->x * c;
if (abs(front) > abs(side))
{
@ -720,19 +720,19 @@ static int MotorBikeDynamics(ITEM_INFO* item)
floor = GetFloor(item->pos.xPos, item->pos.yPos, item->pos.zPos, &room_number);
height = GetFloorHeight(floor, item->pos.xPos, item->pos.yPos, item->pos.zPos);
if (item->pos.yPos >= height)
speed = (item->speed * phd_cos(item->pos.xRot)) >> W2V_SHIFT;
speed = item->speed * phd_cos(item->pos.xRot);
else
speed = item->speed;
item->pos.zPos += (speed * phd_cos(motorbike->momentumAngle)) >> W2V_SHIFT;
item->pos.xPos += (speed * phd_sin(motorbike->momentumAngle)) >> W2V_SHIFT;
item->pos.zPos += speed * phd_cos(motorbike->momentumAngle);
item->pos.xPos += speed * phd_sin(motorbike->momentumAngle);
if (item->pos.yPos >= height)
{
short anglex = 100 * phd_sin(item->pos.xRot) >> W2V_SHIFT;
short anglex = 100 * phd_sin(item->pos.xRot);
if (abs(anglex) > 16)
{
short anglex2 = 100 * phd_sin(item->pos.xRot) >> W2V_SHIFT;
short anglex2 = 100 * phd_sin(item->pos.xRot);
if (anglex < 0)
anglex2 = -anglex;
if (anglex2 > 24)
@ -741,7 +741,7 @@ static int MotorBikeDynamics(ITEM_INFO* item)
motorbike->velocity -= anglex;
}
short anglez = 100 * phd_sin(item->pos.zRot) >> W2V_SHIFT;
short anglez = 100 * phd_sin(item->pos.zRot);
if (abs(anglez) > 32)
{
short ang, angabs;
@ -751,8 +751,8 @@ static int MotorBikeDynamics(ITEM_INFO* item)
else
ang = item->pos.yRot - 0x4000;
angabs = abs(anglez) - 24;
item->pos.xPos += angabs * phd_sin(ang) >> W2V_SHIFT;
item->pos.zPos += angabs * phd_cos(ang) >> W2V_SHIFT;
item->pos.xPos += angabs * phd_sin(ang);
item->pos.zPos += angabs * phd_cos(ang);
}
}
@ -841,7 +841,7 @@ static int MotorBikeDynamics(ITEM_INFO* item)
collide = GetMotorbikeCollisionAnim(item, &moved);
if (collide)
{
newspeed = ((item->pos.zPos - oldpos.z) * phd_cos(motorbike->momentumAngle) + (item->pos.xPos - oldpos.x) * phd_sin(motorbike->momentumAngle)) >> 6;
newspeed = ((item->pos.zPos - oldpos.z) * phd_cos(motorbike->momentumAngle) + (item->pos.xPos - oldpos.x) * phd_sin(motorbike->momentumAngle)) * 256;
if (&g_Level.Items[Lara.Vehicle] == item && motorbike->velocity >= 0x8000 && newspeed < (motorbike->velocity - 10))
{
LaraItem->hitPoints -= (motorbike->velocity - newspeed) >> 7;
@ -870,9 +870,9 @@ static BOOL MotorbikeCanGetOff(void)
item = &g_Level.Items[Lara.Vehicle];
angle = item->pos.yRot + 0x4000;
x = item->pos.xPos + ((500 * phd_sin(angle)) >> W2V_SHIFT);
x = item->pos.xPos + 500 * phd_sin(angle);
y = item->pos.yPos;
z = item->pos.zPos + ((500 * phd_cos(angle)) >> W2V_SHIFT);
z = item->pos.zPos + 500 * phd_cos(angle);
room_number = item->roomNumber;
floor = GetFloor(x, y, z, &room_number);

8
TR5Main/Objects/TR5/Emitter/tr5_bats_emitter.cpp
View file

@ -201,11 +201,11 @@ void UpdateBats()
bat->pos.xRot += xAngle;
}
int sp = bat->speed * phd_cos(bat->pos.xRot) >> W2V_SHIFT;
int sp = bat->speed * phd_cos(bat->pos.xRot);
bat->pos.xPos += sp * phd_sin(bat->pos.yRot) >> W2V_SHIFT;
bat->pos.yPos += bat->speed * phd_sin(-bat->pos.xRot) >> W2V_SHIFT;
bat->pos.zPos += sp * phd_cos(bat->pos.yRot) >> W2V_SHIFT;
bat->pos.xPos += sp * phd_sin(bat->pos.yRot);
bat->pos.yPos += bat->speed * phd_sin(-bat->pos.xRot);
bat->pos.zPos += sp * phd_cos(bat->pos.yRot);
if ((i % 2 == 0)
&& bat->pos.xPos > x1

6
TR5Main/Objects/TR5/Emitter/tr5_dart_emitter.cpp
View file

@ -21,9 +21,9 @@ void DartControl(short itemNumber)
}
else
{
item->pos.xPos += item->speed * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.yPos -= item->speed * phd_sin(item->pos.xRot) >> W2V_SHIFT;
item->pos.xPos += item->speed * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos += item->speed * phd_sin(item->pos.yRot);
item->pos.yPos -= item->speed * phd_sin(item->pos.xRot);
item->pos.xPos += item->speed * phd_cos(item->pos.yRot);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(item->pos.xPos, item->pos.yPos, item->pos.zPos, &roomNumber);

4
TR5Main/Objects/TR5/Emitter/tr5_rats_emitter.cpp
View file

@ -147,9 +147,9 @@ void UpdateRats()
int oldY = rat->pos.yPos;
int oldZ = rat->pos.zPos;
rat->pos.xPos += rat->speed * phd_sin(rat->pos.yRot) >> W2V_SHIFT;
rat->pos.xPos += rat->speed * phd_sin(rat->pos.yRot);
rat->pos.yPos += rat->fallspeed;
rat->pos.zPos += rat->speed * phd_cos(rat->pos.yRot) >> W2V_SHIFT;
rat->pos.zPos += rat->speed * phd_cos(rat->pos.yRot);
rat->fallspeed += GRAVITY;

4
TR5Main/Objects/TR5/Emitter/tr5_spider_emitter.cpp
View file

@ -149,9 +149,9 @@ void UpdateSpiders()
int y = spider->pos.yPos;
int z = spider->pos.zPos;
spider->pos.xPos += spider->speed * phd_sin(spider->pos.yRot) >> W2V_SHIFT;
spider->pos.xPos += spider->speed * phd_sin(spider->pos.yRot);
spider->pos.yPos += spider->fallspeed;
spider->pos.zPos += spider->speed * phd_cos(spider->pos.yRot) >> W2V_SHIFT;
spider->pos.zPos += spider->speed * phd_cos(spider->pos.yRot);
spider->fallspeed += GRAVITY;
int dx = LaraItem->pos.xPos - spider->pos.xPos;

4
TR5Main/Objects/TR5/Entity/tr5_chef.cpp
View file

@ -34,8 +34,8 @@ void InitialiseChef(short itemNumber)
item->goalAnimState = STATE_CHEF_COOKING;
item->currentAnimState = STATE_CHEF_COOKING;
item->frameNumber = g_Level.Anims[item->animNumber].frameBase;
item->pos.xPos += 192 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.zPos += 192 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos += 192 * phd_sin(item->pos.yRot);
item->pos.zPos += 192 * phd_cos(item->pos.yRot);
}
void ControlChef(short itemNumber)

4
TR5Main/Objects/TR5/Entity/tr5_cyborg.cpp
View file

@ -93,8 +93,8 @@ void HitmanControl(short itemNumber)
int x = item->pos.xPos;
int z = item->pos.zPos;
int dx = 808 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = 808 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = 808 * phd_sin(item->pos.yRot);
int dz = 808 * phd_cos(item->pos.yRot);
x += dx;
z += dz;

16
TR5Main/Objects/TR5/Entity/tr5_guard.cpp
View file

@ -140,8 +140,8 @@ void InitialiseGuard(short itemNum)
case 9:
item->goalAnimState = STATE_GUARD_USE_COMPUTER;
item->animNumber = anim + 59;
item->pos.xPos -= phd_sin(item->pos.yRot); // 4 * not exist there ??
item->pos.zPos -= phd_cos(item->pos.yRot); // 4 * not exist there ??
item->pos.xPos -= 512 * phd_sin(item->pos.yRot);
item->pos.zPos -= 512 * phd_cos(item->pos.yRot);
break;
case 8:
item->goalAnimState = STATE_GUARD_HUNTING_IDLE;
@ -166,8 +166,8 @@ void InitialiseSniper(short itemNum)
item->goalAnimState = STATE_SNIPER_STOP;
item->currentAnimState = STATE_SNIPER_STOP;
item->pos.yPos += STEP_SIZE * 2;
item->pos.xPos += phd_sin(item->pos.yRot);
item->pos.zPos += phd_cos(item->pos.yRot);
item->pos.xPos += 1024 * phd_sin(item->pos.yRot + ANGLE(90));
item->pos.zPos += 1024 * phd_cos(item->pos.yRot + ANGLE(90));
}
void InitialiseGuardLaser(short itemNum)
@ -205,8 +205,8 @@ void GuardControl(short itemNum)
short joint0 = 0;
int x = item->pos.xPos;
int z = item->pos.zPos;
int dx = 870 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = 870 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = 870 * phd_sin(item->pos.yRot);
int dz = 870 * phd_cos(item->pos.yRot);
x += dx;
z += dz;
short roomNumber = item->roomNumber;
@ -1018,8 +1018,8 @@ void Mafia2Control(short itemNum)
int x = item->pos.xPos;
int y = item->pos.yPos;
int z = item->pos.zPos;
int dx = 870 * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = 870 * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = 870 * phd_sin(item->pos.yRot);
int dz = 870 * phd_cos(item->pos.yRot);
x += dx;
z += dz;
short roomNumber = item->roomNumber;

28
TR5Main/Objects/TR5/Entity/tr5_laser_head.cpp
View file

@ -239,7 +239,7 @@ void LaserHeadControl(short itemNumber)
}
}
item->pos.yPos = item->itemFlags[1] - ((192 - item->speed) * phd_sin(item->itemFlags[2]) >> W2V_SHIFT);
item->pos.yPos = item->itemFlags[1] - (192 - item->speed) * phd_sin(item->itemFlags[2]);
item->itemFlags[2] += ONE_DEGREE * item->speed;
if (!(GlobalCounter & 7))
@ -281,7 +281,7 @@ void LaserHeadControl(short itemNumber)
else
{
item->triggerFlags++;
item->pos.yPos = item->itemFlags[1] - (128 * phd_sin(item->itemFlags[2]) >> W2V_SHIFT);
item->pos.yPos = item->itemFlags[1] - 128 * phd_sin(item->itemFlags[2]);
item->itemFlags[2] += ANGLE(3);
// Get guardian head's position
@ -338,10 +338,10 @@ void LaserHeadControl(short itemNumber)
else
yRot = 2 * GetRandomControl();
int v = ((GetRandomControl() & 0x1FFF) + 8192);
int c = v * phd_cos(-xRot) >> W2V_SHIFT;
dest.x = src.x + (c * phd_sin(yRot) >> W2V_SHIFT);
dest.y = src.y + (v * phd_sin(-xRot) >> W2V_SHIFT);
dest.z = src.z + (c * phd_cos(yRot) >> W2V_SHIFT);
int c = v * phd_cos(-xRot);
dest.x = src.x + c * phd_sin(yRot);
dest.y = src.y + v * phd_sin(-xRot);
dest.z = src.z + c * phd_cos(yRot);
if (condition)
{
@ -375,11 +375,11 @@ void LaserHeadControl(short itemNumber)
if (JustLoaded)
{
int c = 8192 * phd_cos(item->pos.xRot + 3328) >> W2V_SHIFT;
int c = 8192 * phd_cos(item->pos.xRot + 3328);
dest.x = LaserHeadData.target.x = src.x + (c * phd_sin(item->pos.yRot) >> W2V_SHIFT);
dest.y = LaserHeadData.target.y = src.y + (8192 * phd_sin(3328 - item->pos.xRot) >> W2V_SHIFT);
dest.z = LaserHeadData.target.z = src.z + (c * phd_cos(item->pos.yRot) >> W2V_SHIFT);
dest.x = LaserHeadData.target.x = src.x + c * phd_sin(item->pos.yRot);
dest.y = LaserHeadData.target.y = src.y + 8192 * phd_sin(3328 - item->pos.xRot);
dest.z = LaserHeadData.target.z = src.z + c * phd_cos(item->pos.yRot);
}
else
{
@ -471,10 +471,10 @@ void LaserHeadControl(short itemNumber)
src.z = 0;
GetJointAbsPosition(item, (PHD_VECTOR*)& src, GuardianMeshes[i]);
int c = 8192 * phd_cos(angles[1]) >> W2V_SHIFT;
dest.x = src.x + (c * phd_sin(item->pos.yRot) >> W2V_SHIFT);
dest.y = src.y + (8192 * phd_sin(-angles[1]) >> W2V_SHIFT);
dest.z = src.z + (c * phd_cos(item->pos.yRot) >> W2V_SHIFT);
int c = 8192 * phd_cos(angles[1]);
dest.x = src.x + c * phd_sin(item->pos.yRot);
dest.y = src.y + 8192 * phd_sin(-angles[1]);
dest.z = src.z + c * phd_cos(item->pos.yRot);
if (item->itemFlags[3] != 90
&& LaserHeadData.fireArcs[j] != NULL)

4
TR5Main/Objects/TR5/Entity/tr5_roman_statue.cpp
View file

@ -273,8 +273,8 @@ void InitialiseRomanStatue(short itemNum)
item->currentAnimState = 13;
item->frameNumber = g_Level.Anims[item->animNumber].frameBase;
item->status = ITEM_NOT_ACTIVE;
item->pos.xPos += 486 * phd_sin(item->pos.yRot + ANGLE(90.0f)) >> W2V_SHIFT;
item->pos.zPos += 486 * phd_cos(item->pos.yRot + ANGLE(90.0f)) >> W2V_SHIFT;
item->pos.xPos += 486 * phd_sin(item->pos.yRot + ANGLE(90.0f));
item->pos.zPos += 486 * phd_cos(item->pos.yRot + ANGLE(90.0f));
ZeroMemory(&RomanStatueData, sizeof(ROMAN_STATUE_STRUCT));
}

12
TR5Main/Objects/TR5/Entity/tr5_submarine.cpp
View file

@ -403,8 +403,8 @@ void ChaffFlareControl(short itemNumber)
item->pos.zRot += ANGLE(5);
}
int dx = item->speed * phd_sin(item->pos.yRot) >> W2V_SHIFT;
int dz = item->speed * phd_cos(item->pos.yRot) >> W2V_SHIFT;
int dx = item->speed * phd_sin(item->pos.yRot);
int dz = item->speed * phd_cos(item->pos.yRot);
item->pos.xPos += dx;
item->pos.zPos += dz;
@ -569,11 +569,11 @@ void TorpedoControl(short itemNumber)
item->pos.zRot += 16 * item->speed;
int c = item->speed * phd_cos(item->pos.xRot) >> W2V_SHIFT;
int c = item->speed * phd_cos(item->pos.xRot);
item->pos.xPos += c * phd_sin(item->pos.yRot) >> W2V_SHIFT;
item->pos.yPos += item->speed * phd_sin(-item->pos.xRot) >> W2V_SHIFT;
item->pos.zPos += c * phd_cos(item->pos.yRot) >> W2V_SHIFT;
item->pos.xPos += c * phd_sin(item->pos.yRot);
item->pos.yPos += item->speed * phd_sin(-item->pos.xRot);
item->pos.zPos += c * phd_cos(item->pos.yRot);
short roomNumber = item->roomNumber;
FLOOR_INFO* floor = GetFloor(item->pos.xPos, item->pos.yPos, item->pos.zPos, &roomNumber);

10
TR5Main/Objects/TR5/Light/tr5_light.cpp
View file

@ -16,7 +16,7 @@ void PulseLightControl(short itemNumber)
{
item->itemFlags[0] -= 1024;
long pulse = 256 * phd_sin(item->itemFlags[0] + 4 * (item->pos.yPos & 0x3FFF)) >> W2V_SHIFT;
long pulse = 256 * phd_sin(item->itemFlags[0] + 4 * (item->pos.yPos & 0x3FFF));
pulse = abs(pulse);
if (pulse > 255)
pulse = 255;
@ -41,9 +41,9 @@ void TriggerAlertLight(int x, int y, int z, int r, int g, int b, int angle, shor
source.z = z;
GetFloor(x, y, z, &room);
source.roomNumber = room;
target.x = x + phd_sin(16 * angle);
target.x = x + 16384 * phd_sin(16 * angle);
target.y = y;
target.z = z + phd_cos(16 * angle);
target.z = z + 16384 * phd_cos(16 * angle);
if (!LOS(&source, &target))
TriggerDynamicLight(target.x, target.y, target.z, falloff, r, g, b);
}
@ -70,9 +70,9 @@ void StrobeLightControl(short itemNumber)
12);
TriggerDynamicLight(
item->pos.xPos + 256 * phd_sin(item->pos.yRot + 22528) >> W2V_SHIFT,
item->pos.xPos + 256 * phd_sin(item->pos.yRot + 22528),
item->pos.yPos - 768,
item->pos.zPos + 256 * phd_cos(item->pos.yRot + 22528) >> W2V_SHIFT,
item->pos.zPos + 256 * phd_cos(item->pos.yRot + 22528),
8,
r, g, b);
}

4
TR5Main/Objects/TR5/Object/tr5_bodypart.cpp
View file

@ -34,9 +34,9 @@ void ControlBodyPart(short fxNumber)
fx->fallspeed += 2;
}
fx->pos.xPos += fx->speed * phd_sin(fx->pos.yRot) >> W2V_SHIFT;
fx->pos.xPos += fx->speed * phd_sin(fx->pos.yRot);
fx->pos.yPos += fx->fallspeed;
fx->pos.zPos += fx->speed * phd_cos(fx->pos.yRot) >> W2V_SHIFT;
fx->pos.zPos += fx->speed * phd_cos(fx->pos.yRot);
short roomNumber = fx->roomNumber;
FLOOR_INFO* floor = GetFloor(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos, &roomNumber);

8
TR5Main/Objects/TR5/Object/tr5_missile.cpp
View file

@ -105,11 +105,11 @@ void MissileControl(short itemNumber)
int y = fx->pos.yPos;
int z = fx->pos.zPos;
int c = fx->speed * phd_cos(fx->pos.xRot) >> W2V_SHIFT;
int c = fx->speed * phd_cos(fx->pos.xRot);
fx->pos.xPos += c * phd_sin(fx->pos.yRot) >> W2V_SHIFT;
fx->pos.yPos += fx->speed * phd_sin(-fx->pos.xRot) >> W2V_SHIFT;
fx->pos.zPos += c * phd_cos(fx->pos.yRot) >> W2V_SHIFT;
fx->pos.xPos += c * phd_sin(fx->pos.yRot);
fx->pos.yPos += fx->speed * phd_sin(-fx->pos.xRot);
fx->pos.zPos += c * phd_cos(fx->pos.yRot);
short roomNumber = fx->roomNumber;
FLOOR_INFO* floor = GetFloor(fx->pos.xPos, fx->pos.yPos, fx->pos.zPos, &roomNumber);

4
TR5Main/Objects/TR5/Object/tr5_rollingball.cpp
View file

@ -428,8 +428,8 @@ void ClassicRollingBallControl(short itemNum)
ydist = 1024;
}
x = item->pos.xPos + (dist * phd_sin(item->pos.yRot) >> W2V_SHIFT);
z = item->pos.zPos + (dist * phd_cos(item->pos.yRot) >> W2V_SHIFT);
x = item->pos.xPos + dist * phd_sin(item->pos.yRot);
z = item->pos.zPos + dist * phd_cos(item->pos.yRot);
floor = GetFloor(x, item->pos.yPos, z, &roomNum);
y1 = GetFloorHeight(floor, x, item->pos.yPos, z);

12
TR5Main/Objects/TR5/Trap/tr5_deathslide.cpp
View file

@ -85,11 +85,11 @@ void ControlDeathSlide(short itemNumber)
if (item->fallspeed < 100)
item->fallspeed += 5;
int c = phd_cos(item->pos.yRot);
int s = phd_sin(item->pos.yRot);
float c = phd_cos(item->pos.yRot);
float s = phd_sin(item->pos.yRot);
item->pos.zPos += item->fallspeed * c >> W2V_SHIFT;
item->pos.xPos += item->fallspeed * s >> W2V_SHIFT;
item->pos.zPos += item->fallspeed * c;
item->pos.xPos += item->fallspeed * s;
item->pos.yPos += item->fallspeed >> 2;
short roomNumber = item->roomNumber;
@ -104,9 +104,9 @@ void ControlDeathSlide(short itemNumber)
LaraItem->pos.zPos = item->pos.zPos;
}
int x = item->pos.xPos + (1024 * s >> W2V_SHIFT);
int x = item->pos.xPos + 1024 * s;
int y = item->pos.yPos + 64;
int z = item->pos.zPos + (1024 * c >> W2V_SHIFT);
int z = item->pos.zPos + 1024 * c;
FLOOR_INFO* floor = GetFloor(x, y, z, &roomNumber);

12
TR5Main/Objects/TR5/Trap/tr5_ventilator.cpp
View file

@ -66,8 +66,8 @@ static void VentilatorEffect(BOUNDING_BOX* bounds, int intensity, short rot, int
int factor = 3 * (bounds->X2 - bounds->X1) / 8;
short angle = 2 * GetRandomControl();
spark->x = ((bounds->X1 + bounds->X2) / 2) + ((GetRandomControl() % factor) * phd_sin(angle) >> W2V_SHIFT);
spark->z = ((bounds->Z1 + bounds->Z2) / 2) + ((GetRandomControl() % factor) * phd_cos(angle) >> W2V_SHIFT);
spark->x = ((bounds->X1 + bounds->X2) / 2) + (GetRandomControl() % factor) * phd_sin(angle);
spark->z = ((bounds->Z1 + bounds->Z2) / 2) + (GetRandomControl() % factor) * phd_cos(angle);
if (intensity >= 0)
spark->y = bounds->Y2;
@ -92,8 +92,8 @@ static void VentilatorEffect(BOUNDING_BOX* bounds, int intensity, short rot, int
else
spark->z = bounds->Z1;
spark->x = ((bounds->X1 + bounds->X2) / 2) + ((GetRandomControl() % factor) * phd_cos(angle) >> W2V_SHIFT);
spark->y += (GetRandomControl() % factor) * phd_sin(angle) >> W2V_SHIFT;
spark->x = ((bounds->X1 + bounds->X2) / 2) + (GetRandomControl() % factor) * phd_cos(angle);
spark->y += (GetRandomControl() % factor) * phd_sin(angle);
spark->xVel = 0;
spark->zVel = 16 * intensity * ((GetRandomControl() & 0x1F) + 224);
}
@ -104,8 +104,8 @@ static void VentilatorEffect(BOUNDING_BOX* bounds, int intensity, short rot, int
else
spark->x = bounds->X1;
spark->y += (GetRandomControl() % factor) * phd_sin(angle) >> W2V_SHIFT;
spark->z = ((bounds->Z1 + bounds->Z2) / 2) + ((GetRandomControl() % factor) * phd_cos(angle) >> W2V_SHIFT);
spark->y += (GetRandomControl() % factor) * phd_sin(angle);
spark->z = ((bounds->Z1 + bounds->Z2) / 2) + (GetRandomControl() % factor) * phd_cos(angle);
spark->zVel = 0;
spark->xVel = 16 * intensity * ((GetRandomControl() & 0x1F) + 224);
}