Go to the source code of this file.

Data Structures
struct	QuizRequirement

struct	NpcBlueprint

struct	MobileAISettings

struct	GuardAISettings

struct	FireBarAISettings

struct	FireBarData

struct	NpcSettings

struct	ItemDrop

struct	StatDrop
	Describes heart/flower drop chances after defeating an Npc in the overworld. More...

struct	EnemyDrops

struct	EnemyDetectVolume

struct	EnemyTerritoryWander

struct	EnemyTerritoryPatrol

union	EnemyTerritory

union	NpcInitialVars

struct	NpcData

struct	NpcGroup
	Zero-terminated. More...

struct	Enemy

struct	Encounter

struct	FieldStatus

struct	EncounterStatus

struct	NpcData.animations

union	Enemy.__unnamed54__

Macros
#define	NPC_GROUP(args...) VFUNC(NPC_GROUP, args)

#define	NPC_GROUP1(npcs) { sizeof(npcs) / sizeof(NpcData), (NpcData*) &npcs, 0, 0 }

#define	NPC_GROUP2(npcs, battle) { sizeof(npcs) / sizeof(NpcData), (NpcData*) &npcs, battle, 0 }

#define	NPC_GROUP3(npcs, battle, stage) { sizeof(npcs) / sizeof(NpcData), (NpcData*) &npcs, battle, stage + 1 }

#define	NPC_GROUP_EXPLICIT_SIZE(args...) VFUNC(NPC_GROUP_EXPLICIT_SIZE, args)

#define	NPC_GROUP_EXPLICIT_SIZE3(npcs, start, count) { count, (NpcData*) &npcs[start], 0, 0 }

#define	NPC_GROUP_EXPLICIT_SIZE4(npcs, start, count, battle) { count, (NpcData*) &npcs[start], battle, 0 }

#define	NPC_GROUP_EXPLICIT_SIZE5(npcs, start, count, battle, stage) { count, (NpcData*) &npcs[start], battle, stage + 1 }

#define	NO_DROPS

#define	STANDARD_HEART_DROPS(attempts)

#define	GENEROUS_HEART_DROPS(attempts)

#define	GENEROUS_WHEN_LOW_HEART_DROPS(attempts)

#define	STANDARD_FLOWER_DROPS(attempts)

#define	GENEROUS_WHEN_LOW_FLOWER_DROPS(attempts)

#define	REDUCED_FLOWER_DROPS(attempts)

#define	OVERRIDE_MOVEMENT_SPEED(speed) ((s32)(speed * 32767))

#define	NO_OVERRIDE_MOVEMENT_SPEED OVERRIDE_MOVEMENT_SPEED(-1.0f)

Typedefs
typedef void(*	FireBarCallback) (struct FireBarData *, s32)

typedef NpcGroup	NpcGroupList[]

typedef void	AIStateHandler(Evt script, MobileAISettings settings, EnemyDetectVolume *territory)

Enumerations
enum	TerritoryShape { SHAPE_CYLINDER , SHAPE_RECT }

Functions
b32	basic_ai_check_player_dist (EnemyDetectVolume arg0, Enemy arg1, f32 arg2, f32 arg3, s8 arg4)

void	STUB_npc_callback (Npc *)
	The default Npc::onUpdate and Npc::onRender callback.

void	mtx_ident_mirror_y (Matrix4f mtx)

void	clear_npcs (void)

void	init_npc_list (void)
	Points the current NPC list to the world or battle lists depending on game state.

s32	create_npc_impl (NpcBlueprint blueprint, AnimID animList, s32 skipLoadingAnims)

s32	create_basic_npc (NpcBlueprint *blueprint)

s32	create_standard_npc (NpcBlueprint blueprint, AnimID animList)

s32	create_peach_npc (NpcBlueprint *blueprint)

void	free_npc_by_index (s32 listIndex)

void	free_npc (Npc *npc)

Npc *	get_npc_by_index (s32 listIndex)

void	npc_do_world_collision (Npc *npc)

void	npc_do_other_npc_collision (Npc *npc)

s32	npc_do_player_collision (Npc *npc)

void	npc_try_apply_gravity (Npc *npc)

s32	npc_try_snap_to_ground (Npc *npc, f32 velocity)

void	update_npcs (void)
	Updates all NPCs.

f32	npc_get_render_yaw (Npc *npc)

void	appendGfx_npc (void *data)

void	render_npcs (void)
	Renders all NPCs.

void	npc_move_heading (Npc *npc, f32 speed, f32 yaw)

Npc *	get_npc_unsafe (s32 npcID)

Npc *	get_npc_safe (s32 npcID)

void	enable_npc_shadow (Npc *npc)

void	disable_npc_shadow (Npc *npc)

void	update_npc_blur (Npc *npc)

void	appendGfx_npc_blur (void *npc)

void	npc_enable_collisions (void)

void	npc_disable_collisions (void)

void	func_8003B1A8 (void)

void	npc_reload_all (void)

void	set_npc_yaw (Npc *npc, f32 yaw)

void	npc_set_palswap_mode_A (Npc *npc, s32 arg1)

void	npc_set_palswap_mode_B (Npc *npc, s32 arg1)

void	npc_revert_palswap_mode (Npc *npc)

void	npc_set_palswap_1 (Npc *npc, s32 palIndexA, s32 palIndexB, s32 timeHoldA, s32 timeAB)

void	npc_set_palswap_2 (Npc *npc, s32 timeHoldB, s32 timeBA, s32 palIndexC, s32 palIndexD)

void	npc_draw_with_palswap (Npc *npc, s32 arg1, Matrix4f mtx)

void	npc_render_without_adjusted_palettes (Npc *npc, s32 arg1, Matrix4f mtx)

void	npc_render_with_watt_idle_palettes (Npc *, s32, Matrix4f mtx)

u16	npc_blend_palette_colors (u16 colorA, u16 colorB, s32 lerpAlpha)

void	npc_render_with_single_pal_blending (Npc *, s32, s32, Matrix4f mtx)

void	npc_render_with_double_pal_blending (Npc *, s32, Matrix4f mtx)

void	npc_set_decoration (Npc *npc, s32 idx, s32 decorationType)

void	npc_remove_decoration (Npc *npc, s32 idx)

void	npc_update_decorations (Npc *npc)

void	npc_reset_current_decoration (Npc *npc, s32 idx)

void	npc_update_decoration_none (Npc *npc, s32 idx)

void	npc_remove_decoration_none (Npc *npc, s32 idx)

void	npc_update_decoration_bowser_aura (Npc *npc, s32 idx)

void	npc_remove_decoration_bowser_aura (Npc *npc, s32 idx)

void	npc_update_decoration_sweat (Npc *npc, s32 idx)

void	npc_remove_decoration_sweat (Npc *npc, s32 idx)

void	npc_update_decoration_seeing_stars (Npc *npc, s32 idx)

void	npc_remove_decoration_seeing_stars (Npc *npc, s32 idx)

void	npc_update_decoration_glow_in_front (Npc *npc, s32 idx)

void	npc_remove_decoration_glow_in_front (Npc *npc, s32 idx)

void	npc_update_decoration_glow_behind (Npc *npc, s32 idx)

void	npc_remove_decoration_glow_behind (Npc *npc, s32 idx)

void	npc_update_decoration_charged (Npc *npc, s32 idx)

void	npc_remove_decoration_charged (Npc *npc, s32 idx)

Npc *	npc_find_closest (f32 x, f32 y, f32 z, f32 radius)
	Finds the closest NPC to a given point within a radius.

Npc *	npc_find_closest_simple (f32 x, f32 y, f32 z, f32 radius)
	Finds the closest simple-hitbox NPC to a given point within a radius.

s32	npc_get_collider_below (Npc *npc)

void	npc_imgfx_update (Npc *npc)

void	npc_set_imgfx_params (Npc *npc, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 arg5, s32 arg6)

void	npc_surface_spawn_fx (Npc *npc, SurfaceInteractMode mode)

void	spawn_default_surface_effects (Npc *npc, SurfaceInteractMode mode)

void	spawn_flower_surface_effects (Npc *npc, SurfaceInteractMode mode)

void	spawn_cloud_surface_effects (Npc *npc, SurfaceInteractMode mode)

void	spawn_snow_surface_effects (Npc *npc, SurfaceInteractMode mode)

void	spawn_hedge_surface_effects (Npc *npc, SurfaceInteractMode mode)

void	spawn_water_surface_effects (Npc *npc, SurfaceInteractMode mode)

void	COPY_set_defeated (s32 mapID, s32 encounterID)
	Duplicate of set_defeated().

void	init_encounter_status (void)

void	clear_encounter_status (void)

void	func_8003E50C (void)

void	func_8003E514 (s8 arg0)

void	update_encounters (void)

void	draw_encounter_ui (void)

void	draw_first_strike_ui (void)

void	npc_render_worker_do_nothing (void)

void	make_npcs (s32 flags, s32 mapID, s32 *npcGroupList)

void	kill_encounter (Enemy *enemy)

void	kill_enemy (Enemy *enemy)

s32	bind_enemy_ai (Enemy enemy, EvtScript aiScriptBytecode)
	Binds the specified ai script to the specified enemy.

s32	bind_enemy_aux (Enemy enemy, EvtScript auxScriptBytecode)
	Binds the specified auxillary script to the specified enemy.

s32	bind_enemy_interact (Enemy enemy, EvtScript interactScriptBytecode)
	Binds the specified interact script to the specified enemy.

void	bind_npc_ai (s32 npcID, EvtScript *npcAiBytecode)
	Binds the specified ai script to the npc matching the specified npcId.

void	bind_npc_aux (s32 npcID, EvtScript *npcAuxBytecode)
	Binds the specified auxillary script to the npc matching the specified npcId.

void	bind_npc_interact (s32 npcID, EvtScript *npcInteractBytecode)
	Binds the specified interact script to the npc matching the specified npcId.

Enemy *	get_enemy (s32 npcID)
	Looks for an enemy matching the specified npcID.

Enemy *	get_enemy_safe (s32 npcID)
	Same as get_enemy(), with the exception of always returning a value if an enemy is not found.

void	set_npc_sprite (Npc npc, s32 anim, AnimID extraAnimList)

Variables
EncounterStatus	gCurrentEncounter

Data Structure Documentation

◆ QuizRequirement

struct QuizRequirement

Data Fields
s32	requiredStoryProgress
s32	numQuestionsUnlocked

◆ MobileAISettings

struct MobileAISettings

Data Fields
f32	moveSpeed
s32	moveTime
s32	waitTime
f32	alertRadius
f32	alertOffsetDist
s32	playerSearchInterval
f32	chaseSpeed
s32	chaseTurnRate
s32	chaseUpdateInterval
f32	chaseRadius
f32	chaseOffsetDist
s32	unk_AI_2C

◆ GuardAISettings

struct GuardAISettings

Data Fields
f32	alertRadius
f32	alertOffsetDist
s32	playerSearchInterval
f32	chaseSpeed
s32	chaseTurnRate
s32	chaseUpdateInterval
f32	chaseRadius
f32	chaseOffsetDist
s32	unk_AI_20

◆ FireBarAISettings

struct FireBarAISettings

Data Fields
Vec3i	centerPos
s32	rotRate
s32	firstNpc
s32	npcCount
FireBarCallback	callback

◆ FireBarData

struct FireBarData

Data Fields
s32	flags
Vec3f	centerPos
f32	rotRate
s32	firstNpc
s32	npcCount
FireBarCallback	callback
s32	soundIndex
f32	lastDeltaYaw
f32	yaw
FireBarAISettings *	settings

◆ NpcSettings

struct NpcSettings

Data Fields
AnimID	defaultAnim
s16	height
s16	radius
void *	otherAI
EvtScript *	onInteract
EvtScript *	ai
EvtScript *	onHit
EvtScript *	aux
EvtScript *	onDefeat
s32	flags
s32	unk_24
s16	level
s16	actionFlags

◆ ItemDrop

struct ItemDrop

Data Fields
s16	item
s16	weight
s16	flagIdx

◆ StatDrop

struct StatDrop

Data Fields
s16	cutoff	% of max HP/FP. If current HP/FP > cutoff, no hearts/flowers can be dropped.
s16	generalChance	% chance for any hearts/flowers to be dropped at all from this StatDrop.
s16	attempts	Maximum number of hearts/flowers that can be dropped from this StatDrop.
s16	chancePerAttempt	% chance for a single heart/flower to be dropped from each attempt.

◆ EnemyDrops

struct EnemyDrops

Data Fields
u8	dropFlags
u8	itemDropChance
ItemDrop	itemDrops[8]
StatDrop	heartDrops[8]
StatDrop	flowerDrops[8]
s16	minCoinBonus
s16	maxCoinBonus
char	unk_DE[2]

◆ EnemyDetectVolume

struct EnemyDetectVolume

Data Fields
s32	skipPlayerDetectChance
enum TerritoryShape	shape
s32	pointX
s32	pointZ
s32	sizeX
s32	sizeZ
f32	halfHeight
s16	detectFlags

◆ EnemyTerritoryWander

struct EnemyTerritoryWander

Data Fields
Vec3i	centerPos
VecXZi	wanderSize
s32	moveSpeedOverride
enum TerritoryShape	wanderShape
Vec3i	detectPos
VecXZi	detectSize
enum TerritoryShape	detectShape
b32	isFlying

◆ EnemyTerritoryPatrol

struct EnemyTerritoryPatrol

Data Fields
s32	numPoints
Vec3i	points[10]
s32	moveSpeedOverride
Vec3i	detectPos
VecXZi	detectSize
enum TerritoryShape	detectShape
b32	isFlying

◆ EnemyTerritory

union EnemyTerritory

Data Fields
EnemyTerritoryWander	wander
EnemyTerritoryPatrol	patrol
char	PADDING[0xC0]

◆ NpcInitialVars

union NpcInitialVars

Data Fields
s32	value
s8	bytes[4]
s32 *	array

◆ NpcData

struct NpcData

Data Fields
s32	id
NpcSettings *	settings
Vec3f	pos
s32	flags
EvtScript *	init
s32	initVarCount
NpcInitialVars	initVar
s32	yaw
EnemyDrops	drops
EnemyTerritory	territory
struct NpcData.animations	animations
s8	unk__1E0
s8	unk__1E1
s8	unk__1E2
u8	aiDetectFlags
u32	aiFlags
AnimID *	extraAnimations
s32	tattle

◆ NpcGroup

struct NpcGroup

Data Fields
s32	npcCount
NpcData *	npcs
s16	battle
s16	stage

◆ Enemy

struct Enemy

Data Fields
s32	flags
s8	encounterIndex
s8	encountered
u8	scriptGroup
s8	hitboxIsActive
s16	npcID
s16	spawnPos[3]
Vec3s	unk_10
char	unk_16[2]
NpcSettings *	npcSettings
EvtScript *	initBytecode
EvtScript *	interactBytecode
EvtScript *	aiBytecode
EvtScript *	hitBytecode
EvtScript *	auxBytecode
EvtScript *	defeatBytecode
struct Evt *	initScript
struct Evt *	interactScript
struct Evt *	aiScript
struct Evt *	hitScript
struct Evt *	auxScript
struct Evt *	defeatScript
s32	initScriptID
s32	interactScriptID
s32	aiScriptID
s32	hitScriptID
s32	auxScriptID
s32	defeatScriptID
void *	unk_64
char	unk_68[4]
union Enemy.__unnamed54__	__unnamed__
u8	aiDetectFlags
char	unk_AD[3]
u32	aiFlags
s8	aiSuspendTime
s8	instigatorValue
char	unk_B6[2]
EvtScript *	unk_B8
struct Evt *	unk_BC
s32	unk_C0
s32	unk_C4
s32	unk_C8
s32 *	animList
EnemyTerritory *	territory
EnemyDrops *	drops
u32	tattleMsg
s32	unk_DC
s16	savedNpcYaw
char	unk_E2[6]

◆ Encounter

struct Encounter

Data Fields
s32	count
Enemy *	enemy[16]
s16	battle
s16	stage
s16	encounterID
char	unk_4C[2]

◆ FieldStatus

struct FieldStatus

Data Fields
s8	status
char	pad_01
s16	duration

◆ EncounterStatus

struct EncounterStatus

Data Fields
s32	flags
s8	firstStrikeType
s8	hitType
s8	hitTier
char	unk_07
s8	unk_08
s8	battleOutcome
s8	battleTriggerCooldown	set to 15 after victory, 45 after fleeing
b8	hasMerleeCoinBonus
u8	damageTaken
char	unk_0D
s16	coinsEarned
s8	instigatorValue
s8	forbidFleeing
s8	scriptedBattle	battle started by StartBattle but not by encounter
s8	dropWhackaBump
s32	songID
s32	unk_18
s8	numEncounters
s8	curAreaIndex
u8	curMapIndex
u8	curEntryIndex
s8	mapID
s8	resetMapEncounterFlags
char	unk_22[2]
s32 *	npcGroupList
Encounter *	encounterList[24]
Encounter *	curEncounter
Enemy *	curEnemy
s32	fadeOutAmount
s32	substateDelay
s32	fadeOutAccel
s32	battleStartCountdown
FieldStatus	dizzyAttack
FieldStatus	unusedAttack1
FieldStatus	unusedAttack2
FieldStatus	unusedAttack3
s32	defeatFlags[60][12]
s16	recentMaps[2]

◆ NpcData.animations

struct NpcData.animations

Data Fields
s32	idle
s32	walk
s32	run
s32	chase
s32	anim_4
s32	anim_5
s32	death
s32	hit
s32	anim_8
s32	anim_9
s32	anim_A
s32	anim_B
s32	anim_C
s32	anim_D
s32	anim_E
s32	anim_F

◆ Enemy.unnamed54

union Enemy.__unnamed54__

Data Fields
s32	varTable[16]
f32	varTableF[16]
void *	varTablePtr[16]

Macro Definition Documentation

◆ NPC_GROUP

#define NPC_GROUP ( args... ) VFUNC(NPC_GROUP, args)

Definition at line 13 of file npc.h.

◆ NPC_GROUP1

#define NPC_GROUP1 ( npcs ) { sizeof(npcs) / sizeof(NpcData), (NpcData*) &npcs, 0, 0 }

Definition at line 14 of file npc.h.

◆ NPC_GROUP2

