SSBM Decomp
Loading...
Searching...
No Matches
ftCo_0A01.c File Reference
#include "ftCo_0A01.h"
#include <Runtime/platform.h>
#include <melee/ft/kinds/ftDonkey/forward.h>
#include <melee/ft/kinds/ftKirby/forward.h>
#include <melee/ft/kinds/ftKoopa/forward.h>
#include <melee/ft/kinds/ftMewtwo/forward.h>
#include <melee/ft/kinds/ftPopo/forward.h>
#include <melee/ft/kinds/ftSamus/forward.h>
#include <melee/gr/forward.h>
#include <math.h>
#include <placeholder.h>
#include "forward.h"
#include "ftpickupitem.h"
#include <dolphin/mtx.h>
#include <melee/cm/camera.h>
#include <melee/ft/fighter.h>
#include <melee/ft/ft_0877.h>
#include <melee/ft/ft_3C61.h>
#include <melee/ft/ftcmdscript.h>
#include <melee/ft/ftcpuattack.h>
#include <melee/ft/ftlib.h>
#include <melee/ft/inlines.h>
#include <melee/ft/kinds/ftPopo/ftpopospeciallw.h>
#include <melee/ft/types.h>
#include <melee/gm/gm_unsplit.h>
#include <melee/gr/grbigblue.h>
#include <melee/gr/grcastle.h>
#include <melee/gr/grcorneria.h>
#include <melee/gr/grgreatbay.h>
#include <melee/gr/grinishie1.h>
#include <melee/gr/grlib.h>
#include <melee/gr/ground.h>
#include <melee/gr/grrcruise.h>
#include <melee/gr/grvenom.h>
#include <melee/gr/stage.h>
#include <melee/it/inlines.h>
#include <melee/it/item.h>
#include <melee/it/types.h>
#include <melee/lb/lb_00CE.h>
#include <melee/lb/lbcollision.h>
#include <melee/lb/lbvector.h>
#include <melee/mp/mpisland.h>
#include <melee/mp/mplib.h>
#include <melee/mp/types.h>
#include <melee/pl/player.h>
#include <sysdolphin/baselib/random.h>

Macros

#define sqrtf_store(x, y)
#define ftCo_800A9904_sqrtf_store(dst, x, store)
#define ftCo_800A9CB4_sqrtf_store(dst, x, store)

Functions

static void ftCo_800A0148 (Fighter *)
static void ftCo_800AC7D4 (Fighter *)
static void ftCo_800A0384 (Fighter *fp)
static void ftCo_800ACB44 (Fighter *)
static void ftCo_800A0508 (Fighter *fp)
static void ftCo_800ACD5C (Fighter *fp)
static void ftCo_800A08F0 (Fighter *fp)
static void ftCo_800A0AF4 (Fighter *fp)
static void ftCo_800A0CB0 (Fighter *fp)
static void ftCo_800AD42C (Fighter *fp)
static void ftCo_800AD54C (Fighter *)
static bool ftCo_800A0F00 (Fighter_GObj *gobj)
static void ftCo_800AD7FC (Fighter *fp)
 CPU item throw behavior.
static void ftCo_800ADC28 (Fighter *fp)
 Handle charging neutral-B.
static void ftCo_800A1F3C (Fighter *fp, float arg1, float arg2, float arg3)
static bool ftCo_800A1F98 (int x, float y)
static void ftCo_800A20A0 (Fighter *fp)
static void ftCo_800AE7AC (Fighter *fp, Vec3 *, int)
static bool ftCo_800A21FC (Fighter *fp)
static s32 ftCo_800A229C (Fighter *fp, Vec3 *)
static void ftCo_800AEA8C (Fighter *fp)
static void ftCo_800AECF0 (Fighter *fp)
static bool ftCo_800A2718 (mp_UnkStruct0 *)
static void ftCo_800AEFB8 (Fighter *fp)
static void ftCo_800AF290 (Fighter *)
static s32 ftCo_800A2C80 (Fighter *fp)
static void ftCo_800AF78C (Fighter *)
static bool ftCo_800A3234 (Fighter *fp)
static bool ftCo_800A3498 (Fighter *fp)
static bool ftCo_800A3554 (Fighter *fp, float)
static void ftCo_800AFC40 (Fighter *fp)
static bool ftCo_800A3710 (Fighter *fp)
static void ftCo_800AFE3C (Fighter *, int)
static bool ftCo_800A3908 (Fighter *fp, bool)
static void ftCo_800B00F8 (Fighter *)
static void ftCo_800B04DC (Fighter *)
static bool ftCo_800A4038 (Fighter *fp, bool)
static void ftCo_800B0760 (Fighter *fp)
static void ftCo_800B0918 (Fighter *fp0, Fighter *fp1)
static void ftCo_800B0AF4 (Fighter *fp)
static bool ftCo_800B0CA8 (Fighter *fp0, Fighter *fp1)
static s32 ftCo_800A4768 (Fighter *fp, Vec3 *arg1)
static bool ftCo_800B0E98 (Fighter *fp0, Fighter *fp1)
static void ftCo_800A49B4 (Fighter *fp)
static void ftCo_800B101C (Fighter *)
static Fighter * ftCo_800A4BEC (Fighter *fp)
static void ftCo_800B126C (Fighter *)
static bool ftCo_800A1B38 (enum_t)
static void ftCo_800B1478 (Fighter *)
static Fighter * ftCo_800A50D4 (Fighter *fp)
 Returns the closest enemy fighter.
static void ftCo_800B17D0 (Fighter *)
static Fighter * ftCo_800A5294 (Fighter *fp, int player_id)
static Fighter * ftCo_800A53DC (Fighter *)
static void ftCo_800B1AB8 (Fighter *)
static void ftCo_800B1EF0 (Fighter *)
static Fighter * ftCo_800A589C (Fighter *fp)
static bool ftCo_800A5944 (Item *ip)
static void ftCo_800B21C8 (Fighter *)
static void ftCo_800B24B8 (Fighter *)
static void ftCo_800B2790 (Fighter *fp)
static void ftCo_800B33B0 (Fighter *fp)
static bool ftCo_800A5ACC (Fighter *)
static Fighter * ftCo_800A5CE0 (Fighter *fp)
static Item * ftCo_800A5F4C (Fighter *fp, ItemKind arg1)
 Decide which common item to target.
