mirror of
https://github.com/HarbourMasters/SpaghettiKart
synced 2026-09-03 18:43:38 -04:00
[WIP] Migrated code
This commit is contained in:
@@ -7,12 +7,27 @@
|
||||
#include <ultra64.h>
|
||||
#endif
|
||||
|
||||
typedef f32 Vec3f[3];
|
||||
typedef f32 Vec4f[4];
|
||||
typedef struct Vec4f {
|
||||
/* 0x0 */ f32 x;
|
||||
/* 0x4 */ f32 y;
|
||||
/* 0x8 */ f32 z;
|
||||
/* 0xC */ f32 w;
|
||||
} Vec4f; // size = 0x10
|
||||
|
||||
typedef struct {
|
||||
/* 0x0 */ f32 x;
|
||||
/* 0x4 */ f32 y;
|
||||
/* 0x8 */ f32 z;
|
||||
} Vec3f; // size = 0xC
|
||||
|
||||
typedef struct {
|
||||
/* 0x0 */ s16 x;
|
||||
/* 0x2 */ s16 y;
|
||||
/* 0x4 */ s16 z;
|
||||
} Vec3s; // size = 0x6;
|
||||
|
||||
typedef s32 Vec3iu[3];
|
||||
|
||||
typedef s16 Vec3s[3];
|
||||
typedef u16 Vec3su[3];
|
||||
typedef s16 Vec4s[4];
|
||||
|
||||
|
||||
@@ -15,7 +15,7 @@ void render_actor_banana(Camera* camera, UNUSED Mat4 arg1, struct BananaActor* b
|
||||
Vec3s sp7C;
|
||||
Mat4 sp3C;
|
||||
|
||||
f32 temp = is_within_render_distance(camera->pos, banana->pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
|
||||
f32 temp = is_within_render_distance(camera->pos, banana->pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
|
||||
490000.0f);
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp = MAX(temp, 0.0f);
|
||||
@@ -25,11 +25,11 @@ void render_actor_banana(Camera* camera, UNUSED Mat4 arg1, struct BananaActor* b
|
||||
return;
|
||||
}
|
||||
|
||||
if ((banana->pos[1] > gCourseMaxY + 800.0f)) {
|
||||
if ((banana->pos.y > gCourseMaxY + 800.0f)) {
|
||||
actor_not_rendered(camera, (struct Actor*) banana);
|
||||
return;
|
||||
}
|
||||
if (banana->pos[1] < (gCourseMinY - 800.0f)) {
|
||||
if (banana->pos.y < (gCourseMinY - 800.0f)) {
|
||||
actor_not_rendered(camera, (struct Actor*) banana);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -31,24 +31,24 @@ void update_actor_banana(struct BananaActor* banana) {
|
||||
player = &gPlayers[banana->playerId];
|
||||
switch (banana->state) {
|
||||
case HELD_BANANA:
|
||||
temp_f2 = player->pos[0] - banana->pos[0];
|
||||
temp_f14 = player->pos[1] - banana->pos[1];
|
||||
temp_f16 = player->pos[2] - banana->pos[2];
|
||||
temp_f2 = player->pos.x - banana->pos.x;
|
||||
temp_f14 = player->pos.y - banana->pos.y;
|
||||
temp_f16 = player->pos.z - banana->pos.z;
|
||||
temp_f12 = sqrtf((temp_f2 * temp_f2) + (temp_f14 * temp_f14) + (temp_f16 * temp_f16)) / 10.0f;
|
||||
if (temp_f12 == 0.0f) {
|
||||
banana->pos[0] = player->pos[0] + 0.2f;
|
||||
banana->pos[1] = player->pos[1] + 0.2f;
|
||||
banana->pos[2] = player->pos[2] + 0.2f;
|
||||
banana->pos.x = player->pos.x + 0.2f;
|
||||
banana->pos.y = player->pos.y + 0.2f;
|
||||
banana->pos.z = player->pos.z + 0.2f;
|
||||
} else {
|
||||
temp_f2 /= temp_f12;
|
||||
temp_f14 /= temp_f12;
|
||||
temp_f16 /= temp_f12;
|
||||
banana->pos[0] = player->pos[0] - temp_f2;
|
||||
banana->pos[1] = player->pos[1] - temp_f14 - 2.0f;
|
||||
banana->pos[2] = player->pos[2] - temp_f16;
|
||||
banana->pos.x = player->pos.x - temp_f2;
|
||||
banana->pos.y = player->pos.y - temp_f14 - 2.0f;
|
||||
banana->pos.z = player->pos.z - temp_f16;
|
||||
}
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
|
||||
banana->pos[2]);
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
|
||||
banana->pos.z);
|
||||
func_802B4E30((struct Actor*) banana);
|
||||
if ((player->type & PLAYER_HUMAN) != 0) {
|
||||
if (gDemoMode) {
|
||||
@@ -73,13 +73,13 @@ void update_actor_banana(struct BananaActor* banana) {
|
||||
}
|
||||
vec3f_set(someVelocity, 0, pad3, temp_f0);
|
||||
func_802B64C4(someVelocity, player->rotation[1] + player->unk_0C0);
|
||||
banana->velocity[0] = someVelocity[0];
|
||||
banana->velocity[1] = someVelocity[1];
|
||||
banana->velocity[2] = someVelocity[2];
|
||||
banana->velocity.x = someVelocity[0];
|
||||
banana->velocity.y = someVelocity[1];
|
||||
banana->velocity.z = someVelocity[2];
|
||||
} else {
|
||||
banana->velocity[0] = 0;
|
||||
banana->velocity[1] = 1.5f;
|
||||
banana->velocity[2] = 0;
|
||||
banana->velocity.x = 0;
|
||||
banana->velocity.y = 1.5f;
|
||||
banana->velocity.z = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -91,27 +91,27 @@ void update_actor_banana(struct BananaActor* banana) {
|
||||
banana->flags &= ~0x1000;
|
||||
}
|
||||
}
|
||||
banana->pos[0] += banana->velocity[0];
|
||||
banana->pos[2] += banana->velocity[2];
|
||||
if (banana->velocity[1] > -1.0f) {
|
||||
banana->velocity[1] -= 0.15f;
|
||||
banana->pos.x += banana->velocity.x;
|
||||
banana->pos.z += banana->velocity.z;
|
||||
if (banana->velocity.y > -1.0f) {
|
||||
banana->velocity.y -= 0.15f;
|
||||
}
|
||||
banana->pos[1] += banana->velocity[1];
|
||||
if ((banana->pos[2] < (f32) gCourseMinZ) || ((f32) gCourseMaxZ < banana->pos[2]) ||
|
||||
(banana->pos[0] < (f32) gCourseMinX) || ((f32) gCourseMaxX < banana->pos[0]) ||
|
||||
(banana->pos[1] < (f32) gCourseMinY)) {
|
||||
banana->pos.y += banana->velocity.y;
|
||||
if ((banana->pos.z < (f32) gCourseMinZ) || ((f32) gCourseMaxZ < banana->pos.z) ||
|
||||
(banana->pos.x < (f32) gCourseMinX) || ((f32) gCourseMaxX < banana->pos.x) ||
|
||||
(banana->pos.y < (f32) gCourseMinY)) {
|
||||
destroy_destructable_actor((struct Actor*) banana);
|
||||
} else {
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
|
||||
banana->pos[2]);
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
|
||||
banana->pos.z);
|
||||
banana->unk30.unk34 = 1;
|
||||
if ((banana->unk30.unk34 != 0) && (banana->unk30.surfaceDistance[2] < 0.0f)) {
|
||||
someOtherVelocity[0] = -banana->unk30.orientationVector[0];
|
||||
someOtherVelocity[1] = -banana->unk30.orientationVector[1];
|
||||
someOtherVelocity[2] = -banana->unk30.orientationVector[2];
|
||||
banana->pos[0] += someOtherVelocity[0] * banana->unk30.surfaceDistance[2];
|
||||
banana->pos[1] += someOtherVelocity[1] * banana->unk30.surfaceDistance[2];
|
||||
banana->pos[2] += someOtherVelocity[2] * banana->unk30.surfaceDistance[2];
|
||||
banana->pos.x += someOtherVelocity[0] * banana->unk30.surfaceDistance[2];
|
||||
banana->pos.y += someOtherVelocity[1] * banana->unk30.surfaceDistance[2];
|
||||
banana->pos.z += someOtherVelocity[2] * banana->unk30.surfaceDistance[2];
|
||||
banana->flags &= ~0x1000;
|
||||
banana->state = 4;
|
||||
}
|
||||
@@ -122,61 +122,61 @@ void update_actor_banana(struct BananaActor* banana) {
|
||||
someVelocity[1] = 0.0f;
|
||||
someVelocity[2] = -5.0f;
|
||||
func_802B64C4(someVelocity, player->rotation[1] + player->unk_0C0);
|
||||
unkX = player->pos[0] + someVelocity[0];
|
||||
unkY = player->pos[1] + someVelocity[1];
|
||||
unkZ = player->pos[2] + someVelocity[2];
|
||||
temp_f2 = unkX - banana->pos[0];
|
||||
temp_f14 = unkY - banana->pos[1];
|
||||
temp_f16 = unkZ - banana->pos[2];
|
||||
unkX = player->pos.x + someVelocity[0];
|
||||
unkY = player->pos.y + someVelocity[1];
|
||||
unkZ = player->pos.z + someVelocity[2];
|
||||
temp_f2 = unkX - banana->pos.x;
|
||||
temp_f14 = unkY - banana->pos.y;
|
||||
temp_f16 = unkZ - banana->pos.z;
|
||||
temp_f0 = sqrtf((temp_f2 * temp_f2) + (temp_f14 * temp_f14) + (temp_f16 * temp_f16));
|
||||
if (temp_f0 == 0.0f) {
|
||||
banana->pos[0] = player->pos[0] + 0.2f;
|
||||
banana->pos[1] = player->pos[1] + 0.2f;
|
||||
banana->pos[2] = player->pos[2] + 0.2f;
|
||||
banana->pos.x = player->pos.x + 0.2f;
|
||||
banana->pos.y = player->pos.y + 0.2f;
|
||||
banana->pos.z = player->pos.z + 0.2f;
|
||||
} else {
|
||||
temp_f2 /= temp_f0;
|
||||
temp_f14 /= temp_f0;
|
||||
temp_f16 /= temp_f0;
|
||||
banana->pos[0] = someVelocity[0] + (unkX - temp_f2);
|
||||
banana->pos[1] = unkY - temp_f14 - 2.0f;
|
||||
banana->pos[2] = unkZ - temp_f16;
|
||||
banana->pos.x = someVelocity[0] + (unkX - temp_f2);
|
||||
banana->pos.y = unkY - temp_f14 - 2.0f;
|
||||
banana->pos.z = unkZ - temp_f16;
|
||||
}
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
|
||||
banana->pos[2]);
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
|
||||
banana->pos.z);
|
||||
func_802B4E30((struct Actor*) banana);
|
||||
break;
|
||||
case BANANA_BUNCH_BANANA:
|
||||
elderBanana = (struct BananaActor*) GET_ACTOR(banana->elderIndex);
|
||||
temp_f2 = elderBanana->pos[0] - banana->pos[0];
|
||||
temp_f14 = elderBanana->pos[1] - banana->pos[1];
|
||||
temp_f16 = elderBanana->pos[2] - banana->pos[2];
|
||||
temp_f2 = elderBanana->pos.x - banana->pos.x;
|
||||
temp_f14 = elderBanana->pos.y - banana->pos.y;
|
||||
temp_f16 = elderBanana->pos.z - banana->pos.z;
|
||||
temp_f12 = sqrtf((temp_f2 * temp_f2) + (temp_f14 * temp_f14) + (temp_f16 * temp_f16)) / 5.0f;
|
||||
if (temp_f12 == 0.0f) {
|
||||
banana->pos[0] = elderBanana->pos[0] + 0.2f;
|
||||
banana->pos[1] = elderBanana->pos[1] + 0.2f;
|
||||
banana->pos[2] = elderBanana->pos[2] + 0.2f;
|
||||
banana->pos.x = elderBanana->pos.x + 0.2f;
|
||||
banana->pos.y = elderBanana->pos.y + 0.2f;
|
||||
banana->pos.z = elderBanana->pos.z + 0.2f;
|
||||
} else {
|
||||
temp_f2 /= temp_f12;
|
||||
temp_f14 /= temp_f12;
|
||||
temp_f16 /= temp_f12;
|
||||
banana->pos[0] = elderBanana->pos[0] - temp_f2;
|
||||
banana->pos[1] = elderBanana->pos[1] - temp_f14 - 2.0f;
|
||||
banana->pos[2] = elderBanana->pos[2] - temp_f16;
|
||||
banana->pos.x = elderBanana->pos.x - temp_f2;
|
||||
banana->pos.y = elderBanana->pos.y - temp_f14 - 2.0f;
|
||||
banana->pos.z = elderBanana->pos.z - temp_f16;
|
||||
}
|
||||
var_f8 = banana->pos[2];
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos[0], banana->pos[1],
|
||||
banana->pos[2]);
|
||||
var_f8 = banana->pos.z;
|
||||
check_bounding_collision(&banana->unk30, banana->boundingBoxSize + 1.0f, banana->pos.x, banana->pos.y,
|
||||
banana->pos.z);
|
||||
func_802B4E30((struct Actor*) banana);
|
||||
break;
|
||||
case DESTROYED_BANANA:
|
||||
banana->velocity[1] -= 0.3f;
|
||||
if (banana->velocity[1] < -5.0f) {
|
||||
banana->velocity[1] = -5.0f;
|
||||
banana->velocity.y -= 0.3f;
|
||||
if (banana->velocity.y < -5.0f) {
|
||||
banana->velocity.y = -5.0f;
|
||||
}
|
||||
banana->pos[1] += banana->velocity[1];
|
||||
banana->rot[0] += 0x16C;
|
||||
banana->rot[1] -= 0x5B0;
|
||||
banana->rot[2] += 0x38E;
|
||||
banana->pos.y += banana->velocity.y;
|
||||
banana->rot.x += 0x16C;
|
||||
banana->rot.y -= 0x5B0;
|
||||
banana->rot.z += 0x38E;
|
||||
banana->unk_04 -= 1;
|
||||
if (banana->unk_04 == 0) {
|
||||
destroy_actor((struct Actor*) banana);
|
||||
|
||||
@@ -39,18 +39,18 @@ void func_802B3B44(struct ShellActor* shell) {
|
||||
nextWaypoint -= D_80164430;
|
||||
}
|
||||
|
||||
temp_f20 = temp_f2 - shell->pos[0];
|
||||
temp_f22 = temp_f12 - shell->pos[1];
|
||||
temp_f24 = temp_f28 - shell->pos[2];
|
||||
temp_f20 = temp_f2 - shell->pos.x;
|
||||
temp_f22 = temp_f12 - shell->pos.y;
|
||||
temp_f24 = temp_f28 - shell->pos.z;
|
||||
temp_f0 = (temp_f20 * temp_f20) + (temp_f22 * temp_f22) + (temp_f24 * temp_f24);
|
||||
if (temp_f0 > 400.0f) {
|
||||
temp_f18_3 = D_80164490[nextWaypoint].posX;
|
||||
temp_f16_3 = D_80164490[nextWaypoint].posY;
|
||||
temp_f26 = D_80164490[nextWaypoint].posZ;
|
||||
|
||||
temp_f12_0 = temp_f18_3 - shell->pos[0];
|
||||
temp_f12_1 = temp_f16_3 - shell->pos[1];
|
||||
temp_f12_2 = temp_f26 - shell->pos[2];
|
||||
temp_f12_0 = temp_f18_3 - shell->pos.x;
|
||||
temp_f12_1 = temp_f16_3 - shell->pos.y;
|
||||
temp_f12_2 = temp_f26 - shell->pos.z;
|
||||
|
||||
temp_f0_3 = (temp_f12_0 * temp_f12_0) + (temp_f12_1 * temp_f12_1) + (temp_f12_2 * temp_f12_2);
|
||||
if (temp_f0_3 < temp_f0) {
|
||||
@@ -61,9 +61,9 @@ void func_802B3B44(struct ShellActor* shell) {
|
||||
temp_f22 /= temp_f0_2;
|
||||
temp_f24 /= temp_f0_2;
|
||||
|
||||
temp_f12_3 = shell->velocity[0];
|
||||
temp_f14_2 = shell->velocity[1];
|
||||
temp_f16_2 = shell->velocity[2];
|
||||
temp_f12_3 = shell->velocity.x;
|
||||
temp_f14_2 = shell->velocity.y;
|
||||
temp_f16_2 = shell->velocity.z;
|
||||
|
||||
temp_f12_3 += temp_f20;
|
||||
temp_f14_2 += temp_f22;
|
||||
@@ -75,39 +75,39 @@ void func_802B3B44(struct ShellActor* shell) {
|
||||
temp_f14_2 /= temp_f0;
|
||||
temp_f16_2 /= temp_f0;
|
||||
}
|
||||
shell->velocity[0] = temp_f12_3;
|
||||
shell->velocity[1] = temp_f14_2;
|
||||
shell->velocity[2] = temp_f16_2;
|
||||
shell->velocity.x = temp_f12_3;
|
||||
shell->velocity.y = temp_f14_2;
|
||||
shell->velocity.z = temp_f16_2;
|
||||
|
||||
origPos[0] = shell->pos[0];
|
||||
origPos[1] = shell->pos[1];
|
||||
origPos[2] = shell->pos[2];
|
||||
origPos[0] = shell->pos.x;
|
||||
origPos[1] = shell->pos.y;
|
||||
origPos[2] = shell->pos.z;
|
||||
|
||||
shell->pos[0] += temp_f12_3;
|
||||
shell->pos[1] += temp_f14_2;
|
||||
shell->pos[2] += temp_f16_2;
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], origPos[0],
|
||||
shell->pos.x += temp_f12_3;
|
||||
shell->pos.y += temp_f14_2;
|
||||
shell->pos.z += temp_f16_2;
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, origPos[0],
|
||||
origPos[1], origPos[2]);
|
||||
func_802B4E30((struct Actor*) shell);
|
||||
}
|
||||
} else {
|
||||
if (temp_f0 > 5.0f) {
|
||||
shell->pos[0] = temp_f2;
|
||||
shell->pos[1] = shell->boundingBoxSize + temp_f12;
|
||||
shell->pos[2] = temp_f28;
|
||||
shell->pos.x = temp_f2;
|
||||
shell->pos.y = shell->boundingBoxSize + temp_f12;
|
||||
shell->pos.z = temp_f28;
|
||||
shell->pathIndex = nextWaypoint;
|
||||
} else {
|
||||
temp_f18_3 = D_80164490[nextWaypoint].posX;
|
||||
temp_f16_3 = D_80164490[nextWaypoint].posY;
|
||||
temp_f26 = D_80164490[nextWaypoint].posZ;
|
||||
|
||||
shell->pos[0] = (temp_f2 + temp_f18_3) * 0.5f;
|
||||
shell->pos[1] = ((temp_f12 + temp_f16_3) * 0.5f) + shell->boundingBoxSize;
|
||||
shell->pos[2] = (temp_f28 + temp_f26) * 0.5f;
|
||||
shell->pos.x = (temp_f2 + temp_f18_3) * 0.5f;
|
||||
shell->pos.y = ((temp_f12 + temp_f16_3) * 0.5f) + shell->boundingBoxSize;
|
||||
shell->pos.z = (temp_f28 + temp_f26) * 0.5f;
|
||||
|
||||
shell->velocity[0] = (temp_f18_3 - temp_f2) * 0.5f;
|
||||
shell->velocity[1] = (temp_f16_3 - temp_f12) * 0.5f;
|
||||
shell->velocity[2] = (temp_f26 - temp_f28) * 0.5f;
|
||||
shell->velocity.x = (temp_f18_3 - temp_f2) * 0.5f;
|
||||
shell->velocity.y = (temp_f16_3 - temp_f12) * 0.5f;
|
||||
shell->velocity.z = (temp_f26 - temp_f28) * 0.5f;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -118,10 +118,10 @@ void func_802B3E7C(struct ShellActor* shell, Player* player) {
|
||||
f32 xz_dist;
|
||||
Vec3f newPosition;
|
||||
|
||||
x_velocity = player->pos[0];
|
||||
x_velocity -= shell->pos[0];
|
||||
z_velocity = player->pos[2];
|
||||
z_velocity -= shell->pos[2];
|
||||
x_velocity = player->pos.x;
|
||||
x_velocity -= shell->pos.x;
|
||||
z_velocity = player->pos.z;
|
||||
z_velocity -= shell->pos.z;
|
||||
xz_dist = sqrtf((x_velocity * x_velocity) + (z_velocity * z_velocity)) / 8;
|
||||
if (xz_dist == 0.0f) {
|
||||
x_velocity = 0.0f;
|
||||
@@ -131,20 +131,20 @@ void func_802B3E7C(struct ShellActor* shell, Player* player) {
|
||||
z_velocity /= xz_dist;
|
||||
}
|
||||
|
||||
newPosition[0] = shell->pos[0];
|
||||
newPosition[1] = shell->pos[1];
|
||||
newPosition[2] = shell->pos[2];
|
||||
shell->pos[0] += x_velocity;
|
||||
shell->pos[1] -= 2.0f;
|
||||
shell->pos[2] += z_velocity;
|
||||
shell->velocity[0] = x_velocity;
|
||||
shell->velocity[1] = -2.0f;
|
||||
shell->velocity[2] = z_velocity;
|
||||
newPosition[0] = shell->pos.x;
|
||||
newPosition[1] = shell->pos.y;
|
||||
newPosition[2] = shell->pos.z;
|
||||
shell->pos.x += x_velocity;
|
||||
shell->pos.y -= 2.0f;
|
||||
shell->pos.z += z_velocity;
|
||||
shell->velocity.x = x_velocity;
|
||||
shell->velocity.y = -2.0f;
|
||||
shell->velocity.z = z_velocity;
|
||||
|
||||
if (player->effects & BOO_EFFECT) {
|
||||
destroy_destructable_actor((struct Actor*) shell);
|
||||
} else {
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], newPosition[0],
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, newPosition[0],
|
||||
newPosition[1], newPosition[2]);
|
||||
func_802B4E30((struct Actor*) shell);
|
||||
func_802B4104(shell);
|
||||
@@ -234,9 +234,9 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
UNUSED f32 pad17;
|
||||
Vec3f origPos;
|
||||
|
||||
pad1 = shell->pos[0];
|
||||
pad0 = shell->pos[2];
|
||||
pad2 = shell->pos[1];
|
||||
pad1 = shell->pos.x;
|
||||
pad0 = shell->pos.z;
|
||||
pad2 = shell->pos.y;
|
||||
pad13 = shell->type;
|
||||
if ((pad0 < (f32) gCourseMinZ) || ((f32) gCourseMaxZ < pad0) || (pad1 < (f32) gCourseMinX) ||
|
||||
((f32) gCourseMaxX < pad1) || (pad2 < (f32) gCourseMinY)) {
|
||||
@@ -252,16 +252,16 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
somePosVel[1] = player->boundingBoxSize;
|
||||
somePosVel[2] = -(player->boundingBoxSize + shell->boundingBoxSize + 2.0f);
|
||||
mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
|
||||
shell->pos[0] = player->pos[0] + somePosVel[0];
|
||||
pad7 = player->pos[1] - somePosVel[1];
|
||||
shell->pos[2] = player->pos[2] + somePosVel[2];
|
||||
height = calculate_surface_height(shell->pos[0], pad7, shell->pos[2], player->collision.meshIndexZX);
|
||||
shell->pos.x = player->pos.x + somePosVel[0];
|
||||
pad7 = player->pos.y - somePosVel[1];
|
||||
shell->pos.z = player->pos.z + somePosVel[2];
|
||||
height = calculate_surface_height(shell->pos.x, pad7, shell->pos.z, player->collision.meshIndexZX);
|
||||
temp_f2 = pad7 - height;
|
||||
|
||||
if ((temp_f2 < 5.0f) && (temp_f2 > -5.0f)) {
|
||||
shell->pos[1] = shell->boundingBoxSize + height;
|
||||
shell->pos.y = shell->boundingBoxSize + height;
|
||||
} else {
|
||||
shell->pos[1] = pad7;
|
||||
shell->pos.y = pad7;
|
||||
}
|
||||
|
||||
if ((player->type & PLAYER_HUMAN) != 0) {
|
||||
@@ -325,17 +325,17 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
somePosVel[1] = 0.0f;
|
||||
somePosVel[2] = height;
|
||||
func_802B64C4(somePosVel, (s16) (player->rotation[1] + player->unk_0C0));
|
||||
shell->velocity[0] = somePosVel[0];
|
||||
shell->velocity[1] = somePosVel[1];
|
||||
shell->velocity[2] = somePosVel[2];
|
||||
shell->velocity.x = somePosVel[0];
|
||||
shell->velocity.y = somePosVel[1];
|
||||
shell->velocity.z = somePosVel[2];
|
||||
} else {
|
||||
somePosVel[0] = sins(shell->rotAngle) * 8.0f;
|
||||
somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
|
||||
somePosVel[2] = coss(shell->rotAngle) * 8.0f;
|
||||
mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
|
||||
shell->pos[0] = player->pos[0] + somePosVel[0];
|
||||
shell->pos[1] = player->pos[1] + somePosVel[1];
|
||||
shell->pos[2] = player->pos[2] + somePosVel[2];
|
||||
shell->pos.x = player->pos.x + somePosVel[0];
|
||||
shell->pos.y = player->pos.y + somePosVel[1];
|
||||
shell->pos.z = player->pos.z + somePosVel[2];
|
||||
}
|
||||
break;
|
||||
case MOVING_SHELL:
|
||||
@@ -357,7 +357,7 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
shell->targetPlayer = func_802B3FD0(player, shell);
|
||||
if (shell->targetPlayer < 0) {
|
||||
shell->flags = 0x8000;
|
||||
shell->velocity[1] = 3.0f;
|
||||
shell->velocity.y = 3.0f;
|
||||
shell->pathIndex = 0;
|
||||
shell->someTimer = 0x003C;
|
||||
shell->state = DESTROYED_SHELL;
|
||||
@@ -389,17 +389,17 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
}
|
||||
}
|
||||
}
|
||||
shell->velocity[1] -= 0.5;
|
||||
if (shell->velocity[1] < -2.0f) {
|
||||
shell->velocity[1] = -2.0f;
|
||||
shell->velocity.y -= 0.5;
|
||||
if (shell->velocity.y < -2.0f) {
|
||||
shell->velocity.y = -2.0f;
|
||||
}
|
||||
origPos[0] = shell->pos[0];
|
||||
origPos[1] = shell->pos[1];
|
||||
origPos[2] = shell->pos[2];
|
||||
shell->pos[0] += shell->velocity[0];
|
||||
shell->pos[1] += shell->velocity[1];
|
||||
shell->pos[2] += shell->velocity[2];
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], origPos[0],
|
||||
origPos[0] = shell->pos.x;
|
||||
origPos[1] = shell->pos.y;
|
||||
origPos[2] = shell->pos.z;
|
||||
shell->pos.x += shell->velocity.x;
|
||||
shell->pos.y += shell->velocity.y;
|
||||
shell->pos.z += shell->velocity.z;
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, origPos[0],
|
||||
origPos[1], origPos[2]);
|
||||
func_802B4E30((struct Actor*) shell);
|
||||
func_802B4104(shell);
|
||||
@@ -420,10 +420,10 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
case GREEN_SHELL_HIT_A_RACER:
|
||||
func_802B3B44(shell);
|
||||
player = &gPlayers[shell->targetPlayer];
|
||||
height = player->pos[0];
|
||||
height -= shell->pos[0];
|
||||
temp_f2 = player->pos[2];
|
||||
temp_f2 -= shell->pos[2];
|
||||
height = player->pos.x;
|
||||
height -= shell->pos.x;
|
||||
temp_f2 = player->pos.z;
|
||||
temp_f2 -= shell->pos.z;
|
||||
if (((height * height) + (temp_f2 * temp_f2)) < 40000.0f) {
|
||||
shell->state = RED_SHELL_LOCK_ON;
|
||||
}
|
||||
@@ -439,25 +439,25 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
|
||||
somePosVel[2] = coss(shell->rotAngle) * 8.0f;
|
||||
mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
|
||||
origPos[0] = shell->pos[0];
|
||||
origPos[1] = shell->pos[1];
|
||||
origPos[2] = shell->pos[2];
|
||||
shell->pos[0] = player->pos[0] + somePosVel[0];
|
||||
shell->pos[1] = player->pos[1] + somePosVel[1];
|
||||
shell->pos[2] = player->pos[2] + somePosVel[2];
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], origPos[0],
|
||||
origPos[0] = shell->pos.x;
|
||||
origPos[1] = shell->pos.y;
|
||||
origPos[2] = shell->pos.z;
|
||||
shell->pos.x = player->pos.x + somePosVel[0];
|
||||
shell->pos.y = player->pos.y + somePosVel[1];
|
||||
shell->pos.z = player->pos.z + somePosVel[2];
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, origPos[0],
|
||||
origPos[1], origPos[2]);
|
||||
func_802B4E30((struct Actor*) shell);
|
||||
}
|
||||
break;
|
||||
case DESTROYED_SHELL:
|
||||
shell->velocity[1] -= 0.3f;
|
||||
if (shell->velocity[1] < -5.0f) {
|
||||
shell->velocity[1] = -5.0f;
|
||||
shell->velocity.y -= 0.3f;
|
||||
if (shell->velocity.y < -5.0f) {
|
||||
shell->velocity.y = -5.0f;
|
||||
}
|
||||
shell->rotAngle += 0x5B0;
|
||||
shell->someTimer -= 1;
|
||||
shell->pos[1] += shell->velocity[1];
|
||||
shell->pos.y += shell->velocity.y;
|
||||
if (shell->someTimer == 0) {
|
||||
destroy_actor((struct Actor*) shell);
|
||||
}
|
||||
@@ -466,10 +466,10 @@ void update_actor_red_blue_shell(struct ShellActor* shell) {
|
||||
func_802B3B44(shell);
|
||||
shell->targetPlayer = gPlayerPositionLUT[0];
|
||||
player = &gPlayers[gPlayerPositionLUT[0]];
|
||||
height = player->pos[0];
|
||||
height -= shell->pos[0];
|
||||
temp_f2 = player->pos[2];
|
||||
temp_f2 -= shell->pos[2];
|
||||
height = player->pos.x;
|
||||
height -= shell->pos.x;
|
||||
temp_f2 = player->pos.z;
|
||||
temp_f2 -= shell->pos.z;
|
||||
if (((height * height) + (temp_f2 * temp_f2)) < 40000.0f) {
|
||||
shell->state = BLUE_SHELL_TARGET_ELIMINATED;
|
||||
}
|
||||
|
||||
@@ -17,7 +17,7 @@ void render_actor_box_truck(Camera* arg0, struct Actor* arg1) {
|
||||
Mat4 spD8;
|
||||
UNUSED s32 pad2[32];
|
||||
f32 temp_f0 =
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
}
|
||||
|
||||
@@ -16,7 +16,7 @@ void render_actor_car(Camera* arg0, struct Actor* arg1) {
|
||||
Mat4 spC8;
|
||||
UNUSED s32 pad2[32];
|
||||
f32 temp_f0 =
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
}
|
||||
|
||||
@@ -13,15 +13,15 @@
|
||||
* @param arg2
|
||||
*/
|
||||
void render_actor_cow(Camera* camera, Mat4 arg1, struct Actor* arg2) {
|
||||
if (is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
|
||||
if (is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
|
||||
4000000.0f) < 0 &&
|
||||
CVarGetInteger("gNoCulling", 0) == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
switch (arg2->state) {
|
||||
|
||||
@@ -28,24 +28,24 @@ void render_actor_fake_item_box(Camera* camera, struct FakeItemBox* fakeItemBox)
|
||||
// @port: Tag the transform.
|
||||
FrameInterpolation_RecordOpenChild("Fake Item Box", TAG_ITEM_ADDR(fakeItemBox));
|
||||
|
||||
if (is_within_render_distance(camera->pos, fakeItemBox->pos, camera->rot[1], 2500.0f, gCameraZoom[camera - camera1],
|
||||
if (is_within_render_distance(camera->pos, fakeItemBox->pos, camera->rot.y, 2500.0f, gCameraZoom[camera - camera1],
|
||||
1000000.0f) < 0 &&
|
||||
CVarGetInteger("gNoCulling", 0) == 0) {
|
||||
actor_not_rendered(camera, (struct Actor*) fakeItemBox);
|
||||
return;
|
||||
}
|
||||
if (((f32) gCourseMaxY + 800.0f) < fakeItemBox->pos[1]) {
|
||||
if (((f32) gCourseMaxY + 800.0f) < fakeItemBox->pos.y) {
|
||||
actor_not_rendered(camera, (struct Actor*) fakeItemBox);
|
||||
return;
|
||||
}
|
||||
if (fakeItemBox->pos[1] < ((f32) gCourseMinY - 800.0f)) {
|
||||
if (fakeItemBox->pos.y < ((f32) gCourseMinY - 800.0f)) {
|
||||
actor_not_rendered(camera, (struct Actor*) fakeItemBox);
|
||||
return;
|
||||
}
|
||||
|
||||
actor_rendered(camera, (struct Actor*) fakeItemBox);
|
||||
someRot[0] = 0;
|
||||
someRot[1] = fakeItemBox->rot[1];
|
||||
someRot[1] = fakeItemBox->rot.y;
|
||||
someRot[2] = 0;
|
||||
mtxf_pos_rotation_xyz(someMatrix2, fakeItemBox->pos, someRot);
|
||||
mtxf_scale(someMatrix2, fakeItemBox->sizeScaling);
|
||||
@@ -65,13 +65,13 @@ void render_actor_fake_item_box(Camera* camera, struct FakeItemBox* fakeItemBox)
|
||||
|
||||
gSPClearGeometryMode(gDisplayListHead++, G_LIGHTING);
|
||||
gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIA, G_CC_MODULATEIA);
|
||||
if ((fakeItemBox->rot[1] < 0xAA1) && (fakeItemBox->rot[1] > 0)) {
|
||||
if ((fakeItemBox->rot.y < 0xAA1) && (fakeItemBox->rot.y > 0)) {
|
||||
gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
} else if ((fakeItemBox->rot[1] >= 0x6AA5) && (fakeItemBox->rot[1] < 0x754E)) {
|
||||
} else if ((fakeItemBox->rot.y >= 0x6AA5) && (fakeItemBox->rot.y < 0x754E)) {
|
||||
gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
} else if ((fakeItemBox->rot[1] >= 0x38E1) && (fakeItemBox->rot[1] < 0x438A)) {
|
||||
} else if ((fakeItemBox->rot.y >= 0x38E1) && (fakeItemBox->rot.y < 0x438A)) {
|
||||
gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
} else if ((fakeItemBox->rot[1] >= 0xC711) && (fakeItemBox->rot[1] < 0xD1BA)) {
|
||||
} else if ((fakeItemBox->rot.y >= 0xC711) && (fakeItemBox->rot.y < 0xD1BA)) {
|
||||
gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
} else {
|
||||
gDPSetBlendMask(gDisplayListHead++, 0xFF);
|
||||
|
||||
@@ -21,23 +21,23 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
|
||||
switch (fake_item_box->state) {
|
||||
case 0:
|
||||
fake_item_box->boundingBoxSize = fake_item_box->sizeScaling * 5.5f;
|
||||
fake_item_box->rot[0] -= 0xB6;
|
||||
fake_item_box->rot[1] += 0x16C;
|
||||
fake_item_box->rot[2] -= 0xB6;
|
||||
fake_item_box->rot.x -= 0xB6;
|
||||
fake_item_box->rot.y += 0x16C;
|
||||
fake_item_box->rot.z -= 0xB6;
|
||||
|
||||
temp_f14 = temp_v0_4->pos[0] - fake_item_box->pos[0];
|
||||
temp_f16 = temp_v0_4->pos[1] - fake_item_box->pos[1];
|
||||
temp_f18 = temp_v0_4->pos[2] - fake_item_box->pos[2];
|
||||
temp_f14 = temp_v0_4->pos.x - fake_item_box->pos.x;
|
||||
temp_f16 = temp_v0_4->pos.y - fake_item_box->pos.y;
|
||||
temp_f18 = temp_v0_4->pos.z - fake_item_box->pos.z;
|
||||
|
||||
temp_f2_2 = sqrtf((temp_f14 * temp_f14) + (temp_f16 * temp_f16) + (temp_f18 * temp_f18)) / 10.0f;
|
||||
temp_f14 /= temp_f2_2;
|
||||
temp_f16 /= temp_f2_2;
|
||||
temp_f18 /= temp_f2_2;
|
||||
fake_item_box->pos[0] = temp_v0_4->pos[0] - temp_f14;
|
||||
fake_item_box->pos[1] = (temp_v0_4->pos[1] - temp_f16) - 1.0f;
|
||||
fake_item_box->pos[2] = temp_v0_4->pos[2] - temp_f18;
|
||||
check_bounding_collision(&fake_item_box->unk30, fake_item_box->boundingBoxSize, fake_item_box->pos[0],
|
||||
fake_item_box->pos[1], fake_item_box->pos[2]);
|
||||
fake_item_box->pos.x = temp_v0_4->pos.x - temp_f14;
|
||||
fake_item_box->pos.y = (temp_v0_4->pos.y - temp_f16) - 1.0f;
|
||||
fake_item_box->pos.z = temp_v0_4->pos.z - temp_f18;
|
||||
check_bounding_collision(&fake_item_box->unk30, fake_item_box->boundingBoxSize, fake_item_box->pos.x,
|
||||
fake_item_box->pos.y, fake_item_box->pos.z);
|
||||
func_802B4E30((struct Actor*) fake_item_box);
|
||||
temp_v1_3 = &gControllers[temp_v1];
|
||||
if ((temp_v0_4->type & 0x4000) != 0) {
|
||||
@@ -58,10 +58,10 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
|
||||
}
|
||||
|
||||
fake_item_box->boundingBoxSize = fake_item_box->sizeScaling * 5.5f;
|
||||
if (fake_item_box->targetY <= fake_item_box->pos[1]) {
|
||||
fake_item_box->pos[1] = fake_item_box->targetY;
|
||||
if (fake_item_box->targetY <= fake_item_box->pos.y) {
|
||||
fake_item_box->pos.y = fake_item_box->targetY;
|
||||
} else {
|
||||
fake_item_box->pos[1] += 0.2f;
|
||||
fake_item_box->pos.y += 0.2f;
|
||||
}
|
||||
if ((fake_item_box->flags & 0x1000) != 0) {
|
||||
if ((fake_item_box->someTimer <= 0) || (fake_item_box->someTimer >= 0x12D)) {
|
||||
@@ -71,9 +71,9 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
|
||||
fake_item_box->someTimer--;
|
||||
}
|
||||
}
|
||||
fake_item_box->rot[0] -= 0xB6;
|
||||
fake_item_box->rot[1] += 0x16C;
|
||||
fake_item_box->rot[2] -= 0xB6;
|
||||
fake_item_box->rot.x -= 0xB6;
|
||||
fake_item_box->rot.y += 0x16C;
|
||||
fake_item_box->rot.z -= 0xB6;
|
||||
break;
|
||||
|
||||
case 2:
|
||||
@@ -81,9 +81,9 @@ void update_actor_fake_item_box(struct FakeItemBox* fake_item_box) {
|
||||
destroy_actor((struct Actor*) fake_item_box);
|
||||
} else {
|
||||
fake_item_box->someTimer++;
|
||||
fake_item_box->rot[0] += 0x444;
|
||||
fake_item_box->rot[1] -= 0x2D8;
|
||||
fake_item_box->rot[2] += 0x16C;
|
||||
fake_item_box->rot.x += 0x444;
|
||||
fake_item_box->rot.y -= 0x2D8;
|
||||
fake_item_box->rot.z += 0x16C;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
|
||||
@@ -24,7 +24,7 @@ void render_actor_falling_rock(Camera* camera, struct FallingRock* rock) {
|
||||
return;
|
||||
}
|
||||
|
||||
height = is_within_render_distance(camera->pos, rock->pos, camera->rot[1], 400.0f, gCameraZoom[camera - camera1],
|
||||
height = is_within_render_distance(camera->pos, rock->pos, camera->rot.y, 400.0f, gCameraZoom[camera - camera1],
|
||||
4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
@@ -38,9 +38,9 @@ void render_actor_falling_rock(Camera* camera, struct FallingRock* rock) {
|
||||
if (height < 250000.0f) {
|
||||
|
||||
if (rock->unk30.unk34 == 1) {
|
||||
sp8C[0] = rock->pos[0];
|
||||
sp8C[2] = rock->pos[2];
|
||||
height = calculate_surface_height(sp8C[0], rock->pos[1], sp8C[2], rock->unk30.meshIndexZX);
|
||||
sp8C[0] = rock->pos.x;
|
||||
sp8C[2] = rock->pos.z;
|
||||
height = calculate_surface_height(sp8C[0], rock->pos.y, sp8C[2], rock->unk30.meshIndexZX);
|
||||
sp98[0] = 0;
|
||||
sp98[1] = 0;
|
||||
sp98[2] = 0;
|
||||
|
||||
@@ -16,9 +16,9 @@ void func_8029CF0C(struct ActorSpawnData* spawnData, struct FallingRock* rock) {
|
||||
temp_v0 += rock->unk_06;
|
||||
#endif
|
||||
rock->respawnTimer = sp24[rock->unk_06]; // * 2
|
||||
rock->pos[0] = (f32) temp_v0[rock->unk_06].pos[0] * gCourseDirection;
|
||||
rock->pos[1] = (f32) temp_v0[rock->unk_06].pos[1] + 10.0f;
|
||||
rock->pos[2] = (f32) temp_v0[rock->unk_06].pos[2];
|
||||
rock->pos.x = (f32) temp_v0[rock->unk_06].pos.x * gCourseDirection;
|
||||
rock->pos.y = (f32) temp_v0[rock->unk_06].pos.y + 10.0f;
|
||||
rock->pos.z = (f32) temp_v0[rock->unk_06].pos.z;
|
||||
vec3f_set(rock->velocity, 0, 0, 0);
|
||||
vec3s_set(rock->rot, 0, 0, 0);
|
||||
}
|
||||
@@ -46,10 +46,10 @@ void spawn_falling_rocks(struct ActorSpawnData* spawnData) {
|
||||
Vec3s startingRot;
|
||||
s16 temp;
|
||||
|
||||
while (temp_s0->pos[0] != -0x8000) {
|
||||
startingPos[0] = temp_s0->pos[0] * gCourseDirection;
|
||||
startingPos[1] = temp_s0->pos[1] + 10.0f;
|
||||
startingPos[2] = temp_s0->pos[2];
|
||||
while (temp_s0->pos.x != -0x8000) {
|
||||
startingPos[0] = temp_s0->pos.x * gCourseDirection;
|
||||
startingPos[1] = temp_s0->pos.y + 10.0f;
|
||||
startingPos[2] = temp_s0->pos.z;
|
||||
vec3f_set(startingVelocity, 0, 0, 0);
|
||||
vec3s_set(startingRot, 0, 0, 0);
|
||||
temp = add_actor_to_empty_slot(startingPos, startingRot, startingVelocity, ACTOR_FALLING_ROCK);
|
||||
@@ -76,46 +76,46 @@ void update_actor_falling_rocks(struct FallingRock* rock) {
|
||||
rock->respawnTimer -= 1;
|
||||
return;
|
||||
}
|
||||
if (rock->pos[1] < CM_GetWaterLevel(rock->pos, NULL)) {
|
||||
if (rock->pos.y < CM_GetWaterLevel(rock->pos, NULL)) {
|
||||
func_8029CF0C(sRockSpawnData, rock);
|
||||
}
|
||||
rock->rot[0] += (s16) ((rock->velocity[2] * 5461.0f) / 20.0f);
|
||||
rock->rot[2] += (s16) ((rock->velocity[0] * 5461.0f) / 20.0f);
|
||||
rock->velocity[1] -= 0.1;
|
||||
if (rock->velocity[1] < (-2.0f)) {
|
||||
rock->velocity[1] = -2.0f;
|
||||
rock->rot.x += (s16) ((rock->velocity.z * 5461.0f) / 20.0f);
|
||||
rock->rot.z += (s16) ((rock->velocity.x * 5461.0f) / 20.0f);
|
||||
rock->velocity.y -= 0.1;
|
||||
if (rock->velocity.y < (-2.0f)) {
|
||||
rock->velocity.y = -2.0f;
|
||||
}
|
||||
rock->pos[0] += rock->velocity[0];
|
||||
rock->pos[1] += rock->velocity[1];
|
||||
rock->pos[2] += rock->velocity[2];
|
||||
pad1 = rock->velocity[1];
|
||||
check_bounding_collision(&rock->unk30, 10.0f, rock->pos[0], rock->pos[1], rock->pos[2]);
|
||||
rock->pos.x += rock->velocity.x;
|
||||
rock->pos.y += rock->velocity.y;
|
||||
rock->pos.z += rock->velocity.z;
|
||||
pad1 = rock->velocity.y;
|
||||
check_bounding_collision(&rock->unk30, 10.0f, rock->pos.x, rock->pos.y, rock->pos.z);
|
||||
pad0 = rock->unk30.surfaceDistance[2];
|
||||
if (pad0 < 0.0f) {
|
||||
unkVec[0] = -rock->unk30.orientationVector[0];
|
||||
unkVec[1] = -rock->unk30.orientationVector[1];
|
||||
unkVec[2] = -rock->unk30.orientationVector[2];
|
||||
rock->pos[0] += unkVec[0] * rock->unk30.surfaceDistance[2];
|
||||
rock->pos[1] += unkVec[1] * rock->unk30.surfaceDistance[2];
|
||||
rock->pos[2] += unkVec[2] * rock->unk30.surfaceDistance[2];
|
||||
rock->pos.x += unkVec[0] * rock->unk30.surfaceDistance[2];
|
||||
rock->pos.y += unkVec[1] * rock->unk30.surfaceDistance[2];
|
||||
rock->pos.z += unkVec[2] * rock->unk30.surfaceDistance[2];
|
||||
adjust_pos_orthogonally(unkVec, pad0, rock->velocity, 2.0f);
|
||||
rock->velocity[1] = -1.2f * pad1;
|
||||
rock->velocity.y = -1.2f * pad1;
|
||||
func_800C98B8(rock->pos, rock->velocity, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x0F));
|
||||
}
|
||||
pad0 = rock->unk30.surfaceDistance[0];
|
||||
if (pad0 < 0.0f) {
|
||||
unkVec[1] = -rock->unk30.unk48[1];
|
||||
if (unkVec[1] == 0.0f) {
|
||||
rock->velocity[1] *= -1.2f;
|
||||
rock->velocity.y *= -1.2f;
|
||||
return;
|
||||
} else {
|
||||
unkVec[0] = -rock->unk30.unk48[0];
|
||||
unkVec[2] = -rock->unk30.unk48[2];
|
||||
rock->pos[0] += unkVec[0] * rock->unk30.surfaceDistance[0];
|
||||
rock->pos[1] += unkVec[1] * rock->unk30.surfaceDistance[0];
|
||||
rock->pos[2] += unkVec[2] * rock->unk30.surfaceDistance[0];
|
||||
rock->pos.x += unkVec[0] * rock->unk30.surfaceDistance[0];
|
||||
rock->pos.y += unkVec[1] * rock->unk30.surfaceDistance[0];
|
||||
rock->pos.z += unkVec[2] * rock->unk30.surfaceDistance[0];
|
||||
adjust_pos_orthogonally(unkVec, pad0, rock->velocity, 2.0f);
|
||||
rock->velocity[1] = -1.2f * pad1;
|
||||
rock->velocity.y = -1.2f * pad1;
|
||||
func_800C98B8(rock->pos, rock->velocity, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x0F));
|
||||
}
|
||||
}
|
||||
@@ -123,16 +123,16 @@ void update_actor_falling_rocks(struct FallingRock* rock) {
|
||||
if (pad0 < 0.0f) {
|
||||
unkVec[1] = -rock->unk30.unk54[1];
|
||||
if (unkVec[1] == 0.0f) {
|
||||
rock->velocity[1] *= -1.2f;
|
||||
rock->velocity.y *= -1.2f;
|
||||
} else {
|
||||
unkVec[0] = -rock->unk30.unk54[0];
|
||||
unkVec[2] = -rock->unk30.unk54[2];
|
||||
rock->pos[0] += unkVec[0] * rock->unk30.surfaceDistance[1];
|
||||
rock->pos[1] += unkVec[1] * rock->unk30.surfaceDistance[1];
|
||||
rock->pos[2] += unkVec[2] * rock->unk30.surfaceDistance[1];
|
||||
pad1 = rock->velocity[1];
|
||||
rock->pos.x += unkVec[0] * rock->unk30.surfaceDistance[1];
|
||||
rock->pos.y += unkVec[1] * rock->unk30.surfaceDistance[1];
|
||||
rock->pos.z += unkVec[2] * rock->unk30.surfaceDistance[1];
|
||||
pad1 = rock->velocity.y;
|
||||
adjust_pos_orthogonally(unkVec, pad0, rock->velocity, 2.0f);
|
||||
rock->velocity[1] = -1.2f * pad1;
|
||||
rock->velocity.y = -1.2f * pad1;
|
||||
func_800C98B8(rock->pos, rock->velocity, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x0F));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -29,9 +29,9 @@ void update_actor_green_shell(struct ShellActor* shell) {
|
||||
UNUSED f32 pad7;
|
||||
UNUSED f32 pad8;
|
||||
|
||||
height = shell->pos[0];
|
||||
y = shell->pos[1];
|
||||
z = shell->pos[2];
|
||||
height = shell->pos.x;
|
||||
y = shell->pos.y;
|
||||
z = shell->pos.z;
|
||||
if ((z < gCourseMinZ) || (gCourseMaxZ < z) || (height < gCourseMinX) || (gCourseMaxX < height) ||
|
||||
(y < gCourseMinY)) {
|
||||
destroy_destructable_actor((struct Actor*) shell);
|
||||
@@ -45,15 +45,15 @@ void update_actor_green_shell(struct ShellActor* shell) {
|
||||
somePosVel[1] = player->boundingBoxSize;
|
||||
somePosVel[2] = -(player->boundingBoxSize + shell->boundingBoxSize + 2.0f);
|
||||
mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
|
||||
shell->pos[0] = player->pos[0] + somePosVel[0];
|
||||
pad2 = player->pos[1] - somePosVel[1];
|
||||
shell->pos[2] = player->pos[2] + somePosVel[2];
|
||||
height = calculate_surface_height(shell->pos[0], pad2, shell->pos[2], player->collision.meshIndexZX);
|
||||
shell->pos.x = player->pos.x + somePosVel[0];
|
||||
pad2 = player->pos.y - somePosVel[1];
|
||||
shell->pos.z = player->pos.z + somePosVel[2];
|
||||
height = calculate_surface_height(shell->pos.x, pad2, shell->pos.z, player->collision.meshIndexZX);
|
||||
z = pad2 - height;
|
||||
if ((z < 5.0f) && (z > -5.0f)) {
|
||||
shell->pos[1] = shell->boundingBoxSize + height;
|
||||
shell->pos.y = shell->boundingBoxSize + height;
|
||||
} else {
|
||||
shell->pos[1] = pad2;
|
||||
shell->pos.y = pad2;
|
||||
}
|
||||
if ((player->type & PLAYER_HUMAN) != 0) {
|
||||
controller = &gControllers[shell->playerId];
|
||||
@@ -68,9 +68,9 @@ void update_actor_green_shell(struct ShellActor* shell) {
|
||||
somePosVel[1] = 0.0f;
|
||||
somePosVel[2] = -var_f2;
|
||||
func_802B64C4(somePosVel, player->rotation[1] + player->unk_0C0);
|
||||
shell->velocity[0] = somePosVel[0];
|
||||
shell->velocity[1] = somePosVel[1];
|
||||
shell->velocity[2] = somePosVel[2];
|
||||
shell->velocity.x = somePosVel[0];
|
||||
shell->velocity.y = somePosVel[1];
|
||||
shell->velocity.z = somePosVel[2];
|
||||
shell->state = 2;
|
||||
func_800C9060(shell->playerId, SOUND_ARG_LOAD(0x19, 0x00, 0x80, 0x04));
|
||||
func_800C90F4(shell->playerId,
|
||||
@@ -120,17 +120,17 @@ void update_actor_green_shell(struct ShellActor* shell) {
|
||||
somePosVel[1] = 0.0f;
|
||||
somePosVel[2] = var_f2;
|
||||
func_802B64C4(somePosVel, player->rotation[1] + player->unk_0C0);
|
||||
shell->velocity[0] = somePosVel[0];
|
||||
shell->velocity[1] = somePosVel[1];
|
||||
shell->velocity[2] = somePosVel[2];
|
||||
shell->velocity.x = somePosVel[0];
|
||||
shell->velocity.y = somePosVel[1];
|
||||
shell->velocity.z = somePosVel[2];
|
||||
} else {
|
||||
somePosVel[0] = sins(shell->rotAngle) * 6.0f;
|
||||
somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
|
||||
somePosVel[2] = coss(shell->rotAngle) * 6.0f;
|
||||
mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
|
||||
shell->pos[0] = player->pos[0] + somePosVel[0];
|
||||
shell->pos[1] = player->pos[1] + somePosVel[1];
|
||||
shell->pos[2] = player->pos[2] + somePosVel[2];
|
||||
shell->pos.x = player->pos.x + somePosVel[0];
|
||||
shell->pos.y = player->pos.y + somePosVel[1];
|
||||
shell->pos.z = player->pos.z + somePosVel[2];
|
||||
}
|
||||
break;
|
||||
case MOVING_SHELL:
|
||||
@@ -140,17 +140,17 @@ void update_actor_green_shell(struct ShellActor* shell) {
|
||||
shell->flags &= ~0x1000;
|
||||
}
|
||||
}
|
||||
shell->velocity[1] -= 0.5f;
|
||||
if (shell->velocity[1] < -2.0f) {
|
||||
shell->velocity[1] = -2.0f;
|
||||
shell->velocity.y -= 0.5f;
|
||||
if (shell->velocity.y < -2.0f) {
|
||||
shell->velocity.y = -2.0f;
|
||||
}
|
||||
somePos2[0] = shell->pos[0];
|
||||
somePos2[1] = shell->pos[1];
|
||||
somePos2[2] = shell->pos[2];
|
||||
shell->pos[0] += shell->velocity[0];
|
||||
shell->pos[1] += shell->velocity[1];
|
||||
shell->pos[2] += shell->velocity[2];
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], somePos2[0],
|
||||
somePos2[0] = shell->pos.x;
|
||||
somePos2[1] = shell->pos.y;
|
||||
somePos2[2] = shell->pos.z;
|
||||
shell->pos.x += shell->velocity.x;
|
||||
shell->pos.y += shell->velocity.y;
|
||||
shell->pos.z += shell->velocity.z;
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, somePos2[0],
|
||||
somePos2[1], somePos2[2]);
|
||||
func_802B4E30((struct Actor*) shell);
|
||||
if ((shell->unk30.surfaceDistance[0] < 0.0f) || (shell->unk30.surfaceDistance[1] < 0.0f)) {
|
||||
@@ -170,26 +170,26 @@ void update_actor_green_shell(struct ShellActor* shell) {
|
||||
somePosVel[1] = shell->boundingBoxSize - player->boundingBoxSize;
|
||||
somePosVel[2] = coss(shell->rotAngle) * 8.0f;
|
||||
mtxf_translate_vec3f_mat3(somePosVel, player->orientationMatrix);
|
||||
somePos2[0] = shell->pos[0];
|
||||
somePos2[1] = shell->pos[1];
|
||||
somePos2[2] = shell->pos[2];
|
||||
shell->pos[0] = player->pos[0] + somePosVel[0];
|
||||
shell->pos[1] = player->pos[1] + somePosVel[1];
|
||||
shell->pos[2] = player->pos[2] + somePosVel[2];
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos[0], shell->pos[1], shell->pos[2], somePos2[0],
|
||||
somePos2[0] = shell->pos.x;
|
||||
somePos2[1] = shell->pos.y;
|
||||
somePos2[2] = shell->pos.z;
|
||||
shell->pos.x = player->pos.x + somePosVel[0];
|
||||
shell->pos.y = player->pos.y + somePosVel[1];
|
||||
shell->pos.z = player->pos.z + somePosVel[2];
|
||||
actor_terrain_collision(&shell->unk30, 4.0f, shell->pos.x, shell->pos.y, shell->pos.z, somePos2[0],
|
||||
somePos2[1], somePos2[2]);
|
||||
func_802B4E30((struct Actor*) shell);
|
||||
}
|
||||
break;
|
||||
case GREEN_SHELL_HIT_A_RACER:
|
||||
// Somehow, this fake match affects stack management up in case 2
|
||||
shell->velocity[1] -= (0, 0.3f);
|
||||
if (shell->velocity[1] < -5.0f) {
|
||||
shell->velocity[1] = -5.0f;
|
||||
shell->velocity.y -= (0, 0.3f);
|
||||
if (shell->velocity.y < -5.0f) {
|
||||
shell->velocity.y = -5.0f;
|
||||
}
|
||||
shell->rotAngle += 0x5B0;
|
||||
shell->someTimer -= 1;
|
||||
shell->pos[1] += shell->velocity[1];
|
||||
shell->pos.y += shell->velocity.y;
|
||||
if (shell->someTimer == 0) {
|
||||
destroy_actor((struct Actor*) shell);
|
||||
}
|
||||
|
||||
@@ -30,7 +30,7 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
|
||||
// @port: Tag the transform.
|
||||
FrameInterpolation_RecordOpenChild("ItemBox", TAG_ITEM_ADDR(item_box));
|
||||
|
||||
temp_f0 = is_within_render_distance(camera->pos, item_box->pos, camera->rot[1], 0.0f, gCameraZoom[camera - camera1],
|
||||
temp_f0 = is_within_render_distance(camera->pos, item_box->pos, camera->rot.y, 0.0f, gCameraZoom[camera - camera1],
|
||||
4000000.0f);
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = CLAMP(temp_f0, 0.0f, 600000.0f);
|
||||
@@ -38,11 +38,11 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
|
||||
if (!(temp_f0 < 0.0f) && !(600000.0f < temp_f0)) {
|
||||
if ((item_box->state == 2) && (temp_f0 < 100000.0f)) {
|
||||
someRot[0] = 0;
|
||||
someRot[1] = item_box->rot[1];
|
||||
someRot[1] = item_box->rot.y;
|
||||
someRot[2] = 0;
|
||||
someVec2[0] = item_box->pos[0];
|
||||
someVec2[0] = item_box->pos.x;
|
||||
someVec2[1] = item_box->resetDistance + 2.0f;
|
||||
someVec2[2] = item_box->pos[2];
|
||||
someVec2[2] = item_box->pos.z;
|
||||
|
||||
mtxf_pos_rotation_xyz(someMatrix1, someVec2, someRot);
|
||||
|
||||
@@ -52,8 +52,8 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
|
||||
|
||||
gSPDisplayList(gDisplayListHead++, D_0D002EE8);
|
||||
|
||||
someRot[1] = item_box->rot[1] * 2;
|
||||
someVec2[1] = item_box->pos[1];
|
||||
someRot[1] = item_box->rot.y * 2;
|
||||
someVec2[1] = item_box->pos.y;
|
||||
|
||||
mtxf_pos_rotation_xyz(someMatrix1, someVec2, someRot);
|
||||
|
||||
@@ -82,13 +82,13 @@ void render_actor_item_box(Camera* camera, struct ItemBox* item_box) {
|
||||
|
||||
gSPClearGeometryMode(gDisplayListHead++, G_LIGHTING);
|
||||
gDPSetCombineMode(gDisplayListHead++, G_CC_MODULATEIA, G_CC_MODULATEIA);
|
||||
// if ((item_box->rot[1] < 0xAA1) && (item_box->rot[1] > 0)) {
|
||||
// if ((item_box->rot.y < 0xAA1) && (item_box->rot.y > 0)) {
|
||||
// gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
// } else if ((item_box->rot[1] >= 0x6AA5) && (item_box->rot[1] < 0x754E)) {
|
||||
// } else if ((item_box->rot.y >= 0x6AA5) && (item_box->rot.y < 0x754E)) {
|
||||
// gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
// } else if ((item_box->rot[1] >= 0x38E1) && (item_box->rot[1] < 0x438A)) {
|
||||
// } else if ((item_box->rot.y >= 0x38E1) && (item_box->rot.y < 0x438A)) {
|
||||
// gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
// } else if ((item_box->rot[1] >= 0xC711) && (item_box->rot[1] < 0xD1BA)) {
|
||||
// } else if ((item_box->rot.y >= 0xC711) && (item_box->rot.y < 0xD1BA)) {
|
||||
// gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
// } else {
|
||||
gDPSetBlendMask(gDisplayListHead++, 0xFF);
|
||||
|
||||
@@ -10,9 +10,9 @@
|
||||
void update_actor_item_box_hot_air_balloon(struct ItemBox* itemBox) {
|
||||
switch (itemBox->state) {
|
||||
case 5:
|
||||
itemBox->rot[0] += 0xB6;
|
||||
itemBox->rot[1] -= 0x16C;
|
||||
itemBox->rot[2] += 0xB6;
|
||||
itemBox->rot.x += 0xB6;
|
||||
itemBox->rot.y -= 0x16C;
|
||||
itemBox->rot.z += 0xB6;
|
||||
break;
|
||||
case 3:
|
||||
if (itemBox->someTimer == 0x14) {
|
||||
@@ -20,9 +20,9 @@ void update_actor_item_box_hot_air_balloon(struct ItemBox* itemBox) {
|
||||
itemBox->flags = -0x4000;
|
||||
} else {
|
||||
itemBox->someTimer++;
|
||||
itemBox->rot[0] += 0x444;
|
||||
itemBox->rot[1] -= 0x2D8;
|
||||
itemBox->rot[2] += 0x16C;
|
||||
itemBox->rot.x += 0x444;
|
||||
itemBox->rot.y -= 0x2D8;
|
||||
itemBox->rot.z += 0x16C;
|
||||
}
|
||||
break;
|
||||
}
|
||||
@@ -39,29 +39,29 @@ void update_actor_item_box(struct ItemBox* itemBox) {
|
||||
itemBox->state = 1;
|
||||
break;
|
||||
case 1:
|
||||
if ((itemBox->pos[1] - itemBox->origY) < 8.66f) {
|
||||
itemBox->pos[1] += 0.45f;
|
||||
if ((itemBox->pos.y - itemBox->origY) < 8.66f) {
|
||||
itemBox->pos.y += 0.45f;
|
||||
} else {
|
||||
itemBox->pos[1] = itemBox->origY + 8.66f;
|
||||
itemBox->pos.y = itemBox->origY + 8.66f;
|
||||
itemBox->state = 2;
|
||||
itemBox->flags = 0xC000;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
itemBox->rot[0] += 0xB6;
|
||||
itemBox->rot[1] -= 0x16C;
|
||||
itemBox->rot[2] += 0xB6;
|
||||
itemBox->rot.x += 0xB6;
|
||||
itemBox->rot.y -= 0x16C;
|
||||
itemBox->rot.z += 0xB6;
|
||||
break;
|
||||
case 3:
|
||||
if (itemBox->someTimer == 20) {
|
||||
itemBox->state = 0;
|
||||
itemBox->pos[1] = itemBox->resetDistance - 20.0f;
|
||||
itemBox->pos.y = itemBox->resetDistance - 20.0f;
|
||||
itemBox->flags = 0xC000;
|
||||
} else {
|
||||
itemBox->someTimer++;
|
||||
itemBox->rot[0] += 0x444;
|
||||
itemBox->rot[1] -= 0x2D8;
|
||||
itemBox->rot[2] += 0x16C;
|
||||
itemBox->rot.x += 0x444;
|
||||
itemBox->rot.y -= 0x2D8;
|
||||
itemBox->rot.z += 0x16C;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -20,18 +20,18 @@ void render_actor_kiwano_fruit(UNUSED Camera* camera, Mat4 arg1, struct Actor* a
|
||||
return;
|
||||
}
|
||||
|
||||
arg1[3][0] = actor->pos[0];
|
||||
arg1[3][1] = actor->pos[1];
|
||||
arg1[3][2] = actor->pos[2];
|
||||
arg1[3][0] = actor->pos.x;
|
||||
arg1[3][1] = actor->pos.y;
|
||||
arg1[3][2] = actor->pos.z;
|
||||
|
||||
maxObjectsReached = render_set_position(arg1, 0) == 0;
|
||||
if (maxObjectsReached) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Animate actor by creating an index from rot[0]. Divide by texture size to get whole number 0-2.
|
||||
// Animate actor by creating an index from rot.x. Divide by texture size to get whole number 0-2.
|
||||
// All three animated textures need to be the same size for this to work.
|
||||
size_t idx = (actor->rot[0] << 0xA) / ResourceGetTexSizeByName(gTextureDksJungleParkwayKiwanoFruit1);
|
||||
size_t idx = (actor->rot.x << 0xA) / ResourceGetTexSizeByName(gTextureDksJungleParkwayKiwanoFruit1);
|
||||
switch(idx) {
|
||||
case 0:
|
||||
addr = gTextureDksJungleParkwayKiwanoFruit1;
|
||||
@@ -44,7 +44,7 @@ void render_actor_kiwano_fruit(UNUSED Camera* camera, Mat4 arg1, struct Actor* a
|
||||
break;
|
||||
}
|
||||
|
||||
//addr = segmented_texture_to_virtual((actor->rot[0] << 0xA) + 0x03009000);
|
||||
//addr = segmented_texture_to_virtual((actor->rot.x << 0xA) + 0x03009000);
|
||||
gDPLoadTextureBlock(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(addr), G_IM_FMT_CI, G_IM_SIZ_8b, 32, 32, 0,
|
||||
G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMIRROR | G_TX_CLAMP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
|
||||
G_TX_NOLOD);
|
||||
|
||||
@@ -28,34 +28,34 @@ void update_actor_kiwano_fruit(struct KiwanoFruit* fruit) {
|
||||
return;
|
||||
}
|
||||
fruit->state = 1;
|
||||
fruit->velocity[0] = 80.0f;
|
||||
fruit->velocity.x = 80.0f;
|
||||
case 1:
|
||||
nearestWaypoint = gNearestWaypointByPlayerId[(u16) (player - gPlayerOne)];
|
||||
temp_f2 = player->pos[0] - D_80164490[nearestWaypoint].posX;
|
||||
temp_f16 = player->pos[1] - D_80164490[nearestWaypoint].posY;
|
||||
temp_f14 = player->pos[2] - D_80164490[nearestWaypoint].posZ;
|
||||
temp_f12 = fruit->velocity[0] / sqrtf((temp_f2 * temp_f2) + (temp_f16 * temp_f16) + (temp_f14 * temp_f14));
|
||||
temp_f2 = player->pos.x - D_80164490[nearestWaypoint].posX;
|
||||
temp_f16 = player->pos.y - D_80164490[nearestWaypoint].posY;
|
||||
temp_f14 = player->pos.z - D_80164490[nearestWaypoint].posZ;
|
||||
temp_f12 = fruit->velocity.x / sqrtf((temp_f2 * temp_f2) + (temp_f16 * temp_f16) + (temp_f14 * temp_f14));
|
||||
temp_f2 *= temp_f12;
|
||||
temp_f16 *= temp_f12;
|
||||
temp_f14 *= temp_f12;
|
||||
fruit->pos[0] = player->pos[0] + temp_f2;
|
||||
fruit->pos[1] = player->pos[1] + temp_f16;
|
||||
fruit->pos[2] = player->pos[2] + temp_f14;
|
||||
fruit->velocity[0] -= 2.0f;
|
||||
if (fruit->velocity[0] <= 0.0f) {
|
||||
fruit->pos.x = player->pos.x + temp_f2;
|
||||
fruit->pos.y = player->pos.y + temp_f16;
|
||||
fruit->pos.z = player->pos.z + temp_f14;
|
||||
fruit->velocity.x -= 2.0f;
|
||||
if (fruit->velocity.x <= 0.0f) {
|
||||
fruit->state = 2;
|
||||
fruit->bonkTimer = 30.0f;
|
||||
fruit->velocity[0] = 0.0f;
|
||||
fruit->velocity[1] = 2.3f;
|
||||
fruit->velocity[2] = 0.0f;
|
||||
fruit->velocity.x = 0.0f;
|
||||
fruit->velocity.y = 2.3f;
|
||||
fruit->velocity.z = 0.0f;
|
||||
if ((player->effects & STAR_EFFECT) != 0) {
|
||||
func_800C9060(player - gPlayerOne, SOUND_ARG_LOAD(0x19, 0x00, 0xA0, 0x52));
|
||||
} else {
|
||||
player->effects |= 0x8000;
|
||||
player->pos[0] -= temp_f2 * 4.0f;
|
||||
player->pos[2] -= temp_f14 * 4.0f;
|
||||
player->velocity[0] -= temp_f2 * 0.7f;
|
||||
player->velocity[2] -= temp_f14 * 0.7f;
|
||||
player->pos.x -= temp_f2 * 4.0f;
|
||||
player->pos.z -= temp_f14 * 4.0f;
|
||||
player->velocity.x -= temp_f2 * 0.7f;
|
||||
player->velocity.z -= temp_f14 * 0.7f;
|
||||
func_800C9060(player - gPlayerOne, SOUND_ARG_LOAD(0x19, 0x00, 0x70, 0x18));
|
||||
if (gModeSelection != GRAND_PRIX) {
|
||||
D_80162DF8 = 1;
|
||||
@@ -64,10 +64,10 @@ void update_actor_kiwano_fruit(struct KiwanoFruit* fruit) {
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
fruit->velocity[1] -= 0.3f;
|
||||
fruit->pos[0] += fruit->velocity[0];
|
||||
fruit->pos[1] += fruit->velocity[1];
|
||||
fruit->pos[2] += fruit->velocity[2];
|
||||
fruit->velocity.y -= 0.3f;
|
||||
fruit->pos.x += fruit->velocity.x;
|
||||
fruit->pos.y += fruit->velocity.y;
|
||||
fruit->pos.z += fruit->velocity.z;
|
||||
fruit->bonkTimer -= 1.0f;
|
||||
if (fruit->bonkTimer < 0.0f) {
|
||||
fruit->state = 0;
|
||||
|
||||
@@ -19,7 +19,7 @@ void render_actor_mario_sign(Camera* arg0, UNUSED Mat4 arg1, struct Actor* arg2)
|
||||
return;
|
||||
}
|
||||
|
||||
unk = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot[1], 0, gCameraZoom[arg0 - camera1], 16000000.0f);
|
||||
unk = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot.y, 0, gCameraZoom[arg0 - camera1], 16000000.0f);
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
unk = MAX(unk, 0.0f);
|
||||
}
|
||||
|
||||
@@ -8,13 +8,13 @@
|
||||
void update_actor_mario_sign(struct Actor* arg0) {
|
||||
if ((arg0->flags & 0x800) == 0) {
|
||||
if ((arg0->flags & 0x400) != 0) {
|
||||
arg0->pos[1] += 4.0f;
|
||||
if (arg0->pos[1] > 800.0f) {
|
||||
arg0->pos.y += 4.0f;
|
||||
if (arg0->pos.y > 800.0f) {
|
||||
arg0->flags |= 0x800;
|
||||
arg0->rot[1] += 1820;
|
||||
arg0->rot.y += 1820;
|
||||
}
|
||||
} else {
|
||||
arg0->rot[1] += 182;
|
||||
arg0->rot.y += 182;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -29,7 +29,7 @@ void render_actor_paddle_boat(Camera* arg0, struct PaddleWheelBoat* boat, UNUSED
|
||||
return;
|
||||
}
|
||||
|
||||
temp = is_within_render_distance(arg0->pos, boat->pos, arg0->rot[1], 90000.0f, gCameraZoom[arg0 - camera1],
|
||||
temp = is_within_render_distance(arg0->pos, boat->pos, arg0->rot.y, 90000.0f, gCameraZoom[arg0 - camera1],
|
||||
9000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
|
||||
@@ -21,7 +21,7 @@ void render_actor_palm_tree(Camera* arg0, UNUSED Mat4 arg1, struct PalmTree* arg
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(arg0->pos, arg2->pos, arg0->rot[1], 0.0f, gCameraZoom[arg0 - camera1], 4000000.0f);
|
||||
is_within_render_distance(arg0->pos, arg2->pos, arg0->rot.y, 0.0f, gCameraZoom[arg0 - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
|
||||
@@ -25,7 +25,7 @@ void render_actor_piranha_plant(Camera* arg0, Mat4 arg1, struct PiranhaPlant* ar
|
||||
return;
|
||||
}
|
||||
|
||||
temp_f0 = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot[1], 0, gCameraZoom[arg0 - camera1], 1000000.0f);
|
||||
temp_f0 = is_within_render_distance(arg0->pos, arg2->pos, arg0->rot.y, 0, gCameraZoom[arg0 - camera1], 1000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -49,9 +49,9 @@ void render_actor_piranha_plant(Camera* arg0, Mat4 arg1, struct PiranhaPlant* ar
|
||||
}
|
||||
return;
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
maxObjectsReached = render_set_position(arg1, 0) == 0;
|
||||
if (maxObjectsReached) {
|
||||
return;
|
||||
|
||||
@@ -9,8 +9,8 @@
|
||||
void update_actor_piranha_plant(struct PiranhaPlant* arg0) {
|
||||
if ((arg0->flags & 0x800) == 0) {
|
||||
if ((arg0->flags & 0x400) != 0) {
|
||||
arg0->pos[1] += 4.0f;
|
||||
if (arg0->pos[1] > 800.0f) {
|
||||
arg0->pos.y += 4.0f;
|
||||
if (arg0->pos.y > 800.0f) {
|
||||
arg0->flags |= 0x800;
|
||||
}
|
||||
} else {
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
void render_actor_railroad_crossing(Camera* arg0, struct RailroadCrossing* rr_crossing) {
|
||||
UNUSED Vec3s sp80 = { 0, 0, 0 };
|
||||
Mat4 sp40;
|
||||
f32 unk = is_within_render_distance(arg0->pos, rr_crossing->pos, arg0->rot[1], 0.0f, gCameraZoom[arg0 - camera1],
|
||||
f32 unk = is_within_render_distance(arg0->pos, rr_crossing->pos, arg0->rot.y, 0.0f, gCameraZoom[arg0 - camera1],
|
||||
4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
|
||||
@@ -18,7 +18,7 @@ void render_actor_school_bus(Camera* arg0, struct Actor* arg1) {
|
||||
f32 temp_f0;
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 2500.0f, gCameraZoom[arg0 - camera1], 9000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
|
||||
@@ -14,7 +14,7 @@ void render_actor_tanker_truck(Camera* camera, struct Actor* arg1) {
|
||||
UNUSED s32 pad[6];
|
||||
Mat4 spC8;
|
||||
UNUSED s32 pad2[32];
|
||||
f32 temp_f0 = is_within_render_distance(camera->pos, arg1->pos, camera->rot[1], 2500.0f,
|
||||
f32 temp_f0 = is_within_render_distance(camera->pos, arg1->pos, camera->rot.y, 2500.0f,
|
||||
gCameraZoom[camera - camera1], 9000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
|
||||
@@ -19,7 +19,7 @@ void render_actor_train_engine(Camera* camera, struct TrainCar* actor) {
|
||||
Mat4 objectMtx;
|
||||
Mat4 resultMtx;
|
||||
|
||||
f32 distance = is_within_render_distance(camera->pos, actor->pos, camera->rot[1], 2500.0f,
|
||||
f32 distance = is_within_render_distance(camera->pos, actor->pos, camera->rot.y, 2500.0f,
|
||||
gCameraZoom[camera - camera1], 9000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
@@ -174,7 +174,7 @@ void render_actor_train_tender(Camera* camera, struct TrainCar* actor) {
|
||||
Mat4 spE0;
|
||||
Mat4 spA0;
|
||||
|
||||
f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot[1], 625.0f,
|
||||
f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot.y, 625.0f,
|
||||
gCameraZoom[camera - camera1], 9000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
@@ -267,7 +267,7 @@ void render_actor_train_passenger_car(Camera* camera, struct TrainCar* actor) {
|
||||
Mat4 spE0;
|
||||
Mat4 spA0;
|
||||
|
||||
f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot[1], 2025.0f,
|
||||
f32 temp_f0 = is_within_render_distance(camera->pos, actor->pos, camera->rot.y, 2025.0f,
|
||||
gCameraZoom[camera - camera1], 9000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
|
||||
@@ -21,7 +21,7 @@ void render_actor_tree_mario_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
return;
|
||||
}
|
||||
|
||||
temp_f0 = is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
|
||||
temp_f0 = is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
|
||||
16000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
@@ -35,9 +35,9 @@ void render_actor_tree_mario_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 3.0f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
|
||||
@@ -61,7 +61,7 @@ void render_actor_tree_yoshi_valley(Camera* camera, Mat4 arg1, struct Actor* arg
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -74,9 +74,9 @@ void render_actor_tree_yoshi_valley(Camera* camera, Mat4 arg1, struct Actor* arg
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
|
||||
@@ -100,7 +100,7 @@ void render_actor_tree_royal_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -113,9 +113,9 @@ void render_actor_tree_royal_raceway(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
|
||||
@@ -139,7 +139,7 @@ void render_actor_tree_moo_moo_farm(Camera* camera, Mat4 arg1, struct Actor* arg
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 6250000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 6250000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -152,9 +152,9 @@ void render_actor_tree_moo_moo_farm(Camera* camera, Mat4 arg1, struct Actor* arg
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 600.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 5.0f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
|
||||
@@ -172,7 +172,7 @@ void func_80299864(Camera* camera, Mat4 arg1, struct Actor* arg2) {
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -185,9 +185,9 @@ void func_80299864(Camera* camera, Mat4 arg1, struct Actor* arg2) {
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
|
||||
@@ -224,7 +224,7 @@ void render_actor_tree_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -237,9 +237,9 @@ void render_actor_tree_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
|
||||
@@ -263,7 +263,7 @@ void render_actor_bush_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 640000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 640000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -276,9 +276,9 @@ void render_actor_bush_bowser_castle(Camera* camera, Mat4 arg1, struct Actor* ar
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gDPLoadTLUT_pal256(gDisplayListHead++, common_tlut_trees_import);
|
||||
@@ -302,7 +302,7 @@ void render_actor_tree_frappe_snowland(Camera* camera, Mat4 arg1, struct Actor*
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -315,9 +315,9 @@ void render_actor_tree_frappe_snowland(Camera* camera, Mat4 arg1, struct Actor*
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 250000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 2.79999995f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gSPDisplayList(gDisplayListHead++, d_course_frappe_snowland_dl_tree);
|
||||
@@ -340,7 +340,7 @@ void render_actor_tree_cactus1_kalimari_desert(Camera* camera, Mat4 arg1, struct
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -353,9 +353,9 @@ void render_actor_tree_cactus1_kalimari_desert(Camera* camera, Mat4 arg1, struct
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 40000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 1.0f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gSPDisplayList(gDisplayListHead++, d_course_kalimari_desert_dl_cactus1);
|
||||
@@ -378,7 +378,7 @@ void render_actor_tree_cactus2_kalimari_desert(Camera* camera, Mat4 arg1, struct
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -391,9 +391,9 @@ void render_actor_tree_cactus2_kalimari_desert(Camera* camera, Mat4 arg1, struct
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 40000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 1.0f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gSPDisplayList(gDisplayListHead++, d_course_kalimari_desert_dl_cactus2);
|
||||
@@ -416,7 +416,7 @@ void render_actor_tree_cactus3_kalimari_desert(Camera* camera, Mat4 arg1, struct
|
||||
}
|
||||
|
||||
temp_f0 =
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
is_within_render_distance(camera->pos, arg2->pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 4000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
temp_f0 = MAX(temp_f0, 0.0f);
|
||||
@@ -429,9 +429,9 @@ void render_actor_tree_cactus3_kalimari_desert(Camera* camera, Mat4 arg1, struct
|
||||
if (((temp_v0 & 0x400) == 0) && (temp_f0 < 40000.0f)) {
|
||||
func_8029794C(arg2->pos, arg2->rot, 0.80000001f);
|
||||
}
|
||||
arg1[3][0] = arg2->pos[0];
|
||||
arg1[3][1] = arg2->pos[1];
|
||||
arg1[3][2] = arg2->pos[2];
|
||||
arg1[3][0] = arg2->pos.x;
|
||||
arg1[3][1] = arg2->pos.y;
|
||||
arg1[3][2] = arg2->pos.z;
|
||||
|
||||
if (render_set_position(arg1, 0) != 0) {
|
||||
gSPDisplayList(gDisplayListHead++, d_course_kalimari_desert_dl_cactus3);
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
void render_actor_wario_sign(Camera* arg0, struct Actor* arg1) {
|
||||
Mat4 sp38;
|
||||
f32 unk =
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot[1], 0, gCameraZoom[arg0 - camera1], 16000000.0f);
|
||||
is_within_render_distance(arg0->pos, arg1->pos, arg0->rot.y, 0, gCameraZoom[arg0 - camera1], 16000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
unk = MAX(unk, 0.0f);
|
||||
|
||||
@@ -7,5 +7,5 @@
|
||||
* @param arg0
|
||||
*/
|
||||
void update_actor_wario_sign(struct Actor* arg0) {
|
||||
arg0->rot[1] += 0xB6;
|
||||
arg0->rot.y += 0xB6;
|
||||
}
|
||||
|
||||
@@ -20,7 +20,7 @@ void render_actor_yoshi_egg(Camera* arg0, Mat4 arg1, struct YoshiValleyEgg* egg,
|
||||
f32 temp_f0;
|
||||
|
||||
if (gGamestate != CREDITS_SEQUENCE) {
|
||||
temp_f0 = is_within_render_distance(arg0->pos, egg->pos, arg0->rot[1], 200.0f, gCameraZoom[arg0 - camera1],
|
||||
temp_f0 = is_within_render_distance(arg0->pos, egg->pos, arg0->rot.y, 200.0f, gCameraZoom[arg0 - camera1],
|
||||
16000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
@@ -43,9 +43,9 @@ void render_actor_yoshi_egg(Camera* arg0, Mat4 arg1, struct YoshiValleyEgg* egg,
|
||||
gSPSetGeometryMode(gDisplayListHead++, G_SHADING_SMOOTH);
|
||||
if ((arg3 > 12) && (arg3 < 20)) {
|
||||
if (temp_f0 < 640000.0f) {
|
||||
sp54[0] = egg->pos[0];
|
||||
sp54[0] = egg->pos.x;
|
||||
sp54[1] = 3.0f;
|
||||
sp54[2] = egg->pos[2];
|
||||
sp54[2] = egg->pos.z;
|
||||
func_802976D8(sp5C);
|
||||
func_8029794C(sp54, sp5C, 10.0f);
|
||||
}
|
||||
@@ -64,9 +64,9 @@ void render_actor_yoshi_egg(Camera* arg0, Mat4 arg1, struct YoshiValleyEgg* egg,
|
||||
gSPDisplayList(gDisplayListHead++, d_course_yoshi_valley_dl_16D70);
|
||||
FrameInterpolation_RecordMatrixPop(sp60);
|
||||
} else {
|
||||
arg1[3][0] = egg->pos[0];
|
||||
arg1[3][1] = egg->pos[1];
|
||||
arg1[3][2] = egg->pos[2];
|
||||
arg1[3][0] = egg->pos.x;
|
||||
arg1[3][1] = egg->pos.y;
|
||||
arg1[3][2] = egg->pos.z;
|
||||
|
||||
FrameInterpolation_RecordMatrixPush(arg1);
|
||||
|
||||
|
||||
@@ -7,16 +7,16 @@
|
||||
*/
|
||||
void update_actor_yoshi_egg(struct YoshiValleyEgg* egg) {
|
||||
egg->pathRot += 0x5B;
|
||||
egg->pos[0] = egg->pathCenter[0] + (sins(egg->pathRot) * egg->pathRadius);
|
||||
egg->pos[2] = egg->pathCenter[2] + (coss(egg->pathRot) * egg->pathRadius);
|
||||
egg->pos.x = egg->pathCenter[0] + (sins(egg->pathRot) * egg->pathRadius);
|
||||
egg->pos.z = egg->pathCenter[2] + (coss(egg->pathRot) * egg->pathRadius);
|
||||
if ((egg->flags & 0x400) != 0) {
|
||||
egg->pathCenter[1] -= 0.12;
|
||||
if (egg->pathCenter[1] < -3.0f) {
|
||||
egg->pathCenter[1] = -3.0f;
|
||||
}
|
||||
egg->pos[1] += egg->pathCenter[1];
|
||||
if (egg->pos[1] < 0.0f) {
|
||||
egg->pos[1] = 0.0f;
|
||||
egg->pos.y += egg->pathCenter[1];
|
||||
if (egg->pos.y < 0.0f) {
|
||||
egg->pos.y = 0.0f;
|
||||
egg->pathCenter[1] = 0.0f;
|
||||
egg->flags &= ~(1 << 10);
|
||||
}
|
||||
|
||||
+3
-3
@@ -63,9 +63,9 @@ void mtxf_translate_rotate2(Mat4 dest, Vec3f pos, Vec3s angle) {
|
||||
dest[2][2] = cx * cy;
|
||||
dest[2][3] = 0.0f;
|
||||
|
||||
dest[3][0] = pos[0];
|
||||
dest[3][1] = pos[1];
|
||||
dest[3][2] = pos[2];
|
||||
dest[3][0] = pos.x;
|
||||
dest[3][1] = pos.y;
|
||||
dest[3][2] = pos.z;
|
||||
dest[3][3] = 1.0f;
|
||||
}
|
||||
|
||||
|
||||
+57
-57
@@ -318,7 +318,7 @@ void func_800C19D0(u8 arg0, u8 arg1, u8 arg2) {
|
||||
sp3C = (func_800C1480(arg0, arg1) * *temp_s0->unk14) * D_80192C48[arg0].current;
|
||||
sp3B = func_800C15D0(arg0, arg1, arg2);
|
||||
sp34 = func_800C1934(arg0, arg1) * *temp_s0->unk10;
|
||||
sp33 = func_800C16E8(*temp_s0->unk00[0], *temp_s0->unk08, temp_s0->cameraId);
|
||||
sp33 = func_800C16E8(*temp_s0->unk00.x, *temp_s0->unk08, temp_s0->cameraId);
|
||||
break;
|
||||
}
|
||||
temp_s0_2 = &D_8018EF18[arg2];
|
||||
@@ -340,7 +340,7 @@ void func_800C19D0(u8 arg0, u8 arg1, u8 arg2) {
|
||||
}
|
||||
}
|
||||
|
||||
struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, f32* velocity, f32* arg3, u8 arg4, u32 soundBits) {
|
||||
struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, Vec3f velocity, f32* arg3, u8 arg4, u32 soundBits) {
|
||||
struct Unk_8018EFD8* temp_a1;
|
||||
struct Unk_8018EFD8* temp_v1;
|
||||
u8 temp_t7;
|
||||
@@ -355,14 +355,14 @@ struct Unk_8018EFD8* func_800C1C88(u8 arg0, Vec3f position, f32* velocity, f32*
|
||||
D_8018FB91 = why1;
|
||||
D_8018FB90 = D_8018EFD8[D_8018FB90].next;
|
||||
D_8018EFD8[D_8018FB90].prev = 0xFF;
|
||||
D_8018EFD8[why1].posX = &position[0];
|
||||
D_8018EFD8[why1].posY = &position[1];
|
||||
D_8018EFD8[why1].posZ = &position[2];
|
||||
D_8018EFD8[why1].posX = &position.x;
|
||||
D_8018EFD8[why1].posY = &position.y;
|
||||
D_8018EFD8[why1].posZ = &position.z;
|
||||
D_8018EFD8[why1].next = 0xFF;
|
||||
D_8018EFD8[why1].velX = &velocity[0];
|
||||
D_8018EFD8[why1].velY = &velocity[1];
|
||||
D_8018EFD8[why1].velZ = &velocity[2];
|
||||
D_8018EFD8[why1].unk18[1] = 0.0f;
|
||||
D_8018EFD8[why1].velX = &velocity.x;
|
||||
D_8018EFD8[why1].velY = &velocity.y;
|
||||
D_8018EFD8[why1].velZ = &velocity.z;
|
||||
D_8018EFD8[why1].unk18.y = 0.0f;
|
||||
D_8018EFD8[why1].unk24 = arg3;
|
||||
D_8018EFD8[why1].cameraId = arg4;
|
||||
D_8018EFD8[why1].unk30 = arg0;
|
||||
@@ -376,10 +376,10 @@ void func_800C1DA4(Camera* arg0, Vec3s rot, struct Unk_8018EFD8* arg2) {
|
||||
f32 x;
|
||||
f32 y;
|
||||
|
||||
x = arg0->pos[0] - *arg2->posX;
|
||||
y = arg0->pos[2] - *arg2->posZ;
|
||||
arg2->unk18[0] = func_800416D8(x, y, rot[1]);
|
||||
arg2->unk18[2] = func_80041724(x, y, rot[1]);
|
||||
x = arg0->pos.x - *arg2->posX;
|
||||
y = arg0->pos.z - *arg2->posZ;
|
||||
arg2->unk18.x = func_800416D8(x, y, rot.y);
|
||||
arg2->unk18.z = func_80041724(x, y, rot.y);
|
||||
}
|
||||
|
||||
void func_800C1E2C(Camera* camera, Vec3f velocity, struct Unk_8018EFD8* arg2) {
|
||||
@@ -393,11 +393,11 @@ void func_800C1E2C(Camera* camera, Vec3f velocity, struct Unk_8018EFD8* arg2) {
|
||||
f32 thing1;
|
||||
f32 temp_f2;
|
||||
|
||||
x = (*arg2->posX) - camera->pos[0];
|
||||
y = (*arg2->posZ) - camera->pos[2];
|
||||
x = (*arg2->posX) - camera->pos.x;
|
||||
y = (*arg2->posZ) - camera->pos.z;
|
||||
|
||||
sp44 = (*arg2->velX) - velocity[0];
|
||||
temp_f6 = (*arg2->velZ) - velocity[2];
|
||||
sp44 = (*arg2->velX) - velocity.x;
|
||||
temp_f6 = (*arg2->velZ) - velocity.z;
|
||||
|
||||
thing0 = x + sp44;
|
||||
thing1 = y + temp_f6;
|
||||
@@ -414,7 +414,7 @@ void func_800C1E2C(Camera* camera, Vec3f velocity, struct Unk_8018EFD8* arg2) {
|
||||
}
|
||||
|
||||
if ((*arg2->unk24) != 0.0f) {
|
||||
arg2->unk2C *= (((*arg2->unk24) / D_800EA06C[arg2->unk30].unk00[1]) + D_800EA06C[arg2->unk30].unk00[0]) +
|
||||
arg2->unk2C *= (((*arg2->unk24) / D_800EA06C[arg2->unk30].unk00.y) + D_800EA06C[arg2->unk30].unk00.x) +
|
||||
D_800E9F34[arg2->unk30];
|
||||
}
|
||||
}
|
||||
@@ -427,16 +427,16 @@ void func_800C1F8C(void) {
|
||||
|
||||
var_a1 = D_800EA1C0 + 1;
|
||||
for (var_s1 = 0; var_s1 < var_a1; var_s1++) {
|
||||
gVelocityCamera[var_s1][0] = gCopyCamera[var_s1]->pos[0] - gCameraLastPos[var_s1][0];
|
||||
gVelocityCamera[var_s1][2] = gCopyCamera[var_s1]->pos[2] - gCameraLastPos[var_s1][2];
|
||||
gCameraLastPos[var_s1][0] = gCopyCamera[var_s1]->pos[0];
|
||||
gCameraLastPos[var_s1][2] = gCopyCamera[var_s1]->pos[2];
|
||||
gVelocityCamera[var_s1].x = gCopyCamera[var_s1]->pos.x - gCameraLastPos[var_s1].x;
|
||||
gVelocityCamera[var_s1].z = gCopyCamera[var_s1]->pos.z - gCameraLastPos[var_s1].z;
|
||||
gCameraLastPos[var_s1].x = gCopyCamera[var_s1]->pos.x;
|
||||
gCameraLastPos[var_s1].z = gCopyCamera[var_s1]->pos.z;
|
||||
}
|
||||
|
||||
var_a1 = 0;
|
||||
var_s1 = D_8018EFD8[0].next;
|
||||
while (var_s1 != 0xFF) {
|
||||
if (D_8018EFD8[var_s1].unk18[1] == 100000.0f) {
|
||||
if (D_8018EFD8[var_s1].unk18.y == 100000.0f) {
|
||||
if (D_8018FB91 == var_s1) {
|
||||
D_8018FB91 = D_8018EFD8[var_s1].prev;
|
||||
} else {
|
||||
@@ -452,7 +452,7 @@ void func_800C1F8C(void) {
|
||||
// Why? Why would you do it this way? For what possible reason?
|
||||
camera = &gCopyCamera[cameraId];
|
||||
func_800C1DA4(*camera, (*camera)->rot, &D_8018EFD8[var_s1]);
|
||||
if (D_800EA1C8 != D_8018EFD8[var_s1].velX) {
|
||||
if (&D_800EA1C8 != D_8018EFD8[var_s1].velX) {
|
||||
func_800C1E2C(*camera, gVelocityCamera[0], &D_8018EFD8[var_s1]);
|
||||
}
|
||||
var_a1 = var_s1;
|
||||
@@ -468,7 +468,7 @@ Vec3f* func_800C21E8(Vec3f pos, u32 soundBits) {
|
||||
u8 it; // iterator
|
||||
Vec3f* ret;
|
||||
// Only here to force a match
|
||||
UNUSED f32* thing = pos;
|
||||
UNUSED f32* thing = &pos;
|
||||
struct Unk_8018EFD8* temp_a1;
|
||||
|
||||
ret = 0;
|
||||
@@ -477,10 +477,10 @@ Vec3f* func_800C21E8(Vec3f pos, u32 soundBits) {
|
||||
temp_a1 = &D_8018EFD8[it];
|
||||
// It doesn't matter what you set var_v0 to here actually
|
||||
it = D_8018EFD8[0].next;
|
||||
if ((pos == temp_a1->posX) && (soundBits == temp_a1->soundBits)) {
|
||||
if ((&pos == temp_a1->posX) && (soundBits == temp_a1->soundBits)) {
|
||||
// I suspect all this weirdness here is a result of someone not knowing the 'break' keyword
|
||||
it = 0xFF;
|
||||
if (temp_a1->unk18[1] != 100000.0f) {
|
||||
if (temp_a1->unk18.y != 100000.0f) {
|
||||
ret = &temp_a1->unk18;
|
||||
} else {
|
||||
goto test;
|
||||
@@ -575,12 +575,12 @@ void func_800C2474(void) {
|
||||
for (var_v0 = 0; var_v0 < 4; var_v0++) {
|
||||
D_800E9DB4[var_v0] = 0;
|
||||
D_800E9DF4[var_v0] = 0; // This is an f32 FYI, but 0.0f doesn't match right :)
|
||||
gVelocityCamera[var_v0][0] = 0.0f;
|
||||
gVelocityCamera[var_v0][1] = 0.0f;
|
||||
gVelocityCamera[var_v0][2] = 0.0f;
|
||||
gCameraLastPos[var_v0][0] = 0.0f;
|
||||
gCameraLastPos[var_v0][1] = 0.0f;
|
||||
gCameraLastPos[var_v0][2] = 0.0f;
|
||||
gVelocityCamera[var_v0].x = 0.0f;
|
||||
gVelocityCamera[var_v0].y = 0.0f;
|
||||
gVelocityCamera[var_v0].z = 0.0f;
|
||||
gCameraLastPos[var_v0].x = 0.0f;
|
||||
gCameraLastPos[var_v0].y = 0.0f;
|
||||
gCameraLastPos[var_v0].z = 0.0f;
|
||||
D_800EA0EC[var_v0] = 0;
|
||||
D_800E9EA4[var_v0] = 0;
|
||||
D_800E9F7C[var_v0].unk_14 = 0;
|
||||
@@ -1237,8 +1237,8 @@ void func_800C41CC(u8 arg0, struct SoundCharacteristics* arg1) {
|
||||
}
|
||||
if (found) {
|
||||
sound->soundBits = 0;
|
||||
if (*sound->position != D_800EA1C8) {
|
||||
(*sound->position)[1] = 100000.0f;
|
||||
if (sound->position != &D_800EA1C8) {
|
||||
sound->position.y = 100000.0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1307,9 +1307,9 @@ void func_800C4398(void) {
|
||||
}
|
||||
if ((sSoundBanks[bank][sSoundBankFreeListFront[bank]].next != 0xFF) && (soundIndex != 0)) {
|
||||
soundIndex = sSoundBankFreeListFront[bank];
|
||||
sSoundBanks[bank][soundIndex].unk00 = &(*var_a2->position)[0];
|
||||
sSoundBanks[bank][soundIndex].unk04 = &(*var_a2->position)[1];
|
||||
sSoundBanks[bank][soundIndex].unk08 = &(*var_a2->position)[2];
|
||||
sSoundBanks[bank][soundIndex].unk00 = &(*var_a2->position).x;
|
||||
sSoundBanks[bank][soundIndex].unk04 = &(*var_a2->position).y;
|
||||
sSoundBanks[bank][soundIndex].unk08 = &(*var_a2->position).z;
|
||||
sSoundBanks[bank][soundIndex].cameraId = var_a2->cameraId;
|
||||
sSoundBanks[bank][soundIndex].unk10 = var_a2->unk0C;
|
||||
sSoundBanks[bank][soundIndex].unk14 = var_a2->unk10;
|
||||
@@ -1324,8 +1324,8 @@ void func_800C4398(void) {
|
||||
sSoundBanks[bank][sSoundBankFreeListFront[bank]].prev = 0xFF;
|
||||
sSoundBanks[bank][soundIndex].next = 0xFF;
|
||||
} else if (sSoundBanks[bank][sSoundBankFreeListFront[bank]].next == 0xFF) {
|
||||
if (D_800EA1C8 != *var_a2->position) {
|
||||
(*var_a2->position)[1] = 100000.0f;
|
||||
if (&D_800EA1C8 != var_a2->position) {
|
||||
(*var_a2->position).y = 100000.0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1336,7 +1336,7 @@ GLOBAL_ASM("asm/non_matchings/audio/external/func_800C4398.s")
|
||||
void delete_sound_from_bank(u8 bankId, u8 soundId) {
|
||||
UNUSED s32 stackPadding;
|
||||
struct SoundCharacteristics* temp = &sSoundBanks[bankId][soundId];
|
||||
if (*temp->unk00 != D_800EA1C8) {
|
||||
if (temp->unk00->x != D_800EA1C8.x) {
|
||||
*temp->unk04 = 100000.0f;
|
||||
}
|
||||
if (temp->soundBits & 0x80000) {
|
||||
@@ -1393,10 +1393,10 @@ void func_800C4888(u8 bankId) {
|
||||
if (temp_t2->freshness == 0) {
|
||||
delete_sound_from_bank(bankId, soundIndex);
|
||||
} else if (temp_t2->soundStatus != 0) {
|
||||
if (D_800EA1C8 == *temp_t2->unk00) {
|
||||
if (D_800EA1C8.x == temp_t2->unk00->x) {
|
||||
temp_t2->distance = 0.0f;
|
||||
} else {
|
||||
temp_t2->distance = ((*temp_t2->unk00)[0] * (*temp_t2->unk00)[0]) + (*temp_t2->unk08 * *temp_t2->unk08);
|
||||
temp_t2->distance = (temp_t2->unk00->x * temp_t2->unk00->x) + (*temp_t2->unk08 * *temp_t2->unk08);
|
||||
}
|
||||
requestedPriority = ((u32) (temp_t2->soundBits & 0xFF00) >> 8) & 0xFF;
|
||||
if (temp_t2->soundBits & 0x100000) {
|
||||
@@ -1581,7 +1581,7 @@ void func_800C5384(u8 arg0, Vec3f* arg1) {
|
||||
next = sSoundBanks[arg0][0].next;
|
||||
|
||||
while (next != 0xff) {
|
||||
if (*arg1 == *sSoundBanks[arg0][next].unk00) {
|
||||
if (arg1->x == sSoundBanks[arg0][next].unk00->x) {
|
||||
if (sSoundBanks[arg0][next].soundStatus >= 3) {
|
||||
func_800CBBE8((0x06020000 | ((sSoundBanks[arg0][next].unk2C & 0xff) << 8)), 0);
|
||||
}
|
||||
@@ -2789,7 +2789,7 @@ void func_800C8AE4(void) {
|
||||
}
|
||||
|
||||
void func_800C8C7C(u8 arg0) {
|
||||
D_800EA06C[arg0].unk00[2] = (1.0f - D_800E9F54[arg0]) - D_800EA130[arg0];
|
||||
D_800EA06C[arg0].unk00.z = (1.0f - D_800E9F54[arg0]) - D_800EA130[arg0];
|
||||
}
|
||||
|
||||
void func_800C8CCC() {
|
||||
@@ -2913,7 +2913,7 @@ void func_800C92CC(u8 playerId, u32 soundBits) {
|
||||
|
||||
if ((D_800EA108 == 0) && (D_800EA0F0 == 0) && ((s32) D_800EA1C0 < 2)) {
|
||||
for (var_s0 = 0; var_s0 < D_800EA1C0 + 1; var_s0++) {
|
||||
temp_v0 = func_800C1C88(playerId, gPlayers[playerId].pos, gPlayers[playerId].velocity, D_800EA1C8,
|
||||
temp_v0 = func_800C1C88(playerId, gPlayers[playerId].pos, gPlayers[playerId].velocity, &D_800EA1C8,
|
||||
(u8) var_s0, soundBits);
|
||||
if (temp_v0 != NULL) {
|
||||
temp_v0->unk34 = 170.0f;
|
||||
@@ -3072,26 +3072,26 @@ void func_800C9A88(u8 playerId) {
|
||||
switch (gPlayers[playerId].characterId) {
|
||||
case 0:
|
||||
case 1:
|
||||
D_800EA06C[playerId].unk00[0] = 0.35f;
|
||||
D_800EA06C[playerId].unk00[1] = 1568.9796f;
|
||||
D_800EA06C[playerId].unk00.x = 0.35f;
|
||||
D_800EA06C[playerId].unk00.y = 1568.9796f;
|
||||
break;
|
||||
case 2:
|
||||
case 6:
|
||||
D_800EA06C[playerId].unk00[0] = 0.6f;
|
||||
D_800EA06C[playerId].unk00[1] = 1478.4615f;
|
||||
D_800EA06C[playerId].unk00.x = 0.6f;
|
||||
D_800EA06C[playerId].unk00.y = 1478.4615f;
|
||||
break;
|
||||
case 3:
|
||||
D_800EA06C[playerId].unk00[0] = 0.6f;
|
||||
D_800EA06C[playerId].unk00[1] = 1747.2728f;
|
||||
D_800EA06C[playerId].unk00.x = 0.6f;
|
||||
D_800EA06C[playerId].unk00.y = 1747.2728f;
|
||||
break;
|
||||
case 4:
|
||||
D_800EA06C[playerId].unk00[0] = 0.2f;
|
||||
D_800EA06C[playerId].unk00[1] = 2135.5557f;
|
||||
D_800EA06C[playerId].unk00.x = 0.2f;
|
||||
D_800EA06C[playerId].unk00.y = 2135.5557f;
|
||||
break;
|
||||
case 5:
|
||||
case 7:
|
||||
D_800EA06C[playerId].unk00[0] = 0.4f;
|
||||
D_800EA06C[playerId].unk00[1] = 1922.0f;
|
||||
D_800EA06C[playerId].unk00.x = 0.4f;
|
||||
D_800EA06C[playerId].unk00.y = 1922.0f;
|
||||
}
|
||||
if (D_800EA1C0 < 2) {
|
||||
for (var_s0 = 0; var_s0 < D_800EA1C0 + 1; var_s0++) {
|
||||
@@ -3101,7 +3101,7 @@ void func_800C9A88(u8 playerId) {
|
||||
if (temp_v0_6 != NULL) {
|
||||
temp_v0_6->unk34 = 40.0f;
|
||||
play_sound(soundBits, &temp_v0_6->unk18, var_s0, &temp_v0_6->unk2C,
|
||||
&D_800EA06C[playerId].unk00[2], &D_800EA06C[playerId].unk0C);
|
||||
&D_800EA06C[playerId].unk00.z, &D_800EA06C[playerId].unk0C);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+124
-124
@@ -70,13 +70,13 @@ void camera_init(f32 posX, f32 posY, f32 posZ, UNUSED s16 rot, u32 arg4, s32 cam
|
||||
case 9:
|
||||
case 10:
|
||||
D_80164A89 = 0;
|
||||
camera->pos[0] = posX;
|
||||
camera->pos[1] = posY;
|
||||
camera->pos[2] = posZ;
|
||||
camera->pos.x = posX;
|
||||
camera->pos.y = posY;
|
||||
camera->pos.z = posZ;
|
||||
camera->someBitFlags = 0;
|
||||
camera->lookAt[0] = 0.0f;
|
||||
camera->lookAt[2] = 150.0f;
|
||||
camera->lookAt[1] = posY - 3.0;
|
||||
camera->lookAt.x = 0.0f;
|
||||
camera->lookAt.z = 150.0f;
|
||||
camera->lookAt.y = posY - 3.0;
|
||||
camera->up[0] = 0.0f;
|
||||
camera->up[1] = 1.0f;
|
||||
camera->up[2] = 0.0f;
|
||||
@@ -237,9 +237,9 @@ void func_8001CA78(UNUSED Player* player, Camera* camera, Vec3f arg2, f32* arg3,
|
||||
sp5C[0] = camera->unk_3C[0];
|
||||
sp5C[1] = camera->unk_3C[1];
|
||||
sp5C[2] = camera->unk_3C[2];
|
||||
arg2[0] = camera->lookAt[0];
|
||||
arg2[1] = camera->lookAt[1];
|
||||
arg2[2] = camera->lookAt[2];
|
||||
arg2[0] = camera->lookAt.x;
|
||||
arg2[1] = camera->lookAt.y;
|
||||
arg2[2] = camera->lookAt.z;
|
||||
calculate_orientation_matrix(sp74, 0, 1, 0, -0x00008000);
|
||||
mtxf_translate_vec3f_mat3(sp5C, sp74);
|
||||
if (GetCourse() == GetToadsTurnpike()) {
|
||||
@@ -249,9 +249,9 @@ void func_8001CA78(UNUSED Player* player, Camera* camera, Vec3f arg2, f32* arg3,
|
||||
}
|
||||
temp_f16 = D_80165230[7] + sp5C[2];
|
||||
temp_f18 = sp5C[1] + (temp_s2->posY + D_80164A30);
|
||||
arg2[0] += (var_f14 - camera->lookAt[0]) * 1;
|
||||
arg2[1] += (temp_f18 - camera->lookAt[1]) * 1;
|
||||
arg2[2] += (temp_f16 - camera->lookAt[2]) * 1;
|
||||
arg2[0] += (var_f14 - camera->lookAt.x) * 1;
|
||||
arg2[1] += (temp_f18 - camera->lookAt.y) * 1;
|
||||
arg2[2] += (temp_f16 - camera->lookAt.z) * 1;
|
||||
mtxf_translate_vec3f_mat3(sp68, sp74);
|
||||
if (GetCourse() == GetToadsTurnpike()) {
|
||||
var_f14 = sp68[0];
|
||||
@@ -261,11 +261,11 @@ void func_8001CA78(UNUSED Player* player, Camera* camera, Vec3f arg2, f32* arg3,
|
||||
temp_f16 = D_80165230[7] + sp68[2];
|
||||
temp_f18 = sp68[1] + (temp_s2->posY + D_80164A30 + 6.0f);
|
||||
move_f32_towards(&D_80164A30, 0, 0.02f);
|
||||
posX = camera->pos[0];
|
||||
posX = camera->pos.x;
|
||||
*arg3 = ((var_f14 - posX) * 1) + posX;
|
||||
posY = camera->pos[1];
|
||||
posY = camera->pos.y;
|
||||
*arg4 = ((temp_f18 - posY) * 1) + posY;
|
||||
posZ = camera->pos[2];
|
||||
posZ = camera->pos.z;
|
||||
*arg5 = ((temp_f16 - posZ) * 1) + posZ;
|
||||
}
|
||||
|
||||
@@ -366,45 +366,45 @@ void func_8001CCEC(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
|
||||
sp84[0] = camera->unk_3C[0];
|
||||
sp84[1] = camera->unk_3C[1] + (player->unk_DB4.unk1E * 0.85) + temp_f12;
|
||||
sp84[2] = camera->unk_3C[2] + temp_f0 - D_80164A90[index];
|
||||
arg2[0] = camera->lookAt[0];
|
||||
arg2[1] = camera->lookAt[1];
|
||||
arg2[2] = camera->lookAt[2];
|
||||
arg2[0] = camera->lookAt.x;
|
||||
arg2[1] = camera->lookAt.y;
|
||||
arg2[2] = camera->lookAt.z;
|
||||
if ((player->effects & 0x01000000) == 0x01000000) {
|
||||
sp84[2] /= 3.0f;
|
||||
}
|
||||
calculate_orientation_matrix(sp9C, 0, 1, 0, arg7);
|
||||
mtxf_translate_vec3f_mat3(sp84, sp9C);
|
||||
|
||||
x = player->pos[0] + sp84[0];
|
||||
z = player->pos[2] + sp84[2];
|
||||
y = player->pos[1] + sp84[1];
|
||||
x = player->pos.x + sp84[0];
|
||||
z = player->pos.z + sp84[2];
|
||||
y = player->pos.y + sp84[1];
|
||||
|
||||
arg2[0] += (x - camera->lookAt[0]) * D_80164A78[index];
|
||||
arg2[2] += ((z - camera->lookAt[2]) * D_80164A78[index]);
|
||||
arg2[0] += (x - camera->lookAt.x) * D_80164A78[index];
|
||||
arg2[2] += ((z - camera->lookAt.z) * D_80164A78[index]);
|
||||
|
||||
if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
|
||||
arg2[1] += ((y - camera->lookAt[1]) * 0.02);
|
||||
arg2[1] += ((y - camera->lookAt.y) * 0.02);
|
||||
} else {
|
||||
arg2[1] += ((y - camera->lookAt[1]) * 0.5);
|
||||
arg2[1] += ((y - camera->lookAt.y) * 0.5);
|
||||
}
|
||||
mtxf_translate_vec3f_mat3(sp90, sp9C);
|
||||
x = player->pos[0] + sp90[0];
|
||||
z = player->pos[2] + sp90[2];
|
||||
x = player->pos.x + sp90[0];
|
||||
z = player->pos.z + sp90[2];
|
||||
if ((player->effects & 0x01000000) != 0x01000000) {
|
||||
var_f0 = player->pos[1] + sp90[1];
|
||||
var_f0 = player->pos.y + sp90[1];
|
||||
// permute
|
||||
y = var_f0;
|
||||
} else {
|
||||
y = player->unk_074 + player->boundingBoxSize + sp90[1];
|
||||
}
|
||||
|
||||
*arg3 = camera->pos[0] + ((x - camera->pos[0]) * D_80164A78[index]);
|
||||
*arg5 = camera->pos[2] + ((z - camera->pos[2]) * D_80164A78[index]);
|
||||
*arg3 = camera->pos.x + ((x - camera->pos.x) * D_80164A78[index]);
|
||||
*arg5 = camera->pos.z + ((z - camera->pos.z) * D_80164A78[index]);
|
||||
|
||||
if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
|
||||
*arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.01));
|
||||
*arg4 = camera->pos.y + (((y - camera->pos.y) * 0.01));
|
||||
} else {
|
||||
*arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.15));
|
||||
*arg4 = camera->pos.y + (((y - camera->pos.y) * 0.15));
|
||||
}
|
||||
|
||||
if ((player->unk_0DE & 1) != 0) {
|
||||
@@ -437,20 +437,20 @@ void func_8001D53C(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
|
||||
sp5C[0] = camera->unk_3C[0];
|
||||
sp5C[1] = camera->unk_3C[1] + camera->unk_A0;
|
||||
sp5C[2] = camera->unk_3C[2];
|
||||
arg2[0] = camera->lookAt[0];
|
||||
arg2[1] = camera->lookAt[1];
|
||||
arg2[2] = camera->lookAt[2];
|
||||
arg2[0] = camera->lookAt.x;
|
||||
arg2[1] = camera->lookAt.y;
|
||||
arg2[2] = camera->lookAt.z;
|
||||
calculate_orientation_matrix(sp74, 0.0f, 1.0f, 0.0f, arg6);
|
||||
mtxf_translate_vec3f_mat3(sp5C, sp74);
|
||||
stackPadding0 = player->pos[0] + sp5C[0];
|
||||
stackPadding2 = player->pos[2] + sp5C[2];
|
||||
stackPadding1 = player->pos[1] + sp5C[1];
|
||||
arg2[0] += (stackPadding0 - camera->lookAt[0]) * 1;
|
||||
arg2[2] += (stackPadding2 - camera->lookAt[2]) * 1;
|
||||
arg2[1] += (stackPadding1 - camera->lookAt[1]) * 1;
|
||||
stackPadding0 = player->pos.x + sp5C[0];
|
||||
stackPadding2 = player->pos.z + sp5C[2];
|
||||
stackPadding1 = player->pos.y + sp5C[1];
|
||||
arg2[0] += (stackPadding0 - camera->lookAt.x) * 1;
|
||||
arg2[2] += (stackPadding2 - camera->lookAt.z) * 1;
|
||||
arg2[1] += (stackPadding1 - camera->lookAt.y) * 1;
|
||||
mtxf_translate_vec3f_mat3(sp68, sp74);
|
||||
stackPadding0 = player->pos[0] + sp68[0];
|
||||
stackPadding2 = player->pos[2] + sp68[2];
|
||||
stackPadding0 = player->pos.x + sp68[0];
|
||||
stackPadding2 = player->pos.z + sp68[2];
|
||||
stackPadding1 = sp68[1] + (player->unk_074 + 1.5);
|
||||
if ((player->unk_0CA & 1) == 1) {
|
||||
stackPadding1 = sp68[1] + (thing + 10.0f);
|
||||
@@ -479,28 +479,28 @@ void func_8001D794(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
|
||||
sp54[1] = camera->unk_3C[1];
|
||||
sp54[2] = camera->unk_3C[2];
|
||||
|
||||
arg2[0] = camera->lookAt[0];
|
||||
arg2[1] = camera->lookAt[1];
|
||||
arg2[2] = camera->lookAt[2];
|
||||
arg2[0] = camera->lookAt.x;
|
||||
arg2[1] = camera->lookAt.y;
|
||||
arg2[2] = camera->lookAt.z;
|
||||
|
||||
calculate_orientation_matrix(sp6C, 0, 1, 0, arg6);
|
||||
mtxf_translate_vec3f_mat3(sp54, sp6C);
|
||||
|
||||
test1 = player->pos[0] + sp54[0];
|
||||
test3 = player->pos[2] + sp54[2];
|
||||
test2 = player->pos[1] + sp54[1];
|
||||
arg2[0] += (test1 - camera->lookAt[0]) * 1;
|
||||
arg2[1] += (test2 - camera->lookAt[1]) * 1;
|
||||
arg2[2] += (test3 - camera->lookAt[2]) * 1;
|
||||
test1 = player->pos.x + sp54[0];
|
||||
test3 = player->pos.z + sp54[2];
|
||||
test2 = player->pos.y + sp54[1];
|
||||
arg2[0] += (test1 - camera->lookAt.x) * 1;
|
||||
arg2[1] += (test2 - camera->lookAt.y) * 1;
|
||||
arg2[2] += (test3 - camera->lookAt.z) * 1;
|
||||
|
||||
mtxf_translate_vec3f_mat3(sp60, sp6C);
|
||||
|
||||
test1 = player->pos[0] + sp60[0];
|
||||
test3 = player->pos[2] + sp60[2];
|
||||
test2 = player->pos[1] + sp60[1];
|
||||
*arg3 = camera->pos[0] + ((test1 - camera->pos[0]) * 1);
|
||||
*arg4 = camera->pos[1] + ((test2 - camera->pos[1]) * 1);
|
||||
*arg5 = camera->pos[2] + ((test3 - camera->pos[2]) * 1);
|
||||
test1 = player->pos.x + sp60[0];
|
||||
test3 = player->pos.z + sp60[2];
|
||||
test2 = player->pos.y + sp60[1];
|
||||
*arg3 = camera->pos.x + ((test1 - camera->pos.x) * 1);
|
||||
*arg4 = camera->pos.y + ((test2 - camera->pos.y) * 1);
|
||||
*arg5 = camera->pos.z + ((test3 - camera->pos.z) * 1);
|
||||
}
|
||||
|
||||
void func_8001D944(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* arg4, f32* arg5, UNUSED s32* arg6,
|
||||
@@ -586,45 +586,45 @@ void func_8001D944(Player* player, Camera* camera, Vec3f arg2, f32* arg3, f32* a
|
||||
sp84[0] = camera->unk_3C[0];
|
||||
sp84[1] = camera->unk_3C[1] + (player->unk_DB4.unk1E * 0.85) + temp_f12;
|
||||
sp84[2] = camera->unk_3C[2] + temp_f0 - D_80164A90[index];
|
||||
arg2[0] = camera->lookAt[0];
|
||||
arg2[1] = camera->lookAt[1];
|
||||
arg2[2] = camera->lookAt[2];
|
||||
arg2[0] = camera->lookAt.x;
|
||||
arg2[1] = camera->lookAt.y;
|
||||
arg2[2] = camera->lookAt.z;
|
||||
if ((player->effects & 0x01000000) == 0x01000000) {
|
||||
sp84[2] /= 3.0f;
|
||||
}
|
||||
calculate_orientation_matrix(sp9C, 0, 1, 0, arg7);
|
||||
mtxf_translate_vec3f_mat3(sp84, sp9C);
|
||||
|
||||
x = player->pos[0] + sp84[0];
|
||||
z = player->pos[2] + sp84[2];
|
||||
y = player->pos[1] + sp84[1];
|
||||
x = player->pos.x + sp84[0];
|
||||
z = player->pos.z + sp84[2];
|
||||
y = player->pos.y + sp84[1];
|
||||
|
||||
arg2[0] += (x - camera->lookAt[0]) * D_80164A78[index];
|
||||
arg2[2] += ((z - camera->lookAt[2]) * D_80164A78[index]);
|
||||
arg2[0] += (x - camera->lookAt.x) * D_80164A78[index];
|
||||
arg2[2] += ((z - camera->lookAt.z) * D_80164A78[index]);
|
||||
|
||||
if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
|
||||
arg2[1] += ((y - camera->lookAt[1]) * 0.02);
|
||||
arg2[1] += ((y - camera->lookAt.y) * 0.02);
|
||||
} else {
|
||||
arg2[1] += ((y - camera->lookAt[1]) * 0.5);
|
||||
arg2[1] += ((y - camera->lookAt.y) * 0.5);
|
||||
}
|
||||
mtxf_translate_vec3f_mat3(sp90, sp9C);
|
||||
x = player->pos[0] + sp90[0];
|
||||
z = player->pos[2] + sp90[2];
|
||||
x = player->pos.x + sp90[0];
|
||||
z = player->pos.z + sp90[2];
|
||||
if ((player->effects & 0x01000000) != 0x01000000) {
|
||||
var_f0 = player->pos[1] + sp90[1];
|
||||
var_f0 = player->pos.y + sp90[1];
|
||||
// permute
|
||||
y = var_f0;
|
||||
} else {
|
||||
y = player->unk_074 + player->boundingBoxSize + sp90[1];
|
||||
}
|
||||
|
||||
*arg3 = camera->pos[0] + ((x - camera->pos[0]) * D_80164A78[index]);
|
||||
*arg5 = camera->pos[2] + ((z - camera->pos[2]) * D_80164A78[index]);
|
||||
*arg3 = camera->pos.x + ((x - camera->pos.x) * D_80164A78[index]);
|
||||
*arg5 = camera->pos.z + ((z - camera->pos.z) * D_80164A78[index]);
|
||||
|
||||
if ((((player->unk_094 / 18) * 216) <= 5.0f) && ((player->effects & 2) == 2)) {
|
||||
*arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.01));
|
||||
*arg4 = camera->pos.y + (((y - camera->pos.y) * 0.01));
|
||||
} else {
|
||||
*arg4 = camera->pos[1] + (((y - camera->pos[1]) * 0.15));
|
||||
*arg4 = camera->pos.y + (((y - camera->pos.y) * 0.15));
|
||||
}
|
||||
|
||||
if ((player->unk_0DE & 1) != 0) {
|
||||
@@ -678,18 +678,18 @@ void func_8001E0C4(Camera* camera, Player* player, s8 arg2) {
|
||||
if ((temp_t7 == 0) && ((camera->someBitFlags & 2) != 2)) {
|
||||
camera->unk_AC = camera->unk_2C;
|
||||
}
|
||||
camera->lookAt[0] = sp60[0];
|
||||
camera->lookAt[1] = sp60[1];
|
||||
camera->lookAt[2] = sp60[2];
|
||||
camera->pos[0] = sp74;
|
||||
camera->pos[1] = sp70;
|
||||
camera->pos[2] = sp6C;
|
||||
temp_f12 = camera->lookAt[0] - camera->pos[0];
|
||||
sp80 = camera->lookAt[1] - camera->pos[1];
|
||||
temp_f14 = camera->lookAt[2] - camera->pos[2];
|
||||
camera->rot[1] = atan2s(temp_f12, temp_f14);
|
||||
camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp80);
|
||||
camera->rot[2] = 0;
|
||||
camera->lookAt.x = sp60[0];
|
||||
camera->lookAt.y = sp60[1];
|
||||
camera->lookAt.z = sp60[2];
|
||||
camera->pos.x = sp74;
|
||||
camera->pos.y = sp70;
|
||||
camera->pos.z = sp6C;
|
||||
temp_f12 = camera->lookAt.x - camera->pos.x;
|
||||
sp80 = camera->lookAt.y - camera->pos.y;
|
||||
temp_f14 = camera->lookAt.z - camera->pos.z;
|
||||
camera->rot.y = atan2s(temp_f12, temp_f14);
|
||||
camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp80);
|
||||
camera->rot.z = 0;
|
||||
}
|
||||
|
||||
// This function has a few stack variables.
|
||||
@@ -767,21 +767,21 @@ void func_8001E45C(Camera* camera, Player* player, s8 arg2) {
|
||||
camera->someBitFlags &= 0xFFFB;
|
||||
check_bounding_collision(&camera->collision, temp, sp84, sp80, sp7C);
|
||||
|
||||
camera->pos[0] = sp84;
|
||||
camera->pos[1] = sp80;
|
||||
camera->pos[2] = sp7C;
|
||||
camera->pos.x = sp84;
|
||||
camera->pos.y = sp80;
|
||||
camera->pos.z = sp7C;
|
||||
|
||||
camera->lookAt[0] = sp64[0];
|
||||
camera->lookAt[1] = sp64[1];
|
||||
camera->lookAt[2] = sp64[2];
|
||||
camera->lookAt.x = sp64[0];
|
||||
camera->lookAt.y = sp64[1];
|
||||
camera->lookAt.z = sp64[2];
|
||||
|
||||
temp_f12 = camera->lookAt[0] - camera->pos[0];
|
||||
sp90 = camera->lookAt[1] - camera->pos[1];
|
||||
temp_f14 = camera->lookAt[2] - camera->pos[2];
|
||||
temp_f12 = camera->lookAt.x - camera->pos.x;
|
||||
sp90 = camera->lookAt.y - camera->pos.y;
|
||||
temp_f14 = camera->lookAt.z - camera->pos.z;
|
||||
|
||||
camera->rot[1] = atan2s(temp_f12, temp_f14);
|
||||
camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
|
||||
camera->rot[2] = 0;
|
||||
camera->rot.y = atan2s(temp_f12, temp_f14);
|
||||
camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
|
||||
camera->rot.z = 0;
|
||||
}
|
||||
|
||||
void func_8001E8E8(Camera* camera, Player* player, s8 arg2) {
|
||||
@@ -801,18 +801,18 @@ void func_8001E8E8(Camera* camera, Player* player, s8 arg2) {
|
||||
camera->unk_2C = player->rotation[1];
|
||||
func_8001D53C(player, camera, sp5C, &sp7C, &sp78, &sp74, (s16) (s32) player->rotation[1], (s16) (s32) arg2);
|
||||
check_bounding_collision(&camera->collision, 5.0f, sp7C, sp78, sp74);
|
||||
camera->lookAt[0] = sp5C[0];
|
||||
camera->lookAt[1] = sp5C[1];
|
||||
camera->lookAt[2] = sp5C[2];
|
||||
camera->pos[0] = sp7C;
|
||||
camera->pos[1] = sp78;
|
||||
camera->pos[2] = sp74;
|
||||
temp_f12 = camera->lookAt[0] - camera->pos[0];
|
||||
sp88 = camera->lookAt[1] - camera->pos[1];
|
||||
temp_f14 = camera->lookAt[2] - camera->pos[2];
|
||||
camera->rot[1] = atan2s(temp_f12, temp_f14);
|
||||
camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp88);
|
||||
camera->rot[2] = 0;
|
||||
camera->lookAt.x = sp5C[0];
|
||||
camera->lookAt.y = sp5C[1];
|
||||
camera->lookAt.z = sp5C[2];
|
||||
camera->pos.x = sp7C;
|
||||
camera->pos.y = sp78;
|
||||
camera->pos.z = sp74;
|
||||
temp_f12 = camera->lookAt.x - camera->pos.x;
|
||||
sp88 = camera->lookAt.y - camera->pos.y;
|
||||
temp_f14 = camera->lookAt.z - camera->pos.z;
|
||||
camera->rot.y = atan2s(temp_f12, temp_f14);
|
||||
camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp88);
|
||||
camera->rot.z = 0;
|
||||
}
|
||||
|
||||
void func_8001EA0C(Camera* camera, Player* player, s8 arg2) {
|
||||
@@ -890,21 +890,21 @@ void func_8001EA0C(Camera* camera, Player* player, s8 arg2) {
|
||||
camera->someBitFlags &= 0xFFFB;
|
||||
check_bounding_collision(&camera->collision, temp, sp84, sp80, sp7C);
|
||||
|
||||
camera->pos[0] = sp84;
|
||||
camera->pos[1] = sp80;
|
||||
camera->pos[2] = sp7C;
|
||||
camera->pos.x = sp84;
|
||||
camera->pos.y = sp80;
|
||||
camera->pos.z = sp7C;
|
||||
|
||||
camera->lookAt[0] = sp64[0];
|
||||
camera->lookAt[1] = sp64[1];
|
||||
camera->lookAt[2] = sp64[2];
|
||||
camera->lookAt.x = sp64[0];
|
||||
camera->lookAt.y = sp64[1];
|
||||
camera->lookAt.z = sp64[2];
|
||||
|
||||
temp_f12 = camera->lookAt[0] - camera->pos[0];
|
||||
sp90 = camera->lookAt[1] - camera->pos[1];
|
||||
temp_f14 = camera->lookAt[2] - camera->pos[2];
|
||||
temp_f12 = camera->lookAt.x - camera->pos.x;
|
||||
sp90 = camera->lookAt.y - camera->pos.y;
|
||||
temp_f14 = camera->lookAt.z - camera->pos.z;
|
||||
|
||||
camera->rot[1] = atan2s(temp_f12, temp_f14);
|
||||
camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
|
||||
camera->rot[2] = 0;
|
||||
camera->rot.y = atan2s(temp_f12, temp_f14);
|
||||
camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), sp90);
|
||||
camera->rot.z = 0;
|
||||
}
|
||||
|
||||
void func_8001EE98(Player* player, Camera* camera, s8 index) {
|
||||
@@ -1160,7 +1160,7 @@ void func_8001F87C(s32 cameraId) {
|
||||
if ((playerIndex == 7) && (D_80164A2C == 0x0000003C)) {
|
||||
D_80164A28 = 2;
|
||||
D_80152300[id] = 1;
|
||||
cameras[id].rot[1] = gPlayerOne[playerIndex].rotation[1];
|
||||
cameras[id].rot.y = gPlayerOne[playerIndex].rotation[1];
|
||||
cameras[id].unk_2C = gPlayerOne[playerIndex].rotation[1];
|
||||
}
|
||||
}
|
||||
|
||||
+375
-375
File diff suppressed because it is too large
Load Diff
+204
-217
@@ -1182,9 +1182,9 @@ void func_80059820(s32 playerId) {
|
||||
D_8018CF1C = &gPlayerOne[playerId];
|
||||
D_8018CF14 = &camera1[playerId];
|
||||
temp_v0 = &playerHUD[playerId];
|
||||
temp_v0->posXInt = (s32) D_8018CF1C->pos[0];
|
||||
temp_v0->posYInt = (s32) D_8018CF1C->pos[1];
|
||||
temp_v0->posZInt = (s32) D_8018CF1C->pos[2];
|
||||
temp_v0->posXInt = (s32) D_8018CF1C->pos.x;
|
||||
temp_v0->posYInt = (s32) D_8018CF1C->pos.y;
|
||||
temp_v0->posZInt = (s32) D_8018CF1C->pos.z;
|
||||
}
|
||||
|
||||
void randomize_seed_from_controller(s32 arg0) {
|
||||
@@ -2843,12 +2843,12 @@ void func_8005D898(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
|
||||
s32 temp_lo;
|
||||
|
||||
if (player->unk_0C0 >= 0) {
|
||||
func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_LEFT].pos[0],
|
||||
player->tyres[BACK_LEFT].baseHeight + 2.0f, player->tyres[BACK_LEFT].pos[2],
|
||||
func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_LEFT].pos.x,
|
||||
player->tyres[BACK_LEFT].baseHeight + 2.0f, player->tyres[BACK_LEFT].pos.z,
|
||||
player->tyres[BACK_LEFT].surfaceType, 1);
|
||||
} else {
|
||||
func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_RIGHT].pos[0],
|
||||
player->tyres[BACK_RIGHT].baseHeight + 2.0f, player->tyres[BACK_RIGHT].pos[2],
|
||||
func_8005D794(player, &player->unk_258[10 + arg1], player->tyres[BACK_RIGHT].pos.x,
|
||||
player->tyres[BACK_RIGHT].baseHeight + 2.0f, player->tyres[BACK_RIGHT].pos.z,
|
||||
player->tyres[BACK_RIGHT].surfaceType, 0);
|
||||
}
|
||||
|
||||
@@ -2907,16 +2907,16 @@ void func_8005DAF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
surfaceType = 0x000000FF;
|
||||
temp_v0 = random_int(test);
|
||||
if ((temp_v0 == 0) || (temp_v0 == 4)) {
|
||||
var_f2 = player->tyres[BACK_LEFT].pos[0];
|
||||
var_f2 = player->tyres[BACK_LEFT].pos.x;
|
||||
var_f12 = player->tyres[BACK_LEFT].baseHeight + 2.0f;
|
||||
var_f14 = player->tyres[BACK_LEFT].pos[2];
|
||||
var_f14 = player->tyres[BACK_LEFT].pos.z;
|
||||
var_t3 = 1;
|
||||
surfaceType = player->tyres[BACK_LEFT].surfaceType;
|
||||
}
|
||||
if ((temp_v0 == 2) || (temp_v0 == 6)) {
|
||||
var_f2 = player->tyres[BACK_RIGHT].pos[0];
|
||||
var_f2 = player->tyres[BACK_RIGHT].pos.x;
|
||||
var_f12 = player->tyres[BACK_RIGHT].baseHeight + 2.0f;
|
||||
var_f14 = player->tyres[BACK_RIGHT].pos[2];
|
||||
var_f14 = player->tyres[BACK_RIGHT].pos.z;
|
||||
var_t3 = 0;
|
||||
surfaceType = player->tyres[BACK_RIGHT].surfaceType;
|
||||
}
|
||||
@@ -3131,18 +3131,18 @@ void func_8005EA94(Player* player, s16 arg1, s32 arg2, s8 arg3, UNUSED s8 arg4)
|
||||
temp_v0 = random_int(test);
|
||||
if ((temp_v0 == 0) || (temp_v0 == 8)) {
|
||||
if ((D_801652A0[arg3] - player->tyres[BACK_LEFT].baseHeight) >= 3.5) {
|
||||
var_f2 = player->tyres[BACK_LEFT].pos[0];
|
||||
var_f2 = player->tyres[BACK_LEFT].pos.x;
|
||||
var_f12 = player->tyres[BACK_LEFT].baseHeight + 2.0f;
|
||||
var_f14 = player->tyres[BACK_LEFT].pos[2];
|
||||
var_f14 = player->tyres[BACK_LEFT].pos.z;
|
||||
var_t1 = 1;
|
||||
var_t0 = 0;
|
||||
}
|
||||
}
|
||||
if ((temp_v0 == 2) || (temp_v0 == 6)) {
|
||||
if ((D_801652A0[arg3] - player->tyres[BACK_RIGHT].baseHeight) >= 3.5) {
|
||||
var_f2 = player->tyres[BACK_RIGHT].pos[0];
|
||||
var_f2 = player->tyres[BACK_RIGHT].pos.x;
|
||||
var_f12 = player->tyres[BACK_RIGHT].baseHeight + 2.0f;
|
||||
var_f14 = player->tyres[BACK_RIGHT].pos[2];
|
||||
var_f14 = player->tyres[BACK_RIGHT].pos.z;
|
||||
var_t1 = 0;
|
||||
var_t0 = 0;
|
||||
}
|
||||
@@ -3175,16 +3175,16 @@ void func_8005ED48(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
surfaceType = 0x000000FF;
|
||||
temp_v0 = random_int(test);
|
||||
if ((temp_v0 == 2) || (temp_v0 == 4)) {
|
||||
var_f0 = player->tyres[BACK_LEFT].pos[0];
|
||||
var_f0 = player->tyres[BACK_LEFT].pos.x;
|
||||
var_f2 = player->tyres[BACK_LEFT].baseHeight + 2.0f;
|
||||
var_f12 = player->tyres[BACK_LEFT].pos[2];
|
||||
var_f12 = player->tyres[BACK_LEFT].pos.z;
|
||||
var_t3 = 1;
|
||||
surfaceType = player->tyres[BACK_LEFT].surfaceType;
|
||||
}
|
||||
if ((temp_v0 == 0) || (temp_v0 == 6)) {
|
||||
var_f0 = player->tyres[BACK_RIGHT].pos[0];
|
||||
var_f0 = player->tyres[BACK_RIGHT].pos.x;
|
||||
var_f2 = player->tyres[BACK_RIGHT].baseHeight + 2.0f;
|
||||
var_f12 = player->tyres[BACK_RIGHT].pos[2];
|
||||
var_f12 = player->tyres[BACK_RIGHT].pos.z;
|
||||
var_t3 = 0;
|
||||
surfaceType = player->tyres[BACK_RIGHT].surfaceType;
|
||||
}
|
||||
@@ -3376,15 +3376,15 @@ void func_8005F90C(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
|
||||
var_t1 = 0;
|
||||
if ((player->effects & 0x80) == 0x80) {
|
||||
var_f0 = player->pos[0];
|
||||
var_f2 = player->pos[1] - player->boundingBoxSize;
|
||||
var_f12 = player->pos[2];
|
||||
var_f0 = player->pos.x;
|
||||
var_f2 = player->pos.y - player->boundingBoxSize;
|
||||
var_f12 = player->pos.z;
|
||||
var_t1 = 1;
|
||||
surfaceType = player->tyres[BACK_LEFT].surfaceType;
|
||||
} else {
|
||||
var_f0 = player->pos[0];
|
||||
var_f2 = player->pos[1] - player->boundingBoxSize;
|
||||
var_f12 = player->pos[2];
|
||||
var_f0 = player->pos.x;
|
||||
var_f2 = player->pos.y - player->boundingBoxSize;
|
||||
var_f12 = player->pos.z;
|
||||
surfaceType = player->tyres[BACK_RIGHT].surfaceType;
|
||||
}
|
||||
|
||||
@@ -3572,15 +3572,15 @@ void func_80060504(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
temp_v0 = random_int(var_v0);
|
||||
if ((temp_v0 == 1) || (temp_v0 == 2) || (temp_v0 == 3)) {
|
||||
if ((arg1 == 0) && ((player->unk_258[arg2].unk_01E > 0) || (player->unk_258[arg2].unk_01C == 0))) {
|
||||
sp4C = player->pos[1] - 2.5;
|
||||
sp48 = player->pos[2];
|
||||
sp50 = player->pos[0];
|
||||
sp4C = player->pos.y - 2.5;
|
||||
sp48 = player->pos.z;
|
||||
sp50 = player->pos.x;
|
||||
func_8005D794(player, &player->unk_258[arg1], sp50, sp4C, sp48, 0, 0);
|
||||
func_8005D7D8(&player->unk_258[arg1], 1, 0.5f);
|
||||
} else if (player->unk_258[arg2].unk_01E > 0) {
|
||||
sp4C = player->pos[1] - 2.5;
|
||||
sp48 = player->pos[2];
|
||||
sp50 = player->pos[0];
|
||||
sp4C = player->pos.y - 2.5;
|
||||
sp48 = player->pos.z;
|
||||
sp50 = player->pos.x;
|
||||
func_8005D794(player, &player->unk_258[arg1], sp50, sp4C, sp48, 0, 0);
|
||||
func_8005D7D8(&player->unk_258[arg1], 1, 0.5f);
|
||||
}
|
||||
@@ -3613,9 +3613,9 @@ void func_80060504(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
}
|
||||
func_80062B18(&sp50, &sp4C, &sp48, 0.0f, 4.5f, (player->unk_258[arg1].unk_01E * var_f0) + -5.5, -thing2,
|
||||
-player->unk_206 * 2);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos[0] + sp50;
|
||||
sp4C = sp4C + (player->pos[1] - player->boundingBoxSize);
|
||||
player->unk_258[arg1].unk_000[2] = player->pos[2] + sp48;
|
||||
player->unk_258[arg1].unk_000[0] = player->pos.x + sp50;
|
||||
sp4C = sp4C + (player->pos.y - player->boundingBoxSize);
|
||||
player->unk_258[arg1].unk_000[2] = player->pos.z + sp48;
|
||||
player->unk_258[arg1].unk_000[1] = player->unk_258[arg1].unk_024 + sp4C;
|
||||
player->unk_258[arg1].unk_010 = 0;
|
||||
}
|
||||
@@ -3626,14 +3626,14 @@ void func_800608E0(Player* player, s16 arg1, UNUSED s32 arg2, s8 arg3, UNUSED s8
|
||||
f32 sp4C;
|
||||
f32 sp48;
|
||||
|
||||
var_f0 = 8.0f - (D_801652A0[arg3] - player->pos[1]);
|
||||
var_f0 = 8.0f - (D_801652A0[arg3] - player->pos.y);
|
||||
if ((f64) var_f0 <= 0.0) {
|
||||
var_f0 = 0.0f;
|
||||
}
|
||||
sp4C = (D_801652A0[arg3] - player->pos[1]) - 3.0f;
|
||||
sp4C = (D_801652A0[arg3] - player->pos.y) - 3.0f;
|
||||
if ((player->unk_0DE & 1) && (GetCourse() != GetKoopaTroopaBeach())) {
|
||||
var_f0 = 2.5f;
|
||||
sp4C = (f32) ((f64) (D_801652A0[arg3] - player->pos[1]) + 0.1);
|
||||
sp4C = (f32) ((f64) (D_801652A0[arg3] - player->pos.y) + 0.1);
|
||||
}
|
||||
func_8005D794(player, &player->unk_258[arg1], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
|
||||
func_8005D7D8(&player->unk_258[arg1], 3, var_f0);
|
||||
@@ -3645,9 +3645,9 @@ void func_800608E0(Player* player, s16 arg1, UNUSED s32 arg2, s8 arg3, UNUSED s8
|
||||
func_80062B18(&sp50, &sp4C, &sp48, 0.0f, sp4C,
|
||||
((-player->unk_258[arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 10.0f) + -4.0f,
|
||||
-player->unk_258[arg1].unk_020, -player->unk_206 * 2);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos[0] + sp50;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos[2] + sp48;
|
||||
player->unk_258[arg1].unk_000[1] = player->pos[1] + sp4C;
|
||||
player->unk_258[arg1].unk_000[0] = player->pos.x + sp50;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos.z + sp48;
|
||||
player->unk_258[arg1].unk_000[1] = player->pos.y + sp4C;
|
||||
}
|
||||
|
||||
void func_80060B14(Player* player, s16 arg1, s32 arg2, s8 arg3, s8 arg4) {
|
||||
@@ -3684,18 +3684,18 @@ void func_80060BCC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
func_8005D794(player, &player->unk_258[arg1 + 10], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
|
||||
func_8005D7D8(&player->unk_258[arg1 + 10], 0x0B, 0.4f);
|
||||
func_8005D800(&player->unk_258[arg1 + 10], 0x00FFFFFF, 0x00FF);
|
||||
player->unk_258[arg1 + 10].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[arg1 + 10].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[arg1 + 10].unk_018 = sp44 + 1.0f;
|
||||
player->unk_258[arg1 + 10].unk_00C = (sp48 + 2.0f) / 10.0f;
|
||||
} else if (player->unk_258[arg2 + 10].unk_01E > 0) {
|
||||
func_8005D794(player, &player->unk_258[arg1 + 10], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
|
||||
func_8005D7D8(&player->unk_258[arg1 + 10], 0x0B, 0.4f);
|
||||
func_8005D800(&player->unk_258[arg1 + 10], 0x00FFFFFF, 0x00FF);
|
||||
player->unk_258[arg1 + 10].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[arg1 + 10].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -1.8);
|
||||
player->unk_258[arg1 + 10].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[arg1 + 10].unk_018 = sp44 + 1.0f;
|
||||
player->unk_258[arg1 + 10].unk_00C = (sp48 + 2.0f) / 10.0f;
|
||||
}
|
||||
@@ -3711,8 +3711,8 @@ void func_80060F50(Player* player, s16 arg1, UNUSED s32 arg2, s8 arg3, UNUSED s8
|
||||
func_8005D800(&player->unk_258[arg1], 0xFFFFFF, 0xFF);
|
||||
}
|
||||
|
||||
player->unk_258[arg1].unk_000[2] = player->pos[2] + (coss(player->unk_258[arg1].unk_020) * -5.8);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos[0] + (sins(player->unk_258[arg1].unk_020) * -5.8);
|
||||
player->unk_258[arg1].unk_000[2] = player->pos.z + (coss(player->unk_258[arg1].unk_020) * -5.8);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos.x + (sins(player->unk_258[arg1].unk_020) * -5.8);
|
||||
player->unk_258[arg1].unk_000[1] = D_801652A0[arg3];
|
||||
player->unk_0DE &= ~0x0008;
|
||||
}
|
||||
@@ -3733,9 +3733,9 @@ void func_80061130(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
|
||||
func_8005D7D8(&player->unk_258[arg1], 7, 0.6f);
|
||||
func_8005D800(&player->unk_258[arg1], 0xFFFFFF, 0xD0);
|
||||
|
||||
player->unk_258[arg1].unk_000[2] = player->pos[2] + (coss(player->unk_258[arg1].unk_020) * 6.0f);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos[0] + (sins(player->unk_258[arg1].unk_020) * 6.0f);
|
||||
player->unk_258[arg1].unk_000[1] = player->pos[1] - 5.0f;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos.z + (coss(player->unk_258[arg1].unk_020) * 6.0f);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos.x + (sins(player->unk_258[arg1].unk_020) * 6.0f);
|
||||
player->unk_258[arg1].unk_000[1] = player->pos.y - 5.0f;
|
||||
player->unk_258[arg1].unk_040 = 0;
|
||||
player->unk_258[arg1].unk_024 = 0.0f;
|
||||
}
|
||||
@@ -3756,15 +3756,15 @@ void func_800612F8(Player* player, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s8 a
|
||||
|
||||
for (var_s2 = 0; var_s2 < 10; var_s2++) {
|
||||
player->unk_258[0x1E + var_s2].unk_01C = 1;
|
||||
player->unk_258[0x1E + var_s2].unk_028 = player->pos[1] + 5.0f;
|
||||
player->unk_258[0x1E + var_s2].unk_028 = player->pos.y + 5.0f;
|
||||
player->unk_258[0x1E + var_s2].unk_020 = (0x1C70 * var_s2) - player->rotation[1];
|
||||
player->unk_258[0x1E + var_s2].unk_024 = (random_int(0x0064U) / 100.0f) + 1.5;
|
||||
player->unk_258[0x1E + var_s2].unk_03A = 0;
|
||||
player->unk_258[0x1E + var_s2].unk_012 = 1;
|
||||
player->unk_258[0x1E + var_s2].unk_01E = 0;
|
||||
player->unk_258[0x1E + var_s2].unk_03E = 0x00FF;
|
||||
player->unk_258[0x1E + var_s2].unk_000[2] = player->pos[2];
|
||||
player->unk_258[0x1E + var_s2].unk_000[0] = player->pos[0];
|
||||
player->unk_258[0x1E + var_s2].unk_000[2] = player->pos.z;
|
||||
player->unk_258[0x1E + var_s2].unk_000[0] = player->pos.x;
|
||||
}
|
||||
player->unk_046 &= ~0x0008;
|
||||
}
|
||||
@@ -3774,7 +3774,7 @@ void func_80061430(Player* player, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s8 a
|
||||
|
||||
for (var_s2 = 0; var_s2 < 7; var_s2++) {
|
||||
player->unk_258[0x1E + var_s2].unk_01C = 1;
|
||||
player->unk_258[0x1E + var_s2].unk_028 = player->pos[1] - 4.0f;
|
||||
player->unk_258[0x1E + var_s2].unk_028 = player->pos.y - 4.0f;
|
||||
player->unk_258[0x1E + var_s2].unk_020 = (0x1C70 * var_s2) - player->rotation[1];
|
||||
// ???
|
||||
player->unk_258[0x1E + var_s2].unk_024 = (random_int(0x0064U) / 100.0f) + 1.9;
|
||||
@@ -3783,8 +3783,8 @@ void func_80061430(Player* player, UNUSED s32 arg1, UNUSED s32 arg2, UNUSED s8 a
|
||||
player->unk_258[0x1E + var_s2].unk_012 = 9;
|
||||
player->unk_258[0x1E + var_s2].unk_01E = 0;
|
||||
player->unk_258[0x1E + var_s2].unk_03E = 0x00FF;
|
||||
player->unk_258[0x1E + var_s2].unk_000[2] = player->pos[2];
|
||||
player->unk_258[0x1E + var_s2].unk_000[0] = player->pos[0];
|
||||
player->unk_258[0x1E + var_s2].unk_000[2] = player->pos.z;
|
||||
player->unk_258[0x1E + var_s2].unk_000[0] = player->pos.x;
|
||||
}
|
||||
player->unk_044 &= ~0x1000;
|
||||
}
|
||||
@@ -3798,14 +3798,14 @@ void func_800615AC(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
|
||||
|
||||
if (random_int(3U) == 2.0f) {
|
||||
player->unk_258[0x1E + arg1].unk_01C = 1;
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0];
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2];
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x;
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z;
|
||||
player->unk_258[0x1E + arg1].unk_020 = -player->rotation[1] + sp28[arg1];
|
||||
player->unk_258[0x1E + arg1].unk_018 = random_int(1U) + 2.0f;
|
||||
temp_f0 = random_int(4U);
|
||||
temp_f0 -= test;
|
||||
player->unk_258[0x1E + arg1].unk_014 = temp_f0;
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = player->pos[1] + temp_f0;
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = player->pos.y + temp_f0;
|
||||
player->unk_258[0x1E + arg1].unk_00C = 0.15f;
|
||||
player->unk_258[0x1E + arg1].unk_012 = 5;
|
||||
player->unk_258[0x1E + arg1].unk_01E = 0;
|
||||
@@ -3840,9 +3840,9 @@ void func_80061754(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3, U
|
||||
player->unk_258[0x1E + arg1].unk_03A += temp_s1;
|
||||
player->unk_258[0x1E + arg1].unk_03C += temp_s1;
|
||||
}
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -5.0f);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -5.0f);
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -5.0f);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -5.0f);
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_018 = sp44 + 1.0f;
|
||||
player->unk_258[0x1E + arg1].unk_00C = sp48 + 1.0f;
|
||||
}
|
||||
@@ -3870,17 +3870,17 @@ void func_80061A34(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
func_8005D794(player, &player->unk_258[0x1E + arg1], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
|
||||
func_8005D7D8(&player->unk_258[0x1E + arg1], 7, 1.0f);
|
||||
func_8005D800(&player->unk_258[0x1E + arg1], 0x00FFFFFF, 0x00FF);
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp4C + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_00C = (sp48 + 2.0f) / 10.0f;
|
||||
} else if (player->unk_258[0x1E + arg2].unk_01E > 0) {
|
||||
func_8005D794(player, &player->unk_258[0x1E + arg1], 0.0f, 0.0f, 0.0f, (s8) 0, (s8) 0);
|
||||
func_8005D7D8(&player->unk_258[0x1E + arg1], 7, 1.0f);
|
||||
func_8005D800(&player->unk_258[0x1E + arg1], 0x00FFFFFF, 0x00FF);
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2] + (coss(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0] + (sins(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + (f32) sp4C + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z + (coss(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x + (sins(sp54 * 0xB6) * -2.0);
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + (f32) sp4C + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_00C = (sp48 + 2.0f) / 10.0f;
|
||||
}
|
||||
}
|
||||
@@ -3894,9 +3894,9 @@ void func_80061D4C(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s8 arg3, UN
|
||||
|
||||
if (random_int(3U) == 2.0f) {
|
||||
player->unk_258[0x1E + arg1].unk_01C = 1;
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos[0];
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = player->pos[1] + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos[2];
|
||||
player->unk_258[0x1E + arg1].unk_000[0] = player->pos.x;
|
||||
player->unk_258[0x1E + arg1].unk_000[1] = player->pos.y + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_000[2] = player->pos.z;
|
||||
player->unk_258[0x1E + arg1].unk_020 = -player->rotation[1] + sp20[arg1];
|
||||
player->unk_258[0x1E + arg1].unk_018 = random_int(3U) + 2.0f;
|
||||
player->unk_258[0x1E + arg1].unk_014 = random_int(4U);
|
||||
@@ -3921,12 +3921,12 @@ void func_80061EF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
if (temp_v1 == 1) {
|
||||
var_t1 = 1;
|
||||
var_t0 = 0;
|
||||
var_f2 = player->pos[1];
|
||||
var_f2 = player->pos.y;
|
||||
}
|
||||
if (temp_v1 == 0) {
|
||||
var_t1 = 0;
|
||||
var_t0 = 0;
|
||||
var_f2 = player->pos[1];
|
||||
var_f2 = player->pos.y;
|
||||
}
|
||||
if (var_t0 == 0) {
|
||||
if ((arg1 == 0) &&
|
||||
@@ -3941,10 +3941,10 @@ void func_80061EF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
player->unk_258[0x1E + arg1].unk_020 -= 0x888;
|
||||
}
|
||||
player->unk_258[0x1E + arg1].unk_000[2] =
|
||||
player->pos[2] +
|
||||
player->pos.z +
|
||||
(coss(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] =
|
||||
player->pos[0] +
|
||||
player->pos.x +
|
||||
(sins(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
} else if (player->unk_258[0x1E + arg2].unk_01E > 0) {
|
||||
func_8005D794(player, &player->unk_258[0x1E + arg1], 0.0f, var_f2, 0.0f, (s8) var_t0, (s8) var_t1);
|
||||
@@ -3957,10 +3957,10 @@ void func_80061EF4(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
player->unk_258[0x1E + arg1].unk_020 -= 0x888;
|
||||
}
|
||||
player->unk_258[0x1E + arg1].unk_000[2] =
|
||||
player->pos[2] +
|
||||
player->pos.z +
|
||||
(coss(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
player->unk_258[0x1E + arg1].unk_000[0] =
|
||||
player->pos[0] +
|
||||
player->pos.x +
|
||||
(sins(player->unk_258[0x1E + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
}
|
||||
}
|
||||
@@ -3979,7 +3979,7 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
if (temp_v1 == 1) {
|
||||
phi_t1 = 1;
|
||||
phi_t0 = 0;
|
||||
phi_f2 = player->pos[1];
|
||||
phi_f2 = player->pos.y;
|
||||
}
|
||||
|
||||
if (temp_v1 == 0) {
|
||||
@@ -3987,7 +3987,7 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
if (1) {
|
||||
phi_t0 = 0;
|
||||
}
|
||||
phi_f2 = player->pos[1];
|
||||
phi_f2 = player->pos.y;
|
||||
}
|
||||
|
||||
if (phi_t0 == 0) {
|
||||
@@ -4004,10 +4004,10 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
}
|
||||
|
||||
player->unk_258[30 + arg1].unk_000[2] =
|
||||
player->pos[2] +
|
||||
player->pos.z +
|
||||
(coss((player->unk_258[30 + arg1].unk_020 - player->rotation[1]) - player->unk_0C0) * 5.0f);
|
||||
player->unk_258[30 + arg1].unk_000[0] =
|
||||
player->pos[0] +
|
||||
player->pos.x +
|
||||
(sins((player->unk_258[30 + arg1].unk_020 - player->rotation[1]) - player->unk_0C0) * 5.0f);
|
||||
return;
|
||||
}
|
||||
@@ -4026,10 +4026,10 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
|
||||
new_var = new_var2;
|
||||
new_var->unk_258[30 + arg1].unk_000[2] =
|
||||
new_var->pos[2] +
|
||||
new_var->pos.z +
|
||||
(coss((new_var->unk_258[30 + arg1].unk_020 - new_var->rotation[1]) - new_var->unk_0C0) * 5.0f);
|
||||
new_var->unk_258[30 + arg1].unk_000[0] =
|
||||
new_var->pos[0] +
|
||||
new_var->pos.x +
|
||||
(sins((new_var->unk_258[30 + arg1].unk_020 - new_var->rotation[1]) - new_var->unk_0C0) * 5.0f);
|
||||
}
|
||||
}
|
||||
@@ -4038,8 +4038,8 @@ void func_800621BC(Player* player, s16 arg1, s32 arg2, UNUSED s8 arg3, UNUSED s8
|
||||
void func_80062484(Player* player, UnkPlayerStruct258* arg1, s32 arg2) {
|
||||
arg1->unk_01C = 1;
|
||||
arg1->unk_000[1] = player->unk_074 + 1.0f;
|
||||
arg1->unk_000[2] = player->pos[2];
|
||||
arg1->unk_000[0] = player->pos[0];
|
||||
arg1->unk_000[2] = player->pos.z;
|
||||
arg1->unk_000[0] = player->pos.x;
|
||||
arg1->unk_020 = (arg2 * 0x1998) - player->rotation[1];
|
||||
arg1->unk_012 = 4;
|
||||
arg1->unk_01E = 0;
|
||||
@@ -4175,9 +4175,9 @@ void func_80062A18(Player* player, s8 arg1, UNUSED s8 arg2, s8 arg3) {
|
||||
player->unk_258[20 + arg3].unk_01E = 1;
|
||||
player->unk_258[20 + arg3].unk_020 = 0;
|
||||
player->unk_0B6 &= ~0x0080;
|
||||
player->unk_258[20 + arg3].unk_000[2] = player->pos[2];
|
||||
player->unk_258[20 + arg3].unk_000[0] = player->pos[0];
|
||||
player->unk_258[20 + arg3].unk_000[1] = (player->pos[1] + 4.0f);
|
||||
player->unk_258[20 + arg3].unk_000[2] = player->pos.z;
|
||||
player->unk_258[20 + arg3].unk_000[0] = player->pos.x;
|
||||
player->unk_258[20 + arg3].unk_000[1] = (player->pos.y + 4.0f);
|
||||
}
|
||||
|
||||
void func_80062AA8(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
|
||||
@@ -4185,43 +4185,30 @@ void func_80062AA8(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
|
||||
player->unk_258[20 + arg3].unk_012 = 5;
|
||||
player->unk_258[20 + arg3].unk_00C = 0.1f;
|
||||
player->unk_258[20 + arg3].unk_01E = 0;
|
||||
player->unk_258[20 + arg3].unk_000[1] = (player->pos[1] + player->boundingBoxSize) - 2.5;
|
||||
player->unk_258[20 + arg3].unk_000[1] = (player->pos.y + player->boundingBoxSize) - 2.5;
|
||||
}
|
||||
|
||||
void func_80062B18(f32* arg0, f32* arg1, f32* arg2, f32 arg3, f32 arg4, f32 arg5, u16 arg6, u16 arg7) {
|
||||
UNUSED f32 pad;
|
||||
f32 sp30;
|
||||
f32 sp2C;
|
||||
f32 sp28;
|
||||
f32 temp_f20;
|
||||
void func_80062B18(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY, f32 inZ, u16 theta, u16 phi) {
|
||||
FrameInterpolation_RecordMatrixMultKart(outX, outY, outZ, inX, inY, inZ, theta, phi);
|
||||
f32 sinTheta = sins(theta);
|
||||
f32 cosTheta = coss(theta);
|
||||
f32 sinPhi = sins(phi);
|
||||
f32 cosPhi = coss(phi);
|
||||
|
||||
// Apply the matrix multiplication:
|
||||
// Matrix is the Jacobian for cartesian to spherical coordinates?
|
||||
// Get the change in r, theta, and phi for a change in x, y, z?
|
||||
//
|
||||
// | arg0 | | cos(arg6)*cos(arg7) cos(arg6)*sin(arg7) -sin(arg6) | | arg3 |
|
||||
// | | | | | |
|
||||
// | arg1 | = | -sin(arg7) cos(arg7) 0 | X | arg4 |
|
||||
// | | | | | |
|
||||
// | arg2 | | sin(arg6)*cos(arg7) sin(arg6)*sin(arg7) cos(arg6) | | arg5 |
|
||||
//
|
||||
sp28 = sins(arg7);
|
||||
sp2C = coss(arg6);
|
||||
sp30 = coss(arg7);
|
||||
temp_f20 = coss(arg6);
|
||||
// = arg3 * cos(arg6) * cos(arg7) + arg4 * cos(arg6) * sin(arg7) - arg5 * sin(arg6)
|
||||
*arg0 = (((arg3 * temp_f20) * sp30) + (arg4 * sp2C) * sp28) - (sins(arg6) * arg5);
|
||||
// Project onto spherical basis vectors:
|
||||
// outX corresponds to radial component
|
||||
*outX = (inX * cosTheta * cosPhi) +
|
||||
(inY * cosTheta * sinPhi) -
|
||||
(inZ * sinTheta);
|
||||
|
||||
temp_f20 = sins(arg7);
|
||||
// = -arg3 * sin(arg7) + arg4 * cos(arg7)
|
||||
*arg1 = (coss(arg7) * arg4) - (arg3 * temp_f20);
|
||||
// outY corresponds to azimuthal component
|
||||
*outY = (-inX * sinPhi) +
|
||||
(inY * cosPhi);
|
||||
|
||||
sp28 = sins(arg7);
|
||||
sp2C = sins(arg6);
|
||||
sp30 = coss(arg7);
|
||||
temp_f20 = sins(arg6);
|
||||
// = arg3 * sin(arg6) * cos(arg7) + arg4 * sin(arg6) * sin(arg7) + arg5 * cos(arg6)
|
||||
*arg2 = (coss(arg6) * arg5) + (((arg3 * temp_f20) * sp30) + ((arg4 * sp2C) * sp28));
|
||||
// outZ corresponds to polar (vertical) component
|
||||
*outZ = (inX * sinTheta * cosPhi) +
|
||||
(inY * sinTheta * sinPhi) +
|
||||
(inZ * cosTheta);
|
||||
}
|
||||
|
||||
void func_80062C74(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3) {
|
||||
@@ -4273,9 +4260,9 @@ void func_80062C74(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3) {
|
||||
}
|
||||
func_80062B18(&sp40, &sp38, &sp3C, 0.0f, sp48[player->characterId], (player->unk_258[arg1].unk_01E * var_f6) + -5.5,
|
||||
-thing, -player->unk_206 * 2);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos[0] + sp40;
|
||||
sp38 = (player->pos[1] - player->boundingBoxSize) + sp38;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos[2] + sp3C;
|
||||
player->unk_258[arg1].unk_000[0] = player->pos.x + sp40;
|
||||
sp38 = (player->pos.y - player->boundingBoxSize) + sp38;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos.z + sp3C;
|
||||
player->unk_258[arg1].unk_000[1] = player->unk_258[arg1].unk_024 + sp38;
|
||||
}
|
||||
|
||||
@@ -4303,8 +4290,8 @@ void func_80062F98(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
|
||||
|
||||
void func_800630C0(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
|
||||
++player->unk_258[arg1].unk_01E;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos[2] + coss(player->unk_258[arg1].unk_020) * -5.8;
|
||||
player->unk_258[arg1].unk_000[0] = player->pos[0] + sins(player->unk_258[arg1].unk_020) * -5.8;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos.z + coss(player->unk_258[arg1].unk_020) * -5.8;
|
||||
player->unk_258[arg1].unk_000[0] = player->pos.x + sins(player->unk_258[arg1].unk_020) * -5.8;
|
||||
player->unk_258[arg1].unk_000[1] = D_801652A0[arg2];
|
||||
if (player->unk_258[arg1].unk_01E == 15) {
|
||||
player->unk_258[arg1].unk_01C = 0;
|
||||
@@ -4347,10 +4334,10 @@ void func_80063268(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
|
||||
player->unk_258[arg1].unk_024 += 0.25;
|
||||
player->unk_258[arg1].unk_000[2] =
|
||||
player->pos[2] + (coss((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
|
||||
player->pos.z + (coss((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
|
||||
player->unk_258[arg1].unk_000[0] =
|
||||
player->pos[0] + (sins((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
|
||||
player->unk_258[arg1].unk_000[1] = ((player->pos[1] - 5.0f) + player->unk_258[arg1].unk_024);
|
||||
player->pos.x + (sins((player->unk_258[arg1].unk_020 + player->unk_258[arg1].unk_040)) * 5.5);
|
||||
player->unk_258[arg1].unk_000[1] = ((player->pos.y - 5.0f) + player->unk_258[arg1].unk_024);
|
||||
++player->unk_258[arg1].unk_01E;
|
||||
player->unk_258[arg1].unk_00C += 0.05;
|
||||
player->unk_258[arg1].unk_03E -= 5;
|
||||
@@ -4369,17 +4356,17 @@ void func_80063268(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
void func_80063408(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
if (player->unk_258[10 + arg1].unk_010 == 1) {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_LEFT].pos[2] +
|
||||
player->tyres[BACK_LEFT].pos.z +
|
||||
(player->unk_258[10 + arg1].unk_01E * -7) * coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_LEFT].pos[0] +
|
||||
player->tyres[BACK_LEFT].pos.x +
|
||||
(player->unk_258[10 + arg1].unk_01E * -7) * sins(player->unk_258[10 + arg1].unk_020);
|
||||
} else {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_RIGHT].pos[2] +
|
||||
player->tyres[BACK_RIGHT].pos.z +
|
||||
(player->unk_258[10 + arg1].unk_01E * -7) * coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_RIGHT].pos[0] +
|
||||
player->tyres[BACK_RIGHT].pos.x +
|
||||
(player->unk_258[10 + arg1].unk_01E * -7) * sins(player->unk_258[10 + arg1].unk_020);
|
||||
}
|
||||
|
||||
@@ -4417,15 +4404,15 @@ void func_800635D4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
func_80062B18(&sp44, &sp40, &sp3C, -2.0f, 0.0f,
|
||||
(-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16,
|
||||
-player->unk_258[10 + arg1].unk_020, 2 * -player->unk_206);
|
||||
player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_LEFT].pos[0] + sp44;
|
||||
player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_LEFT].pos[2] + sp3C;
|
||||
player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_LEFT].pos.x + sp44;
|
||||
player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_LEFT].pos.z + sp3C;
|
||||
} else {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_LEFT].pos[2] +
|
||||
player->tyres[BACK_LEFT].pos.z +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
|
||||
coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_LEFT].pos[0] +
|
||||
player->tyres[BACK_LEFT].pos.x +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
|
||||
sins(player->unk_258[10 + arg1].unk_020);
|
||||
}
|
||||
@@ -4433,15 +4420,15 @@ void func_800635D4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
func_80062B18(&sp44, &sp40, &sp3C, 2.0f, 0.0f,
|
||||
(-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16,
|
||||
-player->unk_258[10 + arg1].unk_020, 2 * -player->unk_206);
|
||||
player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_RIGHT].pos[0] + sp44;
|
||||
player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_RIGHT].pos[2] + sp3C;
|
||||
player->unk_258[10 + arg1].unk_000[0] = player->tyres[BACK_RIGHT].pos.x + sp44;
|
||||
player->unk_258[10 + arg1].unk_000[2] = player->tyres[BACK_RIGHT].pos.z + sp3C;
|
||||
} else {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_RIGHT].pos[2] +
|
||||
player->tyres[BACK_RIGHT].pos.z +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
|
||||
coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_RIGHT].pos[0] +
|
||||
player->tyres[BACK_RIGHT].pos.x +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 16) *
|
||||
sins(player->unk_258[10 + arg1].unk_020);
|
||||
}
|
||||
@@ -4480,17 +4467,17 @@ void func_800635D4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
void func_800639DC(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
if (player->unk_258[10 + arg1].unk_010 == 1) {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_LEFT].pos[2] +
|
||||
player->tyres[BACK_LEFT].pos.z +
|
||||
(-1.8f * player->unk_258[10 + arg1].unk_01E) * coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_LEFT].pos[0] +
|
||||
player->tyres[BACK_LEFT].pos.x +
|
||||
(-1.8f * player->unk_258[10 + arg1].unk_01E) * sins(player->unk_258[10 + arg1].unk_020);
|
||||
} else {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_RIGHT].pos[2] +
|
||||
player->tyres[BACK_RIGHT].pos.z +
|
||||
(-1.8f * player->unk_258[10 + arg1].unk_01E) * coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_RIGHT].pos[0] +
|
||||
player->tyres[BACK_RIGHT].pos.x +
|
||||
(-1.8f * player->unk_258[10 + arg1].unk_01E) * sins(player->unk_258[10 + arg1].unk_020);
|
||||
}
|
||||
++player->unk_258[10 + arg1].unk_01E;
|
||||
@@ -4523,17 +4510,17 @@ void func_800639DC(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
void func_80063BD4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
if (player->unk_258[10 + arg1].unk_010 == 1) {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_LEFT].pos[2] +
|
||||
player->tyres[BACK_LEFT].pos.z +
|
||||
(-2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_LEFT].pos[0] +
|
||||
player->tyres[BACK_LEFT].pos.x +
|
||||
(-2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
|
||||
} else {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_RIGHT].pos[2] +
|
||||
player->tyres[BACK_RIGHT].pos.z +
|
||||
(-2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_RIGHT].pos[0] +
|
||||
player->tyres[BACK_RIGHT].pos.x +
|
||||
(-2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
|
||||
}
|
||||
|
||||
@@ -4552,20 +4539,20 @@ void func_80063BD4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
void func_80063D58(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
if (player->unk_258[10 + arg1].unk_010 == 1) {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_LEFT].pos[2] +
|
||||
player->tyres[BACK_LEFT].pos.z +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
|
||||
coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_LEFT].pos[0] +
|
||||
player->tyres[BACK_LEFT].pos.x +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
|
||||
sins(player->unk_258[10 + arg1].unk_020);
|
||||
} else {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->tyres[BACK_RIGHT].pos[2] +
|
||||
player->tyres[BACK_RIGHT].pos.z +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
|
||||
coss(player->unk_258[10 + arg1].unk_020);
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->tyres[BACK_RIGHT].pos[0] +
|
||||
player->tyres[BACK_RIGHT].pos.x +
|
||||
((-player->unk_258[10 + arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 20.0f) *
|
||||
sins(player->unk_258[10 + arg1].unk_020);
|
||||
}
|
||||
@@ -4604,9 +4591,9 @@ void func_80063FBC(Player* player, s16 arg1, UNUSED s32 arg2, UNUSED s32 arg3) {
|
||||
-5.5 - (player->unk_258[10 + arg1].unk_01E * (((player->unk_094 / 18.0f) * 216.0f) / 15.0f)),
|
||||
-player->unk_258[10 + arg1].unk_020, 0);
|
||||
}
|
||||
player->unk_258[10 + arg1].unk_000[0] = player->pos[0] + sp3C;
|
||||
player->unk_258[10 + arg1].unk_000[2] = player->pos[2] + sp38;
|
||||
player->unk_258[10 + arg1].unk_000[1] = (player->pos[1] - player->boundingBoxSize) + sp34;
|
||||
player->unk_258[10 + arg1].unk_000[0] = player->pos.x + sp3C;
|
||||
player->unk_258[10 + arg1].unk_000[2] = player->pos.z + sp38;
|
||||
player->unk_258[10 + arg1].unk_000[1] = (player->pos.y - player->boundingBoxSize) + sp34;
|
||||
player->unk_258[10 + arg1].unk_01E++;
|
||||
if (player->unk_258[10 + arg1].unk_01E == 6) {
|
||||
player->unk_258[10 + arg1].unk_01C = 0;
|
||||
@@ -4620,19 +4607,19 @@ void func_80064184(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
|
||||
f32 sp40;
|
||||
f32 sp3C;
|
||||
|
||||
sp40 = D_801652A0[arg2] - player->pos[1] - 3.0f;
|
||||
sp40 = D_801652A0[arg2] - player->pos.y - 3.0f;
|
||||
if (((player->unk_0DE & 1) != 0) && (GetCourse() != GetKoopaTroopaBeach())) {
|
||||
sp40 = D_801652A0[arg2] - player->pos[1] + 0.1;
|
||||
sp40 = D_801652A0[arg2] - player->pos.y + 0.1;
|
||||
}
|
||||
|
||||
func_80062B18(&sp44, &sp40, &sp3C, 0.0f, sp40,
|
||||
-4.0f + ((-player->unk_258[arg1].unk_01E * (player->unk_094 / 18.0f) * 216.0f) / 10.0f),
|
||||
-player->unk_258[arg1].unk_020, 2 * -player->unk_206);
|
||||
player->unk_258[arg1].unk_000[0] = player->pos[0] + sp44;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos[2] + sp3C;
|
||||
player->unk_258[arg1].unk_000[1] = player->pos[1] + sp40;
|
||||
player->unk_258[arg1].unk_000[0] = player->pos.x + sp44;
|
||||
player->unk_258[arg1].unk_000[2] = player->pos.z + sp3C;
|
||||
player->unk_258[arg1].unk_000[1] = player->pos.y + sp40;
|
||||
++player->unk_258[arg1].unk_01E;
|
||||
if ((player->unk_258[arg1].unk_01E == 12) || (D_801652A0[arg2] <= (player->pos[1] - player->boundingBoxSize))) {
|
||||
if ((player->unk_258[arg1].unk_01E == 12) || (D_801652A0[arg2] <= (player->pos.y - player->boundingBoxSize))) {
|
||||
player->unk_258[arg1].unk_01C = 0;
|
||||
player->unk_258[arg1].unk_01E = 0;
|
||||
player->unk_258[arg1].unk_012 = 0;
|
||||
@@ -4651,9 +4638,9 @@ void func_80064184(Player* player, s16 arg1, s8 arg2, UNUSED s8 arg3) {
|
||||
|
||||
void func_800643A8(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
player->unk_258[10 + arg1].unk_000[2] =
|
||||
player->pos[2] + (-1.2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
|
||||
player->pos.z + (-1.2 * player->unk_258[10 + arg1].unk_01E * coss(player->unk_258[10 + arg1].unk_020));
|
||||
player->unk_258[10 + arg1].unk_000[0] =
|
||||
player->pos[0] + (-1.2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
|
||||
player->pos.x + (-1.2 * player->unk_258[10 + arg1].unk_01E * sins(player->unk_258[10 + arg1].unk_020));
|
||||
player->unk_258[10 + arg1].unk_000[1] = player->unk_258[10 + arg1].unk_000[1] + 0.5;
|
||||
|
||||
++player->unk_258[10 + arg1].unk_01E;
|
||||
@@ -4682,9 +4669,9 @@ void func_800644E8(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
thing2 = player->unk_258[30 + arg1].unk_024;
|
||||
thing = player->unk_258[30 + arg1].unk_01E;
|
||||
player->unk_258[30 + arg1].unk_000[2] =
|
||||
player->pos[2] + (coss(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
|
||||
player->pos.z + (coss(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
|
||||
player->unk_258[30 + arg1].unk_000[0] =
|
||||
player->pos[0] + (sins(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
|
||||
player->pos.x + (sins(player->unk_258[30 + arg1].unk_020) * (-0.7 * thing));
|
||||
player->unk_258[30 + arg1].unk_01E++;
|
||||
player->unk_258[30 + arg1].unk_000[1] =
|
||||
player->unk_258[30 + arg1].unk_028 + (f32) ((thing * thing2) - (0.2 * (thing * thing)));
|
||||
@@ -4710,9 +4697,9 @@ void func_80064664(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
temp_v1 = player->unk_258[30 + arg1].unk_01E;
|
||||
temp_f4 = player->unk_258[30 + arg1].unk_024;
|
||||
player->unk_258[30 + arg1].unk_000[2] =
|
||||
player->pos[2] + (coss(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
|
||||
player->pos.z + (coss(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
|
||||
player->unk_258[30 + arg1].unk_000[0] =
|
||||
player->pos[0] + (sins(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
|
||||
player->pos.x + (sins(player->unk_258[30 + arg1].unk_020) * (-0.6 * temp_v1));
|
||||
player->unk_258[30 + arg1].unk_01E++;
|
||||
player->unk_258[30 + arg1].unk_000[1] =
|
||||
player->unk_258[30 + arg1].unk_028 + (f32) ((temp_v1 * temp_f4) - (0.1 * (temp_v1 * temp_v1)));
|
||||
@@ -4733,9 +4720,9 @@ void func_800647C8(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
|
||||
++player->unk_258[30 + arg1].unk_01E;
|
||||
player->unk_258[30 + arg1].unk_000[2] =
|
||||
player->pos[2] + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * coss(player->unk_258[30 + arg1].unk_020));
|
||||
player->pos.z + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * coss(player->unk_258[30 + arg1].unk_020));
|
||||
player->unk_258[30 + arg1].unk_000[0] =
|
||||
player->pos[0] + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * sins(player->unk_258[30 + arg1].unk_020));
|
||||
player->pos.x + ((-0.8 * (player->unk_258[30 + arg1].unk_01E)) * sins(player->unk_258[30 + arg1].unk_020));
|
||||
player->unk_258[30 + arg1].unk_000[1] = (player->unk_074 + 2.0f);
|
||||
|
||||
if (player->unk_258[30 + arg1].unk_01E == 14) {
|
||||
@@ -4786,7 +4773,7 @@ void func_800649F4(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
player->unk_21C + (((-temp) * player->unk_258[30 + arg1].unk_01E) * coss(player->unk_258[30 + arg1].unk_020));
|
||||
player->unk_258[30 + arg1].unk_000[0] =
|
||||
player->unk_218 + (((-temp) * player->unk_258[30 + arg1].unk_01E) * sins(player->unk_258[30 + arg1].unk_020));
|
||||
player->unk_258[30 + arg1].unk_000[1] = player->pos[1] + player->unk_258[30 + arg1].unk_014;
|
||||
player->unk_258[30 + arg1].unk_000[1] = player->pos.y + player->unk_258[30 + arg1].unk_014;
|
||||
player->unk_258[30 + arg1].unk_00C += 0.04;
|
||||
|
||||
++player->unk_258[30 + arg1].unk_01E;
|
||||
@@ -4809,9 +4796,9 @@ void func_80064B30(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
temp = player->unk_258[30 + arg1].unk_018 * 1.2;
|
||||
|
||||
player->unk_258[30 + arg1].unk_000[2] =
|
||||
(player->pos[2] + (-temp * player->unk_258[30 + arg1].unk_01E) * (coss(player->unk_258[30 + arg1].unk_020)));
|
||||
(player->pos.z + (-temp * player->unk_258[30 + arg1].unk_01E) * (coss(player->unk_258[30 + arg1].unk_020)));
|
||||
player->unk_258[30 + arg1].unk_000[0] =
|
||||
(player->pos[0] + (-temp * player->unk_258[30 + arg1].unk_01E) * (sins(player->unk_258[30 + arg1].unk_020)));
|
||||
(player->pos.x + (-temp * player->unk_258[30 + arg1].unk_01E) * (sins(player->unk_258[30 + arg1].unk_020)));
|
||||
player->unk_258[30 + arg1].unk_000[1] += 0.1;
|
||||
|
||||
++player->unk_258[30 + arg1].unk_01E;
|
||||
@@ -4839,10 +4826,10 @@ void func_80064C74(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
}
|
||||
|
||||
player->unk_258[30 + arg1].unk_000[2] =
|
||||
player->pos[2] + (coss(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
player->pos.z + (coss(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
player->unk_258[30 + arg1].unk_000[0] =
|
||||
player->pos[0] + (sins(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
player->unk_258[30 + arg1].unk_000[1] = player->pos[1] - 1.0f;
|
||||
player->pos.x + (sins(player->unk_258[30 + arg1].unk_020 - player->rotation[1] - player->unk_0C0) * 5.0f);
|
||||
player->unk_258[30 + arg1].unk_000[1] = player->pos.y - 1.0f;
|
||||
player->unk_258[30 + arg1].unk_00C += 0.4;
|
||||
++player->unk_258[30 + arg1].unk_01E;
|
||||
|
||||
@@ -4861,7 +4848,7 @@ void func_80064C74(Player* player, s16 arg1, UNUSED s8 arg2, UNUSED s8 arg3) {
|
||||
|
||||
void func_80064DEC(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
|
||||
|
||||
player->unk_258[20 + arg3].unk_000[1] = player->pos[1];
|
||||
player->unk_258[20 + arg3].unk_000[1] = player->pos.y;
|
||||
++player->unk_258[20 + arg3].unk_01E;
|
||||
|
||||
if (player->unk_258[20 + arg3].unk_01E == 9) {
|
||||
@@ -4928,9 +4915,9 @@ void func_80065030(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
|
||||
}
|
||||
|
||||
void func_800650FC(Player* player, UNUSED s8 arg1, UNUSED s8 arg2, s8 arg3) {
|
||||
player->unk_258[20 + arg3].unk_000[2] = (f32) player->pos[2];
|
||||
player->unk_258[20 + arg3].unk_000[0] = (f32) player->pos[0];
|
||||
player->unk_258[20 + arg3].unk_000[1] = (f32) (player->pos[1] + 4.0f);
|
||||
player->unk_258[20 + arg3].unk_000[2] = (f32) player->pos.z;
|
||||
player->unk_258[20 + arg3].unk_000[0] = (f32) player->pos.x;
|
||||
player->unk_258[20 + arg3].unk_000[1] = (f32) (player->pos.y + 4.0f);
|
||||
if ((player->effects & 0x80) == 0x80) {
|
||||
player->unk_258[20 + arg3].unk_020 += 4732;
|
||||
} else {
|
||||
@@ -5327,14 +5314,14 @@ void func_80066BAC(Player* player, UNUSED s8 arg1, s16 arg2, s8 arg3) {
|
||||
if ((player->unk_258[arg2].unk_01C == 1) && (player->unk_258[arg2].unk_038 != 0x00FF)) {
|
||||
|
||||
if (player->collision.surfaceDistance[2] >= 300.0f) {
|
||||
spDC[1] = player->pos[1] + 5.0f;
|
||||
spDC[1] = player->pos.y + 5.0f;
|
||||
} else {
|
||||
spDC[1] = player->pos[1] - 3.0f;
|
||||
spDC[1] = player->pos.y - 3.0f;
|
||||
}
|
||||
spDC[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
spDC[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
spDC[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
spDC[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
if (player->collision.surfaceDistance[2] >= 300.0f) {
|
||||
spD4[0] = cameras[arg3].rot[0] - 0x4000;
|
||||
spD4[0] = cameras[arg3].rot.x - 0x4000;
|
||||
} else {
|
||||
spD4[0] = 0;
|
||||
}
|
||||
@@ -5492,9 +5479,9 @@ void func_80067D3C(Player* player, s8 arg1, u8* texture, s8 arg3, f32 arg4, s32
|
||||
sp74[0] = 0;
|
||||
sp74[1] = player->unk_048[arg1];
|
||||
sp74[2] = 0;
|
||||
sp7C[0] = player->pos[0] + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
sp7C[1] = player->pos[1] + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
|
||||
sp7C[2] = player->pos[2] + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
sp7C[0] = player->pos.x + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
sp7C[1] = player->pos.y + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
|
||||
sp7C[2] = player->pos.z + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
func_800652D4(sp7C, sp74, player->unk_258[20 + arg3].unk_00C * player->size);
|
||||
gSPDisplayList(gDisplayListHead++, D_0D008DB8);
|
||||
gDPLoadTextureBlock(gDisplayListHead++, texture, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
|
||||
@@ -5520,9 +5507,9 @@ void func_8006801C(Player* player, s8 arg1, u8* texture, s8 arg3, f32 arg4, s32
|
||||
sp74[0] = 0;
|
||||
sp74[1] = player->unk_048[arg1];
|
||||
sp74[2] = 0;
|
||||
sp7C[0] = player->pos[0] + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
sp7C[1] = player->pos[1] + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
|
||||
sp7C[2] = player->pos[2] + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
sp7C[0] = player->pos.x + (sins((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
sp7C[1] = player->pos.y + player->boundingBoxSize - sp54[player->characterId] - 2.0f;
|
||||
sp7C[2] = player->pos.z + (coss((0x4000 & 0xFFFFFFFF) - (player->rotation[1] + player->unk_0C0)) * arg4);
|
||||
func_800652D4(sp7C, sp74, player->unk_258[20 + arg3].unk_00C * player->size * 0.8);
|
||||
gSPDisplayList(gDisplayListHead++, D_0D008DB8);
|
||||
gDPLoadTextureBlock(gDisplayListHead++, texture, G_IM_FMT_I, G_IM_SIZ_8b, 32, 32, 0, G_TX_NOMIRROR | G_TX_WRAP,
|
||||
@@ -5541,8 +5528,8 @@ void func_80068310(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
|
||||
|
||||
if (player->unk_258[20 + arg4].unk_01C == 1) {
|
||||
sp9C[1] = player->unk_258[20 + arg4].unk_000[1];
|
||||
sp9C[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
sp9C[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
sp9C[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
sp9C[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
sp94[0] = 0;
|
||||
sp94[1] = player->unk_048[arg3];
|
||||
sp94[2] = 0;
|
||||
@@ -5570,9 +5557,9 @@ void func_80068724(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
|
||||
Vec3s sp7C;
|
||||
|
||||
if (player->unk_258[20 + arg4].unk_01C == 1) {
|
||||
sp84[1] = player->pos[1] - 3.0f;
|
||||
sp84[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
sp84[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
sp84[1] = player->pos.y - 3.0f;
|
||||
sp84[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
sp84[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
sp7C[0] = 0;
|
||||
sp7C[1] = player->unk_048[arg3];
|
||||
sp7C[2] = 0;
|
||||
@@ -5598,15 +5585,15 @@ void func_80068AA4(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
|
||||
Vec3f sp64;
|
||||
Vec3s sp5C;
|
||||
|
||||
sp64[1] = player->pos[1];
|
||||
sp64[2] = player->pos[2];
|
||||
sp64[0] = player->pos[0];
|
||||
sp64[1] = player->pos.y;
|
||||
sp64[2] = player->pos.z;
|
||||
sp64[0] = player->pos.x;
|
||||
|
||||
if ((player->unk_258[20 + arg4].unk_01C == 1) && (player->animFrameSelector[arg3] < 0xD)) {
|
||||
if (gTickVisuals) {
|
||||
sp64[1] = player->pos[1] - 3.0f;
|
||||
sp64[2] = player->pos[2] + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * coss(player->unk_048[arg3]));
|
||||
sp64[0] = player->pos[0] + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * sins(player->unk_048[arg3]));
|
||||
sp64[1] = player->pos.y - 3.0f;
|
||||
sp64[2] = player->pos.z + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * coss(player->unk_048[arg3]));
|
||||
sp64[0] = player->pos.x + ((-2.5 * player->unk_258[20 + arg4].unk_01E) * sins(player->unk_048[arg3]));
|
||||
}
|
||||
sp5C[0] = 0;
|
||||
sp5C[1] = player->unk_048[arg3];
|
||||
@@ -5630,9 +5617,9 @@ void func_80068DA0(Player* player, UNUSED s8 arg1, UNUSED f32 arg2, s8 arg3, s8
|
||||
Vec3s sp94;
|
||||
|
||||
if ((player->unk_258[20 + arg4].unk_01C == 1) && ((s32) player->animFrameSelector[arg3] < 0xD)) {
|
||||
sp9C[1] = (player->pos[1] - 3.0f) + player->unk_258[20 + arg4].unk_000[1];
|
||||
sp9C[2] = player->pos[2] + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
sp9C[0] = player->pos[0] + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
sp9C[1] = (player->pos.y - 3.0f) + player->unk_258[20 + arg4].unk_000[1];
|
||||
sp9C[2] = player->pos.z + (coss(player->unk_048[arg3]) * -10.0f);
|
||||
sp9C[0] = player->pos.x + (sins(player->unk_048[arg3]) * -10.0f);
|
||||
sp94[0] = 0;
|
||||
sp94[1] = player->unk_048[arg3];
|
||||
sp94[2] = 0;
|
||||
@@ -5915,9 +5902,9 @@ void func_8006A50C(Player* player, f32 arg1, f32 arg2, s8 arg3, s8 arg4, s16 arg
|
||||
D_8018D830[arg3][arg4] = 1;
|
||||
D_8018D620[arg3][arg4] = -player->rotation[1] - player->unk_0C0;
|
||||
func_80062B18(&someX, &someY, &someZ, arg1, 4.0f, arg2 + -3.8, -player->rotation[1], 0);
|
||||
D_8018D4D0[arg3][arg4] = player->pos[0] + someX;
|
||||
D_8018D590[arg3][arg4] = player->pos[2] + someZ;
|
||||
D_8018D530[arg3][arg4] = (player->pos[1] - player->boundingBoxSize) + someY;
|
||||
D_8018D4D0[arg3][arg4] = player->pos.x + someX;
|
||||
D_8018D590[arg3][arg4] = player->pos.z + someZ;
|
||||
D_8018D530[arg3][arg4] = (player->pos.y - player->boundingBoxSize) + someY;
|
||||
gPlayerBalloonStatus[arg3][arg4] |= 1;
|
||||
D_8018D860[arg3][arg4] = arg5;
|
||||
D_8018D890[arg3][arg4] = 0;
|
||||
@@ -5994,9 +5981,9 @@ void func_8006A7C0(Player* player, f32 arg1, f32 arg2, s8 arg3, s8 arg4) {
|
||||
func_80062B18(&someX, &someY, &someZ, arg1, sp80[player->characterId] - D_8018D710[arg3][arg4],
|
||||
arg2 + -3.2 + (sp6C * 1), -D_8018D620[arg3][arg4], -player->unk_206 * 2);
|
||||
if ((gPlayerBalloonStatus[arg3][arg4] & 2) != 2) {
|
||||
D_8018D530[arg3][arg4] = (player->pos[1] - player->boundingBoxSize) + someY;
|
||||
D_8018D4D0[arg3][arg4] = player->pos[0] + someX;
|
||||
D_8018D590[arg3][arg4] = player->pos[2] + someZ;
|
||||
D_8018D530[arg3][arg4] = (player->pos.y - player->boundingBoxSize) + someY;
|
||||
D_8018D4D0[arg3][arg4] = player->pos.x + someX;
|
||||
D_8018D590[arg3][arg4] = player->pos.z + someZ;
|
||||
D_8018D8D0[arg3][arg4] = 0;
|
||||
} else {
|
||||
D_8018D530[arg3][arg4] += 0.2;
|
||||
@@ -6045,8 +6032,8 @@ void render_battle_balloon(Player* player, s8 arg1, s16 arg2, s8 arg3) {
|
||||
var_f20 = 0.3f;
|
||||
} else {
|
||||
// wut?
|
||||
xdiff = (var_f20 = player->pos[0] - cameras[arg3].pos[0]);
|
||||
zdiff = player->pos[2] - cameras[arg3].pos[2];
|
||||
xdiff = (var_f20 = player->pos.x - cameras[arg3].pos.x);
|
||||
zdiff = player->pos.z - cameras[arg3].pos.z;
|
||||
if (gActiveScreenMode != 3) {
|
||||
var_f20 = sqrtf((xdiff * xdiff) + (zdiff * zdiff)) / 300.0f;
|
||||
} else {
|
||||
@@ -6189,7 +6176,7 @@ void render_balloon(Vec3f arg0, f32 arg1, s16 arg2, s16 arg3) {
|
||||
spFC[1] = arg0[1];
|
||||
spFC[2] = arg0[2];
|
||||
spF4[0] = 0;
|
||||
spF4[1] = camera1->rot[1];
|
||||
spF4[1] = camera1->rot.y;
|
||||
spF4[2] = arg2;
|
||||
mtxf_translate_rotate(mtx, spFC, spF4);
|
||||
mtxf_scale2(mtx, arg1);
|
||||
@@ -6234,7 +6221,7 @@ void func_8006C0C8(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha) {
|
||||
sp4C[1] = arg0[1];
|
||||
sp4C[2] = arg0[2];
|
||||
sp44[0] = 0;
|
||||
sp44[1] = camera1->rot[1];
|
||||
sp44[1] = camera1->rot.y;
|
||||
sp44[2] = 0;
|
||||
func_800652D4(sp4C, sp44, arg1);
|
||||
gSPDisplayList(gDisplayListHead++, D_0D008DB8);
|
||||
@@ -6263,7 +6250,7 @@ void func_8006C294(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha) {
|
||||
sp5C[1] = arg0[1];
|
||||
sp5C[2] = arg0[2];
|
||||
sp54[0] = 0;
|
||||
sp54[1] = camera1->rot[1];
|
||||
sp54[1] = camera1->rot.y;
|
||||
sp54[2] = 0;
|
||||
func_800652D4(sp5C, sp54, arg1);
|
||||
gSPDisplayList(gDisplayListHead++, D_0D008D58);
|
||||
@@ -6290,7 +6277,7 @@ void func_8006C4D4(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha, s16 arg4) {
|
||||
sp4C[1] = arg0[1];
|
||||
sp4C[2] = arg0[2];
|
||||
sp44[0] = 0;
|
||||
sp44[1] = camera1->rot[1];
|
||||
sp44[1] = camera1->rot.y;
|
||||
sp44[2] = 0;
|
||||
func_800652D4(sp4C, sp44, arg1);
|
||||
gSPDisplayList(gDisplayListHead++, D_0D008DB8);
|
||||
|
||||
+21
-21
@@ -671,16 +671,16 @@ void init_course_object(void) {
|
||||
// // Handle the big statue's fire breath
|
||||
// objectId = indexObjectList2[0];
|
||||
// init_object(objectId, 0);
|
||||
// gObjectList[objectId].pos[0] = -68.0 * xOrientation;
|
||||
// gObjectList[objectId].pos[1] = 80.0f;
|
||||
// gObjectList[objectId].pos[2] = -1840.0f;
|
||||
// gObjectList[objectId].pos.x = -68.0 * xOrientation;
|
||||
// gObjectList[objectId].pos.y = 80.0f;
|
||||
// gObjectList[objectId].pos.z = -1840.0f;
|
||||
// // Handle the smaller statues' fire breath
|
||||
// for (i = 0; i < NUM_FIRE_BREATHS; i++) {
|
||||
// objectId = indexObjectList3[i];
|
||||
// init_object(objectId, 0);
|
||||
// gObjectList[objectId].pos[0] = gFireBreathsSpawns[i][0] * xOrientation;
|
||||
// gObjectList[objectId].pos[1] = gFireBreathsSpawns[i][1];
|
||||
// gObjectList[objectId].pos[2] = gFireBreathsSpawns[i][2];
|
||||
// gObjectList[objectId].pos.x = gFireBreathsSpawns[i][0] * xOrientation;
|
||||
// gObjectList[objectId].pos.y = gFireBreathsSpawns[i][1];
|
||||
// gObjectList[objectId].pos.z = gFireBreathsSpawns[i][2];
|
||||
// gObjectList[objectId].direction_angle[1] = 0;
|
||||
// if (i % 2U) {
|
||||
// gObjectList[objectId].direction_angle[1] += 0x8000;
|
||||
@@ -710,11 +710,11 @@ void init_course_object(void) {
|
||||
// for (i = 0; i < NUM_HEDGEHOGS; i++) {
|
||||
// objectId = indexObjectList2[i];
|
||||
// init_object(objectId, 0);
|
||||
// gObjectList[objectId].pos[0] = gObjectList[objectId].origin_pos[0] =
|
||||
// gHedgehogSpawns[i].pos[0] * xOrientation;
|
||||
// gObjectList[objectId].pos[1] = gObjectList[objectId].surfaceHeight =
|
||||
// gHedgehogSpawns[i].pos[1] + 6.0;
|
||||
// gObjectList[objectId].pos[2] = gObjectList[objectId].origin_pos[2] = gHedgehogSpawns[i].pos[2];
|
||||
// gObjectList[objectId].pos.x = gObjectList[objectId].origin_pos[0] =
|
||||
// gHedgehogSpawns[i].pos.x * xOrientation;
|
||||
// gObjectList[objectId].pos.y = gObjectList[objectId].surfaceHeight =
|
||||
// gHedgehogSpawns[i].pos.y + 6.0;
|
||||
// gObjectList[objectId].pos.z = gObjectList[objectId].origin_pos[2] = gHedgehogSpawns[i].pos.z;
|
||||
// gObjectList[objectId].unk_0D5 = gHedgehogSpawns[i].unk_06;
|
||||
// gObjectList[objectId].unk_09C = gHedgehogPatrolPoints[i][0] * xOrientation;
|
||||
// gObjectList[objectId].unk_09E = gHedgehogPatrolPoints[i][2];
|
||||
@@ -729,14 +729,14 @@ void init_course_object(void) {
|
||||
// for (i = 0; i < NUM_SNOWMEN; i++) {
|
||||
// objectId = indexObjectList2[i];
|
||||
// init_object(objectId, 0);
|
||||
// gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos[0] * xOrientation;
|
||||
// gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos[1] + 5.0 + 3.0;
|
||||
// gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos[2];
|
||||
// gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos.x * xOrientation;
|
||||
// gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos.y + 5.0 + 3.0;
|
||||
// gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos.z;
|
||||
// objectId = indexObjectList1[i];
|
||||
// init_object(objectId, 0);
|
||||
// gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos[0] * xOrientation;
|
||||
// gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos[1] + 3.0;
|
||||
// gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos[2];
|
||||
// gObjectList[objectId].origin_pos[0] = gSnowmanSpawns[i].pos.x * xOrientation;
|
||||
// gObjectList[objectId].origin_pos[1] = gSnowmanSpawns[i].pos.y + 3.0;
|
||||
// gObjectList[objectId].origin_pos[2] = gSnowmanSpawns[i].pos.z;
|
||||
// gObjectList[objectId].unk_0D5 = gSnowmanSpawns[i].unk_6;
|
||||
// }
|
||||
// }
|
||||
@@ -746,11 +746,11 @@ void init_course_object(void) {
|
||||
// for (i = 0; i < NUM_CRABS; i++) {
|
||||
// objectId = indexObjectList1[i];
|
||||
// init_object(objectId, 0);
|
||||
// gObjectList[objectId].pos[0] = gObjectList[objectId].origin_pos[0] =
|
||||
// gObjectList[objectId].pos.x = gObjectList[objectId].origin_pos[0] =
|
||||
// gCrabSpawns[i].startX * xOrientation;
|
||||
// gObjectList[objectId].unk_01C[0] = gCrabSpawns[i].patrolX * xOrientation;
|
||||
|
||||
// gObjectList[objectId].pos[2] = gObjectList[objectId].origin_pos[2] = gCrabSpawns[i].startZ;
|
||||
// gObjectList[objectId].pos.z = gObjectList[objectId].origin_pos[2] = gCrabSpawns[i].startZ;
|
||||
// gObjectList[objectId].unk_01C[2] = gCrabSpawns[i].patrolZ;
|
||||
// }
|
||||
// }
|
||||
@@ -834,8 +834,8 @@ void init_course_object(void) {
|
||||
// find_unused_obj_index(&gObjectParticle1[i]);
|
||||
// objectId = gObjectParticle1[i];
|
||||
// init_object(objectId, 0);
|
||||
// gObjectList[objectId].pos[0] = gMoleSpawns.asVec3sList[i][0] * xOrientation;
|
||||
// gObjectList[objectId].pos[2] = gMoleSpawns.asVec3sList[i][2];
|
||||
// gObjectList[objectId].pos.x = gMoleSpawns.asVec3sList[i][0] * xOrientation;
|
||||
// gObjectList[objectId].pos.z = gMoleSpawns.asVec3sList[i][2];
|
||||
// func_800887C0(objectId);
|
||||
// gObjectList[objectId].sizeScaling = 0.7f;
|
||||
// }
|
||||
|
||||
+148
-148
@@ -118,20 +118,20 @@ UNUSED void func_80087258(s32 objectIndex, UNUSED s32 arg1, f32 arg2) {
|
||||
}
|
||||
|
||||
UNUSED s32 get_angle_between_player_object(s32 objectIndex, Player* player) {
|
||||
return get_angle_between_xy(player->pos[0], gObjectList[objectIndex].pos[0], player->pos[2],
|
||||
gObjectList[objectIndex].pos[2]);
|
||||
return get_angle_between_xy(player->pos.x, gObjectList[objectIndex].pos.x, player->pos.z,
|
||||
gObjectList[objectIndex].pos.z);
|
||||
}
|
||||
|
||||
s32 angle_between_object_camera(s32 objectIndex, Camera* camera) {
|
||||
return atan2s(gObjectList[objectIndex].pos[0] - camera->pos[0], gObjectList[objectIndex].pos[2] - camera->pos[2]);
|
||||
return atan2s(gObjectList[objectIndex].pos.x - camera->pos.x, gObjectList[objectIndex].pos.z - camera->pos.z);
|
||||
}
|
||||
|
||||
u16 get_x_direction_angle(s32 objectIndex) {
|
||||
return -atan2s(gObjectList[objectIndex].velocity[1], gObjectList[objectIndex].velocity[2]);
|
||||
return -atan2s(gObjectList[objectIndex].velocity.y, gObjectList[objectIndex].velocity.z);
|
||||
}
|
||||
|
||||
s32 get_y_direction_angle(s32 objectIndex) {
|
||||
return atan2s(gObjectList[objectIndex].velocity[0], gObjectList[objectIndex].velocity[2]);
|
||||
return atan2s(gObjectList[objectIndex].velocity.x, gObjectList[objectIndex].velocity.z);
|
||||
}
|
||||
|
||||
UNUSED void func_800873A4(s32 objectIndex) {
|
||||
@@ -145,24 +145,24 @@ void func_800873F4(s32 objectIndex) {
|
||||
}
|
||||
|
||||
UNUSED void func_80087444(s32 objectIndex) {
|
||||
gObjectList[objectIndex].velocity[0] =
|
||||
gObjectList[objectIndex].velocity.x =
|
||||
gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[1]);
|
||||
}
|
||||
|
||||
UNUSED void func_8008748C(s32 objectIndex) {
|
||||
gObjectList[objectIndex].velocity[1] =
|
||||
gObjectList[objectIndex].velocity.y =
|
||||
gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[0]);
|
||||
}
|
||||
|
||||
UNUSED void func_800874D4(s32 objectIndex) {
|
||||
gObjectList[objectIndex].velocity[2] =
|
||||
gObjectList[objectIndex].velocity.z =
|
||||
gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[1]);
|
||||
}
|
||||
|
||||
void func_8008751C(s32 objectIndex) {
|
||||
gObjectList[objectIndex].velocity[0] =
|
||||
gObjectList[objectIndex].velocity.x =
|
||||
gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[1]);
|
||||
gObjectList[objectIndex].velocity[2] =
|
||||
gObjectList[objectIndex].velocity.z =
|
||||
gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[1]);
|
||||
}
|
||||
|
||||
@@ -170,19 +170,19 @@ void func_8008757C(s32 objectIndex) {
|
||||
f32 sp24;
|
||||
|
||||
sp24 = coss(gObjectList[objectIndex].direction_angle[0]);
|
||||
gObjectList[objectIndex].velocity[0] =
|
||||
gObjectList[objectIndex].velocity.x =
|
||||
(gObjectList[objectIndex].unk_034 * sp24) * sins(gObjectList[objectIndex].direction_angle[1]);
|
||||
gObjectList[objectIndex].velocity[1] =
|
||||
gObjectList[objectIndex].velocity.y =
|
||||
-gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[0]);
|
||||
sp24 = coss(gObjectList[objectIndex].direction_angle[0]);
|
||||
gObjectList[objectIndex].velocity[2] =
|
||||
gObjectList[objectIndex].velocity.z =
|
||||
(gObjectList[objectIndex].unk_034 * sp24) * coss(gObjectList[objectIndex].direction_angle[1]);
|
||||
}
|
||||
|
||||
void func_80087620(s32 objectIndex) {
|
||||
gObjectList[objectIndex].velocity[0] =
|
||||
gObjectList[objectIndex].velocity.x =
|
||||
gObjectList[objectIndex].unk_034 * sins(gObjectList[objectIndex].direction_angle[1] + 0x8000);
|
||||
gObjectList[objectIndex].velocity[2] =
|
||||
gObjectList[objectIndex].velocity.z =
|
||||
gObjectList[objectIndex].unk_034 * coss(gObjectList[objectIndex].direction_angle[1] + 0x8000);
|
||||
}
|
||||
|
||||
@@ -194,26 +194,26 @@ void func_800876A0(s32 objectIndex) {
|
||||
}
|
||||
|
||||
void object_add_velocity_offset_xyz(s32 objectIndex) {
|
||||
gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity[0];
|
||||
gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity[1];
|
||||
gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity[2];
|
||||
gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity.x;
|
||||
gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity.y;
|
||||
gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity.z;
|
||||
}
|
||||
|
||||
void object_add_velocity_offset_xz(s32 objectIndex) {
|
||||
gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity[0];
|
||||
gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity[2];
|
||||
gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity.x;
|
||||
gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity.z;
|
||||
}
|
||||
|
||||
UNUSED void object_add_velocity_offset_x(s32 objectIndex) {
|
||||
gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity[0];
|
||||
gObjectList[objectIndex].offset[0] += gObjectList[objectIndex].velocity.x;
|
||||
}
|
||||
|
||||
void object_add_velocity_offset_y(s32 objectIndex) {
|
||||
gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity[1];
|
||||
gObjectList[objectIndex].offset[1] += gObjectList[objectIndex].velocity.y;
|
||||
}
|
||||
|
||||
UNUSED void object_add_velocity_offset_z(s32 objectIndex) {
|
||||
gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity[2];
|
||||
gObjectList[objectIndex].offset[2] += gObjectList[objectIndex].velocity.z;
|
||||
}
|
||||
|
||||
void func_8008781C(s32 arg0) {
|
||||
@@ -301,10 +301,10 @@ s32 func_80087B84(s32 objectIndex, f32 arg1, f32 arg2) {
|
||||
sp24 = 0;
|
||||
if (is_obj_index_flag_status_inactive(objectIndex, 8) != false) {
|
||||
set_object_flag(objectIndex, 8);
|
||||
gObjectList[objectIndex].velocity[1] = -arg1;
|
||||
gObjectList[objectIndex].velocity.y = -arg1;
|
||||
}
|
||||
object_add_velocity_offset_y(objectIndex);
|
||||
if (gObjectList[objectIndex].pos[1] <= arg2) {
|
||||
if (gObjectList[objectIndex].pos.y <= arg2) {
|
||||
clear_object_flag(objectIndex, 8);
|
||||
func_80086FD4(objectIndex);
|
||||
sp24 = 1;
|
||||
@@ -318,7 +318,7 @@ s32 func_80087C48(s32 objectIndex, f32 arg1, f32 arg2, s32 arg3) {
|
||||
sp24 = 0;
|
||||
if (is_obj_index_flag_status_inactive(objectIndex, 8) != false) {
|
||||
set_object_flag(objectIndex, 8);
|
||||
gObjectList[objectIndex].velocity[1] = arg1;
|
||||
gObjectList[objectIndex].velocity.y = arg1;
|
||||
gObjectList[objectIndex].unk_0B0 = (s16) arg3;
|
||||
}
|
||||
gObjectList[objectIndex].unk_0B0--;
|
||||
@@ -327,7 +327,7 @@ s32 func_80087C48(s32 objectIndex, f32 arg1, f32 arg2, s32 arg3) {
|
||||
func_80086FD4(objectIndex);
|
||||
sp24 = 1;
|
||||
} else {
|
||||
gObjectList[objectIndex].velocity[1] -= arg2;
|
||||
gObjectList[objectIndex].velocity.y -= arg2;
|
||||
object_add_velocity_offset_y(objectIndex);
|
||||
}
|
||||
return sp24;
|
||||
@@ -339,9 +339,9 @@ s32 func_80087D24(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3) {
|
||||
sp24 = 0;
|
||||
if (is_obj_index_flag_status_inactive(objectIndex, 8) != 0) {
|
||||
set_object_flag(objectIndex, 8);
|
||||
gObjectList[objectIndex].velocity[1] = arg1;
|
||||
gObjectList[objectIndex].velocity.y = arg1;
|
||||
}
|
||||
gObjectList[objectIndex].velocity[1] -= arg2;
|
||||
gObjectList[objectIndex].velocity.y -= arg2;
|
||||
object_add_velocity_offset_y(objectIndex);
|
||||
if (gObjectList[objectIndex].offset[1] <= arg3) {
|
||||
clear_object_flag(objectIndex, 8);
|
||||
@@ -363,7 +363,7 @@ bool func_80087E08(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4, s32
|
||||
gObjectList[objectIndex].offset[1] = 0.0f;
|
||||
gObjectList[objectIndex].offset[0] = 0.0f;
|
||||
gObjectList[objectIndex].unk_034 = arg3;
|
||||
gObjectList[objectIndex].velocity[1] = arg1;
|
||||
gObjectList[objectIndex].velocity.y = arg1;
|
||||
gObjectList[objectIndex].direction_angle[1] = arg4;
|
||||
func_8008751C(objectIndex);
|
||||
gObjectList[objectIndex].unk_0B0 = arg5;
|
||||
@@ -374,7 +374,7 @@ bool func_80087E08(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4, s32
|
||||
func_80086FD4(objectIndex);
|
||||
sp2C = true;
|
||||
} else {
|
||||
gObjectList[objectIndex].velocity[1] -= arg2;
|
||||
gObjectList[objectIndex].velocity.y -= arg2;
|
||||
object_add_velocity_offset_xyz(objectIndex);
|
||||
}
|
||||
return sp2C;
|
||||
@@ -391,7 +391,7 @@ UNUSED s32 func_80087F14(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4
|
||||
gObjectList[objectIndex].offset[1] = 0.0f;
|
||||
gObjectList[objectIndex].offset[0] = 0.0f;
|
||||
gObjectList[objectIndex].unk_034 = arg3;
|
||||
gObjectList[objectIndex].velocity[1] = arg1;
|
||||
gObjectList[objectIndex].velocity.y = arg1;
|
||||
gObjectList[objectIndex].direction_angle[1] = arg4;
|
||||
func_8008751C(objectIndex);
|
||||
gObjectList[objectIndex].unk_0B0 = gVBlankTimer;
|
||||
@@ -401,7 +401,7 @@ UNUSED s32 func_80087F14(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3, s16 arg4
|
||||
func_80086FD4(objectIndex);
|
||||
sp2C = 1;
|
||||
} else {
|
||||
gObjectList[objectIndex].velocity[1] -= arg2;
|
||||
gObjectList[objectIndex].velocity.y -= arg2;
|
||||
object_add_velocity_offset_xyz(objectIndex);
|
||||
}
|
||||
return sp2C;
|
||||
@@ -416,8 +416,8 @@ void func_80088038(s32 objectIndex, f32 arg1, u16 arg2) {
|
||||
gObjectList[objectIndex].unk_0C4 += arg2;
|
||||
gObjectList[objectIndex].offset[0] = sins(gObjectList[objectIndex].unk_0C4) * arg1;
|
||||
gObjectList[objectIndex].offset[2] = coss(gObjectList[objectIndex].unk_0C4) * arg1;
|
||||
gObjectList[objectIndex].velocity[0] = gObjectList[objectIndex].offset[0] - temp_f4;
|
||||
gObjectList[objectIndex].velocity[2] = gObjectList[objectIndex].offset[2] - sp20;
|
||||
gObjectList[objectIndex].velocity.x = gObjectList[objectIndex].offset[0] - temp_f4;
|
||||
gObjectList[objectIndex].velocity.z = gObjectList[objectIndex].offset[2] - sp20;
|
||||
}
|
||||
|
||||
UNUSED void func_800880DC(void) {
|
||||
@@ -428,9 +428,9 @@ void func_800880E4(s32 objectIndex) {
|
||||
s32 someIndex;
|
||||
phi_v0 = gObjectList[objectIndex].controlPoints;
|
||||
for (someIndex = 0; someIndex < 2; someIndex++, phi_v0++) {
|
||||
D_80165760[someIndex] = phi_v0->pos[0];
|
||||
D_80165770[someIndex] = phi_v0->pos[1];
|
||||
D_80165780[someIndex] = phi_v0->pos[2];
|
||||
D_80165760[someIndex] = phi_v0->pos.x;
|
||||
D_80165770[someIndex] = phi_v0->pos.y;
|
||||
D_80165780[someIndex] = phi_v0->pos.z;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -464,9 +464,9 @@ void func_80088228(s32 objectIndex) {
|
||||
but for some unholy reason that doesn't match
|
||||
*/
|
||||
object->unk_084[8] = *((s16*) object->controlPoints - 1);
|
||||
object->offset[0] = object->controlPoints[0].pos[0];
|
||||
object->offset[1] = object->controlPoints[0].pos[1];
|
||||
object->offset[2] = object->controlPoints[0].pos[2];
|
||||
object->offset[0] = object->controlPoints[0].pos.x;
|
||||
object->offset[1] = object->controlPoints[0].pos.y;
|
||||
object->offset[2] = object->controlPoints[0].pos.z;
|
||||
func_80086FD4(objectIndex);
|
||||
}
|
||||
|
||||
@@ -528,14 +528,14 @@ s32 func_8008847C(s32 objectIndex) {
|
||||
sp2C = 0;
|
||||
clear_object_flag(objectIndex, 0x00800000);
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00000400) != 0) {
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
|
||||
gObjectList[objectIndex].pos[2]);
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
|
||||
gObjectList[objectIndex].pos.z);
|
||||
if (D_8018C3B0.unk34 == 1) {
|
||||
sp2C = 1;
|
||||
set_object_flag(objectIndex, 0x00800000);
|
||||
}
|
||||
gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
|
||||
gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
|
||||
}
|
||||
return sp2C;
|
||||
}
|
||||
@@ -546,14 +546,14 @@ s32 func_80088538(s32 objectIndex) {
|
||||
sp2C = 0;
|
||||
clear_object_flag(objectIndex, 0x00800000);
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00000400) != 0) {
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
|
||||
gObjectList[objectIndex].pos[2]);
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
|
||||
gObjectList[objectIndex].pos.z);
|
||||
if (D_8018C3B0.unk34 == 1) {
|
||||
sp2C = 1;
|
||||
set_object_flag(objectIndex, 0x00800000);
|
||||
}
|
||||
gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
|
||||
gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].unk_0B8[0] =
|
||||
atan2s(D_8018C3B0.orientationVector[2], D_8018C3B0.orientationVector[1]) + 0x4000;
|
||||
gObjectList[objectIndex].unk_0B8[2] = atan2s(D_8018C3B0.orientationVector[0], D_8018C3B0.orientationVector[1]);
|
||||
@@ -567,14 +567,14 @@ s32 func_8008861C(s32 objectIndex) {
|
||||
sp2C = 0;
|
||||
clear_object_flag(objectIndex, 0x00800000);
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00000400) != 0) {
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
|
||||
gObjectList[objectIndex].pos[2]);
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
|
||||
gObjectList[objectIndex].pos.z);
|
||||
if (D_8018C3B0.unk34 == 1) {
|
||||
sp2C = 1;
|
||||
set_object_flag(objectIndex, 0x00800000);
|
||||
}
|
||||
gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
|
||||
gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].unk_01C[0] = D_8018C3B0.orientationVector[0];
|
||||
gObjectList[objectIndex].unk_01C[1] = D_8018C3B0.orientationVector[1];
|
||||
gObjectList[objectIndex].unk_01C[2] = D_8018C3B0.orientationVector[2];
|
||||
@@ -583,12 +583,12 @@ s32 func_8008861C(s32 objectIndex) {
|
||||
}
|
||||
|
||||
void func_800886F4(s32 objectIndex) {
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
|
||||
gObjectList[objectIndex].pos[2]);
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
|
||||
gObjectList[objectIndex].pos.z);
|
||||
if (D_8018C3B0.unk34 == 1) {
|
||||
set_object_flag(objectIndex, 0x00800000);
|
||||
gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
|
||||
gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].unk_0B8[0] =
|
||||
atan2s(D_8018C3B0.orientationVector[2], D_8018C3B0.orientationVector[1]) + 0x4000;
|
||||
gObjectList[objectIndex].unk_0B8[2] = atan2s(D_8018C3B0.orientationVector[0], D_8018C3B0.orientationVector[1]);
|
||||
@@ -598,15 +598,15 @@ void func_800886F4(s32 objectIndex) {
|
||||
}
|
||||
|
||||
void func_800887C0(s32 objectIndex) {
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos[0], 20.0f,
|
||||
gObjectList[objectIndex].pos[2]);
|
||||
check_bounding_collision(&D_8018C3B0, 10.0f, gObjectList[objectIndex].pos.x, 20.0f,
|
||||
gObjectList[objectIndex].pos.z);
|
||||
if (D_8018C3B0.unk34 == 1) {
|
||||
set_object_flag(objectIndex, 0x00800000);
|
||||
gObjectList[objectIndex].surfaceHeight = calculate_surface_height(
|
||||
gObjectList[objectIndex].pos[0], 0.0f, gObjectList[objectIndex].pos[2], D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].velocity[0] = D_8018C3B0.orientationVector[0];
|
||||
gObjectList[objectIndex].velocity[1] = D_8018C3B0.orientationVector[1];
|
||||
gObjectList[objectIndex].velocity[2] = D_8018C3B0.orientationVector[2];
|
||||
gObjectList[objectIndex].pos.x, 0.0f, gObjectList[objectIndex].pos.z, D_8018C3B0.meshIndexZX);
|
||||
gObjectList[objectIndex].velocity.x = D_8018C3B0.orientationVector[0];
|
||||
gObjectList[objectIndex].velocity.y = D_8018C3B0.orientationVector[1];
|
||||
gObjectList[objectIndex].velocity.z = D_8018C3B0.orientationVector[2];
|
||||
return;
|
||||
}
|
||||
clear_object_flag(objectIndex, 0x00800000);
|
||||
@@ -623,8 +623,8 @@ UNUSED s32 get_horizontal_distance_to_player(s32 objectIndex, Player* player) {
|
||||
s32 x;
|
||||
s32 y;
|
||||
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
y = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
y = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
return (x * x) + (y * y);
|
||||
}
|
||||
|
||||
@@ -640,9 +640,9 @@ UNUSED s32 get_distance_to_player(s32 objectIndex, Player* player) {
|
||||
s32 z;
|
||||
s32 y;
|
||||
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
y = gObjectList[objectIndex].pos[1] - player->pos[1];
|
||||
z = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
y = gObjectList[objectIndex].pos.y - player->pos.y;
|
||||
z = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
return (x * x) + (y * y) + (z * z);
|
||||
}
|
||||
|
||||
@@ -657,8 +657,8 @@ u32 get_horizontal_distance_to_camera(s32 objectIndex, Camera* camera) {
|
||||
s32 x;
|
||||
s32 y;
|
||||
|
||||
x = gObjectList[objectIndex].pos[0] - camera->pos[0];
|
||||
y = gObjectList[objectIndex].pos[2] - camera->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - camera->pos.x;
|
||||
y = gObjectList[objectIndex].pos.z - camera->pos.z;
|
||||
return (x * x) + (y * y);
|
||||
}
|
||||
|
||||
@@ -674,9 +674,9 @@ UNUSED s32 get_distance_to_camera(s32 objectIndex, Camera* camera) {
|
||||
s32 z;
|
||||
s32 y;
|
||||
|
||||
x = gObjectList[objectIndex].pos[0] - camera->pos[0];
|
||||
y = gObjectList[objectIndex].pos[1] - camera->pos[1];
|
||||
z = gObjectList[objectIndex].pos[2] - camera->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - camera->pos.x;
|
||||
y = gObjectList[objectIndex].pos.y - camera->pos.y;
|
||||
z = gObjectList[objectIndex].pos.z - camera->pos.z;
|
||||
return (x * x) + (y * y) + (z * z);
|
||||
}
|
||||
|
||||
@@ -695,8 +695,8 @@ bool is_within_horizontal_distance_of_player(s32 objectIndex, Player* player, f3
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
y = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
y = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
if (((x * x) + (y * y)) <= (distance * distance)) {
|
||||
var_v1 = true;
|
||||
}
|
||||
@@ -720,8 +720,8 @@ bool is_in_bounds_to_player(s32 objectIndex, Player* player, f32 distance_min, f
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
z = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
z = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
distance = (x * x) + (z * z);
|
||||
if (((distance_min * distance_min) <= distance) && (distance <= (distance_max * distance_max))) {
|
||||
var_v1 = true;
|
||||
@@ -745,9 +745,9 @@ bool is_within_distance_to_player(s32 objectIndex, Player* player, f32 distance)
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
y = gObjectList[objectIndex].pos[1] - player->pos[1];
|
||||
z = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
y = gObjectList[objectIndex].pos.y - player->pos.y;
|
||||
z = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
if (((x * x) + (y * y) + (z * z)) <= (distance * distance)) {
|
||||
var_v1 = true;
|
||||
}
|
||||
@@ -769,8 +769,8 @@ bool is_within_horizontal_distance_to_camera(s32 objectIndex, Camera* camera, f3
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - camera->pos[0];
|
||||
y = gObjectList[objectIndex].pos[2] - camera->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - camera->pos.x;
|
||||
y = gObjectList[objectIndex].pos.z - camera->pos.z;
|
||||
if (((x * x) + (y * y)) <= (distance * distance)) {
|
||||
var_v1 = true;
|
||||
}
|
||||
@@ -793,8 +793,8 @@ UNUSED bool is_within_bounds_to_camera(s32 objectIndex, Camera* camera, f32 dist
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - camera->pos[0];
|
||||
z = gObjectList[objectIndex].pos[2] - camera->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - camera->pos.x;
|
||||
z = gObjectList[objectIndex].pos.z - camera->pos.z;
|
||||
distance = (x * x) + (z * z);
|
||||
if (((distance_min * distance_min) <= distance) && (distance <= (distance_max * distance_max))) {
|
||||
var_v1 = true;
|
||||
@@ -817,9 +817,9 @@ UNUSED bool is_within_distance_to_camera(s32 objectIndex, Camera* camera, f32 di
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - camera->pos[0];
|
||||
y = gObjectList[objectIndex].pos[1] - camera->pos[1];
|
||||
z = gObjectList[objectIndex].pos[2] - camera->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - camera->pos.x;
|
||||
y = gObjectList[objectIndex].pos.y - camera->pos.y;
|
||||
z = gObjectList[objectIndex].pos.z - camera->pos.z;
|
||||
if (((x * x) + (y * y) + (z * z)) <= (distance * distance)) {
|
||||
var_v1 = true;
|
||||
}
|
||||
@@ -841,8 +841,8 @@ bool has_collided_horizontally_with_player(s32 objectIndex, Player* player) {
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
z = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
z = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
distance = gObjectList[objectIndex].boundingBoxSize + player->boundingBoxSize;
|
||||
if (((x * x) + (z * z)) <= (distance * distance)) {
|
||||
var_v1 = true;
|
||||
@@ -866,9 +866,9 @@ bool has_collided_with_player(s32 objectIndex, Player* player) {
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
y = gObjectList[objectIndex].pos[1] - player->pos[1];
|
||||
z = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
y = gObjectList[objectIndex].pos.y - player->pos.y;
|
||||
z = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
distance = gObjectList[objectIndex].boundingBoxSize + player->boundingBoxSize;
|
||||
if (((x * x) + (y * y) + (z * z)) <= (distance * distance)) {
|
||||
var_v1 = true;
|
||||
@@ -889,7 +889,7 @@ UNUSED bool has_collided_with_player_1d(s32 objectIndex, Player* player, f32 dis
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[1] - player->pos[1];
|
||||
x = gObjectList[objectIndex].pos.y - player->pos.y;
|
||||
if ((x * x) <= (distance * distance)) {
|
||||
var_v1 = true;
|
||||
}
|
||||
@@ -913,9 +913,9 @@ bool has_collided_with_player_and_within_height(s32 objectIndex, Player* player,
|
||||
bool var_v1;
|
||||
|
||||
var_v1 = false;
|
||||
x = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
y = gObjectList[objectIndex].pos[1] - player->pos[1];
|
||||
z = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
x = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
y = gObjectList[objectIndex].pos.y - player->pos.y;
|
||||
z = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
distance = gObjectList[objectIndex].boundingBoxSize + player->boundingBoxSize;
|
||||
// abs(y)
|
||||
if (y < 0.0f) {
|
||||
@@ -930,7 +930,7 @@ bool has_collided_with_player_and_within_height(s32 objectIndex, Player* player,
|
||||
f32 func_80088F54(s32 objectIndex, Player* player) {
|
||||
f32 distance;
|
||||
|
||||
distance = gObjectList[objectIndex].pos[1] - player->unk_074;
|
||||
distance = gObjectList[objectIndex].pos.y - player->unk_074;
|
||||
// abs(distance)
|
||||
if (distance < 0.0f) {
|
||||
distance = -distance;
|
||||
@@ -942,7 +942,7 @@ UNUSED bool func_80088F94(s32 objectIndex, Player* player, f32 arg2) {
|
||||
f32 distance;
|
||||
bool var_v1;
|
||||
|
||||
distance = gObjectList[objectIndex].pos[1] - player->unk_074;
|
||||
distance = gObjectList[objectIndex].pos.y - player->unk_074;
|
||||
var_v1 = false;
|
||||
// abs(distance)
|
||||
if (distance < 0.0f) {
|
||||
@@ -957,8 +957,8 @@ UNUSED bool func_80088F94(s32 objectIndex, Player* player, f32 arg2) {
|
||||
void func_80088FF0(Player* player) {
|
||||
player->unk_08C = 0.0f;
|
||||
player->currentSpeed = 0.0f;
|
||||
player->velocity[0] = 0.0f;
|
||||
player->velocity[2] = 0.0f;
|
||||
player->velocity.x = 0.0f;
|
||||
player->velocity.z = 0.0f;
|
||||
}
|
||||
|
||||
UNUSED void func_8008900C(Player* player) {
|
||||
@@ -1045,17 +1045,17 @@ f32 func_8008933C(Player* player, s32 objectIndex, f32 arg2, f32 arg3) {
|
||||
player->unk_046 |= 2;
|
||||
player->effects |= 0x8000;
|
||||
temp_v1->unk_18[6] = 4;
|
||||
something = (player->pos[0] - object->pos[0]) * object->velocity[0];
|
||||
something = (player->pos.x - object->pos.x) * object->velocity.x;
|
||||
if (something >= 0.0f) {
|
||||
temp_v1->unk_04[0] = (-player->velocity[0] * arg2) + (object->velocity[0] * arg3);
|
||||
temp_v1->unk_04[0] = (-player->velocity.x * arg2) + (object->velocity.x * arg3);
|
||||
} else {
|
||||
temp_v1->unk_04[0] = -player->velocity[0] * arg2;
|
||||
temp_v1->unk_04[0] = -player->velocity.x * arg2;
|
||||
}
|
||||
something = (player->pos[2] - object->pos[2]) * object->velocity[2];
|
||||
something = (player->pos.z - object->pos.z) * object->velocity.z;
|
||||
if (something >= 0.0f) {
|
||||
temp_v1->unk_04[2] = (-player->velocity[2] * arg2) + (object->velocity[2] * arg3);
|
||||
temp_v1->unk_04[2] = (-player->velocity.z * arg2) + (object->velocity.z * arg3);
|
||||
} else {
|
||||
temp_v1->unk_04[2] = -player->velocity[2] * arg2;
|
||||
temp_v1->unk_04[2] = -player->velocity.z * arg2;
|
||||
}
|
||||
var_f2 = (temp_v1->unk_04[0] * temp_v1->unk_04[0]) + (temp_v1->unk_04[2] * temp_v1->unk_04[2]);
|
||||
}
|
||||
@@ -1260,7 +1260,7 @@ s32 func_8008A060(s32 objectIndex, Camera* camera, u16 arg2) {
|
||||
s32 var_v1;
|
||||
|
||||
var_v1 = 0;
|
||||
temp_t3 = (((u16) camera->rot[1] - gObjectList[objectIndex].direction_angle[1]) + (arg2 >> 1));
|
||||
temp_t3 = (((u16) camera->rot.y - gObjectList[objectIndex].direction_angle[1]) + (arg2 >> 1));
|
||||
|
||||
//! @warning Always true
|
||||
if ((temp_t3 >= 0) && (arg2 >= temp_t3)) {
|
||||
@@ -1276,9 +1276,9 @@ s32 func_8008A0B4(s32 objectIndex, Player* player, Camera* camera, u16 arg3) {
|
||||
s32 var_t0;
|
||||
|
||||
var_t0 = 0;
|
||||
x_diff = gObjectList[objectIndex].pos[0] - player->pos[0];
|
||||
z_diff = gObjectList[objectIndex].pos[2] - player->pos[2];
|
||||
temp_t3 = ((u16) camera->rot[1] - atan2s(x_diff, z_diff)) + (arg3 >> 1);
|
||||
x_diff = gObjectList[objectIndex].pos.x - player->pos.x;
|
||||
z_diff = gObjectList[objectIndex].pos.z - player->pos.z;
|
||||
temp_t3 = ((u16) camera->rot.y - atan2s(x_diff, z_diff)) + (arg3 >> 1);
|
||||
if ((temp_t3 >= 0) && (arg3 >= temp_t3)) {
|
||||
var_t0 = 1;
|
||||
}
|
||||
@@ -1294,10 +1294,10 @@ bool is_object_visible_on_camera(s32 objectIndex, Camera* camera, u16 angle) {
|
||||
}
|
||||
|
||||
var_t0 = false;
|
||||
temp_t2 = (get_angle_between_xy(camera->pos[0], gObjectList[objectIndex].pos[0], camera->pos[2],
|
||||
gObjectList[objectIndex].pos[2]) +
|
||||
temp_t2 = (get_angle_between_xy(camera->pos.x, gObjectList[objectIndex].pos.x, camera->pos.z,
|
||||
gObjectList[objectIndex].pos.z) +
|
||||
((s32) angle / 2)) -
|
||||
camera->rot[1];
|
||||
camera->rot.y;
|
||||
if ((temp_t2 >= 0) && (angle >= temp_t2)) {
|
||||
var_t0 = true;
|
||||
}
|
||||
@@ -1463,9 +1463,9 @@ void func_8008A920(s32 objectIndex) {
|
||||
SplineControlPoint* temp_v0;
|
||||
|
||||
temp_v0 = gObjectList[objectIndex].controlPoints;
|
||||
gObjectList[objectIndex].velocity[0] = (f32) (temp_v0[1].pos[0] - temp_v0[0].pos[0]) / (f32) temp_v0[0].velocity;
|
||||
gObjectList[objectIndex].velocity[1] = (f32) (temp_v0[1].pos[1] - temp_v0[0].pos[1]) / (f32) temp_v0[0].velocity;
|
||||
gObjectList[objectIndex].velocity[2] = (f32) (temp_v0[1].pos[2] - temp_v0[0].pos[2]) / (f32) temp_v0[0].velocity;
|
||||
gObjectList[objectIndex].velocity.x = (f32) (temp_v0[1].pos.x - temp_v0[0].pos.x) / (f32) temp_v0[0].velocity;
|
||||
gObjectList[objectIndex].velocity.y = (f32) (temp_v0[1].pos.y - temp_v0[0].pos.y) / (f32) temp_v0[0].velocity;
|
||||
gObjectList[objectIndex].velocity.z = (f32) (temp_v0[1].pos.z - temp_v0[0].pos.z) / (f32) temp_v0[0].velocity;
|
||||
}
|
||||
|
||||
void func_8008A9B8(s32 objectIndex) {
|
||||
@@ -1491,9 +1491,9 @@ void func_8008AA3C(s32 objectIndex) {
|
||||
but for some unholy reason that doesn't match
|
||||
*/
|
||||
object->unk_084[8] = *((s16*) object->controlPoints - 1);
|
||||
object->offset[0] = object->controlPoints[0].pos[0];
|
||||
object->offset[1] = object->controlPoints[0].pos[1];
|
||||
object->offset[2] = object->controlPoints[0].pos[2];
|
||||
object->offset[0] = object->controlPoints[0].pos.x;
|
||||
object->offset[1] = object->controlPoints[0].pos.y;
|
||||
object->offset[2] = object->controlPoints[0].pos.z;
|
||||
object->unk_09A = (s16) (10000 / object->controlPoints[0].velocity);
|
||||
func_8008A920(objectIndex);
|
||||
func_80086FD4(objectIndex);
|
||||
@@ -1504,9 +1504,9 @@ void func_8008AB10(s32 objectIndex) {
|
||||
Object* object;
|
||||
|
||||
object = &gObjectList[objectIndex];
|
||||
object->offset[0] += object->velocity[0];
|
||||
object->offset[1] += object->velocity[1];
|
||||
object->offset[2] += object->velocity[2];
|
||||
object->offset[0] += object->velocity.x;
|
||||
object->offset[1] += object->velocity.y;
|
||||
object->offset[2] += object->velocity.z;
|
||||
object->animationTimer += (u16) object->unk_09A;
|
||||
if (object->animationTimer >= 0x2710) {
|
||||
object->unk_084[9] = (u16) object->unk_084[9] + 1;
|
||||
@@ -1595,11 +1595,11 @@ void func_8008AE9C(s32 objectIndex) {
|
||||
Object* object;
|
||||
|
||||
object = &gObjectList[objectIndex];
|
||||
object->velocity[0] = (D_80183DC8[0] * D_80165760[0]) + (D_80183DC8[1] * D_80165760[1]) +
|
||||
object->velocity.x = (D_80183DC8[0] * D_80165760[0]) + (D_80183DC8[1] * D_80165760[1]) +
|
||||
(D_80183DC8[2] * D_80165760[2]) + (D_80183DC8[3] * D_80165760[3]);
|
||||
object->velocity[1] = (D_80183DC8[0] * D_80165770[0]) + (D_80183DC8[1] * D_80165770[1]) +
|
||||
object->velocity.y = (D_80183DC8[0] * D_80165770[0]) + (D_80183DC8[1] * D_80165770[1]) +
|
||||
(D_80183DC8[2] * D_80165770[2]) + (D_80183DC8[3] * D_80165770[3]);
|
||||
object->velocity[2] = (D_80183DC8[0] * D_80165780[0]) + (D_80183DC8[1] * D_80165780[1]) +
|
||||
object->velocity.z = (D_80183DC8[0] * D_80165780[0]) + (D_80183DC8[1] * D_80165780[1]) +
|
||||
(D_80183DC8[2] * D_80165780[2]) + (D_80183DC8[3] * D_80165780[3]);
|
||||
}
|
||||
|
||||
@@ -1656,9 +1656,9 @@ void func_8008B1D4(s32 objectIndex) {
|
||||
|
||||
test = gObjectList[objectIndex].controlPoints;
|
||||
for (someIndex = 0; someIndex < 4; someIndex++) {
|
||||
D_80165760[someIndex] = test->pos[0];
|
||||
D_80165770[someIndex] = test->pos[1];
|
||||
D_80165780[someIndex] = test->pos[2];
|
||||
D_80165760[someIndex] = test->pos.x;
|
||||
D_80165770[someIndex] = test->pos.y;
|
||||
D_80165780[someIndex] = test->pos.z;
|
||||
test++;
|
||||
}
|
||||
}
|
||||
@@ -1683,9 +1683,9 @@ void func_8008B284(s32 objectIndex) {
|
||||
sp0 = 0;
|
||||
}
|
||||
for (someIndex = 0; someIndex < 4; someIndex++) {
|
||||
D_80165760[someIndex] = test->pos[0];
|
||||
D_80165770[someIndex] = test->pos[1];
|
||||
D_80165780[someIndex] = test->pos[2];
|
||||
D_80165760[someIndex] = test->pos.x;
|
||||
D_80165770[someIndex] = test->pos.y;
|
||||
D_80165780[someIndex] = test->pos.z;
|
||||
if (sp0 == someIndex) {
|
||||
// Reset back to start of the spline path
|
||||
test = gObjectList[objectIndex].spline->controlPoints;
|
||||
@@ -1823,9 +1823,9 @@ void set_obj_origin_offset(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3) {
|
||||
void func_8008B844(s32 objectIndex) {
|
||||
f32 temp_f0 = gObjectList[objectIndex].origin_pos[0];
|
||||
|
||||
gObjectList[objectIndex].pos[0] = gObjectList[objectIndex].offset[0] + temp_f0;
|
||||
gObjectList[objectIndex].pos[1] = gObjectList[objectIndex].offset[1] + temp_f0;
|
||||
gObjectList[objectIndex].pos[2] = gObjectList[objectIndex].offset[2] + temp_f0;
|
||||
gObjectList[objectIndex].pos.x = gObjectList[objectIndex].offset[0] + temp_f0;
|
||||
gObjectList[objectIndex].pos.y = gObjectList[objectIndex].offset[1] + temp_f0;
|
||||
gObjectList[objectIndex].pos.z = gObjectList[objectIndex].offset[2] + temp_f0;
|
||||
}
|
||||
|
||||
void set_obj_direction_angle(s32 objectIndex, u16 arg1, u16 arg2, u16 arg3) {
|
||||
@@ -1841,9 +1841,9 @@ void set_obj_orientation(s32 objectIndex, u16 arg1, u16 arg2, u16 arg3) {
|
||||
}
|
||||
|
||||
void set_obj_velocity(s32 objectIndex, f32 arg1, f32 arg2, f32 arg3) {
|
||||
gObjectList[objectIndex].velocity[0] = arg1;
|
||||
gObjectList[objectIndex].velocity[1] = arg2;
|
||||
gObjectList[objectIndex].velocity[2] = arg3;
|
||||
gObjectList[objectIndex].velocity.x = arg1;
|
||||
gObjectList[objectIndex].velocity.y = arg2;
|
||||
gObjectList[objectIndex].velocity.z = arg3;
|
||||
}
|
||||
|
||||
void func_8008B928(s32 objectIndex, s16 arg1, s16 arg2, s16 arg3, SplineData* spline) {
|
||||
@@ -1854,11 +1854,11 @@ void func_8008B928(s32 objectIndex, s16 arg1, s16 arg2, s16 arg3, SplineData* sp
|
||||
object->origin_pos[1] = (f32) arg2;
|
||||
object->spline = spline;
|
||||
object->origin_pos[2] = (f32) arg3;
|
||||
object->velocity[0] = (f32) (spline->controlPoints[1].pos[0] - spline->controlPoints[0].pos[0]);
|
||||
object->velocity[1] = (f32) (spline->controlPoints[1].pos[1] - spline->controlPoints[0].pos[1]);
|
||||
object->velocity[2] = (f32) (spline->controlPoints[1].pos[2] - spline->controlPoints[0].pos[2]);
|
||||
object->velocity.x = (f32) (spline->controlPoints[1].pos.x - spline->controlPoints[0].pos.x);
|
||||
object->velocity.y = (f32) (spline->controlPoints[1].pos.y - spline->controlPoints[0].pos.y);
|
||||
object->velocity.z = (f32) (spline->controlPoints[1].pos.z - spline->controlPoints[0].pos.z);
|
||||
object->direction_angle[1] = get_y_direction_angle(objectIndex);
|
||||
object->velocity[2] = func_800416D8(object->velocity[2], object->velocity[0], -object->direction_angle[1]);
|
||||
object->velocity.z = func_800416D8(object->velocity.z, object->velocity.x, -object->direction_angle[1]);
|
||||
object->direction_angle[0] = get_x_direction_angle(objectIndex);
|
||||
}
|
||||
|
||||
@@ -1917,8 +1917,8 @@ void object_origin_pos_randomize_around_xyz(s32 objectIndex, s16 x, s16 y, s16 z
|
||||
}
|
||||
|
||||
void object_origin_pos_around_player_one(s32 objectIndex, s16 dist, u16 angle) {
|
||||
gObjectList[objectIndex].origin_pos[0] = gPlayerOneCopy->pos[0] + (sins(angle) * dist);
|
||||
gObjectList[objectIndex].origin_pos[2] = gPlayerOneCopy->pos[2] + (coss(angle) * dist);
|
||||
gObjectList[objectIndex].origin_pos[0] = gPlayerOneCopy->pos.x + (sins(angle) * dist);
|
||||
gObjectList[objectIndex].origin_pos[2] = gPlayerOneCopy->pos.z + (coss(angle) * dist);
|
||||
}
|
||||
|
||||
UNUSED void func_8008BEA4(s32 objectIndex, u16 arg1, u16 arg2) {
|
||||
@@ -1926,31 +1926,31 @@ UNUSED void func_8008BEA4(s32 objectIndex, u16 arg1, u16 arg2) {
|
||||
u16 thing2;
|
||||
|
||||
thing = random_int(arg1);
|
||||
thing2 = camera1->rot[1] + random_int(arg2) - ((s32) arg2 / 2);
|
||||
thing2 = camera1->rot.y + random_int(arg2) - ((s32) arg2 / 2);
|
||||
object_origin_pos_around_player_one(objectIndex, thing, thing2);
|
||||
}
|
||||
|
||||
void object_calculate_new_pos_offset(s32 objectIndex) {
|
||||
gObjectList[objectIndex].pos[0] = gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0];
|
||||
gObjectList[objectIndex].pos[1] = gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
|
||||
gObjectList[objectIndex].pos[2] = gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2];
|
||||
gObjectList[objectIndex].pos.x = gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0];
|
||||
gObjectList[objectIndex].pos.y = gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
|
||||
gObjectList[objectIndex].pos.z = gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2];
|
||||
}
|
||||
|
||||
void func_8008BF64(s32 objectIndex) {
|
||||
Object* object;
|
||||
|
||||
object = &gObjectList[objectIndex];
|
||||
D_80183E40[0] = object->pos[0];
|
||||
D_80183E40[1] = object->pos[1];
|
||||
D_80183E40[2] = object->pos[2];
|
||||
D_80183E40[0] = object->pos.x;
|
||||
D_80183E40[1] = object->pos.y;
|
||||
D_80183E40[2] = object->pos.z;
|
||||
D_80183E80[0] = object->direction_angle[0];
|
||||
D_80183E80[1] = object->direction_angle[1];
|
||||
D_80183E80[2] = object->direction_angle[2];
|
||||
}
|
||||
|
||||
void func_8008BFC0(s32 objectIndex) {
|
||||
gObjectList[objectIndex].unk_09C = gObjectList[objectIndex].pos[0];
|
||||
gObjectList[objectIndex].unk_09E = gObjectList[objectIndex].pos[1];
|
||||
gObjectList[objectIndex].unk_09C = gObjectList[objectIndex].pos.x;
|
||||
gObjectList[objectIndex].unk_09E = gObjectList[objectIndex].pos.y;
|
||||
}
|
||||
|
||||
void func_8008BFFC(s32 objectIndex) {
|
||||
|
||||
+13
-13
@@ -43,18 +43,18 @@ UNUSED void func_800914E0(void) {
|
||||
}
|
||||
tempData = sp48 + D_80152308;
|
||||
|
||||
camera->pos[0] = (f32) (tempData->pos[0] + 10);
|
||||
camera->pos[1] = (f32) (tempData->pos[1] + 7);
|
||||
camera->pos[2] = (f32) (tempData->pos[2] - 20);
|
||||
camera->lookAt[0] = gPlayerOneCopy->pos[0];
|
||||
camera->pos.x = (f32) (tempData->pos.x + 10);
|
||||
camera->pos.y = (f32) (tempData->pos.y + 7);
|
||||
camera->pos.z = (f32) (tempData->pos.z - 20);
|
||||
camera->lookAt.x = gPlayerOneCopy->pos.x;
|
||||
|
||||
camera->lookAt[1] = gPlayerOneCopy->pos[1];
|
||||
camera->lookAt[2] = gPlayerOneCopy->pos[2];
|
||||
check_bounding_collision(&camera->collision, 20.0f, camera->pos[0], camera->pos[1], camera->pos[2]);
|
||||
sp38 = camera->lookAt[0] - camera->pos[0];
|
||||
sp34 = camera->lookAt[1] - camera->pos[1];
|
||||
sp30 = camera->lookAt[2] - camera->pos[2];
|
||||
camera->rot[1] = atan2s(sp38, sp30);
|
||||
camera->rot[0] = atan2s(sqrtf((sp38 * sp38) + (sp30 * sp30)), sp34);
|
||||
camera->rot[2] = 0;
|
||||
camera->lookAt.y = gPlayerOneCopy->pos.y;
|
||||
camera->lookAt.z = gPlayerOneCopy->pos.z;
|
||||
check_bounding_collision(&camera->collision, 20.0f, camera->pos.x, camera->pos.y, camera->pos.z);
|
||||
sp38 = camera->lookAt.x - camera->pos.x;
|
||||
sp34 = camera->lookAt.y - camera->pos.y;
|
||||
sp30 = camera->lookAt.z - camera->pos.z;
|
||||
camera->rot.y = atan2s(sp38, sp30);
|
||||
camera->rot.x = atan2s(sqrtf((sp38 * sp38) + (sp30 * sp30)), sp34);
|
||||
camera->rot.z = 0;
|
||||
}
|
||||
|
||||
@@ -14,9 +14,9 @@ variableWatchAttributes gMainVariableWatchList[] = {
|
||||
{ "Global Timer: ", &gGlobalTimer, sizeof(gGlobalTimer), DISPLAY_DECIMAL_NUMBER | DISPLAY_SIGNED_NUMBER, 0, 0 },
|
||||
{ "Actors: ", &gNumActors, sizeof(gNumActors), DISPLAY_DECIMAL_NUMBER, 0, 0 },
|
||||
{ "Player Type: ", &gPlayers[0].type, sizeof(gPlayerOne->type), DISPLAY_HEXIDECIMAL_NUMBER, 0, 0 },
|
||||
{ "X ", &gPlayers[0].pos[0], sizeof(gPlayerOne->pos[0]), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "Y ", &gPlayers[0].pos[1], sizeof(gPlayerOne->pos[1]), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "Z ", &gPlayers[0].pos[2], sizeof(gPlayerOne->pos[2]), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "X ", &gPlayers[0].pos.x, sizeof(gPlayerOne->pos.x), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "Y ", &gPlayers[0].pos.y, sizeof(gPlayerOne->pos.y), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "Z ", &gPlayers[0].pos.z, sizeof(gPlayerOne->pos.z), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "Torque 9C: ", &gPlayers[0].currentSpeed, sizeof(gPlayerOne->currentSpeed), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "Top Speed 214: ", &gPlayers[0].topSpeed, sizeof(gPlayerOne->topSpeed), DISPLAY_FLOAT_NUMBER, 0, 0 },
|
||||
{ "Accel Offset C4: ", &gPlayers[0].slopeAccel, sizeof(gPlayerOne->slopeAccel), DISPLAY_SIGNED_NUMBER, 0, 0 },
|
||||
|
||||
+26
-26
@@ -762,7 +762,7 @@ void apply_hit_effect(Player* player, s8 arg1) {
|
||||
break;
|
||||
case 1:
|
||||
player->unk_DB4.unk10 = 4.5f;
|
||||
player->pos[1] += 0.13;
|
||||
player->pos.y += 0.13;
|
||||
++player->unk_238;
|
||||
|
||||
if ((player->unk_046 & 0x80) != 0) {
|
||||
@@ -799,7 +799,7 @@ void apply_hit_effect(Player* player, s8 arg1) {
|
||||
}
|
||||
|
||||
player->unk_DB4.unk10 = 4.5f;
|
||||
player->pos[1] -= 0.085;
|
||||
player->pos.y -= 0.085;
|
||||
|
||||
if ((player->effects & 8) != 8) {
|
||||
D_8018D990[arg1] = 3;
|
||||
@@ -940,8 +940,8 @@ void func_8008E4A4(Player* player, s8 arg1) {
|
||||
player->unk_042 += 0xAAA;
|
||||
player->unk_08C = 0.0f;
|
||||
player->currentSpeed = 0.0f;
|
||||
player->velocity[0] = 0.0f;
|
||||
player->velocity[2] = 0.0f;
|
||||
player->velocity.x = 0.0f;
|
||||
player->velocity.z = 0.0f;
|
||||
player->effects &= ~0xC0;
|
||||
|
||||
if ((player->effects & 8) != 8) {
|
||||
@@ -1837,18 +1837,18 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
|
||||
player->unk_0C8 = 0x003C;
|
||||
}
|
||||
} else {
|
||||
move_f32_towards(&player->pos[1], D_801652A0[playerId] + 100.0f, 0.012f);
|
||||
move_f32_towards(&player->pos.y, D_801652A0[playerId] + 100.0f, 0.012f);
|
||||
move_s16_towards(&player->unk_0CC[arg2], 0, 0.2f);
|
||||
if ((D_801652A0[playerId] + 40.0f) <= player->pos[1]) {
|
||||
if ((D_801652A0[playerId] + 40.0f) <= player->pos.y) {
|
||||
player->unk_222 = 1;
|
||||
player->unk_0CA |= 4;
|
||||
player->unk_0C6 = 0x00FF;
|
||||
}
|
||||
}
|
||||
} else if ((player->unk_0CA & 2) == 2) {
|
||||
move_f32_towards(&player->pos[1], player->unk_074 + 100.0f, 0.025f);
|
||||
move_f32_towards(&player->pos.y, player->unk_074 + 100.0f, 0.025f);
|
||||
move_s16_towards(&player->unk_0CC[arg2], 0, 0.2f);
|
||||
if ((player->unk_074 + 40.0f) <= player->pos[1]) {
|
||||
if ((player->unk_074 + 40.0f) <= player->pos.y) {
|
||||
player->unk_222 = 1;
|
||||
player->unk_0CA |= 4;
|
||||
player->unk_0C6 = 0x00FF;
|
||||
@@ -1863,7 +1863,7 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
|
||||
func_8009E088(playerId, 0xA);
|
||||
}
|
||||
if ((player->unk_0CA & 1) == 1) {
|
||||
move_f32_towards(&player->pos[1], D_801652A0[playerId] + 40.0f, 0.02f);
|
||||
move_f32_towards(&player->pos.y, D_801652A0[playerId] + 40.0f, 0.02f);
|
||||
player->unk_0C6 -= 8;
|
||||
if (player->unk_0C6 < 9) {
|
||||
player->unk_0C6 = 0;
|
||||
@@ -1871,7 +1871,7 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
|
||||
player->unk_0CA &= ~0x0001;
|
||||
}
|
||||
} else {
|
||||
move_f32_towards(&player->pos[1], player->oldPos[1] + 40.0f, 0.02f);
|
||||
move_f32_towards(&player->pos.y, player->oldPos[1] + 40.0f, 0.02f);
|
||||
player->unk_0C6 -= 8;
|
||||
if (player->unk_0C6 < 9) {
|
||||
player->unk_0C6 = 0;
|
||||
@@ -1884,9 +1884,9 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
|
||||
func_80090178(player, playerId, sp44, sp38);
|
||||
// Fakematch found by Verti, who knows what's going on here
|
||||
player->rotation[1] = (u16) -get_angle_between_two_vectors(sp44, sp38) & 0xFFFF;
|
||||
player->pos[0] = sp44[0];
|
||||
player->pos[1] = sp44[1] + 40.0f;
|
||||
player->pos[2] = sp44[2];
|
||||
player->pos.x = sp44[0];
|
||||
player->pos.y = sp44[1] + 40.0f;
|
||||
player->pos.z = sp44[2];
|
||||
player->unk_222 = 3;
|
||||
break;
|
||||
case 3:
|
||||
@@ -1895,11 +1895,11 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
|
||||
func_8009E020(playerId, 0x14);
|
||||
}
|
||||
func_80090178(player, playerId, sp44, sp38);
|
||||
player->pos[0] = sp44[0];
|
||||
player->pos[1] = sp44[1] + 40.0f;
|
||||
player->pos[2] = sp44[2];
|
||||
player->pos[2] = player->pos[2] + coss((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
|
||||
player->pos[0] = player->pos[0] + sins((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
|
||||
player->pos.x = sp44[0];
|
||||
player->pos.y = sp44[1] + 40.0f;
|
||||
player->pos.z = sp44[2];
|
||||
player->pos.z = player->pos.z + coss((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
|
||||
player->pos.x = player->pos.x + sins((playerId * 0x1C70) - player->rotation[1]) * -5.0f;
|
||||
player->unk_0C6 += 8;
|
||||
if (player->unk_0C6 >= 0xF0) {
|
||||
player->unk_0C6 = 0x00FF;
|
||||
@@ -1910,16 +1910,16 @@ void func_80090970(Player* player, s8 playerId, s8 arg2) {
|
||||
break;
|
||||
case 4:
|
||||
if ((player->unk_0C8 == 0x0096) || (player->unk_0C8 == 0x00C8) || (player->unk_0C8 == 0x00FA)) {
|
||||
player->pos[2] = player->pos[2] + coss(-player->rotation[1]) * -10.0f;
|
||||
player->pos[0] = player->pos[0] + sins(-player->rotation[1]) * -10.0f;
|
||||
player->pos.z = player->pos.z + coss(-player->rotation[1]) * -10.0f;
|
||||
player->pos.x = player->pos.x + sins(-player->rotation[1]) * -10.0f;
|
||||
}
|
||||
if (player->unk_0C8 == 0x00FC) {
|
||||
waypoint = D_80164550[0];
|
||||
player->pos[0] = waypoint->posX;
|
||||
player->pos[1] = waypoint->posY;
|
||||
player->pos[2] = waypoint->posZ;
|
||||
player->pos.x = waypoint->posX;
|
||||
player->pos.y = waypoint->posY;
|
||||
player->pos.z = waypoint->posZ;
|
||||
}
|
||||
move_f32_towards(&player->pos[1], (player->unk_074 + player->boundingBoxSize) - 2.0f, 0.04f);
|
||||
move_f32_towards(&player->pos.y, (player->unk_074 + player->boundingBoxSize) - 2.0f, 0.04f);
|
||||
player->unk_0C8++;
|
||||
if (((player->effects & 8) != 8) || (player->effects & 0x8000)) {
|
||||
player->unk_0CA &= ~0x1000;
|
||||
@@ -2062,8 +2062,8 @@ void func_80091298(Player* player, s8 arg1) {
|
||||
player->unk_0B2 = 0;
|
||||
}
|
||||
if (player->unk_0B2 == 0) {
|
||||
if ((player->pos[1] - (player->boundingBoxSize + 1.0f)) <= spC[arg1]) {
|
||||
player->pos[1] = (f32) ((f64) (spC[arg1] + player->boundingBoxSize) + 1.08);
|
||||
if ((player->pos.y - (player->boundingBoxSize + 1.0f)) <= spC[arg1]) {
|
||||
player->pos.y = (f32) ((f64) (spC[arg1] + player->boundingBoxSize) + 1.08);
|
||||
player->unk_DB4.unk18 = 0;
|
||||
player->unk_0A8 = 0;
|
||||
player->unk_07C = 0;
|
||||
|
||||
+15
-15
@@ -17,25 +17,25 @@ void update_camera_podium_ceremony(void) {
|
||||
camera = &cameras[0];
|
||||
func_80283648(camera);
|
||||
|
||||
x_dist = camera->lookAt[0] - camera->pos[0];
|
||||
y_dist = camera->lookAt[1] - camera->pos[1];
|
||||
z_dist = camera->lookAt[2] - camera->pos[2];
|
||||
camera->rot[1] = atan2s(x_dist, z_dist);
|
||||
camera->rot[0] = atan2s(sqrtf((x_dist * x_dist) + (z_dist * z_dist)), y_dist);
|
||||
camera->rot[2] = 0;
|
||||
x_dist = camera->lookAt.x - camera->pos.x;
|
||||
y_dist = camera->lookAt.y - camera->pos.y;
|
||||
z_dist = camera->lookAt.z - camera->pos.z;
|
||||
camera->rot.x = atan2s(x_dist, z_dist);
|
||||
camera->rot.y = atan2s(sqrtf((x_dist * x_dist) + (z_dist * z_dist)), y_dist);
|
||||
camera->rot.z = 0;
|
||||
}
|
||||
|
||||
// GP podium ceremony camera settings?
|
||||
void init_camera_podium_ceremony(void) {
|
||||
cameras[0].pos[0] = -3133.0f;
|
||||
cameras[0].pos[1] = 19.0f;
|
||||
cameras[0].pos[2] = -467.0f;
|
||||
cameras[0].lookAt[0] = -3478.0f;
|
||||
cameras[0].lookAt[1] = 21.0f;
|
||||
cameras[0].lookAt[2] = -528.0f;
|
||||
cameras[0].up[0] = 0.0f;
|
||||
cameras[0].up[1] = 1.0f;
|
||||
cameras[0].up[2] = 0.0f;
|
||||
cameras[0].pos.x = -3133.0f;
|
||||
cameras[0].pos.y = 19.0f;
|
||||
cameras[0].pos.z = -467.0f;
|
||||
cameras[0].lookAt.x = -3478.0f;
|
||||
cameras[0].lookAt.y = 21.0f;
|
||||
cameras[0].lookAt.z = -528.0f;
|
||||
cameras[0].up.x = 0.0f;
|
||||
cameras[0].up.y = 1.0f;
|
||||
cameras[0].up.z = 0.0f;
|
||||
gCameraZoom[0] = 40.0f;
|
||||
gScreenAspect = 1.33333333f;
|
||||
D_80150150 = 3.0f;
|
||||
|
||||
@@ -427,8 +427,8 @@ void func_80282F44(s32 arg0, CinematicCamera* arg1, Camera* camera) {
|
||||
Vec3f pos;
|
||||
Vec3f lookat;
|
||||
|
||||
vec3f_set_dupe(pos, camera->pos[0], camera->pos[1], camera->pos[2]);
|
||||
vec3f_set_dupe(lookat, camera->lookAt[0], camera->lookAt[1], camera->lookAt[2]);
|
||||
vec3f_set_dupe(pos, camera->pos.x, camera->pos.y, camera->pos.z);
|
||||
vec3f_set_dupe(lookat, camera->lookAt.x, camera->lookAt.y, camera->lookAt.z);
|
||||
if ((arg0 == 0) || (arg0 == 1)) {
|
||||
if ((arg1->unk48[0] != 0) || (arg1->unk48[1] != 0)) {
|
||||
calculate_distance_angle_y_and_angle_y_to_xz(pos, lookat, &distance, &angleCam[0], &angleCam[1]);
|
||||
@@ -441,9 +441,9 @@ void func_80282F44(s32 arg0, CinematicCamera* arg1, Camera* camera) {
|
||||
arg1->unk4E[arg0] = 0;
|
||||
}
|
||||
}
|
||||
camera->lookAt[0] = lookat[0];
|
||||
camera->lookAt[1] = lookat[1];
|
||||
camera->lookAt[2] = lookat[2];
|
||||
camera->lookAt.x = lookat[0];
|
||||
camera->lookAt.y = lookat[1];
|
||||
camera->lookAt.z = lookat[2];
|
||||
}
|
||||
}
|
||||
|
||||
@@ -627,8 +627,8 @@ s32 func_80283648(Camera* camera) {
|
||||
vec3f_copy_return_dupe(camera->pos, cinematicCamera->lookAt);
|
||||
vec3f_copy_return_dupe(camera->lookAt, cinematicCamera->pos);
|
||||
if ((gGamestate == CREDITS_SEQUENCE) && (gIsMirrorMode != 0)) {
|
||||
camera->pos[0] = -camera->pos[0];
|
||||
camera->lookAt[0] = -camera->lookAt[0];
|
||||
camera->pos.x = -camera->pos.x;
|
||||
camera->lookAt.x = -camera->lookAt.x;
|
||||
}
|
||||
}
|
||||
func_80282F44(0, cinematicCamera, camera);
|
||||
@@ -947,9 +947,9 @@ void copy_player_two_in_camera(CinematicCamera* camera) {
|
||||
}
|
||||
|
||||
void lerp_player_two_in_camera(CinematicCamera* camera) {
|
||||
f32_lerp(&camera->pos[0], gPlayerTwo->pos[0], 0.12f);
|
||||
f32_lerp(&camera->pos[1], gPlayerTwo->pos[1], 0.12f);
|
||||
f32_lerp(&camera->pos[2], gPlayerTwo->pos[2], 0.12f);
|
||||
f32_lerp(&camera->pos.x, gPlayerTwo->pos.x, 0.12f);
|
||||
f32_lerp(&camera->pos.y, gPlayerTwo->pos.y, 0.12f);
|
||||
f32_lerp(&camera->pos.z, gPlayerTwo->pos.z, 0.12f);
|
||||
}
|
||||
|
||||
void func_80283F6C(CinematicCamera* camera) {
|
||||
@@ -963,9 +963,9 @@ void copy_player_three_in_camera(CinematicCamera* camera) {
|
||||
}
|
||||
|
||||
void lerp_player_three_in_camera(CinematicCamera* camera) {
|
||||
f32_lerp(&camera->pos[0], gPlayerThree->pos[0], 0.12f);
|
||||
f32_lerp(&camera->pos[1], gPlayerThree->pos[1], 0.12f);
|
||||
f32_lerp(&camera->pos[2], gPlayerThree->pos[2], 0.12f);
|
||||
f32_lerp(&camera->pos.x, gPlayerThree->pos.x, 0.12f);
|
||||
f32_lerp(&camera->pos.y, gPlayerThree->pos.y, 0.12f);
|
||||
f32_lerp(&camera->pos.z, gPlayerThree->pos.z, 0.12f);
|
||||
}
|
||||
|
||||
void func_80284068(CinematicCamera* camera) {
|
||||
@@ -999,8 +999,8 @@ void func_80284184(CinematicCamera* camera) {
|
||||
f32 trophy;
|
||||
|
||||
if (gTrophyIndex != NULL) {
|
||||
trophy = ((gObjectList[gTrophyIndex].pos[1] - camera->lookAt[1]) * 0.9f) + camera->lookAt[1];
|
||||
f32_lerp(&camera->pos[1], trophy, 0.5);
|
||||
trophy = ((gObjectList[gTrophyIndex].pos.y - camera->lookAt.y) * 0.9f) + camera->lookAt.y;
|
||||
f32_lerp(&camera->pos.y, trophy, 0.5);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1039,16 +1039,16 @@ void func_80284308(CinematicCamera* camera) {
|
||||
|
||||
ply = *(sp30[0] + D_802874D8.unk1D);
|
||||
|
||||
x = ply->pos[0] - gPlayerOne->pos[0];
|
||||
y = ply->pos[1] - gPlayerOne->pos[1];
|
||||
z = ply->pos[2] - gPlayerOne->pos[2];
|
||||
x = ply->pos.x - gPlayerOne->pos.x;
|
||||
y = ply->pos.y - gPlayerOne->pos.y;
|
||||
z = ply->pos.z - gPlayerOne->pos.z;
|
||||
|
||||
camera->lookAt[0] += x;
|
||||
camera->lookAt[2] += z;
|
||||
camera->pos[0] += x;
|
||||
camera->pos[2] += z;
|
||||
camera->lookAt[1] += y;
|
||||
camera->pos[1] += y;
|
||||
camera->lookAt.x += x;
|
||||
camera->lookAt.z += z;
|
||||
camera->pos.x += x;
|
||||
camera->pos.z += z;
|
||||
camera->lookAt.y += y;
|
||||
camera->pos.y += y;
|
||||
}
|
||||
|
||||
struct struct_80282C40 D_80285A10[] = {
|
||||
@@ -1225,12 +1225,12 @@ void func_802846E4(CinematicCamera* camera) {
|
||||
|
||||
move_cinematic_camera_along_spline(camera, (struct struct_80286A04*) D_80285CB0,
|
||||
(struct struct_80286A04*) D_80285CE0, 0);
|
||||
camera->lookAt[0] += (gPlayerFour->pos[0] - -2796.0f); // <-- rodata
|
||||
camera->lookAt[1] += (gPlayerFour->pos[1] - -29.0f);
|
||||
camera->lookAt[2] += (gPlayerFour->pos[2] - -97.0f);
|
||||
camera->pos[0] += (gPlayerFour->pos[0] - -2796.0f);
|
||||
camera->pos[1] += (gPlayerFour->pos[1] - -29.0f);
|
||||
camera->pos[2] += (gPlayerFour->pos[2] - -97.0f);
|
||||
camera->lookAt.x += (gPlayerFour->pos.x - -2796.0f); // <-- rodata
|
||||
camera->lookAt.y += (gPlayerFour->pos.y - -29.0f);
|
||||
camera->lookAt.z += (gPlayerFour->pos.z - -97.0f);
|
||||
camera->pos.x += (gPlayerFour->pos.x - -2796.0f);
|
||||
camera->pos.y += (gPlayerFour->pos.y - -29.0f);
|
||||
camera->pos.z += (gPlayerFour->pos.z - -97.0f);
|
||||
}
|
||||
|
||||
struct Cutscene D_80285D58[] = {
|
||||
|
||||
+14
-14
@@ -61,8 +61,8 @@ void func_80280038(void) {
|
||||
gSPPerspNormalize(gDisplayListHead++, perspNorm);
|
||||
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxPersp[0]),
|
||||
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
|
||||
guLookAt(&gGfxPool->mtxLookAt[0], camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0],
|
||||
camera->lookAt[1], camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
|
||||
guLookAt(&gGfxPool->mtxLookAt[0], camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x,
|
||||
camera->lookAt.y, camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
|
||||
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxLookAt[0]),
|
||||
G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
|
||||
gCurrentCourseId = gCreditsCourseId;
|
||||
@@ -110,12 +110,12 @@ void credits_loop(void) {
|
||||
|
||||
D_802874FC = 0;
|
||||
func_80283648(camera);
|
||||
temp_f12 = camera->lookAt[0] - camera->pos[0];
|
||||
temp = camera->lookAt[1] - camera->pos[1];
|
||||
temp_f14 = camera->lookAt[2] - camera->pos[2];
|
||||
camera->rot[1] = atan2s(temp_f12, temp_f14);
|
||||
camera->rot[0] = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), temp);
|
||||
camera->rot[2] = 0;
|
||||
temp_f12 = camera->lookAt.x - camera->pos.x;
|
||||
temp = camera->lookAt.y - camera->pos.y;
|
||||
temp_f14 = camera->lookAt.z - camera->pos.z;
|
||||
camera->rot.y = atan2s(temp_f12, temp_f14);
|
||||
camera->rot.x = atan2s(sqrtf((temp_f12 * temp_f12) + (temp_f14 * temp_f14)), temp);
|
||||
camera->rot.z = 0;
|
||||
if (D_802874A0 != 0) {
|
||||
D_800DC5E4++;
|
||||
} else {
|
||||
@@ -168,12 +168,12 @@ void load_credits(void) {
|
||||
D_800DC5BC = 0;
|
||||
D_800DC5C8 = 0;
|
||||
gCollisionMesh = (CollisionTriangle*) gNextFreeMemoryAddress;
|
||||
camera->pos[0] = 1400.0f;
|
||||
camera->pos[1] = 300.0f;
|
||||
camera->pos[2] = 1400.0f;
|
||||
camera->lookAt[0] = 0.0f;
|
||||
camera->lookAt[1] = 0.0f;
|
||||
camera->lookAt[2] = 0.0f;
|
||||
camera->pos.x = 1400.0f;
|
||||
camera->pos.y = 300.0f;
|
||||
camera->pos.z = 1400.0f;
|
||||
camera->lookAt.x = 0.0f;
|
||||
camera->lookAt.y = 0.0f;
|
||||
camera->lookAt.z = 0.0f;
|
||||
camera->up[0] = 0.0f;
|
||||
camera->up[1] = 1.0f;
|
||||
camera->up[2] = 0.0f;
|
||||
|
||||
@@ -77,8 +77,8 @@ void func_80281D00(void) {
|
||||
gSPPerspNormalize(gDisplayListHead++, perspNorm);
|
||||
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxPersp[0]),
|
||||
G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
|
||||
guLookAt((Mtx*) &gGfxPool->mtxLookAt[0], camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0],
|
||||
camera->lookAt[1], camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
|
||||
guLookAt((Mtx*) &gGfxPool->mtxLookAt[0], camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x,
|
||||
camera->lookAt.y, camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
|
||||
gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxLookAt[0]),
|
||||
G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
|
||||
mtxf_identity(matrix);
|
||||
|
||||
@@ -83,9 +83,9 @@ void func_80280650(void) {
|
||||
void set_initial_position(CeremonyActor* actor) {
|
||||
ActorInitParams* params = actor->initParams;
|
||||
|
||||
actor->pos[0] = params->unk2[0];
|
||||
actor->pos[1] = params->unk2[1];
|
||||
actor->pos[2] = params->unk2[2];
|
||||
actor->pos.x = params->unk2[0];
|
||||
actor->pos.y = params->unk2[1];
|
||||
actor->pos.z = params->unk2[2];
|
||||
|
||||
// Place value in the high bits of s16.
|
||||
// Example: 85, 0b01010101 -> 0b0101010100000000
|
||||
@@ -174,7 +174,7 @@ void func_80280884(void) {
|
||||
|
||||
void balloon_update(CeremonyActor* actor) {
|
||||
render_balloon(actor->pos, 1.0f, actor->unk2E, actor->unk2C);
|
||||
actor->pos[1] += 0.8f;
|
||||
actor->pos.y += 0.8f;
|
||||
actor->unk2E = sins(actor->unk30) * actor->unk34;
|
||||
actor->unk30 += actor->unk32;
|
||||
actor->timer++;
|
||||
@@ -194,14 +194,14 @@ void balloon_update(CeremonyActor* actor) {
|
||||
*/
|
||||
void firework_cone_update_and_spawn_burst(Firework* cone) {
|
||||
if (cone->unk44 < 30) {
|
||||
cone->pos[1] += 2.5f;
|
||||
cone->pos[0] += random_who_knows(0.2f);
|
||||
cone->pos[2] += random_who_knows(0.2f);
|
||||
cone->pos.y += 2.5f;
|
||||
cone->pos.x += random_who_knows(0.2f);
|
||||
cone->pos.z += random_who_knows(0.2f);
|
||||
} else if (cone->unk2C == 4) {
|
||||
Firework* burst = (Firework*) new_actor(&initCone);
|
||||
burst->pos[0] = cone->pos[0];
|
||||
burst->pos[1] = cone->pos[1];
|
||||
burst->pos[2] = cone->pos[2];
|
||||
burst->pos.x = cone->pos.x;
|
||||
burst->pos.y = cone->pos.y;
|
||||
burst->pos.z = cone->pos.z;
|
||||
burst->unk30 = fireworkConeColour[cone->unk48];
|
||||
burst->unk3C = 0xFF;
|
||||
burst->unk40 = -0x11;
|
||||
@@ -243,7 +243,7 @@ void render_fireworks(Vec3f arg0, f32 arg1, s32 rgb, s16 alpha) {
|
||||
sp4C[1] = arg0[1];
|
||||
sp4C[2] = arg0[2];
|
||||
sp44[0] = 0;
|
||||
sp44[1] = camera1->rot[1];
|
||||
sp44[1] = camera1->rot.y;
|
||||
sp44[2] = 0;
|
||||
func_80280A28(sp4C, sp44, arg1);
|
||||
gSPDisplayList(gDisplayListHead++, D_0D008DB8);
|
||||
@@ -264,9 +264,9 @@ void firework_update(Firework* actor) {
|
||||
Vec3f pos;
|
||||
if (actor->unk44 < 30) {
|
||||
for (i = 0; i < 10; i++) {
|
||||
pos[0] = actor->pos[0];
|
||||
pos[1] = actor->pos[1] - i * 2;
|
||||
pos[2] = actor->pos[2];
|
||||
pos.x = actor->pos.x;
|
||||
pos.y = actor->pos.y - i * 2;
|
||||
pos.z = actor->pos.z;
|
||||
render_fireworks(pos, ((10 - i) / 10.0f) * 2, fireworkColour[actor->unk48],
|
||||
(((((30 - actor->unk44) * 100)) / 30.0f)));
|
||||
}
|
||||
@@ -322,9 +322,9 @@ void spawn_balloons(s32 arg0, s32 arg1, s32 arg2) {
|
||||
for (i = 0; i < 100; i++) {
|
||||
CeremonyActor* balloon;
|
||||
balloon = new_actor(&initBalloon);
|
||||
balloon->pos[0] = random_who_knows(200.0f) + arg0;
|
||||
balloon->pos[1] = random_who_knows(380.0f) + arg1;
|
||||
balloon->pos[2] = random_who_knows(600.0f) + arg2;
|
||||
balloon->pos.x = random_who_knows(200.0f) + arg0;
|
||||
balloon->pos.y = random_who_knows(380.0f) + arg1;
|
||||
balloon->pos.z = random_who_knows(600.0f) + arg2;
|
||||
balloon->unk2C = (s16) (s32) (random_float_between_0_and_1() * 7.0f);
|
||||
balloon->unk30 = random_u16_credits();
|
||||
balloon->unk32 = (s16) (s32) (random_who_knows(400.0f) + 900.0f);
|
||||
@@ -349,9 +349,9 @@ void spawn_firework_cone(s32 arg0, s32 arg1, s32 arg2) {
|
||||
if (((f32) random_float_between_0_and_1() * (D_802874B0[7] + 0xD)) < 1.0f) {
|
||||
Firework* cone;
|
||||
cone = (Firework*) new_actor(&initBurst);
|
||||
cone->pos[0] = random_who_knows(0.0f) + arg0;
|
||||
cone->pos[1] = random_who_knows((f32) (D_802874B0[11] + 100)) + (f32) arg1;
|
||||
cone->pos[2] = random_who_knows((f32) (D_802874B0[12] + 700)) + (f32) arg2;
|
||||
cone->pos.x = random_who_knows(0.0f) + arg0;
|
||||
cone->pos.y = random_who_knows((f32) (D_802874B0[11] + 100)) + (f32) arg1;
|
||||
cone->pos.z = random_who_knows((f32) (D_802874B0[12] + 700)) + (f32) arg2;
|
||||
|
||||
num = 1.1f;
|
||||
|
||||
@@ -377,12 +377,12 @@ void spawn_timer(void) {
|
||||
Camera* camera = &cameras[0];
|
||||
f32 lookAtY;
|
||||
|
||||
guLookAtF(D_80287500, camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0], camera->lookAt[1],
|
||||
camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
|
||||
guLookAtF(D_80287500, camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x, camera->lookAt.y,
|
||||
camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
|
||||
if (D_802874D8.unk1D < 3) {
|
||||
if (D_802874D8.actorTimer < 300) {
|
||||
lookAtY = camera->lookAt[1];
|
||||
spawn_firework_cone(-0xE0E, (s32) (((lookAtY - camera->pos[1]) * 1.5f) + lookAtY), -0x258);
|
||||
lookAtY = camera->lookAt.y;
|
||||
spawn_firework_cone(-0xE0E, (s32) (((lookAtY - camera->pos.y) * 1.5f) + lookAtY), -0x258);
|
||||
}
|
||||
if (D_802874D8.actorTimer == 120) {
|
||||
spawn_balloons(-0xC6C, (s32) ((f32) D_802874B0[10] + 210.0f), -0x1EF);
|
||||
|
||||
@@ -14,9 +14,9 @@ extern "C" {
|
||||
void PlayerBombKart::Draw(size_t playerId, s32 cameraId) { // render_player_bomb_kart
|
||||
Player* player = &gPlayerOne[playerId];
|
||||
if (state != PlayerBombKartState::DISABLED) {
|
||||
pos.x = player->pos[0];
|
||||
pos.y = player->pos[1] - 2.0;
|
||||
pos.z = player->pos[2];
|
||||
pos.x = player->pos.x;
|
||||
pos.y = player->pos.y - 2.0;
|
||||
pos.z = player->pos.z;
|
||||
surfaceHeight = player->unk_074;
|
||||
PlayerBombKart::func_800563DC(cameraId, _primAlpha);
|
||||
PlayerBombKart::func_8005669C(_primAlpha);
|
||||
|
||||
@@ -15,9 +15,9 @@ extern "C" {
|
||||
}
|
||||
|
||||
TrainCrossing::TrainCrossing(Vec3f position, u32 waypointMin, u32 waypointMax, f32 approachRadius, f32 exitRadius) {
|
||||
Position[0] = position[0] * xOrientation;
|
||||
Position[1] = position[1];
|
||||
Position[2] = position[2];
|
||||
Position[0] = position.x * xOrientation;
|
||||
Position[1] = position.y;
|
||||
Position[2] = position.z;
|
||||
ApproachRadius = approachRadius;
|
||||
ExitRadius = exitRadius;
|
||||
WaypointMin = waypointMin;
|
||||
|
||||
@@ -30,9 +30,9 @@ void ABowserStatue::Tick() {
|
||||
void ABowserStatue::Draw(Camera *camera) {
|
||||
Mat4 mtx;
|
||||
Vec3f pos;
|
||||
pos[0] = Pos.x + 76;
|
||||
pos[1] = Pos.y;
|
||||
pos[2] = Pos.z + 1846;
|
||||
pos.x = Pos.x + 76;
|
||||
pos.y = Pos.y;
|
||||
pos.z = Pos.z + 1846;
|
||||
gSPSetGeometryMode(gDisplayListHead++, G_SHADING_SMOOTH);
|
||||
gSPClearGeometryMode(gDisplayListHead++, G_LIGHTING);
|
||||
|
||||
|
||||
@@ -60,7 +60,7 @@ void AFinishline::Draw(Camera *camera) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (temp < camera->pos[2]) {
|
||||
if (temp < camera->pos.z) {
|
||||
if (D_800DC5BC != 0) {
|
||||
|
||||
gDPSetFogColor(gDisplayListHead++, D_801625EC, D_801625F4, D_801625F0, 0xFF);
|
||||
|
||||
@@ -41,7 +41,7 @@ void AMarioSign::Draw(Camera *camera) {
|
||||
return;
|
||||
}
|
||||
|
||||
unk = is_within_render_distance(camera->pos, Pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 16000000.0f);
|
||||
unk = is_within_render_distance(camera->pos, Pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 16000000.0f);
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
unk = MAX(unk, 0.0f);
|
||||
}
|
||||
|
||||
@@ -11,9 +11,9 @@ extern "C" {
|
||||
|
||||
ATree::ATree(Vec3f pos, Gfx* displaylist, f32 drawDistance, f32 minDrawDistance, const char* tlut = nullptr) {
|
||||
Name = "Tree";
|
||||
Pos[0] = pos[0];
|
||||
Pos[1] = pos[1];
|
||||
Pos[2] = pos[2];
|
||||
Pos[0] = pos.x;
|
||||
Pos[1] = pos.y;
|
||||
Pos[2] = pos.z;
|
||||
|
||||
Displaylist = displaylist;
|
||||
Tlut = tlut;
|
||||
@@ -37,7 +37,7 @@ void ATree::Draw(Camera* camera) {
|
||||
return;
|
||||
}
|
||||
|
||||
dist = is_within_render_distance(camera->pos, Pos, camera->rot[1], 0, gCameraZoom[camera - camera1],
|
||||
dist = is_within_render_distance(camera->pos, Pos, camera->rot.y, 0, gCameraZoom[camera - camera1],
|
||||
DrawDistance);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
|
||||
@@ -25,7 +25,7 @@ void AWarioSign::Tick() {
|
||||
void AWarioSign::Draw(Camera *camera) {
|
||||
Mat4 sp38;
|
||||
f32 unk =
|
||||
is_within_render_distance(camera->pos, Pos, camera->rot[1], 0, gCameraZoom[camera - camera1], 16000000.0f);
|
||||
is_within_render_distance(camera->pos, Pos, camera->rot.y, 0, gCameraZoom[camera - camera1], 16000000.0f);
|
||||
|
||||
if (CVarGetInteger("gNoCulling", 0) == 1) {
|
||||
unk = MAX(unk, 0.0f);
|
||||
|
||||
@@ -298,13 +298,13 @@ void BansheeBoardwalk::Render(struct UnkStruct_800DC5EC* arg0) {
|
||||
// d_course_banshee_boardwalk_packed_dl_540
|
||||
gSPDisplayList(gDisplayListHead++, segmented_gfx_to_virtual(reinterpret_cast<void*>(0x07000540)));
|
||||
|
||||
if (camera->pos[1] < -20.0f) {
|
||||
if (camera->pos.y < -20.0f) {
|
||||
// d_course_banshee_boardwalk_packed_dl_6310
|
||||
gSPDisplayList(gDisplayListHead++, segmented_gfx_to_virtual(reinterpret_cast<void*>(0x07006310)));
|
||||
}
|
||||
spA8[0] = camera->pos[0];
|
||||
spA8[0] = camera->pos.x;
|
||||
spA8[1] = -82.0f;
|
||||
spA8[2] = camera->pos[2];
|
||||
spA8[2] = camera->pos.z;
|
||||
mtxf_translate(spCC, spA8);
|
||||
render_set_position(spCC, 0);
|
||||
|
||||
|
||||
@@ -243,16 +243,16 @@ void BowsersCastle::InitCourseObjects() {
|
||||
// Handle the big statue's fire breath
|
||||
objectId = indexObjectList2[0];
|
||||
init_object(objectId, 0);
|
||||
gObjectList[objectId].pos[0] = -68.0 * xOrientation;
|
||||
gObjectList[objectId].pos[1] = 80.0f;
|
||||
gObjectList[objectId].pos[2] = -1840.0f;
|
||||
gObjectList[objectId].pos.x = -68.0 * xOrientation;
|
||||
gObjectList[objectId].pos.y = 80.0f;
|
||||
gObjectList[objectId].pos.z = -1840.0f;
|
||||
// Handle the smaller statues' fire breath
|
||||
for (i = 0; i < NUM_FIRE_BREATHS; i++) {
|
||||
objectId = indexObjectList3[i];
|
||||
init_object(objectId, 0);
|
||||
gObjectList[objectId].pos[0] = gFireBreathsSpawns[i][0] * xOrientation;
|
||||
gObjectList[objectId].pos[1] = gFireBreathsSpawns[i][1];
|
||||
gObjectList[objectId].pos[2] = gFireBreathsSpawns[i][2];
|
||||
gObjectList[objectId].pos.x = gFireBreathsSpawns[i][0] * xOrientation;
|
||||
gObjectList[objectId].pos.y = gFireBreathsSpawns[i][1];
|
||||
gObjectList[objectId].pos.z = gFireBreathsSpawns[i][2];
|
||||
gObjectList[objectId].direction_angle[1] = 0;
|
||||
if (i % 2U) {
|
||||
gObjectList[objectId].direction_angle[1] += 0x8000;
|
||||
|
||||
@@ -160,12 +160,12 @@ void KalimariDesert::BeginPlay() {
|
||||
uintptr_t* crossing2 = (uintptr_t*) gWorldInstance.AddCrossing(crossingPos2, 176, 182, 900.0f, 650.0f);
|
||||
|
||||
vec3f_set(position, -1680.0f, 2.0f, 35.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
|
||||
ACTOR_RAILROAD_CROSSING));
|
||||
rrxing->crossingTrigger = crossing2;
|
||||
vec3f_set(position, -1600.0f, 2.0f, 35.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
|
||||
ACTOR_RAILROAD_CROSSING));
|
||||
rrxing->crossingTrigger = crossing2;
|
||||
@@ -173,12 +173,12 @@ void KalimariDesert::BeginPlay() {
|
||||
// Original game forgot to put gCourseDirection to face the crossing the right direction in extra mode
|
||||
vec3s_set(rotation, 0, -0x2000 * gCourseDirection, 0);
|
||||
vec3f_set(position, -2459.0f, 2.0f, 2263.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
|
||||
ACTOR_RAILROAD_CROSSING));
|
||||
rrxing->crossingTrigger = crossing1;
|
||||
vec3f_set(position, -2467.0f, 2.0f, 2375.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
|
||||
ACTOR_RAILROAD_CROSSING));
|
||||
rrxing->crossingTrigger = crossing1;
|
||||
|
||||
@@ -194,10 +194,10 @@ void MarioRaceway::BeginPlay() {
|
||||
spawn_piranha_plants((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_mario_raceway_piranha_plant_spawns));
|
||||
spawn_all_item_boxes((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_mario_raceway_item_box_spawns));
|
||||
vec3f_set(position, 150.0f, 40.0f, -1300.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN);
|
||||
vec3f_set(position, 2520.0f, 0.0f, 1240.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
add_actor_to_empty_slot(position, rotation, velocity, ACTOR_MARIO_SIGN);
|
||||
|
||||
if (gModeSelection == VERSUS) {
|
||||
|
||||
@@ -258,7 +258,7 @@ void SherbetLand::DrawWater(struct UnkStruct_800DC5EC* screen, uint16_t pathCoun
|
||||
render_course_segments(sherbet_land_dls_2, screen);
|
||||
|
||||
gDPSetAlphaCompare(gDisplayListHead++, G_AC_NONE);
|
||||
if ((func_80290C20(screen->camera) == 1) && (get_water_level(screen->player) < screen->player->pos[1])) {
|
||||
if ((func_80290C20(screen->camera) == 1) && (get_water_level(screen->player) < screen->player->pos.y)) {
|
||||
gSPSetGeometryMode(gDisplayListHead++, G_ZBUFFER);
|
||||
gDPSetCombineMode(gDisplayListHead++, G_CC_SHADE, G_CC_SHADE);
|
||||
gDPSetRenderMode(gDisplayListHead++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
|
||||
|
||||
@@ -256,7 +256,7 @@ void TestCourse::BeginPlay() {
|
||||
Vec3f crossingPos = {0, 2, 0};
|
||||
uintptr_t* crossing1 = (uintptr_t*) gWorldInstance.AddCrossing(crossingPos, 0, 2, 900.0f, 650.0f);
|
||||
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
rrxing = (struct RailroadCrossing*) GET_ACTOR(add_actor_to_empty_slot(position, rotation, velocity,
|
||||
ACTOR_RAILROAD_CROSSING));
|
||||
rrxing->crossingTrigger = crossing1;
|
||||
|
||||
@@ -151,7 +151,7 @@ void YoshiValley::BeginPlay() {
|
||||
spawn_foliage((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_yoshi_valley_tree_spawn));
|
||||
spawn_all_item_boxes((struct ActorSpawnData*)LOAD_ASSET_RAW(d_course_yoshi_valley_item_box_spawns));
|
||||
vec3f_set(position, -2300.0f, 0.0f, 634.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
add_actor_to_empty_slot(position, rotation, velocity, ACTOR_YOSHI_EGG);
|
||||
|
||||
if (gGamestate != CREDITS_SEQUENCE) {
|
||||
@@ -241,7 +241,7 @@ void YoshiValley::CreditsSpawnActors() {
|
||||
Vec3s rotation = { 0, 0, 0 };
|
||||
|
||||
vec3f_set(position, -2300.0f, 0.0f, 634.0f);
|
||||
position[0] *= gCourseDirection;
|
||||
position.x *= gCourseDirection;
|
||||
add_actor_to_empty_slot(position, rotation, velocity, ACTOR_YOSHI_EGG);
|
||||
}
|
||||
|
||||
|
||||
@@ -68,7 +68,7 @@ FVector ScreenRayTrace() {
|
||||
FVector4 rayEye = MultiplyMatrixVector(inversePerspMtx, (float*)&rayClip.x);
|
||||
|
||||
Mat4 lookAtMtx;
|
||||
guLookAtF(lookAtMtx, camera->pos[0], camera->pos[1], camera->pos[2], camera->lookAt[0], camera->lookAt[1], camera->lookAt[2], camera->up[0], camera->up[1], camera->up[2]);
|
||||
guLookAtF(lookAtMtx, camera->pos.x, camera->pos.y, camera->pos.z, camera->lookAt.x, camera->lookAt.y, camera->lookAt.z, camera->up[0], camera->up[1], camera->up[2]);
|
||||
Mat4 inverseViewMtx;
|
||||
if (InverseMatrix((float*)&lookAtMtx, (float*)&inverseViewMtx[0][0]) != 2) {
|
||||
rayEye.w = 0;
|
||||
@@ -411,10 +411,10 @@ void SetRotatorFromDirection(FVector direction, IRotator* rot) {
|
||||
}
|
||||
|
||||
FVector GetPositionAheadOfCamera(f32 dist) {
|
||||
FVector pos = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
|
||||
FVector pos = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
|
||||
|
||||
f32 pitch = (cameras[0].rot[2] / 65535.0f) * 360.0f;
|
||||
f32 yaw = (cameras[0].rot[1] / 65535.0f) * 360.0f;
|
||||
f32 pitch = (cameras[0].rot.z / 65535.0f) * 360.0f;
|
||||
f32 yaw = (cameras[0].rot.y / 65535.0f) * 360.0f;
|
||||
|
||||
// Convert degrees to radians
|
||||
pitch = pitch * M_PI / 180.0f;
|
||||
|
||||
@@ -29,9 +29,9 @@ struct Triangle {
|
||||
*
|
||||
* @return FVector ray direction
|
||||
*
|
||||
* ray.x = camera->pos[0] + direction.x * length;
|
||||
* ray.y = camera->pos[1] + direction.y * length;
|
||||
* ray.z = camera->pos[2] + direction.z * length;
|
||||
* ray.x = camera->pos.x + direction.x * length;
|
||||
* ray.y = camera->pos.y + direction.y * length;
|
||||
* ray.z = camera->pos.z + direction.z * length;
|
||||
*/
|
||||
bool IsInGameScreen();
|
||||
FVector ScreenRayTrace();
|
||||
|
||||
+12
-12
@@ -118,31 +118,31 @@ void Gizmo::Translate() {
|
||||
|
||||
if (Enabled) {
|
||||
length = sqrt(
|
||||
pow(_selected->Pos->x - cameras[0].pos[0], 2) +
|
||||
pow(_selected->Pos->y - cameras[0].pos[1], 2) +
|
||||
pow(_selected->Pos->z - cameras[0].pos[2], 2)
|
||||
pow(_selected->Pos->x - cameras[0].pos.x, 2) +
|
||||
pow(_selected->Pos->y - cameras[0].pos.y, 2) +
|
||||
pow(_selected->Pos->z - cameras[0].pos.z, 2)
|
||||
);
|
||||
|
||||
switch(SelectedHandle) {
|
||||
case GizmoHandle::All_Axis:
|
||||
_selected->Pos->x = (cameras[0].pos[0] + _ray.x * PickDistance) + _cursorOffset.x;
|
||||
_selected->Pos->y = (cameras[0].pos[1] + _ray.y * PickDistance) + _cursorOffset.y;
|
||||
_selected->Pos->z = (cameras[0].pos[2] + _ray.z * PickDistance) + _cursorOffset.z;
|
||||
_selected->Pos->x = (cameras[0].pos.x + _ray.x * PickDistance) + _cursorOffset.x;
|
||||
_selected->Pos->y = (cameras[0].pos.y + _ray.y * PickDistance) + _cursorOffset.y;
|
||||
_selected->Pos->z = (cameras[0].pos.z + _ray.z * PickDistance) + _cursorOffset.z;
|
||||
if (CVarGetInteger("gEditorSnapToGround", 0) == true) {
|
||||
_selected->Pos->y = SnapToSurface(_selected->Pos);
|
||||
}
|
||||
break;
|
||||
case GizmoHandle::X_Axis:
|
||||
_selected->Pos->x = (cameras[0].pos[0] + _ray.x * length) + _cursorOffset.x;
|
||||
_selected->Pos->x = (cameras[0].pos.x + _ray.x * length) + _cursorOffset.x;
|
||||
if (CVarGetInteger("gEditorSnapToGround", 0) == true) {
|
||||
_selected->Pos->y = SnapToSurface(_selected->Pos);
|
||||
}
|
||||
break;
|
||||
case GizmoHandle::Y_Axis:
|
||||
_selected->Pos->y = (cameras[0].pos[1] + _ray.y * length) + _cursorOffset.y;
|
||||
_selected->Pos->y = (cameras[0].pos.y + _ray.y * length) + _cursorOffset.y;
|
||||
break;
|
||||
case GizmoHandle::Z_Axis:
|
||||
_selected->Pos->z = (cameras[0].pos[2] + _ray.z * length) + _cursorOffset.z;
|
||||
_selected->Pos->z = (cameras[0].pos.z + _ray.z * length) + _cursorOffset.z;
|
||||
if (CVarGetInteger("gEditorSnapToGround", 0) == true) {
|
||||
_selected->Pos->y = SnapToSurface(_selected->Pos);
|
||||
}
|
||||
@@ -180,7 +180,7 @@ f32 Gizmo::SnapToSurface(FVector* pos) {
|
||||
}
|
||||
|
||||
void Gizmo::Rotate() {
|
||||
FVector cam = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
|
||||
FVector cam = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
|
||||
|
||||
if (_selected == nullptr || _selected->Rot == nullptr) {
|
||||
return;
|
||||
@@ -214,7 +214,7 @@ void Gizmo::Rotate() {
|
||||
}
|
||||
|
||||
void Gizmo::Scale() {
|
||||
FVector cam = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
|
||||
FVector cam = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
|
||||
if (_selected == nullptr || _selected->Scale == nullptr) {
|
||||
return;
|
||||
}
|
||||
@@ -320,7 +320,7 @@ void Gizmo::DrawHandles() {
|
||||
Editor_MatrixIdentity(CenterMtx);
|
||||
|
||||
// Calculate camera-to-object distance
|
||||
FVector cameraDir = FVector(Pos.x - cameras[0].pos[0], Pos.y - cameras[0].pos[1], Pos.z - cameras[0].pos[2]);
|
||||
FVector cameraDir = FVector(Pos.x - cameras[0].pos.x, Pos.y - cameras[0].pos.y, Pos.z - cameras[0].pos.z);
|
||||
cameraDir = cameraDir.Normalize();
|
||||
|
||||
IRotator centerRot;
|
||||
|
||||
@@ -61,7 +61,7 @@ size_t LightObject::NumLights = 0;
|
||||
|
||||
|
||||
// Calculate camera-to-object distance
|
||||
FVector cameraDir = FVector(LightPos.x - cameras[0].pos[0], LightPos.y - cameras[0].pos[1], LightPos.z - cameras[0].pos[2]);
|
||||
FVector cameraDir = FVector(LightPos.x - cameras[0].pos.x, LightPos.y - cameras[0].pos.y, LightPos.z - cameras[0].pos.z);
|
||||
cameraDir = cameraDir.Normalize();
|
||||
|
||||
IRotator centerRot;
|
||||
|
||||
@@ -34,7 +34,7 @@ void ObjectPicker::Tick() {
|
||||
|
||||
void ObjectPicker::SelectObject(std::vector<GameObject*> objects) {
|
||||
Ray ray;
|
||||
ray.Origin = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
|
||||
ray.Origin = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
|
||||
|
||||
// This allows selection of objects in the scene explorer.
|
||||
// Otherwise this would still run when selecting buttons in editor windows.
|
||||
@@ -56,7 +56,7 @@ void ObjectPicker::SelectObject(std::vector<GameObject*> objects) {
|
||||
|
||||
void ObjectPicker::DragHandle() {
|
||||
Ray ray;
|
||||
ray.Origin = FVector(cameras[0].pos[0], cameras[0].pos[1], cameras[0].pos[2]);
|
||||
ray.Origin = FVector(cameras[0].pos.x, cameras[0].pos.y, cameras[0].pos.z);
|
||||
ray.Direction = ScreenRayTrace();
|
||||
|
||||
// Skip if a drag is already in progress
|
||||
@@ -136,9 +136,9 @@ void ObjectPicker::Draw() {
|
||||
FVector scale = FVector(0.1, 0.1, 0.1);
|
||||
FVector ray = ScreenRayTrace();
|
||||
|
||||
float x = (cameras[0].pos[0] + ray.x * 800);
|
||||
float y = (cameras[0].pos[1] + ray.y * 800);
|
||||
float z = (cameras[0].pos[2] + ray.z * 800);
|
||||
float x = (cameras[0].pos.x + ray.x * 800);
|
||||
float y = (cameras[0].pos.y + ray.y * 800);
|
||||
float z = (cameras[0].pos.z + ray.z * 800);
|
||||
|
||||
ApplyMatrixTransformations((float(*)[4])&CursorMtx, FVector(x, y, z), rot, scale);
|
||||
Editor_AddMatrix((float(*)[4])&CursorMtx, G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
|
||||
|
||||
@@ -120,7 +120,7 @@ void OBat::Draw(s32 cameraId) {
|
||||
|
||||
if ((gObjectList[objectIndex].state >= 2) && (gMatrixHudCount < 0x2EF)) {
|
||||
D_80183E80[1] =
|
||||
func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], temp_s7->pos);
|
||||
func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, temp_s7->pos);
|
||||
func_800431B0(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling,
|
||||
(Vtx*)D_0D0062B0);
|
||||
}
|
||||
@@ -135,7 +135,7 @@ void OBat::Draw(s32 cameraId) {
|
||||
|
||||
if ((gObjectList[objectIndex].state >= 2) && (gMatrixHudCount < 0x2EF)) {
|
||||
D_80183E80[1] =
|
||||
func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], temp_s7->pos);
|
||||
func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, temp_s7->pos);
|
||||
func_800431B0(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling,
|
||||
(Vtx*)D_0D0062B0);
|
||||
}
|
||||
@@ -179,18 +179,18 @@ void OBat::func_8007D8D4(s32 objectIndex, s32 arg1) {
|
||||
}
|
||||
if (arg1 == 1) {
|
||||
if (gIsMirrorMode != 0) {
|
||||
if (gObjectList[objectIndex].pos[0] >= 2540.0) {
|
||||
if (gObjectList[objectIndex].pos.x >= 2540.0) {
|
||||
func_80072428(objectIndex);
|
||||
}
|
||||
} else if (gObjectList[objectIndex].pos[0] <= -2540.0) {
|
||||
} else if (gObjectList[objectIndex].pos.x <= -2540.0) {
|
||||
func_80072428(objectIndex);
|
||||
}
|
||||
} else if (gIsMirrorMode != 0) {
|
||||
if (gObjectList[objectIndex].pos[0] >= 2150.0) {
|
||||
if (gObjectList[objectIndex].pos.x >= 2150.0) {
|
||||
func_80072428(objectIndex);
|
||||
}
|
||||
} else {
|
||||
if (gObjectList[objectIndex].pos[0] <= -2150.0) {
|
||||
if (gObjectList[objectIndex].pos.x <= -2150.0) {
|
||||
func_80072428(objectIndex);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -131,9 +131,9 @@ void OBombKart::Tick() {
|
||||
if (GetCourse() == GetPodiumCeremony()) {
|
||||
if (D_8016347E == 1) {
|
||||
player = gPlayerFour;
|
||||
temp_f0 = newPos[0] - player->pos[0];
|
||||
temp_f2 = newPos[2] - player->pos[1];
|
||||
temp_f12 = newPos[2] - player->pos[2];
|
||||
temp_f0 = newPos[0] - player->pos.x;
|
||||
temp_f2 = newPos[2] - player->pos.y;
|
||||
temp_f12 = newPos[2] - player->pos.z;
|
||||
if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) + (temp_f12 * temp_f12)) < 25.0f) {
|
||||
circleTimer = 0;
|
||||
state = States::EXPLODE;
|
||||
@@ -146,9 +146,9 @@ void OBombKart::Tick() {
|
||||
for (size_t i = 0; i < gPlayerCount; i++) {
|
||||
player = &gPlayers[i];
|
||||
if (!(player->effects & 0x80000000)) {
|
||||
temp_f0 = newPos[0] - player->pos[0];
|
||||
temp_f2 = newPos[1] - player->pos[1];
|
||||
temp_f12 = newPos[2] - player->pos[2];
|
||||
temp_f0 = newPos[0] - player->pos.x;
|
||||
temp_f2 = newPos[1] - player->pos.y;
|
||||
temp_f12 = newPos[2] - player->pos.z;
|
||||
if ((((temp_f0 * temp_f0) + (temp_f2 * temp_f2)) + (temp_f12 * temp_f12)) < 25.0f) {
|
||||
state = States::EXPLODE;
|
||||
circleTimer = 0;
|
||||
@@ -334,9 +334,9 @@ void OBombKart::Draw(s32 cameraId) {
|
||||
if (object->state != 0) {
|
||||
s32 primAlpha = object->primAlpha;
|
||||
Player* player = &gPlayerOne[playerId];
|
||||
object->pos[0] = player->pos[0];
|
||||
object->pos[1] = player->pos[1] - 2.0;
|
||||
object->pos[2] = player->pos[2];
|
||||
object->pos.x = player->pos.x;
|
||||
object->pos.y = player->pos.y - 2.0;
|
||||
object->pos.z = player->pos.z;
|
||||
object->surfaceHeight = player->unk_074;
|
||||
func_800563DC(_objectIndex, cameraId, primAlpha);
|
||||
func_8005669C(_objectIndex, cameraId, primAlpha);
|
||||
@@ -370,9 +370,9 @@ void OBombKart::Draw(s32 cameraId) {
|
||||
// huh???
|
||||
s32 state = State;
|
||||
if (State != States::DISABLED) {
|
||||
gObjectList[_objectIndex].pos[0] = Pos[0];
|
||||
gObjectList[_objectIndex].pos[1] = Pos[1];
|
||||
gObjectList[_objectIndex].pos[2] = Pos[2];
|
||||
gObjectList[_objectIndex].pos.x = Pos[0];
|
||||
gObjectList[_objectIndex].pos.y = Pos[1];
|
||||
gObjectList[_objectIndex].pos.z = Pos[2];
|
||||
s32 temp_s4 = func_8008A364(_objectIndex, cameraId, 0x31C4U, 0x000001F4);
|
||||
if (is_obj_flag_status_active(_objectIndex, VISIBLE) != 0) {
|
||||
set_object_flag(_objectIndex, 0x00200000);
|
||||
@@ -441,7 +441,7 @@ void OBombKart::Waypoint(s32 screenId) {
|
||||
Player* OBombKart::FindTarget() {
|
||||
for (size_t i = 0; i < NUM_PLAYERS; i++) {
|
||||
if (gPlayers[i].type & PLAYER_HUMAN) {
|
||||
if (is_within_distance_2d(Pos[0], Pos[2], gPlayers[i].pos[0], gPlayers[i].pos[2], 500)) {
|
||||
if (is_within_distance_2d(Pos[0], Pos[2], gPlayers[i].pos.x, gPlayers[i].pos.z, 500)) {
|
||||
return &gPlayers[i];
|
||||
}
|
||||
}
|
||||
@@ -456,9 +456,9 @@ void OBombKart::Chase(Player* player, Vec3f pos) {
|
||||
|
||||
// Calculate the directional vector toward the player
|
||||
Vec3f direction;
|
||||
direction[0] = player->pos[0] - pos[0];
|
||||
direction[1] = player->pos[1] - pos[1];
|
||||
direction[2] = player->pos[2] - pos[2];
|
||||
direction[0] = player->pos.x - pos.x;
|
||||
direction[1] = player->pos.y - pos.y;
|
||||
direction[2] = player->pos.z - pos.z;
|
||||
|
||||
// Calculate the distance in the XZ plane
|
||||
f32 xz_dist = sqrtf((direction[0] * direction[0]) + (direction[2] * direction[2]));
|
||||
@@ -466,18 +466,18 @@ void OBombKart::Chase(Player* player, Vec3f pos) {
|
||||
// Reset distance
|
||||
if (xz_dist > 700.0f) {
|
||||
_target = NULL;
|
||||
pos[0] = _spawnPos[0];
|
||||
pos[1] = _spawnPos[1];
|
||||
pos[2] = _spawnPos[2];
|
||||
pos.x = _spawnPos[0];
|
||||
pos.y = _spawnPos[1];
|
||||
pos.z = _spawnPos[2];
|
||||
return;
|
||||
}
|
||||
|
||||
// Break off the chase if player has boo item
|
||||
if (player->effects & BOO_EFFECT) {
|
||||
_target = NULL;
|
||||
pos[0] = _spawnPos[0];
|
||||
pos[1] = _spawnPos[1];
|
||||
pos[2] = _spawnPos[2];
|
||||
pos.x = _spawnPos[0];
|
||||
pos.y = _spawnPos[1];
|
||||
pos.z = _spawnPos[2];
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -488,20 +488,20 @@ void OBombKart::Chase(Player* player, Vec3f pos) {
|
||||
direction[2] /= xz_dist;
|
||||
|
||||
// Scale the movement by a fixed step size
|
||||
pos[0] += direction[0] * speed;
|
||||
pos[2] += direction[2] * speed;
|
||||
pos.x += direction[0] * speed;
|
||||
pos.z += direction[2] * speed;
|
||||
}
|
||||
|
||||
Vec3f newPosition;
|
||||
newPosition[0] = pos[0];
|
||||
newPosition[1] = pos[1];
|
||||
newPosition[2] = pos[2];
|
||||
newPosition[0] = pos.x;
|
||||
newPosition[1] = pos.y;
|
||||
newPosition[2] = pos.z;
|
||||
|
||||
newPosition[1] = calculate_surface_height(pos[0], 2000.0f, pos[2], _Collision.meshIndexZX) + 3.5f;
|
||||
newPosition[1] = calculate_surface_height(pos.x, 2000.0f, pos.z, _Collision.meshIndexZX) + 3.5f;
|
||||
|
||||
pos[0] = newPosition[0];
|
||||
pos[1] = newPosition[1];
|
||||
pos[2] = newPosition[2];
|
||||
pos.x = newPosition[0];
|
||||
pos.y = newPosition[1];
|
||||
pos.z = newPosition[2];
|
||||
|
||||
check_bounding_collision(&_Collision, 10.0f, pos[0], pos[1], pos[2]);
|
||||
check_bounding_collision(&_Collision, 10.0f, pos.x, pos.y, pos.z);
|
||||
}
|
||||
@@ -61,11 +61,11 @@ void OBoos::Tick() {
|
||||
func_8008B78C(objectIndex);
|
||||
player = &gPlayerOne[object->unk_0D1];
|
||||
camera = &camera1[object->unk_0D1];
|
||||
temp_t4 = (0x8000 - camera->rot[1]);
|
||||
object->pos[0] = player->pos[0] + (coss(temp_t4) * (object->origin_pos[0] + object->offset[0])) -
|
||||
temp_t4 = (0x8000 - camera->rot.y);
|
||||
object->pos.x = player->pos.x + (coss(temp_t4) * (object->origin_pos[0] + object->offset[0])) -
|
||||
(sins(temp_t4) * (object->origin_pos[2] + object->offset[2]));
|
||||
object->pos[1] = 6.5 + player->unk_074 + object->origin_pos[1] + object->offset[1];
|
||||
object->pos[2] = player->pos[2] + (sins(temp_t4) * (object->origin_pos[0] + object->offset[0])) +
|
||||
object->pos.y = 6.5 + player->unk_074 + object->origin_pos[1] + object->offset[1];
|
||||
object->pos.z = player->pos.z + (sins(temp_t4) * (object->origin_pos[0] + object->offset[0])) +
|
||||
(coss(temp_t4) * (object->origin_pos[2] + object->offset[2]));
|
||||
OBoos::func_8007C550(objectIndex);
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00000080) != 0) {
|
||||
@@ -101,7 +101,7 @@ void OBoos::func_800523B8(s32 objectIndex, s32 arg1, u32 arg2) {
|
||||
Camera* camera = &camera1[arg1];
|
||||
|
||||
object = &gObjectList[objectIndex];
|
||||
object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
|
||||
object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
|
||||
func_800484BC(object->pos, object->orientation, object->sizeScaling, object->primAlpha, (u8*) object->activeTLUT,
|
||||
(u8*)object->activeTexture, object->vertex, 0x00000030, 0x00000028, 0x00000030, 0x00000028);
|
||||
if ((is_obj_flag_status_active(objectIndex, 0x00000020) != 0) && (arg2 < 0x15F91U)) {
|
||||
@@ -140,9 +140,9 @@ void OBoos::func_8007C5B4(s32 objectIndex) {
|
||||
|
||||
init_texture_object(objectIndex, (u8*)d_course_banshee_boardwalk_boo_tlut, gTextureGhosts, 48, 40);
|
||||
object = &gObjectList[objectIndex];
|
||||
object->pos[0] = 0.0f;
|
||||
object->pos[1] = 0.0f;
|
||||
object->pos[2] = 0.0f;
|
||||
object->pos.x = 0.0f;
|
||||
object->pos.y = 0.0f;
|
||||
object->pos.z = 0.0f;
|
||||
set_object_flag(objectIndex, 0x00000020);
|
||||
object_next_state(objectIndex);
|
||||
object->primAlpha = 0;
|
||||
@@ -204,7 +204,7 @@ void OBoos::func_8007C4A4(s32 objectIndex) {
|
||||
void OBoos::func_8007C550(s32 objectIndex) {
|
||||
gObjectList[objectIndex].direction_angle[1] =
|
||||
func_800417B4(gObjectList[objectIndex].direction_angle[1],
|
||||
atan2s(gObjectList[objectIndex].velocity[0], gObjectList[objectIndex].velocity[2]));
|
||||
atan2s(gObjectList[objectIndex].velocity.x, gObjectList[objectIndex].velocity.z));
|
||||
OBoos::func_8007C4A4(objectIndex);
|
||||
}
|
||||
|
||||
|
||||
@@ -58,12 +58,12 @@ void OChainChomp::func_80055AB8(s32 objectIndex, s32 cameraId) {
|
||||
camera = &camera1[cameraId];
|
||||
if (gObjectList[objectIndex].state >= 2) {
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00100000) != 0) {
|
||||
D_80183E40[0] = gObjectList[objectIndex].pos[0];
|
||||
D_80183E40[1] = gObjectList[objectIndex].pos[1] + 16.0;
|
||||
D_80183E40[2] = gObjectList[objectIndex].pos[2];
|
||||
D_80183E40[0] = gObjectList[objectIndex].pos.x;
|
||||
D_80183E40[1] = gObjectList[objectIndex].pos.y + 16.0;
|
||||
D_80183E40[2] = gObjectList[objectIndex].pos.z;
|
||||
D_80183E80[0] = 0;
|
||||
D_80183E80[1] =
|
||||
func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
|
||||
func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
|
||||
D_80183E80[2] = 0x8000;
|
||||
func_800468E0(D_80183E40, D_80183E80, 0.54f, (u8*)d_course_rainbow_road_sphere, (Vtx*)D_0D0062B0, 0x00000020,
|
||||
0x00000040, 0x00000020, 0x00000040, 5);
|
||||
|
||||
@@ -94,12 +94,12 @@ void OCheepCheep::func_8007BBBC(s32 objectIndex) {
|
||||
} else {
|
||||
func_80087E08(objectIndex, 18.0f, 0.7f, 25.0f, (s16) 0x00005800, 0x0000012C);
|
||||
}
|
||||
if (object->velocity[2] < 0.0f) {
|
||||
var_f14 = -object->velocity[2];
|
||||
if (object->velocity.z < 0.0f) {
|
||||
var_f14 = -object->velocity.z;
|
||||
} else {
|
||||
var_f14 = object->velocity[2];
|
||||
var_f14 = object->velocity.z;
|
||||
}
|
||||
object->direction_angle[0] = func_80041658(object->velocity[1], var_f14);
|
||||
object->direction_angle[0] = func_80041658(object->velocity.y, var_f14);
|
||||
set_and_run_timer_object(objectIndex, 0x00000046);
|
||||
break;
|
||||
case 3:
|
||||
@@ -180,10 +180,10 @@ void OCheepCheep::func_8007BFB0(s32 objectIndex) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
object->velocity[1] = -0.2f;
|
||||
object->velocity.y = -0.2f;
|
||||
if ((f64) object->offset[1] <= 0.0) {
|
||||
object->offset[1] = 0.0f;
|
||||
object->velocity[1] = 0.0f;
|
||||
object->velocity.y = 0.0f;
|
||||
func_80086F60(objectIndex);
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -36,8 +36,8 @@ OCrab::OCrab(const FVector2D& start, const FVector2D& end) {
|
||||
find_unused_obj_index(&_objectIndex);
|
||||
|
||||
init_object(_objectIndex, 0);
|
||||
gObjectList[_objectIndex].pos[0] = gObjectList[_objectIndex].origin_pos[0] = start.x * xOrientation;
|
||||
gObjectList[_objectIndex].pos[2] = gObjectList[_objectIndex].origin_pos[2] = start.z;
|
||||
gObjectList[_objectIndex].pos.x = gObjectList[_objectIndex].origin_pos[0] = start.x * xOrientation;
|
||||
gObjectList[_objectIndex].pos.z = gObjectList[_objectIndex].origin_pos[2] = start.z;
|
||||
|
||||
gObjectList[_objectIndex].unk_01C[0] = end.x * xOrientation;
|
||||
gObjectList[_objectIndex].unk_01C[2] = end.z;
|
||||
@@ -63,7 +63,7 @@ void OCrab::Draw(s32 cameraId) {
|
||||
camera = &camera1[cameraId];
|
||||
func_8004A6EC(objectIndex, 0.5f);
|
||||
gObjectList[objectIndex].orientation[1] =
|
||||
func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
|
||||
func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
|
||||
draw_2d_texture_at(gObjectList[objectIndex].pos, gObjectList[objectIndex].orientation,
|
||||
gObjectList[objectIndex].sizeScaling, (u8*) gObjectList[objectIndex].activeTLUT,
|
||||
(uint8_t*)gObjectList[objectIndex].activeTexture, vtx, 64, 64,
|
||||
@@ -82,7 +82,7 @@ void OCrab::DrawModel(s32 cameraId) {
|
||||
if (gObjectList[objectIndex].state >= 2) {
|
||||
camera = &camera1[cameraId];
|
||||
func_8004A6EC(objectIndex, 0.5f);
|
||||
gObjectList[objectIndex].orientation[1] = func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
|
||||
gObjectList[objectIndex].orientation[1] = func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
|
||||
draw_2d_texture_at(gObjectList[objectIndex].pos, gObjectList[objectIndex].orientation, gObjectList[objectIndex].sizeScaling, (u8*) gObjectList[objectIndex].activeTLUT, (u8*)gObjectList[objectIndex].activeTexture, (Vtx*)common_vtx_hedgehog, 0x00000040, 0x00000040, 0x00000040, 0x00000020);
|
||||
}
|
||||
}
|
||||
@@ -163,7 +163,7 @@ void OCrab::func_80082C30(s32 objectIndex) {
|
||||
object_calculate_new_pos_offset(objectIndex);
|
||||
if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
|
||||
func_80088538(objectIndex);
|
||||
gObjectList[objectIndex].pos[1] = (f32) (gObjectList[objectIndex].surfaceHeight + 2.5);
|
||||
gObjectList[objectIndex].pos.y = (f32) (gObjectList[objectIndex].surfaceHeight + 2.5);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -172,9 +172,9 @@ void OGrandPrixBalloons::func_80074924(s32 objectIndex) {
|
||||
|
||||
set_obj_origin_offset(objectIndex, 0, 0, 0);
|
||||
if (gPlayerCount == 1) {
|
||||
object->velocity[1] = (f32) (((f64) (f32) (sp2C % 4) * 0.25) + 0.8);
|
||||
object->velocity.y = (f32) (((f64) (f32) (sp2C % 4) * 0.25) + 0.8);
|
||||
} else {
|
||||
object->velocity[1] = (f32) (((f64) (f32) (sp2C % 3) * 0.2) + 0.4);
|
||||
object->velocity.y = (f32) (((f64) (f32) (sp2C % 3) * 0.2) + 0.4);
|
||||
}
|
||||
temp_a0 = sp2C % 8;
|
||||
object->unk_084[0] = D_800E6F30[temp_a0][0];
|
||||
|
||||
@@ -22,9 +22,9 @@ OHedgehog::OHedgehog(const FVector& pos, const FVector2D& patrolPoint, s16 unk)
|
||||
s32 objectId = indexObjectList2[_idx];
|
||||
_objectIndex = objectId;
|
||||
init_object(objectId, 0);
|
||||
gObjectList[objectId].pos[0] = gObjectList[objectId].origin_pos[0] = pos.x * xOrientation;
|
||||
gObjectList[objectId].pos[1] = gObjectList[objectId].surfaceHeight = pos.y + 6.0;
|
||||
gObjectList[objectId].pos[2] = gObjectList[objectId].origin_pos[2] = pos.z;
|
||||
gObjectList[objectId].pos.x = gObjectList[objectId].origin_pos[0] = pos.x * xOrientation;
|
||||
gObjectList[objectId].pos.y = gObjectList[objectId].surfaceHeight = pos.y + 6.0;
|
||||
gObjectList[objectId].pos.z = gObjectList[objectId].origin_pos[2] = pos.z;
|
||||
gObjectList[objectId].unk_0D5 = (u8)unk;
|
||||
gObjectList[objectId].unk_09C = patrolPoint.x * xOrientation;
|
||||
gObjectList[objectId].unk_09E = patrolPoint.z;
|
||||
@@ -75,7 +75,7 @@ void OHedgehog::func_800555BC(s32 objectIndex, s32 cameraId) {
|
||||
camera = &camera1[cameraId];
|
||||
OHedgehog::func_8004A870(objectIndex, 0.7f);
|
||||
gObjectList[objectIndex].orientation[1] =
|
||||
func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
|
||||
func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
|
||||
draw_2d_texture_at(gObjectList[objectIndex].pos, gObjectList[objectIndex].orientation,
|
||||
gObjectList[objectIndex].sizeScaling, (u8*) gObjectList[objectIndex].activeTLUT,
|
||||
(u8*)gObjectList[objectIndex].activeTexture, gObjectList[objectIndex].vertex, 64, 64, 64, 32);
|
||||
@@ -89,9 +89,9 @@ void OHedgehog::func_8004A870(s32 objectIndex, f32 arg1) {
|
||||
if ((is_obj_flag_status_active(objectIndex, 0x00000020) != 0) &&
|
||||
(is_obj_flag_status_active(objectIndex, 0x00800000) != 0)) {
|
||||
object = &gObjectList[objectIndex];
|
||||
D_80183E50[0] = object->pos[0];
|
||||
D_80183E50[0] = object->pos.x;
|
||||
D_80183E50[1] = object->surfaceHeight + 0.8;
|
||||
D_80183E50[2] = object->pos[2];
|
||||
D_80183E50[2] = object->pos.z;
|
||||
set_transform_matrix(mtx, object->unk_01C, D_80183E50, 0U, arg1);
|
||||
// convert_to_fixed_point_matrix(&gGfxPool->mtxHud[gMatrixHudCount], mtx);
|
||||
// gSPMatrix(gDisplayListHead++, VIRTUAL_TO_PHYSICAL(&gGfxPool->mtxHud[gMatrixHudCount++]),
|
||||
@@ -154,7 +154,7 @@ void OHedgehog::func_80083248(s32 objectIndex) {
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00400000) != 0) {
|
||||
func_8008861C(objectIndex);
|
||||
}
|
||||
gObjectList[objectIndex].pos[1] = gObjectList[objectIndex].surfaceHeight + 6.0;
|
||||
gObjectList[objectIndex].pos.y = gObjectList[objectIndex].surfaceHeight + 6.0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -42,9 +42,9 @@ void OHotAirBalloon::Tick() {
|
||||
OHotAirBalloon::func_80085534(objectIndex);
|
||||
object_calculate_new_pos_offset(objectIndex);
|
||||
if (gObjectList[objectIndex].state >= 2) {
|
||||
gActorHotAirBalloonItemBox->pos[0] = gObjectList[objectIndex].pos[0];
|
||||
gActorHotAirBalloonItemBox->pos[1] = gObjectList[objectIndex].pos[1] - 10.0;
|
||||
gActorHotAirBalloonItemBox->pos[2] = gObjectList[objectIndex].pos[2];
|
||||
gActorHotAirBalloonItemBox->pos.x = gObjectList[objectIndex].pos.x;
|
||||
gActorHotAirBalloonItemBox->pos.y = gObjectList[objectIndex].pos.y - 10.0;
|
||||
gActorHotAirBalloonItemBox->pos.z = gObjectList[objectIndex].pos.z;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -74,7 +74,7 @@ void OHotAirBalloon::func_80055CCC(s32 objectIndex, s32 cameraId) {
|
||||
camera = &camera1[cameraId];
|
||||
if (gObjectList[objectIndex].state >= 2) {
|
||||
func_8008A454(objectIndex, cameraId, 0x0000012C);
|
||||
test = gObjectList[objectIndex].pos[1] - gObjectList[objectIndex].surfaceHeight;
|
||||
test = gObjectList[objectIndex].pos.y - gObjectList[objectIndex].surfaceHeight;
|
||||
func_8004A6EC(objectIndex, (20.0 / test) + 0.5);
|
||||
if (is_obj_index_flag_status_inactive(objectIndex, 0x00100000) != 0) {
|
||||
func_80043328(gObjectList[objectIndex].pos, (u16*) gObjectList[objectIndex].direction_angle,
|
||||
@@ -83,7 +83,7 @@ void OHotAirBalloon::func_80055CCC(s32 objectIndex, s32 cameraId) {
|
||||
} else {
|
||||
D_80183E80[0] = (s16) gObjectList[objectIndex].direction_angle[0];
|
||||
D_80183E80[1] =
|
||||
(s16) (func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos) +
|
||||
(s16) (func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos) +
|
||||
0x8000);
|
||||
D_80183E80[2] = (u16) gObjectList[objectIndex].direction_angle[2];
|
||||
func_80043328(gObjectList[objectIndex].pos, D_80183E80, gObjectList[objectIndex].sizeScaling,
|
||||
@@ -109,7 +109,7 @@ void OHotAirBalloon::init_hot_air_balloon(s32 objectIndex) {
|
||||
func_8008B844(objectIndex);
|
||||
func_800886F4(objectIndex);
|
||||
func_80086EF0(objectIndex);
|
||||
gObjectList[objectIndex].velocity[1] = -2.0f;
|
||||
gObjectList[objectIndex].velocity.y = -2.0f;
|
||||
init_actor_hot_air_balloon_item_box(0.0f, 0.0f, 0.0f);
|
||||
object_next_state(objectIndex);
|
||||
}
|
||||
@@ -122,8 +122,8 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity[1], 0.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity[1] == 0.0) {
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity.y, 0.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity.y == 0.0) {
|
||||
func_80086FD4(objectIndex);
|
||||
}
|
||||
break;
|
||||
@@ -131,8 +131,8 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
|
||||
func_800871AC(objectIndex, 1);
|
||||
break;
|
||||
case 4:
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity[1], 1.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity[1] == 1.0) {
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity.y, 1.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity.y == 1.0) {
|
||||
func_80086FD4(objectIndex);
|
||||
}
|
||||
break;
|
||||
@@ -140,14 +140,14 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
|
||||
func_800871AC(objectIndex, 90);
|
||||
break;
|
||||
case 6:
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity[1], 0.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity[1] == 0.0) {
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity.y, 0.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity.y == 0.0) {
|
||||
func_80086FD4(objectIndex);
|
||||
}
|
||||
break;
|
||||
case 7:
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity[1], -1.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity[1] == -1.0) {
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity.y, -1.0f, 0.05f);
|
||||
if (gObjectList[objectIndex].velocity.y == -1.0) {
|
||||
func_80086FD4(objectIndex);
|
||||
}
|
||||
break;
|
||||
@@ -155,7 +155,7 @@ void OHotAirBalloon::func_80085534(s32 objectIndex) {
|
||||
func_800871AC(objectIndex, 90);
|
||||
break;
|
||||
case 9:
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity[1], 0.0f, 0.05f);
|
||||
f32_step_towards(&gObjectList[objectIndex].velocity.y, 0.0f, 0.05f);
|
||||
if (func_80087060(objectIndex, 90) != 0) {
|
||||
func_8008701C(objectIndex, 3);
|
||||
}
|
||||
|
||||
@@ -103,7 +103,7 @@ void OLakitu::Draw(s32 cameraId) {
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00000010) != 0) {
|
||||
object = &gObjectList[objectIndex];
|
||||
object->orientation[0] = 0;
|
||||
object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
|
||||
object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
|
||||
object->orientation[2] = 0x8000;
|
||||
if (func_80072354(objectIndex, 2) != 0) {
|
||||
draw_2d_texture_at(object->pos, object->orientation, object->sizeScaling, (u8*) object->activeTLUT,
|
||||
@@ -116,8 +116,8 @@ void OLakitu::Draw(s32 cameraId) {
|
||||
(s32) object->textureHeight, (s32) object->textureWidth, (s32) object->textureHeight / 2);
|
||||
}
|
||||
if (gScreenModeSelection == SCREEN_MODE_1P) {
|
||||
var_f0 = object->pos[0] - camera->pos[0];
|
||||
var_f2 = object->pos[2] - camera->pos[2];
|
||||
var_f0 = object->pos.x - camera->pos.x;
|
||||
var_f2 = object->pos.z - camera->pos.z;
|
||||
if (var_f0 < 0.0f) {
|
||||
var_f0 = -var_f0;
|
||||
}
|
||||
@@ -331,9 +331,9 @@ void OLakitu::init_obj_lakitu_checkered_flag(s32 objectIndex, s32 playerIndex) {
|
||||
object = &gObjectList[objectIndex];
|
||||
object->activeTexture = *gObjectList[objectIndex].textureList;
|
||||
object->vertex = vtx;
|
||||
object->pos[2] = 5000.0f;
|
||||
object->pos[1] = 5000.0f;
|
||||
object->pos[0] = 5000.0f;
|
||||
object->pos.z = 5000.0f;
|
||||
object->pos.y = 5000.0f;
|
||||
object->pos.x = 5000.0f;
|
||||
object->sizeScaling = 0.15f;
|
||||
func_80086F10(objectIndex, 2, &D_800E6834);
|
||||
clear_object_flag(objectIndex, 0x00000010);
|
||||
@@ -595,9 +595,9 @@ void OLakitu::func_8007A060(s32 objectIndex, s32 playerIndex) {
|
||||
object = &gObjectList[objectIndex];
|
||||
object->activeTexture = *gObjectList[objectIndex].textureList;
|
||||
object->vertex = vtx;
|
||||
object->pos[2] = 5000.0f;
|
||||
object->pos[1] = 5000.0f;
|
||||
object->pos[0] = 5000.0f;
|
||||
object->pos.z = 5000.0f;
|
||||
object->pos.y = 5000.0f;
|
||||
object->pos.x = 5000.0f;
|
||||
object->sizeScaling = 0.15f;
|
||||
clear_object_flag(objectIndex, 0x00000010);
|
||||
func_80086F10(objectIndex, 5, &D_800E694C);
|
||||
@@ -654,9 +654,9 @@ void OLakitu::func_8007A228(s32 objectIndex, s32 playerIndex) {
|
||||
object = &gObjectList[objectIndex];
|
||||
object->activeTexture = *gObjectList[objectIndex].textureList;
|
||||
object->vertex = vtx;
|
||||
object->pos[2] = 5000.0f;
|
||||
object->pos[1] = 5000.0f;
|
||||
object->pos[0] = 5000.0f;
|
||||
object->pos.z = 5000.0f;
|
||||
object->pos.y = 5000.0f;
|
||||
object->pos.x = 5000.0f;
|
||||
object->sizeScaling = 0.15f;
|
||||
clear_object_flag(objectIndex, 0x00000010);
|
||||
func_80086F10(objectIndex, 5, &D_800E694C);
|
||||
@@ -711,9 +711,9 @@ void OLakitu::func_8007A3F0(s32 objectIndex, s32 arg1) {
|
||||
init_texture_object(objectIndex, tlut, sLakituReverseTextures, 72, (u16) 56);
|
||||
gObjectList[objectIndex].activeTexture = *gObjectList[objectIndex].textureList;
|
||||
gObjectList[objectIndex].vertex = vtx;
|
||||
gObjectList[objectIndex].pos[2] = var;
|
||||
gObjectList[objectIndex].pos[1] = var;
|
||||
gObjectList[objectIndex].pos[0] = var;
|
||||
gObjectList[objectIndex].pos.z = var;
|
||||
gObjectList[objectIndex].pos.y = var;
|
||||
gObjectList[objectIndex].pos.x = var;
|
||||
gObjectList[objectIndex].sizeScaling = 0.15f;
|
||||
clear_object_flag(objectIndex, 0x00000010);
|
||||
func_80086F10(objectIndex, 6, &D_800E69B0);
|
||||
@@ -766,16 +766,16 @@ void OLakitu::update_object_lakitu_reverse(s32 objectIndex, s32 playerId) {
|
||||
void OLakitu::func_8007A66C(s32 objectIndex) {
|
||||
Player* player = &gPlayers[_playerId];
|
||||
Camera* camera = &cameras[_playerId];
|
||||
u16 rot = 0x8000 - camera->rot[1];
|
||||
u16 rot = 0x8000 - camera->rot.y;
|
||||
|
||||
gObjectList[objectIndex].pos[0] =
|
||||
(player->pos[0] +
|
||||
gObjectList[objectIndex].pos.x =
|
||||
(player->pos.x +
|
||||
(coss(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) -
|
||||
(sins(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
|
||||
gObjectList[objectIndex].pos[1] =
|
||||
gObjectList[objectIndex].pos.y =
|
||||
player->unk_074 + gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
|
||||
gObjectList[objectIndex].pos[2] =
|
||||
(player->pos[2] +
|
||||
gObjectList[objectIndex].pos.z =
|
||||
(player->pos.z +
|
||||
(sins(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) +
|
||||
(coss(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
|
||||
}
|
||||
@@ -783,16 +783,16 @@ void OLakitu::func_8007A66C(s32 objectIndex) {
|
||||
void OLakitu::func_8007A778(s32 objectIndex) {
|
||||
Player* player = &gPlayers[_playerId];
|
||||
Camera* camera = &cameras[_playerId];
|
||||
u16 rot = 0x8000 - camera->rot[1];
|
||||
u16 rot = 0x8000 - camera->rot.y;
|
||||
|
||||
gObjectList[objectIndex].pos[0] =
|
||||
(player->pos[0] +
|
||||
gObjectList[objectIndex].pos.x =
|
||||
(player->pos.x +
|
||||
(coss(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) -
|
||||
(sins(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
|
||||
gObjectList[objectIndex].pos[1] =
|
||||
player->pos[1] + gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
|
||||
gObjectList[objectIndex].pos[2] =
|
||||
(player->pos[2] +
|
||||
gObjectList[objectIndex].pos.y =
|
||||
player->pos.y + gObjectList[objectIndex].origin_pos[1] + gObjectList[objectIndex].offset[1];
|
||||
gObjectList[objectIndex].pos.z =
|
||||
(player->pos.z +
|
||||
(sins(rot) * (gObjectList[objectIndex].origin_pos[0] + gObjectList[objectIndex].offset[0]))) +
|
||||
(coss(rot) * (gObjectList[objectIndex].origin_pos[2] + gObjectList[objectIndex].offset[2]));
|
||||
}
|
||||
|
||||
+24
-24
@@ -31,9 +31,9 @@ OMole::OMole(FVector pos, OMoleGroup* group) {
|
||||
|
||||
find_unused_obj_index(&_objectIndex);
|
||||
|
||||
gObjectList[_objectIndex].pos[0] = pos.x * xOrientation;
|
||||
gObjectList[_objectIndex].pos[1] = pos.y;
|
||||
gObjectList[_objectIndex].pos[2] = pos.z;
|
||||
gObjectList[_objectIndex].pos.x = pos.x * xOrientation;
|
||||
gObjectList[_objectIndex].pos.y = pos.y;
|
||||
gObjectList[_objectIndex].pos.z = pos.z;
|
||||
|
||||
gObjectList[_objectIndex].origin_pos[0] = pos.x * xOrientation;
|
||||
gObjectList[_objectIndex].origin_pos[1] = pos.y - 9.0;
|
||||
@@ -42,8 +42,8 @@ OMole::OMole(FVector pos, OMoleGroup* group) {
|
||||
// This is probably the mole particles
|
||||
find_unused_obj_index(&_moleIndex);
|
||||
init_object(_moleIndex, 0);
|
||||
gObjectList[_moleIndex].pos[0] = pos.x * xOrientation;
|
||||
gObjectList[_moleIndex].pos[2] = pos.z;
|
||||
gObjectList[_moleIndex].pos.x = pos.x * xOrientation;
|
||||
gObjectList[_moleIndex].pos.z = pos.z;
|
||||
func_800887C0(_moleIndex);
|
||||
gObjectList[_moleIndex].sizeScaling = 0.7f;
|
||||
|
||||
@@ -77,7 +77,7 @@ void OMole::func_80081790(s32 objectIndex) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.3f, gObjectList[objectIndex].unk_034,
|
||||
if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.3f, gObjectList[objectIndex].unk_034,
|
||||
gObjectList[objectIndex].orientation[1], 0x00000032) != 0) {
|
||||
object_next_state(objectIndex);
|
||||
}
|
||||
@@ -183,8 +183,8 @@ void OMole::func_8008153C(s32 objectIndex) {
|
||||
gObjectList[loopObjectIndex].activeTLUT = d_course_moo_moo_farm_mole_dirt;
|
||||
gObjectList[loopObjectIndex].tlutList = mole;
|
||||
gObjectList[loopObjectIndex].sizeScaling = 0.15f;
|
||||
gObjectList[loopObjectIndex].velocity[1] = random_int(0x000AU);
|
||||
gObjectList[loopObjectIndex].velocity[1] = (gObjectList[loopObjectIndex].velocity[1] * 0.1) + 4.8;
|
||||
gObjectList[loopObjectIndex].velocity.y = random_int(0x000AU);
|
||||
gObjectList[loopObjectIndex].velocity.y = (gObjectList[loopObjectIndex].velocity.y * 0.1) + 4.8;
|
||||
gObjectList[loopObjectIndex].unk_034 = random_int(5U);
|
||||
gObjectList[loopObjectIndex].unk_034 = (gObjectList[loopObjectIndex].unk_034 * 0.01) + 0.8;
|
||||
gObjectList[loopObjectIndex].orientation[1] = (0x10000 / sp70) * var_s1;
|
||||
@@ -219,14 +219,14 @@ void OMole::func_80081D34(s32 objectIndex) {
|
||||
} else {
|
||||
player->soundEffects |= 2;
|
||||
}
|
||||
object->direction_angle[1] = camera->rot[1];
|
||||
object->velocity[1] = (player->unk_094 / 2) + 3.0;
|
||||
object->direction_angle[1] = camera->rot.y;
|
||||
object->velocity.y = (player->unk_094 / 2) + 3.0;
|
||||
object->unk_034 = player->unk_094 + 1.0;
|
||||
if (object->velocity[1] >= 5.0) {
|
||||
object->velocity[1] = 5.0f;
|
||||
if (object->velocity.y >= 5.0) {
|
||||
object->velocity.y = 5.0f;
|
||||
}
|
||||
if (object->unk_034 >= 4.0) {
|
||||
object->velocity[1] = 4.0f;
|
||||
object->velocity.y = 4.0f;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -235,7 +235,7 @@ void OMole::func_80081D34(s32 objectIndex) {
|
||||
object = &gObjectList[objectIndex];
|
||||
clear_object_flag(objectIndex, 0x00000200);
|
||||
func_80086F60(objectIndex);
|
||||
set_obj_origin_pos(objectIndex, object->pos[0], object->pos[1], object->pos[2]);
|
||||
set_obj_origin_pos(objectIndex, object->pos.x, object->pos.y, object->pos.z);
|
||||
set_obj_origin_offset(objectIndex, 0.0f, 0.0f, 0.0f);
|
||||
func_80086EAC(objectIndex, 2, 0x000A);
|
||||
func_800726CC(objectIndex, 0x0000000A);
|
||||
@@ -265,7 +265,7 @@ void OMole::func_80081848(s32 objectIndex) {
|
||||
set_obj_direction_angle(objectIndex, 0U, 0U, 0U);
|
||||
set_obj_orientation(objectIndex, 0U, 0U, 0x8000U);
|
||||
gObjectList[objectIndex].boundingBoxSize = 6;
|
||||
gObjectList[objectIndex].velocity[1] = 4.0f;
|
||||
gObjectList[objectIndex].velocity.y = 4.0f;
|
||||
set_object_flag(objectIndex, 0x04000000);
|
||||
object_next_state(objectIndex);
|
||||
}
|
||||
@@ -294,10 +294,10 @@ void OMole::func_80081924(s32 objectIndex) {
|
||||
break;
|
||||
case 10:
|
||||
gObjectList[objectIndex].orientation[2] += 0x1000;
|
||||
gObjectList[objectIndex].velocity[1] -= 0.184;
|
||||
gObjectList[objectIndex].velocity.y -= 0.184;
|
||||
func_8008751C(objectIndex);
|
||||
object_add_velocity_offset_xyz(objectIndex);
|
||||
if (gObjectList[objectIndex].pos[1] <= -10.0) {
|
||||
if (gObjectList[objectIndex].pos.y <= -10.0) {
|
||||
func_80086F60(objectIndex);
|
||||
}
|
||||
break;
|
||||
@@ -333,12 +333,12 @@ void OMole::func_800821AC(s32 objectIndex, s32 arg1) {
|
||||
void OMole::func_80054E10(s32 objectIndex) {
|
||||
if (gObjectList[objectIndex].state > 0) {
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00800000) != 0) {
|
||||
D_80183E50[0] = gObjectList[objectIndex].pos[0];
|
||||
D_80183E50[0] = gObjectList[objectIndex].pos.x;
|
||||
D_80183E50[1] = gObjectList[objectIndex].surfaceHeight + 0.8;
|
||||
D_80183E50[2] = gObjectList[objectIndex].pos[2];
|
||||
D_80183E70[0] = gObjectList[objectIndex].velocity[0];
|
||||
D_80183E70[1] = gObjectList[objectIndex].velocity[1];
|
||||
D_80183E70[2] = gObjectList[objectIndex].velocity[2];
|
||||
D_80183E50[2] = gObjectList[objectIndex].pos.z;
|
||||
D_80183E70[0] = gObjectList[objectIndex].velocity.x;
|
||||
D_80183E70[1] = gObjectList[objectIndex].velocity.y;
|
||||
D_80183E70[2] = gObjectList[objectIndex].velocity.z;
|
||||
func_8004A9B8(gObjectList[objectIndex].sizeScaling);
|
||||
}
|
||||
}
|
||||
@@ -362,7 +362,7 @@ void OMole::func_80054D00(s32 objectIndex, s32 cameraId) {
|
||||
if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
|
||||
D_80183E80[0] = (s16) gObjectList[objectIndex].orientation[0];
|
||||
D_80183E80[1] =
|
||||
func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
|
||||
func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
|
||||
D_80183E80[2] = (u16) gObjectList[objectIndex].orientation[2];
|
||||
func_80048130(gObjectList[objectIndex].pos, (u16*) D_80183E80, gObjectList[objectIndex].sizeScaling,
|
||||
(u8*) gObjectList[objectIndex].activeTLUT, (u8*)gObjectList[objectIndex].activeTexture,
|
||||
@@ -384,7 +384,7 @@ if (_idx == 0) {
|
||||
if (object->state > 0) {
|
||||
func_8008A364(objectIndex, cameraId, 0x2AABU, 0x000000C8);
|
||||
if ((is_obj_flag_status_active(objectIndex, VISIBLE) != 0) && (gMatrixHudCount <= MTX_HUD_POOL_SIZE_MAX)) {
|
||||
object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
|
||||
object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
|
||||
rsp_set_matrix_gObjectList(objectIndex);
|
||||
gSPDisplayList(gDisplayListHead++, (Gfx*)D_0D006980);
|
||||
}
|
||||
|
||||
@@ -121,17 +121,17 @@ void OPodium::func_80086424(s32 objectIndex) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
gObjectList[objectIndex].velocity[1] = 0.75f;
|
||||
gObjectList[objectIndex].velocity.y = 0.75f;
|
||||
func_80086FD4(objectIndex);
|
||||
break;
|
||||
case 2:
|
||||
if (gObjectList[objectIndex].offset[1] >= -2.0) {
|
||||
gObjectList[objectIndex].velocity[1] -= 0.1;
|
||||
gObjectList[objectIndex].velocity.y -= 0.1;
|
||||
}
|
||||
object_add_velocity_offset_y(objectIndex);
|
||||
if (gObjectList[objectIndex].offset[1] >= 0.0) {
|
||||
gObjectList[objectIndex].offset[1] = 0.0f;
|
||||
gObjectList[objectIndex].velocity[1] = 0.0f;
|
||||
gObjectList[objectIndex].velocity.y = 0.0f;
|
||||
func_80086F60(objectIndex);
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -27,9 +27,9 @@ OSnowman::OSnowman(const FVector& pos) {
|
||||
gObjectList[_headIndex].origin_pos[0] = pos.x * xOrientation;
|
||||
gObjectList[_headIndex].origin_pos[1] = pos.y + 5.0 + 3.0;
|
||||
gObjectList[_headIndex].origin_pos[2] = pos.z;
|
||||
gObjectList[_headIndex].pos[0] = pos.x * xOrientation;
|
||||
gObjectList[_headIndex].pos[1] = pos.y + 5.0 + 3.0;
|
||||
gObjectList[_headIndex].pos[2] = pos.z;
|
||||
gObjectList[_headIndex].pos.x = pos.x * xOrientation;
|
||||
gObjectList[_headIndex].pos.y = pos.y + 5.0 + 3.0;
|
||||
gObjectList[_headIndex].pos.z = pos.z;
|
||||
|
||||
find_unused_obj_index(&_bodyIndex);
|
||||
init_object(_bodyIndex, 0);
|
||||
@@ -38,9 +38,9 @@ OSnowman::OSnowman(const FVector& pos) {
|
||||
gObjectList[_bodyIndex].origin_pos[2] = pos.z;
|
||||
gObjectList[_bodyIndex].unk_0D5 = 0; // Section Id no longer used.
|
||||
|
||||
gObjectList[_bodyIndex].pos[0] = pos.x * xOrientation;
|
||||
gObjectList[_bodyIndex].pos[1] = pos.y + 3.0;
|
||||
gObjectList[_bodyIndex].pos[2] = pos.z;
|
||||
gObjectList[_bodyIndex].pos.x = pos.x * xOrientation;
|
||||
gObjectList[_bodyIndex].pos.y = pos.y + 3.0;
|
||||
gObjectList[_bodyIndex].pos.z = pos.z;
|
||||
|
||||
_count++;
|
||||
}
|
||||
@@ -119,7 +119,7 @@ void OSnowman::DrawHead(s32 cameraId) {
|
||||
if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
|
||||
D_80183E80[0] = (s16) gObjectList[objectIndex].orientation[0];
|
||||
D_80183E80[1] =
|
||||
func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], camera->pos);
|
||||
func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, camera->pos);
|
||||
D_80183E80[2] = (u16) gObjectList[objectIndex].orientation[2];
|
||||
if (is_obj_flag_status_active(objectIndex, 0x00000010) != 0) {
|
||||
draw_2d_texture_at(gObjectList[objectIndex].pos, (u16*) D_80183E80,
|
||||
@@ -157,7 +157,7 @@ void OSnowman::DrawBody(s32 cameraId) {
|
||||
if (object->state > 0) {
|
||||
func_8008A364(objectIndex, cameraId, 0x2AABU, 0x000001F4);
|
||||
if (is_obj_flag_status_active(objectIndex, VISIBLE) != 0) {
|
||||
object->orientation[1] = func_800418AC(object->pos[0], object->pos[2], sp44->pos);
|
||||
object->orientation[1] = func_800418AC(object->pos.x, object->pos.z, sp44->pos);
|
||||
rsp_set_matrix_gObjectList(objectIndex);
|
||||
gSPDisplayList(gDisplayListHead++, (Gfx*)D_0D0069E0);
|
||||
}
|
||||
@@ -311,8 +311,8 @@ void OSnowman::func_80083538(s32 objectIndex, Vec3f arg1, s32 arg2, s32 arg3) {
|
||||
object->tlutList = (u8*)d_course_frappe_snowland_snow_tlut;
|
||||
object->sizeScaling = random_int(0x0064U);
|
||||
object->sizeScaling = (object->sizeScaling * 0.001) + 0.05;
|
||||
object->velocity[1] = random_int(0x0014U);
|
||||
object->velocity[1] = (object->velocity[1] * 0.5) + 2.6;
|
||||
object->velocity.y = random_int(0x0014U);
|
||||
object->velocity.y = (object->velocity.y * 0.5) + 2.6;
|
||||
object->unk_034 = random_int(0x000AU);
|
||||
object->unk_034 = (object->unk_034 * 0.1) + 4.5;
|
||||
object->direction_angle[1] = (arg2 << 0x10) / arg3;
|
||||
@@ -327,7 +327,7 @@ void OSnowman::func_8008379C(s32 objectIndex) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.74f,
|
||||
if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.74f,
|
||||
gObjectList[objectIndex].unk_034, gObjectList[objectIndex].direction_angle[1],
|
||||
0x00000064) != 0) {
|
||||
object_next_state(objectIndex);
|
||||
|
||||
@@ -221,12 +221,12 @@ void OThwomp::func_80080E8C(s32 objectIndex1, s32 objectIndex2, s32 arg2) {
|
||||
anAngle = gObjectList[objectIndex2].direction_angle[1];
|
||||
thing1 = func_800416D8(temp_v1[1], temp_v1[0], anAngle);
|
||||
thing0 = func_80041724(temp_v1[1], temp_v1[0], anAngle);
|
||||
gObjectList[objectIndex1].origin_pos[0] = gObjectList[objectIndex2].pos[0] + thing0;
|
||||
gObjectList[objectIndex1].origin_pos[0] = gObjectList[objectIndex2].pos.x + thing0;
|
||||
gObjectList[objectIndex1].origin_pos[1] = gObjectList[objectIndex2].surfaceHeight - 9.0;
|
||||
gObjectList[objectIndex1].origin_pos[2] = gObjectList[objectIndex2].pos[2] + thing1;
|
||||
gObjectList[objectIndex1].origin_pos[2] = gObjectList[objectIndex2].pos.z + thing1;
|
||||
anAngle = D_800E597C[arg2] + gObjectList[objectIndex2].direction_angle[1];
|
||||
gObjectList[objectIndex1].velocity[0] = sins(anAngle) * 0.6;
|
||||
gObjectList[objectIndex1].velocity[2] = coss(anAngle) * 0.6;
|
||||
gObjectList[objectIndex1].velocity.x = sins(anAngle) * 0.6;
|
||||
gObjectList[objectIndex1].velocity.z = coss(anAngle) * 0.6;
|
||||
}
|
||||
#else
|
||||
GLOBAL_ASM("asm/non_matchings/update_objects/func_80080E8C.s")
|
||||
@@ -291,7 +291,7 @@ void OThwomp::func_80074FD8(s32 objectIndex) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity[1], 0.12f,
|
||||
if (func_80087E08(objectIndex, gObjectList[objectIndex].velocity.y, 0.12f,
|
||||
gObjectList[objectIndex].unk_034, gObjectList[objectIndex].direction_angle[1],
|
||||
0x00000064) != 0) {
|
||||
object_next_state(objectIndex);
|
||||
@@ -596,7 +596,7 @@ void OThwomp::func_8007F6C4(s32 objectIndex, s32 playerId) {
|
||||
func_800722A4(objectIndex, 8);
|
||||
func_80086E70(objectIndex);
|
||||
gObjectList[objectIndex].unk_0DD = 2;
|
||||
gObjectList[objectIndex].unk_01C[0] = player->pos[0] - gObjectList[objectIndex].origin_pos[0];
|
||||
gObjectList[objectIndex].unk_01C[0] = player->pos.x - gObjectList[objectIndex].origin_pos[0];
|
||||
gObjectList[objectIndex].unk_0D1 = playerId;
|
||||
}
|
||||
|
||||
@@ -713,7 +713,7 @@ void OThwomp::Draw(s32 cameraId) {
|
||||
object = &gObjectList[objectIndex];
|
||||
if ((object->state >= 2) && (State == MOVE_AND_ROTATE) && (gMatrixHudCount <= MTX_HUD_POOL_SIZE_MAX)) {
|
||||
func_8004B138(0x000000FF, 0x000000FF, 0x000000FF, (s32) object->primAlpha);
|
||||
D_80183E80[1] = func_800418AC(object->pos[0], object->pos[2], camera->pos);
|
||||
D_80183E80[1] = func_800418AC(object->pos.x, object->pos.z, camera->pos);
|
||||
func_800431B0(object->pos, D_80183E80, object->sizeScaling, (Vtx*)D_0D005AE0);
|
||||
}
|
||||
}
|
||||
@@ -932,7 +932,7 @@ void OThwomp::func_8007FA08(s32 objectIndex) {
|
||||
} else {
|
||||
set_obj_orientation(objectIndex, 0U, 0x4000U, 0U);
|
||||
}
|
||||
object->velocity[0] = 0.0f;
|
||||
object->velocity.x = 0.0f;
|
||||
object->direction_angle[1] = object->orientation[1];
|
||||
object->unk_0DD = 1;
|
||||
object->unk_0DF = 8;
|
||||
@@ -963,25 +963,25 @@ void OThwomp::func_8007FB48(s32 objectIndex) {
|
||||
gObjectList[objectIndex].unk_0B0 = 0x00A0;
|
||||
gObjectList[objectIndex].offset[0] = 0.0f;
|
||||
gObjectList[objectIndex].offset[2] = 0.0f;
|
||||
gObjectList[objectIndex].velocity[2] = 0.0f;
|
||||
gObjectList[objectIndex].velocity.z = 0.0f;
|
||||
func_80086FD4(objectIndex);
|
||||
break;
|
||||
case 2:
|
||||
gObjectList[objectIndex].velocity[0] = player->unk_094 * xOrientation * 1.25;
|
||||
gObjectList[objectIndex].velocity.x = player->unk_094 * xOrientation * 1.25;
|
||||
if (gObjectList[objectIndex].unk_048 >= gObjectList[objectIndex].unk_0B0) {
|
||||
if (gObjectList[objectIndex].unk_0B0 == gObjectList[objectIndex].unk_048) {
|
||||
if (D_8018D400 & 1) {
|
||||
gObjectList[objectIndex].velocity[2] = 1.5f;
|
||||
gObjectList[objectIndex].velocity.z = 1.5f;
|
||||
} else {
|
||||
gObjectList[objectIndex].velocity[2] = -1.5f;
|
||||
gObjectList[objectIndex].velocity.z = -1.5f;
|
||||
}
|
||||
}
|
||||
if (gObjectList[objectIndex].velocity[2] >= 0.0) {
|
||||
if (gObjectList[objectIndex].velocity.z >= 0.0) {
|
||||
if (gObjectList[objectIndex].offset[2] >= 40.0) {
|
||||
gObjectList[objectIndex].velocity[2] = -1.5f;
|
||||
gObjectList[objectIndex].velocity.z = -1.5f;
|
||||
}
|
||||
} else if ((f64) gObjectList[objectIndex].offset[2] <= -40.0) {
|
||||
gObjectList[objectIndex].velocity[2] = 1.5f;
|
||||
gObjectList[objectIndex].velocity.z = 1.5f;
|
||||
}
|
||||
}
|
||||
object_add_velocity_offset_xz(objectIndex);
|
||||
@@ -1223,16 +1223,16 @@ void OThwomp::func_800806BC(s32 objectIndex) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], 250.0f, gObjectList[objectIndex].velocity[2]) !=
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], 250.0f, gObjectList[objectIndex].velocity.z) !=
|
||||
0) {
|
||||
gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
|
||||
gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
|
||||
func_80086FD4(objectIndex);
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity[2]) !=
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity.z) !=
|
||||
0) {
|
||||
gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
|
||||
gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
|
||||
func_8008701C(objectIndex, 1);
|
||||
}
|
||||
break;
|
||||
@@ -1244,16 +1244,16 @@ void OThwomp::func_8008078C(s32 objectIndex) {
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], -250.0f, gObjectList[objectIndex].velocity[2]) !=
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], -250.0f, gObjectList[objectIndex].velocity.z) !=
|
||||
0) {
|
||||
gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
|
||||
gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
|
||||
func_80086FD4(objectIndex);
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity[2]) !=
|
||||
if (f32_step_towards(&gObjectList[objectIndex].offset[2], 0.0f, gObjectList[objectIndex].velocity.z) !=
|
||||
0) {
|
||||
gObjectList[objectIndex].velocity[2] = -gObjectList[objectIndex].velocity[2];
|
||||
gObjectList[objectIndex].velocity.z = -gObjectList[objectIndex].velocity.z;
|
||||
func_8008701C(objectIndex, 1);
|
||||
}
|
||||
break;
|
||||
@@ -1286,11 +1286,11 @@ void OThwomp::func_80080524(s32 objectIndex) {
|
||||
switch (object->primAlpha) { /* irregular */
|
||||
case 0:
|
||||
object->unk_0DD = 2;
|
||||
object->velocity[2] = -1.0f;
|
||||
object->velocity.z = -1.0f;
|
||||
break;
|
||||
case 1:
|
||||
object->unk_0DD = 2;
|
||||
object->velocity[2] = -1.5f;
|
||||
object->velocity.z = -1.5f;
|
||||
break;
|
||||
}
|
||||
func_800722A4(objectIndex, 0x00000080);
|
||||
|
||||
@@ -80,17 +80,17 @@ void OTrashBin::init_bb_trash_bin(s32 objectIndex) {
|
||||
gObjectList[objectIndex].orientation[0] = DEGREES_FLOAT_TO_SHORT(_rot.pitch);
|
||||
gObjectList[objectIndex].orientation[1] = DEGREES_FLOAT_TO_SHORT(_rot.yaw);
|
||||
gObjectList[objectIndex].orientation[2] = DEGREES_FLOAT_TO_SHORT(_rot.roll);
|
||||
gObjectList[objectIndex].pos[0] = _pos.x;
|
||||
gObjectList[objectIndex].pos.x = _pos.x;
|
||||
if (_drawBin) {
|
||||
// Position the lid on-top of the box.
|
||||
// This might not be the best fix, but this allows the box to be placed on a surface
|
||||
// when spawned at 0,0,0
|
||||
gObjectList[objectIndex].pos[0] = _pos.y + 32.0f;
|
||||
gObjectList[objectIndex].pos.x = _pos.y + 32.0f;
|
||||
} else {
|
||||
// Stock implementation for banshee boardwalk
|
||||
gObjectList[objectIndex].pos[1] = _pos.y;
|
||||
gObjectList[objectIndex].pos.y = _pos.y;
|
||||
}
|
||||
gObjectList[objectIndex].pos[2] = _pos.z;
|
||||
gObjectList[objectIndex].pos.z = _pos.z;
|
||||
set_obj_velocity(objectIndex, 0.0f, 0.0f, 0.0f);
|
||||
gObjectList[objectIndex].type = 0;
|
||||
object_next_state(objectIndex);
|
||||
|
||||
@@ -86,9 +86,9 @@ OTrophy::OTrophy(const FVector& pos, TrophyType trophy, Behaviour bhv) {
|
||||
object->origin_pos[0] = _spawnPos.x;
|
||||
object->origin_pos[1] = _spawnPos.y;
|
||||
object->origin_pos[2] = _spawnPos.z;
|
||||
object->pos[0] = _spawnPos.x;
|
||||
object->pos[1] = _spawnPos.y;
|
||||
object->pos[2] = _spawnPos.z;
|
||||
object->pos.x = _spawnPos.x;
|
||||
object->pos.y = _spawnPos.y;
|
||||
object->pos.z = _spawnPos.z;
|
||||
|
||||
_emitter = reinterpret_cast<StarEmitter*>(gWorldInstance.AddEmitter(new StarEmitter()));
|
||||
}
|
||||
@@ -156,12 +156,12 @@ void OTrophy::Tick() { // func_80086D80
|
||||
float yaw = (player->rotation[1] + 0x4000) * (M_PI / 32768.0f); // Convert degrees to radians
|
||||
|
||||
// Calculate forward direction based on yaw (same as before)
|
||||
float lookAtX = player->pos[0] + cos(yaw);
|
||||
float lookAtZ = player->pos[2] + sin(yaw);
|
||||
float lookAtX = player->pos.x + cos(yaw);
|
||||
float lookAtZ = player->pos.z + sin(yaw);
|
||||
|
||||
float forwardX = lookAtX - player->pos[0];
|
||||
float forwardX = lookAtX - player->pos.x;
|
||||
float forwardY = 0; // Optional: Ignore height changes
|
||||
float forwardZ = lookAtZ - player->pos[2];
|
||||
float forwardZ = lookAtZ - player->pos.z;
|
||||
|
||||
// Normalize the forward vector
|
||||
float length = sqrtf(forwardX * forwardX + forwardZ * forwardZ);
|
||||
@@ -173,32 +173,32 @@ void OTrophy::Tick() { // func_80086D80
|
||||
float distance = 30.0f;
|
||||
|
||||
// Calculate the object's position in front of the player (same as before)
|
||||
gObjectList[objectIndex].pos[0] = player->pos[0] + forwardX * distance;
|
||||
gObjectList[objectIndex].pos[1] = player->pos[1] + 8.0f; // Optional height offset
|
||||
gObjectList[objectIndex].pos[2] = player->pos[2] + forwardZ * distance;
|
||||
gObjectList[objectIndex].pos.x = player->pos.x + forwardX * distance;
|
||||
gObjectList[objectIndex].pos.y = player->pos.y + 8.0f; // Optional height offset
|
||||
gObjectList[objectIndex].pos.z = player->pos.z + forwardZ * distance;
|
||||
|
||||
// Apply more sensitive random movement based on player velocity to simulate floating behavior
|
||||
float velocityFactor = 0.1f; // Increased factor for more sensitivity
|
||||
gObjectList[objectIndex].pos[0] += player->velocity[0] * velocityFactor;
|
||||
gObjectList[objectIndex].pos[1] += player->velocity[1] * velocityFactor; // Optional: Add vertical movement
|
||||
gObjectList[objectIndex].pos[2] += player->velocity[2] * velocityFactor;
|
||||
gObjectList[objectIndex].pos.x += player->velocity.x * velocityFactor;
|
||||
gObjectList[objectIndex].pos.y += player->velocity.y * velocityFactor; // Optional: Add vertical movement
|
||||
gObjectList[objectIndex].pos.z += player->velocity.z * velocityFactor;
|
||||
|
||||
// Increase oscillation for more dynamic movement (sine wave effect)
|
||||
float oscillationSpeed = 4.0f; // Increased speed for quicker oscillations
|
||||
float oscillationAmplitude = 0.4f; // Increased amplitude for more noticeable movement
|
||||
gObjectList[objectIndex].pos[1] += oscillationAmplitude * sinf(oscillationSpeed * gGlobalTimer); // Vertical oscillation based on time
|
||||
gObjectList[objectIndex].pos.y += oscillationAmplitude * sinf(oscillationSpeed * gGlobalTimer); // Vertical oscillation based on time
|
||||
|
||||
// Now use smooth interpolation (lerp) to gradually move the trophy towards its target position
|
||||
float lerpFactor = 0.25f; // Increased to make the trophy follow the player more quickly
|
||||
|
||||
gObjectList[objectIndex].pos[0] = _oldPos[0] + lerpFactor * (gObjectList[objectIndex].pos[0] - _oldPos[0]);
|
||||
gObjectList[objectIndex].pos[1] = _oldPos[1] + lerpFactor * (gObjectList[objectIndex].pos[1] - _oldPos[1]);
|
||||
gObjectList[objectIndex].pos[2] = _oldPos[2] + lerpFactor * (gObjectList[objectIndex].pos[2] - _oldPos[2]);
|
||||
gObjectList[objectIndex].pos.x = _oldPos[0] + lerpFactor * (gObjectList[objectIndex].pos.x - _oldPos[0]);
|
||||
gObjectList[objectIndex].pos.y = _oldPos[1] + lerpFactor * (gObjectList[objectIndex].pos.y - _oldPos[1]);
|
||||
gObjectList[objectIndex].pos.z = _oldPos[2] + lerpFactor * (gObjectList[objectIndex].pos.z - _oldPos[2]);
|
||||
|
||||
// Save the current position for the next frame
|
||||
_oldPos[0] = gObjectList[objectIndex].pos[0];
|
||||
_oldPos[1] = gObjectList[objectIndex].pos[1];
|
||||
_oldPos[2] = gObjectList[objectIndex].pos[2];
|
||||
_oldPos[0] = gObjectList[objectIndex].pos.x;
|
||||
_oldPos[1] = gObjectList[objectIndex].pos.y;
|
||||
_oldPos[2] = gObjectList[objectIndex].pos.z;
|
||||
|
||||
|
||||
gObjectList[objectIndex].direction_angle[0] += 0x400;
|
||||
@@ -246,8 +246,8 @@ void OTrophy::Draw(s32 cameraId) {
|
||||
|
||||
void OTrophy::func_80086700(s32 objectIndex) {
|
||||
gObjectList[objectIndex].sizeScaling = 0.005f;
|
||||
set_obj_origin_pos(objectIndex, gObjectList[indexObjectList2[0]].pos[0],
|
||||
gObjectList[indexObjectList2[0]].pos[1] + 16.0, gObjectList[indexObjectList2[0]].pos[2]);
|
||||
set_obj_origin_pos(objectIndex, gObjectList[indexObjectList2[0]].pos.x,
|
||||
gObjectList[indexObjectList2[0]].pos.y + 16.0, gObjectList[indexObjectList2[0]].pos.z);
|
||||
set_obj_origin_offset(objectIndex, 0.0f, 0.0f, 0.0f);
|
||||
set_obj_direction_angle(objectIndex, 0U, 0U, 0U);
|
||||
gObjectList[objectIndex].unk_084[1] = 0x0200;
|
||||
@@ -268,7 +268,7 @@ void OTrophy::func_80086940(s32 objectIndex) {
|
||||
case 2:
|
||||
f32_step_towards(&object->sizeScaling, 0.025f, 0.001f);
|
||||
func_80087C48(objectIndex, 6.0f, 0.1f, 0x000000C8);
|
||||
if ((f64) object->velocity[1] <= 0.0) {
|
||||
if ((f64) object->velocity.y <= 0.0) {
|
||||
func_8008701C(objectIndex, 3);
|
||||
}
|
||||
break;
|
||||
@@ -277,7 +277,7 @@ void OTrophy::func_80086940(s32 objectIndex) {
|
||||
break;
|
||||
case 4:
|
||||
D_801658D6 = 1;
|
||||
object->velocity[1] = -0.4f;
|
||||
object->velocity.y = -0.4f;
|
||||
func_80086FD4(objectIndex);
|
||||
// object->origin_pos[1] = 90.0f;
|
||||
object->offset[1] = 60.0f;
|
||||
@@ -294,7 +294,7 @@ void OTrophy::func_80086940(s32 objectIndex) {
|
||||
break;
|
||||
case 5:
|
||||
if ((f64) object->offset[1] <= 8.0) {
|
||||
f32_step_towards(&object->velocity[1], -0.1f, -0.01f);
|
||||
f32_step_towards(&object->velocity.y, -0.1f, -0.01f);
|
||||
}
|
||||
object_add_velocity_offset_y(objectIndex);
|
||||
if ((f64) object->offset[1] <= 0.0) {
|
||||
@@ -338,12 +338,12 @@ void OTrophy::func_80086C14(s32 objectIndex) {
|
||||
void OTrophy::func_80086C6C(s32 objectIndex) {
|
||||
Vec3f sp24;
|
||||
|
||||
sp24[0] = (gObjectList[objectIndex].pos[0] - 5.0f) + random_int(0x000AU);
|
||||
sp24[2] = (gObjectList[objectIndex].pos[2] - 5.0f) + random_int(0x000AU);
|
||||
sp24[0] = (gObjectList[objectIndex].pos.x - 5.0f) + random_int(0x000AU);
|
||||
sp24[2] = (gObjectList[objectIndex].pos.z - 5.0f) + random_int(0x000AU);
|
||||
if (D_801658F4 != 0) {
|
||||
sp24[1] = gObjectList[objectIndex].pos[1] + 14.0;
|
||||
sp24[1] = gObjectList[objectIndex].pos.y + 14.0;
|
||||
} else {
|
||||
sp24[1] = gObjectList[objectIndex].pos[1] - 2.0;
|
||||
sp24[1] = gObjectList[objectIndex].pos.y - 2.0;
|
||||
}
|
||||
|
||||
if (_emitter != nullptr) {
|
||||
|
||||
@@ -37,14 +37,14 @@ void StarEmitter::Emit(Vec3f arg1, s32 arg2) { // func_80077138
|
||||
set_obj_origin_offset(objectIndex, 0.0f, 0.0f, 0.0f);
|
||||
switch (arg2) {
|
||||
case 0:
|
||||
gObjectList[objectIndex].velocity[1] = -1.0f;
|
||||
gObjectList[objectIndex].velocity.y = -1.0f;
|
||||
gObjectList[objectIndex].unk_034 = (f32) ((random_int(0x004BU) * 0.01) + 0.25);
|
||||
gObjectList[objectIndex].direction_angle[1] = random_int(0x0040U) << 0xA;
|
||||
func_8008751C(objectIndex);
|
||||
gObjectList[objectIndex].unk_084[5] = 0x001E;
|
||||
break;
|
||||
case 1:
|
||||
gObjectList[objectIndex].velocity[1] = 1.5f;
|
||||
gObjectList[objectIndex].velocity.y = 1.5f;
|
||||
gObjectList[objectIndex].unk_034 = (f32) ((random_int(0x0064U) * 0.01) + 0.5);
|
||||
gObjectList[objectIndex].direction_angle[1] = random_int(0x0040U) << 0xA;
|
||||
func_8008751C(objectIndex);
|
||||
@@ -114,8 +114,8 @@ void StarEmitter::Draw(s32 cameraId) { // func_80054BE8
|
||||
}
|
||||
|
||||
void StarEmitter::func_80054AFC(s32 objectIndex, Vec3f arg1) {
|
||||
D_80183E80[0] = func_800418E8(gObjectList[objectIndex].pos[2], gObjectList[objectIndex].pos[1], arg1);
|
||||
D_80183E80[1] = func_800418AC(gObjectList[objectIndex].pos[0], gObjectList[objectIndex].pos[2], arg1);
|
||||
D_80183E80[0] = func_800418E8(gObjectList[objectIndex].pos.z, gObjectList[objectIndex].pos.y, arg1);
|
||||
D_80183E80[1] = func_800418AC(gObjectList[objectIndex].pos.x, gObjectList[objectIndex].pos.z, arg1);
|
||||
D_80183E80[2] = (u16) gObjectList[objectIndex].orientation[2];
|
||||
func_8004B138((s32) gObjectList[objectIndex].unk_084[0], (s32) gObjectList[objectIndex].unk_084[1],
|
||||
(s32) gObjectList[objectIndex].unk_084[2], (s32) gObjectList[objectIndex].primAlpha);
|
||||
@@ -135,11 +135,11 @@ void StarEmitter::func_80077584(s32 objectIndex) {
|
||||
|
||||
object = &gObjectList[objectIndex];
|
||||
if ((object->unk_0AE != 0) && (object->unk_0AE == 1) && ((u8) object->unk_0D8 != 0)) {
|
||||
if (object->velocity[1] >= -0.5) {
|
||||
object->velocity[1] -= 0.15;
|
||||
if (object->velocity.y >= -0.5) {
|
||||
object->velocity.y -= 0.15;
|
||||
} else {
|
||||
object->velocity[2] = 0.0f;
|
||||
object->velocity[0] = 0.0f;
|
||||
object->velocity.z = 0.0f;
|
||||
object->velocity.x = 0.0f;
|
||||
}
|
||||
}
|
||||
object->orientation[2] += object->unk_084[3];
|
||||
@@ -161,7 +161,7 @@ void StarEmitter::func_80077450(s32 objectIndex) {
|
||||
break;
|
||||
case 2:
|
||||
f32_step_up_towards(&gObjectList[objectIndex].sizeScaling, 0.1f, 0.01f);
|
||||
if ((gObjectList[objectIndex].pos[1] <= gObjectList[objectIndex].unk_084[5]) &&
|
||||
if ((gObjectList[objectIndex].pos.y <= gObjectList[objectIndex].unk_084[5]) &&
|
||||
(func_80073B00(objectIndex, &gObjectList[objectIndex].primAlpha, 0x000000FF, 0, 0x00000010, 0, 0) !=
|
||||
0)) {
|
||||
func_80086F60(objectIndex);
|
||||
|
||||
@@ -150,13 +150,13 @@ void ABoat::Tick() {
|
||||
Velocity[1] = Position[1] - temp_f28;
|
||||
Velocity[2] = Position[2] - temp_f30;
|
||||
paddleBoatActor = GET_ACTOR(ActorIndex);
|
||||
paddleBoatActor->pos[0] = Position[0];
|
||||
paddleBoatActor->pos[1] = Position[1];
|
||||
paddleBoatActor->pos[2] = Position[2];
|
||||
paddleBoatActor->pos.x = Position[0];
|
||||
paddleBoatActor->pos.y = Position[1];
|
||||
paddleBoatActor->pos.z = Position[2];
|
||||
if (gIsMirrorMode != 0) {
|
||||
paddleBoatActor->rot[1] = -RotY;
|
||||
paddleBoatActor->rot.y = -RotY;
|
||||
} else {
|
||||
paddleBoatActor->rot[1] = RotY;
|
||||
paddleBoatActor->rot.y = RotY;
|
||||
}
|
||||
Velocity[0] = Velocity[0];
|
||||
Velocity[1] = Velocity[1];
|
||||
@@ -173,9 +173,9 @@ void ABoat::VehicleCollision(s32 playerId, Player* player) {
|
||||
f32 playerY;
|
||||
|
||||
if (!((player->effects & 0x01000000)) && (!(player->effects & HIT_BY_ITEM_EFFECT))) {
|
||||
playerX = player->pos[0];
|
||||
playerY = player->pos[1];
|
||||
playerZ = player->pos[2];
|
||||
playerX = player->pos.x;
|
||||
playerY = player->pos.y;
|
||||
playerZ = player->pos.z;
|
||||
if (IsActive == 1) {
|
||||
x_diff = playerX - Position[0];
|
||||
y_diff = playerY - Position[1];
|
||||
|
||||
+13
-13
@@ -137,19 +137,19 @@ void ABus::Tick() {
|
||||
Velocity[1] = Position[1] - sp58;
|
||||
Velocity[2] = Position[2] - sp54;
|
||||
struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
|
||||
vehicleActor->pos[0] = Position[0];
|
||||
vehicleActor->pos[1] = Position[1];
|
||||
vehicleActor->pos[2] = Position[2];
|
||||
vehicleActor->rot[0] = Rotation[0];
|
||||
vehicleActor->pos.x = Position[0];
|
||||
vehicleActor->pos.y = Position[1];
|
||||
vehicleActor->pos.z = Position[2];
|
||||
vehicleActor->rot.x = Rotation[0];
|
||||
if (gIsMirrorMode != 0) {
|
||||
vehicleActor->rot[1] = -Rotation[1];
|
||||
vehicleActor->rot.y = -Rotation[1];
|
||||
} else {
|
||||
vehicleActor->rot[1] = Rotation[1];
|
||||
vehicleActor->rot.y = Rotation[1];
|
||||
}
|
||||
vehicleActor->rot[2] = Rotation[2];
|
||||
vehicleActor->velocity[0] = Velocity[0];
|
||||
vehicleActor->velocity[1] = Velocity[1];
|
||||
vehicleActor->velocity[2] = Velocity[2];
|
||||
vehicleActor->rot.z = Rotation[2];
|
||||
vehicleActor->velocity.x = Velocity[0];
|
||||
vehicleActor->velocity.y = Velocity[1];
|
||||
vehicleActor->velocity.z = Velocity[2];
|
||||
}
|
||||
|
||||
void ABus::VehicleCollision(s32 playerId, Player* player) {
|
||||
@@ -164,9 +164,9 @@ void ABus::VehicleCollision(s32 playerId, Player* player) {
|
||||
if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
|
||||
!(player->effects & 0x01000000)) {
|
||||
|
||||
spC4 = player->pos[0];
|
||||
spC0 = player->pos[1];
|
||||
spBC = player->pos[2];
|
||||
spC4 = player->pos.x;
|
||||
spC0 = player->pos.y;
|
||||
spBC = player->pos.z;
|
||||
|
||||
temp_f12 = spC4 - Position[0];
|
||||
temp_f22 = spC0 - Position[1];
|
||||
|
||||
+13
-13
@@ -119,19 +119,19 @@ void ACar::Tick() {
|
||||
Velocity[1] = Position[1] - sp58;
|
||||
Velocity[2] = Position[2] - sp54;
|
||||
struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
|
||||
vehicleActor->pos[0] = Position[0];
|
||||
vehicleActor->pos[1] = Position[1];
|
||||
vehicleActor->pos[2] = Position[2];
|
||||
vehicleActor->rot[0] = Rotation[0];
|
||||
vehicleActor->pos.x = Position[0];
|
||||
vehicleActor->pos.y = Position[1];
|
||||
vehicleActor->pos.z = Position[2];
|
||||
vehicleActor->rot.x = Rotation[0];
|
||||
if (gIsMirrorMode != 0) {
|
||||
vehicleActor->rot[1] = -Rotation[1];
|
||||
vehicleActor->rot.y = -Rotation[1];
|
||||
} else {
|
||||
vehicleActor->rot[1] = Rotation[1];
|
||||
vehicleActor->rot.y = Rotation[1];
|
||||
}
|
||||
vehicleActor->rot[2] = Rotation[2];
|
||||
vehicleActor->velocity[0] = Velocity[0];
|
||||
vehicleActor->velocity[1] = Velocity[1];
|
||||
vehicleActor->velocity[2] = Velocity[2];
|
||||
vehicleActor->rot.z = Rotation[2];
|
||||
vehicleActor->velocity.x = Velocity[0];
|
||||
vehicleActor->velocity.y = Velocity[1];
|
||||
vehicleActor->velocity.z = Velocity[2];
|
||||
}
|
||||
|
||||
void ACar::Draw(Camera* camera) {
|
||||
@@ -164,9 +164,9 @@ void ACar::VehicleCollision(s32 playerId, Player* player) {
|
||||
if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
|
||||
!(player->effects & 0x01000000)) {
|
||||
|
||||
spC4 = player->pos[0];
|
||||
spC0 = player->pos[1];
|
||||
spBC = player->pos[2];
|
||||
spC4 = player->pos.x;
|
||||
spC0 = player->pos.y;
|
||||
spBC = player->pos.z;
|
||||
|
||||
temp_f12 = spC4 - Position[0];
|
||||
temp_f22 = spC0 - Position[1];
|
||||
|
||||
@@ -137,19 +137,19 @@ void ATankerTruck::Tick() {
|
||||
Velocity[1] = Position[1] - sp58;
|
||||
Velocity[2] = Position[2] - sp54;
|
||||
struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
|
||||
vehicleActor->pos[0] = Position[0];
|
||||
vehicleActor->pos[1] = Position[1];
|
||||
vehicleActor->pos[2] = Position[2];
|
||||
vehicleActor->rot[0] = Rotation[0];
|
||||
vehicleActor->pos.x = Position[0];
|
||||
vehicleActor->pos.y = Position[1];
|
||||
vehicleActor->pos.z = Position[2];
|
||||
vehicleActor->rot.x = Rotation[0];
|
||||
if (gIsMirrorMode != 0) {
|
||||
vehicleActor->rot[1] = -Rotation[1];
|
||||
vehicleActor->rot.y = -Rotation[1];
|
||||
} else {
|
||||
vehicleActor->rot[1] = Rotation[1];
|
||||
vehicleActor->rot.y = Rotation[1];
|
||||
}
|
||||
vehicleActor->rot[2] = Rotation[2];
|
||||
vehicleActor->velocity[0] = Velocity[0];
|
||||
vehicleActor->velocity[1] = Velocity[1];
|
||||
vehicleActor->velocity[2] = Velocity[2];
|
||||
vehicleActor->rot.z = Rotation[2];
|
||||
vehicleActor->velocity.x = Velocity[0];
|
||||
vehicleActor->velocity.y = Velocity[1];
|
||||
vehicleActor->velocity.z = Velocity[2];
|
||||
}
|
||||
|
||||
void ATankerTruck::VehicleCollision(s32 playerId, Player* player) {
|
||||
@@ -164,9 +164,9 @@ void ATankerTruck::VehicleCollision(s32 playerId, Player* player) {
|
||||
if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
|
||||
!(player->effects & 0x01000000)) {
|
||||
|
||||
spC4 = player->pos[0];
|
||||
spC0 = player->pos[1];
|
||||
spBC = player->pos[2];
|
||||
spC4 = player->pos.x;
|
||||
spC0 = player->pos.y;
|
||||
spBC = player->pos.z;
|
||||
|
||||
temp_f12 = spC4 - Position[0];
|
||||
temp_f22 = spC0 - Position[1];
|
||||
|
||||
@@ -86,24 +86,24 @@ ATrain::ATrain(ATrain::TenderStatus tender, size_t numCarriages, f32 speed, uint
|
||||
f32 origZPos;
|
||||
|
||||
tempLocomotive = &Locomotive;
|
||||
origXPos = tempLocomotive->position[0];
|
||||
origZPos = tempLocomotive->position[2];
|
||||
origXPos = tempLocomotive->position.x;
|
||||
origZPos = tempLocomotive->position.z;
|
||||
trainCarYRot = update_vehicle_following_waypoint(
|
||||
tempLocomotive->position, (s16*) &tempLocomotive->waypointIndex, Speed);
|
||||
tempLocomotive->velocity[0] = tempLocomotive->position[0] - origXPos;
|
||||
tempLocomotive->velocity[2] = tempLocomotive->position[2] - origZPos;
|
||||
tempLocomotive->velocity.x = tempLocomotive->position.x - origXPos;
|
||||
tempLocomotive->velocity.z = tempLocomotive->position.z - origZPos;
|
||||
vec3s_set(trainCarRot, 0, trainCarYRot, 0);
|
||||
tempLocomotive->actorIndex = add_actor_to_empty_slot(tempLocomotive->position, trainCarRot,
|
||||
tempLocomotive->velocity, ACTOR_TRAIN_ENGINE);
|
||||
|
||||
tempTender = &Tender;
|
||||
if (tempTender->isActive == 1) {
|
||||
origXPos = tempTender->position[0];
|
||||
origZPos = tempTender->position[2];
|
||||
origXPos = tempTender->position.x;
|
||||
origZPos = tempTender->position.z;
|
||||
trainCarYRot = update_vehicle_following_waypoint(
|
||||
tempTender->position, (s16*) &tempTender->waypointIndex, Speed);
|
||||
tempTender->velocity[0] = tempTender->position[0] - origXPos;
|
||||
tempTender->velocity[2] = tempTender->position[2] - origZPos;
|
||||
tempTender->velocity.x = tempTender->position.x - origXPos;
|
||||
tempTender->velocity.z = tempTender->position.z - origZPos;
|
||||
vec3s_set(trainCarRot, 0, trainCarYRot, 0);
|
||||
tempTender->actorIndex = add_actor_to_empty_slot(tempTender->position, trainCarRot,
|
||||
tempTender->velocity, ACTOR_TRAIN_TENDER);
|
||||
@@ -112,13 +112,13 @@ ATrain::ATrain(ATrain::TenderStatus tender, size_t numCarriages, f32 speed, uint
|
||||
for (size_t i = 0; i < PassengerCars.size(); i++) {
|
||||
tempPassengerCar = &PassengerCars[i];
|
||||
if (tempPassengerCar->isActive == 1) {
|
||||
origXPos = tempPassengerCar->position[0];
|
||||
origZPos = tempPassengerCar->position[2];
|
||||
origXPos = tempPassengerCar->position.x;
|
||||
origZPos = tempPassengerCar->position.z;
|
||||
trainCarYRot = update_vehicle_following_waypoint(tempPassengerCar->position,
|
||||
(s16*) &tempPassengerCar->waypointIndex,
|
||||
Speed);
|
||||
tempPassengerCar->velocity[0] = tempPassengerCar->position[0] - origXPos;
|
||||
tempPassengerCar->velocity[2] = tempPassengerCar->position[2] - origZPos;
|
||||
tempPassengerCar->velocity.x = tempPassengerCar->position.x - origXPos;
|
||||
tempPassengerCar->velocity.z = tempPassengerCar->position.z - origZPos;
|
||||
vec3s_set(trainCarRot, 0, trainCarYRot, 0);
|
||||
tempPassengerCar->actorIndex =
|
||||
add_actor_to_empty_slot(tempPassengerCar->position, trainCarRot, tempPassengerCar->velocity,
|
||||
@@ -138,16 +138,16 @@ void ATrain::SyncComponents(TrainCarStuff* trainCar, s16 orientationY) {
|
||||
|
||||
//! @todo: Change actorIndex to ptr to TrainCar actor
|
||||
trainCarActor = (struct TrainCar*) GET_ACTOR(trainCar->actorIndex);
|
||||
trainCarActor->pos[0] = trainCar->position[0];
|
||||
trainCarActor->pos[1] = trainCar->position[1];
|
||||
trainCarActor->pos[2] = trainCar->position[2];
|
||||
trainCarActor->pos.x = trainCar->position.x;
|
||||
trainCarActor->pos.y = trainCar->position.y;
|
||||
trainCarActor->pos.z = trainCar->position.z;
|
||||
if (gIsMirrorMode != 0) {
|
||||
trainCarActor->rot[1] = -orientationY;
|
||||
trainCarActor->rot.y = -orientationY;
|
||||
} else {
|
||||
trainCarActor->rot[1] = orientationY;
|
||||
trainCarActor->rot.y = orientationY;
|
||||
}
|
||||
trainCarActor->velocity[0] = trainCar->velocity[0];
|
||||
trainCarActor->velocity[2] = trainCar->velocity[2];
|
||||
trainCarActor->velocity.x = trainCar->velocity.x;
|
||||
trainCarActor->velocity.z = trainCar->velocity.z;
|
||||
}
|
||||
|
||||
void ATrain::Tick() {
|
||||
@@ -163,14 +163,14 @@ void ATrain::Tick() {
|
||||
|
||||
oldWaypointIndex = (u16) Locomotive.waypointIndex;
|
||||
|
||||
temp_f20 = Locomotive.position[0];
|
||||
temp_f22 = Locomotive.position[2];
|
||||
temp_f20 = Locomotive.position.x;
|
||||
temp_f22 = Locomotive.position.z;
|
||||
|
||||
orientationYUpdate = update_vehicle_following_waypoint(
|
||||
Locomotive.position, (s16*) &Locomotive.waypointIndex, Speed);
|
||||
|
||||
Locomotive.velocity[0] = Locomotive.position[0] - temp_f20;
|
||||
Locomotive.velocity[2] = Locomotive.position[2] - temp_f22;
|
||||
Locomotive.velocity.x = Locomotive.position.x - temp_f20;
|
||||
Locomotive.velocity.z = Locomotive.position.z - temp_f22;
|
||||
|
||||
sync_train_components(&Locomotive, orientationYUpdate);
|
||||
|
||||
@@ -188,9 +188,9 @@ void ATrain::Tick() {
|
||||
Locomotive.position, TRAIN_SMOKE_RENDER_DISTANCE, SomeFlags);
|
||||
// Renders locomotive smoke on all screens if any player is within range.
|
||||
if ((((s16) AnotherSmokeTimer % 5) == 0) && (SomeFlags != 0)) {
|
||||
smokePos[0] = Locomotive.position[0];
|
||||
smokePos[1] = (f32) ((f64) Locomotive.position[1] + 65.0);
|
||||
smokePos[2] = (f32) ((f64) Locomotive.position[2] + 25.0);
|
||||
smokePos[0] = Locomotive.position.x;
|
||||
smokePos[1] = (f32) ((f64) Locomotive.position.y + 65.0);
|
||||
smokePos[2] = (f32) ((f64) Locomotive.position.z + 25.0);
|
||||
adjust_position_by_angle(smokePos, Locomotive.position, orientationYUpdate);
|
||||
//spawn_train_smoke(Index, smokePos, 1.1f);
|
||||
AddSmoke(Index, smokePos, 1.1f);
|
||||
@@ -199,25 +199,25 @@ void ATrain::Tick() {
|
||||
car = &Tender;
|
||||
|
||||
if (car->isActive == 1) {
|
||||
temp_f20 = car->position[0];
|
||||
temp_f22 = car->position[2];
|
||||
temp_f20 = car->position.x;
|
||||
temp_f22 = car->position.z;
|
||||
orientationYUpdate =
|
||||
update_vehicle_following_waypoint(car->position, (s16*) &car->waypointIndex, Speed);
|
||||
car->velocity[0] = car->position[0] - temp_f20;
|
||||
car->velocity[2] = car->position[2] - temp_f22;
|
||||
car->velocity.x = car->position.x - temp_f20;
|
||||
car->velocity.z = car->position.z - temp_f22;
|
||||
sync_train_components(car, orientationYUpdate);
|
||||
}
|
||||
|
||||
for (j = 0; j < PassengerCars.size(); j++) {
|
||||
car = &PassengerCars[j];
|
||||
if (car->isActive == 1) {
|
||||
temp_f20 = car->position[0];
|
||||
temp_f22 = car->position[2];
|
||||
temp_f20 = car->position.x;
|
||||
temp_f22 = car->position.z;
|
||||
|
||||
orientationYUpdate =
|
||||
update_vehicle_following_waypoint(car->position, (s16*) &car->waypointIndex, Speed);
|
||||
car->velocity[0] = car->position[0] - temp_f20;
|
||||
car->velocity[2] = car->position[2] - temp_f22;
|
||||
car->velocity.x = car->position.x - temp_f20;
|
||||
car->velocity.z = car->position.z - temp_f22;
|
||||
sync_train_components(car, orientationYUpdate);
|
||||
}
|
||||
}
|
||||
@@ -233,21 +233,21 @@ void ATrain::VehicleCollision(s32 playerId, Player* player) {
|
||||
|
||||
if (D_801631E0[playerId] != 1) {
|
||||
if (!(player->effects & 0x01000000)) {
|
||||
playerPosX = player->pos[0];
|
||||
playerPosZ = player->pos[2];
|
||||
playerPosX = player->pos.x;
|
||||
playerPosZ = player->pos.z;
|
||||
trainCar = &Locomotive;
|
||||
x_dist = playerPosX - trainCar->position[0];
|
||||
z_dist = playerPosZ - trainCar->position[2];
|
||||
x_dist = playerPosX - trainCar->position.x;
|
||||
z_dist = playerPosZ - trainCar->position.z;
|
||||
if ((x_dist > -100.0) && (x_dist < 100.0)) {
|
||||
if ((z_dist > -100.0) && (z_dist < 100.0)) {
|
||||
if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
|
||||
trainCar->velocity[2], 60.0f, 20.0f, playerPosX, playerPosZ) == 1) {
|
||||
if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
|
||||
trainCar->velocity.z, 60.0f, 20.0f, playerPosX, playerPosZ) == 1) {
|
||||
player->soundEffects |= REVERSE_SOUND_EFFECT;
|
||||
}
|
||||
trainCar = &Tender;
|
||||
if (trainCar->isActive == 1) {
|
||||
if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
|
||||
trainCar->velocity[2], 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
|
||||
if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
|
||||
trainCar->velocity.z, 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
|
||||
player->soundEffects |= REVERSE_SOUND_EFFECT;
|
||||
}
|
||||
}
|
||||
@@ -256,13 +256,13 @@ void ATrain::VehicleCollision(s32 playerId, Player* player) {
|
||||
|
||||
for (size_t i = 0; i < PassengerCars.size(); i++) {
|
||||
trainCar = &PassengerCars[i];
|
||||
x_dist = playerPosX - trainCar->position[0];
|
||||
z_dist = playerPosZ - trainCar->position[2];
|
||||
x_dist = playerPosX - trainCar->position.x;
|
||||
z_dist = playerPosZ - trainCar->position.z;
|
||||
if (trainCar->isActive == 1) {
|
||||
if ((x_dist > -100.0) && (x_dist < 100.0)) {
|
||||
if ((z_dist > -100.0) && (z_dist < 100.0)) {
|
||||
if (func_80006018(trainCar->position[0], trainCar->position[2], trainCar->velocity[0],
|
||||
trainCar->velocity[2], 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
|
||||
if (func_80006018(trainCar->position.x, trainCar->position.z, trainCar->velocity.x,
|
||||
trainCar->velocity.z, 30.0f, 20.0f, playerPosX, playerPosZ) == 1) {
|
||||
player->soundEffects |= REVERSE_SOUND_EFFECT;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -137,19 +137,19 @@ void ATruck::Tick() {
|
||||
Velocity[1] = Position[1] - sp58;
|
||||
Velocity[2] = Position[2] - sp54;
|
||||
struct Actor* vehicleActor = GET_ACTOR(ActorIndex);
|
||||
vehicleActor->pos[0] = Position[0];
|
||||
vehicleActor->pos[1] = Position[1];
|
||||
vehicleActor->pos[2] = Position[2];
|
||||
vehicleActor->rot[0] = Rotation[0];
|
||||
vehicleActor->pos.x = Position[0];
|
||||
vehicleActor->pos.y = Position[1];
|
||||
vehicleActor->pos.z = Position[2];
|
||||
vehicleActor->rot.x = Rotation[0];
|
||||
if (gIsMirrorMode != 0) {
|
||||
vehicleActor->rot[1] = -Rotation[1];
|
||||
vehicleActor->rot.y = -Rotation[1];
|
||||
} else {
|
||||
vehicleActor->rot[1] = Rotation[1];
|
||||
vehicleActor->rot.y = Rotation[1];
|
||||
}
|
||||
vehicleActor->rot[2] = Rotation[2];
|
||||
vehicleActor->velocity[0] = Velocity[0];
|
||||
vehicleActor->velocity[1] = Velocity[1];
|
||||
vehicleActor->velocity[2] = Velocity[2];
|
||||
vehicleActor->rot.z = Rotation[2];
|
||||
vehicleActor->velocity.x = Velocity[0];
|
||||
vehicleActor->velocity.y = Velocity[1];
|
||||
vehicleActor->velocity.z = Velocity[2];
|
||||
}
|
||||
|
||||
void ATruck::VehicleCollision(s32 playerId, Player* player) {
|
||||
@@ -164,9 +164,9 @@ void ATruck::VehicleCollision(s32 playerId, Player* player) {
|
||||
if (((D_801631E0[playerId] != 1) || ((((player->type & PLAYER_HUMAN) != 0)) && !(player->type & PLAYER_KART_AI))) &&
|
||||
!(player->effects & 0x01000000)) {
|
||||
|
||||
spC4 = player->pos[0];
|
||||
spC0 = player->pos[1];
|
||||
spBC = player->pos[2];
|
||||
spC4 = player->pos.x;
|
||||
spC0 = player->pos.y;
|
||||
spBC = player->pos.z;
|
||||
|
||||
temp_f12 = spC4 - Position[0];
|
||||
temp_f22 = spC0 - Position[1];
|
||||
|
||||
@@ -367,9 +367,9 @@ void freecam_keyboard_manager(Camera* camera, Vec3f forwardVector) {
|
||||
if (Down) {
|
||||
totalMove[1] -= moveSpeed; // Move down
|
||||
}
|
||||
freeCam.velocity[0] += totalMove[0];
|
||||
freeCam.velocity[1] += totalMove[1];
|
||||
freeCam.velocity[2] += totalMove[2];
|
||||
freeCam.velocity.x += totalMove[0];
|
||||
freeCam.velocity.y += totalMove[1];
|
||||
freeCam.velocity.z += totalMove[2];
|
||||
}
|
||||
|
||||
void freecam_update_controller(void) {
|
||||
@@ -402,8 +402,8 @@ void freecam_render_setup(void) {
|
||||
CM_GetProps()->NearPersp, CM_GetProps()->FarPersp, 1.0f);
|
||||
gSPPerspNormalize(gDisplayListHead++, perspNorm);
|
||||
gSPMatrix(gDisplayListHead++, (&gGfxPool->mtxPersp[0]), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_PROJECTION);
|
||||
guLookAt(&gGfxPool->mtxLookAt[0], camera1->pos[0], camera1->pos[1], camera1->pos[2], camera1->lookAt[0],
|
||||
camera1->lookAt[1], camera1->lookAt[2], camera1->up[0], camera1->up[1], camera1->up[2]);
|
||||
guLookAt(&gGfxPool->mtxLookAt[0], camera1->pos.x, camera1->pos.y, camera1->pos.z, camera1->lookAt.x,
|
||||
camera1->lookAt.y, camera1->lookAt.z, camera1->up[0], camera1->up[1], camera1->up[2]);
|
||||
gSPMatrix(gDisplayListHead++, (&gGfxPool->mtxLookAt[0]), G_MTX_NOPUSH | G_MTX_MUL | G_MTX_PROJECTION);
|
||||
mtxf_identity(matrix);
|
||||
gSPSetGeometryMode(gDisplayListHead++, G_CULL_BACK);
|
||||
|
||||
@@ -22,58 +22,58 @@ f32 gRotDampValue = 0.96f;
|
||||
void freecam_tick(Camera* camera, Vec3f forwardVector) {
|
||||
|
||||
// Apply camera movement
|
||||
camera->pos[0] += freeCam.velocity[0] * gDeltaTime;
|
||||
camera->pos[1] += freeCam.velocity[1] * gDeltaTime;
|
||||
camera->pos[2] += freeCam.velocity[2] * gDeltaTime;
|
||||
camera->pos.x += freeCam.velocity.x * gDeltaTime;
|
||||
camera->pos.y += freeCam.velocity.y * gDeltaTime;
|
||||
camera->pos.z += freeCam.velocity.z * gDeltaTime;
|
||||
|
||||
// Damp the velocity back to zero over time (camera slowly comes to a stop)
|
||||
freeCam.velocity[0] *= gDampValue;
|
||||
freeCam.velocity[1] *= gDampValue;
|
||||
freeCam.velocity[2] *= gDampValue;
|
||||
freeCam.velocity.x *= gDampValue;
|
||||
freeCam.velocity.y *= gDampValue;
|
||||
freeCam.velocity.z *= gDampValue;
|
||||
|
||||
// Apply camera rotation
|
||||
camera->rot[0] += freeCam.rotVelocity[0] * gDeltaTime;
|
||||
camera->rot[1] += freeCam.rotVelocity[1] * gDeltaTime;
|
||||
camera->rot[2] += freeCam.rotVelocity[2] * gDeltaTime;
|
||||
camera->rot.x += freeCam.rotVelocity.x * gDeltaTime;
|
||||
camera->rot.y += freeCam.rotVelocity.y * gDeltaTime;
|
||||
camera->rot.z += freeCam.rotVelocity.z * gDeltaTime;
|
||||
|
||||
// Damp the velocity back to zero over time (camera rot slowly comes to a stop)
|
||||
freeCam.rotVelocity[0] *= gRotDampValue;
|
||||
freeCam.rotVelocity[1] *= gRotDampValue;
|
||||
freeCam.rotVelocity[2] *= gRotDampValue;
|
||||
freeCam.rotVelocity.x *= gRotDampValue;
|
||||
freeCam.rotVelocity.y *= gRotDampValue;
|
||||
freeCam.rotVelocity.z *= gRotDampValue;
|
||||
|
||||
// Update lookAt
|
||||
camera->lookAt[0] = camera->pos[0] + forwardVector[0];
|
||||
camera->lookAt[1] = camera->pos[1] + forwardVector[1];
|
||||
camera->lookAt[2] = camera->pos[2] + forwardVector[2];
|
||||
camera->lookAt.x = camera->pos.x + forwardVector.x;
|
||||
camera->lookAt.y = camera->pos.y + forwardVector.y;
|
||||
camera->lookAt.z = camera->pos.z + forwardVector.z;
|
||||
}
|
||||
|
||||
void freecam_calculate_forward_vector_allow_rotation(Camera* camera, Vec3f forwardVector) {
|
||||
// Convert yaw from 0-65535 to degrees
|
||||
f32 pitch = (camera->rot[2] / 65535.0f) * 360.0f;
|
||||
f32 yaw = (camera->rot[1] / 65535.0f) * 360.0f;
|
||||
f32 pitch = (camera->rot.z / 65535.0f) * 360.0f;
|
||||
f32 yaw = (camera->rot.y / 65535.0f) * 360.0f;
|
||||
|
||||
// Convert degrees to radians
|
||||
pitch = pitch * M_PI / 180.0f;
|
||||
yaw = yaw * M_PI / 180.0f;
|
||||
|
||||
// Calculate the forward vector based on yaw, ignoring pitch to keep height unchanged
|
||||
forwardVector[0] = -sinf(yaw);
|
||||
forwardVector[1] = -sinf(pitch); // Keep the height unchanged
|
||||
forwardVector[2] = cosf(yaw);
|
||||
forwardVector.x = -sinf(yaw);
|
||||
forwardVector.y = -sinf(pitch); // Keep the height unchanged
|
||||
forwardVector.z = cosf(yaw);
|
||||
}
|
||||
|
||||
f32 gFreecamFollowFactor = 0.7;
|
||||
|
||||
void freecam_target_player(Camera* camera, Vec3f forwardVector) {
|
||||
// Apply damping to velocity
|
||||
freeCam.velocity[0] *= gDampValue;
|
||||
freeCam.velocity[1] *= gDampValue;
|
||||
freeCam.velocity[2] *= gDampValue;
|
||||
freeCam.velocity.x *= gDampValue;
|
||||
freeCam.velocity.y *= gDampValue;
|
||||
freeCam.velocity.z *= gDampValue;
|
||||
|
||||
// Calculate the direction from the player to the camera
|
||||
f32 dirX = gPlayers[fRankIndex].pos[0] - camera->pos[0];
|
||||
f32 dirY = gPlayers[fRankIndex].pos[1] - camera->pos[1];
|
||||
f32 dirZ = gPlayers[fRankIndex].pos[2] - camera->pos[2];
|
||||
f32 dirX = gPlayers[fRankIndex].pos.x - camera->pos.x;
|
||||
f32 dirY = gPlayers[fRankIndex].pos.y - camera->pos.y;
|
||||
f32 dirZ = gPlayers[fRankIndex].pos.z - camera->pos.z;
|
||||
|
||||
// Normalize the direction vector (if needed)
|
||||
f32 length = sqrtf(dirX * dirX + dirY * dirY + dirZ * dirZ);
|
||||
@@ -84,33 +84,33 @@ void freecam_target_player(Camera* camera, Vec3f forwardVector) {
|
||||
}
|
||||
|
||||
// Update the camera's look-at direction
|
||||
camera->lookAt[0] = camera->pos[0] + dirX;
|
||||
camera->lookAt[1] = camera->pos[1] + dirY;
|
||||
camera->lookAt[2] = camera->pos[2] + dirZ;
|
||||
camera->lookAt.x = camera->pos.x + dirX;
|
||||
camera->lookAt.y = camera->pos.y + dirY;
|
||||
camera->lookAt.z = camera->pos.z + dirZ;
|
||||
|
||||
// Calculate the forward vector based on the updated look-at direction
|
||||
forwardVector[0] = camera->lookAt[0] - camera->pos[0];
|
||||
forwardVector[1] = camera->lookAt[1] - camera->pos[1];
|
||||
forwardVector[2] = camera->lookAt[2] - camera->pos[2];
|
||||
forwardVector.x = camera->lookAt.x - camera->pos.x;
|
||||
forwardVector.y = camera->lookAt.y - camera->pos.y;
|
||||
forwardVector.z = camera->lookAt.z - camera->pos.z;
|
||||
|
||||
// Normalize the forward vector
|
||||
f32 forwardLength = sqrtf(forwardVector[0] * forwardVector[0] + forwardVector[1] * forwardVector[1] +
|
||||
forwardVector[2] * forwardVector[2]);
|
||||
f32 forwardLength = sqrtf(forwardVector.x * forwardVector.x + forwardVector.y * forwardVector.y +
|
||||
forwardVector.z * forwardVector.z);
|
||||
if (forwardLength > 0.0f) {
|
||||
forwardVector[0] /= forwardLength;
|
||||
forwardVector[1] /= forwardLength;
|
||||
forwardVector[2] /= forwardLength;
|
||||
forwardVector.x /= forwardLength;
|
||||
forwardVector.y /= forwardLength;
|
||||
forwardVector.z /= forwardLength;
|
||||
}
|
||||
|
||||
// Store or return the forward vector as needed for subsequent movement calculations
|
||||
freeCam.forwardVector[0] = forwardVector[0];
|
||||
freeCam.forwardVector[1] = forwardVector[1];
|
||||
freeCam.forwardVector[2] = forwardVector[2];
|
||||
freeCam.forwardVector.x = forwardVector.x;
|
||||
freeCam.forwardVector.y = forwardVector.y;
|
||||
freeCam.forwardVector.z = forwardVector.z;
|
||||
|
||||
// Movement
|
||||
freeCam.velocity[0] += gPlayers[fRankIndex].velocity[0] * gFreecamFollowFactor;
|
||||
freeCam.velocity[1] += gPlayers[fRankIndex].velocity[1] * gFreecamFollowFactor;
|
||||
freeCam.velocity[2] += gPlayers[fRankIndex].velocity[2] * gFreecamFollowFactor;
|
||||
freeCam.velocity.x += gPlayers[fRankIndex].velocity.x * gFreecamFollowFactor;
|
||||
freeCam.velocity.y += gPlayers[fRankIndex].velocity.y * gFreecamFollowFactor;
|
||||
freeCam.velocity.z += gPlayers[fRankIndex].velocity.z * gFreecamFollowFactor;
|
||||
}
|
||||
|
||||
void freecam_get_player_from_character(s32 characterId) {
|
||||
|
||||
@@ -5,8 +5,8 @@
|
||||
|
||||
void moon_jump(Player* player, struct Controller* controller) {
|
||||
if (controller->button & L_TRIG) {
|
||||
if (player->velocity[1] <= 3.2f) {
|
||||
player->velocity[1] += 0.5f;
|
||||
if (player->velocity.y <= 3.2f) {
|
||||
player->velocity.y += 0.5f;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -708,7 +708,7 @@ void display_debug_info(void) {
|
||||
(gControllerOne->button & B_BUTTON)) {
|
||||
D_800DC514 = false;
|
||||
}
|
||||
rotY = camera1->rot[1];
|
||||
rotY = camera1->rot.y;
|
||||
gDebugPathCount = D_800DC5EC->pathCounter;
|
||||
|
||||
if (rotY < 0x2000) {
|
||||
|
||||
+29
-29
@@ -454,7 +454,7 @@ bool is_particle_on_screen(Vec3f arg0, Camera* arg1, u16 arg2) {
|
||||
}
|
||||
|
||||
ret = false;
|
||||
temp_t9 = (get_angle_between_xy(arg1->pos[0], arg0[0], arg1->pos[2], arg0[2]) + (arg2 / 2)) - arg1->rot[1];
|
||||
temp_t9 = (get_angle_between_xy(arg1->pos.x, arg0[0], arg1->pos.z, arg0[2]) + (arg2 / 2)) - arg1->rot.y;
|
||||
if ((temp_t9 >= 0) && (arg2 >= temp_t9)) {
|
||||
ret = true;
|
||||
}
|
||||
@@ -465,9 +465,9 @@ void func_800419F8(void) {
|
||||
Vec3f pos;
|
||||
Vec3f vec;
|
||||
|
||||
pos[0] = 0.0f;
|
||||
pos[1] = 0.0f;
|
||||
pos[2] = 120.0f;
|
||||
pos.x = 0.0f;
|
||||
pos.y = 0.0f;
|
||||
pos.z = 120.0f;
|
||||
vec3f_rotate_x_y(vec, pos, (s16*) D_80165834);
|
||||
D_80165840[0] = vec[0];
|
||||
D_80165840[1] = vec[1];
|
||||
@@ -880,15 +880,15 @@ void mtxf_set_matrix_gObjectList(s32 objectIndex, Mat4 transformMatrix) {
|
||||
transformMatrix[0][0] = object->sizeScaling * ((cosY * cosZ) + (sinX * sinY * sinZ));
|
||||
transformMatrix[1][0] = object->sizeScaling * ((-cosY * sinZ) + sinX * sinY * cosZ);
|
||||
transformMatrix[2][0] = object->sizeScaling * (cosX * sinY);
|
||||
transformMatrix[3][0] = object->pos[0];
|
||||
transformMatrix[3][0] = object->pos.x;
|
||||
transformMatrix[0][1] = object->sizeScaling * (cosX * sinZ);
|
||||
transformMatrix[1][1] = object->sizeScaling * (cosX * cosZ);
|
||||
transformMatrix[2][1] = object->sizeScaling * -sinX;
|
||||
transformMatrix[3][1] = object->pos[1];
|
||||
transformMatrix[3][1] = object->pos.y;
|
||||
transformMatrix[0][2] = object->sizeScaling * ((-sinY * cosZ) + (sinX * cosY * sinZ));
|
||||
transformMatrix[1][2] = object->sizeScaling * ((sinY * sinZ) + (sinX * cosY * cosZ));
|
||||
transformMatrix[2][2] = object->sizeScaling * (cosX * cosY);
|
||||
transformMatrix[3][2] = object->pos[2];
|
||||
transformMatrix[3][2] = object->pos.z;
|
||||
transformMatrix[0][3] = 0.0f;
|
||||
transformMatrix[1][3] = 0.0f;
|
||||
transformMatrix[2][3] = 0.0f;
|
||||
@@ -961,22 +961,22 @@ UNUSED void vec3f_rotate(Vec3f dest, Vec3f pos, Vec3s rot) {
|
||||
f32 sine3;
|
||||
f32 cosine3;
|
||||
|
||||
sine1 = sins(rot[0]);
|
||||
cosine1 = coss(rot[0]);
|
||||
sine2 = sins(rot[1]);
|
||||
cosine2 = coss(rot[1]);
|
||||
sine3 = sins(rot[2]);
|
||||
cosine3 = coss(rot[2]);
|
||||
sine1 = sins(rot.x);
|
||||
cosine1 = coss(rot.x);
|
||||
sine2 = sins(rot.y);
|
||||
cosine2 = coss(rot.y);
|
||||
sine3 = sins(rot.z);
|
||||
cosine3 = coss(rot.z);
|
||||
// it's a matrix multiplication
|
||||
sp74 = pos[0] * ((cosine2 * cosine3) + ((sine1 * sine2) * sine3));
|
||||
temp_f4 = pos[1] * ((-cosine2 * sine3) + ((sine1 * sine2) * cosine3));
|
||||
temp_f8 = pos[2] * (cosine1 * sine2);
|
||||
sp70 = pos[0] * (cosine1 * sine3);
|
||||
sp64 = pos[1] * (cosine1 * cosine3);
|
||||
sp58 = pos[2] * -sine1;
|
||||
sp6C = pos[0] * ((-sine2 * cosine3) + ((sine1 * cosine2) * sine3));
|
||||
sp60 = pos[1] * ((sine2 * sine3) + ((sine1 * cosine2) * cosine3));
|
||||
sp54 = pos[2] * (cosine1 * cosine2);
|
||||
sp74 = pos.x * ((cosine2 * cosine3) + ((sine1 * sine2) * sine3));
|
||||
temp_f4 = pos.y * ((-cosine2 * sine3) + ((sine1 * sine2) * cosine3));
|
||||
temp_f8 = pos.z * (cosine1 * sine2);
|
||||
sp70 = pos.x * (cosine1 * sine3);
|
||||
sp64 = pos.y * (cosine1 * cosine3);
|
||||
sp58 = pos.z * -sine1;
|
||||
sp6C = pos.x * ((-sine2 * cosine3) + ((sine1 * cosine2) * sine3));
|
||||
sp60 = pos.y * ((sine2 * sine3) + ((sine1 * cosine2) * cosine3));
|
||||
sp54 = pos.z * (cosine1 * cosine2);
|
||||
dest[0] = sp74 + temp_f4 + temp_f8;
|
||||
dest[1] = sp70 + sp64 + sp58;
|
||||
dest[2] = sp6C + sp60 + sp54;
|
||||
@@ -992,13 +992,13 @@ void vec3f_rotate_x_y(Vec3f dest, Vec3f pos, Vec3s rot) {
|
||||
f32 sine2;
|
||||
f32 cosine2;
|
||||
|
||||
sp2C = pos[0];
|
||||
sp28 = pos[1];
|
||||
sp24 = pos[2];
|
||||
sine1 = sins(rot[0]);
|
||||
cosine1 = coss(rot[0]);
|
||||
sine2 = sins(rot[1]);
|
||||
cosine2 = coss(rot[1]);
|
||||
sp2C = pos.x;
|
||||
sp28 = pos.y;
|
||||
sp24 = pos.z;
|
||||
sine1 = sins(rot.x);
|
||||
cosine1 = coss(rot.x);
|
||||
sine2 = sins(rot.y);
|
||||
cosine2 = coss(rot.y);
|
||||
dest[0] = (sp2C * cosine2) - (sp24 * sine2);
|
||||
dest[1] = (sp2C * sine1 * sine2) + (sp28 * cosine1) + (sp24 * sine1 * cosine2);
|
||||
dest[2] = ((sp2C * cosine1 * sine2) - (sp28 * sine1)) + (sp24 * cosine1 * cosine2);
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
#include "main.h"
|
||||
|
||||
void replicate_player(const char* data) {
|
||||
// gPlayerOne->pos[0];
|
||||
// gPlayerOne->pos.x;
|
||||
// send_data_packet(client, PACKET_PLAYER, &gPlayerOne, sizeof(Player));
|
||||
}
|
||||
|
||||
|
||||
+166
-166
@@ -725,7 +725,7 @@ void func_8002934C(Player* player, Camera* camera, s8 screenId, s8 playerId) {
|
||||
s32 var_t0;
|
||||
u16 var_a0;
|
||||
|
||||
player->unk_048[screenId] = atan2s(player->pos[0] - camera->pos[0], player->pos[2] - camera->pos[2]);
|
||||
player->unk_048[screenId] = atan2s(player->pos.x - camera->pos.x, player->pos.z - camera->pos.z);
|
||||
player->animFrameSelector[screenId] =
|
||||
(u16) ((((player->unk_048[screenId]) + player->rotation[1] + player->unk_0C0))) / 128;
|
||||
|
||||
@@ -746,9 +746,9 @@ void func_8002934C(Player* player, Camera* camera, s8 screenId, s8 playerId) {
|
||||
player->unk_0D4[screenId] = (((func_802B7C40(temp_f0 / temp_f2)) * 0.9));
|
||||
} else {
|
||||
if (((player->animFrameSelector[screenId]) >= 0) && ((player->animFrameSelector[screenId]) < 0x101)) {
|
||||
var_f0 = player->oldPos[1] - player->pos[1];
|
||||
var_f0 = player->oldPos[1] - player->pos.y;
|
||||
} else {
|
||||
var_f0 = player->pos[1] - player->oldPos[1];
|
||||
var_f0 = player->pos.y - player->oldPos[1];
|
||||
}
|
||||
player->unk_0D4[screenId] = (s16) ((s32) (((f64) func_802B7C40(var_f0 / temp_f2)) * 0.5));
|
||||
}
|
||||
@@ -879,45 +879,45 @@ void func_80029B4C(Player* player, UNUSED f32 arg1, f32 arg2, UNUSED f32 arg3) {
|
||||
sp8C[1] = -player->boundingBoxSize;
|
||||
sp8C[2] = var_f12 - 2.0f;
|
||||
mtxf_translate_vec3f_mat3(sp8C, sp5C);
|
||||
sp80[0] = player->tyres[FRONT_LEFT].pos[0];
|
||||
sp80[1] = player->tyres[FRONT_LEFT].pos[1];
|
||||
sp80[2] = player->tyres[FRONT_LEFT].pos[2];
|
||||
player->tyres[FRONT_LEFT].pos[0] = player->pos[0] + sp8C[0];
|
||||
player->tyres[FRONT_LEFT].pos[1] = player->pos[1] + sp8C[1];
|
||||
player->tyres[FRONT_LEFT].pos[2] = player->pos[2] + sp8C[2];
|
||||
sp80[0] = player->tyres[FRONT_LEFT].pos.x;
|
||||
sp80[1] = player->tyres[FRONT_LEFT].pos.y;
|
||||
sp80[2] = player->tyres[FRONT_LEFT].pos.z;
|
||||
player->tyres[FRONT_LEFT].pos.x = player->pos.x + sp8C[0];
|
||||
player->tyres[FRONT_LEFT].pos.y = player->pos.y + sp8C[1];
|
||||
player->tyres[FRONT_LEFT].pos.z = player->pos.z + sp8C[2];
|
||||
player_terrain_collision(player, &player->tyres[FRONT_LEFT], sp80[0], sp80[1], sp80[2]);
|
||||
sp8C[0] = (-var_f12) + 3.6;
|
||||
sp8C[1] = -player->boundingBoxSize;
|
||||
sp8C[2] = var_f12 - 2.0f;
|
||||
mtxf_translate_vec3f_mat3(sp8C, sp5C);
|
||||
sp80[0] = player->tyres[FRONT_RIGHT].pos[0];
|
||||
sp80[1] = player->tyres[FRONT_RIGHT].pos[1];
|
||||
sp80[2] = player->tyres[FRONT_RIGHT].pos[2];
|
||||
player->tyres[FRONT_RIGHT].pos[0] = player->pos[0] + sp8C[0];
|
||||
player->tyres[FRONT_RIGHT].pos[1] = player->pos[1] + sp8C[1];
|
||||
player->tyres[FRONT_RIGHT].pos[2] = player->pos[2] + sp8C[2];
|
||||
sp80[0] = player->tyres[FRONT_RIGHT].pos.x;
|
||||
sp80[1] = player->tyres[FRONT_RIGHT].pos.y;
|
||||
sp80[2] = player->tyres[FRONT_RIGHT].pos.z;
|
||||
player->tyres[FRONT_RIGHT].pos.x = player->pos.x + sp8C[0];
|
||||
player->tyres[FRONT_RIGHT].pos.y = player->pos.y + sp8C[1];
|
||||
player->tyres[FRONT_RIGHT].pos.z = player->pos.z + sp8C[2];
|
||||
player_terrain_collision(player, &player->tyres[FRONT_RIGHT], sp80[0], sp80[1], sp80[2]);
|
||||
sp8C[0] = var_f12 - 2.6;
|
||||
sp8C[1] = -player->boundingBoxSize;
|
||||
sp8C[2] = (-var_f12) + 4.0f;
|
||||
mtxf_translate_vec3f_mat3(sp8C, sp5C);
|
||||
sp80[0] = player->tyres[BACK_LEFT].pos[0];
|
||||
sp80[1] = player->tyres[BACK_LEFT].pos[1];
|
||||
sp80[2] = player->tyres[BACK_LEFT].pos[2];
|
||||
player->tyres[BACK_LEFT].pos[0] = player->pos[0] + sp8C[0];
|
||||
player->tyres[BACK_LEFT].pos[1] = player->pos[1] + sp8C[1];
|
||||
player->tyres[BACK_LEFT].pos[2] = player->pos[2] + sp8C[2];
|
||||
sp80[0] = player->tyres[BACK_LEFT].pos.x;
|
||||
sp80[1] = player->tyres[BACK_LEFT].pos.y;
|
||||
sp80[2] = player->tyres[BACK_LEFT].pos.z;
|
||||
player->tyres[BACK_LEFT].pos.x = player->pos.x + sp8C[0];
|
||||
player->tyres[BACK_LEFT].pos.y = player->pos.y + sp8C[1];
|
||||
player->tyres[BACK_LEFT].pos.z = player->pos.z + sp8C[2];
|
||||
player_terrain_collision(player, &player->tyres[BACK_LEFT], sp80[0], sp80[1], sp80[2]);
|
||||
sp8C[0] = (-var_f12) + 2.6;
|
||||
sp8C[1] = -player->boundingBoxSize;
|
||||
sp8C[2] = (-var_f12) + 4.0f;
|
||||
mtxf_translate_vec3f_mat3(sp8C, sp5C);
|
||||
sp80[0] = player->tyres[BACK_RIGHT].pos[0];
|
||||
sp80[1] = player->tyres[BACK_RIGHT].pos[1];
|
||||
sp80[2] = player->tyres[BACK_RIGHT].pos[2];
|
||||
player->tyres[BACK_RIGHT].pos[0] = player->pos[0] + sp8C[0];
|
||||
player->tyres[BACK_RIGHT].pos[1] = player->pos[1] + sp8C[1];
|
||||
player->tyres[BACK_RIGHT].pos[2] = player->pos[2] + sp8C[2];
|
||||
sp80[0] = player->tyres[BACK_RIGHT].pos.x;
|
||||
sp80[1] = player->tyres[BACK_RIGHT].pos.y;
|
||||
sp80[2] = player->tyres[BACK_RIGHT].pos.z;
|
||||
player->tyres[BACK_RIGHT].pos.x = player->pos.x + sp8C[0];
|
||||
player->tyres[BACK_RIGHT].pos.y = player->pos.y + sp8C[1];
|
||||
player->tyres[BACK_RIGHT].pos.z = player->pos.z + sp8C[2];
|
||||
player_terrain_collision(player, &player->tyres[BACK_RIGHT], sp80[0], sp80[1], sp80[2]);
|
||||
if (!(player->effects & 8)) {
|
||||
a = (player->tyres[BACK_LEFT].baseHeight + player->tyres[FRONT_LEFT].baseHeight) / 2;
|
||||
@@ -985,28 +985,28 @@ void func_8002A194(Player* player, f32 arg1, f32 arg2, f32 arg3) {
|
||||
var_f20 = (((gCharacterSize[player->characterId] * 18) / 2) * player->size) - 1;
|
||||
}
|
||||
|
||||
player->tyres[FRONT_LEFT].pos[2] = (coss(temp_v1 + 0x2000) * var_f20) + arg3;
|
||||
player->tyres[FRONT_LEFT].pos.z = (coss(temp_v1 + 0x2000) * var_f20) + arg3;
|
||||
temp_f12 = (sins(temp_v1 + 0x2000) * var_f20) + arg1;
|
||||
player->tyres[FRONT_LEFT].pos[0] = temp_f12;
|
||||
player->tyres[FRONT_LEFT].pos.x = temp_f12;
|
||||
player->tyres[FRONT_LEFT].baseHeight =
|
||||
calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_LEFT].pos[2], player->collision.meshIndexZX);
|
||||
calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_LEFT].pos.z, player->collision.meshIndexZX);
|
||||
|
||||
player->tyres[FRONT_RIGHT].pos[2] = (coss(temp_v1 - 0x2000) * var_f20) + arg3;
|
||||
player->tyres[FRONT_RIGHT].pos.z = (coss(temp_v1 - 0x2000) * var_f20) + arg3;
|
||||
temp_f12 = (sins(temp_v1 - 0x2000) * var_f20) + arg1;
|
||||
player->tyres[FRONT_RIGHT].pos[0] = temp_f12;
|
||||
player->tyres[FRONT_RIGHT].pos.x = temp_f12;
|
||||
player->tyres[FRONT_RIGHT].baseHeight =
|
||||
calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_RIGHT].pos[2], player->collision.meshIndexZX);
|
||||
calculate_surface_height(temp_f12, arg2, player->tyres[FRONT_RIGHT].pos.z, player->collision.meshIndexZX);
|
||||
|
||||
player->tyres[BACK_LEFT].pos[2] = (coss(temp_v1 + 0x6000) * var_f20) + arg3;
|
||||
player->tyres[BACK_LEFT].pos.z = (coss(temp_v1 + 0x6000) * var_f20) + arg3;
|
||||
temp_f12 = (sins(temp_v1 + 0x6000) * var_f20) + arg1;
|
||||
player->tyres[BACK_LEFT].pos[0] = temp_f12;
|
||||
player->tyres[BACK_LEFT].pos.x = temp_f12;
|
||||
player->tyres[BACK_LEFT].baseHeight =
|
||||
calculate_surface_height(temp_f12, arg2, player->tyres[BACK_LEFT].pos[2], player->collision.meshIndexZX);
|
||||
calculate_surface_height(temp_f12, arg2, player->tyres[BACK_LEFT].pos.z, player->collision.meshIndexZX);
|
||||
|
||||
player->tyres[BACK_RIGHT].pos[2] = (coss(temp_v1 - 0x6000) * var_f20) + arg3;
|
||||
player->tyres[BACK_RIGHT].pos[0] = (sins(temp_v1 - 0x6000) * var_f20) + arg1;
|
||||
player->tyres[BACK_RIGHT].pos.z = (coss(temp_v1 - 0x6000) * var_f20) + arg3;
|
||||
player->tyres[BACK_RIGHT].pos.x = (sins(temp_v1 - 0x6000) * var_f20) + arg1;
|
||||
player->tyres[BACK_RIGHT].baseHeight = calculate_surface_height(
|
||||
player->tyres[BACK_LEFT].pos[0], arg2, player->tyres[BACK_LEFT].pos[2], player->collision.meshIndexZX);
|
||||
player->tyres[BACK_LEFT].pos.x, arg2, player->tyres[BACK_LEFT].pos.z, player->collision.meshIndexZX);
|
||||
|
||||
if ((player->effects & 8) != 8) {
|
||||
player->unk_230 = (player->tyres[BACK_LEFT].baseHeight + player->tyres[FRONT_LEFT].baseHeight) / 2;
|
||||
@@ -1539,9 +1539,9 @@ void func_8002B9CC(Player* player, s8 arg1, UNUSED s32 arg2) {
|
||||
}
|
||||
}
|
||||
} else {
|
||||
temp_f0 = D_80165070[arg1][0] - player->velocity[0];
|
||||
temp_f2 = D_80165070[arg1][1] - player->velocity[1];
|
||||
temp_f14 = D_80165070[arg1][2] - player->velocity[2];
|
||||
temp_f0 = D_80165070[arg1][0] - player->velocity.x;
|
||||
temp_f2 = D_80165070[arg1][1] - player->velocity.y;
|
||||
temp_f14 = D_80165070[arg1][2] - player->velocity.z;
|
||||
if (sqrtf((temp_f0 * temp_f0) + (temp_f2 * temp_f2) + (temp_f14 * temp_f14)) >= 4.2) {
|
||||
player->unk_08C /= 4;
|
||||
player->currentSpeed /= 4;
|
||||
@@ -1672,7 +1672,7 @@ void func_8002BF4C(Player* player, s8 arg1) {
|
||||
for (i = 0; i < NUM_PLAYERS; i++) {
|
||||
playerBorrow = &players[i];
|
||||
if (((player != playerBorrow) && ((playerBorrow->type & 0x100) == 0) && (playerBorrow->type & 0x8000)) &&
|
||||
((var_a2 = func_8001FD78(player, playerBorrow->pos[0], playerBorrow->pos[1], playerBorrow->pos[2]),
|
||||
((var_a2 = func_8001FD78(player, playerBorrow->pos.x, playerBorrow->pos.y, playerBorrow->pos.z),
|
||||
var_a2 == 1))) {
|
||||
player->unk_0E2 += 1;
|
||||
if (player->unk_0E2 >= 0x3D) {
|
||||
@@ -1763,18 +1763,18 @@ void func_8002C17C(Player* player, s8 playerId) {
|
||||
|
||||
void func_8002C4F8(Player* player, s8 arg1) {
|
||||
D_801652A0[arg1] = get_water_level(player);
|
||||
if (player->pos[1] <= D_801652A0[arg1]) {
|
||||
if (player->pos.y <= D_801652A0[arg1]) {
|
||||
player->unk_0DE |= 0x0002;
|
||||
} else {
|
||||
player->unk_0DE &= ~0x0002;
|
||||
}
|
||||
if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos[1])) {
|
||||
if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos.y)) {
|
||||
player->unk_0DE |= 1;
|
||||
player->unk_0DE &= ~0x0002;
|
||||
} else {
|
||||
player->unk_0DE &= ~0x0001;
|
||||
}
|
||||
if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos[1])) {
|
||||
if (player->boundingBoxSize < (D_801652A0[arg1] - player->pos.y)) {
|
||||
if ((player->unk_0DE & 4) != 4) {
|
||||
player->unk_0DE |= 8;
|
||||
player->unk_0DE |= 4;
|
||||
@@ -1792,7 +1792,7 @@ void func_8002C4F8(Player* player, s8 arg1) {
|
||||
(GetCourse() == GetRainbowRoad())) {
|
||||
player->unk_0DE &= ~0x000C;
|
||||
}
|
||||
if ((player->boundingBoxSize < (D_801652A0[arg1] - player->pos[1])) &&
|
||||
if ((player->boundingBoxSize < (D_801652A0[arg1] - player->pos.y)) &&
|
||||
(player->collision.surfaceDistance[2] >= 600.0f)) {
|
||||
player->unk_0CA |= 1;
|
||||
}
|
||||
@@ -1861,7 +1861,7 @@ void func_8002C954(Player* player, s8 playerId, Vec3f arg2) {
|
||||
f32 ydist;
|
||||
f32 zdist;
|
||||
|
||||
temp_f0 = player->pos[1] - player->unk_074;
|
||||
temp_f0 = player->pos.y - player->unk_074;
|
||||
|
||||
if (((((player->effects & 0x10000) != 0x10000) &&
|
||||
((player->effects & BOOST_RAMP_ASPHALT_EFFECT) == BOOST_RAMP_ASPHALT_EFFECT)) ||
|
||||
@@ -2017,8 +2017,8 @@ void func_8002D028(Player* player, s8 arg1) {
|
||||
func_8003680C(player, (s16) temp_t1);
|
||||
D_80165020[arg1] = (s16) temp_t1;
|
||||
|
||||
temp_f18 = sqrtf((sp4C[0] - player->pos[0]) * (sp4C[0] - player->pos[0]) +
|
||||
(sp4C[2] - player->pos[2]) * (sp4C[2] - player->pos[2]));
|
||||
temp_f18 = sqrtf((sp4C[0] - player->pos.x) * (sp4C[0] - player->pos.x) +
|
||||
(sp4C[2] - player->pos.z) * (sp4C[2] - player->pos.z));
|
||||
if (temp_f18 <= 8.0f) {
|
||||
adjust_angle(&player->rotation[1], -0x8000, 0x016C);
|
||||
if ((player->rotation[1] < (-0x7F41)) || (player->rotation[1] > 0x7F41)) {
|
||||
@@ -2029,9 +2029,9 @@ void func_8002D028(Player* player, s8 arg1) {
|
||||
player->unk_104 = 0;
|
||||
player->tyreSpeed = 0;
|
||||
player->unk_07C = 0;
|
||||
player->velocity[0] = 0;
|
||||
player->velocity[1] = 0;
|
||||
player->velocity[2] = 0;
|
||||
player->velocity.x = 0;
|
||||
player->velocity.y = 0;
|
||||
player->velocity.z = 0;
|
||||
player->unk_0C0 = 0;
|
||||
player->unk_078 = 0;
|
||||
} else {
|
||||
@@ -2117,8 +2117,8 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
|
||||
spB0 = -1 * player->kartGravity;
|
||||
spAC = 0 * (player->unk_064[2] + sp16C[2]);
|
||||
}
|
||||
temp_f2_2 = ((player->oldPos[2] - player->pos[2]) * coss(player->rotation[1] + player->unk_0C0)) +
|
||||
(-(player->oldPos[0] - player->pos[0]) * sins(player->rotation[1] + player->unk_0C0));
|
||||
temp_f2_2 = ((player->oldPos[2] - player->pos.z) * coss(player->rotation[1] + player->unk_0C0)) +
|
||||
(-(player->oldPos[0] - player->pos.x) * sins(player->rotation[1] + player->unk_0C0));
|
||||
if (temp_f2_2 > 0.1) {
|
||||
player->unk_044 |= 8;
|
||||
} else {
|
||||
@@ -2137,9 +2137,9 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
|
||||
func_8002C7E4(player, playerId, screenId);
|
||||
sp184[2] = func_80030150(player, playerId);
|
||||
mtxf_translate_vec3f_mat3(sp184, player->orientationMatrix);
|
||||
sp98[0] = player->velocity[0];
|
||||
sp98[1] = player->velocity[1];
|
||||
sp98[2] = player->velocity[2];
|
||||
sp98[0] = player->velocity.x;
|
||||
sp98[1] = player->velocity.y;
|
||||
sp98[2] = player->velocity.z;
|
||||
if (((player->unk_10C < 3) && (((s32) player->unk_256) < 3)) ||
|
||||
((player->effects & BOOST_EFFECT) == BOOST_EFFECT)) {
|
||||
|
||||
@@ -2181,16 +2181,16 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
|
||||
player->unk_044 &= 0xFFEF;
|
||||
}
|
||||
|
||||
posX = player->pos[0];
|
||||
posY = player->pos[1];
|
||||
posZ = player->pos[2];
|
||||
posX = player->pos.x;
|
||||
posY = player->pos.y;
|
||||
posZ = player->pos.z;
|
||||
|
||||
player->oldPos[0] = player->pos[0];
|
||||
player->oldPos[2] = player->pos[2];
|
||||
player->oldPos[1] = player->pos[1];
|
||||
nextX = posX + player->velocity[0] + D_8018CE10[playerId].unk_04[0];
|
||||
nextY = posY + player->velocity[1];
|
||||
nextZ = posZ + player->velocity[2] + D_8018CE10[playerId].unk_04[2];
|
||||
player->oldPos[0] = player->pos.x;
|
||||
player->oldPos[2] = player->pos.z;
|
||||
player->oldPos[1] = player->pos.y;
|
||||
nextX = posX + player->velocity.x + D_8018CE10[playerId].unk_04[0];
|
||||
nextY = posY + player->velocity.y;
|
||||
nextZ = posZ + player->velocity.z + D_8018CE10[playerId].unk_04[2];
|
||||
|
||||
if (((((player->unk_0CA & 2) != 2) && ((player->unk_0CA & 8) != 8)) &&
|
||||
((player->effects & HIT_EFFECT) != HIT_EFFECT)) &&
|
||||
@@ -2319,39 +2319,39 @@ void func_8002D268(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
|
||||
sp98[0] = sp98[0] + (-1 * sp98[0]);
|
||||
sp98[2] = sp98[2] + (-1 * sp98[2]);
|
||||
} else {
|
||||
player->pos[0] = nextX;
|
||||
player->pos[2] = nextZ;
|
||||
player->pos.x = nextX;
|
||||
player->pos.z = nextZ;
|
||||
}
|
||||
player->pos[1] = nextY;
|
||||
player->pos.y = nextY;
|
||||
if (CVarGetInteger("gNoWallColision", 0)) {
|
||||
player->pos[1] = nextY < CVarGetFloat("gMinHeight", 0.0f) ? CVarGetFloat("gMinHeight", 0.0f) : nextY;
|
||||
player->pos.y = nextY < CVarGetFloat("gMinHeight", 0.0f) ? CVarGetFloat("gMinHeight", 0.0f) : nextY;
|
||||
}
|
||||
if ((player->type & PLAYER_HUMAN) && (!(player->type & PLAYER_KART_AI))) {
|
||||
func_8002BB9C(player, &nextX, &nextZ, screenId, playerId, sp98);
|
||||
}
|
||||
player->unk_064[0] = sp178[0];
|
||||
player->unk_064[2] = sp178[2];
|
||||
player->velocity[0] = sp98[0];
|
||||
player->velocity[1] = sp98[1];
|
||||
player->velocity[2] = sp98[2];
|
||||
player->velocity.x = sp98[0];
|
||||
player->velocity.y = sp98[1];
|
||||
player->velocity.z = sp98[2];
|
||||
D_80165070[playerId][0] = sp98[0];
|
||||
D_80165070[playerId][1] = sp98[1];
|
||||
D_80165070[playerId][2] = sp98[2];
|
||||
if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
|
||||
if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
|
||||
temp = gKartTopSpeedTable[player->characterId] / player->unk_094;
|
||||
player->velocity[0] *= temp;
|
||||
player->velocity[1] *= temp;
|
||||
player->velocity[2] *= temp;
|
||||
player->velocity.x *= temp;
|
||||
player->velocity.y *= temp;
|
||||
player->velocity.z *= temp;
|
||||
player->unk_094 = gKartTopSpeedTable[player->characterId];
|
||||
}
|
||||
}
|
||||
if ((player->unk_044 & 1) == 1) {
|
||||
if (player->unk_094 > 1) {
|
||||
temp = 1 / player->unk_094;
|
||||
player->velocity[0] *= temp;
|
||||
player->velocity[1] *= temp;
|
||||
player->velocity[2] *= temp;
|
||||
player->velocity.x *= temp;
|
||||
player->velocity.y *= temp;
|
||||
player->velocity.z *= temp;
|
||||
player->unk_094 = 1;
|
||||
}
|
||||
}
|
||||
@@ -2368,13 +2368,13 @@ void set_player_height(Player* player) {
|
||||
player->kartHopJerk = 0.0f;
|
||||
player->kartHopAcceleration = 0.0f;
|
||||
player->kartHopVelocity = 0.0f;
|
||||
player->pos[1] = spawn_actor_on_surface(player->pos[0], D_80164510[player_index] + 10.0f, player->pos[2]) +
|
||||
player->pos.y = spawn_actor_on_surface(player->pos.x, D_80164510[player_index] + 10.0f, player->pos.z) +
|
||||
player->boundingBoxSize;
|
||||
if (((player->pos[1] - D_80164510[player_index]) > 1200.0f) ||
|
||||
((player->pos[1] - D_80164510[player_index]) < -1200.0f)) {
|
||||
player->pos[1] = player->oldPos[1];
|
||||
if (((player->pos.y - D_80164510[player_index]) > 1200.0f) ||
|
||||
((player->pos.y - D_80164510[player_index]) < -1200.0f)) {
|
||||
player->pos.y = player->oldPos[1];
|
||||
}
|
||||
player->velocity[1] = 0.0f;
|
||||
player->velocity.y = 0.0f;
|
||||
}
|
||||
|
||||
void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 playerId) {
|
||||
@@ -2439,9 +2439,9 @@ void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
|
||||
} else {
|
||||
mtxf_translate_vec3f_mat3(spEC, player->orientationMatrix);
|
||||
}
|
||||
sp54[0] = player->velocity[0];
|
||||
sp54[1] = player->velocity[1];
|
||||
sp54[2] = player->velocity[2];
|
||||
sp54[0] = player->velocity.x;
|
||||
sp54[1] = player->velocity.y;
|
||||
sp54[2] = player->velocity.z;
|
||||
if ((player->unk_10C < 3) && ((player->unk_256) < 3) && ((player->effects & 0x400) != 0x400) &&
|
||||
((player->effects & 0x01000000) != 0x01000000) &&
|
||||
((player->effects & HIT_BY_ITEM_EFFECT) != HIT_BY_ITEM_EFFECT)) {
|
||||
@@ -2462,17 +2462,17 @@ void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
|
||||
sp54[1] = 0.0f;
|
||||
sp54[2] = 0.0f;
|
||||
}
|
||||
posX = player->pos[0];
|
||||
posY = player->pos[1];
|
||||
posZ = player->pos[2];
|
||||
posX = player->pos.x;
|
||||
posY = player->pos.y;
|
||||
posZ = player->pos.z;
|
||||
|
||||
player->oldPos[0] = player->pos[0];
|
||||
player->oldPos[1] = player->pos[1];
|
||||
player->oldPos[2] = player->pos[2];
|
||||
player->oldPos[0] = player->pos.x;
|
||||
player->oldPos[1] = player->pos.y;
|
||||
player->oldPos[2] = player->pos.z;
|
||||
|
||||
spD0 = posX + player->velocity[0] + D_8018CE10[playerId].unk_04[0];
|
||||
spCC = posY + player->velocity[1];
|
||||
spC8 = posZ + player->velocity[2] + D_8018CE10[playerId].unk_04[2];
|
||||
spD0 = posX + player->velocity.x + D_8018CE10[playerId].unk_04[0];
|
||||
spCC = posY + player->velocity.y;
|
||||
spC8 = posZ + player->velocity.z + D_8018CE10[playerId].unk_04[2];
|
||||
func_8002AAC0(player);
|
||||
spCC += player->kartHopVelocity;
|
||||
actor_terrain_collision(&player->collision, player->boundingBoxSize, spD0, spCC, spC8, player->oldPos[0],
|
||||
@@ -2602,21 +2602,21 @@ void func_8002E594(Player* player, UNUSED Camera* camera, s8 screenId, s8 player
|
||||
sp54[0] = sp54[0] + (-1 * sp54[0]);
|
||||
sp54[2] = sp54[2] + (-1 * sp54[2]);
|
||||
} else {
|
||||
player->pos[0] = spD0;
|
||||
player->pos[2] = spC8;
|
||||
player->pos.x = spD0;
|
||||
player->pos.z = spC8;
|
||||
}
|
||||
player->pos[1] = spCC;
|
||||
player->pos.y = spCC;
|
||||
player->unk_064[0] = spE0[0];
|
||||
player->unk_064[2] = spE0[2];
|
||||
player->velocity[0] = sp54[0];
|
||||
player->velocity[1] = sp54[1];
|
||||
player->velocity[2] = sp54[2];
|
||||
player->velocity.x = sp54[0];
|
||||
player->velocity.y = sp54[1];
|
||||
player->velocity.z = sp54[2];
|
||||
if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
|
||||
if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
|
||||
temp_f0_6 = gKartTopSpeedTable[player->characterId] / player->unk_094;
|
||||
player->velocity[0] *= temp_f0_6;
|
||||
player->velocity[1] *= temp_f0_6;
|
||||
player->velocity[2] *= temp_f0_6;
|
||||
player->velocity.x *= temp_f0_6;
|
||||
player->velocity.y *= temp_f0_6;
|
||||
player->velocity.z *= temp_f0_6;
|
||||
player->unk_094 = gKartTopSpeedTable[player->characterId];
|
||||
}
|
||||
}
|
||||
@@ -2655,16 +2655,16 @@ void control_kart_ai_movement(Player* player, UNUSED Camera* camera, s8 arg2, s8
|
||||
player->effects &= ~0x8000;
|
||||
spF4[2] = func_80030150(player, playerId);
|
||||
mtxf_translate_vec3f_mat3(spF4, player->orientationMatrix);
|
||||
sp68[0] = player->velocity[0];
|
||||
sp68[0] = player->velocity.x;
|
||||
sp68[1] = 0;
|
||||
sp68[2] = player->velocity[2];
|
||||
sp68[2] = player->velocity.z;
|
||||
sp68[0] += (((spF4[0] + sp84) + spD0[0]) - (sp68[0] * (0.12 * player->kartFriction))) / 6000.0;
|
||||
sp68[2] += (((spF4[2] + sp7C) + spD0[2]) - (sp68[2] * (0.12 * player->kartFriction))) / 6000.0;
|
||||
player->oldPos[0] = player->pos[0];
|
||||
player->oldPos[0] = player->pos.x;
|
||||
player->oldPos[1] = test;
|
||||
player->oldPos[2] = player->pos[2];
|
||||
spCC = player->pos[0] + player->velocity[0];
|
||||
spC4 = player->pos[2] + player->velocity[2];
|
||||
player->oldPos[2] = player->pos.z;
|
||||
spCC = player->pos.x + player->velocity.x;
|
||||
spC4 = player->pos.z + player->velocity.z;
|
||||
player->unk_0C0 = 0;
|
||||
player->kartHopJerk = 0;
|
||||
player->kartHopAcceleration = 0;
|
||||
@@ -2679,22 +2679,22 @@ void control_kart_ai_movement(Player* player, UNUSED Camera* camera, s8 arg2, s8
|
||||
toSqrt = (sp68[0] * sp68[0]) + (sp68[2] * sp68[2]);
|
||||
player->unk_22C = player->unk_094;
|
||||
player->unk_094 = sqrtf(toSqrt);
|
||||
player->pos[0] = spCC;
|
||||
player->pos[2] = spC4;
|
||||
player->pos[1] = test;
|
||||
player->pos.x = spCC;
|
||||
player->pos.z = spC4;
|
||||
player->pos.y = test;
|
||||
player->unk_064[0] = 0;
|
||||
player->unk_064[2] = 0;
|
||||
player->velocity[0] = sp68[0];
|
||||
player->velocity[1] = sp68[1];
|
||||
player->velocity[2] = sp68[2];
|
||||
player->velocity.x = sp68[0];
|
||||
player->velocity.y = sp68[1];
|
||||
player->velocity.z = sp68[2];
|
||||
D_80165070[playerId][0] = sp68[0];
|
||||
D_80165070[playerId][1] = sp68[1];
|
||||
D_80165070[playerId][2] = sp68[2];
|
||||
if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
|
||||
temp_f0_2 = gKartTopSpeedTable[player->characterId] / player->unk_094;
|
||||
player->velocity[0] *= temp_f0_2;
|
||||
player->velocity[1] *= temp_f0_2;
|
||||
player->velocity[2] *= temp_f0_2;
|
||||
player->velocity.x *= temp_f0_2;
|
||||
player->velocity.y *= temp_f0_2;
|
||||
player->velocity.z *= temp_f0_2;
|
||||
player->unk_094 = gKartTopSpeedTable[player->characterId];
|
||||
}
|
||||
}
|
||||
@@ -2729,25 +2729,25 @@ void func_8002F730(Player* player, UNUSED Camera* camera, UNUSED s8 screenId, s8
|
||||
|
||||
mtxf_translate_vec3f_mat3(spF4, player->orientationMatrix);
|
||||
|
||||
sp68[0] = player->velocity[0];
|
||||
sp68[1] = player->velocity[1];
|
||||
sp68[2] = player->velocity[2];
|
||||
sp68[0] = player->velocity.x;
|
||||
sp68[1] = player->velocity.y;
|
||||
sp68[2] = player->velocity.z;
|
||||
|
||||
sp68[0] += (((f64) (spF4[0] + sp84) - (sp68[0] * 780.0)) / 6500.0);
|
||||
sp68[2] += (((f64) (spF4[2] + sp7C) - (sp68[2] * 780.0)) / 6500.0);
|
||||
sp68[1] += (((f64) (spF4[1] + -1100.0f) - (sp68[1] * 780.0)) / 6500.0);
|
||||
|
||||
spC0 = player->pos[0];
|
||||
sp44 = player->pos[1];
|
||||
spB8 = player->pos[2];
|
||||
spC0 = player->pos.x;
|
||||
sp44 = player->pos.y;
|
||||
spB8 = player->pos.z;
|
||||
|
||||
player->oldPos[0] = player->pos[0];
|
||||
player->oldPos[1] = player->pos[1];
|
||||
player->oldPos[2] = player->pos[2];
|
||||
player->oldPos[0] = player->pos.x;
|
||||
player->oldPos[1] = player->pos.y;
|
||||
player->oldPos[2] = player->pos.z;
|
||||
|
||||
spCC = player->velocity[0] + spC0;
|
||||
spC8 = player->velocity[1] + sp44;
|
||||
spC4 = player->velocity[2] + spB8;
|
||||
spCC = player->velocity.x + spC0;
|
||||
spC8 = player->velocity.y + sp44;
|
||||
spC4 = player->velocity.z + spB8;
|
||||
|
||||
func_8002AAC0(player);
|
||||
|
||||
@@ -2781,17 +2781,17 @@ void func_8002F730(Player* player, UNUSED Camera* camera, UNUSED s8 screenId, s8
|
||||
sp68[0] = sp68[0] + (sp68[0] * -1.0f);
|
||||
sp68[2] = sp68[2] + (sp68[2] * -1.0f);
|
||||
} else {
|
||||
player->pos[0] = spCC;
|
||||
player->pos[2] = spC4;
|
||||
player->pos.x = spCC;
|
||||
player->pos.z = spC4;
|
||||
}
|
||||
player->pos[1] = spC8 - 0.018;
|
||||
player->pos.y = spC8 - 0.018;
|
||||
|
||||
player->unk_064[0] = spE8[0];
|
||||
player->unk_064[2] = spE8[2];
|
||||
|
||||
player->velocity[0] = sp68[0];
|
||||
player->velocity[1] = sp68[1];
|
||||
player->velocity[2] = sp68[2];
|
||||
player->velocity.x = sp68[0];
|
||||
player->velocity.y = sp68[1];
|
||||
player->velocity.z = sp68[2];
|
||||
D_80165070[playerId][0] = sp68[0];
|
||||
D_80165070[playerId][1] = sp68[1];
|
||||
D_80165070[playerId][2] = sp68[2];
|
||||
@@ -2799,9 +2799,9 @@ void func_8002F730(Player* player, UNUSED Camera* camera, UNUSED s8 screenId, s8
|
||||
if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
|
||||
if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
|
||||
temp_f0_2 = gKartTopSpeedTable[player->characterId] / player->unk_094;
|
||||
player->velocity[0] *= temp_f0_2;
|
||||
player->velocity[1] *= temp_f0_2;
|
||||
player->velocity[2] *= temp_f0_2;
|
||||
player->velocity.x *= temp_f0_2;
|
||||
player->velocity.y *= temp_f0_2;
|
||||
player->velocity.z *= temp_f0_2;
|
||||
player->unk_094 = gKartTopSpeedTable[player->characterId];
|
||||
}
|
||||
}
|
||||
@@ -4834,9 +4834,9 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
|
||||
sp114[2] = player->unk_08C;
|
||||
mtxf_translate_vec3f_mat3(sp114, player->orientationMatrix);
|
||||
|
||||
sp88[0] = player->velocity[0];
|
||||
sp88[1] = player->velocity[1];
|
||||
sp88[2] = player->velocity[2];
|
||||
sp88[0] = player->velocity.x;
|
||||
sp88[1] = player->velocity.y;
|
||||
sp88[2] = player->velocity.z;
|
||||
|
||||
sp88[0] += ((((((sp114[0] + spA4) + spF0[0])) - (sp88[0] * (0.12 * (player->kartFriction)))) / 6000.0) / 1);
|
||||
sp88[2] += ((((((sp114[2] + sp9C) + spF0[2])) - (sp88[2] * (0.12 * (player->kartFriction)))) / 6000.0) / 1);
|
||||
@@ -4845,17 +4845,17 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
|
||||
player->unk_044 &= 0xFFEF;
|
||||
}
|
||||
|
||||
posX = player->pos[0];
|
||||
posY = player->pos[1];
|
||||
posZ = player->pos[2];
|
||||
posX = player->pos.x;
|
||||
posY = player->pos.y;
|
||||
posZ = player->pos.z;
|
||||
|
||||
player->oldPos[0] = player->pos[0];
|
||||
player->oldPos[1] = player->pos[1];
|
||||
player->oldPos[2] = player->pos[2];
|
||||
player->oldPos[0] = player->pos.x;
|
||||
player->oldPos[1] = player->pos.y;
|
||||
player->oldPos[2] = player->pos.z;
|
||||
|
||||
spEC = posX + player->velocity[0];
|
||||
spE8 = posY + player->velocity[1];
|
||||
spE4 = posZ + player->velocity[2];
|
||||
spEC = posX + player->velocity.x;
|
||||
spE8 = posY + player->velocity.y;
|
||||
spE4 = posZ + player->velocity.z;
|
||||
func_8002AAC0(player);
|
||||
spE8 += player->kartHopVelocity;
|
||||
spE8 -= 0.02;
|
||||
@@ -4902,16 +4902,16 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
|
||||
player->unk_22C = player->unk_094;
|
||||
player->unk_094 = sqrtf(sqrt);
|
||||
|
||||
player->pos[0] = spEC;
|
||||
player->pos[2] = spE4;
|
||||
player->pos[1] = spE8;
|
||||
player->pos.x = spEC;
|
||||
player->pos.z = spE4;
|
||||
player->pos.y = spE8;
|
||||
|
||||
player->unk_064[0] = sp108[0];
|
||||
player->unk_064[2] = sp108[2];
|
||||
|
||||
player->velocity[0] = sp88[0];
|
||||
player->velocity[1] = sp88[1];
|
||||
player->velocity[2] = sp88[2];
|
||||
player->velocity.x = sp88[0];
|
||||
player->velocity.y = sp88[1];
|
||||
player->velocity.z = sp88[2];
|
||||
|
||||
D_80165070[playerId][0] = sp88[0];
|
||||
D_80165070[playerId][1] = sp88[1];
|
||||
@@ -4920,17 +4920,17 @@ void func_80038C6C(Player* player, UNUSED Camera* camera, s8 arg2, s8 playerId)
|
||||
if ((player->type & PLAYER_HUMAN) == PLAYER_HUMAN) {
|
||||
if (gKartTopSpeedTable[player->characterId] < player->unk_094) {
|
||||
divOptimize = gKartTopSpeedTable[player->characterId] / player->unk_094;
|
||||
player->velocity[0] *= divOptimize;
|
||||
player->velocity[1] *= divOptimize;
|
||||
player->velocity[2] *= divOptimize;
|
||||
player->velocity.x *= divOptimize;
|
||||
player->velocity.y *= divOptimize;
|
||||
player->velocity.z *= divOptimize;
|
||||
player->unk_094 = gKartTopSpeedTable[player->characterId];
|
||||
}
|
||||
}
|
||||
if ((player->unk_044 & 1) == 1) {
|
||||
if (player->unk_094 > 1.0f) {
|
||||
player->velocity[0] *= 1.0f / player->unk_094;
|
||||
player->velocity[1] *= 1.0f / player->unk_094;
|
||||
player->velocity[2] *= 1.0f / player->unk_094;
|
||||
player->velocity.x *= 1.0f / player->unk_094;
|
||||
player->velocity.y *= 1.0f / player->unk_094;
|
||||
player->velocity.z *= 1.0f / player->unk_094;
|
||||
player->unk_094 = 1.0f;
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -719,7 +719,7 @@ void CM_ActorCollision(Player* player, Actor* actor) {
|
||||
}
|
||||
|
||||
f32 CM_GetWaterLevel(Vec3f pos, Collision* collision) {
|
||||
FVector fPos = {pos[0], pos[1], pos[2]};
|
||||
FVector fPos = {pos.x, pos.y, pos.z};
|
||||
return gWorldInstance.CurrentCourse->GetWaterLevel(fPos, collision);
|
||||
}
|
||||
|
||||
|
||||
@@ -57,8 +57,10 @@ enum class Op {
|
||||
MatrixPop,
|
||||
MatrixPut,
|
||||
MatrixMult,
|
||||
MatrixMultKart,
|
||||
MatrixTranslate,
|
||||
MatrixScale,
|
||||
MatrixTranslateRotateZYX,
|
||||
MatrixRotate1Coord,
|
||||
MatrixMult4x4,
|
||||
MatrixPosRotXYZ,
|
||||
@@ -91,9 +93,20 @@ union Data {
|
||||
u8 mode;
|
||||
} matrix_mult;
|
||||
|
||||
struct {
|
||||
f32* outX;
|
||||
f32* outY;
|
||||
f32* outZ;
|
||||
f32 inX;
|
||||
f32 inY;
|
||||
f32 inZ;
|
||||
u16 theta;
|
||||
u16 phi;
|
||||
} matrix_mult_kart;
|
||||
|
||||
struct {
|
||||
Mat4* matrix;
|
||||
Vec3fInterp b;
|
||||
Vec3f b;
|
||||
} matrix_translate, matrix_scale;
|
||||
|
||||
struct {
|
||||
@@ -121,12 +134,11 @@ union Data {
|
||||
} matrix_mult_4x4;
|
||||
|
||||
struct {
|
||||
Vec3fInterp pos;
|
||||
Vec3sInterp orientation;
|
||||
Vec3f pos;
|
||||
Vec3s orientation;
|
||||
} matrix_pos_rot_xyz;
|
||||
|
||||
struct {
|
||||
Mat4* matrix;
|
||||
Vec3f translation;
|
||||
Vec3s rotation;
|
||||
} matrix_translate_rotate_zyx;
|
||||
@@ -197,6 +209,8 @@ Data& append(Op op) {
|
||||
extern "C" {
|
||||
extern Mat4* gInterpolationMatrix;
|
||||
void mtxf_translate(Mat4, Vec3f);
|
||||
void func_80062B18(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY, f32 inZ, u16 theta, u16 phi);
|
||||
void mtxf_translate_rotate(Mat4 dest, Vec3f pos, Vec3s orientation);
|
||||
}
|
||||
|
||||
MtxF* Matrix_GetCurrent() {
|
||||
@@ -228,14 +242,14 @@ struct InterpolateCtx {
|
||||
return w * o + step * n;
|
||||
}
|
||||
|
||||
s16 lerp_s16(s16 o, s16 n) {
|
||||
s16 lerp(s16 o, s16 n) {
|
||||
return w * o + step * n;
|
||||
}
|
||||
|
||||
void lerp_vec3f(Vec3f* res, Vec3f* o, Vec3f* n) {
|
||||
*res[0] = lerp(*o[0], *n[0]);
|
||||
*res[1] = lerp(*o[1], *n[1]);
|
||||
*res[2] = lerp(*o[2], *n[2]);
|
||||
res->x = lerp(o->x, n->x);
|
||||
res->y = lerp(o->y, n->y);
|
||||
res->z = lerp(o->z, n->z);
|
||||
}
|
||||
|
||||
float interpolate_angle(f32 o, f32 n) {
|
||||
@@ -293,15 +307,15 @@ struct InterpolateCtx {
|
||||
}
|
||||
|
||||
void interpolate_vecs(Vec3f* res, Vec3f* o, Vec3f* n) {
|
||||
*res[0] = interpolate_angle(*o[0], *n[0]);
|
||||
*res[1] = interpolate_angle(*o[1], *n[1]);
|
||||
*res[2] = interpolate_angle(*o[2], *n[2]);
|
||||
res->x = interpolate_angle(o->x, n->x);
|
||||
res->y = interpolate_angle(o->y, n->y);
|
||||
res->z = interpolate_angle(o->z, n->z);
|
||||
}
|
||||
|
||||
void interpolate_angles(Vec3s* res, Vec3s* o, Vec3s* n) {
|
||||
*res[0] = interpolate_angle(*o[0], *n[0]);
|
||||
*res[1] = interpolate_angle(*o[1], *n[1]);
|
||||
*res[2] = interpolate_angle(*o[2], *n[2]);
|
||||
res->x = interpolate_angle(o->x, n->x);
|
||||
res->y = interpolate_angle(o->y, n->y);
|
||||
res->z = interpolate_angle(o->z, n->z);
|
||||
}
|
||||
|
||||
void interpolate_branch(Path* old_path, Path* new_path) {
|
||||
@@ -347,14 +361,36 @@ struct InterpolateCtx {
|
||||
interpolate_mtxf(&tmp_mtxf, &old_op.matrix_mult.mf, &new_op.matrix_mult.mf);
|
||||
// Matrix_Mult(gInterpolationMatrix, (Matrix*) &tmp_mtxf, new_op.matrix_mult.mode);
|
||||
break;
|
||||
case Op::MatrixMultKart:
|
||||
|
||||
f32 tempX, tempY, tempZ;
|
||||
u16 tempTheta, tempPhi;
|
||||
tempX = lerp(old_op.matrix_mult_kart.inX, new_op.matrix_mult_kart.inX);
|
||||
tempY = lerp(old_op.matrix_mult_kart.inY, new_op.matrix_mult_kart.inY);
|
||||
tempZ = lerp(old_op.matrix_mult_kart.inZ, new_op.matrix_mult_kart.inZ);
|
||||
tempTheta = interpolate_angle((s16) old_op.matrix_mult_kart.theta, (s16) new_op.matrix_mult_kart.theta);
|
||||
tempPhi = interpolate_angle((s16) old_op.matrix_mult_kart.phi, (s16) new_op.matrix_mult_kart.phi);
|
||||
|
||||
func_80062B18(old_op.matrix_mult_kart.outX, old_op.matrix_mult_kart.outY, old_op.matrix_mult_kart.outZ, tempX, tempY, tempZ, tempTheta, tempPhi);
|
||||
|
||||
// Matrix_MultKart(gInterpolationMatrix, (Matrix*) &tmp_mtxf, new_op.matrix_mult.mode);
|
||||
break;
|
||||
|
||||
case Op::MatrixTranslateRotateZYX:
|
||||
lerp_vec3f(&tmp_vec3f, &old_op.matrix_translate_rotate_zyx.translation,
|
||||
&new_op.matrix_translate_rotate_zyx.translation);
|
||||
interpolate_angles(&tmp_vec3s, &old_op.matrix_translate_rotate_zyx.rotation,
|
||||
&new_op.matrix_translate_rotate_zyx.rotation);
|
||||
mtxf_translate_rotate(*gInterpolationMatrix, tmp_vec3f, tmp_vec3s);
|
||||
break;
|
||||
|
||||
case Op::MatrixTranslate:
|
||||
|
||||
Vec3f temp;
|
||||
|
||||
temp[0] = lerp(old_op.matrix_translate.b.x, new_op.matrix_translate.b.x);
|
||||
temp[1] = lerp(old_op.matrix_translate.b.y, new_op.matrix_translate.b.y);
|
||||
temp[2] = lerp(old_op.matrix_translate.b.z, new_op.matrix_translate.b.z);
|
||||
temp.x = lerp(old_op.matrix_translate.b.x, new_op.matrix_translate.b.x);
|
||||
temp.y = lerp(old_op.matrix_translate.b.y, new_op.matrix_translate.b.y);
|
||||
temp.z = lerp(old_op.matrix_translate.b.z, new_op.matrix_translate.b.z);
|
||||
|
||||
mtxf_translate(*gInterpolationMatrix, temp);
|
||||
break;
|
||||
@@ -362,13 +398,13 @@ struct InterpolateCtx {
|
||||
Vec3f tempF;
|
||||
Vec3s tempS;
|
||||
|
||||
tempF[0] = lerp(old_op.matrix_pos_rot_xyz.pos.x, new_op.matrix_pos_rot_xyz.pos.x);
|
||||
tempF[1] = lerp(old_op.matrix_pos_rot_xyz.pos.y, new_op.matrix_pos_rot_xyz.pos.y);
|
||||
tempF[2] = lerp(old_op.matrix_pos_rot_xyz.pos.z, new_op.matrix_pos_rot_xyz.pos.z);
|
||||
tempF.x = lerp(old_op.matrix_pos_rot_xyz.pos.x, new_op.matrix_pos_rot_xyz.pos.x);
|
||||
tempF.y = lerp(old_op.matrix_pos_rot_xyz.pos.y, new_op.matrix_pos_rot_xyz.pos.y);
|
||||
tempF.z = lerp(old_op.matrix_pos_rot_xyz.pos.z, new_op.matrix_pos_rot_xyz.pos.z);
|
||||
|
||||
tempS[0] = lerp(old_op.matrix_pos_rot_xyz.orientation.x, new_op.matrix_pos_rot_xyz.orientation.x);
|
||||
tempS[1] = lerp(old_op.matrix_pos_rot_xyz.orientation.y, new_op.matrix_pos_rot_xyz.orientation.y);
|
||||
tempS[2] = lerp(old_op.matrix_pos_rot_xyz.orientation.z, new_op.matrix_pos_rot_xyz.orientation.z);
|
||||
tempS.x = lerp(old_op.matrix_pos_rot_xyz.orientation.x, new_op.matrix_pos_rot_xyz.orientation.x);
|
||||
tempS.y = lerp(old_op.matrix_pos_rot_xyz.orientation.y, new_op.matrix_pos_rot_xyz.orientation.y);
|
||||
tempS.z = lerp(old_op.matrix_pos_rot_xyz.orientation.z, new_op.matrix_pos_rot_xyz.orientation.z);
|
||||
|
||||
mtxf_pos_rotation_xyz(*gInterpolationMatrix, tempF, tempS);
|
||||
break;
|
||||
@@ -551,11 +587,24 @@ void FrameInterpolation_RecordMatrixMult(Mat4* matrix, MtxF* mf, u8 mode) {
|
||||
append(Op::MatrixMult).matrix_mult = { matrix, *mf, mode };
|
||||
}
|
||||
|
||||
void FrameInterpolation_RecordMatrixMultKart(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY,
|
||||
f32 inZ, u16 theta, u16 phi) {
|
||||
if (!is_recording)
|
||||
return;
|
||||
append(Op::MatrixMultKart).matrix_mult_kart = { outX, outY, outZ, inX, inY, inZ, theta, phi };
|
||||
}
|
||||
|
||||
void FrameInterpolation_RecordMatrixTranslate(Mat4* matrix, Vec3f b) {
|
||||
if (!is_recording)
|
||||
return;
|
||||
|
||||
append(Op::MatrixTranslate).matrix_translate = { matrix, *((Vec3fInterp*) &b) };
|
||||
append(Op::MatrixTranslate).matrix_translate = { matrix, b };
|
||||
}
|
||||
|
||||
void FrameInterpolation_RecordMatrixTranslateRotateZYX(Vec3f translation, Vec3s rotation) {
|
||||
if (!is_recording)
|
||||
return;
|
||||
append(Op::MatrixTranslateRotateZYX).matrix_translate_rotate_zyx = { translation, rotation };
|
||||
}
|
||||
|
||||
void FrameInterpolation_RecordMatrixScale(Mat4* matrix, f32 x, f32 y, f32 z, u8 mode) {
|
||||
@@ -572,11 +621,10 @@ void FrameInterpolation_RecordMatrixMultVec3fNoTranslate(Mat4* matrix, Vec3f src
|
||||
|
||||
// Make a template for deref
|
||||
|
||||
|
||||
void FrameInterpolation_RecordMatrixPosRotXYZ(Mat4 out, Vec3f pos, Vec3s orientation) {
|
||||
void FrameInterpolation_RecordMatrixPosRotXYZ(Mat4 out, Vec3f pos, Vec3s orientation ) {
|
||||
if (!is_recording)
|
||||
return;
|
||||
append(Op::MatrixPosRotXYZ).matrix_pos_rot_xyz = { *((Vec3fInterp*) &pos), *((Vec3sInterp*) &orientation) };
|
||||
append(Op::MatrixPosRotXYZ).matrix_pos_rot_xyz = { pos, orientation };
|
||||
}
|
||||
|
||||
void FrameInterpolation_RecordMatrixMultVec3f(Mat4* matrix, Vec3f src, Vec3f dest) {
|
||||
|
||||
@@ -47,6 +47,9 @@ void FrameInterpolation_RecordMatrixPop(Mat4* matrix);
|
||||
|
||||
//void FrameInterpolation_RecordMatrixMult(Matrix* matrix, MtxF* mf, u8 mode);
|
||||
|
||||
void FrameInterpolation_RecordMatrixMultKart(f32* outX, f32* outY, f32* outZ, f32 inX, f32 inY,
|
||||
f32 inZ, u16 theta, u16 phi);
|
||||
|
||||
void FrameInterpolation_RecordMatrixTranslate(Mat4* matrix, Vec3f b);
|
||||
|
||||
//void FrameInterpolation_RecordMatrixScale(Matrix* matrix, f32 x, f32 y, f32 z, u8 mode);
|
||||
|
||||
@@ -394,14 +394,14 @@ void Matrix_GetYRPAngles(Matrix* mtx, Vec3f* rot) {
|
||||
xHatP[0] -= originP[0];
|
||||
xHatP[1] -= originP[1];
|
||||
xHatP[2] -= originP[2];
|
||||
*rot[1] = atan2f(zHatP[0], zHatP[2]);
|
||||
*rot[0] = -atan2f(zHatP[1], sqrtf(SQ(zHatP[0]) + SQ(zHatP[2])));
|
||||
Matrix_RotateX(&invYP, -*rot[0], MTXF_NEW);
|
||||
Matrix_RotateY(&invYP, -*rot[1], MTXF_APPLY);
|
||||
*rot.y = atan2f(zHatP[0], zHatP[2]);
|
||||
*rot.x = -atan2f(zHatP[1], sqrtf(SQ(zHatP[0]) + SQ(zHatP[2])));
|
||||
Matrix_RotateX(&invYP, -*rot.x, MTXF_NEW);
|
||||
Matrix_RotateY(&invYP, -*rot.y, MTXF_APPLY);
|
||||
Matrix_MultVec3fNoTranslate(&invYP, &xHatP, &xHat);
|
||||
*rot[0] *= M_RTOD;
|
||||
*rot[1] *= M_RTOD;
|
||||
*rot[2] = atan2f(xHat[1], xHat[0]) * M_RTOD;
|
||||
*rot.x *= M_RTOD;
|
||||
*rot.y *= M_RTOD;
|
||||
*rot.z = atan2f(xHat[1], xHat[0]) * M_RTOD;
|
||||
}
|
||||
|
||||
// Expresses the rotational part of the transform mtx as Tait-Bryan angles, in the extrinsic XYZ convention used in
|
||||
@@ -424,14 +424,14 @@ void Matrix_GetXYZAngles(Matrix* mtx, Vec3f* rot) {
|
||||
yHatP[0] -= originP[0];
|
||||
yHatP[1] -= originP[1];
|
||||
yHatP[2] -= originP[2];
|
||||
*rot[2] = atan2f(xHatP[1], xHatP[0]);
|
||||
*rot[1] = -atan2f(xHatP[2], sqrtf(SQ(xHatP[0]) + SQ(xHatP[1])));
|
||||
Matrix_RotateY(&invYZ, -*rot[1], MTXF_NEW);
|
||||
Matrix_RotateZ(&invYZ, -*rot[2], MTXF_APPLY);
|
||||
*rot.z = atan2f(xHatP[1], xHatP[0]);
|
||||
*rot.y = -atan2f(xHatP[2], sqrtf(SQ(xHatP[0]) + SQ(xHatP[1])));
|
||||
Matrix_RotateY(&invYZ, -*rot.y, MTXF_NEW);
|
||||
Matrix_RotateZ(&invYZ, -*rot.z, MTXF_APPLY);
|
||||
Matrix_MultVec3fNoTranslate(&invYZ, &yHatP, &yHat);
|
||||
*rot[0] = atan2f(yHat[2], yHat[1]) * M_RTOD;
|
||||
*rot[1] *= M_RTOD;
|
||||
*rot[2] *= M_RTOD;
|
||||
*rot.x = atan2f(yHat[2], yHat[1]) * M_RTOD;
|
||||
*rot.y *= M_RTOD;
|
||||
*rot.z *= M_RTOD;
|
||||
}
|
||||
|
||||
// Creates a look-at matrix from Eye, At, and Up in mtx (MTXF_NEW) or applies one to mtx (MTXF_APPLY).
|
||||
|
||||
@@ -10,18 +10,6 @@ typedef struct {
|
||||
float b;
|
||||
} Color;
|
||||
|
||||
typedef struct {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
} Vec3fInterp;
|
||||
|
||||
typedef struct {
|
||||
s16 x;
|
||||
s16 y;
|
||||
s16 z;
|
||||
} Vec3sInterp;
|
||||
|
||||
typedef struct {
|
||||
f32 m1; f32 m2; f32 m3; f32 m4;
|
||||
f32 m5; f32 m6; f32 m7; f32 m8;
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user