#define NPC_GROUP2	(		npcs,
			battle ) { sizeof(npcs) / sizeof(NpcData), (NpcData*) &npcs, battle, 0 }

Definition at line 15 of file npc.h.

◆ NPC_GROUP3

#define NPC_GROUP3	(	npcs,
		battle,
		stage ) { sizeof(npcs) / sizeof(NpcData), (NpcData*) &npcs, battle, stage + 1 }

Definition at line 16 of file npc.h.

◆ NPC_GROUP_EXPLICIT_SIZE

#define NPC_GROUP_EXPLICIT_SIZE ( args... ) VFUNC(NPC_GROUP_EXPLICIT_SIZE, args)

Definition at line 18 of file npc.h.

◆ NPC_GROUP_EXPLICIT_SIZE3

#define NPC_GROUP_EXPLICIT_SIZE3	(	npcs,
		start,
		count ) { count, (NpcData*) &npcs[start], 0, 0 }

Definition at line 19 of file npc.h.

◆ NPC_GROUP_EXPLICIT_SIZE4

#define NPC_GROUP_EXPLICIT_SIZE4	(	npcs,
		start,
		count,
		battle ) { count, (NpcData*) &npcs[start], battle, 0 }

Definition at line 20 of file npc.h.

◆ NPC_GROUP_EXPLICIT_SIZE5

#define NPC_GROUP_EXPLICIT_SIZE5	(	npcs,
		start,
		count,
		battle,
		stage ) { count, (NpcData*) &npcs[start], battle, stage + 1 }

Definition at line 21 of file npc.h.

◆ NO_DROPS

#define NO_DROPS

Value:

    { \
    .dropFlags = NPC_DROP_FLAG_80, \
    .heartDrops  = { { F16(100), F16(0), 0, F16(0) } }, \
    .flowerDrops = { { F16(100), F16(0), 0, F16(0) } }, \
}

Definition at line 23 of file npc.h.

#define NO_DROPS { \
    .dropFlags = NPC_DROP_FLAG_80, \
    .heartDrops  = { { F16(100), F16(0), 0, F16(0) } }, \
    .flowerDrops = { { F16(100), F16(0), 0, F16(0) } }, \
}

◆ STANDARD_HEART_DROPS

#define STANDARD_HEART_DROPS ( attempts )

Value:

    { \
    { F16(20), F16(70), attempts, F16(50) }, \
    { F16(30), F16(60), attempts, F16(50) }, \
    { F16(50), F16(50), attempts, F16(40) }, \
    { F16(80),  F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(30) }, \
}

Definition at line 29 of file npc.h.

#define STANDARD_HEART_DROPS(attempts) { \
    { F16(20), F16(70), attempts, F16(50) }, \
    { F16(30), F16(60), attempts, F16(50) }, \
    { F16(50), F16(50), attempts, F16(40) }, \
    { F16(80),  F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(30) }, \
}

◆ GENEROUS_HEART_DROPS

#define GENEROUS_HEART_DROPS ( attempts )

Value:

    { \
    { F16(20), F16(80), attempts, F16(50) }, \
    { F16(30), F16(70), attempts, F16(50) }, \
    { F16(50), F16(60), attempts, F16(40) }, \
    { F16(80), F16(50), attempts, F16(40) }, \
    { F16(100), F16(40), attempts, F16(30) }, \
}

Definition at line 37 of file npc.h.

#define GENEROUS_HEART_DROPS(attempts) { \
    { F16(20), F16(80), attempts, F16(50) }, \
    { F16(30), F16(70), attempts, F16(50) }, \
    { F16(50), F16(60), attempts, F16(40) }, \
    { F16(80), F16(50), attempts, F16(40) }, \
    { F16(100), F16(40), attempts, F16(30) }, \
}

◆ GENEROUS_WHEN_LOW_HEART_DROPS

#define GENEROUS_WHEN_LOW_HEART_DROPS ( attempts )

Value:

    { \
    { F16(20), F16(80), attempts, F16(60) }, \
    { F16(30), F16(70), attempts, F16(50) }, \
    { F16(50), F16(60), attempts, F16(50) }, \
    { F16(80), F16(50), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(30) }, \
}

Definition at line 45 of file npc.h.

#define GENEROUS_WHEN_LOW_HEART_DROPS(attempts) { \
    { F16(20), F16(80), attempts, F16(60) }, \
    { F16(30), F16(70), attempts, F16(50) }, \
    { F16(50), F16(60), attempts, F16(50) }, \
    { F16(80), F16(50), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(30) }, \
}

◆ STANDARD_FLOWER_DROPS

#define STANDARD_FLOWER_DROPS ( attempts )

Value:

    { \
    { F16(20), F16(50), attempts, F16(40) }, \
    { F16(30), F16(40), attempts, F16(40) }, \
    { F16(50), F16(40), attempts, F16(40) }, \
    { F16(80), F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(40) }, \
}

Definition at line 53 of file npc.h.

#define STANDARD_FLOWER_DROPS(attempts) { \
    { F16(20), F16(50), attempts, F16(40) }, \
    { F16(30), F16(40), attempts, F16(40) }, \
    { F16(50), F16(40), attempts, F16(40) }, \
    { F16(80), F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(40) }, \
}

◆ GENEROUS_WHEN_LOW_FLOWER_DROPS

#define GENEROUS_WHEN_LOW_FLOWER_DROPS ( attempts )

Value:

    { \
    { F16(20), F16(70), attempts, F16(50) }, \
    { F16(30), F16(60), attempts, F16(50) }, \
    { F16(50), F16(50), attempts, F16(40) }, \
    { F16(80), F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(40) }, \
}

Definition at line 61 of file npc.h.

#define GENEROUS_WHEN_LOW_FLOWER_DROPS(attempts) { \
    { F16(20), F16(70), attempts, F16(50) }, \
    { F16(30), F16(60), attempts, F16(50) }, \
    { F16(50), F16(50), attempts, F16(40) }, \
    { F16(80), F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(40) }, \
}

◆ REDUCED_FLOWER_DROPS

#define REDUCED_FLOWER_DROPS ( attempts )

Value:

    { \
    { F16(20), F16(40), attempts, F16(40) }, \
    { F16(30), F16(40), attempts, F16(40) }, \
    { F16(50), F16(40), attempts, F16(40) }, \
    { F16(80), F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(40) }, \
}

Definition at line 69 of file npc.h.

#define REDUCED_FLOWER_DROPS(attempts) { \
    { F16(20), F16(40), attempts, F16(40) }, \
    { F16(30), F16(40), attempts, F16(40) }, \
    { F16(50), F16(40), attempts, F16(40) }, \
    { F16(80), F16(40), attempts, F16(40) }, \
    { F16(100), F16(30), attempts, F16(40) }, \
}

◆ OVERRIDE_MOVEMENT_SPEED

#define OVERRIDE_MOVEMENT_SPEED ( speed ) ((s32)(speed * 32767))

Definition at line 77 of file npc.h.

◆ NO_OVERRIDE_MOVEMENT_SPEED

#define NO_OVERRIDE_MOVEMENT_SPEED OVERRIDE_MOVEMENT_SPEED(-1.0f)

Definition at line 78 of file npc.h.

Typedef Documentation

◆ FireBarCallback

typedef void(* FireBarCallback) (struct FireBarData *, s32)

Definition at line 120 of file npc.h.

◆ NpcGroupList

typedef NpcGroup NpcGroupList[]

Definition at line 289 of file npc.h.

◆ AIStateHandler

typedef void AIStateHandler(Evt *script, MobileAISettings *settings, EnemyDetectVolume *territory)

Definition at line 292 of file npc.h.

Enumeration Type Documentation

◆ TerritoryShape

enum TerritoryShape

Enumerator
SHAPE_CYLINDER
SHAPE_RECT

Definition at line 197 of file npc.h.

197{ SHAPE_CYLINDER, SHAPE_RECT };

SHAPE_CYLINDER

@ SHAPE_CYLINDER

Definition npc.h:197

SHAPE_RECT

@ SHAPE_RECT

Definition npc.h:197

Function Documentation

◆ basic_ai_check_player_dist()

b32 basic_ai_check_player_dist	(	EnemyDetectVolume *	arg0,
		Enemy *	arg1,
		f32	arg2,
		f32	arg3,
		s8	arg4 )

Definition at line 429 of file 23680.c.

                                                                                                                         {
    Npc* npc = get_npc_unsafe(enemy->npcID);
    PlayerStatus* playerStatus = &gPlayerStatus;
    PartnerStatus* partnerStatus;
    f32 x, y, z;
    f32 dist;
    s32 skipCheckForPlayer;
 
    if (enemy->aiFlags & AI_FLAG_CANT_DETECT_PLAYER) {
        return false;
    }
 
    partnerStatus = &gPartnerStatus;
    if (partnerStatus->actingPartner == PARTNER_BOW && partnerStatus->partnerActionState
            && !(territory->detectFlags & AI_TERRITORY_IGNORE_HIDING)) {
        return false;
    }
 
    if (partnerStatus->actingPartner == PARTNER_SUSHIE && partnerStatus->partnerActionState
            && !(territory->detectFlags & AI_TERRITORY_IGNORE_HIDING)) {
        return false;
    }
 
    if (territory->skipPlayerDetectChance < 0) {
        return false;
    }
 
    if (territory->halfHeight <= fabsf(npc->pos.y - playerStatus->pos.y)
            && !(territory->detectFlags & AI_TERRITORY_IGNORE_ELEVATION)) {
        return false;
    }
 
    if (territory->sizeX | territory->sizeZ && is_point_outside_territory(territory->shape,
            territory->pointX, territory->pointZ,
            playerStatus->pos.x, playerStatus->pos.z,
            territory->sizeX, territory->sizeZ)) {
        return false;
    }
 
    if ((playerStatus->actionState == ACTION_STATE_USE_SPINNING_FLOWER)) {
        return false;
    }
 
    // check for unbroken line of sight
    if (enemy->aiDetectFlags & AI_DETECT_SIGHT) {
        x = npc->pos.x;
        y = npc->pos.y + npc->collisionHeight * 0.5;
        z = npc->pos.z;
        dist = dist2D(npc->pos.x, npc->pos.z, playerStatus->pos.x, playerStatus->pos.z);
        if (npc_test_move_simple_with_slipping(COLLIDER_FLAG_IGNORE_PLAYER | COLLISION_IGNORE_ENTITIES,
                &x, &y, &z,
                dist, atan2(npc->pos.x, npc->pos.z, playerStatus->pos.x, playerStatus->pos.z),
                0.1f, 0.1f)) {
            return false;
        }
    }
 
    if (territory->skipPlayerDetectChance == 0) {
        skipCheckForPlayer = 0;
    } else {
        skipCheckForPlayer = rand_int(territory->skipPlayerDetectChance + 1);
    }
 
    if (skipCheckForPlayer == 0) {
        if (enemy->aiDetectFlags & AI_DETECT_SENSITIVE_MOTION) {
            if (playerStatus->actionState == ACTION_STATE_WALK) {
                radius *= 1.15;
            } else if (playerStatus->actionState == ACTION_STATE_RUN) {
                radius *= 1.3;
            }
        }
        x = npc->pos.x;
        z = npc->pos.z;
        if (useWorldYaw & 0xFF) {
            add_vec2D_polar(&x, &z, fwdPosOffset, npc->yaw);
        } else {
            add_vec2D_polar(&x, &z, fwdPosOffset, 270.0f - npc->renderYaw);
        }
        if (dist2D(x, z, playerStatus->pos.x, playerStatus->pos.z) <= radius) {
            return true;
        }
    }
 
    return false;
}

Referenced by AvoidPlayerAI_Chase(), AvoidPlayerAI_ChaseInit(), basic_ai_chase(), basic_ai_loiter(), basic_ai_wander(), CleftAI_FindPlayer(), CleftAI_Hiding(), CleftAI_ReturnHome(), ClubbaNappingAI_Loiter(), ClubbaNappingAI_ReturnHome(), ClubbaNappingAI_Sleep(), FlyingAI_Loiter(), FlyingAI_Wander(), FlyingNoAttackAI_13(), GuardAI_Chase(), GuardAI_Idle(), GuardAI_ReturnHome(), HoppingAI_Chase(), HoppingAI_Hop(), HoppingAI_Loiter(), LakituAI_Loiter(), LakituAI_Wander(), MagikoopaAI_CanShootSpell(), PatrolAI_Chase(), PatrolAI_Loiter(), PatrolAI_Move(), PiranhaPlantAI_01(), PiranhaPlantAI_LosePlayer(), SentinelAI_Chase(), SentinelAI_Descend(), SentinelAI_ReturnHome(), and UnkNpcAIFunc48().

◆ STUB_npc_callback()

void STUB_npc_callback ( Npc * npc )

The default Npc::onUpdate and Npc::onRender callback.

Definition at line 48 of file npc.c.

48 {

49}

Referenced by create_npc_impl().

◆ mtx_ident_mirror_y()

void mtx_ident_mirror_y ( Matrix4f mtx )

Definition at line 51 of file npc.c.

                                      {
    guMtxIdentF(mtx);
    mtx[0][0] = 1.0f;
    mtx[1][1] = -1.0f;
    mtx[2][2] = 1.0f;
    mtx[3][3] = 1.0f;
}

Referenced by appendGfx_npc().

◆ clear_npcs()

void clear_npcs ( void )

Definition at line 59 of file npc.c.

                      {
    s32 i;
 
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentNpcListPtr = &gWorldNpcList;
    } else {
        gCurrentNpcListPtr = &gBattleNpcList;
    }
 
    for (i = 0; i < MAX_NPCS; i++) {
        (*gCurrentNpcListPtr)[i] = nullptr;
    }
 
    gNpcCount = 0;
    gNpcPlayerCollisionsEnabled = true;
}

Referenced by load_demo_battle(), load_engine_data(), load_map_by_IDs(), state_init_logos(), state_init_title_screen(), state_step_battle(), state_step_demo(), state_step_intro(), state_step_pause(), state_step_startup(), and state_step_title_screen().

◆ init_npc_list()

void init_npc_list ( void )

Points the current NPC list to the world or battle lists depending on game state.

Definition at line 76 of file npc.c.

                         {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gCurrentNpcListPtr = &gWorldNpcList;
    } else {
        gCurrentNpcListPtr = &gBattleNpcList;
    }
 
    gNpcCount = 0;
    gNpcPlayerCollisionsEnabled = true;
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ create_npc_impl()

s32 create_npc_impl	(	NpcBlueprint *	blueprint,
		AnimID *	animList,
		s32	skipLoadingAnims )

Definition at line 87 of file npc.c.

                                                                               {
    Npc* npc;
    s32 i;
    s32 j;
 
    for (i = 0; i < MAX_NPCS; i++) {
        if ((*gCurrentNpcListPtr)[i] == nullptr) {
            break;
        }
    }
    ASSERT(i < MAX_NPCS);
 
    (*gCurrentNpcListPtr)[i] = npc = heap_malloc(sizeof(*npc));
    gNpcCount++;
    ASSERT(npc != nullptr);
 
    npc->flags = blueprint->flags | (NPC_FLAG_TOUCHES_GROUND | NPC_FLAG_DIRTY_SHADOW | NPC_FLAG_HAS_SHADOW | NPC_FLAG_ENABLED);
    if (isPeachNpc) {
        npc->flags |= NPC_FLAG_NO_ANIMS_LOADED;
    }
 
    npc->collisionDiameter = 32;
    npc->collisionHeight = 64;
    npc->renderMode = 13;
    npc->blur.any = nullptr;
    npc->yaw = 0.0f;
    npc->jumpVel = 0.0f;
    npc->pos.x = 0.0f;
    npc->pos.y = 0.0f;
    npc->pos.z = 0.0f;
    npc->colliderPos.x = 0.0f;
    npc->colliderPos.y = 0.0f;
    npc->colliderPos.z = 0.0f;
    npc->rotPivotOffsetY = 0.0f;
    npc->rot.x = 0.0f;
    npc->rot.y = 0.0f;
    npc->rot.z = 0.0f;
    npc->homePos.x = 0.0f;
    npc->homePos.y = 0.0f;
    npc->homePos.z = 0.0f;
    npc->unk_96 = 0; // TODO: fix
    npc->verticalRenderOffset = 0;
    npc->alpha = 255;
    npc->hideAlpha = 255;
    npc->jumpScale = 1.0f;
    npc->moveSpeed = 4.0f;
    npc->scale.x = 1.0f;
    npc->scale.y = 1.0f;
    npc->scale.z = 1.0f;
    npc->curAnim = blueprint->initialAnim;
    npc->animationSpeed = 1.0f;
    npc->renderYaw = 0.0f;
    npc->imgfxType = IMGFX_CLEAR;
    npc->imgfxFlags = 0;
    npc->collisionChannel = COLLIDER_FLAG_IGNORE_NPC;
    npc->isFacingAway = false;
    npc->yawCamOffset = 0;
    npc->turnAroundYawAdjustment = 0;
    npc->curFloor = NO_COLLIDER;
    npc->curWall = NO_COLLIDER;
    npc->palSwapType = NPC_PAL_ADJUST_NONE;
    npc->palSwapPrevType = NPC_PAL_ADJUST_NONE;
    npc->screenSpaceOffset2D[0] = 0.0f;
    npc->screenSpaceOffset2D[1] = 0.0f;
    npc->verticalStretch = 1.0f;
 
    for (j = 0; j < ARRAY_COUNT(npc->decorations); j++) {
        npc->decorations[j] = 0;
        npc->decorationType[j] = 0;
    }
 
    npc->onUpdate = blueprint->onUpdate;
    if (npc->onUpdate == nullptr) {
        npc->onUpdate = &STUB_npc_callback;
    }
 
    npc->onRender = blueprint->onRender;
    if (npc->onRender == nullptr) {
        npc->onRender = &STUB_npc_callback;
    }
    if (!isPeachNpc) {
        npc->extraAnimList = animList;
        if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
            if (!(npc->flags & NPC_FLAG_PARTNER)) {
                npc->spriteInstanceID = spr_load_npc_sprite(npc->curAnim, animList);
            } else {
                npc->spriteInstanceID = spr_load_npc_sprite(npc->curAnim | SPRITE_ID_TAIL_ALLOCATE, animList);
            }
        } else {
            npc->flags |= NPC_FLAG_INVISIBLE;
        }
    }
 
    npc->shadowIndex = create_shadow_type(SHADOW_VARYING_CIRCLE, npc->pos.x, npc->pos.y, npc->pos.z);
    npc->shadowScale = 1.0f;
 
    if (gGameStatusPtr->context != CONTEXT_WORLD) {
        i |= BATTLE_NPC_ID_BIT;
    }
    return i;
}