static Item * ftCo_800A61D8 (Fighter *fp)
static int ftCo_800A648C (Fighter *fp)
static bool ftCo_800A6700 (Fighter *fp, Vec3 *, Vec3 *)
static s32 ftCo_800A6A98 (Fighter *fp, Vec3 *arg1)
static s32 ftCo_800A6D2C (Fighter *fp, Vec3 *arg1)
static bool ftCo_800A6FC4 (Fighter *fp, Vec3 *, Vec3 *)
static void ftCo_800A75DC (Fighter *fp0, Fighter *fp1)
static void ftCo_800A7AAC (Fighter *fp)
static void ftCo_800A80E4 (Fighter *fp)
static bool ftCo_800A8210 (Fighter *fp, Vec3 *)
static void ftCo_800A866C (Fighter *fp)
static void ftCo_800A8940 (Fighter *fp)
static void ftCo_800A8DE4 (Fighter *fp)
static void ftCo_800A8EB0 (Fighter *fp)
 Ness recovery PK thunder logic.
static void ftCo_800A92CC (Fighter *fp)
 Pikachu/Pichu recovery logic.
static void ftCo_800A96B8 (Fighter *fp)
 Handles CPU recovery / up-B logic for each character.
static UNK_RET ftCo_800A9904 (Fighter *)
static void ftCo_800A9CB4 (Fighter *fp)
static void ftCo_800AA320 (Fighter *fp, int *stick, int *clamp)
 Determine how much to move the stick based on CPU level.
static UNK_RET ftCo_800AA42C (Fighter *fp)
static UNK_RET ftCo_800AA844 (Fighter *fp)
static void ftCo_800AABC8 (Fighter *fp)
static UNK_RET ftCo_800AACD0 (Fighter *fp)
static bool ftCo_800AAF48 (Fighter *fp)
static void ftCo_800AB224 (Fighter *fp)
static void ftCo_800ABA34 (Fighter *fp)
static void ftCo_800ABBA8 (Fighter *fp)
static void ftCo_800AC30C (Fighter *fp)
static void ftCo_800AC434 (Fighter *fp)
static void ftCo_800AC5A0 (Fighter *fp)
static void ftCo_800B2AFC (Fighter *fp)
static void ftCo_800B1DA0 (Fighter *fp)
static void ftCo_CpuSetNeutralStick (Fighter *fp)
static void ftCo_CpuFinishWithNeutralY (Fighter *fp)
static void ftCo_CpuFinishWithNeutralStick (Fighter *fp)
static void ftCo_CpuReturnToPreviousBehavior (Fighter *fp, struct CpuFighter *data)
static void ftCo_CpuHoldUpForOneFrame (Fighter *fp)
static void ftCo_CpuTapA (Fighter *fp)
static void ftCo_CpuRetapA (Fighter *fp)
static void ftCo_CpuTapB (Fighter *fp)
static void ftCo_CpuStartCharging (Fighter *fp)
static void ftCo_CpuTapR (Fighter *fp)
static void ftCo_CpuRetapR (Fighter *fp)
static void ftCo_CpuTapRAndWait (Fighter *fp)
static void ftCo_CpuDoubleJumpAfterDelay (Fighter *fp)
void ftCo_800A05F4 (Fighter *fp)
void ftCo_800A0798 (Fighter *fp)
void ftCo_800A0C8C (Fighter *fp)
void ftCo_800A0DA4 (Fighter *fp)
bool ftCo_800A0FB0 (Vec3 *vec_out, int *line_id_out, u32 *flags_out, Vec3 *normal_out, int arg4, int arg5, int arg6, float arg7, float arg8, float arg9, float arg10, float arg11)
void ftCo_800A101C (Fighter *arg0, int arg1, int arg2, int arg3)
static float convertStickAxis (s8 val)
float ftCo_GetCpuLStickX (Fighter *fp)
float ftCo_GetCpuLStickY (Fighter *fp)
float ftCo_GetCpuLTrigger (Fighter *fp)
float ftCo_GetCpuRTrigger (Fighter *fp)
HSD_Pad ftCo_GetCpuButtons (Fighter *fp)
float ftCo_GetCpuCStickX (Fighter *fp)
float ftCo_GetCpuCStickY (Fighter *fp)
f32 ftCo_800A1AB4 (Fighter *fp0, Fighter *fp1)
 Compute 2D distance between two fighters.
bool ftCo_800A1B38_noinline (enum_t arg0)
static bool ftCo_IsIgnoredFloor (int line_id)
bool ftCo_800A1BA8 (Fighter *fp)
bool ftCo_800A1C44 (Fighter *fp)
bool ftCo_800A1CA8 (Fighter *fp)
static bool ftCo_800A1CC4_inline0 (Fighter *fp, ftCo_803C6594_t *var_r29, mp_UnkStruct0 *temp_r3)
static void ftCo_800A1CC4_inline1 (Fighter *fp, float x, float y)
static void ftCo_800A1CC4 (Fighter *fp, ftCo_803C6594_t *var_r29)
void ftCo_800A1F3C_noinline (Fighter *fp, float arg1, float arg2, float arg3)
void ftCo_800A1F3C_noinline2 (Fighter *fp, float arg1, float arg2, float arg3)
static void ftCo_ApplyStageEntry (Fighter *fp, GrKind kind)
static void ftCo_800A75DC_set_target (Fighter *fp, const int *x60, float arg1, float arg2, float arg3)
bool ftCo_IsCpuControlled (Fighter *fp)
bool ftCo_800A2170 (Fighter *fp0, Fighter *fp1)
static bool ftCo_800A2718_dontinline (mp_UnkStruct0 *arg0)
static bool ftCo_800A2718_dontinline2 (mp_UnkStruct0 *arg0)
static bool ftCo_800A2718_dontinline3 (mp_UnkStruct0 *arg0)
bool ftCo_800A28D0 (Fighter *fp, float arg1)
bool ftCo_800A2998 (Fighter *fp, float arg1)
float ftCo_800A2A70 (Fighter *fp, bool arg1)
bool ftCo_800A2BD4 (Fighter *fp)
bool ftCo_800A2C08 (Fighter *fp)
static s32 ftCo_800A2C80_inline0 (Fighter *fp)
enum_t ftCo_800A3134 (Fighter *fp)
bool ftCo_IsGrabbing_dontinline (Fighter *fp)
bool ftCo_IsGrabbing (Fighter *fp)
bool ftCo_800A3200 (Fighter *fp)
static bool inlineC0 (Fighter *fp)
static bool ftCo_800A2170_it (Fighter *fp, Item *ip)
 This appears to be similar to ftCo_800A2170, but for fighter/item args.
