366 lines
10 KiB
C
366 lines
10 KiB
C
#include "decomp/global_state.h"
|
|
|
|
#include "debug_print.h"
|
|
#include "load_surfaces.h"
|
|
#include "gfx_adapter.h"
|
|
#include "load_anim_data.h"
|
|
#include "load_tex_data.h"
|
|
#include "obj_pool.h"
|
|
|
|
#include "decomp/game/interaction.h"
|
|
#include "decomp/include/object_fields.h"
|
|
#include "decomp/include/sm64.h"
|
|
#include "decomp/shim.h"
|
|
#include "decomp/game/mario.h"
|
|
#include "decomp/engine/math_util.h"
|
|
#include "fake_interaction.h"
|
|
|
|
#define INT_GROUND_POUND_OR_TWIRL (1 << 0) // 0x01
|
|
#define INT_PUNCH (1 << 1) // 0x02
|
|
#define INT_KICK (1 << 2) // 0x04
|
|
#define INT_TRIP (1 << 3) // 0x08
|
|
#define INT_SLIDE_KICK (1 << 4) // 0x10
|
|
#define INT_FAST_ATTACK_OR_SHELL (1 << 5) // 0x20
|
|
#define INT_HIT_FROM_ABOVE (1 << 6) // 0x40
|
|
#define INT_HIT_FROM_BELOW (1 << 7) // 0x80
|
|
|
|
#define INT_ATTACK_NOT_FROM_BELOW \
|
|
(INT_GROUND_POUND_OR_TWIRL | INT_PUNCH | INT_KICK | INT_TRIP | INT_SLIDE_KICK \
|
|
| INT_FAST_ATTACK_OR_SHELL | INT_HIT_FROM_ABOVE)
|
|
|
|
#define INT_ANY_ATTACK \
|
|
(INT_GROUND_POUND_OR_TWIRL | INT_PUNCH | INT_KICK | INT_TRIP | INT_SLIDE_KICK \
|
|
| INT_FAST_ATTACK_OR_SHELL | INT_HIT_FROM_ABOVE | INT_HIT_FROM_BELOW)
|
|
|
|
#define INT_ATTACK_NOT_WEAK_FROM_ABOVE \
|
|
(INT_GROUND_POUND_OR_TWIRL | INT_PUNCH | INT_KICK | INT_TRIP | INT_HIT_FROM_BELOW)
|
|
|
|
#define sDelayInvincTimer (g_state->msDelayInvincTimer)
|
|
#define sInvulnerable (g_state->msInvulnerable)
|
|
|
|
static u32 sForwardKnockbackActions[][3] = {
|
|
{ACT_SOFT_FORWARD_GROUND_KB, ACT_FORWARD_GROUND_KB, ACT_HARD_FORWARD_GROUND_KB},
|
|
{ACT_FORWARD_AIR_KB, ACT_FORWARD_AIR_KB, ACT_HARD_FORWARD_AIR_KB},
|
|
{ACT_FORWARD_WATER_KB, ACT_FORWARD_WATER_KB, ACT_FORWARD_WATER_KB},
|
|
};
|
|
|
|
static u32 sBackwardKnockbackActions[][3] = {
|
|
{ACT_SOFT_BACKWARD_GROUND_KB, ACT_BACKWARD_GROUND_KB, ACT_HARD_BACKWARD_GROUND_KB},
|
|
{ACT_BACKWARD_AIR_KB, ACT_BACKWARD_AIR_KB, ACT_HARD_BACKWARD_AIR_KB},
|
|
{ACT_BACKWARD_WATER_KB, ACT_BACKWARD_WATER_KB, ACT_BACKWARD_WATER_KB},
|
|
};
|
|
|
|
uint32_t fake_damage_knock_back(struct MarioState *m, uint32_t damage, uint32_t interactionSubtype, float xSrc, float ySrc, float zSrc)
|
|
{
|
|
if (!sInvulnerable && !(m->flags & MARIO_VANISH_CAP) && !(interactionSubtype & INT_SUBTYPE_DELAY_INVINCIBILITY))
|
|
{
|
|
//o->oInteractStatus = INT_STATUS_INTERACTED | INT_STATUS_ATTACKED_MARIO;
|
|
//m->interactObj = o;
|
|
|
|
// calculate damage, substitute for take_damage_from_interact_object
|
|
if (!(m->flags & MARIO_CAP_ON_HEAD))
|
|
{
|
|
damage += (damage + 1) / 2;
|
|
}
|
|
|
|
if (m->flags & MARIO_METAL_CAP)
|
|
{
|
|
damage = 0;
|
|
}
|
|
|
|
m->hurtCounter += 4 * damage; // apply hurt counter
|
|
|
|
if (interactionSubtype & INT_SUBTYPE_BIG_KNOCKBACK)
|
|
{
|
|
m->forwardVel = 40.0f;
|
|
}
|
|
|
|
if (damage > 0)
|
|
{
|
|
play_sound(SOUND_MARIO_ATTACKED, m->marioObj->header.gfx.cameraToObject);
|
|
}
|
|
|
|
//update_mario_sound_and_camera(m);
|
|
return drop_and_set_mario_action(m, fake_determine_knockback_action(m, damage, xSrc, ySrc, zSrc), damage);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
s16 fake_mario_obj_angle_to_object(struct MarioState *m, float xSrc, float zSrc)
|
|
{
|
|
f32 dx = xSrc - m->pos[0];
|
|
f32 dz = zSrc - m->pos[2];
|
|
|
|
return atan2s(dz, dx);
|
|
}
|
|
|
|
u32 fake_determine_knockback_action(struct MarioState *m, s32 damage, float xSrc, float ySrc, float zSrc)
|
|
{
|
|
u32 bonkAction;
|
|
|
|
s16 terrainIndex = 0; // 1 = air, 2 = water, 0 = default
|
|
s16 strengthIndex = 0;
|
|
|
|
s16 angleToObject = fake_mario_obj_angle_to_object(m, xSrc, zSrc);
|
|
s16 facingDYaw = angleToObject - m->faceAngle[1];
|
|
s16 remainingHealth = m->health - 0x40 * m->hurtCounter;
|
|
|
|
if (m->action & (ACT_FLAG_SWIMMING | ACT_FLAG_METAL_WATER))
|
|
{
|
|
terrainIndex = 2;
|
|
}
|
|
else if (m->action & (ACT_FLAG_AIR | ACT_FLAG_ON_POLE | ACT_FLAG_HANGING))
|
|
{
|
|
terrainIndex = 1;
|
|
}
|
|
|
|
if (remainingHealth < 0x100 || damage >= 2)
|
|
{
|
|
strengthIndex = 2;
|
|
}
|
|
|
|
m->faceAngle[1] = angleToObject;
|
|
|
|
if (terrainIndex == 2)
|
|
{
|
|
if (m->forwardVel < 28.0f)
|
|
{
|
|
mario_set_forward_vel(m, 28.0f);
|
|
}
|
|
|
|
if (m->pos[1] >= ySrc)
|
|
{
|
|
if (m->vel[1] < 20.0f)
|
|
{
|
|
m->vel[1] = 20.0f;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m->vel[1] > 0.0f)
|
|
{
|
|
m->vel[1] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m->forwardVel < 16.0f)
|
|
{
|
|
mario_set_forward_vel(m, 16.0f);
|
|
}
|
|
}
|
|
|
|
if (-0x4000 <= facingDYaw && facingDYaw <= 0x4000)
|
|
{
|
|
m->forwardVel *= -1.0f;
|
|
bonkAction = sBackwardKnockbackActions[terrainIndex][strengthIndex];
|
|
}
|
|
else
|
|
{
|
|
m->faceAngle[1] += 0x8000;
|
|
bonkAction = sForwardKnockbackActions[terrainIndex][strengthIndex];
|
|
}
|
|
|
|
return bonkAction;
|
|
}
|
|
|
|
s16 fake_mario_obj_angle_to_pos(struct MarioState *m, float x, float z)
|
|
{
|
|
f32 dx = x - m->pos[0];
|
|
f32 dz = z - m->pos[2];
|
|
|
|
return atan2s(dz, dx);
|
|
}
|
|
|
|
void fake_bounce_back_from_attack(struct MarioState *m, u32 interaction)
|
|
{
|
|
if (interaction & (INT_PUNCH | INT_KICK | INT_TRIP))
|
|
{
|
|
if (m->action == ACT_PUNCHING)
|
|
{
|
|
m->action = ACT_MOVE_PUNCHING;
|
|
}
|
|
|
|
if (m->action & ACT_FLAG_AIR)
|
|
{
|
|
mario_set_forward_vel(m, -16.0f);
|
|
}
|
|
else
|
|
{
|
|
mario_set_forward_vel(m, -48.0f);
|
|
}
|
|
|
|
//set_camera_shake_from_hit(SHAKE_ATTACK);
|
|
m->particleFlags |= PARTICLE_TRIANGLE;
|
|
}
|
|
|
|
if (interaction & (INT_PUNCH | INT_KICK | INT_TRIP | INT_FAST_ATTACK_OR_SHELL))
|
|
{
|
|
play_sound(SOUND_ACTION_HIT_2, m->marioObj->header.gfx.cameraToObject);
|
|
}
|
|
}
|
|
|
|
u32 fake_determine_interaction(struct MarioState *m, float x, float y, float z)
|
|
{
|
|
u32 interaction = 0;
|
|
u32 action = m->action;
|
|
|
|
s16 dYawToObject = fake_mario_obj_angle_to_pos(m, x, z) - m->faceAngle[1];
|
|
if (action & ACT_FLAG_ATTACKING)
|
|
{
|
|
if (action == ACT_PUNCHING || action == ACT_MOVE_PUNCHING || action == ACT_JUMP_KICK)
|
|
{
|
|
if (m->flags & MARIO_PUNCHING)
|
|
{
|
|
// 120 degrees total, or 60 each way
|
|
if (-0x2AAA <= dYawToObject && dYawToObject <= 0x2AAA)
|
|
{
|
|
interaction = INT_PUNCH;
|
|
}
|
|
}
|
|
if (m->flags & MARIO_KICKING)
|
|
{
|
|
// 120 degrees total, or 60 each way
|
|
if (-0x2AAA <= dYawToObject && dYawToObject <= 0x2AAA)
|
|
{
|
|
interaction = INT_KICK;
|
|
}
|
|
}
|
|
if (m->flags & MARIO_TRIPPING)
|
|
{
|
|
// 180 degrees total, or 90 each way
|
|
if (-0x4000 <= dYawToObject && dYawToObject <= 0x4000)
|
|
{
|
|
interaction = INT_TRIP;
|
|
}
|
|
}
|
|
}
|
|
else if (action == ACT_GROUND_POUND || action == ACT_TWIRLING)
|
|
{
|
|
if (m->vel[1] < 0.0f)
|
|
{
|
|
interaction = INT_GROUND_POUND_OR_TWIRL;
|
|
}
|
|
}
|
|
else if (action == ACT_GROUND_POUND_LAND || action == ACT_TWIRL_LAND)
|
|
{
|
|
// Neither ground pounding nor twirling change Mario's vertical speed on landing.,
|
|
// so the speed check is nearly always true (perhaps not if you land while going upwards?)
|
|
// Additionally, actionState it set on each first thing in their action, so this is
|
|
// only true prior to the very first frame (i.e. active 1 frame prior to it run).
|
|
if (m->vel[1] < 0.0f && m->actionState == 0)
|
|
{
|
|
interaction = INT_GROUND_POUND_OR_TWIRL;
|
|
}
|
|
}
|
|
else if (action == ACT_SLIDE_KICK || action == ACT_SLIDE_KICK_SLIDE)
|
|
{
|
|
interaction = INT_SLIDE_KICK;
|
|
}
|
|
else if (action & ACT_FLAG_RIDING_SHELL || m->forwardVel <= -26.0f || 26.0f <= m->forwardVel)
|
|
{
|
|
interaction = INT_FAST_ATTACK_OR_SHELL;
|
|
}
|
|
}
|
|
|
|
// Prior to this, the interaction type could be overwritten. This requires, however,
|
|
// that the interaction not be set prior. This specifically overrides turning a ground
|
|
// pound into just a bounce.
|
|
if (interaction == 0 && action & ACT_FLAG_AIR)
|
|
{
|
|
if (m->vel[1] < 0.0f)
|
|
{
|
|
if (m->pos[1] > y)
|
|
{
|
|
interaction = INT_HIT_FROM_ABOVE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (m->pos[1] < y)
|
|
{
|
|
interaction = INT_HIT_FROM_BELOW;
|
|
}
|
|
}
|
|
}
|
|
|
|
return interaction;
|
|
}
|
|
|
|
void fake_bounce_off_object(struct MarioState *m, float x, float y, float z, float hitboxHeight, f32 velY)
|
|
{
|
|
//m->pos[1] = y + hitboxHeight;
|
|
m->vel[1] = velY;
|
|
|
|
m->flags &= ~MARIO_UNKNOWN_08;
|
|
|
|
play_sound(SOUND_ACTION_BOUNCE_OFF_OBJECT, m->marioObj->header.gfx.cameraToObject);
|
|
}
|
|
|
|
u32 fake_interact_hit_from_below(struct MarioState *m, float x, float y, float z, float hitboxHeight)
|
|
{
|
|
u32 interaction;
|
|
if (m->flags & MARIO_METAL_CAP)
|
|
{
|
|
interaction = INT_FAST_ATTACK_OR_SHELL;
|
|
}
|
|
else
|
|
{
|
|
interaction = fake_determine_interaction(m, x, y, z);
|
|
}
|
|
|
|
if (interaction & INT_ANY_ATTACK)
|
|
{
|
|
fake_bounce_back_from_attack(m, interaction);
|
|
|
|
if (interaction & INT_HIT_FROM_BELOW)
|
|
{
|
|
m->vel[1] = 0.0f;
|
|
}
|
|
|
|
if (interaction & INT_HIT_FROM_ABOVE)
|
|
{
|
|
fake_bounce_off_object(m, x, y, z, hitboxHeight, 30.0f);
|
|
}
|
|
return TRUE;
|
|
}
|
|
else /* if (fake_damage_knock_back(m, 0, 0, x, y, z))*/
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
u32 fake_interact_bounce_top(struct MarioState *m, float x, float y, float z, float hitboxHeight)
|
|
{
|
|
u32 interaction;
|
|
if (m->flags & MARIO_METAL_CAP)
|
|
{
|
|
interaction = INT_FAST_ATTACK_OR_SHELL;
|
|
}
|
|
else
|
|
{
|
|
interaction = fake_determine_interaction(m, x, y, z);
|
|
}
|
|
|
|
if (interaction & INT_ATTACK_NOT_FROM_BELOW)
|
|
{
|
|
fake_bounce_back_from_attack(m, interaction);
|
|
|
|
if (interaction & INT_HIT_FROM_ABOVE)
|
|
{
|
|
fake_bounce_off_object(m, x, y, z, hitboxHeight, 30.0f);
|
|
}
|
|
return TRUE;
|
|
}
|
|
else /* if (fake_damage_knock_back(m, 0, 0, x, y, z))*/
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|