Referenced by create_basic_npc(), create_peach_npc(), and create_standard_npc().

◆ create_basic_npc()

s32 create_basic_npc ( NpcBlueprint * blueprint )

Definition at line 189 of file npc.c.

                                              {
    return create_npc_impl(blueprint, nullptr, false);
}

Referenced by create_partner_npc().

◆ create_standard_npc()

s32 create_standard_npc	(	NpcBlueprint *	blueprint,
		AnimID *	animList )

Definition at line 193 of file npc.c.

                                                                   {
    return create_npc_impl(blueprint, animList, false);
}

Referenced by create_encounters(), and peach_make_disguise_npc().

◆ create_peach_npc()

s32 create_peach_npc ( NpcBlueprint * blueprint )

Definition at line 197 of file npc.c.

                                              {
    return create_npc_impl(blueprint, nullptr, true);
}

Referenced by create_encounters().

◆ free_npc_by_index()

void free_npc_by_index ( s32 listIndex )

Definition at line 201 of file npc.c.

                                      {
    Npc* npc;
    s32 i;
 
    listIndex &= ~BATTLE_NPC_ID_BIT;
 
    npc = (*gCurrentNpcListPtr)[listIndex];
    if (npc != nullptr) {
        if (npc->flags) {
            if (npc->blur.any != nullptr) {
                heap_free(npc->blur.any);
                npc->blur.any = nullptr;
            }
 
            if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                ASSERT((npc->flags & NPC_FLAG_HAS_NO_SPRITE) || !spr_free_sprite(npc->spriteInstanceID));
            }
 
            delete_shadow(npc->shadowIndex);
 
            for (i = 0; i < MAX_NPC_DECORATIONS; i++) {
                npc_remove_decoration(npc, i);
            }
 
            if (npc->flags & NPC_FLAG_MOTION_BLUR) {
                disable_npc_blur(npc);
            }
 
            heap_free((*gCurrentNpcListPtr)[listIndex]);
            (*gCurrentNpcListPtr)[listIndex] = nullptr;
            gNpcCount--;
        }
    }
}

Referenced by action_update_parasol(), partner_free_npc(), and peach_force_disguise_action().

◆ free_npc()

void free_npc ( Npc * npc )

Definition at line 236 of file npc.c.

                        {
    s32 i;
 
    if (npc->blur.any != nullptr) {
        heap_free(npc->blur.any);
        npc->blur.any = nullptr;
    }
 
    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
        ASSERT((npc->flags & NPC_FLAG_HAS_NO_SPRITE) || !spr_free_sprite(npc->spriteInstanceID));
    }
 
    delete_shadow(npc->shadowIndex);
 
    for (i = 0; i < MAX_NPC_DECORATIONS; i++) {
        npc_remove_decoration(npc, i);
    }
 
    if (npc->flags & NPC_FLAG_MOTION_BLUR) {
        disable_npc_blur(npc);
    }
 
    heap_free(npc);
 
    for (i = 0; i < MAX_NPCS; i++) {
        if ((*gCurrentNpcListPtr)[i] == npc) {
            break;
        }
    }
 
    (*gCurrentNpcListPtr)[i] = nullptr;
    gNpcCount--;
}

Referenced by kill_enemy().

◆ get_npc_by_index()

Npc * get_npc_by_index ( s32 listIndex )

Definition at line 270 of file npc.c.

                                     {
    return (*gCurrentNpcListPtr)[listIndex & ~BATTLE_NPC_ID_BIT];
}

Referenced by action_update_parasol(), create_encounters(), create_partner_npc(), entity_HiddenPanel_flip_over(), entity_HiddenPanel_idle(), npc_do_other_npc_collision(), peach_make_disguise_npc(), peach_set_disguise_anim(), and peach_sync_disguise_npc().

◆ npc_do_world_collision()

void npc_do_world_collision ( Npc * npc )

Definition at line 277 of file npc.c.

                                      {
    f32 testAngle;
    s32 hit;
    f32 testX;
    f32 testY;
    f32 testZ;
 
    if (npc->flags & NPC_FLAG_IGNORE_WORLD_COLLISION) {
        npc->flags |= NPC_FLAG_WORLD_COLLISION_DIRTY;
    } else if (
           (npc->pos.x != npc->colliderPos.x)
        || (npc->pos.y != npc->colliderPos.y)
        || (npc->pos.z != npc->colliderPos.z)
        || npc->flags & NPC_FLAG_WORLD_COLLISION_DIRTY
    ) {
        npc->flags &= ~NPC_FLAG_WORLD_COLLISION_DIRTY;
        testAngle = clamp_angle(npc->yaw);
        testX = npc->pos.x;
        testY = npc->pos.y;
        testZ = npc->pos.z;
 
        if (!(npc->flags & NPC_FLAG_PARTNER)) {
            hit = npc_test_move_simple_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight, npc->collisionDiameter);
        } else {
            hit = npc_test_move_complex_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight, npc->collisionDiameter);
        }
 
        if (hit) {
            npc->flags |= (NPC_FLAG_COLLDING_WITH_WORLD | NPC_FLAG_COLLDING_FORWARD_WITH_WORLD);
            npc->curWall = NpcHitQueryColliderID;
            npc->pos.x = testX;
            npc->pos.z = testZ;
        } else {
            npc->flags &= ~(NPC_FLAG_COLLDING_WITH_WORLD | NPC_FLAG_COLLDING_FORWARD_WITH_WORLD);
        }
 
        testAngle = clamp_angle(npc->yaw + 45.0f);
        testX = npc->pos.x;
        testY = npc->pos.y;
        testZ = npc->pos.z;
 
        if (!(npc->flags & NPC_FLAG_PARTNER)) {
            hit = npc_test_move_simple_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight, npc->collisionDiameter);
        } else {
            hit = npc_test_move_taller_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight, npc->collisionDiameter);
        }
 
        if (hit) {
            npc->flags |= NPC_FLAG_COLLDING_WITH_WORLD;
            npc->pos.x = testX;
            npc->pos.z = testZ;
        } else {
            npc->flags &= ~NPC_FLAG_COLLDING_WITH_WORLD;
        }
 
        testAngle = clamp_angle(npc->yaw - 45.0f);
        testX = npc->pos.x;
        testY = npc->pos.y;
        testZ = npc->pos.z;
        if (!(npc->flags & NPC_FLAG_PARTNER)) {
            hit = npc_test_move_simple_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight, npc->collisionDiameter);
        } else {
            hit = npc_test_move_taller_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight, npc->collisionDiameter);
        }
 
        if (hit != 0) {
            npc->flags |= NPC_FLAG_COLLDING_WITH_WORLD;
            npc->pos.x = testX;
            npc->pos.z = testZ;
        } else {
            npc->flags &= ~NPC_FLAG_COLLDING_WITH_WORLD;
        }
 
        if (npc->flags & NPC_FLAG_PARTNER) {
            testAngle = clamp_angle(npc->yaw + 45.0f + 180.0f);
            testX = npc->pos.x;
            testY = npc->pos.y;
            testZ = npc->pos.z;
            if (npc_test_move_simple_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight,
                              npc->collisionDiameter) != 0) {
                npc->flags |= NPC_FLAG_COLLDING_WITH_WORLD;
                npc->pos.x = testX;
                npc->pos.z = testZ;
            } else {
                npc->flags &= ~NPC_FLAG_COLLDING_WITH_WORLD;
            }
 
            testAngle = clamp_angle((npc->yaw - 45.0f) + 180.0f);
            testX = npc->pos.x;
            testY = npc->pos.y;
            testZ = npc->pos.z;
            if (npc_test_move_simple_with_slipping(npc->collisionChannel, &testX, &testY, &testZ, 0, testAngle, npc->collisionHeight,
                              npc->collisionDiameter) != 0) {
                npc->flags |= NPC_FLAG_COLLDING_WITH_WORLD;
                npc->pos.x = testX;
                npc->pos.z = testZ;
                return;
            }
            npc->flags &= ~NPC_FLAG_COLLDING_WITH_WORLD;
        }
    }
}

Referenced by partner_get_out(), partner_move_to_goal(), and update_npcs().

◆ npc_do_other_npc_collision()

void npc_do_other_npc_collision ( Npc * npc )

Definition at line 380 of file npc.c.

                                          {
    Npc* otherNpc;
    f32 angle;
    f32 thisX, thisY, thisZ;
    f32 thisBuf;
    f32 otherX, otherZ;
    f32 otherBuf;
    f32 xDiff, zDiff;
    f32 dist;
    s32 collision;
    s32 i;
 
    if (!(npc->flags & NPC_FLAG_IGNORE_PLAYER_COLLISION)) {
        npc->flags &= ~NPC_FLAG_COLLIDING_WITH_NPC;
        thisBuf = npc->collisionDiameter * 0.5f;
        thisX = npc->pos.x;
        thisY = npc->pos.y;
        thisZ = npc->pos.z;
 
        for (i = 0; i < MAX_NPCS; i++) {
            otherNpc = get_npc_by_index(i);
            if (otherNpc != nullptr && npc != otherNpc) {
                if (otherNpc->flags != 0 && !(otherNpc->flags & (NPC_FLAG_SUSPENDED | NPC_FLAG_IGNORE_PLAYER_COLLISION))) {
                    if (!(otherNpc->pos.y + otherNpc->collisionHeight < thisY) &&
                        !(thisY + npc->collisionHeight < otherNpc->pos.y))
                    {
                        otherX = otherNpc->pos.x;
                        xDiff = otherX - thisX;
                        otherZ = otherNpc->pos.z;
                        zDiff = otherZ - thisZ;
                        otherBuf = otherNpc->collisionDiameter * 0.5f;
                        dist = sqrtf(SQ(xDiff) + SQ(zDiff));
 
                        if (!(thisBuf + otherBuf <= dist)) {
                            collision = false;
                            if (npc->flags & NPC_FLAG_PARTNER) {
                                collision = gPartnerStatus.partnerActionState == PARTNER_ACTION_NONE;
                            } else if (!(otherNpc->flags & NPC_FLAG_PARTNER) ||
                                        gPartnerStatus.partnerActionState == PARTNER_ACTION_NONE)
                            {
                                collision = true;
                            }
 
                            if (collision) {
                                angle = DEG_TO_RAD(atan2(otherX, otherZ, thisX, thisZ));
                                dist = (thisBuf + otherBuf) - dist;
                                xDiff = dist * sin_rad(angle);
                                zDiff = -dist * cos_rad(angle);
                                thisX += xDiff * 0.1f;
                                thisZ += zDiff * 0.1f;
                            }
                            npc->flags |= NPC_FLAG_COLLIDING_WITH_NPC;
                        }
                    }
                }
            }
        }
        npc->pos.x = thisX;
        npc->pos.z = thisZ;
    }
}

Referenced by update_npcs().

◆ npc_do_player_collision()

s32 npc_do_player_collision ( Npc * npc )

Returns: true if a collision occurred

Definition at line 442 of file npc.c.

                                      {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 playerX, playerZ;
    f32 playerYaw, yaw;
    f32 npcX, npcZ;
    f32 dist, colDist, distToNpc;
    f32 npcColRadius, playerColRadius;
    f32 deltaX, deltaZ;
 
    if (npc->flags & NPC_FLAG_IGNORE_PLAYER_COLLISION) {
        return false;
    }
 
    if (npc->flags & NPC_FLAG_PARTNER) {
        return false;
    }
 
    if (!gNpcPlayerCollisionsEnabled) {
        return false;
    }
 
    if (playerStatus->pos.y + playerStatus->colliderHeight < npc->pos.y) {
        return false;
    }
 
    if (npc->pos.y + npc->collisionHeight < playerStatus->pos.y) {
        return false;
    }
 
    playerX = playerStatus->pos.x;
    playerZ = playerStatus->pos.z;
 
    npcColRadius = npc->collisionDiameter / 2;
    playerColRadius = playerStatus->colliderDiameter / 2;
 
    npcX = npc->pos.x;
    npcZ = npc->pos.z;
 
    deltaX = playerX - npcX;
    deltaZ = playerZ - npcZ;
 
    distToNpc = sqrtf(SQ(deltaX) + SQ(deltaZ));
    colDist = npcColRadius + playerColRadius;
    if (colDist < distToNpc) {
        return false;
    }
 
    playerStatus->animFlags |= PA_FLAG_NPC_COLLIDED;
 
    npcX = npc->colliderPos.x;
    npcZ = npc->colliderPos.z;
 
    deltaX = playerX - npcX;
    deltaZ = playerZ - npcZ;
 
    dist = sqrtf(SQ(deltaX) + SQ(deltaZ));
    yaw = atan2(playerX, playerZ, npcX, npcZ);
 
    playerYaw = playerStatus->targetYaw;
    dist = colDist - dist;
    deltaX = dist * sin_rad(DEG_TO_RAD(yaw));
    deltaZ = -dist * cos_rad(DEG_TO_RAD(yaw));
 
    if (playerStatus->animFlags & PA_FLAG_RIDING_PARTNER) {
        if (fabsf(get_clamped_angle_diff(yaw, playerYaw)) < 45.0f) {
            playerStatus->pos.x -= deltaX;
            playerStatus->pos.z -= deltaZ;
            wPartnerNpc->pos.x -= deltaX;
            wPartnerNpc->pos.z -= deltaZ;
        } else {
            playerStatus->pos.x -= deltaX * 0.5f;
            playerStatus->pos.z -= deltaZ * 0.5f;
            wPartnerNpc->pos.x -= deltaX * 0.5f;
            wPartnerNpc->pos.z -= deltaZ * 0.5f;
        }
    } else {
        if (playerStatus->flags & (PS_FLAG_JUMPING | PS_FLAG_FALLING)) {
            playerStatus->pos.x -= deltaX * 0.4f;
            playerStatus->pos.z -= deltaZ * 0.4f;
        } else {
            dist = get_clamped_angle_diff(yaw, playerYaw); // required to match
            if (fabsf(dist) < 45.0f) {
                playerStatus->pos.x -= deltaX;
                playerStatus->pos.z -= deltaZ;
            } else {
                playerStatus->pos.x -= deltaX * 0.5f;
                playerStatus->pos.z -= deltaZ * 0.5f;
            }
        }
    }
    npc->pos.x = npc->colliderPos.x;
    npc->pos.y = npc->colliderPos.y;
    npc->pos.z = npc->colliderPos.z;
    return true;
}

Referenced by update_npcs().

◆ npc_try_apply_gravity()

void npc_try_apply_gravity ( Npc * npc )

Definition at line 540 of file npc.c.

                                     {
    f32 x, y, z, testLength;
    f32 length;
    s32 hitID;
 
    if (!(npc->flags & NPC_FLAG_GRAVITY)) {
        return;
    }
 
    if (npc->flags & NPC_FLAG_JUMPING) {
        npc->flags &= ~NPC_FLAG_GROUNDED;
        return;
    }
 
    npc->jumpScale = 1.0f;
    npc->jumpVel -= npc->jumpScale;
    npc->pos.y += npc->jumpVel;
 
    x = npc->pos.x;
    y = npc->pos.y + 13;
    z = npc->pos.z;
    testLength = length = fabsf(npc->jumpVel) + 16;
 
    if (!(npc->flags & NPC_FLAG_PARTNER)) {
        hitID = npc_raycast_down_sides(npc->collisionChannel, &x, &y, &z, &length);
    } else {
        hitID = npc_raycast_down_around(npc->collisionChannel, &x, &y, &z, &length, npc->yaw, npc->collisionDiameter);
    }
 
    if (hitID && length <= testLength) {
        npc->jumpVel = 0.0f;
        npc->flags |= NPC_FLAG_GROUNDED;
        npc->pos.y = y;
        npc->curFloor = NpcHitQueryColliderID;
    } else {
        npc->flags &= ~NPC_FLAG_GROUNDED;
    }
}

Referenced by update_npcs().

◆ npc_try_snap_to_ground()

s32 npc_try_snap_to_ground	(	Npc *	npc,
		f32	velocity )

Definition at line 580 of file npc.c.

                                                   {
    f32 x, y, z, testLength;
    f32 length;
    s32 hitID;
 
    if (npc->flags & (NPC_FLAG_GRAVITY | NPC_FLAG_FLYING)) {
        return false;
    }
 
    if (npc->flags & NPC_FLAG_JUMPING) {
        npc->flags &= ~NPC_FLAG_GROUNDED;
        return false;
    }
 
    length = testLength = fabsf(velocity) + 16;
    x = npc->pos.x;
    y = npc->pos.y + 13;
    z = npc->pos.z;
 
    if (!(npc->flags & NPC_FLAG_PARTNER)) {
        hitID = npc_raycast_down_sides(npc->collisionChannel, &x, &y, &z, &length);
    } else {
        hitID = npc_raycast_down_around(npc->collisionChannel, &x, &y, &z, &length, npc->yaw, npc->collisionDiameter);
    }
 
    if (hitID != 0 && length <= testLength) {
        npc->pos.y = y;
        npc->curFloor = NpcHitQueryColliderID;
        npc->flags |= NPC_FLAG_GROUNDED;
        return true;
    }
 
    npc->flags &= ~NPC_FLAG_GROUNDED;
    return false;
}

Referenced by partner_get_out(), and update_npcs().

◆ update_npcs()

void update_npcs ( void )

Updates all NPCs.