bool ftCo_IsAlly (Fighter *fp0, Fighter *fp1)
static bool ftCo_IsAlly_dontinline (Fighter *fp0, Fighter *fp1)
static bool ftCo_800A3908_inline0 (Fighter *fp, struct CpuFighter *data, float x, float y)
s32 ftCo_800A3908_inline1 (float x, float y, Vec3 *out_pos, Vec3 *out_normal, int *out_line, u32 *out_flags)
static float ftCo_GetTerminalVelocity (Fighter *fp)
static bool ftCo_800A4038_inline0 (Fighter *fp, struct CpuFighter *data, float x, float y)
static s32 ftCo_800A4038_inline1 (float x, float y, Vec3 *arg_floor_pos, Vec3 *arg_floor_normal, int *arg_line_id, u32 *arg_flags)
static bool ftCo_800A4768_inline0 (Fighter *fp, Vec3 *p)
static bool inlineD0 (Fighter *fp, Fighter *fp1)
static bool inlineD0_it (Fighter *fp, Item *it)
static bool inlineD1 (Fighter *fp)
Fighter * ftCo_800A4A40 (Fighter *fp)
Fighter * ftCo_800A4E8C (Fighter *fp, Vec3 *arg1)
bool ftCo_800A5908 (Item *ip)
bool ftCo_800A5980_dontinline (Fighter *fp)
bool ftCo_800A5980 (Fighter *fp)
bool ftCo_800A59C0 (Item *ip)
bool ftCo_800A59E4 (Item *ip)
bool ftCo_800A5A28 (Item *ip)
bool ftCo_800A5A5C (Item *ip)
bool ftCo_800A5A90 (Fighter *fp)
static float ftCo_GetItemDistance (Fighter *fp, Item *ip)
static bool ftCo_800A648C_inline1 (Item *ip)
static HSD_GObj * ftCo_800A648C_inline2 (void)
static HSD_GObj * ftCo_800A648C_inline3 (HSD_GObj *cur)
static bool ftCo_800A6700_inline0 (Fighter *fp, f32 x, f32 y)
static s32 ftCo_800A6D2C_inline0 (f32 mx, f32 my, Vec3 *fpos, int *lid, u32 *fl, Vec3 *fn, s32 blocked)
static s32 ftCo_800A75DC_CheckFloor (f32 x0, f32 above, f32 x1, f32 below, Vec3 *floor_pos, int *line_id, u32 *flags, Vec3 *floor_normal)
static void ftCo_800A8210_inline0 (Fighter *fp, Vec3 *out)
static s32 ftCo_800A8940_inline0 (s32 result_in, s32 blocked_in, const int *line_id_ptr)
void ftCo_800A8DE4_noinline (Fighter *fp)
static int angle_x_units (float angle)
static int angle_y_units (float angle)
static void ftCo_CpuAimPkThunder (Fighter *fp, float angle, int frames)
static void ftCo_CpuStartUpSpecial (Fighter *fp)
static void ftCo_800A949C (Fighter *fp, bool unused)
 Zelda recovery logic.
static void ftCo_CpuRecoverDiagonally (Fighter *fp)
static void ftCo_800A963C (Fighter *fp, bool unused)
 Samus recovery logic.
static bool ftCo_IsNearlyZero (float x)
static enum_t ftCo_800A9CB4_inline0 (Fighter *fp)
static bool ftCo_800A9CB4_inline1 (Fighter *fp, Vec3 *stage_pos)
static void ftCo_CpuUseAvailableJump (Fighter *fp, struct CpuFighter *data)
static bool isInTeeter (Fighter *fp)
static void ftCo_CpuTurnAwayFromLedge (Fighter *fp)
static void ftCo_CpuTurnAround (Fighter *fp)
static int ftCo_800AA42C_inline0 (float clamp, float dist, float near, float far)
static void ftCo_800AABC8_dontinline (Fighter *fp)
static void ftCo_800ABBA8_blk155144r (Fighter *fp, Fighter **target)
static bool inlineG0 (Fighter *fp)
void ftCo_800AC30C_noinline (Fighter *fp)
static enum_t inlineH0 (Fighter *fp)
static void inlineH1 (Fighter *fp, struct CpuFighter *data)
static bool is_capsule_egg_ball (ItemKind kind)
static bool ftCo_ItemCheck (Item *ip)
static f32 ftCo_800ADE48_inline0 (f32 y)
static struct CpuFighter * ftCo_800ADE48_inline1 (Fighter *fp)
static bool ftCo_800ADE48 (Fighter *fp)
static void ftCo_CpuUpdateCommonItemTarget (Fighter *fp)
static void ftCo_CpuUpdateSpecialItemTarget (Fighter *fp)
static bool ftCo_CpuDataShouldAct (struct CpuFighter *data)
static bool ftCo_CpuShouldAct (Fighter *fp)
static void ftCo_CpuTargetAct (Fighter *fp)
static void ftCo_CpuSetTargetActive (struct CpuFighter *data)
static void ftCo_CpuClearTargetModes (struct CpuFighter *data)
static void ftCo_CpuSetTargetReady (struct CpuFighter *data)
static void ftCo_CpuSetTargetFlags (struct CpuFighter *data)
static void ftCo_CpuInitNoTarget (Fighter *fp, bool fear_flag)
static void ftCo_CpuActOnNoTarget (Fighter *fp, struct CpuFighter *data)
static void ftCo_CpuUpdateTargetDistance (Fighter *fp)
static void ftCo_CpuUpdateFoodItemTarget (Fighter *fp, bool *is_food)
static void ftCo_CpuApproachFoodItemTarget (Fighter *fp, struct CpuFighter *data, Fighter **target_slot, Vec3 *approach_pos)
static void ftCo_CpuActOnPlayer (Fighter *fp, struct CpuFighter *data, int player_id)
static void ftCo_CpuInitEnemyTarget (Fighter *fp, struct CpuFighter *data)
static void inlineI3 (Fighter *fp, struct CpuFighter *data)
static u8 inlineM0 (float x)
static bool inlineJ0 (Fighter *fp, Fighter *nana_fp)
static bool isInCaptureWait (Fighter *fp)
static bool inlineK0 (Fighter *fp0)
static bool isPopoUpB (Fighter *fp)
static bool ftCo_800B101C_inline0 (Fighter *fp, Fighter *other)
static void ftCo_CpuUpdateNanaFollow (Fighter *fp, Fighter *popo, struct CpuFighter *data)
static void ftCo_800B1DA0_noinline (Fighter *fp)
static void ftCo_800B1DA0_noinline2 (Fighter *fp)
static bool ftCo_800B2AFC_IsIgnoredFloor (int line)
static int ftCo_800B33B0_IsIgnoredFloor (int line1)
static void ftCo_CpuUpdateRecoveryScale (Fighter *fp, struct CpuFighter *data, const int *timer)
void ftCo_800B3900 (Fighter_GObj *gobj)
bool ftCo_800B395C (Fighter_GObj *gobj, int arg1)