Definition at line 616 of file npc.c.

                       {
    PlayerStatus* playerStatus = &gPlayerStatus;
    f32 x, y, z;
    f32 hitYaw, hitPitch, hitLength;
 
    playerStatus->animFlags &= ~PA_FLAG_NPC_COLLIDED;
    if (!(gOverrideFlags & (GLOBAL_OVERRIDES_800 | GLOBAL_OVERRIDES_400))) {
        s32 i;
 
        for (i = 0; i < MAX_NPCS; i++) {
            Npc* npc = (*gCurrentNpcListPtr)[i];
 
            if (npc != nullptr) {
                if (npc->flags != 0) {
                    if (npc->flags & (NPC_FLAG_SUSPENDED | NPC_FLAG_INACTIVE)) {
                        npc_do_world_collision(npc);
                        continue;
                    }
 
                    npc->onUpdate(npc);
                    if (npc->flags & NPC_FLAG_IGNORE_ENTITY_COLLISION) {
                        npc->collisionChannel |= COLLISION_IGNORE_ENTITIES;
                    } else {
                        npc->collisionChannel &= ~COLLISION_IGNORE_ENTITIES;
                    }
 
                    npc->curFloor = NO_COLLIDER;
                    npc->curWall = NO_COLLIDER;
                    npc->flags &= ~(NPC_FLAG_COLLDING_FORWARD_WITH_WORLD | NPC_FLAG_COLLDING_WITH_WORLD);
 
                    npc_do_world_collision(npc);
                    npc_try_apply_gravity(npc);
                    npc_try_snap_to_ground(npc, 0.0f);
                    npc_do_player_collision(npc);
                    npc_do_other_npc_collision(npc);
 
                    if (npc->flags & NPC_FLAG_MOTION_BLUR) {
                        update_npc_blur(npc);
                    }
 
                    if ((npc->pos.y < -2000.0f) && !(npc->flags & NPC_FLAG_PARTNER)) {
                        npc->pos.y = playerStatus->pos.y;
                        npc->jumpVel = 0.0f;
                        npc->moveSpeed = 0.0f;
                        npc->jumpScale = 0.0f;
                        npc->flags &= ~NPC_FLAG_JUMPING;
                    }
 
                    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                        if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
                            if (npc->curAnim != 0) {
                                if (npc->spriteInstanceID >= 0) {
                                    spr_update_sprite(npc->spriteInstanceID, npc->curAnim, npc->animationSpeed);
                                }
                            }
                        }
                    } else {
                        spr_update_player_sprite(PLAYER_SPRITE_AUX1, npc->curAnim, npc->animationSpeed);
                    }
 
                    if (npc->flags & NPC_FLAG_HAS_SHADOW) {
                        Shadow* shadow = get_shadow_by_index(npc->shadowIndex);
                        EntityModel* entityModel = get_entity_model(shadow->entityModelID);
 
                        entityModel->flags &= ~ENTITY_MODEL_FLAG_REFLECT;
                        if (npc->flags & NPC_FLAG_REFLECT_WALL) {
                            entityModel->flags |= ENTITY_MODEL_FLAG_REFLECT;
                        }
 
                        x = npc->pos.x;
                        y = npc->pos.y;
                        z = npc->pos.z;
                        if (!(npc->flags & NPC_FLAG_NO_SHADOW_RAYCAST)) {
                            if (   x != npc->colliderPos.x
                                || y != npc->colliderPos.y
                                || z != npc->colliderPos.z
                                || (npc->flags & NPC_FLAG_DIRTY_SHADOW)
                            ) {
                                x = npc->pos.x;
                                y = npc->pos.y + (npc->collisionHeight / 2);
                                z = npc->pos.z;
                                hitLength = 1000.0f;
                                entity_raycast_down(&x, &y, &z, &hitYaw, &hitPitch, &hitLength);
                                set_npc_shadow_scale(shadow, hitLength, npc->collisionDiameter);
                                shadow->pos.x = x;
                                shadow->pos.y = y;
                                shadow->pos.z = z;
                                shadow->rot.x = hitYaw;
                                shadow->rot.y = npc->renderYaw;
                                shadow->rot.z = hitPitch;
                                shadow->scale.x *= npc->shadowScale;
                                npc->flags &= ~NPC_FLAG_DIRTY_SHADOW;
                            }
                        } else {
                            if (npc->flags & NPC_FLAG_DONT_UPDATE_SHADOW_Y) {
                                shadow->pos.x = npc->pos.x;
                                shadow->pos.z = npc->pos.z;
                            } else {
                                shadow->pos.x = npc->pos.x;
                                shadow->pos.y = npc->pos.y;
                                shadow->pos.z = npc->pos.z;
                            }
                        }
                    }
 
                    npc->colliderPos.x = npc->pos.x;
                    npc->colliderPos.y = npc->pos.y;
                    npc->colliderPos.z = npc->pos.z;
                    npc_update_decorations(npc);
 
                    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                        if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
                            if (npc->spriteInstanceID < 0) {
                                npc->spriteInstanceID++;
                                if (npc->spriteInstanceID == -1) {
                                    npc->spriteInstanceID = spr_load_npc_sprite(npc->curAnim, npc->extraAnimList);
                                    ASSERT(npc->spriteInstanceID >= 0);
                                    spr_update_sprite(npc->spriteInstanceID, npc->curAnim, npc->animationSpeed);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Referenced by state_step_battle(), state_step_change_map(), state_step_enter_world(), state_step_game_over(), state_step_intro(), state_step_logos(), state_step_pause(), state_step_title_screen(), state_step_unpause(), and state_step_world().

◆ npc_get_render_yaw()

f32 npc_get_render_yaw ( Npc * npc )

Definition at line 744 of file npc.c.

                                 {
    Camera* camera = &gCameras[gCurrentCamID];
    f32 cameraYaw;
    f32 camRelativeYaw;
    f32 yaw;
    s32 direction;
 
    if (!(gOverrideFlags & (GLOBAL_OVERRIDES_PREV_800 | GLOBAL_OVERRIDES_PREV_400))) {
        cameraYaw = camera->curYaw;
        camRelativeYaw = get_clamped_angle_diff(cameraYaw, npc->yaw);
 
        if (camRelativeYaw < -5.0f && camRelativeYaw > -175.0f) {
            direction = 0;
            camRelativeYaw = 0.0f;
        } else if (camRelativeYaw > 5.0f && camRelativeYaw < 175.0f) {
            direction = 1;
            camRelativeYaw = 180.0f;
        } else {
            // direction is close to flipping, use saved value
            direction = 2;
            camRelativeYaw = npc->yawCamOffset;
        }
 
        npc->yawCamOffset = yaw = clamp_angle(camRelativeYaw);
 
        if (!(npc->flags & NPC_FLAG_IGNORE_CAMERA_FOR_YAW)) {
            if (npc->isFacingAway != direction && direction != 2) {
                npc->isFacingAway = direction;
 
                if (npc->isFacingAway) {
                    npc->turnAroundYawAdjustment = 180;
                } else {
                    npc->turnAroundYawAdjustment = -180;
                }
 
                if (fabsf(get_clamped_angle_diff(cameraYaw, npc->yaw)) >= 90.0f) {
                    npc->turnAroundYawAdjustment = -npc->turnAroundYawAdjustment;
                }
            }
 
            if (npc->turnAroundYawAdjustment != 0) {
                if (npc->turnAroundYawAdjustment < 0) {
                    npc->turnAroundYawAdjustment += 20;
                }
                if (npc->turnAroundYawAdjustment > 0) {
                    npc->turnAroundYawAdjustment -= 20;
                }
            }
 
            if (npc->flags & NPC_FLAG_FLIP_INSTANTLY) {
                npc->turnAroundYawAdjustment = 0;
            }
 
            npc->renderYaw = clamp_angle(clamp_angle(npc->turnAroundYawAdjustment + yaw) - cameraYaw);
            yaw = npc->renderYaw;
        } else {
            yaw = npc->renderYaw;
        }
    } else {
        yaw = npc->renderYaw;
    }
    return yaw;
}

Referenced by appendGfx_npc().

◆ appendGfx_npc()

void appendGfx_npc ( void * data )

Definition at line 808 of file npc.c.

                               {
    Npc* npc = data;
    Matrix4f mtx1, mtx2;
    f32 renderYaw = npc_get_render_yaw(npc);
 
    guTranslateF(mtx1, npc->pos.x, npc->pos.y + npc->verticalRenderOffset, npc->pos.z);
    if (npc->flags & NPC_FLAG_UPSIDE_DOWN) {
        mtx_ident_mirror_y(mtx2);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if (npc->rotPivotOffsetY != 0.0f) {
        guTranslateF(mtx2, 0.0f, npc->rotPivotOffsetY, 0.0f);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if (npc->rot.y != 0.0f) {
        guRotateF(mtx2, npc->rot.y, 0.0f, 1.0f, 0.0f);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if (npc->rot.x != 0.0f) {
        guRotateF(mtx2, npc->rot.x, 1.0f, 0.0f, 0.0f);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if (npc->rot.z != 0.0f) {
        guRotateF(mtx2, npc->rot.z, 0.0f, 0.0f, 1.0f);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if (npc->rotPivotOffsetY != 0.0f) {
        guTranslateF(mtx2, 0.0f, -npc->rotPivotOffsetY, 0.0f);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if ((npc->screenSpaceOffset2D[0] != 0.0f) || (npc->screenSpaceOffset2D[1] != 0.0f)) {
        guTranslateF(mtx1, npc->screenSpaceOffset2D[0], npc->screenSpaceOffset2D[1], 0.0f);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if (npc->scale.x * SPRITE_WORLD_SCALE_D != 1.0f
        || (npc->scale.y * npc->verticalStretch) * SPRITE_WORLD_SCALE_D != 1.0f
        || npc->scale.z * SPRITE_WORLD_SCALE_D != 1.0f
    ) {
        guScaleF(mtx2, npc->scale.x * SPRITE_WORLD_SCALE_D, (npc->scale.y * npc->verticalStretch) * SPRITE_WORLD_SCALE_D,
                 npc->scale.z * SPRITE_WORLD_SCALE_D);
        guMtxCatF(mtx2, mtx1, mtx1);
    }
 
    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
        if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE) && (npc->curAnim != 0) && (npc->spriteInstanceID >= 0)) {
            npc_draw_with_palswap(npc, renderYaw, mtx1);
            npc->animNotifyValue = spr_get_notify_value(npc->spriteInstanceID);
        }
    } else {
        npc_draw_with_palswap(npc, renderYaw, mtx1);
        npc->animNotifyValue = func_802DDEC4(PLAYER_SPRITE_AUX1);
    }
 
    if (npc->flags & NPC_FLAG_REFLECT_WALL) {
        guTranslateF(mtx1, npc->pos.x, npc->pos.y + npc->verticalRenderOffset, -npc->pos.z);
        if (npc->flags & NPC_FLAG_UPSIDE_DOWN) {
            mtx_ident_mirror_y(mtx2);
            guMtxCatF(mtx2, mtx1, mtx1);
        }
        if ((npc->rot.y != 0.0f) || (npc->rot.x != 0.0f) || (npc->rot.z != 0.0f)) {
            guRotateRPYF(mtx2, npc->rot.x, npc->rot.y, npc->rot.z);
            guMtxCatF(mtx2, mtx1, mtx1);
        }
 
        if (npc->scale.x * SPRITE_WORLD_SCALE_D != 1.0f
            || (npc->scale.y * npc->verticalStretch) * SPRITE_WORLD_SCALE_D != 1.0f
            || npc->scale.z * SPRITE_WORLD_SCALE_D != 1.0f
        ) {
            guScaleF(mtx2,
                SPRITE_WORLD_SCALE_D * npc->scale.x,
                SPRITE_WORLD_SCALE_D * npc->scale.y * npc->verticalStretch,
                SPRITE_WORLD_SCALE_D * npc->scale.z);
            guMtxCatF(mtx2, mtx1, mtx1);
 
        }
 
        if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
            if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE) && (npc->curAnim != 0)) {
                spr_draw_npc_sprite(npc->spriteInstanceID, renderYaw, 0, 0, mtx1);
            }
        } else {
            spr_draw_player_sprite(PLAYER_SPRITE_AUX1 | DRAW_SPRITE_OVERRIDE_YAW, renderYaw, 0, 0, mtx1);
        }
    }
 
    if (npc->flags & NPC_FLAG_REFLECT_FLOOR) {
        guTranslateF(mtx1, npc->pos.x, -(npc->pos.y + npc->verticalRenderOffset), npc->pos.z);
        mtx_ident_mirror_y(mtx2);
        guMtxCatF(mtx2, mtx1, mtx1);
 
        if (npc->rot.y != 0.0f || npc->rot.x != 0.0f || npc->rot.z != 0.0f) {
            guRotateRPYF(mtx2, npc->rot.x, npc->rot.y, npc->rot.z);
            guMtxCatF(mtx2, mtx1, mtx1);
        }
 
        if (npc->scale.x * SPRITE_WORLD_SCALE_D != 1.0f
            || (npc->scale.y * npc->verticalStretch) * SPRITE_WORLD_SCALE_D != 1.0f
            || npc->scale.z * SPRITE_WORLD_SCALE_D != 1.0f
        ) {
            guScaleF(mtx2,
                SPRITE_WORLD_SCALE_D * npc->scale.x,
                SPRITE_WORLD_SCALE_D * npc->scale.y * npc->verticalStretch,
                SPRITE_WORLD_SCALE_D * npc->scale.z);
            guMtxCatF(mtx2, mtx1, mtx1);
        }
        if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
            if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE) && (npc->curAnim != 0)) {
                spr_draw_npc_sprite(npc->spriteInstanceID, renderYaw, 0, 0, mtx1);
            }
        } else {
            spr_draw_player_sprite(PLAYER_SPRITE_AUX1 | DRAW_SPRITE_OVERRIDE_YAW, renderYaw, 0, 0, mtx1);
        }
    }
    npc->onRender(npc);
}

Referenced by render_npcs().

◆ render_npcs()

void render_npcs ( void )

Renders all NPCs.

Definition at line 931 of file npc.c.

                       {
    RenderTask renderTask;
    RenderTask* renderTaskPtr = &renderTask;
    Camera* cam = &gCameras[gCurrentCamID];
    f32 x, y, z, s;
    f32 renderDist;
    s32 i;
 
    for (i = 0; i < MAX_NPCS; i++) {
        Npc* npc = (*gCurrentNpcListPtr)[i];
        if ((npc != nullptr)
            && (npc->flags != 0)
            && !(npc->flags & (NPC_FLAG_SUSPENDED | NPC_FLAG_HAS_NO_SPRITE | NPC_FLAG_INACTIVE | NPC_FLAG_INVISIBLE))
        ) {
            transform_point(cam->mtxPerspective, npc->pos.x, npc->pos.y, npc->pos.z, 1.0f, &x, &y, &z, &s);
            if (!(s < 0.01) || !(s > -0.01)) {
                renderDist = ((z * 5000.0f) / s) + 5000.0f;
                if (renderDist < 0.0f) {
                    renderDist = 0.0f;
                } else if (renderDist > 10000.0f) {
                    renderDist = 10000.0f;
                }
 
                renderTaskPtr->dist = -renderDist;
                renderTaskPtr->appendGfxArg = npc;
                renderTaskPtr->appendGfx = appendGfx_npc;
                renderTaskPtr->renderMode = npc->renderMode;
 
                if (npc->flags & NPC_FLAG_HIDING) {
                    u8 r, g, b, a;
                    mdl_get_shroud_tint_params(&r, &g, &b, &a);
                    npc->hideAlpha = 255 - a;
                } else {
                    npc->hideAlpha = 255;
                }
 
                if (npc->hideAlpha != 0) {
                    queue_render_task(renderTaskPtr);
                }
 
                if (npc->flags & NPC_FLAG_MOTION_BLUR) {
                    renderTaskPtr->dist = -renderDist;
                    renderTaskPtr->appendGfx = appendGfx_npc_blur;
                    renderTaskPtr->appendGfxArg = npc;
                    renderTaskPtr->renderMode = RENDER_MODE_SURFACE_XLU_LAYER1;
                    queue_render_task(renderTaskPtr);
                }
            }
        }
    }
}

Referenced by render_frame().

◆ npc_move_heading()

void npc_move_heading	(	Npc *	npc,
		f32	speed,
		f32	yaw )

Definition at line 983 of file npc.c.

                                                    {
    f32 angle = DEG_TO_RAD(yaw);
    f32 sin = sin_rad(angle);
    f32 cos = cos_rad(angle);
 
    npc->pos.x += speed * sin;
    npc->pos.z += -speed * cos;
}

Referenced by _npc_jump_to(), AvoidPlayerAI_Chase(), basic_ai_chase(), basic_ai_wander(), BooPatrolAI_Move(), CleftAI_ReturnHome(), CleftAI_Tackle(), ClubbaNappingAI_ReturnHome(), FlyingAI_LosePlayer(), FlyingAI_Wander(), FlyingNoAttackAI_13(), GuardAI_Chase(), GuardAI_ReturnHome(), HoppingAI_Chase(), HoppingAI_Hop(), LakituAI_Wander(), MagikoopaAI_06(), npc_follow_npc(), ParatroopaAI_Dive(), ParatroopaAI_Overshoot(), partner_do_player_collision(), partner_flying_follow_player(), partner_get_out(), partner_move_to_goal(), partner_put_away(), partner_walking_follow_player(), PatrolAI_Chase(), PatrolAI_Move(), PiranhaPlantAI_10(), player_jump(), SentinelAI_Chase(), SentinelAI_ReturnHome(), ShyGuyPatrolAI_15(), ShyGuyPatrolAI_16(), ShyGuyWanderAI_15(), ShyGuyWanderAI_16(), UnkNpcAIFunc12(), update_riding_physics(), and update_riding_physics().

◆ get_npc_unsafe()

Npc * get_npc_unsafe ( s32 npcID )

Definition at line 992 of file npc.c.

                               {
    s32 i;
    Npc* npc;
 
    for (i = 0; i < MAX_NPCS; i++) {
        npc = (*gCurrentNpcListPtr)[i];
        if (npc != nullptr && npc->flags != 0 && npc->npcID == npcID) {
            break;
        }
    }
    ASSERT(i < MAX_NPCS);
 
    return npc;
}

◆ get_npc_safe()

Npc * get_npc_safe ( s32 npcID )

Returns: nullptr if not found

Definition at line 1007 of file npc.c.

                             {
    s32 i;
    Npc* npc;
 
    for (i = 0; i < MAX_NPCS; i++) {
        npc = (*gCurrentNpcListPtr)[i];
        if (npc != nullptr && npc->flags != 0 && npc->npcID == npcID) {
            break;
        }
    }
    if (i >= MAX_NPCS) {
        return nullptr;
    }
 
    return npc;
}

Referenced by resolve_npc(), sfx_play_sound_at_npc(), and unkVtxFunc001().

◆ enable_npc_shadow()

void enable_npc_shadow ( Npc * npc )

Definition at line 1024 of file npc.c.

                                 {
    Shadow* shadow;
 
    if (!(npc->flags & NPC_FLAG_HAS_SHADOW)) {
        shadow = get_shadow_by_index(npc->shadowIndex);
        shadow->flags &= ~ENTITY_FLAG_HIDDEN;
        npc->flags |= (NPC_FLAG_DIRTY_SHADOW | NPC_FLAG_HAS_SHADOW);
    }
}

Referenced by CleftAI_PreAmbush(), and MagikoopaAI_11().

◆ disable_npc_shadow()

void disable_npc_shadow ( Npc * npc )

Definition at line 1034 of file npc.c.

                                  {
    Shadow* shadow;
 
    if (npc->flags & NPC_FLAG_HAS_SHADOW) {
        shadow = get_shadow_by_index(npc->shadowIndex);
        shadow->flags |= ENTITY_FLAG_HIDDEN;
        npc->flags &= ~NPC_FLAG_HAS_SHADOW;
        npc->flags &= ~NPC_FLAG_DIRTY_SHADOW;
    }
}

Referenced by action_update_use_tweester(), CleftAI_HidingInit(), MagikoopaAI_01(), and peach_make_disguise_npc().

◆ update_npc_blur()

void update_npc_blur ( Npc * npc )

Definition at line 1094 of file npc.c.

                               {
    NpcMotionBlur* motionBlur = npc->blur.motion;
    s32 index = motionBlur->index;
 
    motionBlur->posX[index] = npc->pos.x;
    motionBlur->posY[index] = npc->pos.y;
    motionBlur->posZ[index] = npc->pos.z;
 
    index++;
    if (index >= 20) {
        index = 0;
    }
 
    motionBlur->index = index;
}

Referenced by update_npcs().

◆ appendGfx_npc_blur()

void appendGfx_npc_blur ( void * npc )

Definition at line 1110 of file npc.c.

                                    {
    Npc* npc = (Npc*) data;
    Matrix4f mtx, tempMtx;
    f32 x, y, z;
    f32 yaw;
    s32 strideIdx;
    s32 drawIdx;
    s32 bufPos;
    NpcMotionBlur* blur;
 
    strideIdx = 0;
    drawIdx = 0;
    blur = npc->blur.motion;
    bufPos = blur->index;
 
    while (true) {
        bufPos--;
        strideIdx++;
 
        if (bufPos < 0) {
            bufPos = NPC_BLUR_FRAMES - 1;
        }
 
        if (bufPos == blur->index) {
            break;
        }
 
        // only draw every third blur frame
        if (strideIdx < 3) {
            continue;
        }
 
        strideIdx = 0;
        drawIdx++;
 
        // draw three blur samples
        if (drawIdx > 3) {
            break;
        }
 
        x = blur->posX[bufPos];
        y = blur->posY[bufPos];
        z = blur->posZ[bufPos];
        set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_ALPHA, 255, 255, 255, 120 - (drawIdx * 20), 0);
        yaw = npc->renderYaw;
        guTranslateF(mtx, x, y, z);
 
        if (npc->rot.y != 0.0f) {
            guRotateF(tempMtx, npc->rot.y, 0.0f, 1.0f, 0.0f);
            guMtxCatF(tempMtx, mtx, mtx);
        }
        if (npc->rot.x != 0.0f) {
            guRotateF(tempMtx, npc->rot.y, 0.0f, 1.0f, 0.0f);
            guMtxCatF(tempMtx, mtx, mtx);
        }
        if (npc->rot.z != 0.0f) {
            guRotateF(tempMtx, npc->rot.y, 0.0f, 1.0f, 0.0f);
            guMtxCatF(tempMtx, mtx, mtx);
        }
 
        if ((npc->scale.x * SPRITE_WORLD_SCALE_D) != 1.0
            || ((npc->scale.y * npc->verticalStretch) * SPRITE_WORLD_SCALE_D) != 1.0
            || (npc->scale.z * SPRITE_WORLD_SCALE_D) != 1.0
        ) {
            guScaleF(
                tempMtx,
                npc->scale.x * SPRITE_WORLD_SCALE_D,
                (npc->scale.y * npc->verticalStretch) * SPRITE_WORLD_SCALE_D,
                npc->scale.z * SPRITE_WORLD_SCALE_D
            );
            guMtxCatF(tempMtx, mtx, mtx);
        }
 
        if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
            if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
                spr_draw_npc_sprite(npc->spriteInstanceID, yaw, 0, 0, mtx);
            }
        } else {
            spr_draw_player_sprite(PLAYER_SPRITE_AUX1 | DRAW_SPRITE_OVERRIDE_YAW, yaw, 0, 0, mtx);
        }
    }
    npc_imgfx_update(npc);
}