Variables

int ftCo_803C5A68 []
 Priority table, mapping ItemKind to priority number, for which items the CPU should prefer to target.

Macro Definition Documentation

◆ sqrtf_store

#define sqrtf_store ( x,
y )
Value:
sqrtf(x)
sqrtf
float sqrtf(float)
Definition math_ppc.h:11

◆ ftCo_800A9904_sqrtf_store

#define ftCo_800A9904_sqrtf_store ( dst,
x,
store )
Value:
do { \
if (x > 0.0f) { \
double guess = __frsqrte((double) x); \
guess = 0.5 * guess * (3.0 - guess * guess * x); \
guess = 0.5 * guess * (3.0 - guess * guess * x); \
guess = 0.5 * guess * (3.0 - guess * guess * x); \
store = (float) (x * guess); \
dst = *(f32*) &store; \
} else { \
dst = x; \
} \
} while (0)
f32
float f32
Definition types.h:13
__frsqrte
#define __frsqrte(x)
Definition placeholder.h:13

◆ ftCo_800A9CB4_sqrtf_store

#define ftCo_800A9CB4_sqrtf_store ( dst,
x,
store )
Value:
do { \
if (x > 0.0f) { \
double guess = __frsqrte((double) x); \
guess = 0.5 * guess * (3.0 - guess * guess * x); \
guess = 0.5 * guess * (3.0 - guess * guess * x); \
guess = 0.5 * guess * (3.0 - guess * guess * x); \
store = (float) (x * guess); \
dst = store; \
} else { \
dst = x; \
} \
} while (0)

Function Documentation

◆ ftCo_800A0148()

void ftCo_800A0148 ( Fighter * fp)
static

◆ ftCo_800AC7D4()

void ftCo_800AC7D4 ( Fighter * fp)
static

◆ ftCo_800A0384()

void ftCo_800A0384 ( Fighter * fp)
static

◆ ftCo_800ACB44()

void ftCo_800ACB44 ( Fighter * fp)
static

◆ ftCo_800A0508()

void ftCo_800A0508 ( Fighter * fp)
static

◆ ftCo_800ACD5C()

void ftCo_800ACD5C ( Fighter * fp)
static

◆ ftCo_800A08F0()

void ftCo_800A08F0 ( Fighter * fp)
static

◆ ftCo_800A0AF4()

void ftCo_800A0AF4 ( Fighter * fp)
static

◆ ftCo_800A0CB0()

void ftCo_800A0CB0 ( Fighter * fp)
static

◆ ftCo_800AD42C()

void ftCo_800AD42C ( Fighter * fp)
static

◆ ftCo_800AD54C()

void ftCo_800AD54C ( Fighter * fp)
static

◆ ftCo_800A0F00()

bool ftCo_800A0F00 ( Fighter_GObj * gobj)
static

◆ ftCo_800AD7FC()

void ftCo_800AD7FC ( Fighter * fp)
static

CPU item throw behavior.

◆ ftCo_800ADC28()

void ftCo_800ADC28 ( Fighter * fp)
static

Handle charging neutral-B.

◆ ftCo_800A1F3C()

void ftCo_800A1F3C ( Fighter * fp,
float arg1,
float arg2,
float arg3 )
static

◆ ftCo_800A1F98()

bool ftCo_800A1F98 ( int x,
float y )
static

◆ ftCo_800A20A0()

void ftCo_800A20A0 ( Fighter * fp)
static

◆ ftCo_800AE7AC()

void ftCo_800AE7AC ( Fighter * fp,
Vec3 * arg1,
int arg2 )
static

◆ ftCo_800A21FC()

bool ftCo_800A21FC ( Fighter * fp)
static

◆ ftCo_800A229C()

s32 ftCo_800A229C ( Fighter * fp,
Vec3 * arg1 )
static

◆ ftCo_800AEA8C()

void ftCo_800AEA8C ( Fighter * fp)
static

◆ ftCo_800AECF0()

void ftCo_800AECF0 ( Fighter * fp)
static

◆ ftCo_800A2718()

bool ftCo_800A2718 ( mp_UnkStruct0 * arg0)
static
Todo
Redundant cast and assignment improves match

◆ ftCo_800AEFB8()

void ftCo_800AEFB8 ( Fighter * fp)
static

◆ ftCo_800AF290()

void ftCo_800AF290 ( Fighter * fp)
static

◆ ftCo_800A2C80()

s32 ftCo_800A2C80 ( Fighter * fp)
static

◆ ftCo_800AF78C()

void ftCo_800AF78C ( Fighter * fp)
static

◆ ftCo_800A3234()

bool ftCo_800A3234 ( Fighter * fp)
static

◆ ftCo_800A3498()

bool ftCo_800A3498 ( Fighter * fp)
static

◆ ftCo_800A3554()

bool ftCo_800A3554 ( Fighter * fp,
float arg1 )
static

◆ ftCo_800AFC40()

void ftCo_800AFC40 ( Fighter * fp)
static

◆ ftCo_800A3710()

bool ftCo_800A3710 ( Fighter * fp)
static

◆ ftCo_800AFE3C()

void ftCo_800AFE3C ( Fighter * fp,
int arg1 )
static

◆ ftCo_800A3908()

bool ftCo_800A3908 ( Fighter * fp,
bool arg1 )
static

◆ ftCo_800B00F8()

void ftCo_800B00F8 ( Fighter * fp)
static

◆ ftCo_800B04DC()

void ftCo_800B04DC ( Fighter * fp)
static

◆ ftCo_800A4038()

bool ftCo_800A4038 ( Fighter * fp,
bool arg1 )
static

◆ ftCo_800B0760()

void ftCo_800B0760 ( Fighter * fp)
static

◆ ftCo_800B0918()

void ftCo_800B0918 ( Fighter * fp0,
Fighter * fp1 )
static

◆ ftCo_800B0AF4()

void ftCo_800B0AF4 ( Fighter * fp)
static

◆ ftCo_800B0CA8()

bool ftCo_800B0CA8 ( Fighter * fp0,
Fighter * fp1 )
static

◆ ftCo_800A4768()

s32 ftCo_800A4768 ( Fighter * fp,
Vec3 * arg1 )
static

◆ ftCo_800B0E98()

bool ftCo_800B0E98 ( Fighter * fp0,
Fighter * fp1 )
static

◆ ftCo_800A49B4()

void ftCo_800A49B4 ( Fighter * fp)
static

◆ ftCo_800B101C()

void ftCo_800B101C ( Fighter * fp)
static

◆ ftCo_800A4BEC()

Fighter * ftCo_800A4BEC ( Fighter * fp)
static

◆ ftCo_800B126C()