Referenced by render_npcs().

◆ npc_enable_collisions()

void npc_enable_collisions ( void )

Definition at line 1194 of file npc.c.

                                 {
    gNpcPlayerCollisionsEnabled = true;
}

◆ npc_disable_collisions()

void npc_disable_collisions ( void )

Definition at line 1198 of file npc.c.

                                  {
    gNpcPlayerCollisionsEnabled = false;
}

◆ func_8003B1A8()

void func_8003B1A8 ( void )

Definition at line 1202 of file npc.c.

1202 {

1203}

Referenced by state_step_battle(), and state_step_pause().

◆ npc_reload_all()

void npc_reload_all ( void )

Definition at line 1205 of file npc.c.

                          {
    s32 i;
    s32 j;
 
    for (i = 0; i < MAX_NPCS; i++) {
        Npc* npc = (*gCurrentNpcListPtr)[i];
        if (npc != nullptr) {
            if (npc->flags && !(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
                    if (!(npc->flags & NPC_FLAG_PARTNER)) {
                        npc->spriteInstanceID = spr_load_npc_sprite(npc->curAnim, npc->extraAnimList);
                    } else {
                        npc->spriteInstanceID = spr_load_npc_sprite(npc->curAnim | SPRITE_ID_TAIL_ALLOCATE, npc->extraAnimList);
                    }
                }
                if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                    if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE) && (npc->palSwapType != NPC_PAL_ADJUST_NONE)) {
                        npc->originalPalettesList = spr_get_npc_palettes(npc->curAnim >> 16);
                        npc->originalPalettesCount = 0;
                        while (npc->originalPalettesList[npc->originalPalettesCount] != (PAL_PTR) -1) {
                            npc->originalPalettesCount++;
                        }
                        npc->spriteColorVariations = spr_get_npc_color_variations(npc->curAnim >> 16);
                    }
                    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                        if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
                            for (j = 0; j < MAX_NPC_DECORATIONS; j++) {
                                npc_reset_current_decoration(npc, j);
                            }
                            npc_imgfx_update(npc);
                        }
                    }
                }
            }
        }
    }
}

Referenced by state_step_end_battle(), and state_step_unpause().

◆ set_npc_yaw()

void set_npc_yaw	(	Npc *	npc,
		f32	yaw )

Definition at line 1243 of file npc.c.

                                    {
    npc->yaw = yaw;
 
    if (get_clamped_angle_diff(gCameras[gCurrentCameraID].curYaw, yaw) >= 0.0f) {
        npc->yawCamOffset = 180;
        npc->isFacingAway = true;
    } else {
        npc->yawCamOffset = 0;
        npc->isFacingAway = false;
    }
}

Referenced by create_encounters(), GrooveGuyAI_02(), GrooveGuyAI_03(), peach_make_disguise_npc(), SpearGuyAI_Loiter(), and SpearGuyAI_LoiterInit().

◆ npc_set_palswap_mode_A()

void npc_set_palswap_mode_A	(	Npc *	npc,
		s32	arg1 )

Definition at line 1255 of file npc.c.

                                                {
    if (npc->palSwapType != mode) {
        npc->palSwapPrevType = npc->palSwapType;
        npc->palSwapType = mode;
        npc->palAnimState = PAL_SWAP_HOLD_A;
        npc->resetPalAdjust = 1;
    }
}

◆ npc_set_palswap_mode_B()

void npc_set_palswap_mode_B	(	Npc *	npc,
		s32	arg1 )

Definition at line 1264 of file npc.c.

                                                {
    if (npc->palSwapType != mode) {
        npc->palSwapPrevType = npc->palSwapType;
        npc->palSwapType = mode;
        npc->palAnimState = PAL_SWAP_HOLD_A;
        npc->resetPalAdjust = -1;
    }
}

◆ npc_revert_palswap_mode()

void npc_revert_palswap_mode ( Npc * npc )

Definition at line 1273 of file npc.c.

                                       {
    if (npc->palSwapPrevType == NPC_PAL_ADJUST_NONE) {
        npc->palSwapType = NPC_PAL_ADJUST_NONE;
        return;
    }
    npc->palSwapType = npc->palSwapPrevType;
    npc->palSwapPrevType = NPC_PAL_ADJUST_NONE;
    npc->palAnimState = PAL_SWAP_HOLD_A;
    npc->resetPalAdjust = 1;
}

◆ npc_set_palswap_1()

void npc_set_palswap_1	(	Npc *	npc,
		s32	palIndexA,
		s32	palIndexB,
		s32	timeHoldA,
		s32	timeAB )

Definition at line 1284 of file npc.c.

                                                                                          {
    npc->blendPalA = palIndexA;
    npc->blendPalB = palIndexB;
    npc->palswapTimeHoldA = timeHoldA;
    npc->palswapTimeAtoB = timeAB;
}

◆ npc_set_palswap_2()

void npc_set_palswap_2	(	Npc *	npc,
		s32	timeHoldB,
		s32	timeBA,
		s32	palIndexC,
		s32	palIndexD )

Definition at line 1291 of file npc.c.

                                                                                          {
    npc->palswapTimeHoldB = timeHoldB;
    npc->palswapTimeBtoA = timeBA;
    npc->blendPalC = palIndexC;
    npc->blendPalD = palIndexD;
}

◆ npc_draw_with_palswap()

void npc_draw_with_palswap	(	Npc *	npc,
		s32	arg1,
		Matrix4f	mtx )

Definition at line 1298 of file npc.c.

                                                            {
    switch (npc->palSwapType) {
        case NPC_PAL_ADJUST_NONE:
            npc_render_without_adjusted_palettes(npc, yaw, mtx);
            break;
        case NPC_PAL_ADJUST_WATT_IDLE:
            npc_render_with_watt_idle_palettes(npc, yaw, mtx);
            break;
        case NPC_PAL_ADJUST_BLEND_PALETTES_UNIFORM_INTERVALS:
            npc_render_with_single_pal_blending(npc, yaw, false, mtx);
            break;
        case NPC_PAL_ADJUST_BLEND_PALETTES_VARYING_INTERVALS:
            npc_render_with_single_pal_blending(npc, yaw, true, mtx);
            break;
        case NPC_PAL_ADJUST_BLEND_DOUBLE_PALETTES:
            npc_render_with_double_pal_blending(npc, yaw, mtx);
            break;
    }
}

Referenced by appendGfx_npc().

◆ npc_render_without_adjusted_palettes()

void npc_render_without_adjusted_palettes	(	Npc *	npc,
		s32	arg1,
		Matrix4f	mtx )

Definition at line 1318 of file npc.c.

                                                                            {
    if (npc->resetPalAdjust != 0) {
        npc->verticalStretch = 1.0f;
        npc->screenSpaceOffset2D[0] = 0.0f;
        npc->screenSpaceOffset2D[1] = 0.0f;
        npc->resetPalAdjust = 0;
    }
 
    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
        s32 alpha = (npc->alpha * npc->hideAlpha / 255);
        u32 mask;
        if (alpha < 255) {
            mask = DRAW_SPRITE_OVERRIDE_ALPHA;
        } else {
            mask = 0;
        }
        spr_draw_npc_sprite(npc->spriteInstanceID | mask, arg1, alpha, nullptr, mtx);
    } else {
        spr_draw_player_sprite(PLAYER_SPRITE_AUX1 | DRAW_SPRITE_OVERRIDE_YAW, arg1, 0, 0, mtx);
    }
}

Referenced by npc_draw_with_palswap().

◆ npc_render_with_watt_idle_palettes()

void npc_render_with_watt_idle_palettes	(	Npc *	npc,
		s32	arg1,
		Matrix4f	mtx )

Definition at line 1340 of file npc.c.

                                                                          {
    s32 i, j;
    s32 brightness;
    PAL_PTR src;
    PAL_PTR dst;
 
    if (npc->resetPalAdjust != 0) {
        npc->originalPalettesList = spr_get_npc_palettes(npc->curAnim >> 16);
        npc->originalPalettesCount = 0;
        while ((s32)npc->originalPalettesList[npc->originalPalettesCount] != -1) {
            npc->originalPalettesCount++;
        }
 
        npc->spriteColorVariations = spr_get_npc_color_variations(npc->curAnim >> 16);
        for (i = 0; i < npc->originalPalettesCount; i++) {
            dst = npc->copiedPalettes[i];
            src = npc->originalPalettesList[i];
            if (src != nullptr) {
                for (j = 0; j < SPR_PAL_SIZE; j++) {
                    *dst++ = *src++;
                }
            }
        }
 
        npc->palAnimState = -2;
        npc->palBlendAlpha = 0;
        npc->resetPalAdjust = 0;
        npc->nextPalTime = 0;
    }
 
    if (npc->nextPalTime == 0) {
        npc->palAnimState += 2;
        brightness = wWattIdlePalettesAnim[npc->palAnimState];
        if (brightness == 255) {
            npc->palAnimState = 0;
        }
        npc->nextPalTime = wWattIdlePalettesAnim[npc->palAnimState + 1] / 2;
    }
 
    brightness = wWattIdlePalettesAnim[npc->palAnimState];
    npc->nextPalTime--;
 
    switch(brightness) {
        case WATT_DEFAULT:
            for (i = 0; i < npc->spriteColorVariations; i++) {
                dst = npc->copiedPalettes[i];
                src = npc->originalPalettesList[i];
                if (src != nullptr) {
                    for (j = 0; j < SPR_PAL_SIZE; j++) {
                        *dst++ = *src++;
                    }
                }
            }
            break;
        case WATT_BRIGHTEST:
            for (i = 0; i < npc->spriteColorVariations; i++) {
                // use watt's Brightest palettes
                dst = npc->copiedPalettes[i];
                src = npc->originalPalettesList[npc->spriteColorVariations * SPR_PAL_WorldWatt_Brightest + i];
                if (src != nullptr) {
                    for (j = 0; j < SPR_PAL_SIZE; j++) {
                        *dst++ = *src++;
                    }
                }
            }
            break;
        case WATT_BRIGHTER:
            for (i = 0; i < npc->spriteColorVariations; i++) {
                // use watt's Brighter palettes
                dst = npc->copiedPalettes[i];
                src = npc->originalPalettesList[npc->spriteColorVariations * SPR_PAL_WorldWatt_Brighter + i];
                if (src != nullptr) {
                    for (j = 0; j < SPR_PAL_SIZE; j++) {
                        *dst++ = *src++;
                    }
                }
            }
            break;
    }
 
    for (i = 0; i < npc->originalPalettesCount; i++) {
        npc->adjustedPalettes[i] = npc->copiedPalettes[i];
    }
 
    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
        s32 alpha = npc->alpha * npc->hideAlpha / 255;
        u32 mask = 0;
        if (alpha < 255) {
            mask |= DRAW_SPRITE_OVERRIDE_ALPHA;
        }
        mask |= DRAW_SPRITE_OVERRIDE_PALETTES;
        spr_draw_npc_sprite(npc->spriteInstanceID | mask, arg1, alpha, npc->adjustedPalettes, mtx);
    }
    npc->palBlendAlpha--;
}

Referenced by npc_draw_with_palswap().

◆ npc_blend_palette_colors()

u16 npc_blend_palette_colors	(	u16	colorA,
		u16	colorB,
		s32	lerpAlpha )

Definition at line 1436 of file npc.c.

                                                                    {
    u8 r = (UNPACK_PAL_R(colorA) * (255 - lerpAlpha) + UNPACK_PAL_R(colorB) * lerpAlpha) / 255;
    u8 g = (UNPACK_PAL_G(colorA) * (255 - lerpAlpha) + UNPACK_PAL_G(colorB) * lerpAlpha) / 255;
    u8 b = (UNPACK_PAL_B(colorA) * (255 - lerpAlpha) + UNPACK_PAL_B(colorB) * lerpAlpha) / 255;
    u8 a = UNPACK_PAL_A(colorB);
 
    return PACK_PAL_RGBA(r, g, b, a);
}

Referenced by npc_render_with_double_pal_blending(), and npc_render_with_single_pal_blending().

◆ npc_render_with_single_pal_blending()

void npc_render_with_single_pal_blending	(	Npc *	npc,
		s32	yaw,
		s32	hasDifferentIntervals,
		Matrix4f	mtx )