void ftCo_800B126C ( Fighter * fp)
static

◆ ftCo_800A1B38()

bool ftCo_800A1B38 ( enum_t arg0)
static

◆ ftCo_800B1478()

void ftCo_800B1478 ( Fighter * fp)
static

◆ ftCo_800A50D4()

Fighter * ftCo_800A50D4 ( Fighter * fp)
static

Returns the closest enemy fighter.

◆ ftCo_800B17D0()

void ftCo_800B17D0 ( Fighter * fp)
static

◆ ftCo_800A5294()

Fighter * ftCo_800A5294 ( Fighter * fp,
int player_id )
static

◆ ftCo_800A53DC()

Fighter * ftCo_800A53DC ( Fighter * fp)
static

◆ ftCo_800B1AB8()

void ftCo_800B1AB8 ( Fighter * fp)
static

◆ ftCo_800B1EF0()

void ftCo_800B1EF0 ( Fighter * fp)
static

◆ ftCo_800A589C()

Fighter * ftCo_800A589C ( Fighter * fp)
static

◆ ftCo_800A5944()

bool ftCo_800A5944 ( Item * ip)
static

◆ ftCo_800B21C8()

void ftCo_800B21C8 ( Fighter * fp)
static

◆ ftCo_800B24B8()

void ftCo_800B24B8 ( Fighter * fp)
static

◆ ftCo_800B2790()

void ftCo_800B2790 ( Fighter * fp)
static

◆ ftCo_800B33B0()

void ftCo_800B33B0 ( Fighter * fp)
static

◆ ftCo_800A5ACC()

bool ftCo_800A5ACC ( Fighter * fp)
static

◆ ftCo_800A5CE0()

Fighter * ftCo_800A5CE0 ( Fighter * fp)
static

◆ ftCo_800A5F4C()

Item * ftCo_800A5F4C ( Fighter * fp,
ItemKind arg1 )
static

Decide which common item to target.

The repeated accessor call emits no code but reserves the stack slot the target has below the sqrtf temporaries.

Passing It_Kind_L_Gun_Ray means to target any common item

If we don't have a target yet, just pick the first item, and remember its distance.

Skip items with lower priority than the current one

◆ ftCo_800A61D8()

Item * ftCo_800A61D8 ( Fighter * fp)
static

◆ ftCo_800A648C()

int ftCo_800A648C ( Fighter * fp)
static

◆ ftCo_800A6700()

bool ftCo_800A6700 ( Fighter * fp,
Vec3 * arg1,
Vec3 * arg2 )
static

◆ ftCo_800A6A98()

s32 ftCo_800A6A98 ( Fighter * fp,
Vec3 * arg1 )
static

◆ ftCo_800A6D2C()

s32 ftCo_800A6D2C ( Fighter * fp,
Vec3 * arg1 )
static

◆ ftCo_800A6FC4()

bool ftCo_800A6FC4 ( Fighter * fp,
Vec3 * arg1,
Vec3 * arg2 )
static

◆ ftCo_800A75DC()

void ftCo_800A75DC ( Fighter * fp0,
Fighter * fp1 )
static

◆ ftCo_800A7AAC()

void ftCo_800A7AAC ( Fighter * fp)
static

◆ ftCo_800A80E4()

void ftCo_800A80E4 ( Fighter * fp)
static

◆ ftCo_800A8210()

bool ftCo_800A8210 ( Fighter * fp,
Vec3 * arg1 )
static

◆ ftCo_800A866C()

void ftCo_800A866C ( Fighter * fp)
static

◆ ftCo_800A8940()

void ftCo_800A8940 ( Fighter * fp)
static

◆ ftCo_800A8DE4()

void ftCo_800A8DE4 ( Fighter * fp)
static

◆ ftCo_800A8EB0()

void ftCo_800A8EB0 ( Fighter * fp)
static

Ness recovery PK thunder logic.

◆ ftCo_800A92CC()

void ftCo_800A92CC ( Fighter * fp)
static

Pikachu/Pichu recovery logic.

◆ ftCo_800A96B8()

void ftCo_800A96B8 ( Fighter * fp)
static

Handles CPU recovery / up-B logic for each character.

◆ ftCo_800A9904()

void ftCo_800A9904 ( Fighter * fp)
static

◆ ftCo_800A9CB4()

void ftCo_800A9CB4 ( Fighter * fp)
static

◆ ftCo_800AA320()

void ftCo_800AA320 ( Fighter * fp,
int * stick,
int * clamp )
static

Determine how much to move the stick based on CPU level.

◆ ftCo_800AA42C()

void ftCo_800AA42C ( Fighter * fp)
static

◆ ftCo_800AA844()

void ftCo_800AA844 ( Fighter * fp)
static

◆ ftCo_800AABC8()

void ftCo_800AABC8 ( Fighter * fp)
static
Todo
Using ftCo_CpuTurnAwayFromLedge here changes inlining in ftCo_800AB224.

◆ ftCo_800AACD0()

void ftCo_800AACD0 ( Fighter * fp)
static

◆ ftCo_800AAF48()

bool ftCo_800AAF48 ( Fighter * fp)
static

◆ ftCo_800AB224()

void ftCo_800AB224 ( Fighter * fp)
static

◆ ftCo_800ABA34()

void ftCo_800ABA34 ( Fighter * fp)
static

◆ ftCo_800ABBA8()

void ftCo_800ABBA8 ( Fighter * fp)
static

◆ ftCo_800AC30C()

void ftCo_800AC30C ( Fighter * fp)
static

◆ ftCo_800AC434()

void ftCo_800AC434 ( Fighter * fp)
static

◆ ftCo_800AC5A0()

void ftCo_800AC5A0 ( Fighter * fp)
static
Bug
These can be called with stick_x and stick_y being uninitialized.

◆ ftCo_800B2AFC()

void ftCo_800B2AFC ( Fighter * fp)
static

◆ ftCo_800B1DA0()

void ftCo_800B1DA0 ( Fighter * fp)
static

◆ ftCo_CpuSetNeutralStick()

void ftCo_CpuSetNeutralStick ( Fighter * fp)
inlinestatic

◆ ftCo_CpuFinishWithNeutralY()

void ftCo_CpuFinishWithNeutralY ( Fighter * fp)
inlinestatic

◆ ftCo_CpuFinishWithNeutralStick()

void ftCo_CpuFinishWithNeutralStick ( Fighter * fp)
inlinestatic

◆ ftCo_CpuReturnToPreviousBehavior()

void ftCo_CpuReturnToPreviousBehavior ( Fighter * fp,
struct CpuFighter * data )
inlinestatic

◆ ftCo_CpuHoldUpForOneFrame()