Definition at line 1445 of file npc.c.

                                                                                                     {
    PAL_PTR color1;
    PAL_PTR color2;
    PAL_PTR outColor;
    s32 i, j;
    s32 blendAlpha;
 
    // copy palettes from sprite data
    if (npc->resetPalAdjust != 0) {
        if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
            npc->originalPalettesList = spr_get_npc_palettes(npc->curAnim >> 16);
        }
 
        npc->originalPalettesCount = 0;
        while ((s32)npc->originalPalettesList[npc->originalPalettesCount] != -1) {
            npc->originalPalettesCount++;
        }
 
        if (npc->resetPalAdjust == 1) {
            npc->palAnimState = PAL_SWAP_HOLD_A;
            npc->palBlendAlpha = 0;
        } else {
            npc->palAnimState = PAL_SWAP_HOLD_A;
            npc->palBlendAlpha = 255;
        }
 
        for (i = 0; i < npc->originalPalettesCount; i++) {
            color1 = npc->copiedPalettes[i];
            color2 = npc->originalPalettesList[i];
            npc->adjustedPalettes[i] = color1;
            if (color2 != nullptr) {
                for (j = 0; j < SPR_PAL_SIZE; j++) {
                    *color1++ = *color2++;
                }
            }
        }
 
        if (!hasDifferentIntervals) {
            npc->palswapTimeAtoB = npc->palswapTimeHoldA;
            npc->palswapTimeHoldB = npc->palswapTimeHoldA;
            npc->palswapTimeBtoA = npc->palswapTimeAtoB;
            npc->palswapTimeHoldA = 0;
        }
 
        npc->nextPalTime = npc->palswapTimeHoldA;
        npc->palBlendAlpha = 0;
        npc->palAnimState = PAL_SWAP_HOLD_A;
        npc->resetPalAdjust = 0;
    }
 
    // blending from A -> B
    switch (npc->palAnimState) {
        case PAL_SWAP_HOLD_A:
            if (npc->nextPalTime != 0) {
                npc->nextPalTime--;
                break;
            } else {
                npc->palBlendAlpha = 0;
                npc->palAnimState = PAL_SWAP_A_TO_B;
            }
            // fallthrough
        case PAL_SWAP_A_TO_B:
            npc->palBlendAlpha += 25600 / npc->palswapTimeAtoB;
            if (npc->palBlendAlpha > 25500) {
                npc->palBlendAlpha = 25500;
            }
            blendAlpha = npc->palBlendAlpha / 100;
            // blend two palettes
            outColor = npc->copiedPalettes[0];
            color2 = npc->originalPalettesList[npc->blendPalA];
            color1 = npc->originalPalettesList[npc->blendPalB];
            npc->adjustedPalettes[0] = outColor;
 
            for (j = 0; j < SPR_PAL_SIZE; j++) {
                *outColor++ = npc_blend_palette_colors(*color2++, *color1++, blendAlpha);
            }
 
            if (blendAlpha == 255) {
                npc->palAnimState = PAL_SWAP_HOLD_B;
                npc->nextPalTime = npc->palswapTimeHoldB;
            }
            break;
    }
 
    // blending from B -> A
    switch (npc->palAnimState) {
        case PAL_SWAP_HOLD_B:
            if (npc->nextPalTime != 0) {
                npc->nextPalTime--;
                break;
            } else {
                npc->palBlendAlpha = 0;
                npc->palAnimState = PAL_SWAP_B_TO_A;
            }
            // fallthrough
        case PAL_SWAP_B_TO_A:
            npc->palBlendAlpha += 25600 / npc->palswapTimeBtoA;
            if (npc->palBlendAlpha > 25500) {
                npc->palBlendAlpha = 25500;
            }
            blendAlpha = npc->palBlendAlpha / 100;
            // blend two palettes
            outColor = npc->copiedPalettes[0];
            color2 = npc->originalPalettesList[npc->blendPalB];
            color1 = npc->originalPalettesList[npc->blendPalA];
            npc->adjustedPalettes[0] = outColor;
 
            for (j = 0; j < SPR_PAL_SIZE; j++) {
                *outColor++ = npc_blend_palette_colors(*color2++, *color1++, blendAlpha);
            }
 
            if (blendAlpha == 255) {
                npc->palAnimState = PAL_SWAP_HOLD_A;
                npc->nextPalTime = npc->palswapTimeHoldA;
            }
            break;
    }
 
    switch (npc->palAnimState) {
        case PAL_SWAP_HOLD_A:
        case PAL_SWAP_A_TO_B:
        case PAL_SWAP_HOLD_B:
        case PAL_SWAP_B_TO_A:
            if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                u32 mask = 0;
                blendAlpha = npc->alpha * npc->hideAlpha / 255;
                if (blendAlpha < 255) {
                    mask |= DRAW_SPRITE_OVERRIDE_ALPHA;
                }
                mask |= DRAW_SPRITE_OVERRIDE_PALETTES;
                spr_draw_npc_sprite(npc->spriteInstanceID | mask, yaw, blendAlpha, npc->adjustedPalettes, mtx);
            }
            break;
    }
}

Referenced by npc_draw_with_palswap().

◆ npc_render_with_double_pal_blending()

void npc_render_with_double_pal_blending	(	Npc *	npc,
		s32	yaw,
		Matrix4f	mtx )

Bug: ? should this be index 3?

Definition at line 1581 of file npc.c.

                                                                          {
    PAL_PTR color1;
    PAL_PTR color2;
    PAL_PTR outColor;
    s32 i, j;
    u8 blendAlpha;
 
    // copy palettes from sprite data
    if (npc->resetPalAdjust != 0) {
        if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
            npc->originalPalettesList = spr_get_npc_palettes(npc->curAnim >> 16);
        }
 
        npc->originalPalettesCount = 0;
        while ((s32)npc->originalPalettesList[npc->originalPalettesCount] != -1) {
            npc->originalPalettesCount++;
        }
 
        if (npc->resetPalAdjust == 1) {
            npc->palAnimState = PAL_SWAP_HOLD_A;
            npc->palBlendAlpha = 0;
        } else {
            npc->palAnimState = PAL_SWAP_HOLD_A;
            npc->palBlendAlpha = 255;
        }
 
        for (i = 0; i < npc->originalPalettesCount; i++) {
            color1 = npc->copiedPalettes[i];
            color2 = npc->originalPalettesList[i];
            npc->adjustedPalettes[i] = color1;
            if (color2 != nullptr) {
                for (j = 0; j < SPR_PAL_SIZE; j++) {
                    *color1++ = *color2++;
                }
            }
        }
 
        npc->nextPalTime = npc->palswapTimeHoldA;
        npc->palBlendAlpha = 0;
        npc->palAnimState = PAL_SWAP_HOLD_A;
        npc->resetPalAdjust = 0;
    }
 
    // blending from A -> B
    switch (npc->palAnimState) {
        case PAL_SWAP_HOLD_A:
            if (npc->nextPalTime != 0) {
                npc->nextPalTime--;
                break;
            }
            npc->palBlendAlpha = 0;
            npc->palAnimState = PAL_SWAP_A_TO_B;
            // fallthrough
        case PAL_SWAP_A_TO_B:
            npc->palBlendAlpha += 25600 / npc->palswapTimeAtoB;
            if (npc->palBlendAlpha > 25500) {
                npc->palBlendAlpha = 25500;
            }
            blendAlpha = npc->palBlendAlpha / 100;
 
            // blend first two palettes
            outColor = npc->copiedPalettes[0];
            color2 = npc->originalPalettesList[npc->blendPalA];
            color1 = npc->originalPalettesList[npc->blendPalB];
            npc->adjustedPalettes[0] = outColor;
 
            for (j = 0; j < SPR_PAL_SIZE; j++) {
                *outColor++ = npc_blend_palette_colors(*color2++, *color1++, blendAlpha);
            }
 
            // blend next palettes
            outColor = npc->copiedPalettes[3];
            color2 = npc->originalPalettesList[npc->blendPalC];
            color1 = npc->originalPalettesList[npc->blendPalD];
            npc->adjustedPalettes[3] = outColor;
 
            for (j = 0; j < SPR_PAL_SIZE; j++) {
                *outColor++ = npc_blend_palette_colors(*color2++, *color1++, blendAlpha);
            }
 
            if (blendAlpha == 255) {
                npc->palAnimState = PAL_SWAP_HOLD_B;
                npc->nextPalTime = npc->palswapTimeHoldB;
            }
            break;
    }
 
    // blending from B -> A
    switch (npc->palAnimState) {
        case PAL_SWAP_HOLD_B:
            if (npc->nextPalTime != 0) {
                npc->nextPalTime--;
                break;
            } else {
                npc->palBlendAlpha = 0;
                npc->palAnimState = PAL_SWAP_B_TO_A;
            }
            // fallthrough
        case PAL_SWAP_B_TO_A:
            npc->palBlendAlpha += 25600 / npc->palswapTimeBtoA;
            if (npc->palBlendAlpha > 25500) {
                npc->palBlendAlpha = 25500;
            }
            blendAlpha = npc->palBlendAlpha / 100;
 
            // blend first two palettes
            outColor = npc->copiedPalettes[0];
            color2 = npc->originalPalettesList[npc->blendPalB];
            color1 = npc->originalPalettesList[npc->blendPalA];
            npc->adjustedPalettes[0] = outColor;
 
            for (j = 0; j < SPR_PAL_SIZE; j++) {
                *outColor++ = npc_blend_palette_colors(*color2++, *color1++, blendAlpha);
            }
 
            // blend next palettes
            outColor = npc->copiedPalettes[1]; 
            color2 = npc->originalPalettesList[npc->blendPalD];
            color1 = npc->originalPalettesList[npc->blendPalC];
            npc->adjustedPalettes[3] = npc->copiedPalettes[3];
 
            for (j = 0; j < SPR_PAL_SIZE; j++) {
                *outColor++ = npc_blend_palette_colors(*color2++, *color1++, blendAlpha);
            }
 
            if (blendAlpha == 255) {
                npc->palAnimState = PAL_SWAP_HOLD_A;
                npc->nextPalTime = npc->palswapTimeHoldA;
            }
            break;
    }
 
    switch (npc->palAnimState) {
        case PAL_SWAP_HOLD_A:
        case PAL_SWAP_A_TO_B:
        case PAL_SWAP_HOLD_B:
        case PAL_SWAP_B_TO_A:
            if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
                u32 mask = 0;
                blendAlpha = npc->alpha * npc->hideAlpha / 255;
                if (blendAlpha < 255) {
                    mask |= DRAW_SPRITE_OVERRIDE_ALPHA;
                }
                mask |= DRAW_SPRITE_OVERRIDE_PALETTES;
                spr_draw_npc_sprite(npc->spriteInstanceID | mask, yaw, blendAlpha, npc->adjustedPalettes, mtx);
            }
            break;
    }
}

Referenced by npc_draw_with_palswap().

◆ npc_set_decoration()

void npc_set_decoration	(	Npc *	npc,
		s32	idx,
		s32	decorationType )

Definition at line 1731 of file npc.c.

                                                               {
    npc_remove_decoration(npc, idx);
    npc->decorationType[idx] = decorationType;
    npc->changedDecoration[idx] = 1;
    npc->decorationInitialized[idx] = 0;
}

◆ npc_remove_decoration()

void npc_remove_decoration	(	Npc *	npc,
		s32	idx )

Definition at line 1738 of file npc.c.

                                              {
    switch (npc->decorationType[idx]) {
        case NPC_DECORATION_NONE:
            npc_remove_decoration_none(npc, idx);
            break;
        case NPC_DECORATION_BOWSER_AURA:
            npc_remove_decoration_bowser_aura(npc, idx);
            break;
        case NPC_DECORATION_SWEAT:
            npc_remove_decoration_sweat(npc, idx);
            break;
        case NPC_DECORATION_SEEING_STARS:
            npc_remove_decoration_seeing_stars(npc, idx);
            break;
        case NPC_DECORATION_WHITE_GLOW_FRONT:
            npc_remove_decoration_glow_in_front(npc, idx);
            break;
        case NPC_DECORATION_WHITE_GLOW_BEHIND:
            npc_remove_decoration_glow_behind(npc, idx);
            break;
        case NPC_DECORATION_CHARGED:
            npc_remove_decoration_charged(npc, idx);
            break;
    }
    npc->decorationType[idx] = NPC_DECORATION_NONE;
}

Referenced by free_npc(), free_npc_by_index(), and npc_set_decoration().

◆ npc_update_decorations()

void npc_update_decorations ( Npc * npc )

Definition at line 1765 of file npc.c.

                                      {
    s32 i;
 
    for (i = 0; i < MAX_NPC_DECORATIONS; i++) {
        switch (npc->decorationType[i]) {
            case NPC_DECORATION_NONE:
                npc_update_decoration_none(npc, i);
                break;
            case NPC_DECORATION_BOWSER_AURA:
                npc_update_decoration_bowser_aura(npc, i);
                break;
            case NPC_DECORATION_SWEAT:
                npc_update_decoration_sweat(npc, i);
                break;
            case NPC_DECORATION_SEEING_STARS:
                npc_update_decoration_seeing_stars(npc, i);
                break;
            case NPC_DECORATION_WHITE_GLOW_FRONT:
                npc_update_decoration_glow_in_front(npc, i);
                break;
            case NPC_DECORATION_WHITE_GLOW_BEHIND:
                npc_update_decoration_glow_behind(npc, i);
                break;
            case NPC_DECORATION_CHARGED:
                npc_update_decoration_charged(npc, i);
                break;
        }
    }
}

Referenced by update_npcs().

◆ npc_reset_current_decoration()

void npc_reset_current_decoration	(	Npc *	npc,
		s32	idx )

Definition at line 1795 of file npc.c.

                                                     {
    switch (npc->decorationType[idx]) {
        case NPC_DECORATION_NONE:
        case NPC_DECORATION_BOWSER_AURA:
        case NPC_DECORATION_SWEAT:
        case NPC_DECORATION_SEEING_STARS:
        case NPC_DECORATION_WHITE_GLOW_FRONT:
        case NPC_DECORATION_WHITE_GLOW_BEHIND:
            break;
        case NPC_DECORATION_CHARGED:
            npc->decorationInitialized[idx] = 0;
            break;
    }
}

Referenced by npc_reload_all().

◆ npc_update_decoration_none()

void npc_update_decoration_none	(	Npc *	npc,
		s32	idx )

Definition at line 1810 of file npc.c.

1810 {

1811}

Referenced by npc_update_decorations().

◆ npc_remove_decoration_none()

void npc_remove_decoration_none	(	Npc *	npc,
		s32	idx )

Definition at line 1813 of file npc.c.

1813 {

1814}

Referenced by npc_remove_decoration().

◆ npc_update_decoration_bowser_aura()

void npc_update_decoration_bowser_aura	(	Npc *	npc,
		s32	idx )

Definition at line 1816 of file npc.c.

                                                          {
    AuraFXData* data;
 
    switch (npc->decorationInitialized[idx]) {
        case 0:
            fx_aura(FX_AURA_BLUE, npc->pos.x, npc->pos.y, npc->pos.z, 1.0f, &npc->decorations[idx]);
            npc->decorationInitialized[idx] = 1;
            // fallthrough
        case 1:
            data = npc->decorations[idx]->data.aura;
            data->posA.x = npc->pos.x;
            data->posA.y = npc->pos.y;
            data->posA.z = npc->pos.z;
            data->scale.x = (npc->scale.x * npc->collisionDiameter) * 0.01;
            data->scale.y = (npc->scale.y * npc->collisionHeight) * 0.01;
            data->renderYaw = npc->renderYaw;
            break;
    }
}

Referenced by npc_update_decorations().

◆ npc_remove_decoration_bowser_aura()

void npc_remove_decoration_bowser_aura	(	Npc *	npc,
		s32	idx )

Definition at line 1836 of file npc.c.

                                                          {
    npc->decorations[idx]->data.aura->fadeTime = 5;
}

Referenced by npc_remove_decoration().

◆ npc_update_decoration_sweat()

void npc_update_decoration_sweat	(	Npc *	npc,
		s32	idx )

Definition at line 1840 of file npc.c.

                                                    {
    switch (npc->decorationInitialized[idx]) {
        case 0:
            if (npc->yawCamOffset > 90) {
                fx_sweat(0, npc->pos.x, npc->pos.y + npc->collisionHeight, npc->pos.z, 5.0f, 45.0f, 20);
            } else {
                fx_sweat(0, npc->pos.x, npc->pos.y + npc->collisionHeight, npc->pos.z, 5.0f, -45.0f, 20);
            }
            npc->decorationGlowPhase[idx] = 10;
            npc->decorationInitialized[idx] = 1;
            break;
        case 1:
            if (npc->decorationGlowPhase[idx] != 0) {
                npc->decorationGlowPhase[idx]--;
            } else {
                npc->decorationInitialized[idx] = 0;
            }
            break;
    }
}

Referenced by npc_update_decorations().

◆ npc_remove_decoration_sweat()

void npc_remove_decoration_sweat	(	Npc *	npc,
		s32	idx )

Definition at line 1861 of file npc.c.

1861 {

1862}

Referenced by npc_remove_decoration().

◆ npc_update_decoration_seeing_stars()

void npc_update_decoration_seeing_stars	(	Npc *	npc,
		s32	idx )

Definition at line 1864 of file npc.c.

                                                           {
    StarsOrbitingFXData* data;
 
    switch (npc->decorationInitialized[idx]) {
        case 0:
            fx_stars_orbiting(0, npc->pos.x, npc->pos.y + npc->collisionHeight, npc->pos.z, 20.0f, 3, &npc->decorations[idx]);
            npc->decorationInitialized[idx] = 1;
            break;
        case 1:
            data = npc->decorations[idx]->data.starsOrbiting;
            data->pos.x = npc->pos.x;
            data->pos.y = npc->pos.y + npc->collisionHeight;
            data->pos.z = npc->pos.z;
            break;
    }
}

Referenced by npc_update_decorations().

◆ npc_remove_decoration_seeing_stars()

void npc_remove_decoration_seeing_stars	(	Npc *	npc,
		s32	idx )

Definition at line 1881 of file npc.c.

                                                           {
    remove_effect(npc->decorations[idx]);
}

Referenced by npc_remove_decoration().

◆ npc_update_decoration_glow_in_front()

void npc_update_decoration_glow_in_front	(	Npc *	npc,
		s32	idx )

Definition at line 1885 of file npc.c.

                                                            {
    EnergyOrbWaveFXData* data;
 
    switch (npc->decorationInitialized[idx]) {
        case 0:
            npc->decorations[idx] = fx_energy_orb_wave(2, npc->pos.x, npc->pos.y + npc->collisionHeight * 0.5, npc->pos.z, npc->scale.x * 0.8 + 0.2f, -1);
            npc->decorationInitialized[idx] = 1;
            break;
        case 1:
            data = npc->decorations[idx]->data.energyOrbWave;
            data->pos.x = npc->pos.x;
            data->pos.y = npc->pos.y + npc->collisionHeight * 0.5 * npc->scale.x;
            data->pos.z = npc->pos.z;
            data->scale = npc->scale.x * 0.8 + 0.2f;
            break;
    }
}

Referenced by npc_update_decorations().

◆ npc_remove_decoration_glow_in_front()

void npc_remove_decoration_glow_in_front	(	Npc *	npc,
		s32	idx )

Definition at line 1903 of file npc.c.

                                                            {
    remove_effect(npc->decorations[idx]);
}

Referenced by npc_remove_decoration().

◆ npc_update_decoration_glow_behind()

void npc_update_decoration_glow_behind	(	Npc *	npc,
		s32	idx )

Definition at line 1907 of file npc.c.

                                                          {
    EnergyOrbWaveFXData* data;
 
    switch (npc->decorationInitialized[idx]) {
        case 0:
            npc->decorations[idx] = fx_energy_orb_wave(2, npc->pos.x, npc->pos.y + npc->collisionHeight * 0.5, npc->pos.z - 5.0f, 1.0f, 0);
            npc->decorationInitialized[idx] = 1;
            break;
        case 1:
            data = npc->decorations[idx]->data.energyOrbWave;
            data->pos.x = npc->pos.x;
            data->pos.y = npc->pos.y + npc->collisionHeight * 0.5;
            data->pos.z = npc->pos.z - 5.0f;
            data->scale = 1.0f;
            break;
    }
}

Referenced by npc_update_decorations().

◆ npc_remove_decoration_glow_behind()

void npc_remove_decoration_glow_behind	(	Npc *	npc,
		s32	idx )

Definition at line 1925 of file npc.c.

                                                          {
    remove_effect(npc->decorations[idx]);
}

Referenced by npc_remove_decoration().

◆ npc_update_decoration_charged()

void npc_update_decoration_charged	(	Npc *	npc,
		s32	idx )

Definition at line 1929 of file npc.c.

                                                      {
    #define RGBA_BUF_SIZE 20
    u8 rbuf[RGBA_BUF_SIZE];
    u8 gbuf[RGBA_BUF_SIZE];
    u8 bbuf[RGBA_BUF_SIZE];
    s32 color;
    s32 alpha;
    s32 i;
 
    if (npc->decorationInitialized[idx] == 0) {
        set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_ALLOC_COLOR_BUF, 20, 0, 0, 255, 0);
        npc->decorationInitialized[idx] = 1;
    }
    if (npc->decorationInitialized[idx] == 1) {
        npc->decorationGlowPhase[idx] += 7;
        if (npc->decorationGlowPhase[idx] >= 360) {
            npc->decorationGlowPhase[idx] %= 360;
        }
 
        for (i = 0; i < RGBA_BUF_SIZE; i++) {
            rbuf[i] = (cosine(npc->decorationGlowPhase[idx] + (25 * i)) + 1.0) * 80.0f;
            gbuf[i] = (cosine(npc->decorationGlowPhase[idx] + (25 * i) + 45) + 1.0) * 80.0f;
            bbuf[i] = (cosine(npc->decorationGlowPhase[idx] + (25 * i) + 90) + 1.0) * 80.0f;
        }
 
        alpha = 255;
        for (i = 0; i < RGBA_BUF_SIZE; i++) {
            color = (rbuf[i] << 24) | (gbuf[i] << 16) | (bbuf[i] << 8) | alpha;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_COLOR_BUF_SET_MODULATE, i, color, 0, 255, 0);
        }
    }
    #undef RGBA_BUF_SIZE
}

Referenced by npc_update_decorations().

◆ npc_remove_decoration_charged()

void npc_remove_decoration_charged	(	Npc *	npc,
		s32	idx )

Definition at line 1963 of file npc.c.

1963 {

1964}

Referenced by npc_remove_decoration().

◆ npc_find_closest()

Npc * npc_find_closest	(	f32	x,
		f32	y,
		f32	z,
		f32	radius )

Finds the closest NPC to a given point within a radius.

Ignores Y position.

NPCs with NPC_FLAG_PARTNER set are ignored. See also npc_find_closest_simple(), which requires that NPC_FLAG_PARTNER be set.

Parameters

x	X position
y	Y position (unused)
z	Z position
radius	No NPCs further than this distance will be considered

Returns: nullptr if there are no NPCs within radius

Definition at line 1966 of file npc.c.

                                                       {
    Npc* closestNpc = nullptr;
    f32 closestDist = radius;
    f32 maxDist = radius;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentNpcListPtr); i++) {
        Npc* npc = (*gCurrentNpcListPtr)[i];
 
        if (npc != nullptr && npc->flags != 0 && !(npc->flags & NPC_FLAG_PARTNER)) {
            if (!(npc->flags & (NPC_FLAG_SUSPENDED | NPC_FLAG_INACTIVE))) {
                f32 distance = fabsf(dist2D(npc->pos.x, npc->pos.z, x, z));
 
                if (distance <= maxDist) {
                    if (distance < closestDist) {
                        closestDist = distance;
                        closestNpc = npc;
                    }
                }
            }
        }
    }
 
    return closestNpc;
}

Referenced by parasol_get_npc().

◆ npc_find_closest_simple()

Npc * npc_find_closest_simple	(	f32	x,
		f32	y,
		f32	z,
		f32	radius )

Finds the closest simple-hitbox NPC to a given point within a radius.

Ignores Y position.

Only NPCs with NPC_FLAG_PARTNER set are considered. See also npc_find_closest(), which requires that NPC_FLAG_PARTNER be unset.

Parameters

x	X position
y	Y position (unused)
z	Z position
radius	No NPCs further than this distance will be considered

Returns: nullptr if there are no NPCs within radius

Definition at line 1992 of file npc.c.

                                                              {
    Npc* closestNpc = nullptr;
    f32 closestDist = radius;
    f32 maxDist = radius;
    s32 i;
 
    for (i = 0; i < ARRAY_COUNT(*gCurrentNpcListPtr); i++) {
        Npc* npc = (*gCurrentNpcListPtr)[i];
 
        if (npc != nullptr && npc->flags != 0 && (npc->flags & NPC_FLAG_PARTNER)) {
            if (!(npc->flags & (NPC_FLAG_SUSPENDED | NPC_FLAG_INACTIVE))) {
                f32 distance = fabsf(dist2D(npc->pos.x, npc->pos.z, x, z));
 
                if (distance <= maxDist) {
                    if (distance < closestDist) {
                        closestDist = distance;
                        closestNpc = npc;
                    }
                }
            }
        }
    }
 
    return closestNpc;
}

Referenced by entity_Tweester_idle().

◆ npc_get_collider_below()

s32 npc_get_collider_below ( Npc * npc )

Definition at line 2066 of file npc.c.

                                     {
    f32 x;
    f32 y;
    f32 z;
    f32 yaw;
 
    if (npc->flags & NPC_FLAG_PARTNER) {
        y = get_shadow_by_index(npc->shadowIndex)->pos.y + 13.0f;
    } else {
        y = npc->pos.y + 13.0f;
    }
 
    yaw = 16.0f;
    x = npc->pos.x;
    z = npc->pos.z;
 
    if (npc_raycast_down_sides(COLLIDER_FLAG_IGNORE_SHELL | COLLIDER_FLAG_IGNORE_PLAYER | COLLIDER_FLAG_IGNORE_NPC, &x, &y, &z, &yaw)) {
        if (yaw <= 16.0f) {
            return NpcHitQueryColliderID;
        }
    }
    return 0;
}

Referenced by npc_find_standing_on_entity().

◆ npc_imgfx_update()

void npc_imgfx_update ( Npc * npc )

Definition at line 2090 of file npc.c.

                                {
    s32 imgfxType = npc->imgfxType;
    s32 imgfxArg1 = npc->imgfxArg1;
    s32 imgfxArg2 = npc->imgfxArg2;
    s32 imgfxArg3 = npc->imgfxArg3;
    s32 imgfxArg4 = npc->imgfxArg4;
    s32 imgfxFlags = npc->imgfxFlags;
 
    set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_CLEAR, 0, 0, 0, 0, 0);
 
    switch (imgfxType) {
        case IMGFX_CLEAR:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_CLEAR, 0, 0, 0, 0, imgfxFlags);
            break;
        case IMGFX_UNK_2:
        case IMGFX_RESET:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            // fallthrough
        case IMGFX_UNK_1:
            set_npc_imgfx_all(npc->spriteInstanceID, imgfxType, 0, 0, 0, 0, imgfxFlags);
            break;
        case IMGFX_SET_WAVY:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_WAVY, imgfxArg1, imgfxArg2, imgfxArg3, 0, imgfxFlags);
            break;
        case IMGFX_SET_COLOR:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_COLOR, imgfxArg1, imgfxArg2, imgfxArg3, 255, imgfxFlags);
            break;
        case IMGFX_SET_ALPHA:
            npc->renderMode = RENDER_MODE_SURFACE_XLU_LAYER2;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_ALPHA, 255, 255, 255, imgfxArg1, imgfxFlags);
            break;
        case IMGFX_SET_TINT:
            npc->renderMode = RENDER_MODE_SURFACE_XLU_LAYER2;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_TINT, imgfxArg1, imgfxArg2, imgfxArg3, imgfxArg4, imgfxFlags);
            break;
        case IMGFX_SET_WHITE_FADE:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_WHITE_FADE, imgfxArg1, imgfxArg2, imgfxArg3, 255, imgfxFlags);
            break;
        case IMGFX_SET_CREDITS_FADE:
            npc->renderMode = RENDER_MODE_SURFACE_XLU_LAYER2;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_CREDITS_FADE, imgfxArg1, imgfxArg2, imgfxArg3, imgfxArg4, imgfxFlags);
            break;
        case IMGFX_SET_ANIM:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_SET_ANIM, imgfxArg1, imgfxArg2, imgfxArg3, 0, imgfxFlags);
            break;
        case IMGFX_HOLOGRAM:
            npc->renderMode = RENDER_MODE_SURFACE_XLU_LAYER2;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_HOLOGRAM, imgfxArg1, imgfxArg2, imgfxArg3, imgfxArg4, imgfxFlags);
            break;
        case IMGFX_FILL_COLOR:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_FILL_COLOR, imgfxArg1, imgfxArg2, imgfxArg3, 255, imgfxFlags);
            break;
        case IMGFX_OVERLAY:
            npc->renderMode = RENDER_MODE_ALPHATEST;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_OVERLAY, imgfxArg1, 255, 0, 255, imgfxFlags);
            break;
        case IMGFX_OVERLAY_XLU:
            npc->renderMode = RENDER_MODE_SURFACE_XLU_LAYER2;
            set_npc_imgfx_all(npc->spriteInstanceID, IMGFX_OVERLAY, imgfxArg1, imgfxArg2, 0, imgfxArg2, imgfxFlags);
            break;
    }
}

Referenced by appendGfx_npc_blur(), npc_reload_all(), and npc_set_imgfx_params().

◆ npc_set_imgfx_params()

void npc_set_imgfx_params	(	Npc *	npc,
		s32	arg1,
		s32	arg2,
		s32	arg3,
		s32	arg4,
		s32	arg5,
		s32	arg6 )

Definition at line 2159 of file npc.c.

                                                                                                     {
    npc->imgfxType = imgfxType;
    npc->imgfxArg1 = arg2;
    npc->imgfxArg2 = arg3;
    npc->imgfxArg3 = arg4;
    npc->imgfxArg4 = arg5;
    npc->imgfxFlags = arg6;
    npc_imgfx_update(npc);
}

Referenced by end_outta_sight_cleanup(), reset_outta_sight_alpha_on_menu_close(), and update_riding_physics().

◆ npc_surface_spawn_fx()

void npc_surface_spawn_fx	(	Npc *	npc,
		SurfaceInteractMode	mode )

Definition at line 394 of file surfaces.c.

                                                              {
    s32 surfaceType;
 
    if ((npc->flags & NPC_FLAG_INVISIBLE) || !(npc->flags & NPC_FLAG_TOUCHES_GROUND) || npc->moveSpeed == 0.0f) {
        return;
    }
 
    surfaceType = get_collider_flags((u16)npc->curFloor) & COLLIDER_FLAGS_SURFACE_TYPE_MASK;
    switch (surfaceType) {
        case SURFACE_TYPE_FLOWERS:
            npc_surface_spawn_flower_fx(npc, mode);
            break;
        case SURFACE_TYPE_CLOUD:
            npc_surface_spawn_cloud_fx(npc, mode);
            break;
        case SURFACE_TYPE_SNOW:
            npc_surface_spawn_snow_fx(npc, mode);
            break;
        case SURFACE_TYPE_HEDGES:
            npc_surface_spawn_hedges_fx(npc, mode);
            break;
        case SURFACE_TYPE_WATER:
            npc_surface_spawn_water_fx(npc, mode);
            break;
        default:
            npc_surface_spawn_basic_fx(npc, mode);
            break;
    }
}

Referenced by _npc_jump_to(), AvoidPlayerAI_Chase(), basic_ai_chase(), CleftAI_Tackle(), GuardAI_Chase(), partner_get_out(), partner_move_to_goal(), partner_walking_follow_player(), PatrolAI_Chase(), PatrolAI_Move(), player_jump(), and update_riding_physics().

◆ spawn_default_surface_effects()

void spawn_default_surface_effects	(	Npc *	npc,
		SurfaceInteractMode	mode )

◆ spawn_flower_surface_effects()

void spawn_flower_surface_effects	(	Npc *	npc,
		SurfaceInteractMode	mode )

◆ spawn_cloud_surface_effects()

void spawn_cloud_surface_effects	(	Npc *	npc,
		SurfaceInteractMode	mode )

◆ spawn_snow_surface_effects()

void spawn_snow_surface_effects	(	Npc *	npc,
		SurfaceInteractMode	mode )

◆ spawn_hedge_surface_effects()

void spawn_hedge_surface_effects	(	Npc *	npc,
		SurfaceInteractMode	mode )

◆ spawn_water_surface_effects()

void spawn_water_surface_effects	(	Npc *	npc,
		SurfaceInteractMode	mode )

◆ COPY_set_defeated()

void COPY_set_defeated	(	s32	mapID,
		s32	encounterID )

Duplicate of set_defeated().

Definition at line 2169 of file npc.c.

                                                   {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    s32 encounterIdx = encounterID / 32;
    s32 encounterShift;
    s32 flag;
 
    flag = encounterID % 32;
    encounterShift = flag;
    flag = currentEncounter->defeatFlags[mapID][encounterIdx];
    currentEncounter->defeatFlags[mapID][encounterIdx] = flag | (1 << encounterShift);
 
    // TODO: The below should work but has regalloc issues:
    /*EncounterStatus *currentEncounter = &gCurrentEncounter;
    s32 encounterIdx = encounterID / 32;
    s32 encounterShift = encounterID % 32;
 
    currentEncounter->defeatFlags[mapID][encounterIdx] |= (1 << encounterShift);*/
}

Referenced by kill_enemy().

◆ init_encounter_status()

void init_encounter_status ( void )

Definition at line 2188 of file npc.c.

                                 {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    for (i = 0; i < ARRAY_COUNT(currentEncounter->encounterList); i++) {
        currentEncounter->encounterList[i] = 0;
    }
 
    currentEncounter->flags = ENCOUNTER_FLAG_NONE;
    currentEncounter->numEncounters = 0;
    currentEncounter->firstStrikeType = FIRST_STRIKE_NONE;
    currentEncounter->hitType = 0;
    currentEncounter->battleTriggerCooldown = 0;
    currentEncounter->npcGroupList = 0;
    currentEncounter->unk_08 = 0;
    currentEncounter->dropWhackaBump = false;
 
    for (i = 0; i < ARRAY_COUNT(currentEncounter->defeatFlags); i++) {
        for (j = 0; j < ARRAY_COUNT(currentEncounter->defeatFlags[i]); j++) {
            currentEncounter->defeatFlags[i][j] = 0;
        }
    }
 
    for (i = 0; i < ARRAY_COUNT(currentEncounter->recentMaps); i++) {
        currentEncounter->recentMaps[i] = -1;
    }
 
    func_80045AC0();
    gEncounterState = ENCOUNTER_STATE_NONE;
    create_worker_scene(nullptr, npc_render_worker_do_nothing);
}

Referenced by load_engine_data(), state_step_demo(), state_step_intro(), and state_step_startup().

◆ clear_encounter_status()

void clear_encounter_status ( void )

Definition at line 2221 of file npc.c.

                                  {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    for (i = 0; i < ARRAY_COUNT(currentEncounter->encounterList); i++) {
        currentEncounter->encounterList[i] = 0;
    }
 
    if (gGameStatusPtr->didAreaChange) {
        for (i = 0; i < ARRAY_COUNT(currentEncounter->defeatFlags); i++) {
            for (j = 0; j < ARRAY_COUNT(currentEncounter->defeatFlags[i]); j++) {
                currentEncounter->defeatFlags[i][j] = 0;
            }
        }
 
        if (gGameStatusPtr->didAreaChange) {
            for (i = 0; i < ARRAY_COUNT(currentEncounter->recentMaps); i++) {
                currentEncounter->recentMaps[i] = -1;
            }
        }
    }
 
    currentEncounter->numEncounters = 0;
    currentEncounter->firstStrikeType = FIRST_STRIKE_NONE;
    currentEncounter->hitType = 0;
    currentEncounter->battleTriggerCooldown = 0;
    currentEncounter->curAreaIndex = gGameStatusPtr->areaID;
    currentEncounter->curMapIndex = gGameStatusPtr->mapID;
    currentEncounter->curEntryIndex = gGameStatusPtr->entryID;
    currentEncounter->npcGroupList = 0;
    currentEncounter->unk_08 = 0;
    currentEncounter->scriptedBattle = false;
 
    func_80045AC0();
    gEncounterState = ENCOUNTER_STATE_NONE;
    create_worker_scene(nullptr, npc_render_worker_do_nothing);
}

Referenced by load_demo_battle(), and load_map_by_IDs().

◆ func_8003E50C()

void func_8003E50C ( void )

Definition at line 2260 of file npc.c.

2260 {

2261}

◆ func_8003E514()

void func_8003E514 ( s8 arg0 )

Definition at line 2263 of file npc.c.

                            {
    gCurrentEncounter.unk_08 = arg0;
}

Referenced by btl_state_update_end_battle().

◆ update_encounters()

void update_encounters ( void )

Definition at line 2267 of file npc.c.

                             {
    switch (gEncounterState) {
        case ENCOUNTER_STATE_NONE:
            break;
        case ENCOUNTER_STATE_CREATE:
            create_encounters();
            break;
        case ENCOUNTER_STATE_NEUTRAL:
            update_encounters_neutral();
            break;
        case ENCOUNTER_STATE_PRE_BATTLE:
            update_encounters_pre_battle();
            break;
        case ENCOUNTER_STATE_CONVERSATION:
            update_encounters_conversation();
            break;
        case ENCOUNTER_STATE_POST_BATTLE:
            update_encounters_post_battle();
            break;
    }
 
    update_merlee_messages();
}