void ftCo_CpuHoldUpForOneFrame ( Fighter * fp)
inlinestatic

◆ ftCo_CpuTapA()

void ftCo_CpuTapA ( Fighter * fp)
inlinestatic

◆ ftCo_CpuRetapA()

void ftCo_CpuRetapA ( Fighter * fp)
inlinestatic

◆ ftCo_CpuTapB()

void ftCo_CpuTapB ( Fighter * fp)
inlinestatic

◆ ftCo_CpuStartCharging()

void ftCo_CpuStartCharging ( Fighter * fp)
inlinestatic

◆ ftCo_CpuTapR()

void ftCo_CpuTapR ( Fighter * fp)
inlinestatic

◆ ftCo_CpuRetapR()

void ftCo_CpuRetapR ( Fighter * fp)
inlinestatic

◆ ftCo_CpuTapRAndWait()

void ftCo_CpuTapRAndWait ( Fighter * fp)
inlinestatic

◆ ftCo_CpuDoubleJumpAfterDelay()

void ftCo_CpuDoubleJumpAfterDelay ( Fighter * fp)
inlinestatic

◆ ftCo_800A05F4()

void ftCo_800A05F4 ( Fighter * fp)

◆ ftCo_800A0798()

void ftCo_800A0798 ( Fighter * fp)

◆ ftCo_800A0C8C()

void ftCo_800A0C8C ( Fighter * fp)

◆ ftCo_800A0DA4()

void ftCo_800A0DA4 ( Fighter * fp)

◆ ftCo_800A0FB0()

bool ftCo_800A0FB0 ( Vec3 * vec_out,
int * line_id_out,
u32 * flags_out,
Vec3 * normal_out,
int arg4,
int arg5,
int arg6,
float arg7,
float arg8,
float arg9,
float arg10,
float arg11 )

◆ ftCo_800A101C()

void ftCo_800A101C ( Fighter * arg0,
int arg1,
int arg2,
int arg3 )

◆ convertStickAxis()

float convertStickAxis ( s8 val)
inlinestatic

◆ ftCo_GetCpuLStickX()

float ftCo_GetCpuLStickX ( Fighter * fp)

◆ ftCo_GetCpuLStickY()

float ftCo_GetCpuLStickY ( Fighter * fp)

◆ ftCo_GetCpuLTrigger()

float ftCo_GetCpuLTrigger ( Fighter * fp)

◆ ftCo_GetCpuRTrigger()

float ftCo_GetCpuRTrigger ( Fighter * fp)

◆ ftCo_GetCpuButtons()

HSD_Pad ftCo_GetCpuButtons ( Fighter * fp)

◆ ftCo_GetCpuCStickX()

float ftCo_GetCpuCStickX ( Fighter * fp)

◆ ftCo_GetCpuCStickY()

float ftCo_GetCpuCStickY ( Fighter * fp)

◆ ftCo_800A1AB4()

f32 ftCo_800A1AB4 ( Fighter * fp0,
Fighter * fp1 )

Compute 2D distance between two fighters.

◆ ftCo_800A1B38_noinline()

bool ftCo_800A1B38_noinline ( enum_t arg0)

◆ ftCo_IsIgnoredFloor()

bool ftCo_IsIgnoredFloor ( int line_id)
inlinestatic

◆ ftCo_800A1BA8()

bool ftCo_800A1BA8 ( Fighter * fp)

◆ ftCo_800A1C44()

bool ftCo_800A1C44 ( Fighter * fp)

◆ ftCo_800A1CA8()

bool ftCo_800A1CA8 ( Fighter * fp)

◆ ftCo_800A1CC4_inline0()

bool ftCo_800A1CC4_inline0 ( Fighter * fp,
ftCo_803C6594_t * var_r29,
mp_UnkStruct0 * temp_r3 )
inlinestatic

◆ ftCo_800A1CC4_inline1()

void ftCo_800A1CC4_inline1 ( Fighter * fp,
float x,
float y )
inlinestatic

◆ ftCo_800A1CC4()

void ftCo_800A1CC4 ( Fighter * fp,
ftCo_803C6594_t * var_r29 )
static

◆ ftCo_800A1F3C_noinline()

void ftCo_800A1F3C_noinline ( Fighter * fp,
float arg1,
float arg2,
float arg3 )

◆ ftCo_800A1F3C_noinline2()

void ftCo_800A1F3C_noinline2 ( Fighter * fp,
float arg1,
float arg2,
float arg3 )

◆ ftCo_ApplyStageEntry()

void ftCo_ApplyStageEntry ( Fighter * fp,
GrKind kind )
inlinestatic

◆ ftCo_800A75DC_set_target()

void ftCo_800A75DC_set_target ( Fighter * fp,
const int * x60,
float arg1,
float arg2,
float arg3 )
inlinestatic

◆ ftCo_IsCpuControlled()

bool ftCo_IsCpuControlled ( Fighter * fp)

◆ ftCo_800A2170()

bool ftCo_800A2170 ( Fighter * fp0,
Fighter * fp1 )

◆ ftCo_800A2718_dontinline()

bool ftCo_800A2718_dontinline ( mp_UnkStruct0 * arg0)
inlinestatic

◆ ftCo_800A2718_dontinline2()

bool ftCo_800A2718_dontinline2 ( mp_UnkStruct0 * arg0)
inlinestatic

◆ ftCo_800A2718_dontinline3()

bool ftCo_800A2718_dontinline3 ( mp_UnkStruct0 * arg0)
inlinestatic

◆ ftCo_800A28D0()

bool ftCo_800A28D0 ( Fighter * fp,
float arg1 )

◆ ftCo_800A2998()

bool ftCo_800A2998 ( Fighter * fp,
float arg1 )

◆ ftCo_800A2A70()

float ftCo_800A2A70 ( Fighter * fp,
bool arg1 )

◆ ftCo_800A2BD4()

bool ftCo_800A2BD4 ( Fighter * fp)

◆ ftCo_800A2C08()

bool ftCo_800A2C08 ( Fighter * fp)

◆ ftCo_800A2C80_inline0()

s32 ftCo_800A2C80_inline0 ( Fighter * fp)
inlinestatic

◆ ftCo_800A3134()

enum_t ftCo_800A3134 ( Fighter * fp)

◆ ftCo_IsGrabbing_dontinline()

bool ftCo_IsGrabbing_dontinline ( Fighter * fp)

◆ ftCo_IsGrabbing()

bool ftCo_IsGrabbing ( Fighter * fp)

◆ ftCo_800A3200()

bool ftCo_800A3200 ( Fighter * fp)

◆ inlineC0()

bool inlineC0 ( Fighter * fp)
inlinestatic

◆ ftCo_800A2170_it()

bool ftCo_800A2170_it ( Fighter * fp,
Item * ip )
inlinestatic

This appears to be similar to ftCo_800A2170, but for fighter/item args.

◆ ftCo_IsAlly()

bool ftCo_IsAlly ( Fighter * fp0,
Fighter * fp1 )

◆ ftCo_IsAlly_dontinline()

bool ftCo_IsAlly_dontinline ( Fighter * fp0,
Fighter * fp1 )
inlinestatic

◆ ftCo_800A3908_inline0()

bool ftCo_800A3908_inline0 ( Fighter * fp,
struct CpuFighter * data,
float x,
float y )
inlinestatic

◆ ftCo_800A3908_inline1()

s32 ftCo_800A3908_inline1 ( float x,
float y,
Vec3 * out_pos,
Vec3 * out_normal,
int * out_line,
u32 * out_flags )
inline

◆ ftCo_GetTerminalVelocity()

float ftCo_GetTerminalVelocity ( Fighter * fp)
inlinestatic

◆ ftCo_800A4038_inline0()

bool ftCo_800A4038_inline0 ( Fighter * fp,
struct CpuFighter * data,
float x,
float y )
inlinestatic

◆ ftCo_800A4038_inline1()

s32 ftCo_800A4038_inline1 ( float x,
float y,
Vec3 * arg_floor_pos,
Vec3 * arg_floor_normal,
int * arg_line_id,
u32 * arg_flags )
inlinestatic

◆ ftCo_800A4768_inline0()

bool ftCo_800A4768_inline0 ( Fighter * fp,
Vec3 * p )
inlinestatic

◆ inlineD0()

bool inlineD0 ( Fighter * fp,
Fighter * fp1 )
inlinestatic

◆ inlineD0_it()

bool inlineD0_it ( Fighter * fp,
Item * it )
inlinestatic

◆ inlineD1()

bool inlineD1 ( Fighter * fp)
inlinestatic

◆ ftCo_800A4A40()

Fighter * ftCo_800A4A40 ( Fighter * fp)

◆ ftCo_800A4E8C()

Fighter * ftCo_800A4E8C ( Fighter * fp,
Vec3 * arg1 )

◆ ftCo_800A5908()

bool ftCo_800A5908 ( Item * ip)

◆ ftCo_800A5980_dontinline()

bool ftCo_800A5980_dontinline ( Fighter * fp)

◆ ftCo_800A5980()

bool ftCo_800A5980 ( Fighter * fp)

◆ ftCo_800A59C0()

bool ftCo_800A59C0 ( Item * ip)

◆ ftCo_800A59E4()

bool ftCo_800A59E4 ( Item * ip)

◆ ftCo_800A5A28()

bool ftCo_800A5A28 ( Item * ip)

◆ ftCo_800A5A5C()

bool ftCo_800A5A5C ( Item * ip)

◆ ftCo_800A5A90()

bool ftCo_800A5A90 ( Fighter * fp)

◆ ftCo_GetItemDistance()

float ftCo_GetItemDistance ( Fighter * fp,
Item * ip )
inlinestatic

◆ ftCo_800A648C_inline1()

bool ftCo_800A648C_inline1 ( Item * ip)
inlinestatic

◆ ftCo_800A648C_inline2()

HSD_GObj * ftCo_800A648C_inline2 ( void )
inlinestatic

◆ ftCo_800A648C_inline3()

HSD_GObj * ftCo_800A648C_inline3 ( HSD_GObj * cur)
inlinestatic

◆ ftCo_800A6700_inline0()

bool ftCo_800A6700_inline0 ( Fighter * fp,
f32 x,
f32 y )
inlinestatic

◆ ftCo_800A6D2C_inline0()

s32 ftCo_800A6D2C_inline0 ( f32 mx,
f32 my,
Vec3 * fpos,
int * lid,
u32 * fl,
Vec3 * fn,
s32 blocked )
inlinestatic

◆ ftCo_800A75DC_CheckFloor()

s32 ftCo_800A75DC_CheckFloor ( f32 x0,
f32 above,
f32 x1,
f32 below,
Vec3 * floor_pos,
int * line_id,
u32 * flags,
Vec3 * floor_normal )
inlinestatic

◆ ftCo_800A8210_inline0()

void ftCo_800A8210_inline0 ( Fighter * fp,
Vec3 * out )
inlinestatic

◆ ftCo_800A8940_inline0()

s32 ftCo_800A8940_inline0 ( s32 result_in,
s32 blocked_in,
const int * line_id_ptr )
inlinestatic

◆ ftCo_800A8DE4_noinline()

void ftCo_800A8DE4_noinline ( Fighter * fp)

◆ angle_x_units()

int angle_x_units ( float angle)
inlinestatic

◆ angle_y_units()

int angle_y_units ( float angle)
inlinestatic

◆ ftCo_CpuAimPkThunder()

void ftCo_CpuAimPkThunder ( Fighter * fp,
float angle,
int frames )
inlinestatic

◆ ftCo_CpuStartUpSpecial()

void ftCo_CpuStartUpSpecial ( Fighter * fp)
inlinestatic

◆ ftCo_800A949C()

void ftCo_800A949C ( Fighter * fp,
bool unused )
static

Zelda recovery logic.

If we're far from the stage horizontally, up-B diagonally, otherwise go straight up.

◆ ftCo_CpuRecoverDiagonally()

void ftCo_CpuRecoverDiagonally ( Fighter * fp)
inlinestatic

◆ ftCo_800A963C()

void ftCo_800A963C ( Fighter * fp,
bool unused )
static

Samus recovery logic.

◆ ftCo_IsNearlyZero()

bool ftCo_IsNearlyZero ( float x)
inlinestatic

◆ ftCo_800A9CB4_inline0()

enum_t ftCo_800A9CB4_inline0 ( Fighter * fp)
inlinestatic

◆ ftCo_800A9CB4_inline1()

bool ftCo_800A9CB4_inline1 ( Fighter * fp,
Vec3 * stage_pos )
inlinestatic

◆ ftCo_CpuUseAvailableJump()

void ftCo_CpuUseAvailableJump ( Fighter * fp,
struct CpuFighter * data )
inlinestatic

◆ isInTeeter()

bool isInTeeter ( Fighter * fp)
inlinestatic

◆ ftCo_CpuTurnAwayFromLedge()

void ftCo_CpuTurnAwayFromLedge ( Fighter * fp)
inlinestatic

◆ ftCo_CpuTurnAround()

void ftCo_CpuTurnAround ( Fighter * fp)
inlinestatic

◆ ftCo_800AA42C_inline0()