Referenced by state_step_battle(), state_step_change_map(), state_step_enter_world(), state_step_game_over(), state_step_intro(), state_step_pause(), state_step_unpause(), and state_step_world().

◆ draw_encounter_ui()

void draw_encounter_ui ( void )

Definition at line 2291 of file npc.c.

                             {
    switch (gEncounterState) {
        case ENCOUNTER_STATE_NONE:
            break;
        case ENCOUNTER_STATE_CREATE:
            init_encounters_ui();
            break;
        case ENCOUNTER_STATE_NEUTRAL:
            draw_encounters_neutral();
            break;
        case ENCOUNTER_STATE_PRE_BATTLE:
            draw_encounters_pre_battle();
            break;
        case ENCOUNTER_STATE_CONVERSATION:
            draw_encounters_conversation();
            break;
        case ENCOUNTER_STATE_POST_BATTLE:
            draw_encounters_post_battle();
            break;
    }
 
    draw_merlee_messages();
}

Referenced by state_drawUI_battle(), and state_drawUI_world().

◆ draw_first_strike_ui()

void draw_first_strike_ui ( void )

Definition at line 2315 of file npc.c.

                                {
    switch (gEncounterState) {
        case ENCOUNTER_STATE_NONE:
            break;
        case ENCOUNTER_STATE_PRE_BATTLE:
            show_first_strike_message();
            break;
    }
}

Referenced by state_world_draw_aux_ui().

◆ npc_render_worker_do_nothing()

void npc_render_worker_do_nothing ( void )

Definition at line 2325 of file npc.c.

2325 {

2326}

Referenced by clear_encounter_status(), and init_encounter_status().

◆ make_npcs()

void make_npcs	(	s32	flags,
		s32	mapID,
		s32 *	npcGroupList )

Definition at line 2328 of file npc.c.

                                                        {
    EncounterStatus* currentEncounter = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    currentEncounter->resetMapEncounterFlags = flags;
    currentEncounter->mapID = mapID;
    currentEncounter->npcGroupList = npcGroupList;
 
    if (gGameStatusPtr->didAreaChange) {
        for (i = 0; i < ARRAY_COUNT(currentEncounter->defeatFlags); i++) {
            for (j = 0; j < ARRAY_COUNT(currentEncounter->defeatFlags[i]); j++) {
                currentEncounter->defeatFlags[i][j] = 0;
            }
        }
 
        if (gGameStatusPtr->didAreaChange) {
            for (i = 0; i < ARRAY_COUNT(currentEncounter->recentMaps); i++) {
                currentEncounter->recentMaps[i] = -1;
            }
        }
    }
 
    if (npcGroupList != nullptr) {
        gEncounterState = ENCOUNTER_STATE_CREATE;
        EncounterStateChanged = true;
        gEncounterSubState = ENCOUNTER_SUBSTATE_CREATE_INIT;
    }
}

◆ kill_encounter()

void kill_encounter ( Enemy * enemy )

Definition at line 2358 of file npc.c.

                                  {
    Encounter* encounter = gCurrentEncounter.encounterList[enemy->encounterIndex];
    s32 i;
 
    for (i = 0; i < encounter->count; i++) {
        Enemy* currentEnemy = encounter->enemy[i];
        if (currentEnemy != nullptr) {
            kill_enemy(currentEnemy);
            encounter->enemy[i] = nullptr;
        }
    }
}

◆ kill_enemy()

void kill_enemy ( Enemy * enemy )

Definition at line 2371 of file npc.c.

                              {
    EncounterStatus* encounterStatus = &gCurrentEncounter;
    Encounter* encounter = encounterStatus->encounterList[enemy->encounterIndex];
    s32 i;
    s32 j;
 
    for (i = 0; i < encounter->count; i++) {
        Enemy* currentEnemy = encounter->enemy[i];
        if (currentEnemy == enemy) {
            break;
        }
    }
 
    if (enemy->initScript != nullptr) {
        kill_script_by_ID(enemy->initScriptID);
    }
    if (enemy->interactScript != nullptr) {
        kill_script_by_ID(enemy->interactScriptID);
    }
    if (enemy->aiScript != nullptr) {
        kill_script_by_ID(enemy->aiScriptID);
    }
    if (enemy->hitScript != nullptr) {
        kill_script_by_ID(enemy->hitScriptID);
    }
    if (enemy->auxScript != nullptr) {
        kill_script_by_ID(enemy->auxScriptID);
    }
    if (enemy->defeatScript != nullptr) {
        kill_script_by_ID(enemy->defeatScriptID);
    }
 
    enemy->interactBytecode = nullptr;
    enemy->aiBytecode = nullptr;
    enemy->hitBytecode = nullptr;
    enemy->auxBytecode = nullptr;
    enemy->defeatBytecode = nullptr;
 
    #if DX_DEBUG_MENU
    if (enemy->npcID != (s16) DX_DEBUG_DUMMY_ID) {
        free_npc(get_npc_unsafe(enemy->npcID));
    }
    #else
    free_npc(get_npc_unsafe(enemy->npcID));
    #endif
 
    if (enemy->unk_64 != nullptr) {
        heap_free(enemy->unk_64);
    }
 
    for (j = 0; j < ARRAY_COUNT(encounter->enemy); j++) {
        if (encounter->enemy[j] == enemy) {
            encounter->enemy[j] = nullptr;
        }
    }
 
    if (!(enemy->flags & ENEMY_FLAG_DO_NOT_KILL)
        && (!(enemy->flags & ENEMY_FLAG_ENABLE_HIT_SCRIPT) || (enemy == encounterStatus->curEnemy))
        && !(enemy->flags & ENEMY_FLAG_PASSIVE)
        && !(enemy->flags & ENEMY_FLAG_FLED)
    ) {
        COPY_set_defeated(encounterStatus->mapID, encounter->encounterID + i);
    }
 
    heap_free(enemy);
}

Referenced by kill_encounter(), and update_encounters_post_battle().

◆ bind_enemy_ai()

s32 bind_enemy_ai	(	Enemy *	enemy,
		EvtScript *	aiScriptBytecode )

Binds the specified ai script to the specified enemy.

Parameters

enemy	pointer to the enemy to bind the script to
aiScriptBytecode	pointer to the script to be bound.

Definition at line 2438 of file npc.c.

                                                             {
    Evt* aiScript;
    s32 id;
 
    if (enemy->aiScript != nullptr) {
        kill_script_by_ID(enemy->aiScript->id);
    }
    enemy->aiBytecode = aiScriptBytecode;
    aiScript = enemy->aiScript = start_script(aiScriptBytecode, EVT_PRIORITY_A, 0);
    id = enemy->aiScriptID = aiScript->id;
    aiScript->owner1.enemy = enemy;
    return id;
}

Referenced by bind_npc_ai().

◆ bind_enemy_aux()

s32 bind_enemy_aux	(	Enemy *	enemy,
		EvtScript *	auxScriptBytecode )

Binds the specified auxillary script to the specified enemy.

Parameters

enemy	pointer to the enemy to bind the script to
auxScriptBytecode	pointer to the script to be bound.

Definition at line 2452 of file npc.c.

                                                               {
    Evt* auxScript;
    s32 id;
 
    if (enemy->auxScript != nullptr) {
        kill_script_by_ID(enemy->auxScript->id);
    }
    enemy->auxBytecode = auxScriptBytecode;
    auxScript = enemy->auxScript = start_script(auxScriptBytecode, EVT_PRIORITY_A, 0);
    id = enemy->auxScriptID = auxScript->id;
    auxScript->owner1.enemy = enemy;
    return id;
}

Referenced by bind_npc_aux().

◆ bind_enemy_interact()

s32 bind_enemy_interact	(	Enemy *	enemy,
		EvtScript *	interactScriptBytecode )

Binds the specified interact script to the specified enemy.

Parameters

enemy	pointer to the enemy to bind the script to
interactScriptBytecode	pointer to the script to be bound.

Definition at line 2466 of file npc.c.

                                                                         {
    Evt* interactScript;
    s32 id;
 
    if (enemy->interactScript != nullptr) {
        kill_script_by_ID(enemy->interactScript->id);
    }
    enemy->interactBytecode = interactScriptBytecode;
    interactScript = enemy->interactScript = start_script(interactScriptBytecode, EVT_PRIORITY_A, 0);
    id = enemy->interactScriptID = interactScript->id;
    interactScript->owner1.enemy = enemy;
    return id;
}

Referenced by bind_npc_interact().

◆ bind_npc_ai()

void bind_npc_ai	(	s32	npcID,
		EvtScript *	npcAiBytecode )

Binds the specified ai script to the npc matching the specified npcId.

Parameters

npcID	ID of the desired npc
npcAiBytecode	pointer to the script to be bound.

Definition at line 2480 of file npc.c.

                                                      {
    EncounterStatus* currentEncounterStatus = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    for (i = 0; i < currentEncounterStatus->numEncounters; i++) {
        Encounter* currentEncounter = currentEncounterStatus->encounterList[i];
        if (currentEncounter != nullptr) {
            for (j = 0; j < currentEncounter->count; j++) {
                Enemy* currentEnemy = currentEncounter->enemy[j];
                if ((currentEnemy != nullptr) && (currentEnemy->npcID == npcID)) {
                    bind_enemy_ai(currentEnemy, npcAiBytecode);
                    break;
                }
            }
        }
    }
}

◆ bind_npc_aux()

void bind_npc_aux	(	s32	npcID,
		EvtScript *	npcAuxBytecode )

Binds the specified auxillary script to the npc matching the specified npcId.

Parameters

npcID	ID of the desired npc
npcAuxBytecode	pointer to the script to be bound.

Definition at line 2499 of file npc.c.

                                                        {
    EncounterStatus* currentEncounterStatus = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    for (i = 0; i < currentEncounterStatus->numEncounters; i++) {
        Encounter* currentEncounter = currentEncounterStatus->encounterList[i];
        if (currentEncounter != nullptr) {
            for (j = 0; j < currentEncounter->count; j++) {
                Enemy* currentEnemy = currentEncounter->enemy[j];
                if ((currentEnemy != nullptr) && (currentEnemy->npcID == npcID)) {
                    bind_enemy_aux(currentEnemy, npcAuxBytecode);
                    break;
                }
            }
        }
    }
}

◆ bind_npc_interact()

void bind_npc_interact	(	s32	npcID,
		EvtScript *	npcInteractBytecode )

Binds the specified interact script to the npc matching the specified npcId.

Parameters

npcID	ID of the desired npc
npcInteractBytecode	pointer to the script to be bound.

Definition at line 2518 of file npc.c.

                                                                  {
    EncounterStatus* currentEncounterStatus = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    for (i = 0; i < currentEncounterStatus->numEncounters; i++) {
        Encounter* currentEncounter = currentEncounterStatus->encounterList[i];
        if (currentEncounter != nullptr) {
            for (j = 0; j < currentEncounter->count; j++) {
                Enemy* currentEnemy = currentEncounter->enemy[j];
                if ((currentEnemy != nullptr) && (currentEnemy->npcID == npcID)) {
                    bind_enemy_interact(currentEnemy, npcInteractBytecode);
                    break;
                }
            }
        }
    }
}

◆ get_enemy()

Enemy * get_enemy ( s32 npcID )

Looks for an enemy matching the specified npcID.

Parameters

npcID ID of the npc bound to the desired enemy.

Returns: pointer to Enemy struct, if one is found. If one is not found, a panic occurs.

Definition at line 2537 of file npc.c.

                            {
    EncounterStatus* currentEncounterStatus = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    for (i = 0; i < currentEncounterStatus->numEncounters; i++) {
        Encounter* currentEncounter = currentEncounterStatus->encounterList[i];
        if (currentEncounter != nullptr) {
            for (j = 0; j < currentEncounter->count; j++) {
                Enemy* currentEnemy = currentEncounter->enemy[j];
                if ((currentEnemy != nullptr) && (currentEnemy->npcID == npcID)) {
                    return currentEnemy;
                }
            }
        }
    }
    PANIC();
}

Referenced by ai_enemy_play_sound(), FlyingMagikoopaAI_23(), LakituAI_GetAvailableSpiny(), MagikoopaAI_23(), MagikoopaAI_CanShootSpell(), MeleeHitbox_CanSeePlayer(), ProjectileHitbox_30(), ProjectileHitbox_32(), ProjectileHitbox_GetUsableProjectileID(), SentinelAI_DescendInit(), set_npc_animation(), and UnkNpcAIFunc48().

◆ get_enemy_safe()

Enemy * get_enemy_safe ( s32 npcID )

Same as get_enemy(), with the exception of always returning a value if an enemy is not found.

Parameters

npcID ID of the npc bound to the desired enemy.

Returns: pointer to Enemy struct, if one is found. Otherwise, nullptr.

Definition at line 2556 of file npc.c.

                                 {
    EncounterStatus* currentEncounterStatus = &gCurrentEncounter;
    s32 i;
    s32 j;
 
    for (i = 0; i < currentEncounterStatus->numEncounters; i++) {
        Encounter* currentEncounter = currentEncounterStatus->encounterList[i];
 
        if (currentEncounter != nullptr) {
            for (j = 0; j < currentEncounter->count; j++) {
                Enemy* currentEnemy = currentEncounter->enemy[j];
                if ((currentEnemy != nullptr) && (currentEnemy->npcID == npcID)) {
                    return currentEnemy;
                }
            }
        }
    }
    return nullptr;
}

◆ set_npc_sprite()

void set_npc_sprite	(	Npc *	npc,
		s32	anim,
		AnimID *	extraAnimList )

Definition at line 1045 of file npc.c.

                                                               {
    ASSERT((npc->flags & NPC_FLAG_HAS_NO_SPRITE) || spr_free_sprite(npc->spriteInstanceID) == 0);
 
    npc->extraAnimList = extraAnimList;
 
    if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
        npc->spriteInstanceID = spr_load_npc_sprite(anim, extraAnimList);
        ASSERT(npc->spriteInstanceID >= 0);
    }
 
    npc->curAnim = anim;
 
    if (!(npc->flags & NPC_FLAG_NO_ANIMS_LOADED)) {
        if (!(npc->flags & NPC_FLAG_HAS_NO_SPRITE)) {
            spr_update_sprite(npc->spriteInstanceID, anim, npc->animationSpeed);
        }
    }
}

Variable Documentation

◆ gCurrentEncounter

EncounterStatus gCurrentEncounter

extern

Definition at line 175 of file encounter.c.

Referenced by bind_npc_ai(), bind_npc_aux(), bind_npc_interact(), btl_merlee_on_first_strike(), btl_merlee_on_start_turn(), btl_state_draw_end_battle(), btl_state_update_defeat(), btl_state_update_end_battle(), btl_state_update_end_training_battle(), btl_state_update_first_strike(), btl_state_update_normal_start(), btl_state_update_run_away(), btl_state_update_victory(), check_conversation_trigger(), clear_encounter_status(), COPY_set_defeated(), create_encounters(), draw_encounters_post_battle(), draw_encounters_pre_battle(), fio_serialize_state(), func_8003E514(), func_80048F0C(), get_coin_drop_amount(), get_defeated(), get_enemy(), get_enemy_safe(), init_encounter_status(), is_starting_conversation(), kill_encounter(), kill_enemy(), load_demo_battle(), make_npcs(), set_defeated(), show_first_strike_message(), spawn_drops(), start_battle(), test_item_player_collision(), update_encounters_conversation(), update_encounters_neutral(), update_encounters_post_battle(), update_encounters_pre_battle(), ver_deserialize_standard(), and ver_deserialize_vanilla_save().

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Data Structure Documentation

◆ QuizRequirement

◆ MobileAISettings

◆ GuardAISettings

◆ FireBarAISettings

◆ FireBarData

◆ NpcSettings

◆ ItemDrop

◆ StatDrop

◆ EnemyDrops

◆ EnemyDetectVolume

◆ EnemyTerritoryWander

◆ EnemyTerritoryPatrol

◆ EnemyTerritory

◆ NpcInitialVars

◆ NpcData

◆ NpcGroup

◆ Enemy

◆ Encounter

◆ FieldStatus

◆ EncounterStatus

◆ NpcData.animations

◆ Enemy.__unnamed54__

Macro Definition Documentation

◆ NPC_GROUP

◆ NPC_GROUP1

◆ NPC_GROUP2

◆ NPC_GROUP3

◆ NPC_GROUP_EXPLICIT_SIZE

◆ NPC_GROUP_EXPLICIT_SIZE3

◆ NPC_GROUP_EXPLICIT_SIZE4

◆ NPC_GROUP_EXPLICIT_SIZE5

◆ NO_DROPS

◆ STANDARD_HEART_DROPS

◆ GENEROUS_HEART_DROPS

◆ GENEROUS_WHEN_LOW_HEART_DROPS

◆ STANDARD_FLOWER_DROPS

◆ GENEROUS_WHEN_LOW_FLOWER_DROPS

◆ REDUCED_FLOWER_DROPS

◆ OVERRIDE_MOVEMENT_SPEED

◆ NO_OVERRIDE_MOVEMENT_SPEED

Typedef Documentation

◆ FireBarCallback

◆ NpcGroupList

◆ AIStateHandler

Enumeration Type Documentation

◆ TerritoryShape

Function Documentation

◆ basic_ai_check_player_dist()

◆ STUB_npc_callback()

◆ mtx_ident_mirror_y()

◆ clear_npcs()

◆ init_npc_list()

◆ create_npc_impl()

◆ create_basic_npc()

◆ create_standard_npc()

◆ create_peach_npc()

◆ free_npc_by_index()

◆ free_npc()

◆ get_npc_by_index()

◆ npc_do_world_collision()

◆ npc_do_other_npc_collision()

◆ npc_do_player_collision()

◆ npc_try_apply_gravity()

◆ npc_try_snap_to_ground()

◆ update_npcs()

◆ npc_get_render_yaw()

◆ appendGfx_npc()

◆ render_npcs()

◆ npc_move_heading()

◆ get_npc_unsafe()

◆ get_npc_safe()

◆ enable_npc_shadow()

◆ disable_npc_shadow()

◆ Enemy.unnamed54