int ftCo_800AA42C_inline0 ( float clamp,
float dist,
float near,
float far )
inlinestatic

◆ ftCo_800AABC8_dontinline()

void ftCo_800AABC8_dontinline ( Fighter * fp)
inlinestatic

◆ ftCo_800ABBA8_blk155144r()

void ftCo_800ABBA8_blk155144r ( Fighter * fp,
Fighter ** target )
inlinestatic

◆ inlineG0()

bool inlineG0 ( Fighter * fp)
inlinestatic

◆ ftCo_800AC30C_noinline()

void ftCo_800AC30C_noinline ( Fighter * fp)

◆ inlineH0()

enum_t inlineH0 ( Fighter * fp)
inlinestatic

◆ inlineH1()

void inlineH1 ( Fighter * fp,
struct CpuFighter * data )
inlinestatic

◆ is_capsule_egg_ball()

bool is_capsule_egg_ball ( ItemKind kind)
inlinestatic

◆ ftCo_ItemCheck()

bool ftCo_ItemCheck ( Item * ip)
inlinestatic

◆ ftCo_800ADE48_inline0()

f32 ftCo_800ADE48_inline0 ( f32 y)
inlinestatic

◆ ftCo_800ADE48_inline1()

struct CpuFighter * ftCo_800ADE48_inline1 ( Fighter * fp)
inlinestatic

◆ ftCo_800ADE48()

bool ftCo_800ADE48 ( Fighter * fp)
static

◆ ftCo_CpuUpdateCommonItemTarget()

void ftCo_CpuUpdateCommonItemTarget ( Fighter * fp)
inlinestatic

◆ ftCo_CpuUpdateSpecialItemTarget()

void ftCo_CpuUpdateSpecialItemTarget ( Fighter * fp)
inlinestatic

◆ ftCo_CpuDataShouldAct()

bool ftCo_CpuDataShouldAct ( struct CpuFighter * data)
inlinestatic

◆ ftCo_CpuShouldAct()

bool ftCo_CpuShouldAct ( Fighter * fp)
inlinestatic

◆ ftCo_CpuTargetAct()

void ftCo_CpuTargetAct ( Fighter * fp)
inlinestatic

◆ ftCo_CpuSetTargetActive()

void ftCo_CpuSetTargetActive ( struct CpuFighter * data)
inlinestatic

◆ ftCo_CpuClearTargetModes()

void ftCo_CpuClearTargetModes ( struct CpuFighter * data)
inlinestatic

◆ ftCo_CpuSetTargetReady()

void ftCo_CpuSetTargetReady ( struct CpuFighter * data)
inlinestatic

◆ ftCo_CpuSetTargetFlags()

void ftCo_CpuSetTargetFlags ( struct CpuFighter * data)
inlinestatic

◆ ftCo_CpuInitNoTarget()

void ftCo_CpuInitNoTarget ( Fighter * fp,
bool fear_flag )
inlinestatic
Note
These phases must be called directly from their three users. Wrapping them in another inline prevents MWCC from inlining the outer helper.

◆ ftCo_CpuActOnNoTarget()

void ftCo_CpuActOnNoTarget ( Fighter * fp,
struct CpuFighter * data )
inlinestatic

◆ ftCo_CpuUpdateTargetDistance()

void ftCo_CpuUpdateTargetDistance ( Fighter * fp)
inlinestatic

◆ ftCo_CpuUpdateFoodItemTarget()

void ftCo_CpuUpdateFoodItemTarget ( Fighter * fp,
bool * is_food )
inlinestatic

◆ ftCo_CpuApproachFoodItemTarget()

void ftCo_CpuApproachFoodItemTarget ( Fighter * fp,
struct CpuFighter * data,
Fighter ** target_slot,
Vec3 * approach_pos )
inlinestatic

◆ ftCo_CpuActOnPlayer()

void ftCo_CpuActOnPlayer ( Fighter * fp,
struct CpuFighter * data,
int player_id )
inlinestatic

◆ ftCo_CpuInitEnemyTarget()

void ftCo_CpuInitEnemyTarget ( Fighter * fp,
struct CpuFighter * data )
inlinestatic

◆ inlineI3()

void inlineI3 ( Fighter * fp,
struct CpuFighter * data )
inlinestatic

◆ inlineM0()

u8 inlineM0 ( float x)
inlinestatic
Todo
Maybe a macro?

◆ inlineJ0()

bool inlineJ0 ( Fighter * fp,
Fighter * nana_fp )
inlinestatic

◆ isInCaptureWait()

bool isInCaptureWait ( Fighter * fp)
inlinestatic

◆ inlineK0()

bool inlineK0 ( Fighter * fp0)
inlinestatic

◆ isPopoUpB()

bool isPopoUpB ( Fighter * fp)
inlinestatic

◆ ftCo_800B101C_inline0()

bool ftCo_800B101C_inline0 ( Fighter * fp,
Fighter * other )
inlinestatic

◆ ftCo_CpuUpdateNanaFollow()

void ftCo_CpuUpdateNanaFollow ( Fighter * fp,
Fighter * popo,
struct CpuFighter * data )
inlinestatic

◆ ftCo_800B1DA0_noinline()

void ftCo_800B1DA0_noinline ( Fighter * fp)
inlinestatic

◆ ftCo_800B1DA0_noinline2()

void ftCo_800B1DA0_noinline2 ( Fighter * fp)
inlinestatic

◆ ftCo_800B2AFC_IsIgnoredFloor()

bool ftCo_800B2AFC_IsIgnoredFloor ( int line)
inlinestatic

◆ ftCo_800B33B0_IsIgnoredFloor()

int ftCo_800B33B0_IsIgnoredFloor ( int line1)
inlinestatic

◆ ftCo_CpuUpdateRecoveryScale()

void ftCo_CpuUpdateRecoveryScale ( Fighter * fp,
struct CpuFighter * data,
const int * timer )
inlinestatic

◆ ftCo_800B3900()

void ftCo_800B3900 ( Fighter_GObj * gobj)

◆ ftCo_800B395C()

bool ftCo_800B395C ( Fighter_GObj * gobj,
int arg1 )

Variable Documentation

◆ ftCo_803C5A68

int ftCo_803C5A68[]
Initial value:
= {
1, 0, 0, 1, 0, 0, 0, 1, 7, 6, 5, 4, 4, 3, 1, 1, 2, 1,
5, 2, 2, 2, 3, 3, 3, 4, 0, 0, 8, 4, 1, 4, 4, 5, 5,
}

Priority table, mapping ItemKind to priority number, for which items the CPU should prefer to target.

Todo
.sdata2 order hack

Higher numbers are preferred.